igb_ptp.c 37.7 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0+
2
3
/* Copyright (C) 2011 Richard Cochran <richardcochran@gmail.com> */

4
5
6
#include <linux/module.h>
#include <linux/device.h>
#include <linux/pci.h>
7
#include <linux/ptp_classify.h>
8
9
10
11
12
13

#include "igb.h"

#define INCVALUE_MASK		0x7fffffff
#define ISGN			0x80000000

14
/* The 82580 timesync updates the system timer every 8ns by 8ns,
15
16
 * and this update value cannot be reprogrammed.
 *
17
18
 * Neither the 82576 nor the 82580 offer registers wide enough to hold
 * nanoseconds time values for very long. For the 82580, SYSTIM always
19
 * counts nanoseconds, but the upper 24 bits are not available. The
20
21
22
23
24
25
26
27
 * frequency is adjusted by changing the 32 bit fractional nanoseconds
 * register, TIMINCA.
 *
 * For the 82576, the SYSTIM register time unit is affect by the
 * choice of the 24 bit TININCA:IV (incvalue) field. Five bits of this
 * field are needed to provide the nominal 16 nanosecond period,
 * leaving 19 bits for fractional nanoseconds.
 *
28
29
30
31
32
33
34
35
 * We scale the NIC clock cycle by a large factor so that relatively
 * small clock corrections can be added or subtracted at each clock
 * tick. The drawbacks of a large factor are a) that the clock
 * register overflows more quickly (not such a big deal) and b) that
 * the increment per tick has to fit into 24 bits.  As a result we
 * need to use a shift of 19 so we can fit a value of 16 into the
 * TIMINCA register.
 *
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 *
 *             SYSTIMH            SYSTIML
 *        +--------------+   +---+---+------+
 *  82576 |      32      |   | 8 | 5 |  19  |
 *        +--------------+   +---+---+------+
 *         \________ 45 bits _______/  fract
 *
 *        +----------+---+   +--------------+
 *  82580 |    24    | 8 |   |      32      |
 *        +----------+---+   +--------------+
 *          reserved  \______ 40 bits _____/
 *
 *
 * The 45 bit 82576 SYSTIM overflows every
 *   2^45 * 10^-9 / 3600 = 9.77 hours.
 *
 * The 40 bit 82580 SYSTIM overflows every
 *   2^40 * 10^-9 /  60  = 18.3 minutes.
54
55
 *
 * SYSTIM is converted to real time using a timecounter. As
56
57
58
59
60
61
 * timecounter_cyc2time() allows old timestamps, the timecounter needs
 * to be updated at least once per half of the SYSTIM interval.
 * Scheduling of delayed work is not very accurate, and also the NIC
 * clock can be adjusted to run up to 6% faster and the system clock
 * up to 10% slower, so we aim for 6 minutes to be sure the actual
 * interval in the NIC time is shorter than 9.16 minutes.
62
63
 */

64
#define IGB_SYSTIM_OVERFLOW_PERIOD	(HZ * 60 * 6)
65
#define IGB_PTP_TX_TIMEOUT		(HZ * 15)
66
67
68
#define INCPERIOD_82576			BIT(E1000_TIMINCA_16NS_SHIFT)
#define INCVALUE_82576_MASK		GENMASK(E1000_TIMINCA_16NS_SHIFT - 1, 0)
#define INCVALUE_82576			(16u << IGB_82576_TSYNC_SHIFT)
69
#define IGB_NBITS_82580			40
70

71
72
static void igb_ptp_tx_hwtstamp(struct igb_adapter *adapter);

73
/* SYSTIM read access for the 82576 */
74
static u64 igb_ptp_read_82576(const struct cyclecounter *cc)
75
76
77
{
	struct igb_adapter *igb = container_of(cc, struct igb_adapter, cc);
	struct e1000_hw *hw = &igb->hw;
78
79
	u64 val;
	u32 lo, hi;
80
81
82
83
84
85
86
87
88
89

	lo = rd32(E1000_SYSTIML);
	hi = rd32(E1000_SYSTIMH);

	val = ((u64) hi) << 32;
	val |= lo;

	return val;
}

90
/* SYSTIM read access for the 82580 */
91
static u64 igb_ptp_read_82580(const struct cyclecounter *cc)
92
93
94
{
	struct igb_adapter *igb = container_of(cc, struct igb_adapter, cc);
	struct e1000_hw *hw = &igb->hw;
95
	u32 lo, hi;
96
	u64 val;
97

98
	/* The timestamp latches on lowest register read. For the 82580
99
100
101
	 * the lowest register is SYSTIMR instead of SYSTIML.  However we only
	 * need to provide nanosecond resolution, so we just ignore it.
	 */
102
	rd32(E1000_SYSTIMR);
103
104
105
106
107
108
109
110
111
	lo = rd32(E1000_SYSTIML);
	hi = rd32(E1000_SYSTIMH);

	val = ((u64) hi) << 32;
	val |= lo;

	return val;
}

112
/* SYSTIM read access for I210/I211 */
113
114
static void igb_ptp_read_i210(struct igb_adapter *adapter,
			      struct timespec64 *ts)
115
116
{
	struct e1000_hw *hw = &adapter->hw;
117
	u32 sec, nsec;
118

119
	/* The timestamp latches on lowest register read. For I210/I211, the
120
121
122
	 * lowest register is SYSTIMR. Since we only need to provide nanosecond
	 * resolution, we can ignore it.
	 */
123
	rd32(E1000_SYSTIMR);
124
125
126
127
128
129
130
131
	nsec = rd32(E1000_SYSTIML);
	sec = rd32(E1000_SYSTIMH);

	ts->tv_sec = sec;
	ts->tv_nsec = nsec;
}

static void igb_ptp_write_i210(struct igb_adapter *adapter,
132
			       const struct timespec64 *ts)
133
134
135
{
	struct e1000_hw *hw = &adapter->hw;

136
	/* Writing the SYSTIMR register is not necessary as it only provides
137
138
139
	 * sub-nanosecond resolution.
	 */
	wr32(E1000_SYSTIML, ts->tv_nsec);
Arnd Bergmann's avatar
Arnd Bergmann committed
140
	wr32(E1000_SYSTIMH, (u32)ts->tv_sec);
141
142
}

143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
/**
 * igb_ptp_systim_to_hwtstamp - convert system time value to hw timestamp
 * @adapter: board private structure
 * @hwtstamps: timestamp structure to update
 * @systim: unsigned 64bit system time value.
 *
 * We need to convert the system time value stored in the RX/TXSTMP registers
 * into a hwtstamp which can be used by the upper level timestamping functions.
 *
 * The 'tmreg_lock' spinlock is used to protect the consistency of the
 * system time value. This is needed because reading the 64 bit time
 * value involves reading two (or three) 32 bit registers. The first
 * read latches the value. Ditto for writing.
 *
 * In addition, here have extended the system time with an overflow
 * counter in software.
 **/
