[deliverable/linux.git] / drivers / net / ethernet / intel / e1000e / ptp.c

/*******************************************************************************

  Intel PRO/1000 Linux driver
  Copyright(c) 1999 - 2013 Intel Corporation.

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

  Contact Information:
  Linux NICS <linux.nics@intel.com>
  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

*******************************************************************************/

/* PTP 1588 Hardware Clock (PHC)
 * Derived from PTP Hardware Clock driver for Intel 82576 and 82580 (igb)
 * Copyright (C) 2011 Richard Cochran <richardcochran@gmail.com>
 */

#include "e1000.h"

/**
 * e1000e_phc_adjfreq - adjust the frequency of the hardware clock
 * @ptp: ptp clock structure
 * @delta: Desired frequency change in parts per billion
 *
 * Adjust the frequency of the PHC cycle counter by the indicated delta from
 * the base frequency.
 **/
static int e1000e_phc_adjfreq(struct ptp_clock_info *ptp, s32 delta)
{
	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,
						     ptp_clock_info);
	struct e1000_hw *hw = &adapter->hw;
	bool neg_adj = false;
	u64 adjustment;
	u32 timinca, incvalue;
	s32 ret_val;

	if ((delta > ptp->max_adj) || (delta <= -1000000000))
		return -EINVAL;

	if (delta < 0) {
		neg_adj = true;
		delta = -delta;
	}

	/* Get the System Time Register SYSTIM base frequency */
	ret_val = e1000e_get_base_timinca(adapter, &timinca);
	if (ret_val)
		return ret_val;

	incvalue = timinca & E1000_TIMINCA_INCVALUE_MASK;

	adjustment = incvalue;
	adjustment *= delta;
	adjustment = div_u64(adjustment, 1000000000);

	incvalue = neg_adj ? (incvalue - adjustment) : (incvalue + adjustment);

	timinca &= ~E1000_TIMINCA_INCVALUE_MASK;
	timinca |= incvalue;

	ew32(TIMINCA, timinca);

	return 0;
}

/**
 * e1000e_phc_adjtime - Shift the time of the hardware clock
 * @ptp: ptp clock structure
 * @delta: Desired change in nanoseconds
 *
 * Adjust the timer by resetting the timecounter structure.
 **/
static int e1000e_phc_adjtime(struct ptp_clock_info *ptp, s64 delta)
{
	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,
						     ptp_clock_info);
	unsigned long flags;
	s64 now;

	spin_lock_irqsave(&adapter->systim_lock, flags);
	now = timecounter_read(&adapter->tc);
	now += delta;
	timecounter_init(&adapter->tc, &adapter->cc, now);
	spin_unlock_irqrestore(&adapter->systim_lock, flags);

	return 0;
}

/**
 * e1000e_phc_gettime - Reads the current time from the hardware clock
 * @ptp: ptp clock structure
 * @ts: timespec structure to hold the current time value
 *
 * Read the timecounter and return the correct value in ns after converting
 * it into a struct timespec.
 **/
static int e1000e_phc_gettime(struct ptp_clock_info *ptp, struct timespec *ts)
{
	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,
						     ptp_clock_info);
	unsigned long flags;
	u32 remainder;
	u64 ns;

	spin_lock_irqsave(&adapter->systim_lock, flags);
	ns = timecounter_read(&adapter->tc);
	spin_unlock_irqrestore(&adapter->systim_lock, flags);

	ts->tv_sec = div_u64_rem(ns, NSEC_PER_SEC, &remainder);
	ts->tv_nsec = remainder;

	return 0;
}

/**
 * e1000e_phc_settime - Set the current time on the hardware clock
 * @ptp: ptp clock structure
 * @ts: timespec containing the new time for the cycle counter
 *
 * Reset the timecounter to use a new base value instead of the kernel
 * wall timer value.
 **/
