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

/* Intel PRO/1000 Linux driver
 * Copyright(c) 1999 - 2014 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.
 *
 * 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;
	unsigned long flags;
	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;

	spin_lock_irqsave(&adapter->systim_lock, flags);

	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);

	spin_unlock_irqrestore(&adapter->systim_lock, flags);

	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;

	spin_lock_irqsave(&adapter->systim_lock, flags);
	timecounter_adjtime(&adapter->tc, delta);
	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,
	.n_pins		= 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:
	case e1000_pch_spt:
		if (((hw->mac.type != e1000_pch_lpt) &&
		     (hw->mac.type != e1000_pch_spt)) ||
		    (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
e78b80b1 DE	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	*/
d89777bf BA	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;
6c2ed39c	43	unsigned long flags;
d89777bf BA	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
6c2ed39c TF	61	spin_lock_irqsave(&adapter->systim_lock, flags);
6c2ed39c TF	62
d89777bf BA	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
6c2ed39c TF	76	spin_unlock_irqrestore(&adapter->systim_lock, flags);
6c2ed39c TF	77
d89777bf BA	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;
d89777bf BA	93
d89777bf BA	94	spin_lock_irqsave(&adapter->systim_lock, flags);
f4de2b95	95	timecounter_adjtime(&adapter->tc, delta);
d89777bf BA	96	spin_unlock_irqrestore(&adapter->systim_lock, flags);
	97
	98	return 0;
	99	}
	100
	101	/**
	102	* e1000e_phc_gettime - Reads the current time from the hardware clock
	103	* @ptp: ptp clock structure
	104	* @ts: timespec structure to hold the current time value
	105	*
	106	* Read the timecounter and return the correct value in ns after converting
	107	* it into a struct timespec.
	108	**/
	109	static int e1000e_phc_gettime(struct ptp_clock_info ptp, struct timespec ts)
	110	{
	111	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,
	112	ptp_clock_info);
	113	unsigned long flags;
	114	u32 remainder;
	115	u64 ns;
	116
	117	spin_lock_irqsave(&adapter->systim_lock, flags);
	118	ns = timecounter_read(&adapter->tc);
	119	spin_unlock_irqrestore(&adapter->systim_lock, flags);
	120
	121	ts->tv_sec = div_u64_rem(ns, NSEC_PER_SEC, &remainder);
	122	ts->tv_nsec = remainder;
	123
	124	return 0;
	125	}
	126
	127	/**
	128	* e1000e_phc_settime - Set the current time on the hardware clock
	129	* @ptp: ptp clock structure
	130	* @ts: timespec containing the new time for the cycle counter
	131	*
	132	* Reset the timecounter to use a new base value instead of the kernel
	133	* wall timer value.
	134	**/
	135	static int e1000e_phc_settime(struct ptp_clock_info *ptp,
	136	const struct timespec *ts)
	137	{
	138	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,
	139	ptp_clock_info);
	140	unsigned long flags;
	141	u64 ns;
	142
73e3dd6b	143	ns = timespec_to_ns(ts);
d89777bf BA	144
	145	/* reset the timecounter */
	146	spin_lock_irqsave(&adapter->systim_lock, flags);
	147	timecounter_init(&adapter->tc, &adapter->cc, ns);
	148	spin_unlock_irqrestore(&adapter->systim_lock, flags);
	149
	150	return 0;
	151	}
	152
	153	/**
	154	* e1000e_phc_enable - enable or disable an ancillary feature
	155	* @ptp: ptp clock structure
	156	* @request: Desired resource to enable or disable
	157	* @on: Caller passes one to enable or zero to disable
	158	*
	159	* Enable (or disable) ancillary features of the PHC subsystem.
	160	* Currently, no ancillary features are supported.
	161	**/
8bb62869 BA	162	static int e1000e_phc_enable(struct ptp_clock_info __always_unused *ptp,
	163	struct ptp_clock_request __always_unused *request,
	164	int __always_unused on)