static void igb_ptp_systim_to_hwtstamp(struct igb_adapter *adapter,
				       struct skb_shared_hwtstamps *hwtstamps,
				       u64 systim)
{
	unsigned long flags;
	u64 ns;

	switch (adapter->hw.mac.type) {
168
169
	case e1000_82576:
	case e1000_82580:
170
	case e1000_i354:
171
172
173
174
175
176
177
178
179
180
	case e1000_i350:
		spin_lock_irqsave(&adapter->tmreg_lock, flags);

		ns = timecounter_cyc2time(&adapter->tc, systim);

		spin_unlock_irqrestore(&adapter->tmreg_lock, flags);

		memset(hwtstamps, 0, sizeof(*hwtstamps));
		hwtstamps->hwtstamp = ns_to_ktime(ns);
		break;
181
182
	case e1000_i210:
	case e1000_i211:
183
184
185
186
		memset(hwtstamps, 0, sizeof(*hwtstamps));
		/* Upper 32 bits contain s, lower 32 bits contain ns. */
		hwtstamps->hwtstamp = ktime_set(systim >> 32,
						systim & 0xFFFFFFFF);
187
188
		break;
	default:
189
		break;
190
191
192
	}
}

193
/* PTP clock operations */
194
static int igb_ptp_adjfreq_82576(struct ptp_clock_info *ptp, s32 ppb)
195
{
196
197
198
199
	struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
					       ptp_caps);
	struct e1000_hw *hw = &igb->hw;
	int neg_adj = 0;
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
	u64 rate;
	u32 incvalue;

	if (ppb < 0) {
		neg_adj = 1;
		ppb = -ppb;
	}
	rate = ppb;
	rate <<= 14;
	rate = div_u64(rate, 1953125);

	incvalue = 16 << IGB_82576_TSYNC_SHIFT;

	if (neg_adj)
		incvalue -= rate;
	else
		incvalue += rate;

	wr32(E1000_TIMINCA, INCPERIOD_82576 | (incvalue & INCVALUE_82576_MASK));

	return 0;
}

223
static int igb_ptp_adjfine_82580(struct ptp_clock_info *ptp, long scaled_ppm)
224
{
225
226
227
228
	struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
					       ptp_caps);
	struct e1000_hw *hw = &igb->hw;
	int neg_adj = 0;
229
230
231
	u64 rate;
	u32 inca;

232
	if (scaled_ppm < 0) {
233
		neg_adj = 1;
234
		scaled_ppm = -scaled_ppm;
235
	}
236
237
238
	rate = scaled_ppm;
	rate <<= 13;
	rate = div_u64(rate, 15625);
239
240
241
242
243
244
245
246
247
248

	inca = rate & INCVALUE_MASK;
	if (neg_adj)
		inca |= ISGN;

	wr32(E1000_TIMINCA, inca);

	return 0;
}

249
static int igb_ptp_adjtime_82576(struct ptp_clock_info *ptp, s64 delta)
250
{
251
252
	struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
					       ptp_caps);
253
254
255
	unsigned long flags;

	spin_lock_irqsave(&igb->tmreg_lock, flags);
256
	timecounter_adjtime(&igb->tc, delta);
257
258
259
260
261
	spin_unlock_irqrestore(&igb->tmreg_lock, flags);

	return 0;
}

262
263
264
265
266
static int igb_ptp_adjtime_i210(struct ptp_clock_info *ptp, s64 delta)
{
	struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
					       ptp_caps);
	unsigned long flags;
267
	struct timespec64 now, then = ns_to_timespec64(delta);
268
269
270
271

	spin_lock_irqsave(&igb->tmreg_lock, flags);

	igb_ptp_read_i210(igb, &now);
272
273
	now = timespec64_add(now, then);
	igb_ptp_write_i210(igb, (const struct timespec64 *)&now);
274
275
276
277
278
279

	spin_unlock_irqrestore(&igb->tmreg_lock, flags);

	return 0;
}

280
281
282
static int igb_ptp_gettimex_82576(struct ptp_clock_info *ptp,
				  struct timespec64 *ts,
				  struct ptp_system_timestamp *sts)
283
{
284
285
	struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
					       ptp_caps);
286
	struct e1000_hw *hw = &igb->hw;
287
	unsigned long flags;
288
	u32 lo, hi;
289
290
291
292
	u64 ns;

	spin_lock_irqsave(&igb->tmreg_lock, flags);

293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
	ptp_read_system_prets(sts);
	lo = rd32(E1000_SYSTIML);
	ptp_read_system_postts(sts);
	hi = rd32(E1000_SYSTIMH);

	ns = timecounter_cyc2time(&igb->tc, ((u64)hi << 32) | lo);

	spin_unlock_irqrestore(&igb->tmreg_lock, flags);

	*ts = ns_to_timespec64(ns);

	return 0;
}

static int igb_ptp_gettimex_82580(struct ptp_clock_info *ptp,
				  struct timespec64 *ts,
				  struct ptp_system_timestamp *sts)
{
	struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
					       ptp_caps);
	struct e1000_hw *hw = &igb->hw;
	unsigned long flags;
	u32 lo, hi;
	u64 ns;

	spin_lock_irqsave(&igb->tmreg_lock, flags);

	ptp_read_system_prets(sts);
	rd32(E1000_SYSTIMR);
	ptp_read_system_postts(sts);
	lo = rd32(E1000_SYSTIML);
	hi = rd32(E1000_SYSTIMH);

	ns = timecounter_cyc2time(&igb->tc, ((u64)hi << 32) | lo);
327
328
329

	spin_unlock_irqrestore(&igb->tmreg_lock, flags);

330
	*ts = ns_to_timespec64(ns);
331
332
333
334

	return 0;
}

335
336
337
static int igb_ptp_gettimex_i210(struct ptp_clock_info *ptp,
				 struct timespec64 *ts,
				 struct ptp_system_timestamp *sts)
338
339
340
{
	struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
					       ptp_caps);
341
	struct e1000_hw *hw = &igb->hw;
342
343
344
345
	unsigned long flags;

	spin_lock_irqsave(&igb->tmreg_lock, flags);

346
347
348
349
350
	ptp_read_system_prets(sts);
	rd32(E1000_SYSTIMR);
	ptp_read_system_postts(sts);
	ts->tv_nsec = rd32(E1000_SYSTIML);
	ts->tv_sec = rd32(E1000_SYSTIMH);
351
352
353
354
355
356
357

	spin_unlock_irqrestore(&igb->tmreg_lock, flags);

	return 0;
}

static int igb_ptp_settime_82576(struct ptp_clock_info *ptp,
358
				 const struct timespec64 *ts)
