1 // SPDX-License-Identifier: GPL-2.0+ 2 /* Copyright (C) 2011 Richard Cochran <richardcochran@gmail.com> */ 3 4 #include <linux/module.h> 5 #include <linux/device.h> 6 #include <linux/pci.h> 7 #include <linux/ptp_classify.h> 8 9 #include "igb.h" 10 11 #define INCVALUE_MASK 0x7fffffff 12 #define ISGN 0x80000000 13 14 /* The 82580 timesync updates the system timer every 8ns by 8ns, 15 * and this update value cannot be reprogrammed. 16 * 17 * Neither the 82576 nor the 82580 offer registers wide enough to hold 18 * nanoseconds time values for very long. For the 82580, SYSTIM always 19 * counts nanoseconds, but the upper 24 bits are not available. The 20 * frequency is adjusted by changing the 32 bit fractional nanoseconds 21 * register, TIMINCA. 22 * 23 * For the 82576, the SYSTIM register time unit is affect by the 24 * choice of the 24 bit TININCA:IV (incvalue) field. Five bits of this 25 * field are needed to provide the nominal 16 nanosecond period, 26 * leaving 19 bits for fractional nanoseconds. 27 * 28 * We scale the NIC clock cycle by a large factor so that relatively 29 * small clock corrections can be added or subtracted at each clock 30 * tick. The drawbacks of a large factor are a) that the clock 31 * register overflows more quickly (not such a big deal) and b) that 32 * the increment per tick has to fit into 24 bits. As a result we 33 * need to use a shift of 19 so we can fit a value of 16 into the 34 * TIMINCA register. 35 * 36 * 37 * SYSTIMH SYSTIML 38 * +--------------+ +---+---+------+ 39 * 82576 | 32 | | 8 | 5 | 19 | 40 * +--------------+ +---+---+------+ 41 * \________ 45 bits _______/ fract 42 * 43 * +----------+---+ +--------------+ 44 * 82580 | 24 | 8 | | 32 | 45 * +----------+---+ +--------------+ 46 * reserved \______ 40 bits _____/ 47 * 48 * 49 * The 45 bit 82576 SYSTIM overflows every 50 * 2^45 * 10^-9 / 3600 = 9.77 hours. 51 * 52 * The 40 bit 82580 SYSTIM overflows every 53 * 2^40 * 10^-9 / 60 = 18.3 minutes. 54 * 55 * SYSTIM is converted to real time using a timecounter. As 56 * timecounter_cyc2time() allows old timestamps, the timecounter needs 57 * to be updated at least once per half of the SYSTIM interval. 58 * Scheduling of delayed work is not very accurate, and also the NIC 59 * clock can be adjusted to run up to 6% faster and the system clock 60 * up to 10% slower, so we aim for 6 minutes to be sure the actual 61 * 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 #define INCPERIOD_82576 BIT(E1000_TIMINCA_16NS_SHIFT) 67 #define INCVALUE_82576_MASK GENMASK(E1000_TIMINCA_16NS_SHIFT - 1, 0) 68 #define INCVALUE_82576 (16u << IGB_82576_TSYNC_SHIFT) 69 #define IGB_NBITS_82580 40 70 71 static void igb_ptp_tx_hwtstamp(struct igb_adapter *adapter); 72 73 /* SYSTIM read access for the 82576 */ 74 static u64 igb_ptp_read_82576(const struct cyclecounter *cc) 75 { 76 struct igb_adapter *igb = container_of(cc, struct igb_adapter, cc); 77 struct e1000_hw *hw = &igb->hw; 78 u64 val; 79 u32 lo, hi; 80 81 lo = rd32(E1000_SYSTIML); 82 hi = rd32(E1000_SYSTIMH); 83 84 val = ((u64) hi) << 32; 85 val |= lo; 86 87 return val; 88 } 89 90 /* SYSTIM read access for the 82580 */ 91 static u64 igb_ptp_read_82580(const struct cyclecounter *cc) 92 { 93 struct igb_adapter *igb = container_of(cc, struct igb_adapter, cc); 94 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 * the lowest register is SYSTIMR instead of SYSTIML. However we only 100 * need to provide nanosecond resolution, so we just ignore it. 101 */ 102 rd32(E1000_SYSTIMR); 103 lo = rd32(E1000_SYSTIML); 104 hi = rd32(E1000_SYSTIMH); 105 106 val = ((u64) hi) << 32; 107 val |= lo; 108 109 return val; 110 } 111 112 /* SYSTIM read access for I210/I211 */ 113 static void igb_ptp_read_i210(struct igb_adapter *adapter, 114 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 * lowest register is SYSTIMR. Since we only need to provide nanosecond 121 * resolution, we can ignore it. 122 */ 123 rd32(E1000_SYSTIMR); 124 nsec = rd32(E1000_SYSTIML); 125 sec = rd32(E1000_SYSTIMH); 126 127 ts->tv_sec = sec; 128 ts->tv_nsec = nsec; 129 } 130 131 static void igb_ptp_write_i210(struct igb_adapter *adapter, 132 const struct timespec64 *ts) 133 { 134 struct e1000_hw *hw = &adapter->hw; 135 136 /* Writing the SYSTIMR register is not necessary as it only provides 137 * sub-nanosecond resolution. 138 */ 139 wr32(E1000_SYSTIML, ts->tv_nsec); 140 wr32(E1000_SYSTIMH, (u32)ts->tv_sec); 141 } 142 143 /** 144 * igb_ptp_systim_to_hwtstamp - convert system time value to hw timestamp 145 * @adapter: board private structure 146 * @hwtstamps: timestamp structure to update 147 * @systim: unsigned 64bit system time value. 148 * 149 * We need to convert the system time value stored in the RX/TXSTMP registers 150 * into a hwtstamp which can be used by the upper level timestamping functions. 151 * 152 * The 'tmreg_lock' spinlock is used to protect the consistency of the 153 * system time value. This is needed because reading the 64 bit time 154 * value involves reading two (or three) 32 bit registers. The first 155 * read latches the value. Ditto for writing. 156 * 157 * In addition, here have extended the system time with an overflow 158 * counter in software. 159 **/ 160 static void igb_ptp_systim_to_hwtstamp(struct igb_adapter *adapter, 161 struct skb_shared_hwtstamps *hwtstamps, 162 u64 systim) 163 { 164 unsigned long flags; 165 u64 ns; 166 167 switch (adapter->hw.mac.type) { 168 case e1000_82576: 169 case e1000_82580: 170 case e1000_i354: 171 case e1000_i350: 172 spin_lock_irqsave(&adapter->tmreg_lock, flags); 173 174 ns = timecounter_cyc2time(&adapter->tc, systim); 175 176 spin_unlock_irqrestore(&adapter->tmreg_lock, flags); 177 178 memset(hwtstamps, 0, sizeof(*hwtstamps)); 179 hwtstamps->hwtstamp = ns_to_ktime(ns); 180 break; 181 case e1000_i210: 182 case e1000_i211: 183 memset(hwtstamps, 0, sizeof(*hwtstamps)); 184 /* Upper 32 bits contain s, lower 32 bits contain ns. */ 185 hwtstamps->hwtstamp = ktime_set(systim >> 32, 186 systim & 0xFFFFFFFF); 187 break; 188 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 struct igb_adapter *igb = container_of(ptp, struct igb_adapter, 197 ptp_caps); 198 struct e1000_hw *hw = &igb->hw; 199 int neg_adj = 0; 200 u64 rate; 201 u32 incvalue; 202 203 if (ppb < 0) { 204 neg_adj = 1; 205 ppb = -ppb; 206 } 207 rate = ppb; 208 rate <<= 14; 209 rate = div_u64(rate, 1953125); 210 211 incvalue = 16 << IGB_82576_TSYNC_SHIFT; 212 213 if (neg_adj) 214 incvalue -= rate; 215 else 216 incvalue += rate; 217 218 wr32(E1000_TIMINCA, INCPERIOD_82576 | (incvalue & INCVALUE_82576_MASK)); 219 220 return 0; 221 } 222 223 static int igb_ptp_adjfine_82580(struct ptp_clock_info *ptp, long scaled_ppm) 224 { 225 struct igb_adapter *igb = container_of(ptp, struct igb_adapter, 226 ptp_caps); 227 struct e1000_hw *hw = &igb->hw; 228 int neg_adj = 0; 229 u64 rate; 230 u32 inca; 231 232 if (scaled_ppm < 0) { 233 neg_adj = 1; 234 scaled_ppm = -scaled_ppm; 235 } 236 rate = scaled_ppm; 237 rate <<= 13; 238 rate = div_u64(rate, 15625); 239 240 inca = rate & INCVALUE_MASK; 241 if (neg_adj) 242 inca |= ISGN; 243 244 wr32(E1000_TIMINCA, inca); 245 246 return 0; 247 } 248 249 static int igb_ptp_adjtime_82576(struct ptp_clock_info *ptp, s64 delta) 250 { 251 struct igb_adapter *igb = container_of(ptp, struct igb_adapter, 252 ptp_caps); 253 unsigned long flags; 254 255 spin_lock_irqsave(&igb->tmreg_lock, flags); 256 timecounter_adjtime(&igb->tc, delta); 257 spin_unlock_irqrestore(&igb->tmreg_lock, flags); 258 259 return 0; 260 } 261 262 static int igb_ptp_adjtime_i210(struct ptp_clock_info *ptp, s64 delta) 263 { 264 struct igb_adapter *igb = container_of(ptp, struct igb_adapter, 265 ptp_caps); 266 unsigned long flags; 267 struct timespec64 now, then = ns_to_timespec64(delta); 268 269 spin_lock_irqsave(&igb->tmreg_lock, flags); 270 271 igb_ptp_read_i210(igb, &now); 272 now = timespec64_add(now, then); 273 igb_ptp_write_i210(igb, (const struct timespec64 *)&now); 274 275 spin_unlock_irqrestore(&igb->tmreg_lock, flags); 276 277 return 0; 278 } 279 280 static int igb_ptp_gettimex_82576(struct ptp_clock_info *ptp, 281 struct timespec64 *ts, 282 struct ptp_system_timestamp *sts) 283 { 284 struct igb_adapter *igb = container_of(ptp, struct igb_adapter, 285 ptp_caps); 286 struct e1000_hw *hw = &igb->hw; 287 unsigned long flags; 288 u32 lo, hi; 289 u64 ns; 290 291 spin_lock_irqsave(&igb->tmreg_lock, flags); 292 293 ptp_read_system_prets(sts); 294 lo = rd32(E1000_SYSTIML); 295 ptp_read_system_postts(sts); 296 hi = rd32(E1000_SYSTIMH); 297 298 ns = timecounter_cyc2time(&igb->tc, ((u64)hi << 32) | lo); 299 300 spin_unlock_irqrestore(&igb->tmreg_lock, flags); 301 302 *ts = ns_to_timespec64(ns); 303 304 return 0; 305 } 306 307 static int igb_ptp_gettimex_82580(struct ptp_clock_info *ptp, 308 struct timespec64 *ts, 309 struct ptp_system_timestamp *sts) 310 { 311 struct igb_adapter *igb = container_of(ptp, struct igb_adapter, 312 ptp_caps); 313 struct e1000_hw *hw = &igb->hw; 314 unsigned long flags; 315 u32 lo, hi; 316 u64 ns; 317 318 spin_lock_irqsave(&igb->tmreg_lock, flags); 319 320 ptp_read_system_prets(sts); 321 rd32(E1000_SYSTIMR); 322 ptp_read_system_postts(sts); 323 lo = rd32(E1000_SYSTIML); 324 hi = rd32(E1000_SYSTIMH); 325 326 ns = timecounter_cyc2time(&igb->tc, ((u64)hi << 32) | lo); 327 328 spin_unlock_irqrestore(&igb->tmreg_lock, flags); 329 330 *ts = ns_to_timespec64(ns); 331 332 return 0; 333 } 334 335 static int igb_ptp_gettimex_i210(struct ptp_clock_info *ptp, 336 struct timespec64 *ts, 337 struct ptp_system_timestamp *sts) 338 { 339 struct igb_adapter *igb = container_of(ptp, struct igb_adapter, 340 ptp_caps); 341 struct e1000_hw *hw = &igb->hw; 342 unsigned long flags; 343 344 spin_lock_irqsave(&igb->tmreg_lock, flags); 345 346 ptp_read_system_prets(sts); 347 rd32(E1000_SYSTIMR); 348 ptp_read_system_postts(sts); 349 ts->tv_nsec = rd32(E1000_SYSTIML); 350 ts->tv_sec = rd32(E1000_SYSTIMH); 351 352 spin_unlock_irqrestore(&igb->tmreg_lock, flags); 353 354 return 0; 355 } 356 357 static int igb_ptp_settime_82576(struct ptp_clock_info *ptp, 358 const struct timespec64 *ts) 359 { 360 struct igb_adapter *igb = container_of(ptp, struct igb_adapter, 361 ptp_caps); 362 unsigned long flags; 363 u64 ns; 364 365 ns = timespec64_to_ns(ts); 366 367 spin_lock_irqsave(&igb->tmreg_lock, flags); 368 369 timecounter_init(&igb->tc, &igb->cc, ns); 370 371 spin_unlock_irqrestore(&igb->tmreg_lock, flags); 372 373 return 0; 374 } 375 376 static int igb_ptp_settime_i210(struct ptp_clock_info *ptp, 377 const struct timespec64 *ts) 378 { 379 struct igb_adapter *igb = container_of(ptp, struct igb_adapter, 380 ptp_caps); 381 unsigned long flags; 382 383 spin_lock_irqsave(&igb->tmreg_lock, flags); 384 385 igb_ptp_write_i210(igb, ts); 386 387 spin_unlock_irqrestore(&igb->tmreg_lock, flags); 388 389 return 0; 390 } 391 392 static void igb_pin_direction(int pin, int input, u32 *ctrl, u32 *ctrl_ext) 393 { 394 u32 *ptr = pin < 2 ? ctrl : ctrl_ext; 395 static const u32 mask[IGB_N_SDP] = { 396 E1000_CTRL_SDP0_DIR, 397 E1000_CTRL_SDP1_DIR, 398 E1000_CTRL_EXT_SDP2_DIR, 399 E1000_CTRL_EXT_SDP3_DIR, 400 }; 401 402 if (input) 403 *ptr &= ~mask[pin]; 404 else 405 *ptr |= mask[pin]; 406 } 407 408 static void igb_pin_extts(struct igb_adapter *igb, int chan, int pin) 409 { 410 static const u32 aux0_sel_sdp[IGB_N_SDP] = { 411 AUX0_SEL_SDP0, AUX0_SEL_SDP1, AUX0_SEL_SDP2, AUX0_SEL_SDP3, 412 }; 413 static const u32 aux1_sel_sdp[IGB_N_SDP] = { 414 AUX1_SEL_SDP0, AUX1_SEL_SDP1, AUX1_SEL_SDP2, AUX1_SEL_SDP3, 415 }; 416 static const u32 ts_sdp_en[IGB_N_SDP] = { 417 TS_SDP0_EN, TS_SDP1_EN, TS_SDP2_EN, TS_SDP3_EN, 418 }; 419 struct e1000_hw *hw = &igb->hw; 420 u32 ctrl, ctrl_ext, tssdp = 0; 421 422 ctrl = rd32(E1000_CTRL); 423 ctrl_ext = rd32(E1000_CTRL_EXT); 424 tssdp = rd32(E1000_TSSDP); 425 426 igb_pin_direction(pin, 1, &ctrl, &ctrl_ext); 427 428 /* Make sure this pin is not enabled as an output. */ 429 tssdp &= ~ts_sdp_en[pin]; 430 431 if (chan == 1) { 432 tssdp &= ~AUX1_SEL_SDP3; 433 tssdp |= aux1_sel_sdp[pin] | AUX1_TS_SDP_EN; 434 } else { 435 tssdp &= ~AUX0_SEL_SDP3; 436 tssdp |= aux0_sel_sdp[pin] | AUX0_TS_SDP_EN; 437 } 438 439 wr32(E1000_TSSDP, tssdp); 440 wr32(E1000_CTRL, ctrl); 441 wr32(E1000_CTRL_EXT, ctrl_ext); 442 } 443 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 AUX0_SEL_SDP0, AUX0_SEL_SDP1, AUX0_SEL_SDP2, AUX0_SEL_SDP3, 448 }; 449 static const u32 aux1_sel_sdp[IGB_N_SDP] = { 450 AUX1_SEL_SDP0, AUX1_SEL_SDP1, AUX1_SEL_SDP2, AUX1_SEL_SDP3, 451 }; 452 static const u32 ts_sdp_en[IGB_N_SDP] = { 453 TS_SDP0_EN, TS_SDP1_EN, TS_SDP2_EN, TS_SDP3_EN, 454 }; 455 static const u32 ts_sdp_sel_tt0[IGB_N_SDP] = { 456 TS_SDP0_SEL_TT0, TS_SDP1_SEL_TT0, 457 TS_SDP2_SEL_TT0, TS_SDP3_SEL_TT0, 458 }; 459 static const u32 ts_sdp_sel_tt1[IGB_N_SDP] = { 460 TS_SDP0_SEL_TT1, TS_SDP1_SEL_TT1, 461 TS_SDP2_SEL_TT1, TS_SDP3_SEL_TT1, 462 }; 463 static const u32 ts_sdp_sel_fc0[IGB_N_SDP] = { 464 TS_SDP0_SEL_FC0, TS_SDP1_SEL_FC0, 465 TS_SDP2_SEL_FC0, TS_SDP3_SEL_FC0, 466 }; 467 static const u32 ts_sdp_sel_fc1[IGB_N_SDP] = { 468 TS_SDP0_SEL_FC1, TS_SDP1_SEL_FC1, 469 TS_SDP2_SEL_FC1, TS_SDP3_SEL_FC1, 470 }; 471 static const u32 ts_sdp_sel_clr[IGB_N_SDP] = { 472 TS_SDP0_SEL_FC1, TS_SDP1_SEL_FC1, 473 TS_SDP2_SEL_FC1, TS_SDP3_SEL_FC1, 474 }; 475 struct e1000_hw *hw = &igb->hw; 476 u32 ctrl, ctrl_ext, tssdp = 0; 477 478 ctrl = rd32(E1000_CTRL); 479 ctrl_ext = rd32(E1000_CTRL_EXT); 480 tssdp = rd32(E1000_TSSDP); 481 482 igb_pin_direction(pin, 0, &ctrl, &ctrl_ext); 483 484 /* Make sure this pin is not enabled as an input. */ 485 if ((tssdp & AUX0_SEL_SDP3) == aux0_sel_sdp[pin]) 486 tssdp &= ~AUX0_TS_SDP_EN; 487 488 if ((tssdp & AUX1_SEL_SDP3) == aux1_sel_sdp[pin]) 489 tssdp &= ~AUX1_TS_SDP_EN; 490 491 tssdp &= ~ts_sdp_sel_clr[pin]; 492 if (freq) { 493 if (chan == 1) 494 tssdp |= ts_sdp_sel_fc1[pin]; 495 else 496 tssdp |= ts_sdp_sel_fc0[pin]; 497 } else { 498 if (chan == 1) 499 tssdp |= ts_sdp_sel_tt1[pin]; 500 else 501 tssdp |= ts_sdp_sel_tt0[pin]; 502 } 503 tssdp |= ts_sdp_en[pin]; 504 505 wr32(E1000_TSSDP, tssdp); 506 wr32(E1000_CTRL, ctrl); 507 wr32(E1000_CTRL_EXT, ctrl_ext); 508 } 509 510 static int igb_ptp_feature_enable_i210(struct ptp_clock_info *ptp, 511 struct ptp_clock_request *rq, int on) 512 { 513 struct igb_adapter *igb = 514 container_of(ptp, struct igb_adapter, ptp_caps); 515 struct e1000_hw *hw = &igb->hw; 516 u32 tsauxc, tsim, tsauxc_mask, tsim_mask, trgttiml, trgttimh, freqout; 517 unsigned long flags; 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 if (on) { 525 pin = ptp_find_pin(igb->ptp_clock, PTP_PF_EXTTS, 526 rq->extts.index); 527 if (pin < 0) 528 return -EBUSY; 529 } 530 if (rq->extts.index == 1) { 531 tsauxc_mask = TSAUXC_EN_TS1; 532 tsim_mask = TSINTR_AUTT1; 533 } else { 534 tsauxc_mask = TSAUXC_EN_TS0; 535 tsim_mask = TSINTR_AUTT0; 536 } 537 spin_lock_irqsave(&igb->tmreg_lock, flags); 538 tsauxc = rd32(E1000_TSAUXC); 539 tsim = rd32(E1000_TSIM); 540 if (on) { 541 igb_pin_extts(igb, rq->extts.index, pin); 542 tsauxc |= tsauxc_mask; 543 tsim |= tsim_mask; 544 } else { 545 tsauxc &= ~tsauxc_mask; 546 tsim &= ~tsim_mask; 547 } 548 wr32(E1000_TSAUXC, tsauxc); 549 wr32(E1000_TSIM, tsim); 550 spin_unlock_irqrestore(&igb->tmreg_lock, flags); 551 return 0; 552 553 case PTP_CLK_REQ_PEROUT: 554 /* Reject requests with unsupported flags */ 555 if (rq->perout.flags) 556 return -EOPNOTSUPP; 557 558 if (on) { 559 pin = ptp_find_pin(igb->ptp_clock, PTP_PF_PEROUT, 560 rq->perout.index); 561 if (pin < 0) 562 return -EBUSY; 563 } 564 ts.tv_sec = rq->perout.period.sec; 565 ts.tv_nsec = rq->perout.period.nsec; 566 ns = timespec64_to_ns(&ts); 567 ns = ns >> 1; 568 if (on && ((ns <= 70000000LL) || (ns == 125000000LL) || 569 (ns == 250000000LL) || (ns == 500000000LL))) { 570 if (ns < 8LL) 571 return -EINVAL; 572 use_freq = 1; 573 } 574 ts = ns_to_timespec64(ns); 575 if (rq->perout.index == 1) { 576 if (use_freq) { 577 tsauxc_mask = TSAUXC_EN_CLK1 | TSAUXC_ST1; 578 tsim_mask = 0; 579 } else { 580 tsauxc_mask = TSAUXC_EN_TT1; 581 tsim_mask = TSINTR_TT1; 582 } 583 trgttiml = E1000_TRGTTIML1; 584 trgttimh = E1000_TRGTTIMH1; 585 freqout = E1000_FREQOUT1; 586 } else { 587 if (use_freq) { 588 tsauxc_mask = TSAUXC_EN_CLK0 | TSAUXC_ST0; 589 tsim_mask = 0; 590 } else { 591 tsauxc_mask = TSAUXC_EN_TT0; 592 tsim_mask = TSINTR_TT0; 593 } 594 trgttiml = E1000_TRGTTIML0; 595 trgttimh = E1000_TRGTTIMH0; 596 freqout = E1000_FREQOUT0; 597 } 598 spin_lock_irqsave(&igb->tmreg_lock, flags); 599 tsauxc = rd32(E1000_TSAUXC); 600 tsim = rd32(E1000_TSIM); 601 if (rq->perout.index == 1) { 602 tsauxc &= ~(TSAUXC_EN_TT1 | TSAUXC_EN_CLK1 | TSAUXC_ST1); 603 tsim &= ~TSINTR_TT1; 604 } else { 605 tsauxc &= ~(TSAUXC_EN_TT0 | TSAUXC_EN_CLK0 | TSAUXC_ST0); 606 tsim &= ~TSINTR_TT0; 607 } 608 if (on) { 609 int i = rq->perout.index; 610 igb_pin_perout(igb, i, pin, use_freq); 611 igb->perout[i].start.tv_sec = rq->perout.start.sec; 612 igb->perout[i].start.tv_nsec = rq->perout.start.nsec; 613 igb->perout[i].period.tv_sec = ts.tv_sec; 614 igb->perout[i].period.tv_nsec = ts.tv_nsec; 615 wr32(trgttimh, rq->perout.start.sec); 616 wr32(trgttiml, rq->perout.start.nsec); 617 if (use_freq) 618 wr32(freqout, ns); 619 tsauxc |= tsauxc_mask; 620 tsim |= tsim_mask; 621 } 622 wr32(E1000_TSAUXC, tsauxc); 623 wr32(E1000_TSIM, tsim); 624 spin_unlock_irqrestore(&igb->tmreg_lock, flags); 625 return 0; 626 627 case PTP_CLK_REQ_PPS: 628 spin_lock_irqsave(&igb->tmreg_lock, flags); 629 tsim = rd32(E1000_TSIM); 630 if (on) 631 tsim |= TSINTR_SYS_WRAP; 632 else 633 tsim &= ~TSINTR_SYS_WRAP; 634 igb->pps_sys_wrap_on = !!on; 635 wr32(E1000_TSIM, tsim); 636 spin_unlock_irqrestore(&igb->tmreg_lock, flags); 637 return 0; 638 } 639 640 return -EOPNOTSUPP; 641 } 642 643 static int igb_ptp_feature_enable(struct ptp_clock_info *ptp, 644 struct ptp_clock_request *rq, int on) 645 { 646 return -EOPNOTSUPP; 647 } 648 649 static int igb_ptp_verify_pin(struct ptp_clock_info *ptp, unsigned int pin, 650 enum ptp_pin_function func, unsigned int chan) 651 { 652 switch (func) { 653 case PTP_PF_NONE: 654 case PTP_PF_EXTTS: 655 case PTP_PF_PEROUT: 656 break; 657 case PTP_PF_PHYSYNC: 658 return -1; 659 } 660 return 0; 661 } 662 663 /** 664 * igb_ptp_tx_work 665 * @work: pointer to work struct 666 * 667 * This work function polls the TSYNCTXCTL valid bit to determine when a 668 * timestamp has been taken for the current stored skb. 669 **/ 670 static void igb_ptp_tx_work(struct work_struct *work) 671 { 672 struct igb_adapter *adapter = container_of(work, struct igb_adapter, 673 ptp_tx_work); 674 struct e1000_hw *hw = &adapter->hw; 675 u32 tsynctxctl; 676 677 if (!adapter->ptp_tx_skb) 678 return; 679 680 if (time_is_before_jiffies(adapter->ptp_tx_start + 681 IGB_PTP_TX_TIMEOUT)) { 682 dev_kfree_skb_any(adapter->ptp_tx_skb); 683 adapter->ptp_tx_skb = NULL; 684 clear_bit_unlock(__IGB_PTP_TX_IN_PROGRESS, &adapter->state); 685 adapter->tx_hwtstamp_timeouts++; 686 /* Clear the tx valid bit in TSYNCTXCTL register to enable 687 * interrupt 688 */ 689 rd32(E1000_TXSTMPH); 690 dev_warn(&adapter->pdev->dev, "clearing Tx timestamp hang\n"); 691 return; 692 } 693 694 tsynctxctl = rd32(E1000_TSYNCTXCTL); 695 if (tsynctxctl & E1000_TSYNCTXCTL_VALID) 696 igb_ptp_tx_hwtstamp(adapter); 697 else 698 /* reschedule to check later */ 699 schedule_work(&adapter->ptp_tx_work); 700 } 701 702 static void igb_ptp_overflow_check(struct work_struct *work) 703 { 704 struct igb_adapter *igb = 705 container_of(work, struct igb_adapter, ptp_overflow_work.work); 706 struct timespec64 ts; 707 u64 ns; 708 709 /* Update the timecounter */ 710 ns = timecounter_read(&igb->tc); 711 712 ts = ns_to_timespec64(ns); 713 pr_debug("igb overflow check at %lld.%09lu\n", 714 (long long) ts.tv_sec, ts.tv_nsec); 715 716 schedule_delayed_work(&igb->ptp_overflow_work, 717 IGB_SYSTIM_OVERFLOW_PERIOD); 718 } 719 720 /** 721 * igb_ptp_rx_hang - detect error case when Rx timestamp registers latched 722 * @adapter: private network adapter structure 723 * 724 * This watchdog task is scheduled to detect error case where hardware has 725 * dropped an Rx packet that was timestamped when the ring is full. The 726 * particular error is rare but leaves the device in a state unable to timestamp 727 * any future packets. 728 **/ 729 void igb_ptp_rx_hang(struct igb_adapter *adapter) 730 { 731 struct e1000_hw *hw = &adapter->hw; 732 u32 tsyncrxctl = rd32(E1000_TSYNCRXCTL); 733 unsigned long rx_event; 734 735 /* Other hardware uses per-packet timestamps */ 736 if (hw->mac.type != e1000_82576) 737 return; 738 739 /* If we don't have a valid timestamp in the registers, just update the 740 * timeout counter and exit 741 */ 742 if (!(tsyncrxctl & E1000_TSYNCRXCTL_VALID)) { 743 adapter->last_rx_ptp_check = jiffies; 744 return; 745 } 746 747 /* Determine the most recent watchdog or rx_timestamp event */ 748 rx_event = adapter->last_rx_ptp_check; 749 if (time_after(adapter->last_rx_timestamp, rx_event)) 750 rx_event = adapter->last_rx_timestamp; 751 752 /* Only need to read the high RXSTMP register to clear the lock */ 753 if (time_is_before_jiffies(rx_event + 5 * HZ)) { 754 rd32(E1000_RXSTMPH); 755 adapter->last_rx_ptp_check = jiffies; 756 adapter->rx_hwtstamp_cleared++; 757 dev_warn(&adapter->pdev->dev, "clearing Rx timestamp hang\n"); 758 } 759 } 760 761 /** 762 * igb_ptp_tx_hang - detect error case where Tx timestamp never finishes 763 * @adapter: private network adapter structure 764 */ 765 void igb_ptp_tx_hang(struct igb_adapter *adapter) 766 { 767 struct e1000_hw *hw = &adapter->hw; 768 bool timeout = time_is_before_jiffies(adapter->ptp_tx_start + 769 IGB_PTP_TX_TIMEOUT); 770 771 if (!adapter->ptp_tx_skb) 772 return; 773 774 if (!test_bit(__IGB_PTP_TX_IN_PROGRESS, &adapter->state)) 775 return; 776 777 /* If we haven't received a timestamp within the timeout, it is 778 * reasonable to assume that it will never occur, so we can unlock the 779 * timestamp bit when this occurs. 780 */ 781 if (timeout) { 782 cancel_work_sync(&adapter->ptp_tx_work); 783 dev_kfree_skb_any(adapter->ptp_tx_skb); 784 adapter->ptp_tx_skb = NULL; 785 clear_bit_unlock(__IGB_PTP_TX_IN_PROGRESS, &adapter->state); 786 adapter->tx_hwtstamp_timeouts++; 787 /* Clear the tx valid bit in TSYNCTXCTL register to enable 788 * interrupt 789 */ 790 rd32(E1000_TXSTMPH); 791 dev_warn(&adapter->pdev->dev, "clearing Tx timestamp hang\n"); 792 } 793 } 794 795 /** 796 * igb_ptp_tx_hwtstamp - utility function which checks for TX time stamp 797 * @adapter: Board private structure. 798 * 799 * If we were asked to do hardware stamping and such a time stamp is 800 * available, then it must have been for this skb here because we only 801 * allow only one such packet into the queue. 802 **/ 803 static void igb_ptp_tx_hwtstamp(struct igb_adapter *adapter) 804 { 805 struct sk_buff *skb = adapter->ptp_tx_skb; 806 struct e1000_hw *hw = &adapter->hw; 807 struct skb_shared_hwtstamps shhwtstamps; 808 u64 regval; 809 int adjust = 0; 810 811 regval = rd32(E1000_TXSTMPL); 812 regval |= (u64)rd32(E1000_TXSTMPH) << 32; 813 814 igb_ptp_systim_to_hwtstamp(adapter, &shhwtstamps, regval); 815 /* adjust timestamp for the TX latency based on link speed */ 816 if (adapter->hw.mac.type == e1000_i210) { 817 switch (adapter->link_speed) { 818 case SPEED_10: 819 adjust = IGB_I210_TX_LATENCY_10; 820 break; 821 case SPEED_100: 822 adjust = IGB_I210_TX_LATENCY_100; 823 break; 824 case SPEED_1000: 825 adjust = IGB_I210_TX_LATENCY_1000; 826 break; 827 } 828 } 829 830 shhwtstamps.hwtstamp = 831 ktime_add_ns(shhwtstamps.hwtstamp, adjust); 832 833 /* Clear the lock early before calling skb_tstamp_tx so that 834 * applications are not woken up before the lock bit is clear. We use 835 * a copy of the skb pointer to ensure other threads can't change it 836 * while we're notifying the stack. 837 */ 838 adapter->ptp_tx_skb = NULL; 839 clear_bit_unlock(__IGB_PTP_TX_IN_PROGRESS, &adapter->state); 840 841 /* Notify the stack and free the skb after we've unlocked */ 842 skb_tstamp_tx(skb, &shhwtstamps); 843 dev_kfree_skb_any(skb); 844 } 845 846 /** 847 * igb_ptp_rx_pktstamp - retrieve Rx per packet timestamp 848 * @q_vector: Pointer to interrupt specific structure 849 * @va: Pointer to address containing Rx buffer 850 * @skb: Buffer containing timestamp and packet 851 * 852 * This function is meant to retrieve a timestamp from the first buffer of an 853 * incoming frame. The value is stored in little endian format starting on 854 * byte 8. 855 **/ 856 void igb_ptp_rx_pktstamp(struct igb_q_vector *q_vector, void *va, 857 struct sk_buff *skb) 858 { 859 __le64 *regval = (__le64 *)va; 860 struct igb_adapter *adapter = q_vector->adapter; 861 int adjust = 0; 862 863 /* The timestamp is recorded in little endian format. 864 * DWORD: 0 1 2 3 865 * Field: Reserved Reserved SYSTIML SYSTIMH 866 */ 867 igb_ptp_systim_to_hwtstamp(adapter, skb_hwtstamps(skb), 868 le64_to_cpu(regval[1])); 869 870 /* adjust timestamp for the RX latency based on link speed */ 871 if (adapter->hw.mac.type == e1000_i210) { 872 switch (adapter->link_speed) { 873 case SPEED_10: 874 adjust = IGB_I210_RX_LATENCY_10; 875 break; 876 case SPEED_100: 877 adjust = IGB_I210_RX_LATENCY_100; 878 break; 879 case SPEED_1000: 880 adjust = IGB_I210_RX_LATENCY_1000; 881 break; 882 } 883 } 884 skb_hwtstamps(skb)->hwtstamp = 885 ktime_sub_ns(skb_hwtstamps(skb)->hwtstamp, adjust); 886 } 887 888 /** 889 * igb_ptp_rx_rgtstamp - retrieve Rx timestamp stored in register 890 * @q_vector: Pointer to interrupt specific structure 891 * @skb: Buffer containing timestamp and packet 892 * 893 * This function is meant to retrieve a timestamp from the internal registers 894 * of the adapter and store it in the skb. 895 **/ 896 void igb_ptp_rx_rgtstamp(struct igb_q_vector *q_vector, 897 struct sk_buff *skb) 898 { 899 struct igb_adapter *adapter = q_vector->adapter; 900 struct e1000_hw *hw = &adapter->hw; 901 u64 regval; 902 int adjust = 0; 903 904 /* If this bit is set, then the RX registers contain the time stamp. No 905 * other packet will be time stamped until we read these registers, so 906 * read the registers to make them available again. Because only one 907 * packet can be time stamped at a time, we know that the register 908 * values must belong to this one here and therefore we don't need to 909 * compare any of the additional attributes stored for it. 910 * 911 * If nothing went wrong, then it should have a shared tx_flags that we 912 * can turn into a skb_shared_hwtstamps. 913 */ 914 if (!(rd32(E1000_TSYNCRXCTL) & E1000_TSYNCRXCTL_VALID)) 915 return; 916 917 regval = rd32(E1000_RXSTMPL); 918 regval |= (u64)rd32(E1000_RXSTMPH) << 32; 919 920 igb_ptp_systim_to_hwtstamp(adapter, skb_hwtstamps(skb), regval); 921 922 /* adjust timestamp for the RX latency based on link speed */ 923 if (adapter->hw.mac.type == e1000_i210) { 924 switch (adapter->link_speed) { 925 case SPEED_10: 926 adjust = IGB_I210_RX_LATENCY_10; 927 break; 928 case SPEED_100: 929 adjust = IGB_I210_RX_LATENCY_100; 930 break; 931 case SPEED_1000: 932 adjust = IGB_I210_RX_LATENCY_1000; 933 break; 934 } 935 } 936 skb_hwtstamps(skb)->hwtstamp = 937 ktime_sub_ns(skb_hwtstamps(skb)->hwtstamp, adjust); 938 939 /* Update the last_rx_timestamp timer in order to enable watchdog check 940 * for error case of latched timestamp on a dropped packet. 941 */ 942 adapter->last_rx_timestamp = jiffies; 943 } 944 945 /** 946 * igb_ptp_get_ts_config - get hardware time stamping config 947 * @netdev: 948 * @ifreq: 949 * 950 * Get the hwtstamp_config settings to return to the user. Rather than attempt 951 * to deconstruct the settings from the registers, just return a shadow copy 952 * of the last known settings. 953 **/ 954 int igb_ptp_get_ts_config(struct net_device *netdev, struct ifreq *ifr) 955 { 956 struct igb_adapter *adapter = netdev_priv(netdev); 957 struct hwtstamp_config *config = &adapter->tstamp_config; 958 959 return copy_to_user(ifr->ifr_data, config, sizeof(*config)) ? 960 -EFAULT : 0; 961 } 962 963 /** 964 * igb_ptp_set_timestamp_mode - setup hardware for timestamping 965 * @adapter: networking device structure 966 * @config: hwtstamp configuration 967 * 968 * Outgoing time stamping can be enabled and disabled. Play nice and 969 * disable it when requested, although it shouldn't case any overhead 970 * when no packet needs it. At most one packet in the queue may be 971 * marked for time stamping, otherwise it would be impossible to tell 972 * for sure to which packet the hardware time stamp belongs. 973 * 974 * Incoming time stamping has to be configured via the hardware 975 * filters. Not all combinations are supported, in particular event 976 * type has to be specified. Matching the kind of event packet is 977 * not supported, with the exception of "all V2 events regardless of 978 * level 2 or 4". 979 */ 980 static int igb_ptp_set_timestamp_mode(struct igb_adapter *adapter, 981 struct hwtstamp_config *config) 982 { 983 struct e1000_hw *hw = &adapter->hw; 984 u32 tsync_tx_ctl = E1000_TSYNCTXCTL_ENABLED; 985 u32 tsync_rx_ctl = E1000_TSYNCRXCTL_ENABLED; 986 u32 tsync_rx_cfg = 0; 987 bool is_l4 = false; 988 bool is_l2 = false; 989 u32 regval; 990 991 /* reserved for future extensions */ 992 if (config->flags) 993 return -EINVAL; 994 995 switch (config->tx_type) { 996 case HWTSTAMP_TX_OFF: 997 tsync_tx_ctl = 0; 998 case HWTSTAMP_TX_ON: 999 break; 1000 default: 1001 return -ERANGE; 1002 } 1003 1004 switch (config->rx_filter) { 1005 case HWTSTAMP_FILTER_NONE: 1006 tsync_rx_ctl = 0; 1007 break; 1008 case HWTSTAMP_FILTER_PTP_V1_L4_SYNC: 1009 tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_L4_V1; 1010 tsync_rx_cfg = E1000_TSYNCRXCFG_PTP_V1_SYNC_MESSAGE; 1011 is_l4 = true; 1012 break; 1013 case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ: 1014 tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_L4_V1; 1015 tsync_rx_cfg = E1000_TSYNCRXCFG_PTP_V1_DELAY_REQ_MESSAGE; 1016 is_l4 = true; 1017 break; 1018 case HWTSTAMP_FILTER_PTP_V2_EVENT: 1019 case HWTSTAMP_FILTER_PTP_V2_L2_EVENT: 1020 case HWTSTAMP_FILTER_PTP_V2_L4_EVENT: 1021 case HWTSTAMP_FILTER_PTP_V2_SYNC: 1022 case HWTSTAMP_FILTER_PTP_V2_L2_SYNC: 1023 case HWTSTAMP_FILTER_PTP_V2_L4_SYNC: 1024 case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ: 1025 case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ: 1026 case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ: 1027 tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_EVENT_V2; 1028 config->rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT; 1029 is_l2 = true; 1030 is_l4 = true; 1031 break; 1032 case HWTSTAMP_FILTER_PTP_V1_L4_EVENT: 1033 case HWTSTAMP_FILTER_NTP_ALL: 1034 case HWTSTAMP_FILTER_ALL: 1035 /* 82576 cannot timestamp all packets, which it needs to do to 1036 * support both V1 Sync and Delay_Req messages 1037 */ 1038 if (hw->mac.type != e1000_82576) { 1039 tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_ALL; 1040 config->rx_filter = HWTSTAMP_FILTER_ALL; 1041 break; 1042 } 1043 /* fall through */ 1044 default: 1045 config->rx_filter = HWTSTAMP_FILTER_NONE; 1046 return -ERANGE; 1047 } 1048 1049 if (hw->mac.type == e1000_82575) { 1050 if (tsync_rx_ctl | tsync_tx_ctl) 1051 return -EINVAL; 1052 return 0; 1053 } 1054 1055 /* Per-packet timestamping only works if all packets are 1056 * timestamped, so enable timestamping in all packets as 1057 * long as one Rx filter was configured. 1058 */ 1059 if ((hw->mac.type >= e1000_82580) && tsync_rx_ctl) { 1060 tsync_rx_ctl = E1000_TSYNCRXCTL_ENABLED; 1061 tsync_rx_ctl |= E1000_TSYNCRXCTL_TYPE_ALL; 1062 config->rx_filter = HWTSTAMP_FILTER_ALL; 1063 is_l2 = true; 1064 is_l4 = true; 1065 1066 if ((hw->mac.type == e1000_i210) || 1067 (hw->mac.type == e1000_i211)) { 1068 regval = rd32(E1000_RXPBS); 1069 regval |= E1000_RXPBS_CFG_TS_EN; 1070 wr32(E1000_RXPBS, regval); 1071 } 1072 } 1073 1074 /* enable/disable TX */ 1075 regval = rd32(E1000_TSYNCTXCTL); 1076 regval &= ~E1000_TSYNCTXCTL_ENABLED; 1077 regval |= tsync_tx_ctl; 1078 wr32(E1000_TSYNCTXCTL, regval); 1079 1080 /* enable/disable RX */ 1081 regval = rd32(E1000_TSYNCRXCTL); 1082 regval &= ~(E1000_TSYNCRXCTL_ENABLED | E1000_TSYNCRXCTL_TYPE_MASK); 1083 regval |= tsync_rx_ctl; 1084 wr32(E1000_TSYNCRXCTL, regval); 1085 1086 /* define which PTP packets are time stamped */ 1087 wr32(E1000_TSYNCRXCFG, tsync_rx_cfg); 1088 1089 /* define ethertype filter for timestamped packets */ 1090 if (is_l2) 1091 wr32(E1000_ETQF(IGB_ETQF_FILTER_1588), 1092 (E1000_ETQF_FILTER_ENABLE | /* enable filter */ 1093 E1000_ETQF_1588 | /* enable timestamping */ 1094 ETH_P_1588)); /* 1588 eth protocol type */ 1095 else 1096 wr32(E1000_ETQF(IGB_ETQF_FILTER_1588), 0); 1097 1098 /* L4 Queue Filter[3]: filter by destination port and protocol */ 1099 if (is_l4) { 1100 u32 ftqf = (IPPROTO_UDP /* UDP */ 1101 | E1000_FTQF_VF_BP /* VF not compared */ 1102 | E1000_FTQF_1588_TIME_STAMP /* Enable Timestamping */ 1103 | E1000_FTQF_MASK); /* mask all inputs */ 1104 ftqf &= ~E1000_FTQF_MASK_PROTO_BP; /* enable protocol check */ 1105 1106 wr32(E1000_IMIR(3), htons(PTP_EV_PORT)); 1107 wr32(E1000_IMIREXT(3), 1108 (E1000_IMIREXT_SIZE_BP | E1000_IMIREXT_CTRL_BP)); 1109 if (hw->mac.type == e1000_82576) { 1110 /* enable source port check */ 1111 wr32(E1000_SPQF(3), htons(PTP_EV_PORT)); 1112 ftqf &= ~E1000_FTQF_MASK_SOURCE_PORT_BP; 1113 } 1114 wr32(E1000_FTQF(3), ftqf); 1115 } else { 1116 wr32(E1000_FTQF(3), E1000_FTQF_MASK); 1117 } 1118 wrfl(); 1119 1120 /* clear TX/RX time stamp registers, just to be sure */ 1121 regval = rd32(E1000_TXSTMPL); 1122 regval = rd32(E1000_TXSTMPH); 1123 regval = rd32(E1000_RXSTMPL); 1124 regval = rd32(E1000_RXSTMPH); 1125 1126 return 0; 1127 } 1128 1129 /** 1130 * igb_ptp_set_ts_config - set hardware time stamping config 1131 * @netdev: 1132 * @ifreq: 1133 * 1134 **/ 1135 int igb_ptp_set_ts_config(struct net_device *netdev, struct ifreq *ifr) 1136 { 1137 struct igb_adapter *adapter = netdev_priv(netdev); 1138 struct hwtstamp_config config; 1139 int err; 1140 1141 if (copy_from_user(&config, ifr->ifr_data, sizeof(config))) 1142 return -EFAULT; 1143 1144 err = igb_ptp_set_timestamp_mode(adapter, &config); 1145 if (err) 1146 return err; 1147 1148 /* save these settings for future reference */ 1149 memcpy(&adapter->tstamp_config, &config, 1150 sizeof(adapter->tstamp_config)); 1151 1152 return copy_to_user(ifr->ifr_data, &config, sizeof(config)) ? 1153 -EFAULT : 0; 1154 } 1155 1156 /** 1157 * igb_ptp_init - Initialize PTP functionality 1158 * @adapter: Board private structure 1159 * 1160 * This function is called at device probe to initialize the PTP 1161 * functionality. 1162 */ 1163 void igb_ptp_init(struct igb_adapter *adapter) 1164 { 1165 struct e1000_hw *hw = &adapter->hw; 1166 struct net_device *netdev = adapter->netdev; 1167 int i; 1168 1169 switch (hw->mac.type) { 1170 case e1000_82576: 1171 snprintf(adapter->ptp_caps.name, 16, "%pm", netdev->dev_addr); 1172 adapter->ptp_caps.owner = THIS_MODULE; 1173 adapter->ptp_caps.max_adj = 999999881; 1174 adapter->ptp_caps.n_ext_ts = 0; 1175 adapter->ptp_caps.pps = 0; 1176 adapter->ptp_caps.adjfreq = igb_ptp_adjfreq_82576; 1177 adapter->ptp_caps.adjtime = igb_ptp_adjtime_82576; 1178 adapter->ptp_caps.gettimex64 = igb_ptp_gettimex_82576; 1179 adapter->ptp_caps.settime64 = igb_ptp_settime_82576; 1180 adapter->ptp_caps.enable = igb_ptp_feature_enable; 1181 adapter->cc.read = igb_ptp_read_82576; 1182 adapter->cc.mask = CYCLECOUNTER_MASK(64); 1183 adapter->cc.mult = 1; 1184 adapter->cc.shift = IGB_82576_TSYNC_SHIFT; 1185 adapter->ptp_flags |= IGB_PTP_OVERFLOW_CHECK; 1186 break; 1187 case e1000_82580: 1188 case e1000_i354: 1189 case e1000_i350: 1190 snprintf(adapter->ptp_caps.name, 16, "%pm", netdev->dev_addr); 1191 adapter->ptp_caps.owner = THIS_MODULE; 1192 adapter->ptp_caps.max_adj = 62499999; 1193 adapter->ptp_caps.n_ext_ts = 0; 1194 adapter->ptp_caps.pps = 0; 1195 adapter->ptp_caps.adjfine = igb_ptp_adjfine_82580; 1196 adapter->ptp_caps.adjtime = igb_ptp_adjtime_82576; 1197 adapter->ptp_caps.gettimex64 = igb_ptp_gettimex_82580; 1198 adapter->ptp_caps.settime64 = igb_ptp_settime_82576; 1199 adapter->ptp_caps.enable = igb_ptp_feature_enable; 1200 adapter->cc.read = igb_ptp_read_82580; 1201 adapter->cc.mask = CYCLECOUNTER_MASK(IGB_NBITS_82580); 1202 adapter->cc.mult = 1; 1203 adapter->cc.shift = 0; 1204 adapter->ptp_flags |= IGB_PTP_OVERFLOW_CHECK; 1205 break; 1206 case e1000_i210: 1207 case e1000_i211: 1208 for (i = 0; i < IGB_N_SDP; i++) { 1209 struct ptp_pin_desc *ppd = &adapter->sdp_config[i]; 1210 1211 snprintf(ppd->name, sizeof(ppd->name), "SDP%d", i); 1212 ppd->index = i; 1213 ppd->func = PTP_PF_NONE; 1214 } 1215 snprintf(adapter->ptp_caps.name, 16, "%pm", netdev->dev_addr); 1216 adapter->ptp_caps.owner = THIS_MODULE; 1217 adapter->ptp_caps.max_adj = 62499999; 1218 adapter->ptp_caps.n_ext_ts = IGB_N_EXTTS; 1219 adapter->ptp_caps.n_per_out = IGB_N_PEROUT; 1220 adapter->ptp_caps.n_pins = IGB_N_SDP; 1221 adapter->ptp_caps.pps = 1; 1222 adapter->ptp_caps.pin_config = adapter->sdp_config; 1223 adapter->ptp_caps.adjfine = igb_ptp_adjfine_82580; 1224 adapter->ptp_caps.adjtime = igb_ptp_adjtime_i210; 1225 adapter->ptp_caps.gettimex64 = igb_ptp_gettimex_i210; 1226 adapter->ptp_caps.settime64 = igb_ptp_settime_i210; 1227 adapter->ptp_caps.enable = igb_ptp_feature_enable_i210; 1228 adapter->ptp_caps.verify = igb_ptp_verify_pin; 1229 break; 1230 default: 1231 adapter->ptp_clock = NULL; 1232 return; 1233 } 1234 1235 spin_lock_init(&adapter->tmreg_lock); 1236 INIT_WORK(&adapter->ptp_tx_work, igb_ptp_tx_work); 1237 1238 if (adapter->ptp_flags & IGB_PTP_OVERFLOW_CHECK) 1239 INIT_DELAYED_WORK(&adapter->ptp_overflow_work, 1240 igb_ptp_overflow_check); 1241 1242 adapter->tstamp_config.rx_filter = HWTSTAMP_FILTER_NONE; 1243 adapter->tstamp_config.tx_type = HWTSTAMP_TX_OFF; 1244 1245 igb_ptp_reset(adapter); 1246 1247 adapter->ptp_clock = ptp_clock_register(&adapter->ptp_caps, 1248 &adapter->pdev->dev); 1249 if (IS_ERR(adapter->ptp_clock)) { 1250 adapter->ptp_clock = NULL; 1251 dev_err(&adapter->pdev->dev, "ptp_clock_register failed\n"); 1252 } else if (adapter->ptp_clock) { 1253 dev_info(&adapter->pdev->dev, "added PHC on %s\n", 1254 adapter->netdev->name); 1255 adapter->ptp_flags |= IGB_PTP_ENABLED; 1256 } 1257 } 1258 1259 /** 1260 * igb_ptp_suspend - Disable PTP work items and prepare for suspend 1261 * @adapter: Board private structure 1262 * 1263 * This function stops the overflow check work and PTP Tx timestamp work, and 1264 * will prepare the device for OS suspend. 1265 */ 1266 void igb_ptp_suspend(struct igb_adapter *adapter) 1267 { 1268 if (!(adapter->ptp_flags & IGB_PTP_ENABLED)) 1269 return; 1270 1271 if (adapter->ptp_flags & IGB_PTP_OVERFLOW_CHECK) 1272 cancel_delayed_work_sync(&adapter->ptp_overflow_work); 1273 1274 cancel_work_sync(&adapter->ptp_tx_work); 1275 if (adapter->ptp_tx_skb) { 1276 dev_kfree_skb_any(adapter->ptp_tx_skb); 1277 adapter->ptp_tx_skb = NULL; 1278 clear_bit_unlock(__IGB_PTP_TX_IN_PROGRESS, &adapter->state); 1279 } 1280 } 1281 1282 /** 1283 * igb_ptp_stop - Disable PTP device and stop the overflow check. 1284 * @adapter: Board private structure. 1285 * 1286 * This function stops the PTP support and cancels the delayed work. 1287 **/ 1288 void igb_ptp_stop(struct igb_adapter *adapter) 1289 { 1290 igb_ptp_suspend(adapter); 1291 1292 if (adapter->ptp_clock) { 1293 ptp_clock_unregister(adapter->ptp_clock); 1294 dev_info(&adapter->pdev->dev, "removed PHC on %s\n", 1295 adapter->netdev->name); 1296 adapter->ptp_flags &= ~IGB_PTP_ENABLED; 1297 } 1298 } 1299 1300 /** 1301 * igb_ptp_reset - Re-enable the adapter for PTP following a reset. 1302 * @adapter: Board private structure. 1303 * 1304 * This function handles the reset work required to re-enable the PTP device. 1305 **/ 1306 void igb_ptp_reset(struct igb_adapter *adapter) 1307 { 1308 struct e1000_hw *hw = &adapter->hw; 1309 unsigned long flags; 1310 1311 /* reset the tstamp_config */ 1312 igb_ptp_set_timestamp_mode(adapter, &adapter->tstamp_config); 1313 1314 spin_lock_irqsave(&adapter->tmreg_lock, flags); 1315 1316 switch (adapter->hw.mac.type) { 1317 case e1000_82576: 1318 /* Dial the nominal frequency. */ 1319 wr32(E1000_TIMINCA, INCPERIOD_82576 | INCVALUE_82576); 1320 break; 1321 case e1000_82580: 1322 case e1000_i354: 1323 case e1000_i350: 1324 case e1000_i210: 1325 case e1000_i211: 1326 wr32(E1000_TSAUXC, 0x0); 1327 wr32(E1000_TSSDP, 0x0); 1328 wr32(E1000_TSIM, 1329 TSYNC_INTERRUPTS | 1330 (adapter->pps_sys_wrap_on ? TSINTR_SYS_WRAP : 0)); 1331 wr32(E1000_IMS, E1000_IMS_TS); 1332 break; 1333 default: 1334 /* No work to do. */ 1335 goto out; 1336 } 1337 1338 /* Re-initialize the timer. */ 1339 if ((hw->mac.type == e1000_i210) || (hw->mac.type == e1000_i211)) { 1340 struct timespec64 ts = ktime_to_timespec64(ktime_get_real()); 1341 1342 igb_ptp_write_i210(adapter, &ts); 1343 } else { 1344 timecounter_init(&adapter->tc, &adapter->cc, 1345 ktime_to_ns(ktime_get_real())); 1346 } 1347 out: 1348 spin_unlock_irqrestore(&adapter->tmreg_lock, flags); 1349 1350 wrfl(); 1351 1352 if (adapter->ptp_flags & IGB_PTP_OVERFLOW_CHECK) 1353 schedule_delayed_work(&adapter->ptp_overflow_work, 1354 IGB_SYSTIM_OVERFLOW_PERIOD); 1355 } 1356