devices/e1000e/ptp-3.16-orig.c
branchstable-1.5
changeset 2588 792892ab4806
equal deleted inserted replaced
2587:afd76ee3aa87 2588:792892ab4806
       
     1 /* Intel PRO/1000 Linux driver
       
     2  * Copyright(c) 1999 - 2014 Intel Corporation.
       
     3  *
       
     4  * This program is free software; you can redistribute it and/or modify it
       
     5  * under the terms and conditions of the GNU General Public License,
       
     6  * version 2, as published by the Free Software Foundation.
       
     7  *
       
     8  * This program is distributed in the hope it will be useful, but WITHOUT
       
     9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
       
    10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
       
    11  * more details.
       
    12  *
       
    13  * The full GNU General Public License is included in this distribution in
       
    14  * the file called "COPYING".
       
    15  *
       
    16  * Contact Information:
       
    17  * Linux NICS <linux.nics@intel.com>
       
    18  * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
       
    19  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
       
    20  */
       
    21 
       
    22 /* PTP 1588 Hardware Clock (PHC)
       
    23  * Derived from PTP Hardware Clock driver for Intel 82576 and 82580 (igb)
       
    24  * Copyright (C) 2011 Richard Cochran <richardcochran@gmail.com>
       
    25  */
       
    26 
       
    27 #include "e1000.h"
       
    28 
       
    29 /**
       
    30  * e1000e_phc_adjfreq - adjust the frequency of the hardware clock
       
    31  * @ptp: ptp clock structure
       
    32  * @delta: Desired frequency change in parts per billion
       
    33  *
       
    34  * Adjust the frequency of the PHC cycle counter by the indicated delta from
       
    35  * the base frequency.
       
    36  **/
       
    37 static int e1000e_phc_adjfreq(struct ptp_clock_info *ptp, s32 delta)
       
    38 {
       
    39 	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,
       
    40 						     ptp_clock_info);
       
    41 	struct e1000_hw *hw = &adapter->hw;
       
    42 	bool neg_adj = false;
       
    43 	unsigned long flags;
       
    44 	u64 adjustment;
       
    45 	u32 timinca, incvalue;
       
    46 	s32 ret_val;
       
    47 
       
    48 	if ((delta > ptp->max_adj) || (delta <= -1000000000))
       
    49 		return -EINVAL;
       
    50 
       
    51 	if (delta < 0) {
       
    52 		neg_adj = true;
       
    53 		delta = -delta;
       
    54 	}
       
    55 
       
    56 	/* Get the System Time Register SYSTIM base frequency */
       
    57 	ret_val = e1000e_get_base_timinca(adapter, &timinca);
       
    58 	if (ret_val)
       
    59 		return ret_val;
       
    60 
       
    61 	spin_lock_irqsave(&adapter->systim_lock, flags);
       
    62 
       
    63 	incvalue = timinca & E1000_TIMINCA_INCVALUE_MASK;
       
    64 
       
    65 	adjustment = incvalue;
       
    66 	adjustment *= delta;
       
    67 	adjustment = div_u64(adjustment, 1000000000);
       
    68 
       
    69 	incvalue = neg_adj ? (incvalue - adjustment) : (incvalue + adjustment);
       
    70 
       
    71 	timinca &= ~E1000_TIMINCA_INCVALUE_MASK;
       
    72 	timinca |= incvalue;
       
    73 
       
    74 	ew32(TIMINCA, timinca);
       
    75 
       
    76 	spin_unlock_irqrestore(&adapter->systim_lock, flags);
       
    77 
       
    78 	return 0;
       
    79 }
       
    80 
       
    81 /**
       
    82  * e1000e_phc_adjtime - Shift the time of the hardware clock
       
    83  * @ptp: ptp clock structure
       
    84  * @delta: Desired change in nanoseconds
       
    85  *
       
    86  * Adjust the timer by resetting the timecounter structure.
       
    87  **/
       
    88 static int e1000e_phc_adjtime(struct ptp_clock_info *ptp, s64 delta)
       
    89 {
       
    90 	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,
       
    91 						     ptp_clock_info);
       
    92 	unsigned long flags;
       
    93 	s64 now;
       
    94 
       
    95 	spin_lock_irqsave(&adapter->systim_lock, flags);
       
    96 	now = timecounter_read(&adapter->tc);
       
    97 	now += delta;
       
    98 	timecounter_init(&adapter->tc, &adapter->cc, now);
       
    99 	spin_unlock_irqrestore(&adapter->systim_lock, flags);
       
   100 
       
   101 	return 0;
       
   102 }
       
   103 
       
   104 /**
       
   105  * e1000e_phc_gettime - Reads the current time from the hardware clock
       
   106  * @ptp: ptp clock structure
       
   107  * @ts: timespec structure to hold the current time value
       
   108  *
       
   109  * Read the timecounter and return the correct value in ns after converting
       
   110  * it into a struct timespec.
       
   111  **/
       
   112 static int e1000e_phc_gettime(struct ptp_clock_info *ptp, struct timespec *ts)
       
   113 {
       
   114 	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,
       
   115 						     ptp_clock_info);
       
   116 	unsigned long flags;
       
   117 	u32 remainder;
       
   118 	u64 ns;
       
   119 
       
   120 	spin_lock_irqsave(&adapter->systim_lock, flags);
       
   121 	ns = timecounter_read(&adapter->tc);
       
   122 	spin_unlock_irqrestore(&adapter->systim_lock, flags);
       
   123 
       
   124 	ts->tv_sec = div_u64_rem(ns, NSEC_PER_SEC, &remainder);
       
   125 	ts->tv_nsec = remainder;
       
   126 
       
   127 	return 0;
       
   128 }
       
   129 
       
   130 /**
       
   131  * e1000e_phc_settime - Set the current time on the hardware clock
       
   132  * @ptp: ptp clock structure
       
   133  * @ts: timespec containing the new time for the cycle counter
       
   134  *
       
   135  * Reset the timecounter to use a new base value instead of the kernel
       
   136  * wall timer value.
       
   137  **/
       
   138 static int e1000e_phc_settime(struct ptp_clock_info *ptp,
       
   139 			      const struct timespec *ts)
       
   140 {
       
   141 	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,
       
   142 						     ptp_clock_info);
       
   143 	unsigned long flags;
       
   144 	u64 ns;
       
   145 
       
   146 	ns = timespec_to_ns(ts);
       
   147 
       
   148 	/* reset the timecounter */
       
   149 	spin_lock_irqsave(&adapter->systim_lock, flags);
       
   150 	timecounter_init(&adapter->tc, &adapter->cc, ns);
       
   151 	spin_unlock_irqrestore(&adapter->systim_lock, flags);
       
   152 
       
   153 	return 0;
       
   154 }
       
   155 
       
   156 /**
       
   157  * e1000e_phc_enable - enable or disable an ancillary feature
       
   158  * @ptp: ptp clock structure
       
   159  * @request: Desired resource to enable or disable
       
   160  * @on: Caller passes one to enable or zero to disable
       
   161  *
       
   162  * Enable (or disable) ancillary features of the PHC subsystem.
       
   163  * Currently, no ancillary features are supported.
       
   164  **/
       
   165 static int e1000e_phc_enable(struct ptp_clock_info __always_unused *ptp,
       
   166 			     struct ptp_clock_request __always_unused *request,
       
   167 			     int __always_unused on)
       
   168 {
       
   169 	return -EOPNOTSUPP;
       
   170 }
       
   171 
       
   172 static void e1000e_systim_overflow_work(struct work_struct *work)
       
   173 {
       
   174 	struct e1000_adapter *adapter = container_of(work, struct e1000_adapter,
       
   175 						     systim_overflow_work.work);
       
   176 	struct e1000_hw *hw = &adapter->hw;
       
   177 	struct timespec ts;
       
   178 
       
   179 	adapter->ptp_clock_info.gettime(&adapter->ptp_clock_info, &ts);
       
   180 
       
   181 	e_dbg("SYSTIM overflow check at %ld.%09lu\n", ts.tv_sec, ts.tv_nsec);
       
   182 
       
   183 	schedule_delayed_work(&adapter->systim_overflow_work,
       
   184 			      E1000_SYSTIM_OVERFLOW_PERIOD);
       
   185 }
       
   186 
       
   187 static const struct ptp_clock_info e1000e_ptp_clock_info = {
       
   188 	.owner		= THIS_MODULE,
       
   189 	.n_alarm	= 0,
       
   190 	.n_ext_ts	= 0,
       
   191 	.n_per_out	= 0,
       
   192 	.n_pins		= 0,
       
   193 	.pps		= 0,
       
   194 	.adjfreq	= e1000e_phc_adjfreq,
       
   195 	.adjtime	= e1000e_phc_adjtime,
       
   196 	.gettime	= e1000e_phc_gettime,
       
   197 	.settime	= e1000e_phc_settime,
       
   198 	.enable		= e1000e_phc_enable,
       
   199 };
       
   200 
       
   201 /**
       
   202  * e1000e_ptp_init - initialize PTP for devices which support it
       
   203  * @adapter: board private structure
       
   204  *
       
   205  * This function performs the required steps for enabling PTP support.
       
   206  * If PTP support has already been loaded it simply calls the cyclecounter
       
   207  * init routine and exits.
       
   208  **/
       
   209 void e1000e_ptp_init(struct e1000_adapter *adapter)
       
   210 {
       
   211 	struct e1000_hw *hw = &adapter->hw;
       
   212 
       
   213 	adapter->ptp_clock = NULL;
       
   214 
       
   215 	if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
       
   216 		return;
       
   217 
       
   218 	adapter->ptp_clock_info = e1000e_ptp_clock_info;
       
   219 
       
   220 	snprintf(adapter->ptp_clock_info.name,
       
   221 		 sizeof(adapter->ptp_clock_info.name), "%pm",
       
   222 		 adapter->netdev->perm_addr);
       
   223 
       
   224 	switch (hw->mac.type) {
       
   225 	case e1000_pch2lan:
       
   226 	case e1000_pch_lpt:
       
   227 		if ((hw->mac.type != e1000_pch_lpt) ||
       
   228 		    (er32(TSYNCRXCTL) & E1000_TSYNCRXCTL_SYSCFI)) {
       
   229 			adapter->ptp_clock_info.max_adj = 24000000 - 1;
       
   230 			break;
       
   231 		}
       
   232 		/* fall-through */
       
   233 	case e1000_82574:
       
   234 	case e1000_82583:
       
   235 		adapter->ptp_clock_info.max_adj = 600000000 - 1;
       
   236 		break;
       
   237 	default:
       
   238 		break;
       
   239 	}
       
   240 
       
   241 	INIT_DELAYED_WORK(&adapter->systim_overflow_work,
       
   242 			  e1000e_systim_overflow_work);
       
   243 
       
   244 	schedule_delayed_work(&adapter->systim_overflow_work,
       
   245 			      E1000_SYSTIM_OVERFLOW_PERIOD);
       
   246 
       
   247 	adapter->ptp_clock = ptp_clock_register(&adapter->ptp_clock_info,
       
   248 						&adapter->pdev->dev);
       
   249 	if (IS_ERR(adapter->ptp_clock)) {
       
   250 		adapter->ptp_clock = NULL;
       
   251 		e_err("ptp_clock_register failed\n");
       
   252 	} else {
       
   253 		e_info("registered PHC clock\n");
       
   254 	}
       
   255 }
       
   256 
       
   257 /**
       
   258  * e1000e_ptp_remove - disable PTP device and stop the overflow check
       
   259  * @adapter: board private structure
       
   260  *
       
   261  * Stop the PTP support, and cancel the delayed work.
       
   262  **/
       
   263 void e1000e_ptp_remove(struct e1000_adapter *adapter)
       
   264 {
       
   265 	if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
       
   266 		return;
       
   267 
       
   268 	cancel_delayed_work_sync(&adapter->systim_overflow_work);
       
   269 
       
   270 	if (adapter->ptp_clock) {
       
   271 		ptp_clock_unregister(adapter->ptp_clock);
       
   272 		adapter->ptp_clock = NULL;
       
   273 		e_info("removed PHC\n");
       
   274 	}
       
   275 }