359
{
360
361
	struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
					       ptp_caps);
362
	unsigned long flags;
363
	u64 ns;
364

365
	ns = timespec64_to_ns(ts);
366
367
368
369
370
371
372
373
374
375

	spin_lock_irqsave(&igb->tmreg_lock, flags);

	timecounter_init(&igb->tc, &igb->cc, ns);

	spin_unlock_irqrestore(&igb->tmreg_lock, flags);

	return 0;
}

376
static int igb_ptp_settime_i210(struct ptp_clock_info *ptp,
377
				const struct timespec64 *ts)
378
379
380
381
382
383
384
385
386
387
388
389
390
391
{
	struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
					       ptp_caps);
	unsigned long flags;

	spin_lock_irqsave(&igb->tmreg_lock, flags);

	igb_ptp_write_i210(igb, ts);

	spin_unlock_irqrestore(&igb->tmreg_lock, flags);

	return 0;
}

392
393
394
static void igb_pin_direction(int pin, int input, u32 *ctrl, u32 *ctrl_ext)
{
	u32 *ptr = pin < 2 ? ctrl : ctrl_ext;
395
	static const u32 mask[IGB_N_SDP] = {
396
397
398
399
400
401
402
403
404
405
406
407
408
409
		E1000_CTRL_SDP0_DIR,
		E1000_CTRL_SDP1_DIR,
		E1000_CTRL_EXT_SDP2_DIR,
		E1000_CTRL_EXT_SDP3_DIR,
	};

	if (input)
		*ptr &= ~mask[pin];
	else
		*ptr |= mask[pin];
}

static void igb_pin_extts(struct igb_adapter *igb, int chan, int pin)
{
410
	static const u32 aux0_sel_sdp[IGB_N_SDP] = {
411
412
		AUX0_SEL_SDP0, AUX0_SEL_SDP1, AUX0_SEL_SDP2, AUX0_SEL_SDP3,
	};
413
	static const u32 aux1_sel_sdp[IGB_N_SDP] = {
414
415
		AUX1_SEL_SDP0, AUX1_SEL_SDP1, AUX1_SEL_SDP2, AUX1_SEL_SDP3,
	};
416
	static const u32 ts_sdp_en[IGB_N_SDP] = {
417
418
		TS_SDP0_EN, TS_SDP1_EN, TS_SDP2_EN, TS_SDP3_EN,
	};
419
	struct e1000_hw *hw = &igb->hw;
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
	u32 ctrl, ctrl_ext, tssdp = 0;

	ctrl = rd32(E1000_CTRL);
	ctrl_ext = rd32(E1000_CTRL_EXT);
	tssdp = rd32(E1000_TSSDP);

	igb_pin_direction(pin, 1, &ctrl, &ctrl_ext);

	/* Make sure this pin is not enabled as an output. */
	tssdp &= ~ts_sdp_en[pin];

	if (chan == 1) {
		tssdp &= ~AUX1_SEL_SDP3;
		tssdp |= aux1_sel_sdp[pin] | AUX1_TS_SDP_EN;
	} else {
		tssdp &= ~AUX0_SEL_SDP3;
		tssdp |= aux0_sel_sdp[pin] | AUX0_TS_SDP_EN;
	}

	wr32(E1000_TSSDP, tssdp);
	wr32(E1000_CTRL, ctrl);
	wr32(E1000_CTRL_EXT, ctrl_ext);
}

444
static void igb_pin_perout(struct igb_adapter *igb, int chan, int pin, int freq)
445
{
446
	static const u32 aux0_sel_sdp[IGB_N_SDP] = {
447
448
		AUX0_SEL_SDP0, AUX0_SEL_SDP1, AUX0_SEL_SDP2, AUX0_SEL_SDP3,
	};
449
	static const u32 aux1_sel_sdp[IGB_N_SDP] = {
450
451
		AUX1_SEL_SDP0, AUX1_SEL_SDP1, AUX1_SEL_SDP2, AUX1_SEL_SDP3,
	};
452
	static const u32 ts_sdp_en[IGB_N_SDP] = {
453
454
		TS_SDP0_EN, TS_SDP1_EN, TS_SDP2_EN, TS_SDP3_EN,
	};
455
	static const u32 ts_sdp_sel_tt0[IGB_N_SDP] = {
456
457
458
		TS_SDP0_SEL_TT0, TS_SDP1_SEL_TT0,
		TS_SDP2_SEL_TT0, TS_SDP3_SEL_TT0,
	};
459
	static const u32 ts_sdp_sel_tt1[IGB_N_SDP] = {
460
461
462
		TS_SDP0_SEL_TT1, TS_SDP1_SEL_TT1,
		TS_SDP2_SEL_TT1, TS_SDP3_SEL_TT1,
	};
463
464
465
466
467
468
469
470
	static const u32 ts_sdp_sel_fc0[IGB_N_SDP] = {
		TS_SDP0_SEL_FC0, TS_SDP1_SEL_FC0,
		TS_SDP2_SEL_FC0, TS_SDP3_SEL_FC0,
	};
	static const u32 ts_sdp_sel_fc1[IGB_N_SDP] = {
		TS_SDP0_SEL_FC1, TS_SDP1_SEL_FC1,
		TS_SDP2_SEL_FC1, TS_SDP3_SEL_FC1,
	};
471
	static const u32 ts_sdp_sel_clr[IGB_N_SDP] = {
472
473
474
		TS_SDP0_SEL_FC1, TS_SDP1_SEL_FC1,
		TS_SDP2_SEL_FC1, TS_SDP3_SEL_FC1,
	};
475
	struct e1000_hw *hw = &igb->hw;
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
	u32 ctrl, ctrl_ext, tssdp = 0;

	ctrl = rd32(E1000_CTRL);
	ctrl_ext = rd32(E1000_CTRL_EXT);
	tssdp = rd32(E1000_TSSDP);

	igb_pin_direction(pin, 0, &ctrl, &ctrl_ext);

	/* Make sure this pin is not enabled as an input. */
	if ((tssdp & AUX0_SEL_SDP3) == aux0_sel_sdp[pin])
		tssdp &= ~AUX0_TS_SDP_EN;

	if ((tssdp & AUX1_SEL_SDP3) == aux1_sel_sdp[pin])
		tssdp &= ~AUX1_TS_SDP_EN;

	tssdp &= ~ts_sdp_sel_clr[pin];
492
493
494
495
496
497
498
499
500
501
502
	if (freq) {
		if (chan == 1)
			tssdp |= ts_sdp_sel_fc1[pin];
		else
			tssdp |= ts_sdp_sel_fc0[pin];
	} else {
		if (chan == 1)
			tssdp |= ts_sdp_sel_tt1[pin];
		else
			tssdp |= ts_sdp_sel_tt0[pin];
	}
503
504
505
506
507
508
509
	tssdp |= ts_sdp_en[pin];

	wr32(E1000_TSSDP, tssdp);
	wr32(E1000_CTRL, ctrl);
	wr32(E1000_CTRL_EXT, ctrl_ext);
}