static int e1000e_phc_settime(struct ptp_clock_info *ptp,
			      const struct timespec *ts)
{
	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,
						     ptp_clock_info);
	unsigned long flags;
	u64 ns;

	ns = timespec_to_ns(ts);

	/* reset the timecounter */
	spin_lock_irqsave(&adapter->systim_lock, flags);
	timecounter_init(&adapter->tc, &adapter->cc, ns);
	spin_unlock_irqrestore(&adapter->systim_lock, flags);

	return 0;
}

/**
 * e1000e_phc_enable - enable or disable an ancillary feature
 * @ptp: ptp clock structure
 * @request: Desired resource to enable or disable
 * @on: Caller passes one to enable or zero to disable
 *
 * Enable (or disable) ancillary features of the PHC subsystem.
 * Currently, no ancillary features are supported.
 **/
static int e1000e_phc_enable(struct ptp_clock_info __always_unused *ptp,
			     struct ptp_clock_request __always_unused *request,
			     int __always_unused on)
{
	return -EOPNOTSUPP;
}

static void e1000e_systim_overflow_work(struct work_struct *work)
{
	struct e1000_adapter *adapter = container_of(work, struct e1000_adapter,
						     systim_overflow_work.work);
	struct e1000_hw *hw = &adapter->hw;
	struct timespec ts;

	adapter->ptp_clock_info.gettime(&adapter->ptp_clock_info, &ts);

	e_dbg("SYSTIM overflow check at %ld.%09lu\n", ts.tv_sec, ts.tv_nsec);

	schedule_delayed_work(&adapter->systim_overflow_work,
			      E1000_SYSTIM_OVERFLOW_PERIOD);
}

static const struct ptp_clock_info e1000e_ptp_clock_info = {
	.owner		= THIS_MODULE,
	.n_alarm	= 0,
	.n_ext_ts	= 0,
	.n_per_out	= 0,
	.pps		= 0,
	.adjfreq	= e1000e_phc_adjfreq,
	.adjtime	= e1000e_phc_adjtime,
	.gettime	= e1000e_phc_gettime,
	.settime	= e1000e_phc_settime,
	.enable		= e1000e_phc_enable,
};

/**
 * e1000e_ptp_init - initialize PTP for devices which support it
 * @adapter: board private structure
 *
 * This function performs the required steps for enabling PTP support.
 * If PTP support has already been loaded it simply calls the cyclecounter
 * init routine and exits.
 **/
void e1000e_ptp_init(struct e1000_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;

	adapter->ptp_clock = NULL;

	if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
		return;

	adapter->ptp_clock_info = e1000e_ptp_clock_info;

	snprintf(adapter->ptp_clock_info.name,
		 sizeof(adapter->ptp_clock_info.name), "%pm",
		 adapter->netdev->perm_addr);

	switch (hw->mac.type) {
	case e1000_pch2lan:
	case e1000_pch_lpt:
		if ((hw->mac.type != e1000_pch_lpt) ||
		    (er32(TSYNCRXCTL) & E1000_TSYNCRXCTL_SYSCFI)) {
			adapter->ptp_clock_info.max_adj = 24000000 - 1;
			break;
		}
		/* fall-through */
	case e1000_82574:
	case e1000_82583:
		adapter->ptp_clock_info.max_adj = 600000000 - 1;
		break;
	default:
		break;
	}

	INIT_DELAYED_WORK(&adapter->systim_overflow_work,
			  e1000e_systim_overflow_work);

	schedule_delayed_work(&adapter->systim_overflow_work,
			      E1000_SYSTIM_OVERFLOW_PERIOD);

	adapter->ptp_clock = ptp_clock_register(&adapter->ptp_clock_info,
						&adapter->pdev->dev);
	if (IS_ERR(adapter->ptp_clock)) {
		adapter->ptp_clock = NULL;
		e_err("ptp_clock_register failed\n");
	} else {
		e_info("registered PHC clock\n");
	}
}

/**
 * e1000e_ptp_remove - disable PTP device and stop the overflow check
 * @adapter: board private structure
 *
 * Stop the PTP support, and cancel the delayed work.
 **/
void e1000e_ptp_remove(struct e1000_adapter *adapter)
{
	if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
		return;

	cancel_delayed_work_sync(&adapter->systim_overflow_work);

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