[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 timespec64 *ts)
{
	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,
						     ptp_clock_info);
	unsigned long flags;
	u64 ns;

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

	*ts = ns_to_timespec64(ns);

	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 timespec64 *ts)
{
	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,
						     ptp_clock_info);
	unsigned long flags;
	u64 ns;

	ns = timespec64_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 timespec64 ts;

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

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