510
511
512
513
514
515
static int igb_ptp_feature_enable_i210(struct ptp_clock_info *ptp,
				       struct ptp_clock_request *rq, int on)
{
	struct igb_adapter *igb =
		container_of(ptp, struct igb_adapter, ptp_caps);
	struct e1000_hw *hw = &igb->hw;
516
	u32 tsauxc, tsim, tsauxc_mask, tsim_mask, trgttiml, trgttimh, freqout;
517
	unsigned long flags;
Arnd Bergmann's avatar
Arnd Bergmann committed
518
	struct timespec64 ts;
519
	int use_freq = 0, pin = -1;
520
	s64 ns;
521
522

	switch (rq->type) {
523
	case PTP_CLK_REQ_EXTTS:
524
525
526
		/* Reject requests with unsupported flags */
		if (rq->extts.flags & ~(PTP_ENABLE_FEATURE |
					PTP_RISING_EDGE |
527
528
					PTP_FALLING_EDGE |
					PTP_STRICT_FLAGS))
529
530
			return -EOPNOTSUPP;

531
532
533
534
535
536
		/* Reject requests failing to enable both edges. */
		if ((rq->extts.flags & PTP_STRICT_FLAGS) &&
		    (rq->extts.flags & PTP_ENABLE_FEATURE) &&
		    (rq->extts.flags & PTP_EXTTS_EDGES) != PTP_EXTTS_EDGES)
			return -EOPNOTSUPP;

537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
		if (on) {
			pin = ptp_find_pin(igb->ptp_clock, PTP_PF_EXTTS,
					   rq->extts.index);
			if (pin < 0)
				return -EBUSY;
		}
		if (rq->extts.index == 1) {
			tsauxc_mask = TSAUXC_EN_TS1;
			tsim_mask = TSINTR_AUTT1;
		} else {
			tsauxc_mask = TSAUXC_EN_TS0;
			tsim_mask = TSINTR_AUTT0;
		}
		spin_lock_irqsave(&igb->tmreg_lock, flags);
		tsauxc = rd32(E1000_TSAUXC);
		tsim = rd32(E1000_TSIM);
		if (on) {
			igb_pin_extts(igb, rq->extts.index, pin);
			tsauxc |= tsauxc_mask;
			tsim |= tsim_mask;
		} else {
			tsauxc &= ~tsauxc_mask;
			tsim &= ~tsim_mask;
		}
		wr32(E1000_TSAUXC, tsauxc);
		wr32(E1000_TSIM, tsim);
		spin_unlock_irqrestore(&igb->tmreg_lock, flags);
		return 0;

	case PTP_CLK_REQ_PEROUT:
567
568
569
570
		/* Reject requests with unsupported flags */
		if (rq->perout.flags)
			return -EOPNOTSUPP;

571
572
573
574
575
576
577
578
		if (on) {
			pin = ptp_find_pin(igb->ptp_clock, PTP_PF_PEROUT,
					   rq->perout.index);
			if (pin < 0)
				return -EBUSY;
		}
		ts.tv_sec = rq->perout.period.sec;
		ts.tv_nsec = rq->perout.period.nsec;
Arnd Bergmann's avatar
Arnd Bergmann committed
579
		ns = timespec64_to_ns(&ts);
580
		ns = ns >> 1;
581
582
		if (on && ((ns <= 70000000LL) || (ns == 125000000LL) ||
			   (ns == 250000000LL) || (ns == 500000000LL))) {
583
584
585
			if (ns < 8LL)
				return -EINVAL;
			use_freq = 1;
586
		}
Arnd Bergmann's avatar
Arnd Bergmann committed
587
		ts = ns_to_timespec64(ns);
588
		if (rq->perout.index == 1) {
589
590
591
592
593
594
595
			if (use_freq) {
				tsauxc_mask = TSAUXC_EN_CLK1 | TSAUXC_ST1;
				tsim_mask = 0;
			} else {
				tsauxc_mask = TSAUXC_EN_TT1;
				tsim_mask = TSINTR_TT1;
			}
596
597
			trgttiml = E1000_TRGTTIML1;
			trgttimh = E1000_TRGTTIMH1;
598
			freqout = E1000_FREQOUT1;
599
		} else {
600
601
602
603
604
605
606
			if (use_freq) {
				tsauxc_mask = TSAUXC_EN_CLK0 | TSAUXC_ST0;
				tsim_mask = 0;
			} else {
				tsauxc_mask = TSAUXC_EN_TT0;
				tsim_mask = TSINTR_TT0;
			}
607
608
			trgttiml = E1000_TRGTTIML0;
			trgttimh = E1000_TRGTTIMH0;
609
			freqout = E1000_FREQOUT0;
610
611
612
613
		}
		spin_lock_irqsave(&igb->tmreg_lock, flags);
		tsauxc = rd32(E1000_TSAUXC);
		tsim = rd32(E1000_TSIM);
614
615
616
617
618
619
620
		if (rq->perout.index == 1) {
			tsauxc &= ~(TSAUXC_EN_TT1 | TSAUXC_EN_CLK1 | TSAUXC_ST1);
			tsim &= ~TSINTR_TT1;
		} else {
			tsauxc &= ~(TSAUXC_EN_TT0 | TSAUXC_EN_CLK0 | TSAUXC_ST0);
			tsim &= ~TSINTR_TT0;
		}
621
622
		if (on) {
			int i = rq->perout.index;
623
			igb_pin_perout(igb, i, pin, use_freq);
624
625
626
627
			igb->perout[i].start.tv_sec = rq->perout.start.sec;
			igb->perout[i].start.tv_nsec = rq->perout.start.nsec;
			igb->perout[i].period.tv_sec = ts.tv_sec;
			igb->perout[i].period.tv_nsec = ts.tv_nsec;
628
629
			wr32(trgttimh, rq->perout.start.sec);
			wr32(trgttiml, rq->perout.start.nsec);
630
631
			if (use_freq)
				wr32(freqout, ns);
632
633
634
635
636
637
638
639
			tsauxc |= tsauxc_mask;
			tsim |= tsim_mask;
		}
		wr32(E1000_TSAUXC, tsauxc);
		wr32(E1000_TSIM, tsim);
		spin_unlock_irqrestore(&igb->tmreg_lock, flags);
		return 0;

640
641
642
643
644
645
646
	case PTP_CLK_REQ_PPS:
		spin_lock_irqsave(&igb->tmreg_lock, flags);
		tsim = rd32(E1000_TSIM);
		if (on)
			tsim |= TSINTR_SYS_WRAP;
		else
			tsim &= ~TSINTR_SYS_WRAP;
647
		igb->pps_sys_wrap_on = !!on;
648
649
650
651
652
653
654
655
		wr32(E1000_TSIM, tsim);
		spin_unlock_irqrestore(&igb->tmreg_lock, flags);
		return 0;
	}

