1 /* SPDX-License-Identifier: GPL-2.0+ */ 2 /* Copyright (C) 2018 Microchip Technology Inc. */ 3 4 #include <linux/netdevice.h> 5 6 #include <linux/ptp_clock_kernel.h> 7 #include <linux/module.h> 8 #include <linux/pci.h> 9 #include <linux/net_tstamp.h> 10 #include "lan743x_main.h" 11 12 #include "lan743x_ptp.h" 13 14 #define LAN743X_LED0_ENABLE 20 /* LED0 offset in HW_CFG */ 15 #define LAN743X_LED_ENABLE(pin) BIT(LAN743X_LED0_ENABLE + (pin)) 16 17 #define LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB (31249999) 18 #define LAN743X_PTP_MAX_FINE_ADJ_IN_SCALED_PPM (2047999934) 19 20 static bool lan743x_ptp_is_enabled(struct lan743x_adapter *adapter); 21 static void lan743x_ptp_enable(struct lan743x_adapter *adapter); 22 static void lan743x_ptp_disable(struct lan743x_adapter *adapter); 23 static void lan743x_ptp_reset(struct lan743x_adapter *adapter); 24 static void lan743x_ptp_clock_set(struct lan743x_adapter *adapter, 25 u32 seconds, u32 nano_seconds, 26 u32 sub_nano_seconds); 27 28 int lan743x_gpio_init(struct lan743x_adapter *adapter) 29 { 30 struct lan743x_gpio *gpio = &adapter->gpio; 31 32 spin_lock_init(&gpio->gpio_lock); 33 34 gpio->gpio_cfg0 = 0; /* set all direction to input, data = 0 */ 35 gpio->gpio_cfg1 = 0x0FFF0000;/* disable all gpio, set to open drain */ 36 gpio->gpio_cfg2 = 0;/* set all to 1588 low polarity level */ 37 gpio->gpio_cfg3 = 0;/* disable all 1588 output */ 38 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0); 39 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1); 40 lan743x_csr_write(adapter, GPIO_CFG2, gpio->gpio_cfg2); 41 lan743x_csr_write(adapter, GPIO_CFG3, gpio->gpio_cfg3); 42 43 return 0; 44 } 45 46 static void lan743x_ptp_wait_till_cmd_done(struct lan743x_adapter *adapter, 47 u32 bit_mask) 48 { 49 int timeout = 1000; 50 u32 data = 0; 51 52 while (timeout && 53 (data = (lan743x_csr_read(adapter, PTP_CMD_CTL) & 54 bit_mask))) { 55 usleep_range(1000, 20000); 56 timeout--; 57 } 58 if (data) { 59 netif_err(adapter, drv, adapter->netdev, 60 "timeout waiting for cmd to be done, cmd = 0x%08X\n", 61 bit_mask); 62 } 63 } 64 65 static void lan743x_ptp_tx_ts_enqueue_ts(struct lan743x_adapter *adapter, 66 u32 seconds, u32 nano_seconds, 67 u32 header) 68 { 69 struct lan743x_ptp *ptp = &adapter->ptp; 70 71 spin_lock_bh(&ptp->tx_ts_lock); 72 if (ptp->tx_ts_queue_size < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) { 73 ptp->tx_ts_seconds_queue[ptp->tx_ts_queue_size] = seconds; 74 ptp->tx_ts_nseconds_queue[ptp->tx_ts_queue_size] = nano_seconds; 75 ptp->tx_ts_header_queue[ptp->tx_ts_queue_size] = header; 76 ptp->tx_ts_queue_size++; 77 } else { 78 netif_err(adapter, drv, adapter->netdev, 79 "tx ts queue overflow\n"); 80 } 81 spin_unlock_bh(&ptp->tx_ts_lock); 82 } 83 84 static void lan743x_ptp_tx_ts_complete(struct lan743x_adapter *adapter) 85 { 86 struct lan743x_ptp *ptp = &adapter->ptp; 87 struct skb_shared_hwtstamps tstamps; 88 u32 header, nseconds, seconds; 89 bool ignore_sync = false; 90 struct sk_buff *skb; 91 int c, i; 92 93 spin_lock_bh(&ptp->tx_ts_lock); 94 c = ptp->tx_ts_skb_queue_size; 95 96 if (c > ptp->tx_ts_queue_size) 97 c = ptp->tx_ts_queue_size; 98 if (c <= 0) 99 goto done; 100 101 for (i = 0; i < c; i++) { 102 ignore_sync = ((ptp->tx_ts_ignore_sync_queue & 103 BIT(i)) != 0); 104 skb = ptp->tx_ts_skb_queue[i]; 105 nseconds = ptp->tx_ts_nseconds_queue[i]; 106 seconds = ptp->tx_ts_seconds_queue[i]; 107 header = ptp->tx_ts_header_queue[i]; 108 109 memset(&tstamps, 0, sizeof(tstamps)); 110 tstamps.hwtstamp = ktime_set(seconds, nseconds); 111 if (!ignore_sync || 112 ((header & PTP_TX_MSG_HEADER_MSG_TYPE_) != 113 PTP_TX_MSG_HEADER_MSG_TYPE_SYNC_)) 114 skb_tstamp_tx(skb, &tstamps); 115 116 dev_kfree_skb(skb); 117 118 ptp->tx_ts_skb_queue[i] = NULL; 119 ptp->tx_ts_seconds_queue[i] = 0; 120 ptp->tx_ts_nseconds_queue[i] = 0; 121 ptp->tx_ts_header_queue[i] = 0; 122 } 123 124 /* shift queue */ 125 ptp->tx_ts_ignore_sync_queue >>= c; 126 for (i = c; i < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS; i++) { 127 ptp->tx_ts_skb_queue[i - c] = ptp->tx_ts_skb_queue[i]; 128 ptp->tx_ts_seconds_queue[i - c] = ptp->tx_ts_seconds_queue[i]; 129 ptp->tx_ts_nseconds_queue[i - c] = ptp->tx_ts_nseconds_queue[i]; 130 ptp->tx_ts_header_queue[i - c] = ptp->tx_ts_header_queue[i]; 131 132 ptp->tx_ts_skb_queue[i] = NULL; 133 ptp->tx_ts_seconds_queue[i] = 0; 134 ptp->tx_ts_nseconds_queue[i] = 0; 135 ptp->tx_ts_header_queue[i] = 0; 136 } 137 ptp->tx_ts_skb_queue_size -= c; 138 ptp->tx_ts_queue_size -= c; 139 done: 140 ptp->pending_tx_timestamps -= c; 141 spin_unlock_bh(&ptp->tx_ts_lock); 142 } 143 144 static int lan743x_ptp_reserve_event_ch(struct lan743x_adapter *adapter, 145 int event_channel) 146 { 147 struct lan743x_ptp *ptp = &adapter->ptp; 148 int result = -ENODEV; 149 150 mutex_lock(&ptp->command_lock); 151 if (!(test_bit(event_channel, &ptp->used_event_ch))) { 152 ptp->used_event_ch |= BIT(event_channel); 153 result = event_channel; 154 } else { 155 netif_warn(adapter, drv, adapter->netdev, 156 "attempted to reserved a used event_channel = %d\n", 157 event_channel); 158 } 159 mutex_unlock(&ptp->command_lock); 160 return result; 161 } 162 163 static void lan743x_ptp_release_event_ch(struct lan743x_adapter *adapter, 164 int event_channel) 165 { 166 struct lan743x_ptp *ptp = &adapter->ptp; 167 168 mutex_lock(&ptp->command_lock); 169 if (test_bit(event_channel, &ptp->used_event_ch)) { 170 ptp->used_event_ch &= ~BIT(event_channel); 171 } else { 172 netif_warn(adapter, drv, adapter->netdev, 173 "attempted release on a not used event_channel = %d\n", 174 event_channel); 175 } 176 mutex_unlock(&ptp->command_lock); 177 } 178 179 static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter, 180 u32 *seconds, u32 *nano_seconds, 181 u32 *sub_nano_seconds); 182 static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter, 183 s64 time_step_ns); 184 185 static void lan743x_led_mux_enable(struct lan743x_adapter *adapter, 186 int pin, bool enable) 187 { 188 struct lan743x_ptp *ptp = &adapter->ptp; 189 190 if (ptp->leds_multiplexed && 191 ptp->led_enabled[pin]) { 192 u32 val = lan743x_csr_read(adapter, HW_CFG); 193 194 if (enable) 195 val |= LAN743X_LED_ENABLE(pin); 196 else 197 val &= ~LAN743X_LED_ENABLE(pin); 198 199 lan743x_csr_write(adapter, HW_CFG, val); 200 } 201 } 202 203 static void lan743x_led_mux_save(struct lan743x_adapter *adapter) 204 { 205 struct lan743x_ptp *ptp = &adapter->ptp; 206 u32 id_rev = adapter->csr.id_rev & ID_REV_ID_MASK_; 207 208 if (id_rev == ID_REV_ID_LAN7430_) { 209 int i; 210 u32 val = lan743x_csr_read(adapter, HW_CFG); 211 212 for (i = 0; i < LAN7430_N_LED; i++) { 213 bool led_enabled = (val & LAN743X_LED_ENABLE(i)) != 0; 214 215 ptp->led_enabled[i] = led_enabled; 216 } 217 ptp->leds_multiplexed = true; 218 } else { 219 ptp->leds_multiplexed = false; 220 } 221 } 222 223 static void lan743x_led_mux_restore(struct lan743x_adapter *adapter) 224 { 225 u32 id_rev = adapter->csr.id_rev & ID_REV_ID_MASK_; 226 227 if (id_rev == ID_REV_ID_LAN7430_) { 228 int i; 229 230 for (i = 0; i < LAN7430_N_LED; i++) 231 lan743x_led_mux_enable(adapter, i, true); 232 } 233 } 234 235 static int lan743x_gpio_rsrv_ptp_out(struct lan743x_adapter *adapter, 236 int pin, int event_channel) 237 { 238 struct lan743x_gpio *gpio = &adapter->gpio; 239 unsigned long irq_flags = 0; 240 int bit_mask = BIT(pin); 241 int ret = -EBUSY; 242 243 spin_lock_irqsave(&gpio->gpio_lock, irq_flags); 244 245 if (!(gpio->used_bits & bit_mask)) { 246 gpio->used_bits |= bit_mask; 247 gpio->output_bits |= bit_mask; 248 gpio->ptp_bits |= bit_mask; 249 250 /* assign pin to GPIO function */ 251 lan743x_led_mux_enable(adapter, pin, false); 252 253 /* set as output, and zero initial value */ 254 gpio->gpio_cfg0 |= GPIO_CFG0_GPIO_DIR_BIT_(pin); 255 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DATA_BIT_(pin); 256 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0); 257 258 /* enable gpio, and set buffer type to push pull */ 259 gpio->gpio_cfg1 &= ~GPIO_CFG1_GPIOEN_BIT_(pin); 260 gpio->gpio_cfg1 |= GPIO_CFG1_GPIOBUF_BIT_(pin); 261 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1); 262 263 /* set 1588 polarity to high */ 264 gpio->gpio_cfg2 |= GPIO_CFG2_1588_POL_BIT_(pin); 265 lan743x_csr_write(adapter, GPIO_CFG2, gpio->gpio_cfg2); 266 267 if (event_channel == 0) { 268 /* use channel A */ 269 gpio->gpio_cfg3 &= ~GPIO_CFG3_1588_CH_SEL_BIT_(pin); 270 } else { 271 /* use channel B */ 272 gpio->gpio_cfg3 |= GPIO_CFG3_1588_CH_SEL_BIT_(pin); 273 } 274 gpio->gpio_cfg3 |= GPIO_CFG3_1588_OE_BIT_(pin); 275 lan743x_csr_write(adapter, GPIO_CFG3, gpio->gpio_cfg3); 276 277 ret = pin; 278 } 279 spin_unlock_irqrestore(&gpio->gpio_lock, irq_flags); 280 return ret; 281 } 282 283 static void lan743x_gpio_release(struct lan743x_adapter *adapter, int pin) 284 { 285 struct lan743x_gpio *gpio = &adapter->gpio; 286 unsigned long irq_flags = 0; 287 int bit_mask = BIT(pin); 288 289 spin_lock_irqsave(&gpio->gpio_lock, irq_flags); 290 if (gpio->used_bits & bit_mask) { 291 gpio->used_bits &= ~bit_mask; 292 if (gpio->output_bits & bit_mask) { 293 gpio->output_bits &= ~bit_mask; 294 295 if (gpio->ptp_bits & bit_mask) { 296 gpio->ptp_bits &= ~bit_mask; 297 /* disable ptp output */ 298 gpio->gpio_cfg3 &= ~GPIO_CFG3_1588_OE_BIT_(pin); 299 lan743x_csr_write(adapter, GPIO_CFG3, 300 gpio->gpio_cfg3); 301 } 302 /* release gpio output */ 303 304 /* disable gpio */ 305 gpio->gpio_cfg1 |= GPIO_CFG1_GPIOEN_BIT_(pin); 306 gpio->gpio_cfg1 &= ~GPIO_CFG1_GPIOBUF_BIT_(pin); 307 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1); 308 309 /* reset back to input */ 310 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DIR_BIT_(pin); 311 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DATA_BIT_(pin); 312 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0); 313 314 /* assign pin to original function */ 315 lan743x_led_mux_enable(adapter, pin, true); 316 } 317 } 318 spin_unlock_irqrestore(&gpio->gpio_lock, irq_flags); 319 } 320 321 static int lan743x_ptpci_adjfine(struct ptp_clock_info *ptpci, long scaled_ppm) 322 { 323 struct lan743x_ptp *ptp = 324 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 325 struct lan743x_adapter *adapter = 326 container_of(ptp, struct lan743x_adapter, ptp); 327 u32 lan743x_rate_adj = 0; 328 bool positive = true; 329 u64 u64_delta = 0; 330 331 if ((scaled_ppm < (-LAN743X_PTP_MAX_FINE_ADJ_IN_SCALED_PPM)) || 332 scaled_ppm > LAN743X_PTP_MAX_FINE_ADJ_IN_SCALED_PPM) { 333 return -EINVAL; 334 } 335 if (scaled_ppm > 0) { 336 u64_delta = (u64)scaled_ppm; 337 positive = true; 338 } else { 339 u64_delta = (u64)(-scaled_ppm); 340 positive = false; 341 } 342 u64_delta = (u64_delta << 19); 343 lan743x_rate_adj = div_u64(u64_delta, 1000000); 344 345 if (positive) 346 lan743x_rate_adj |= PTP_CLOCK_RATE_ADJ_DIR_; 347 348 lan743x_csr_write(adapter, PTP_CLOCK_RATE_ADJ, 349 lan743x_rate_adj); 350 351 return 0; 352 } 353 354 static int lan743x_ptpci_adjfreq(struct ptp_clock_info *ptpci, s32 delta_ppb) 355 { 356 struct lan743x_ptp *ptp = 357 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 358 struct lan743x_adapter *adapter = 359 container_of(ptp, struct lan743x_adapter, ptp); 360 u32 lan743x_rate_adj = 0; 361 bool positive = true; 362 u32 u32_delta = 0; 363 u64 u64_delta = 0; 364 365 if ((delta_ppb < (-LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB)) || 366 delta_ppb > LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB) { 367 return -EINVAL; 368 } 369 if (delta_ppb > 0) { 370 u32_delta = (u32)delta_ppb; 371 positive = true; 372 } else { 373 u32_delta = (u32)(-delta_ppb); 374 positive = false; 375 } 376 u64_delta = (((u64)u32_delta) << 35); 377 lan743x_rate_adj = div_u64(u64_delta, 1000000000); 378 379 if (positive) 380 lan743x_rate_adj |= PTP_CLOCK_RATE_ADJ_DIR_; 381 382 lan743x_csr_write(adapter, PTP_CLOCK_RATE_ADJ, 383 lan743x_rate_adj); 384 385 return 0; 386 } 387 388 static int lan743x_ptpci_adjtime(struct ptp_clock_info *ptpci, s64 delta) 389 { 390 struct lan743x_ptp *ptp = 391 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 392 struct lan743x_adapter *adapter = 393 container_of(ptp, struct lan743x_adapter, ptp); 394 395 lan743x_ptp_clock_step(adapter, delta); 396 397 return 0; 398 } 399 400 static int lan743x_ptpci_gettime64(struct ptp_clock_info *ptpci, 401 struct timespec64 *ts) 402 { 403 struct lan743x_ptp *ptp = 404 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 405 struct lan743x_adapter *adapter = 406 container_of(ptp, struct lan743x_adapter, ptp); 407 u32 nano_seconds = 0; 408 u32 seconds = 0; 409 410 lan743x_ptp_clock_get(adapter, &seconds, &nano_seconds, NULL); 411 ts->tv_sec = seconds; 412 ts->tv_nsec = nano_seconds; 413 414 return 0; 415 } 416 417 static int lan743x_ptpci_settime64(struct ptp_clock_info *ptpci, 418 const struct timespec64 *ts) 419 { 420 struct lan743x_ptp *ptp = 421 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 422 struct lan743x_adapter *adapter = 423 container_of(ptp, struct lan743x_adapter, ptp); 424 u32 nano_seconds = 0; 425 u32 seconds = 0; 426 427 if (ts) { 428 if (ts->tv_sec > 0xFFFFFFFFLL || 429 ts->tv_sec < 0) { 430 netif_warn(adapter, drv, adapter->netdev, 431 "ts->tv_sec out of range, %lld\n", 432 ts->tv_sec); 433 return -ERANGE; 434 } 435 if (ts->tv_nsec >= 1000000000L || 436 ts->tv_nsec < 0) { 437 netif_warn(adapter, drv, adapter->netdev, 438 "ts->tv_nsec out of range, %ld\n", 439 ts->tv_nsec); 440 return -ERANGE; 441 } 442 seconds = ts->tv_sec; 443 nano_seconds = ts->tv_nsec; 444 lan743x_ptp_clock_set(adapter, seconds, nano_seconds, 0); 445 } else { 446 netif_warn(adapter, drv, adapter->netdev, "ts == NULL\n"); 447 return -EINVAL; 448 } 449 450 return 0; 451 } 452 453 static void lan743x_ptp_perout_off(struct lan743x_adapter *adapter, 454 unsigned int index) 455 { 456 struct lan743x_ptp *ptp = &adapter->ptp; 457 u32 general_config = 0; 458 struct lan743x_ptp_perout *perout = &ptp->perout[index]; 459 460 if (perout->gpio_pin >= 0) { 461 lan743x_gpio_release(adapter, perout->gpio_pin); 462 perout->gpio_pin = -1; 463 } 464 465 if (perout->event_ch >= 0) { 466 /* set target to far in the future, effectively disabling it */ 467 lan743x_csr_write(adapter, 468 PTP_CLOCK_TARGET_SEC_X(perout->event_ch), 469 0xFFFF0000); 470 lan743x_csr_write(adapter, 471 PTP_CLOCK_TARGET_NS_X(perout->event_ch), 472 0); 473 474 general_config = lan743x_csr_read(adapter, PTP_GENERAL_CONFIG); 475 general_config |= PTP_GENERAL_CONFIG_RELOAD_ADD_X_ 476 (perout->event_ch); 477 lan743x_csr_write(adapter, PTP_GENERAL_CONFIG, general_config); 478 lan743x_ptp_release_event_ch(adapter, perout->event_ch); 479 perout->event_ch = -1; 480 } 481 } 482 483 static int lan743x_ptp_perout(struct lan743x_adapter *adapter, int on, 484 struct ptp_perout_request *perout_request) 485 { 486 struct lan743x_ptp *ptp = &adapter->ptp; 487 u32 period_sec = 0, period_nsec = 0; 488 u32 start_sec = 0, start_nsec = 0; 489 u32 general_config = 0; 490 int pulse_width = 0; 491 int perout_pin = 0; 492 unsigned int index = perout_request->index; 493 struct lan743x_ptp_perout *perout = &ptp->perout[index]; 494 int ret = 0; 495 496 /* Reject requests with unsupported flags */ 497 if (perout_request->flags & ~PTP_PEROUT_DUTY_CYCLE) 498 return -EOPNOTSUPP; 499 500 if (on) { 501 perout_pin = ptp_find_pin(ptp->ptp_clock, PTP_PF_PEROUT, 502 perout_request->index); 503 if (perout_pin < 0) 504 return -EBUSY; 505 } else { 506 lan743x_ptp_perout_off(adapter, index); 507 return 0; 508 } 509 510 if (perout->event_ch >= 0 || 511 perout->gpio_pin >= 0) { 512 /* already on, turn off first */ 513 lan743x_ptp_perout_off(adapter, index); 514 } 515 516 perout->event_ch = lan743x_ptp_reserve_event_ch(adapter, index); 517 518 if (perout->event_ch < 0) { 519 netif_warn(adapter, drv, adapter->netdev, 520 "Failed to reserve event channel %d for PEROUT\n", 521 index); 522 ret = -EBUSY; 523 goto failed; 524 } 525 526 perout->gpio_pin = lan743x_gpio_rsrv_ptp_out(adapter, 527 perout_pin, 528 perout->event_ch); 529 530 if (perout->gpio_pin < 0) { 531 netif_warn(adapter, drv, adapter->netdev, 532 "Failed to reserve gpio %d for PEROUT\n", 533 perout_pin); 534 ret = -EBUSY; 535 goto failed; 536 } 537 538 start_sec = perout_request->start.sec; 539 start_sec += perout_request->start.nsec / 1000000000; 540 start_nsec = perout_request->start.nsec % 1000000000; 541 542 period_sec = perout_request->period.sec; 543 period_sec += perout_request->period.nsec / 1000000000; 544 period_nsec = perout_request->period.nsec % 1000000000; 545 546 if (perout_request->flags & PTP_PEROUT_DUTY_CYCLE) { 547 struct timespec64 ts_on, ts_period; 548 s64 wf_high, period64, half; 549 s32 reminder; 550 551 ts_on.tv_sec = perout_request->on.sec; 552 ts_on.tv_nsec = perout_request->on.nsec; 553 wf_high = timespec64_to_ns(&ts_on); 554 ts_period.tv_sec = perout_request->period.sec; 555 ts_period.tv_nsec = perout_request->period.nsec; 556 period64 = timespec64_to_ns(&ts_period); 557 558 if (period64 < 200) { 559 netif_warn(adapter, drv, adapter->netdev, 560 "perout period too small, minimum is 200nS\n"); 561 ret = -EOPNOTSUPP; 562 goto failed; 563 } 564 if (wf_high >= period64) { 565 netif_warn(adapter, drv, adapter->netdev, 566 "pulse width must be smaller than period\n"); 567 ret = -EINVAL; 568 goto failed; 569 } 570 571 /* Check if we can do 50% toggle on an even value of period. 572 * If the period number is odd, then check if the requested 573 * pulse width is the same as one of pre-defined width values. 574 * Otherwise, return failure. 575 */ 576 half = div_s64_rem(period64, 2, &reminder); 577 if (!reminder) { 578 if (half == wf_high) { 579 /* It's 50% match. Use the toggle option */ 580 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_TOGGLE_; 581 /* In this case, devide period value by 2 */ 582 ts_period = ns_to_timespec64(div_s64(period64, 2)); 583 period_sec = ts_period.tv_sec; 584 period_nsec = ts_period.tv_nsec; 585 586 goto program; 587 } 588 } 589 /* if we can't do toggle, then the width option needs to be the exact match */ 590 if (wf_high == 200000000) { 591 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_; 592 } else if (wf_high == 10000000) { 593 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10MS_; 594 } else if (wf_high == 1000000) { 595 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_1MS_; 596 } else if (wf_high == 100000) { 597 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100US_; 598 } else if (wf_high == 10000) { 599 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10US_; 600 } else if (wf_high == 100) { 601 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100NS_; 602 } else { 603 netif_warn(adapter, drv, adapter->netdev, 604 "duty cycle specified is not supported\n"); 605 ret = -EOPNOTSUPP; 606 goto failed; 607 } 608 } else { 609 if (period_sec == 0) { 610 if (period_nsec >= 400000000) { 611 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_; 612 } else if (period_nsec >= 20000000) { 613 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10MS_; 614 } else if (period_nsec >= 2000000) { 615 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_1MS_; 616 } else if (period_nsec >= 200000) { 617 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100US_; 618 } else if (period_nsec >= 20000) { 619 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10US_; 620 } else if (period_nsec >= 200) { 621 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100NS_; 622 } else { 623 netif_warn(adapter, drv, adapter->netdev, 624 "perout period too small, minimum is 200nS\n"); 625 ret = -EOPNOTSUPP; 626 goto failed; 627 } 628 } else { 629 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_; 630 } 631 } 632 program: 633 634 /* turn off by setting target far in future */ 635 lan743x_csr_write(adapter, 636 PTP_CLOCK_TARGET_SEC_X(perout->event_ch), 637 0xFFFF0000); 638 lan743x_csr_write(adapter, 639 PTP_CLOCK_TARGET_NS_X(perout->event_ch), 0); 640 641 /* Configure to pulse every period */ 642 general_config = lan743x_csr_read(adapter, PTP_GENERAL_CONFIG); 643 general_config &= ~(PTP_GENERAL_CONFIG_CLOCK_EVENT_X_MASK_ 644 (perout->event_ch)); 645 general_config |= PTP_GENERAL_CONFIG_CLOCK_EVENT_X_SET_ 646 (perout->event_ch, pulse_width); 647 general_config &= ~PTP_GENERAL_CONFIG_RELOAD_ADD_X_ 648 (perout->event_ch); 649 lan743x_csr_write(adapter, PTP_GENERAL_CONFIG, general_config); 650 651 /* set the reload to one toggle cycle */ 652 lan743x_csr_write(adapter, 653 PTP_CLOCK_TARGET_RELOAD_SEC_X(perout->event_ch), 654 period_sec); 655 lan743x_csr_write(adapter, 656 PTP_CLOCK_TARGET_RELOAD_NS_X(perout->event_ch), 657 period_nsec); 658 659 /* set the start time */ 660 lan743x_csr_write(adapter, 661 PTP_CLOCK_TARGET_SEC_X(perout->event_ch), 662 start_sec); 663 lan743x_csr_write(adapter, 664 PTP_CLOCK_TARGET_NS_X(perout->event_ch), 665 start_nsec); 666 667 return 0; 668 669 failed: 670 lan743x_ptp_perout_off(adapter, index); 671 return ret; 672 } 673 674 static int lan743x_ptpci_enable(struct ptp_clock_info *ptpci, 675 struct ptp_clock_request *request, int on) 676 { 677 struct lan743x_ptp *ptp = 678 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 679 struct lan743x_adapter *adapter = 680 container_of(ptp, struct lan743x_adapter, ptp); 681 682 if (request) { 683 switch (request->type) { 684 case PTP_CLK_REQ_EXTTS: 685 return -EINVAL; 686 case PTP_CLK_REQ_PEROUT: 687 if (request->perout.index < ptpci->n_per_out) 688 return lan743x_ptp_perout(adapter, on, 689 &request->perout); 690 return -EINVAL; 691 case PTP_CLK_REQ_PPS: 692 return -EINVAL; 693 default: 694 netif_err(adapter, drv, adapter->netdev, 695 "request->type == %d, Unknown\n", 696 request->type); 697 break; 698 } 699 } else { 700 netif_err(adapter, drv, adapter->netdev, "request == NULL\n"); 701 } 702 return 0; 703 } 704 705 static int lan743x_ptpci_verify_pin_config(struct ptp_clock_info *ptp, 706 unsigned int pin, 707 enum ptp_pin_function func, 708 unsigned int chan) 709 { 710 int result = 0; 711 712 /* Confirm the requested function is supported. Parameter 713 * validation is done by the caller. 714 */ 715 switch (func) { 716 case PTP_PF_NONE: 717 case PTP_PF_PEROUT: 718 break; 719 case PTP_PF_EXTTS: 720 case PTP_PF_PHYSYNC: 721 default: 722 result = -1; 723 break; 724 } 725 return result; 726 } 727 728 static long lan743x_ptpci_do_aux_work(struct ptp_clock_info *ptpci) 729 { 730 struct lan743x_ptp *ptp = 731 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 732 struct lan743x_adapter *adapter = 733 container_of(ptp, struct lan743x_adapter, ptp); 734 u32 cap_info, cause, header, nsec, seconds; 735 bool new_timestamp_available = false; 736 int count = 0; 737 738 while ((count < 100) && 739 (lan743x_csr_read(adapter, PTP_INT_STS) & PTP_INT_BIT_TX_TS_)) { 740 count++; 741 cap_info = lan743x_csr_read(adapter, PTP_CAP_INFO); 742 743 if (PTP_CAP_INFO_TX_TS_CNT_GET_(cap_info) > 0) { 744 seconds = lan743x_csr_read(adapter, 745 PTP_TX_EGRESS_SEC); 746 nsec = lan743x_csr_read(adapter, PTP_TX_EGRESS_NS); 747 cause = (nsec & 748 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_MASK_); 749 header = lan743x_csr_read(adapter, 750 PTP_TX_MSG_HEADER); 751 752 if (cause == PTP_TX_EGRESS_NS_CAPTURE_CAUSE_SW_) { 753 nsec &= PTP_TX_EGRESS_NS_TS_NS_MASK_; 754 lan743x_ptp_tx_ts_enqueue_ts(adapter, 755 seconds, nsec, 756 header); 757 new_timestamp_available = true; 758 } else if (cause == 759 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_AUTO_) { 760 netif_err(adapter, drv, adapter->netdev, 761 "Auto capture cause not supported\n"); 762 } else { 763 netif_warn(adapter, drv, adapter->netdev, 764 "unknown tx timestamp capture cause\n"); 765 } 766 } else { 767 netif_warn(adapter, drv, adapter->netdev, 768 "TX TS INT but no TX TS CNT\n"); 769 } 770 lan743x_csr_write(adapter, PTP_INT_STS, PTP_INT_BIT_TX_TS_); 771 } 772 773 if (new_timestamp_available) 774 lan743x_ptp_tx_ts_complete(adapter); 775 776 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_); 777 778 return -1; 779 } 780 781 static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter, 782 u32 *seconds, u32 *nano_seconds, 783 u32 *sub_nano_seconds) 784 { 785 struct lan743x_ptp *ptp = &adapter->ptp; 786 787 mutex_lock(&ptp->command_lock); 788 789 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_READ_); 790 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_READ_); 791 792 if (seconds) 793 (*seconds) = lan743x_csr_read(adapter, PTP_CLOCK_SEC); 794 795 if (nano_seconds) 796 (*nano_seconds) = lan743x_csr_read(adapter, PTP_CLOCK_NS); 797 798 if (sub_nano_seconds) 799 (*sub_nano_seconds) = 800 lan743x_csr_read(adapter, PTP_CLOCK_SUBNS); 801 802 mutex_unlock(&ptp->command_lock); 803 } 804 805 static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter, 806 s64 time_step_ns) 807 { 808 struct lan743x_ptp *ptp = &adapter->ptp; 809 u32 nano_seconds_step = 0; 810 u64 abs_time_step_ns = 0; 811 u32 unsigned_seconds = 0; 812 u32 nano_seconds = 0; 813 u32 remainder = 0; 814 s32 seconds = 0; 815 816 if (time_step_ns > 15000000000LL) { 817 /* convert to clock set */ 818 lan743x_ptp_clock_get(adapter, &unsigned_seconds, 819 &nano_seconds, NULL); 820 unsigned_seconds += div_u64_rem(time_step_ns, 1000000000LL, 821 &remainder); 822 nano_seconds += remainder; 823 if (nano_seconds >= 1000000000) { 824 unsigned_seconds++; 825 nano_seconds -= 1000000000; 826 } 827 lan743x_ptp_clock_set(adapter, unsigned_seconds, 828 nano_seconds, 0); 829 return; 830 } else if (time_step_ns < -15000000000LL) { 831 /* convert to clock set */ 832 time_step_ns = -time_step_ns; 833 834 lan743x_ptp_clock_get(adapter, &unsigned_seconds, 835 &nano_seconds, NULL); 836 unsigned_seconds -= div_u64_rem(time_step_ns, 1000000000LL, 837 &remainder); 838 nano_seconds_step = remainder; 839 if (nano_seconds < nano_seconds_step) { 840 unsigned_seconds--; 841 nano_seconds += 1000000000; 842 } 843 nano_seconds -= nano_seconds_step; 844 lan743x_ptp_clock_set(adapter, unsigned_seconds, 845 nano_seconds, 0); 846 return; 847 } 848 849 /* do clock step */ 850 if (time_step_ns >= 0) { 851 abs_time_step_ns = (u64)(time_step_ns); 852 seconds = (s32)div_u64_rem(abs_time_step_ns, 1000000000, 853 &remainder); 854 nano_seconds = (u32)remainder; 855 } else { 856 abs_time_step_ns = (u64)(-time_step_ns); 857 seconds = -((s32)div_u64_rem(abs_time_step_ns, 1000000000, 858 &remainder)); 859 nano_seconds = (u32)remainder; 860 if (nano_seconds > 0) { 861 /* subtracting nano seconds is not allowed 862 * convert to subtracting from seconds, 863 * and adding to nanoseconds 864 */ 865 seconds--; 866 nano_seconds = (1000000000 - nano_seconds); 867 } 868 } 869 870 if (nano_seconds > 0) { 871 /* add 8 ns to cover the likely normal increment */ 872 nano_seconds += 8; 873 } 874 875 if (nano_seconds >= 1000000000) { 876 /* carry into seconds */ 877 seconds++; 878 nano_seconds -= 1000000000; 879 } 880 881 while (seconds) { 882 mutex_lock(&ptp->command_lock); 883 if (seconds > 0) { 884 u32 adjustment_value = (u32)seconds; 885 886 if (adjustment_value > 0xF) 887 adjustment_value = 0xF; 888 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ, 889 PTP_CLOCK_STEP_ADJ_DIR_ | 890 adjustment_value); 891 seconds -= ((s32)adjustment_value); 892 } else { 893 u32 adjustment_value = (u32)(-seconds); 894 895 if (adjustment_value > 0xF) 896 adjustment_value = 0xF; 897 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ, 898 adjustment_value); 899 seconds += ((s32)adjustment_value); 900 } 901 lan743x_csr_write(adapter, PTP_CMD_CTL, 902 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_); 903 lan743x_ptp_wait_till_cmd_done(adapter, 904 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_); 905 mutex_unlock(&ptp->command_lock); 906 } 907 if (nano_seconds) { 908 mutex_lock(&ptp->command_lock); 909 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ, 910 PTP_CLOCK_STEP_ADJ_DIR_ | 911 (nano_seconds & 912 PTP_CLOCK_STEP_ADJ_VALUE_MASK_)); 913 lan743x_csr_write(adapter, PTP_CMD_CTL, 914 PTP_CMD_CTL_PTP_CLK_STP_NSEC_); 915 lan743x_ptp_wait_till_cmd_done(adapter, 916 PTP_CMD_CTL_PTP_CLK_STP_NSEC_); 917 mutex_unlock(&ptp->command_lock); 918 } 919 } 920 921 void lan743x_ptp_isr(void *context) 922 { 923 struct lan743x_adapter *adapter = (struct lan743x_adapter *)context; 924 struct lan743x_ptp *ptp = NULL; 925 int enable_flag = 1; 926 u32 ptp_int_sts = 0; 927 928 ptp = &adapter->ptp; 929 930 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_); 931 932 ptp_int_sts = lan743x_csr_read(adapter, PTP_INT_STS); 933 ptp_int_sts &= lan743x_csr_read(adapter, PTP_INT_EN_SET); 934 935 if (ptp_int_sts & PTP_INT_BIT_TX_TS_) { 936 ptp_schedule_worker(ptp->ptp_clock, 0); 937 enable_flag = 0;/* tasklet will re-enable later */ 938 } 939 if (ptp_int_sts & PTP_INT_BIT_TX_SWTS_ERR_) { 940 netif_err(adapter, drv, adapter->netdev, 941 "PTP TX Software Timestamp Error\n"); 942 /* clear int status bit */ 943 lan743x_csr_write(adapter, PTP_INT_STS, 944 PTP_INT_BIT_TX_SWTS_ERR_); 945 } 946 if (ptp_int_sts & PTP_INT_BIT_TIMER_B_) { 947 /* clear int status bit */ 948 lan743x_csr_write(adapter, PTP_INT_STS, 949 PTP_INT_BIT_TIMER_B_); 950 } 951 if (ptp_int_sts & PTP_INT_BIT_TIMER_A_) { 952 /* clear int status bit */ 953 lan743x_csr_write(adapter, PTP_INT_STS, 954 PTP_INT_BIT_TIMER_A_); 955 } 956 957 if (enable_flag) { 958 /* re-enable isr */ 959 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_); 960 } 961 } 962 963 static void lan743x_ptp_tx_ts_enqueue_skb(struct lan743x_adapter *adapter, 964 struct sk_buff *skb, bool ignore_sync) 965 { 966 struct lan743x_ptp *ptp = &adapter->ptp; 967 968 spin_lock_bh(&ptp->tx_ts_lock); 969 if (ptp->tx_ts_skb_queue_size < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) { 970 ptp->tx_ts_skb_queue[ptp->tx_ts_skb_queue_size] = skb; 971 if (ignore_sync) 972 ptp->tx_ts_ignore_sync_queue |= 973 BIT(ptp->tx_ts_skb_queue_size); 974 ptp->tx_ts_skb_queue_size++; 975 } else { 976 /* this should never happen, so long as the tx channel 977 * calls and honors the result from 978 * lan743x_ptp_request_tx_timestamp 979 */ 980 netif_err(adapter, drv, adapter->netdev, 981 "tx ts skb queue overflow\n"); 982 dev_kfree_skb(skb); 983 } 984 spin_unlock_bh(&ptp->tx_ts_lock); 985 } 986 987 static void lan743x_ptp_sync_to_system_clock(struct lan743x_adapter *adapter) 988 { 989 struct timespec64 ts; 990 991 ktime_get_clocktai_ts64(&ts); 992 993 lan743x_ptp_clock_set(adapter, ts.tv_sec, ts.tv_nsec, 0); 994 } 995 996 void lan743x_ptp_update_latency(struct lan743x_adapter *adapter, 997 u32 link_speed) 998 { 999 switch (link_speed) { 1000 case 10: 1001 lan743x_csr_write(adapter, PTP_LATENCY, 1002 PTP_LATENCY_TX_SET_(0) | 1003 PTP_LATENCY_RX_SET_(0)); 1004 break; 1005 case 100: 1006 lan743x_csr_write(adapter, PTP_LATENCY, 1007 PTP_LATENCY_TX_SET_(181) | 1008 PTP_LATENCY_RX_SET_(594)); 1009 break; 1010 case 1000: 1011 lan743x_csr_write(adapter, PTP_LATENCY, 1012 PTP_LATENCY_TX_SET_(30) | 1013 PTP_LATENCY_RX_SET_(525)); 1014 break; 1015 } 1016 } 1017 1018 int lan743x_ptp_init(struct lan743x_adapter *adapter) 1019 { 1020 struct lan743x_ptp *ptp = &adapter->ptp; 1021 int i; 1022 1023 mutex_init(&ptp->command_lock); 1024 spin_lock_init(&ptp->tx_ts_lock); 1025 ptp->used_event_ch = 0; 1026 1027 for (i = 0; i < LAN743X_PTP_N_EVENT_CHAN; i++) { 1028 ptp->perout[i].event_ch = -1; 1029 ptp->perout[i].gpio_pin = -1; 1030 } 1031 1032 lan743x_led_mux_save(adapter); 1033 1034 return 0; 1035 } 1036 1037 int lan743x_ptp_open(struct lan743x_adapter *adapter) 1038 { 1039 struct lan743x_ptp *ptp = &adapter->ptp; 1040 int ret = -ENODEV; 1041 u32 temp; 1042 int i; 1043 int n_pins; 1044 1045 lan743x_ptp_reset(adapter); 1046 lan743x_ptp_sync_to_system_clock(adapter); 1047 temp = lan743x_csr_read(adapter, PTP_TX_MOD2); 1048 temp |= PTP_TX_MOD2_TX_PTP_CLR_UDPV4_CHKSUM_; 1049 lan743x_csr_write(adapter, PTP_TX_MOD2, temp); 1050 lan743x_ptp_enable(adapter); 1051 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_); 1052 lan743x_csr_write(adapter, PTP_INT_EN_SET, 1053 PTP_INT_BIT_TX_SWTS_ERR_ | PTP_INT_BIT_TX_TS_); 1054 ptp->flags |= PTP_FLAG_ISR_ENABLED; 1055 1056 if (!IS_ENABLED(CONFIG_PTP_1588_CLOCK)) 1057 return 0; 1058 1059 switch (adapter->csr.id_rev & ID_REV_ID_MASK_) { 1060 case ID_REV_ID_LAN7430_: 1061 n_pins = LAN7430_N_GPIO; 1062 break; 1063 case ID_REV_ID_LAN7431_: 1064 n_pins = LAN7431_N_GPIO; 1065 break; 1066 default: 1067 netif_warn(adapter, drv, adapter->netdev, 1068 "Unknown LAN743x (%08x). Assuming no GPIO\n", 1069 adapter->csr.id_rev); 1070 n_pins = 0; 1071 break; 1072 } 1073 1074 if (n_pins > LAN743X_PTP_N_GPIO) 1075 n_pins = LAN743X_PTP_N_GPIO; 1076 1077 for (i = 0; i < n_pins; i++) { 1078 struct ptp_pin_desc *ptp_pin = &ptp->pin_config[i]; 1079 1080 snprintf(ptp_pin->name, 1081 sizeof(ptp_pin->name), "lan743x_ptp_pin_%02d", i); 1082 ptp_pin->index = i; 1083 ptp_pin->func = PTP_PF_NONE; 1084 } 1085 1086 ptp->ptp_clock_info.owner = THIS_MODULE; 1087 snprintf(ptp->ptp_clock_info.name, 16, "%pm", 1088 adapter->netdev->dev_addr); 1089 ptp->ptp_clock_info.max_adj = LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB; 1090 ptp->ptp_clock_info.n_alarm = 0; 1091 ptp->ptp_clock_info.n_ext_ts = 0; 1092 ptp->ptp_clock_info.n_per_out = LAN743X_PTP_N_EVENT_CHAN; 1093 ptp->ptp_clock_info.n_pins = n_pins; 1094 ptp->ptp_clock_info.pps = 0; 1095 ptp->ptp_clock_info.pin_config = ptp->pin_config; 1096 ptp->ptp_clock_info.adjfine = lan743x_ptpci_adjfine; 1097 ptp->ptp_clock_info.adjfreq = lan743x_ptpci_adjfreq; 1098 ptp->ptp_clock_info.adjtime = lan743x_ptpci_adjtime; 1099 ptp->ptp_clock_info.gettime64 = lan743x_ptpci_gettime64; 1100 ptp->ptp_clock_info.getcrosststamp = NULL; 1101 ptp->ptp_clock_info.settime64 = lan743x_ptpci_settime64; 1102 ptp->ptp_clock_info.enable = lan743x_ptpci_enable; 1103 ptp->ptp_clock_info.do_aux_work = lan743x_ptpci_do_aux_work; 1104 ptp->ptp_clock_info.verify = lan743x_ptpci_verify_pin_config; 1105 1106 ptp->ptp_clock = ptp_clock_register(&ptp->ptp_clock_info, 1107 &adapter->pdev->dev); 1108 1109 if (IS_ERR(ptp->ptp_clock)) { 1110 netif_err(adapter, ifup, adapter->netdev, 1111 "ptp_clock_register failed\n"); 1112 goto done; 1113 } 1114 ptp->flags |= PTP_FLAG_PTP_CLOCK_REGISTERED; 1115 netif_info(adapter, ifup, adapter->netdev, 1116 "successfully registered ptp clock\n"); 1117 1118 return 0; 1119 done: 1120 lan743x_ptp_close(adapter); 1121 return ret; 1122 } 1123 1124 void lan743x_ptp_close(struct lan743x_adapter *adapter) 1125 { 1126 struct lan743x_ptp *ptp = &adapter->ptp; 1127 int index; 1128 1129 if (IS_ENABLED(CONFIG_PTP_1588_CLOCK) && 1130 (ptp->flags & PTP_FLAG_PTP_CLOCK_REGISTERED)) { 1131 ptp_clock_unregister(ptp->ptp_clock); 1132 ptp->ptp_clock = NULL; 1133 ptp->flags &= ~PTP_FLAG_PTP_CLOCK_REGISTERED; 1134 netif_info(adapter, drv, adapter->netdev, 1135 "ptp clock unregister\n"); 1136 } 1137 1138 if (ptp->flags & PTP_FLAG_ISR_ENABLED) { 1139 lan743x_csr_write(adapter, PTP_INT_EN_CLR, 1140 PTP_INT_BIT_TX_SWTS_ERR_ | 1141 PTP_INT_BIT_TX_TS_); 1142 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_); 1143 ptp->flags &= ~PTP_FLAG_ISR_ENABLED; 1144 } 1145 1146 /* clean up pending timestamp requests */ 1147 lan743x_ptp_tx_ts_complete(adapter); 1148 spin_lock_bh(&ptp->tx_ts_lock); 1149 for (index = 0; 1150 index < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS; 1151 index++) { 1152 struct sk_buff *skb = ptp->tx_ts_skb_queue[index]; 1153 1154 dev_kfree_skb(skb); 1155 ptp->tx_ts_skb_queue[index] = NULL; 1156 ptp->tx_ts_seconds_queue[index] = 0; 1157 ptp->tx_ts_nseconds_queue[index] = 0; 1158 } 1159 ptp->tx_ts_skb_queue_size = 0; 1160 ptp->tx_ts_queue_size = 0; 1161 ptp->pending_tx_timestamps = 0; 1162 spin_unlock_bh(&ptp->tx_ts_lock); 1163 1164 lan743x_led_mux_restore(adapter); 1165 1166 lan743x_ptp_disable(adapter); 1167 } 1168 1169 static void lan743x_ptp_set_sync_ts_insert(struct lan743x_adapter *adapter, 1170 bool ts_insert_enable) 1171 { 1172 u32 ptp_tx_mod = lan743x_csr_read(adapter, PTP_TX_MOD); 1173 1174 if (ts_insert_enable) 1175 ptp_tx_mod |= PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_; 1176 else 1177 ptp_tx_mod &= ~PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_; 1178 1179 lan743x_csr_write(adapter, PTP_TX_MOD, ptp_tx_mod); 1180 } 1181 1182 static bool lan743x_ptp_is_enabled(struct lan743x_adapter *adapter) 1183 { 1184 if (lan743x_csr_read(adapter, PTP_CMD_CTL) & PTP_CMD_CTL_PTP_ENABLE_) 1185 return true; 1186 return false; 1187 } 1188 1189 static void lan743x_ptp_enable(struct lan743x_adapter *adapter) 1190 { 1191 struct lan743x_ptp *ptp = &adapter->ptp; 1192 1193 mutex_lock(&ptp->command_lock); 1194 1195 if (lan743x_ptp_is_enabled(adapter)) { 1196 netif_warn(adapter, drv, adapter->netdev, 1197 "PTP already enabled\n"); 1198 goto done; 1199 } 1200 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_ENABLE_); 1201 done: 1202 mutex_unlock(&ptp->command_lock); 1203 } 1204 1205 static void lan743x_ptp_disable(struct lan743x_adapter *adapter) 1206 { 1207 struct lan743x_ptp *ptp = &adapter->ptp; 1208 1209 mutex_lock(&ptp->command_lock); 1210 if (!lan743x_ptp_is_enabled(adapter)) { 1211 netif_warn(adapter, drv, adapter->netdev, 1212 "PTP already disabled\n"); 1213 goto done; 1214 } 1215 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_DISABLE_); 1216 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_ENABLE_); 1217 done: 1218 mutex_unlock(&ptp->command_lock); 1219 } 1220 1221 static void lan743x_ptp_reset(struct lan743x_adapter *adapter) 1222 { 1223 struct lan743x_ptp *ptp = &adapter->ptp; 1224 1225 mutex_lock(&ptp->command_lock); 1226 1227 if (lan743x_ptp_is_enabled(adapter)) { 1228 netif_err(adapter, drv, adapter->netdev, 1229 "Attempting reset while enabled\n"); 1230 goto done; 1231 } 1232 1233 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_RESET_); 1234 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_RESET_); 1235 done: 1236 mutex_unlock(&ptp->command_lock); 1237 } 1238 1239 static void lan743x_ptp_clock_set(struct lan743x_adapter *adapter, 1240 u32 seconds, u32 nano_seconds, 1241 u32 sub_nano_seconds) 1242 { 1243 struct lan743x_ptp *ptp = &adapter->ptp; 1244 1245 mutex_lock(&ptp->command_lock); 1246 1247 lan743x_csr_write(adapter, PTP_CLOCK_SEC, seconds); 1248 lan743x_csr_write(adapter, PTP_CLOCK_NS, nano_seconds); 1249 lan743x_csr_write(adapter, PTP_CLOCK_SUBNS, sub_nano_seconds); 1250 1251 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_LOAD_); 1252 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_LOAD_); 1253 mutex_unlock(&ptp->command_lock); 1254 } 1255 1256 bool lan743x_ptp_request_tx_timestamp(struct lan743x_adapter *adapter) 1257 { 1258 struct lan743x_ptp *ptp = &adapter->ptp; 1259 bool result = false; 1260 1261 spin_lock_bh(&ptp->tx_ts_lock); 1262 if (ptp->pending_tx_timestamps < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) { 1263 /* request granted */ 1264 ptp->pending_tx_timestamps++; 1265 result = true; 1266 } 1267 spin_unlock_bh(&ptp->tx_ts_lock); 1268 return result; 1269 } 1270 1271 void lan743x_ptp_unrequest_tx_timestamp(struct lan743x_adapter *adapter) 1272 { 1273 struct lan743x_ptp *ptp = &adapter->ptp; 1274 1275 spin_lock_bh(&ptp->tx_ts_lock); 1276 if (ptp->pending_tx_timestamps > 0) 1277 ptp->pending_tx_timestamps--; 1278 else 1279 netif_err(adapter, drv, adapter->netdev, 1280 "unrequest failed, pending_tx_timestamps==0\n"); 1281 spin_unlock_bh(&ptp->tx_ts_lock); 1282 } 1283 1284 void lan743x_ptp_tx_timestamp_skb(struct lan743x_adapter *adapter, 1285 struct sk_buff *skb, bool ignore_sync) 1286 { 1287 lan743x_ptp_tx_ts_enqueue_skb(adapter, skb, ignore_sync); 1288 1289 lan743x_ptp_tx_ts_complete(adapter); 1290 } 1291 1292 int lan743x_ptp_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd) 1293 { 1294 struct lan743x_adapter *adapter = netdev_priv(netdev); 1295 struct hwtstamp_config config; 1296 int ret = 0; 1297 int index; 1298 1299 if (!ifr) { 1300 netif_err(adapter, drv, adapter->netdev, 1301 "SIOCSHWTSTAMP, ifr == NULL\n"); 1302 return -EINVAL; 1303 } 1304 1305 if (copy_from_user(&config, ifr->ifr_data, sizeof(config))) 1306 return -EFAULT; 1307 1308 switch (config.tx_type) { 1309 case HWTSTAMP_TX_OFF: 1310 for (index = 0; index < LAN743X_MAX_TX_CHANNELS; 1311 index++) 1312 lan743x_tx_set_timestamping_mode(&adapter->tx[index], 1313 false, false); 1314 lan743x_ptp_set_sync_ts_insert(adapter, false); 1315 break; 1316 case HWTSTAMP_TX_ON: 1317 for (index = 0; index < LAN743X_MAX_TX_CHANNELS; 1318 index++) 1319 lan743x_tx_set_timestamping_mode(&adapter->tx[index], 1320 true, false); 1321 lan743x_ptp_set_sync_ts_insert(adapter, false); 1322 break; 1323 case HWTSTAMP_TX_ONESTEP_SYNC: 1324 for (index = 0; index < LAN743X_MAX_TX_CHANNELS; 1325 index++) 1326 lan743x_tx_set_timestamping_mode(&adapter->tx[index], 1327 true, true); 1328 1329 lan743x_ptp_set_sync_ts_insert(adapter, true); 1330 break; 1331 case HWTSTAMP_TX_ONESTEP_P2P: 1332 ret = -ERANGE; 1333 break; 1334 default: 1335 netif_warn(adapter, drv, adapter->netdev, 1336 " tx_type = %d, UNKNOWN\n", config.tx_type); 1337 ret = -EINVAL; 1338 break; 1339 } 1340 1341 if (!ret) 1342 return copy_to_user(ifr->ifr_data, &config, 1343 sizeof(config)) ? -EFAULT : 0; 1344 return ret; 1345 } 1346