d89777bf BA	165	{
	166	return -EOPNOTSUPP;
	167	}
	168
	169	static void e1000e_systim_overflow_work(struct work_struct *work)
	170	{
	171	struct e1000_adapter *adapter = container_of(work, struct e1000_adapter,
	172	systim_overflow_work.work);
	173	struct e1000_hw *hw = &adapter->hw;
	174	struct timespec ts;
	175
	176	adapter->ptp_clock_info.gettime(&adapter->ptp_clock_info, &ts);
	177
	178	e_dbg("SYSTIM overflow check at %ld.%09lu\n", ts.tv_sec, ts.tv_nsec);
	179
	180	schedule_delayed_work(&adapter->systim_overflow_work,
	181	E1000_SYSTIM_OVERFLOW_PERIOD);
	182	}
	183
	184	static const struct ptp_clock_info e1000e_ptp_clock_info = {
	185	.owner = THIS_MODULE,
	186	.n_alarm = 0,
	187	.n_ext_ts = 0,
	188	.n_per_out = 0,
4986b4f0	189	.n_pins = 0,
d89777bf BA	190	.pps = 0,
	191	.adjfreq = e1000e_phc_adjfreq,
	192	.adjtime = e1000e_phc_adjtime,
	193	.gettime = e1000e_phc_gettime,
	194	.settime = e1000e_phc_settime,
	195	.enable = e1000e_phc_enable,
	196	};
	197
	198	/**
	199	* e1000e_ptp_init - initialize PTP for devices which support it
	200	* @adapter: board private structure
	201	*
	202	* This function performs the required steps for enabling PTP support.
	203	* If PTP support has already been loaded it simply calls the cyclecounter
	204	* init routine and exits.
	205	**/
	206	void e1000e_ptp_init(struct e1000_adapter *adapter)
	207	{
	208	struct e1000_hw *hw = &adapter->hw;
	209
	210	adapter->ptp_clock = NULL;
	211
	212	if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
	213	return;
	214
	215	adapter->ptp_clock_info = e1000e_ptp_clock_info;
	216
	217	snprintf(adapter->ptp_clock_info.name,
	218	sizeof(adapter->ptp_clock_info.name), "%pm",
	219	adapter->netdev->perm_addr);
	220
	221	switch (hw->mac.type) {
	222	case e1000_pch2lan:
	223	case e1000_pch_lpt:
79849ebc DE	224	case e1000_pch_spt:
	225	if (((hw->mac.type != e1000_pch_lpt) &&
	226	(hw->mac.type != e1000_pch_spt)) \|\|
d89777bf BA	227	(er32(TSYNCRXCTL) & E1000_TSYNCRXCTL_SYSCFI)) {
	228	adapter->ptp_clock_info.max_adj = 24000000 - 1;
	229	break;
	230	}
	231	/* fall-through */
	232	case e1000_82574:
	233	case e1000_82583:
	234	adapter->ptp_clock_info.max_adj = 600000000 - 1;
	235	break;
	236	default:
	237	break;
	238	}
	239
	240	INIT_DELAYED_WORK(&adapter->systim_overflow_work,
	241	e1000e_systim_overflow_work);
	242
	243	schedule_delayed_work(&adapter->systim_overflow_work,
	244	E1000_SYSTIM_OVERFLOW_PERIOD);
	245
	246	adapter->ptp_clock = ptp_clock_register(&adapter->ptp_clock_info,
	247	&adapter->pdev->dev);
	248	if (IS_ERR(adapter->ptp_clock)) {
	249	adapter->ptp_clock = NULL;
	250	e_err("ptp_clock_register failed\n");
	251	} else {
	252	e_info("registered PHC clock\n");
	253	}
	254	}
	255
	256	/**
	257	* e1000e_ptp_remove - disable PTP device and stop the overflow check
	258	* @adapter: board private structure
	259	*
	260	* Stop the PTP support, and cancel the delayed work.
	261	**/
	262	void e1000e_ptp_remove(struct e1000_adapter *adapter)
	263	{
	264	if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))
	265	return;
	266
	267	cancel_delayed_work_sync(&adapter->systim_overflow_work);
	268
	269	if (adapter->ptp_clock) {
	270	ptp_clock_unregister(adapter->ptp_clock);
	271	adapter->ptp_clock = NULL;
	272	e_info("removed PHC\n");
	273	}
	274	}