	return -EOPNOTSUPP;
}

656
657
static int igb_ptp_feature_enable(struct ptp_clock_info *ptp,
				  struct ptp_clock_request *rq, int on)
658
659
660
661
{
	return -EOPNOTSUPP;
}

662
663
664
665
666
667
668
669
670
671
672
673
674
675
static int igb_ptp_verify_pin(struct ptp_clock_info *ptp, unsigned int pin,
			      enum ptp_pin_function func, unsigned int chan)
{
	switch (func) {
	case PTP_PF_NONE:
	case PTP_PF_EXTTS:
	case PTP_PF_PEROUT:
		break;
	case PTP_PF_PHYSYNC:
		return -1;
	}
	return 0;
}

676
677
678
679
680
681
/**
 * igb_ptp_tx_work
 * @work: pointer to work struct
 *
 * This work function polls the TSYNCTXCTL valid bit to determine when a
 * timestamp has been taken for the current stored skb.
682
 **/
683
static void igb_ptp_tx_work(struct work_struct *work)
684
685
686
687
688
689
690
691
692
{
	struct igb_adapter *adapter = container_of(work, struct igb_adapter,
						   ptp_tx_work);
	struct e1000_hw *hw = &adapter->hw;
	u32 tsynctxctl;

	if (!adapter->ptp_tx_skb)
		return;

693
694
695
696
	if (time_is_before_jiffies(adapter->ptp_tx_start +
				   IGB_PTP_TX_TIMEOUT)) {
		dev_kfree_skb_any(adapter->ptp_tx_skb);
		adapter->ptp_tx_skb = NULL;
697
		clear_bit_unlock(__IGB_PTP_TX_IN_PROGRESS, &adapter->state);
698
		adapter->tx_hwtstamp_timeouts++;
699
700
701
702
		/* Clear the tx valid bit in TSYNCTXCTL register to enable
		 * interrupt
		 */
		rd32(E1000_TXSTMPH);
703
		dev_warn(&adapter->pdev->dev, "clearing Tx timestamp hang\n");
704
705
706
		return;
	}

707
708
709
710
711
712
713
714
	tsynctxctl = rd32(E1000_TSYNCTXCTL);
	if (tsynctxctl & E1000_TSYNCTXCTL_VALID)
		igb_ptp_tx_hwtstamp(adapter);
	else
		/* reschedule to check later */
		schedule_work(&adapter->ptp_tx_work);
}

715
static void igb_ptp_overflow_check(struct work_struct *work)
716
{
717
718
	struct igb_adapter *igb =
		container_of(work, struct igb_adapter, ptp_overflow_work.work);
719
	struct timespec64 ts;
720
	u64 ns;
721

722
723
	/* Update the timecounter */
	ns = timecounter_read(&igb->tc);
724

725
	ts = ns_to_timespec64(ns);
David S. Miller's avatar
David S. Miller committed
726
727
	pr_debug("igb overflow check at %lld.%09lu\n",
		 (long long) ts.tv_sec, ts.tv_nsec);
728
729
730

	schedule_delayed_work(&igb->ptp_overflow_work,
			      IGB_SYSTIM_OVERFLOW_PERIOD);
731
732
}

733
734
735
736
737
738
739
740
/**
 * igb_ptp_rx_hang - detect error case when Rx timestamp registers latched
 * @adapter: private network adapter structure
 *
 * This watchdog task is scheduled to detect error case where hardware has
 * dropped an Rx packet that was timestamped when the ring is full. The
 * particular error is rare but leaves the device in a state unable to timestamp
 * any future packets.
741
 **/
742
743
744
745
746
747
void igb_ptp_rx_hang(struct igb_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
	u32 tsyncrxctl = rd32(E1000_TSYNCRXCTL);
	unsigned long rx_event;

748
	/* Other hardware uses per-packet timestamps */
749
750
751
752
753
754
755
756
757
758
759
760
761
	if (hw->mac.type != e1000_82576)
		return;

	/* If we don't have a valid timestamp in the registers, just update the
	 * timeout counter and exit
	 */
	if (!(tsyncrxctl & E1000_TSYNCRXCTL_VALID)) {
		adapter->last_rx_ptp_check = jiffies;
		return;
	}

	/* Determine the most recent watchdog or rx_timestamp event */
	rx_event = adapter->last_rx_ptp_check;
762
763
	if (time_after(adapter->last_rx_timestamp, rx_event))
		rx_event = adapter->last_rx_timestamp;
764
765
766
767
768
769

	/* Only need to read the high RXSTMP register to clear the lock */
	if (time_is_before_jiffies(rx_event + 5 * HZ)) {
		rd32(E1000_RXSTMPH);
		adapter->last_rx_ptp_check = jiffies;
		adapter->rx_hwtstamp_cleared++;
770
		dev_warn(&adapter->pdev->dev, "clearing Rx timestamp hang\n");
771
772
773
	}
}

774
775
776
777
778
779
/**
 * igb_ptp_tx_hang - detect error case where Tx timestamp never finishes
 * @adapter: private network adapter structure
 */
void igb_ptp_tx_hang(struct igb_adapter *adapter)
{
780
	struct e1000_hw *hw = &adapter->hw;
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
	bool timeout = time_is_before_jiffies(adapter->ptp_tx_start +
					      IGB_PTP_TX_TIMEOUT);

	if (!adapter->ptp_tx_skb)
		return;

	if (!test_bit(__IGB_PTP_TX_IN_PROGRESS, &adapter->state))
		return;

	/* If we haven't received a timestamp within the timeout, it is
	 * reasonable to assume that it will never occur, so we can unlock the
	 * timestamp bit when this occurs.
	 */
	if (timeout) {
		cancel_work_sync(&adapter->ptp_tx_work);
		dev_kfree_skb_any(adapter->ptp_tx_skb);
		adapter->ptp_tx_skb = NULL;
		clear_bit_unlock(__IGB_PTP_TX_IN_PROGRESS, &adapter->state);
		adapter->tx_hwtstamp_timeouts++;
800
801
802
803
		/* Clear the tx valid bit in TSYNCTXCTL register to enable
		 * interrupt
		 */
		rd32(E1000_TXSTMPH);
804
805
806
807
		dev_warn(&adapter->pdev->dev, "clearing Tx timestamp hang\n");
	}
}

808
809
/**
 * igb_ptp_tx_hwtstamp - utility function which checks for TX time stamp
810
 * @adapter: Board private structure.
811
812
813
814
 *
 * If we were asked to do hardware stamping and such a time stamp is
 * available, then it must have been for this skb here because we only
 * allow only one such packet into the queue.
815
 **/
816
static void igb_ptp_tx_hwtstamp(struct igb_adapter *adapter)
817
{
818
	struct sk_buff *skb = adapter->ptp_tx_skb;
819
820
821
	struct e1000_hw *hw = &adapter->hw;
	struct skb_shared_hwtstamps shhwtstamps;
	u64 regval;
822
	int adjust = 0;
823

824
825
	regval = rd32(E1000_TXSTMPL);
	regval |= (u64)rd32(E1000_TXSTMPH) << 32;
826

827
	igb_ptp_systim_to_hwtstamp(adapter, &shhwtstamps, regval);
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
	/* adjust timestamp for the TX latency based on link speed */
	if (adapter->hw.mac.type == e1000_i210) {
		switch (adapter->link_speed) {
		case SPEED_10:
			adjust = IGB_I210_TX_LATENCY_10;
			break;
		case SPEED_100:
			adjust = IGB_I210_TX_LATENCY_100;
			break;
		case SPEED_1000:
			adjust = IGB_I210_TX_LATENCY_1000;
			break;
		}
	}

843
844
	shhwtstamps.hwtstamp =
		ktime_add_ns(shhwtstamps.hwtstamp, adjust);
845

846
847
848
849
850
	/* Clear the lock early before calling skb_tstamp_tx so that
	 * applications are not woken up before the lock bit is clear. We use
	 * a copy of the skb pointer to ensure other threads can't change it
	 * while we're notifying the stack.
	 */
851
	adapter->ptp_tx_skb = NULL;
852
	clear_bit_unlock(__IGB_PTP_TX_IN_PROGRESS, &adapter->state);
853
854
855
856

	/* Notify the stack and free the skb after we've unlocked */
	skb_tstamp_tx(skb, &shhwtstamps);
	dev_kfree_skb_any(skb);
857
858
}

859
860
861
862
863
864
865
866
867
/**
 * igb_ptp_rx_pktstamp - retrieve Rx per packet timestamp
 * @q_vector: Pointer to interrupt specific structure
 * @va: Pointer to address containing Rx buffer
 * @skb: Buffer containing timestamp and packet
 *
 * This function is meant to retrieve a timestamp from the first buffer of an
 * incoming frame.  The value is stored in little endian format starting on
 * byte 8.
868
 **/
869
void igb_ptp_rx_pktstamp(struct igb_q_vector *q_vector, void *va,
870
871
			 struct sk_buff *skb)
{
872
	__le64 *regval = (__le64 *)va;
873
874
	struct igb_adapter *adapter = q_vector->adapter;
	int adjust = 0;
875

876
	/* The timestamp is recorded in little endian format.
877
878
879
	 * DWORD: 0        1        2        3
	 * Field: Reserved Reserved SYSTIML  SYSTIMH
	 */
880
	igb_ptp_systim_to_hwtstamp(adapter, skb_hwtstamps(skb),
881
				   le64_to_cpu(regval[1]));
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898

	/* adjust timestamp for the RX latency based on link speed */
	if (adapter->hw.mac.type == e1000_i210) {
		switch (adapter->link_speed) {
		case SPEED_10:
			adjust = IGB_I210_RX_LATENCY_10;
			break;
		case SPEED_100:
			adjust = IGB_I210_RX_LATENCY_100;
			break;
		case SPEED_1000:
			adjust = IGB_I210_RX_LATENCY_1000;
			break;
		}
	}
	skb_hwtstamps(skb)->hwtstamp =
		ktime_sub_ns(skb_hwtstamps(skb)->hwtstamp, adjust);
899
900
901
902
903
904
905
906
907
}

/**
 * igb_ptp_rx_rgtstamp - retrieve Rx timestamp stored in register
 * @q_vector: Pointer to interrupt specific structure
 * @skb: Buffer containing timestamp and packet
 *
 * This function is meant to retrieve a timestamp from the internal registers
 * of the adapter and store it in the skb.
908
 **/
909
void igb_ptp_rx_rgtstamp(struct igb_q_vector *q_vector,
910
911
912
913
914
			 struct sk_buff *skb)
{
	struct igb_adapter *adapter = q_vector->adapter;
	struct e1000_hw *hw = &adapter->hw;
	u64 regval;
915
	int adjust = 0;
916

917
	/* If this bit is set, then the RX registers contain the time stamp. No
918
919
920
921
922
923
924
925
926
	 * other packet will be time stamped until we read these registers, so
	 * read the registers to make them available again. Because only one
	 * packet can be time stamped at a time, we know that the register
	 * values must belong to this one here and therefore we don't need to
	 * compare any of the additional attributes stored for it.
	 *
	 * If nothing went wrong, then it should have a shared tx_flags that we
	 * can turn into a skb_shared_hwtstamps.
	 */
927
928
929
930
931
	if (!(rd32(E1000_TSYNCRXCTL) & E1000_TSYNCRXCTL_VALID))
		return;

	regval = rd32(E1000_RXSTMPL);
	regval |= (u64)rd32(E1000_RXSTMPH) << 32;
932
933

	igb_ptp_systim_to_hwtstamp(adapter, skb_hwtstamps(skb), regval);
934

935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
	/* adjust timestamp for the RX latency based on link speed */
	if (adapter->hw.mac.type == e1000_i210) {
		switch (adapter->link_speed) {
		case SPEED_10:
			adjust = IGB_I210_RX_LATENCY_10;
			break;
		case SPEED_100:
			adjust = IGB_I210_RX_LATENCY_100;
			break;
		case SPEED_1000:
			adjust = IGB_I210_RX_LATENCY_1000;
			break;
		}
	}
	skb_hwtstamps(skb)->hwtstamp =
950
		ktime_sub_ns(skb_hwtstamps(skb)->hwtstamp, adjust);
951

952
953
954
955
	/* Update the last_rx_timestamp timer in order to enable watchdog check
	 * for error case of latched timestamp on a dropped packet.
	 */
	adapter->last_rx_timestamp = jiffies;
956
957
958
}

/**
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
 * igb_ptp_get_ts_config - get hardware time stamping config
 * @netdev:
 * @ifreq:
 *
 * Get the hwtstamp_config settings to return to the user. Rather than attempt
 * to deconstruct the settings from the registers, just return a shadow copy
 * of the last known settings.
 **/
int igb_ptp_get_ts_config(struct net_device *netdev, struct ifreq *ifr)
{
	struct igb_adapter *adapter = netdev_priv(netdev);
	struct hwtstamp_config *config = &adapter->tstamp_config;

	return copy_to_user(ifr->ifr_data, config, sizeof(*config)) ?
		-EFAULT : 0;
}
975

976
/**
977
978
979
 * igb_ptp_set_timestamp_mode - setup hardware for timestamping
 * @adapter: networking device structure
 * @config: hwtstamp configuration
980
981
982
983
984
985
986
987
988
989
990
991
 *
 * Outgoing time stamping can be enabled and disabled. Play nice and
 * disable it when requested, although it shouldn't case any overhead
 * when no packet needs it. At most one packet in the queue may be
 * marked for time stamping, otherwise it would be impossible to tell
 * for sure to which packet the hardware time stamp belongs.
 *
 * Incoming time stamping has to be configured via the hardware
 * filters. Not all combinations are supported, in particular event
 * type has to be specified. Matching the kind of event packet is
 * not supported, with the exception of "all V2 events regardless of
 * level 2 or 4".
992
993
994
 */
static int igb_ptp_set_timestamp_mode(struct igb_adapter *adapter,
				      struct hwtstamp_config *config)
995
996
997
998
999
1000
1001
1002
1003
1004
{
	struct e1000_hw *hw = &adapter->hw;
	u32 tsync_tx_ctl = E1000_TSYNCTXCTL_ENABLED;
	u32 tsync_rx_ctl = E1000_TSYNCRXCTL_ENABLED;
	u32 tsync_rx_cfg = 0;
	bool is_l4 = false;
	bool is_l2 = false;
	u32 regval;

	/* reserved for future extensions */
1005
	if (config->flags)
1006
1007
		return -EINVAL;

1008
	switch (config->tx_type) {
1009
1010
1011
1012
1013
1014
1015
1016
	case HWTSTAMP_TX_OFF:
		tsync_tx_ctl = 0;
	case HWTSTAMP_TX_ON:
		break;
	default:
		return -ERANGE;
	}

1017
	switch (config->rx_filter) {
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
	case HWTSTAMP_FILTER_NONE:
		tsync_rx_ctl = 0;
		break;
	case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
		tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_L4_V1;
		tsync_rx_cfg = E1000_TSYNCRXCFG_PTP_V1_SYNC_MESSAGE;
		is_l4 = true;
		break;
	case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
		tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_L4_V1;
		tsync_rx_cfg = E1000_TSYNCRXCFG_PTP_V1_DELAY_REQ_MESSAGE;
		is_l4 = true;
		break;
Matthew Vick's avatar
Matthew Vick committed
1031
1032
1033
1034
	case HWTSTAMP_FILTER_PTP_V2_EVENT:
	case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
	case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
	case HWTSTAMP_FILTER_PTP_V2_SYNC:
1035
1036
	case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
	case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
Matthew Vick's avatar
Matthew Vick committed
1037
	case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
1038
1039
1040
	case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
	case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
		tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_EVENT_V2;
1041
		config->rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT;
1042
1043
1044
		is_l2 = true;
		is_l4 = true;
		break;
Matthew Vick's avatar
Matthew Vick committed
1045
	case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
1046
	case HWTSTAMP_FILTER_NTP_ALL:
Matthew Vick's avatar
Matthew Vick committed
1047
1048
1049
1050
1051
1052
	case HWTSTAMP_FILTER_ALL:
		/* 82576 cannot timestamp all packets, which it needs to do to
		 * support both V1 Sync and Delay_Req messages
		 */
		if (hw->mac.type != e1000_82576) {
			tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_ALL;
1053
			config->rx_filter = HWTSTAMP_FILTER_ALL;
Matthew Vick's avatar
Matthew Vick committed
1054
1055
1056
			break;
		}
		/* fall through */
1057
	default:
1058
		config->rx_filter = HWTSTAMP_FILTER_NONE;
1059
1060
1061
1062
1063
1064
1065
1066
1067
		return -ERANGE;
	}

	if (hw->mac.type == e1000_82575) {
		if (tsync_rx_ctl | tsync_tx_ctl)
			return -EINVAL;
		return 0;
	}

1068
	/* Per-packet timestamping only works if all packets are
1069
	 * timestamped, so enable timestamping in all packets as
1070
	 * long as one Rx filter was configured.
1071
1072
1073
1074
	 */
	if ((hw->mac.type >= e1000_82580) && tsync_rx_ctl) {
		tsync_rx_ctl = E1000_TSYNCRXCTL_ENABLED;
		tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_ALL;
1075
		config->rx_filter = HWTSTAMP_FILTER_ALL;
Matthew Vick's avatar
Matthew Vick committed
1076
1077
		is_l2 = true;
		is_l4 = true;
1078
1079
1080
1081
1082
1083
1084

		if ((hw->mac.type == e1000_i210) ||
		    (hw->mac.type == e1000_i211)) {
			regval = rd32(E1000_RXPBS);
			regval |= E1000_RXPBS_CFG_TS_EN;
			wr32(E1000_RXPBS, regval);
		}
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
	}

	/* enable/disable TX */
	regval = rd32(E1000_TSYNCTXCTL);
	regval &= ~E1000_TSYNCTXCTL_ENABLED;
	regval |= tsync_tx_ctl;
	wr32(E1000_TSYNCTXCTL, regval);

	/* enable/disable RX */
	regval = rd32(E1000_TSYNCRXCTL);
	regval &= ~(E1000_TSYNCRXCTL_ENABLED | E1000_TSYNCRXCTL_TYPE_MASK);
	regval |= tsync_rx_ctl;
	wr32(E1000_TSYNCRXCTL, regval);

	/* define which PTP packets are time stamped */
	wr32(E1000_TSYNCRXCFG, tsync_rx_cfg);

	/* define ethertype filter for timestamped packets */
	if (is_l2)
1104
		wr32(E1000_ETQF(IGB_ETQF_FILTER_1588),
1105
1106
1107
1108
		     (E1000_ETQF_FILTER_ENABLE | /* enable filter */
		      E1000_ETQF_1588 | /* enable timestamping */
		      ETH_P_1588));     /* 1588 eth protocol type */
	else
1109
		wr32(E1000_ETQF(IGB_ETQF_FILTER_1588), 0);
1110
1111
1112
1113
1114
1115
1116
1117
1118

	/* L4 Queue Filter[3]: filter by destination port and protocol */
	if (is_l4) {
		u32 ftqf = (IPPROTO_UDP /* UDP */
			| E1000_FTQF_VF_BP /* VF not compared */
			| E1000_FTQF_1588_TIME_STAMP /* Enable Timestamping */
			| E1000_FTQF_MASK); /* mask all inputs */
		ftqf &= ~E1000_FTQF_MASK_PROTO_BP; /* enable protocol check */

1119
		wr32(E1000_IMIR(3), htons(PTP_EV_PORT));
1120
1121
1122
1123
		wr32(E1000_IMIREXT(3),
		     (E1000_IMIREXT_SIZE_BP | E1000_IMIREXT_CTRL_BP));
		if (hw->mac.type == e1000_82576) {
			/* enable source port check */
1124
			wr32(E1000_SPQF(3), htons(PTP_EV_PORT));
1125
1126
1127
1128
1129
1130
1131
1132
1133
			ftqf &= ~E1000_FTQF_MASK_SOURCE_PORT_BP;
		}
		wr32(E1000_FTQF(3), ftqf);
	} else {
		wr32(E1000_FTQF(3), E1000_FTQF_MASK);
	}
	wrfl();

	/* clear TX/RX time stamp registers, just to be sure */
1134
	regval = rd32(E1000_TXSTMPL);
1135
	regval = rd32(E1000_TXSTMPH);
1136
	regval = rd32(E1000_RXSTMPL);
1137
1138
	regval = rd32(E1000_RXSTMPH);

1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
	return 0;
}

/**
 * igb_ptp_set_ts_config - set hardware time stamping config
 * @netdev:
 * @ifreq:
 *
 **/
int igb_ptp_set_ts_config(struct net_device *netdev, struct ifreq *ifr)
{
	struct igb_adapter *adapter = netdev_priv(netdev);
	struct hwtstamp_config config;
	int err;

	if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
		return -EFAULT;

	err = igb_ptp_set_timestamp_mode(adapter, &config);
	if (err)
		return err;

	/* save these settings for future reference */
	memcpy(&adapter->tstamp_config, &config,
	       sizeof(adapter->tstamp_config));

	return copy_to_user(ifr->ifr_data, &config, sizeof(config)) ?
1166
		-EFAULT : 0;
1167
1168
}

1169
1170
1171
1172
1173
1174
1175
/**
 * igb_ptp_init - Initialize PTP functionality
 * @adapter: Board private structure
 *
 * This function is called at device probe to initialize the PTP
 * functionality.
 */
1176
1177
1178
void igb_ptp_init(struct igb_adapter *adapter)
{
	struct e1000_hw *hw = &adapter->hw;
1179
	struct net_device *netdev = adapter->netdev;
1180
	int i;
1181
1182

	switch (hw->mac.type) {
1183
1184
1185
	case e1000_82576:
		snprintf(adapter->ptp_caps.name, 16, "%pm", netdev->dev_addr);
		adapter->ptp_caps.owner = THIS_MODULE;
Jiri Benc's avatar
Jiri Benc committed
1186
		adapter->ptp_caps.max_adj = 999999881;
1187
1188
1189
1190
		adapter->ptp_caps.n_ext_ts = 0;
		adapter->ptp_caps.pps = 0;
		adapter->ptp_caps.adjfreq = igb_ptp_adjfreq_82576;
		adapter->ptp_caps.adjtime = igb_ptp_adjtime_82576;
1191
		adapter->ptp_caps.gettimex64 = igb_ptp_gettimex_82576;
1192
		adapter->ptp_caps.settime64 = igb_ptp_settime_82576;
1193
		adapter->ptp_caps.enable = igb_ptp_feature_enable;
1194
		adapter->cc.read = igb_ptp_read_82576;
1195
		adapter->cc.mask = CYCLECOUNTER_MASK(64);
1196
1197
		adapter->cc.mult = 1;
		adapter->cc.shift = IGB_82576_TSYNC_SHIFT;
1198
		adapter->ptp_flags |= IGB_PTP_OVERFLOW_CHECK;
1199
		break;
1200
	case e1000_82580:
1201
	case e1000_i354:
1202
	case e1000_i350:
1203
		snprintf(adapter->ptp_caps.name, 16, "%pm", netdev->dev_addr);
1204
1205
1206
1207
		adapter->ptp_caps.owner = THIS_MODULE;
		adapter->ptp_caps.max_adj = 62499999;
		adapter->ptp_caps.n_ext_ts = 0;
		adapter->ptp_caps.pps = 0;
1208
		adapter->ptp_caps.adjfine = igb_ptp_adjfine_82580;
1209
		adapter->ptp_caps.adjtime = igb_ptp_adjtime_82576;
1210
		adapter->ptp_caps.gettimex64 = igb_ptp_gettimex_82580;
1211
		adapter->ptp_caps.settime64 = igb_ptp_settime_82576;
1212
		adapter->ptp_caps.enable = igb_ptp_feature_enable;
1213
		adapter->cc.read = igb_ptp_read_82580;
1214
		adapter->cc.mask = CYCLECOUNTER_MASK(IGB_NBITS_82580);
1215
1216
		adapter->cc.mult = 1;
		adapter->cc.shift = 0;
1217
		adapter->ptp_flags |= IGB_PTP_OVERFLOW_CHECK;
1218
		break;
1219
1220
	case e1000_i210:
	case e1000_i211:
1221
1222
1223
1224
1225
1226
1227
		for (i = 0; i < IGB_N_SDP; i++) {
			struct ptp_pin_desc *ppd = &adapter->sdp_config[i];

			snprintf(ppd->name, sizeof(ppd->name), "SDP%d", i);
			ppd->index = i;
			ppd->func = PTP_PF_NONE;
		}
1228
		snprintf(adapter->ptp_caps.name, 16, "%pm", netdev->dev_addr);
1229
		adapter->ptp_caps.owner = THIS_MODULE;
1230
		adapter->ptp_caps.max_adj = 62499999;
1231
1232
1233
		adapter->ptp_caps.n_ext_ts = IGB_N_EXTTS;
		adapter->ptp_caps.n_per_out = IGB_N_PEROUT;
		adapter->ptp_caps.n_pins = IGB_N_SDP;
1234
		adapter->ptp_caps.pps = 1;
1235
		adapter->ptp_caps.pin_config = adapter->sdp_config;
1236
		adapter->ptp_caps.adjfine = igb_ptp_adjfine_82580;
1237
		adapter->ptp_caps.adjtime = igb_ptp_adjtime_i210;
1238
		adapter->ptp_caps.gettimex64 = igb_ptp_gettimex_i210;
1239
		adapter->ptp_caps.settime64 = igb_ptp_settime_i210;
1240
		adapter->ptp_caps.enable = igb_ptp_feature_enable_i210;
1241
		adapter->ptp_caps.verify = igb_ptp_verify_pin;
1242
1243
1244
1245
1246
1247
		break;
	default:
		adapter->ptp_clock = NULL;
		return;
	}

1248
1249
	spin_lock_init(&adapter->tmreg_lock);
	INIT_WORK(&adapter->ptp_tx_work, igb_ptp_tx_work);
1250

1251
	if (adapter->ptp_flags & IGB_PTP_OVERFLOW_CHECK)
1252
1253
		INIT_DELAYED_WORK(&adapter->ptp_overflow_work,
				  igb_ptp_overflow_check);
1254

1255
1256
1257
	adapter->tstamp_config.rx_filter = HWTSTAMP_FILTER_NONE;
	adapter->tstamp_config.tx_type = HWTSTAMP_TX_OFF;