1 /* SPDX-License-Identifier: GPL-2.0+ */ 2 /* Copyright (C) 2018 Microchip Technology Inc. */ 3 4 #include <linux/netdevice.h> 5 #include "lan743x_main.h" 6 7 #include <linux/ptp_clock_kernel.h> 8 #include <linux/module.h> 9 #include <linux/pci.h> 10 #include <linux/net_tstamp.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 495 if (on) { 496 perout_pin = ptp_find_pin(ptp->ptp_clock, PTP_PF_PEROUT, 497 perout_request->index); 498 if (perout_pin < 0) 499 return -EBUSY; 500 } else { 501 lan743x_ptp_perout_off(adapter, index); 502 return 0; 503 } 504 505 if (perout->event_ch >= 0 || 506 perout->gpio_pin >= 0) { 507 /* already on, turn off first */ 508 lan743x_ptp_perout_off(adapter, index); 509 } 510 511 perout->event_ch = lan743x_ptp_reserve_event_ch(adapter, index); 512 513 if (perout->event_ch < 0) { 514 netif_warn(adapter, drv, adapter->netdev, 515 "Failed to reserve event channel %d for PEROUT\n", 516 index); 517 goto failed; 518 } 519 520 perout->gpio_pin = lan743x_gpio_rsrv_ptp_out(adapter, 521 perout_pin, 522 perout->event_ch); 523 524 if (perout->gpio_pin < 0) { 525 netif_warn(adapter, drv, adapter->netdev, 526 "Failed to reserve gpio %d for PEROUT\n", 527 perout_pin); 528 goto failed; 529 } 530 531 start_sec = perout_request->start.sec; 532 start_sec += perout_request->start.nsec / 1000000000; 533 start_nsec = perout_request->start.nsec % 1000000000; 534 535 period_sec = perout_request->period.sec; 536 period_sec += perout_request->period.nsec / 1000000000; 537 period_nsec = perout_request->period.nsec % 1000000000; 538 539 if (period_sec == 0) { 540 if (period_nsec >= 400000000) { 541 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_; 542 } else if (period_nsec >= 20000000) { 543 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10MS_; 544 } else if (period_nsec >= 2000000) { 545 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_1MS_; 546 } else if (period_nsec >= 200000) { 547 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100US_; 548 } else if (period_nsec >= 20000) { 549 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10US_; 550 } else if (period_nsec >= 200) { 551 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100NS_; 552 } else { 553 netif_warn(adapter, drv, adapter->netdev, 554 "perout period too small, minimum is 200nS\n"); 555 goto failed; 556 } 557 } else { 558 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_; 559 } 560 561 /* turn off by setting target far in future */ 562 lan743x_csr_write(adapter, 563 PTP_CLOCK_TARGET_SEC_X(perout->event_ch), 564 0xFFFF0000); 565 lan743x_csr_write(adapter, 566 PTP_CLOCK_TARGET_NS_X(perout->event_ch), 0); 567 568 /* Configure to pulse every period */ 569 general_config = lan743x_csr_read(adapter, PTP_GENERAL_CONFIG); 570 general_config &= ~(PTP_GENERAL_CONFIG_CLOCK_EVENT_X_MASK_ 571 (perout->event_ch)); 572 general_config |= PTP_GENERAL_CONFIG_CLOCK_EVENT_X_SET_ 573 (perout->event_ch, pulse_width); 574 general_config &= ~PTP_GENERAL_CONFIG_RELOAD_ADD_X_ 575 (perout->event_ch); 576 lan743x_csr_write(adapter, PTP_GENERAL_CONFIG, general_config); 577 578 /* set the reload to one toggle cycle */ 579 lan743x_csr_write(adapter, 580 PTP_CLOCK_TARGET_RELOAD_SEC_X(perout->event_ch), 581 period_sec); 582 lan743x_csr_write(adapter, 583 PTP_CLOCK_TARGET_RELOAD_NS_X(perout->event_ch), 584 period_nsec); 585 586 /* set the start time */ 587 lan743x_csr_write(adapter, 588 PTP_CLOCK_TARGET_SEC_X(perout->event_ch), 589 start_sec); 590 lan743x_csr_write(adapter, 591 PTP_CLOCK_TARGET_NS_X(perout->event_ch), 592 start_nsec); 593 594 return 0; 595 596 failed: 597 lan743x_ptp_perout_off(adapter, index); 598 return -ENODEV; 599 } 600 601 static int lan743x_ptpci_enable(struct ptp_clock_info *ptpci, 602 struct ptp_clock_request *request, int on) 603 { 604 struct lan743x_ptp *ptp = 605 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 606 struct lan743x_adapter *adapter = 607 container_of(ptp, struct lan743x_adapter, ptp); 608 609 if (request) { 610 switch (request->type) { 611 case PTP_CLK_REQ_EXTTS: 612 return -EINVAL; 613 case PTP_CLK_REQ_PEROUT: 614 if (request->perout.index < ptpci->n_per_out) 615 return lan743x_ptp_perout(adapter, on, 616 &request->perout); 617 return -EINVAL; 618 case PTP_CLK_REQ_PPS: 619 return -EINVAL; 620 default: 621 netif_err(adapter, drv, adapter->netdev, 622 "request->type == %d, Unknown\n", 623 request->type); 624 break; 625 } 626 } else { 627 netif_err(adapter, drv, adapter->netdev, "request == NULL\n"); 628 } 629 return 0; 630 } 631 632 static int lan743x_ptpci_verify_pin_config(struct ptp_clock_info *ptp, 633 unsigned int pin, 634 enum ptp_pin_function func, 635 unsigned int chan) 636 { 637 int result = 0; 638 639 /* Confirm the requested function is supported. Parameter 640 * validation is done by the caller. 641 */ 642 switch (func) { 643 case PTP_PF_NONE: 644 case PTP_PF_PEROUT: 645 break; 646 case PTP_PF_EXTTS: 647 case PTP_PF_PHYSYNC: 648 default: 649 result = -1; 650 break; 651 } 652 return result; 653 } 654 655 static long lan743x_ptpci_do_aux_work(struct ptp_clock_info *ptpci) 656 { 657 struct lan743x_ptp *ptp = 658 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 659 struct lan743x_adapter *adapter = 660 container_of(ptp, struct lan743x_adapter, ptp); 661 u32 cap_info, cause, header, nsec, seconds; 662 bool new_timestamp_available = false; 663 int count = 0; 664 665 while ((count < 100) && 666 (lan743x_csr_read(adapter, PTP_INT_STS) & PTP_INT_BIT_TX_TS_)) { 667 count++; 668 cap_info = lan743x_csr_read(adapter, PTP_CAP_INFO); 669 670 if (PTP_CAP_INFO_TX_TS_CNT_GET_(cap_info) > 0) { 671 seconds = lan743x_csr_read(adapter, 672 PTP_TX_EGRESS_SEC); 673 nsec = lan743x_csr_read(adapter, PTP_TX_EGRESS_NS); 674 cause = (nsec & 675 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_MASK_); 676 header = lan743x_csr_read(adapter, 677 PTP_TX_MSG_HEADER); 678 679 if (cause == PTP_TX_EGRESS_NS_CAPTURE_CAUSE_SW_) { 680 nsec &= PTP_TX_EGRESS_NS_TS_NS_MASK_; 681 lan743x_ptp_tx_ts_enqueue_ts(adapter, 682 seconds, nsec, 683 header); 684 new_timestamp_available = true; 685 } else if (cause == 686 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_AUTO_) { 687 netif_err(adapter, drv, adapter->netdev, 688 "Auto capture cause not supported\n"); 689 } else { 690 netif_warn(adapter, drv, adapter->netdev, 691 "unknown tx timestamp capture cause\n"); 692 } 693 } else { 694 netif_warn(adapter, drv, adapter->netdev, 695 "TX TS INT but no TX TS CNT\n"); 696 } 697 lan743x_csr_write(adapter, PTP_INT_STS, PTP_INT_BIT_TX_TS_); 698 } 699 700 if (new_timestamp_available) 701 lan743x_ptp_tx_ts_complete(adapter); 702 703 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_); 704 705 return -1; 706 } 707 708 static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter, 709 u32 *seconds, u32 *nano_seconds, 710 u32 *sub_nano_seconds) 711 { 712 struct lan743x_ptp *ptp = &adapter->ptp; 713 714 mutex_lock(&ptp->command_lock); 715 716 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_READ_); 717 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_READ_); 718 719 if (seconds) 720 (*seconds) = lan743x_csr_read(adapter, PTP_CLOCK_SEC); 721 722 if (nano_seconds) 723 (*nano_seconds) = lan743x_csr_read(adapter, PTP_CLOCK_NS); 724 725 if (sub_nano_seconds) 726 (*sub_nano_seconds) = 727 lan743x_csr_read(adapter, PTP_CLOCK_SUBNS); 728 729 mutex_unlock(&ptp->command_lock); 730 } 731 732 static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter, 733 s64 time_step_ns) 734 { 735 struct lan743x_ptp *ptp = &adapter->ptp; 736 u32 nano_seconds_step = 0; 737 u64 abs_time_step_ns = 0; 738 u32 unsigned_seconds = 0; 739 u32 nano_seconds = 0; 740 u32 remainder = 0; 741 s32 seconds = 0; 742 743 if (time_step_ns > 15000000000LL) { 744 /* convert to clock set */ 745 lan743x_ptp_clock_get(adapter, &unsigned_seconds, 746 &nano_seconds, NULL); 747 unsigned_seconds += div_u64_rem(time_step_ns, 1000000000LL, 748 &remainder); 749 nano_seconds += remainder; 750 if (nano_seconds >= 1000000000) { 751 unsigned_seconds++; 752 nano_seconds -= 1000000000; 753 } 754 lan743x_ptp_clock_set(adapter, unsigned_seconds, 755 nano_seconds, 0); 756 return; 757 } else if (time_step_ns < -15000000000LL) { 758 /* convert to clock set */ 759 time_step_ns = -time_step_ns; 760 761 lan743x_ptp_clock_get(adapter, &unsigned_seconds, 762 &nano_seconds, NULL); 763 unsigned_seconds -= div_u64_rem(time_step_ns, 1000000000LL, 764 &remainder); 765 nano_seconds_step = remainder; 766 if (nano_seconds < nano_seconds_step) { 767 unsigned_seconds--; 768 nano_seconds += 1000000000; 769 } 770 nano_seconds -= nano_seconds_step; 771 lan743x_ptp_clock_set(adapter, unsigned_seconds, 772 nano_seconds, 0); 773 return; 774 } 775 776 /* do clock step */ 777 if (time_step_ns >= 0) { 778 abs_time_step_ns = (u64)(time_step_ns); 779 seconds = (s32)div_u64_rem(abs_time_step_ns, 1000000000, 780 &remainder); 781 nano_seconds = (u32)remainder; 782 } else { 783 abs_time_step_ns = (u64)(-time_step_ns); 784 seconds = -((s32)div_u64_rem(abs_time_step_ns, 1000000000, 785 &remainder)); 786 nano_seconds = (u32)remainder; 787 if (nano_seconds > 0) { 788 /* subtracting nano seconds is not allowed 789 * convert to subtracting from seconds, 790 * and adding to nanoseconds 791 */ 792 seconds--; 793 nano_seconds = (1000000000 - nano_seconds); 794 } 795 } 796 797 if (nano_seconds > 0) { 798 /* add 8 ns to cover the likely normal increment */ 799 nano_seconds += 8; 800 } 801 802 if (nano_seconds >= 1000000000) { 803 /* carry into seconds */ 804 seconds++; 805 nano_seconds -= 1000000000; 806 } 807 808 while (seconds) { 809 mutex_lock(&ptp->command_lock); 810 if (seconds > 0) { 811 u32 adjustment_value = (u32)seconds; 812 813 if (adjustment_value > 0xF) 814 adjustment_value = 0xF; 815 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ, 816 PTP_CLOCK_STEP_ADJ_DIR_ | 817 adjustment_value); 818 seconds -= ((s32)adjustment_value); 819 } else { 820 u32 adjustment_value = (u32)(-seconds); 821 822 if (adjustment_value > 0xF) 823 adjustment_value = 0xF; 824 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ, 825 adjustment_value); 826 seconds += ((s32)adjustment_value); 827 } 828 lan743x_csr_write(adapter, PTP_CMD_CTL, 829 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_); 830 lan743x_ptp_wait_till_cmd_done(adapter, 831 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_); 832 mutex_unlock(&ptp->command_lock); 833 } 834 if (nano_seconds) { 835 mutex_lock(&ptp->command_lock); 836 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ, 837 PTP_CLOCK_STEP_ADJ_DIR_ | 838 (nano_seconds & 839 PTP_CLOCK_STEP_ADJ_VALUE_MASK_)); 840 lan743x_csr_write(adapter, PTP_CMD_CTL, 841 PTP_CMD_CTL_PTP_CLK_STP_NSEC_); 842 lan743x_ptp_wait_till_cmd_done(adapter, 843 PTP_CMD_CTL_PTP_CLK_STP_NSEC_); 844 mutex_unlock(&ptp->command_lock); 845 } 846 } 847 848 void lan743x_ptp_isr(void *context) 849 { 850 struct lan743x_adapter *adapter = (struct lan743x_adapter *)context; 851 struct lan743x_ptp *ptp = NULL; 852 int enable_flag = 1; 853 u32 ptp_int_sts = 0; 854 855 ptp = &adapter->ptp; 856 857 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_); 858 859 ptp_int_sts = lan743x_csr_read(adapter, PTP_INT_STS); 860 ptp_int_sts &= lan743x_csr_read(adapter, PTP_INT_EN_SET); 861 862 if (ptp_int_sts & PTP_INT_BIT_TX_TS_) { 863 ptp_schedule_worker(ptp->ptp_clock, 0); 864 enable_flag = 0;/* tasklet will re-enable later */ 865 } 866 if (ptp_int_sts & PTP_INT_BIT_TX_SWTS_ERR_) { 867 netif_err(adapter, drv, adapter->netdev, 868 "PTP TX Software Timestamp Error\n"); 869 /* clear int status bit */ 870 lan743x_csr_write(adapter, PTP_INT_STS, 871 PTP_INT_BIT_TX_SWTS_ERR_); 872 } 873 if (ptp_int_sts & PTP_INT_BIT_TIMER_B_) { 874 /* clear int status bit */ 875 lan743x_csr_write(adapter, PTP_INT_STS, 876 PTP_INT_BIT_TIMER_B_); 877 } 878 if (ptp_int_sts & PTP_INT_BIT_TIMER_A_) { 879 /* clear int status bit */ 880 lan743x_csr_write(adapter, PTP_INT_STS, 881 PTP_INT_BIT_TIMER_A_); 882 } 883 884 if (enable_flag) { 885 /* re-enable isr */ 886 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_); 887 } 888 } 889 890 static void lan743x_ptp_tx_ts_enqueue_skb(struct lan743x_adapter *adapter, 891 struct sk_buff *skb, bool ignore_sync) 892 { 893 struct lan743x_ptp *ptp = &adapter->ptp; 894 895 spin_lock_bh(&ptp->tx_ts_lock); 896 if (ptp->tx_ts_skb_queue_size < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) { 897 ptp->tx_ts_skb_queue[ptp->tx_ts_skb_queue_size] = skb; 898 if (ignore_sync) 899 ptp->tx_ts_ignore_sync_queue |= 900 BIT(ptp->tx_ts_skb_queue_size); 901 ptp->tx_ts_skb_queue_size++; 902 } else { 903 /* this should never happen, so long as the tx channel 904 * calls and honors the result from 905 * lan743x_ptp_request_tx_timestamp 906 */ 907 netif_err(adapter, drv, adapter->netdev, 908 "tx ts skb queue overflow\n"); 909 dev_kfree_skb(skb); 910 } 911 spin_unlock_bh(&ptp->tx_ts_lock); 912 } 913 914 static void lan743x_ptp_sync_to_system_clock(struct lan743x_adapter *adapter) 915 { 916 struct timespec64 ts; 917 918 ktime_get_clocktai_ts64(&ts); 919 920 lan743x_ptp_clock_set(adapter, ts.tv_sec, ts.tv_nsec, 0); 921 } 922 923 void lan743x_ptp_update_latency(struct lan743x_adapter *adapter, 924 u32 link_speed) 925 { 926 switch (link_speed) { 927 case 10: 928 lan743x_csr_write(adapter, PTP_LATENCY, 929 PTP_LATENCY_TX_SET_(0) | 930 PTP_LATENCY_RX_SET_(0)); 931 break; 932 case 100: 933 lan743x_csr_write(adapter, PTP_LATENCY, 934 PTP_LATENCY_TX_SET_(181) | 935 PTP_LATENCY_RX_SET_(594)); 936 break; 937 case 1000: 938 lan743x_csr_write(adapter, PTP_LATENCY, 939 PTP_LATENCY_TX_SET_(30) | 940 PTP_LATENCY_RX_SET_(525)); 941 break; 942 } 943 } 944 945 int lan743x_ptp_init(struct lan743x_adapter *adapter) 946 { 947 struct lan743x_ptp *ptp = &adapter->ptp; 948 int i; 949 950 mutex_init(&ptp->command_lock); 951 spin_lock_init(&ptp->tx_ts_lock); 952 ptp->used_event_ch = 0; 953 954 for (i = 0; i < LAN743X_PTP_N_EVENT_CHAN; i++) { 955 ptp->perout[i].event_ch = -1; 956 ptp->perout[i].gpio_pin = -1; 957 } 958 959 lan743x_led_mux_save(adapter); 960 961 return 0; 962 } 963 964 int lan743x_ptp_open(struct lan743x_adapter *adapter) 965 { 966 struct lan743x_ptp *ptp = &adapter->ptp; 967 int ret = -ENODEV; 968 u32 temp; 969 int i; 970 int n_pins; 971 972 lan743x_ptp_reset(adapter); 973 lan743x_ptp_sync_to_system_clock(adapter); 974 temp = lan743x_csr_read(adapter, PTP_TX_MOD2); 975 temp |= PTP_TX_MOD2_TX_PTP_CLR_UDPV4_CHKSUM_; 976 lan743x_csr_write(adapter, PTP_TX_MOD2, temp); 977 lan743x_ptp_enable(adapter); 978 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_); 979 lan743x_csr_write(adapter, PTP_INT_EN_SET, 980 PTP_INT_BIT_TX_SWTS_ERR_ | PTP_INT_BIT_TX_TS_); 981 ptp->flags |= PTP_FLAG_ISR_ENABLED; 982 983 if (!IS_ENABLED(CONFIG_PTP_1588_CLOCK)) 984 return 0; 985 986 switch (adapter->csr.id_rev & ID_REV_ID_MASK_) { 987 case ID_REV_ID_LAN7430_: 988 n_pins = LAN7430_N_GPIO; 989 break; 990 case ID_REV_ID_LAN7431_: 991 n_pins = LAN7431_N_GPIO; 992 break; 993 default: 994 netif_warn(adapter, drv, adapter->netdev, 995 "Unknown LAN743x (%08x). Assuming no GPIO\n", 996 adapter->csr.id_rev); 997 n_pins = 0; 998 break; 999 } 1000 1001 if (n_pins > LAN743X_PTP_N_GPIO) 1002 n_pins = LAN743X_PTP_N_GPIO; 1003 1004 for (i = 0; i < n_pins; i++) { 1005 struct ptp_pin_desc *ptp_pin = &ptp->pin_config[i]; 1006 1007 snprintf(ptp_pin->name, 1008 sizeof(ptp_pin->name), "lan743x_ptp_pin_%02d", i); 1009 ptp_pin->index = i; 1010 ptp_pin->func = PTP_PF_NONE; 1011 } 1012 1013 ptp->ptp_clock_info.owner = THIS_MODULE; 1014 snprintf(ptp->ptp_clock_info.name, 16, "%pm", 1015 adapter->netdev->dev_addr); 1016 ptp->ptp_clock_info.max_adj = LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB; 1017 ptp->ptp_clock_info.n_alarm = 0; 1018 ptp->ptp_clock_info.n_ext_ts = 0; 1019 ptp->ptp_clock_info.n_per_out = LAN743X_PTP_N_EVENT_CHAN; 1020 ptp->ptp_clock_info.n_pins = n_pins; 1021 ptp->ptp_clock_info.pps = 0; 1022 ptp->ptp_clock_info.pin_config = ptp->pin_config; 1023 ptp->ptp_clock_info.adjfine = lan743x_ptpci_adjfine; 1024 ptp->ptp_clock_info.adjfreq = lan743x_ptpci_adjfreq; 1025 ptp->ptp_clock_info.adjtime = lan743x_ptpci_adjtime; 1026 ptp->ptp_clock_info.gettime64 = lan743x_ptpci_gettime64; 1027 ptp->ptp_clock_info.getcrosststamp = NULL; 1028 ptp->ptp_clock_info.settime64 = lan743x_ptpci_settime64; 1029 ptp->ptp_clock_info.enable = lan743x_ptpci_enable; 1030 ptp->ptp_clock_info.do_aux_work = lan743x_ptpci_do_aux_work; 1031 ptp->ptp_clock_info.verify = lan743x_ptpci_verify_pin_config; 1032 1033 ptp->ptp_clock = ptp_clock_register(&ptp->ptp_clock_info, 1034 &adapter->pdev->dev); 1035 1036 if (IS_ERR(ptp->ptp_clock)) { 1037 netif_err(adapter, ifup, adapter->netdev, 1038 "ptp_clock_register failed\n"); 1039 goto done; 1040 } 1041 ptp->flags |= PTP_FLAG_PTP_CLOCK_REGISTERED; 1042 netif_info(adapter, ifup, adapter->netdev, 1043 "successfully registered ptp clock\n"); 1044 1045 return 0; 1046 done: 1047 lan743x_ptp_close(adapter); 1048 return ret; 1049 } 1050 1051 void lan743x_ptp_close(struct lan743x_adapter *adapter) 1052 { 1053 struct lan743x_ptp *ptp = &adapter->ptp; 1054 int index; 1055 1056 if (IS_ENABLED(CONFIG_PTP_1588_CLOCK) && 1057 (ptp->flags & PTP_FLAG_PTP_CLOCK_REGISTERED)) { 1058 ptp_clock_unregister(ptp->ptp_clock); 1059 ptp->ptp_clock = NULL; 1060 ptp->flags &= ~PTP_FLAG_PTP_CLOCK_REGISTERED; 1061 netif_info(adapter, drv, adapter->netdev, 1062 "ptp clock unregister\n"); 1063 } 1064 1065 if (ptp->flags & PTP_FLAG_ISR_ENABLED) { 1066 lan743x_csr_write(adapter, PTP_INT_EN_CLR, 1067 PTP_INT_BIT_TX_SWTS_ERR_ | 1068 PTP_INT_BIT_TX_TS_); 1069 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_); 1070 ptp->flags &= ~PTP_FLAG_ISR_ENABLED; 1071 } 1072 1073 /* clean up pending timestamp requests */ 1074 lan743x_ptp_tx_ts_complete(adapter); 1075 spin_lock_bh(&ptp->tx_ts_lock); 1076 for (index = 0; 1077 index < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS; 1078 index++) { 1079 struct sk_buff *skb = ptp->tx_ts_skb_queue[index]; 1080 1081 dev_kfree_skb(skb); 1082 ptp->tx_ts_skb_queue[index] = NULL; 1083 ptp->tx_ts_seconds_queue[index] = 0; 1084 ptp->tx_ts_nseconds_queue[index] = 0; 1085 } 1086 ptp->tx_ts_skb_queue_size = 0; 1087 ptp->tx_ts_queue_size = 0; 1088 ptp->pending_tx_timestamps = 0; 1089 spin_unlock_bh(&ptp->tx_ts_lock); 1090 1091 lan743x_led_mux_restore(adapter); 1092 1093 lan743x_ptp_disable(adapter); 1094 } 1095 1096 static void lan743x_ptp_set_sync_ts_insert(struct lan743x_adapter *adapter, 1097 bool ts_insert_enable) 1098 { 1099 u32 ptp_tx_mod = lan743x_csr_read(adapter, PTP_TX_MOD); 1100 1101 if (ts_insert_enable) 1102 ptp_tx_mod |= PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_; 1103 else 1104 ptp_tx_mod &= ~PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_; 1105 1106 lan743x_csr_write(adapter, PTP_TX_MOD, ptp_tx_mod); 1107 } 1108 1109 static bool lan743x_ptp_is_enabled(struct lan743x_adapter *adapter) 1110 { 1111 if (lan743x_csr_read(adapter, PTP_CMD_CTL) & PTP_CMD_CTL_PTP_ENABLE_) 1112 return true; 1113 return false; 1114 } 1115 1116 static void lan743x_ptp_enable(struct lan743x_adapter *adapter) 1117 { 1118 struct lan743x_ptp *ptp = &adapter->ptp; 1119 1120 mutex_lock(&ptp->command_lock); 1121 1122 if (lan743x_ptp_is_enabled(adapter)) { 1123 netif_warn(adapter, drv, adapter->netdev, 1124 "PTP already enabled\n"); 1125 goto done; 1126 } 1127 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_ENABLE_); 1128 done: 1129 mutex_unlock(&ptp->command_lock); 1130 } 1131 1132 static void lan743x_ptp_disable(struct lan743x_adapter *adapter) 1133 { 1134 struct lan743x_ptp *ptp = &adapter->ptp; 1135 1136 mutex_lock(&ptp->command_lock); 1137 if (!lan743x_ptp_is_enabled(adapter)) { 1138 netif_warn(adapter, drv, adapter->netdev, 1139 "PTP already disabled\n"); 1140 goto done; 1141 } 1142 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_DISABLE_); 1143 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_ENABLE_); 1144 done: 1145 mutex_unlock(&ptp->command_lock); 1146 } 1147 1148 static void lan743x_ptp_reset(struct lan743x_adapter *adapter) 1149 { 1150 struct lan743x_ptp *ptp = &adapter->ptp; 1151 1152 mutex_lock(&ptp->command_lock); 1153 1154 if (lan743x_ptp_is_enabled(adapter)) { 1155 netif_err(adapter, drv, adapter->netdev, 1156 "Attempting reset while enabled\n"); 1157 goto done; 1158 } 1159 1160 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_RESET_); 1161 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_RESET_); 1162 done: 1163 mutex_unlock(&ptp->command_lock); 1164 } 1165 1166 static void lan743x_ptp_clock_set(struct lan743x_adapter *adapter, 1167 u32 seconds, u32 nano_seconds, 1168 u32 sub_nano_seconds) 1169 { 1170 struct lan743x_ptp *ptp = &adapter->ptp; 1171 1172 mutex_lock(&ptp->command_lock); 1173 1174 lan743x_csr_write(adapter, PTP_CLOCK_SEC, seconds); 1175 lan743x_csr_write(adapter, PTP_CLOCK_NS, nano_seconds); 1176 lan743x_csr_write(adapter, PTP_CLOCK_SUBNS, sub_nano_seconds); 1177 1178 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_LOAD_); 1179 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_LOAD_); 1180 mutex_unlock(&ptp->command_lock); 1181 } 1182 1183 bool lan743x_ptp_request_tx_timestamp(struct lan743x_adapter *adapter) 1184 { 1185 struct lan743x_ptp *ptp = &adapter->ptp; 1186 bool result = false; 1187 1188 spin_lock_bh(&ptp->tx_ts_lock); 1189 if (ptp->pending_tx_timestamps < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) { 1190 /* request granted */ 1191 ptp->pending_tx_timestamps++; 1192 result = true; 1193 } 1194 spin_unlock_bh(&ptp->tx_ts_lock); 1195 return result; 1196 } 1197 1198 void lan743x_ptp_unrequest_tx_timestamp(struct lan743x_adapter *adapter) 1199 { 1200 struct lan743x_ptp *ptp = &adapter->ptp; 1201 1202 spin_lock_bh(&ptp->tx_ts_lock); 1203 if (ptp->pending_tx_timestamps > 0) 1204 ptp->pending_tx_timestamps--; 1205 else 1206 netif_err(adapter, drv, adapter->netdev, 1207 "unrequest failed, pending_tx_timestamps==0\n"); 1208 spin_unlock_bh(&ptp->tx_ts_lock); 1209 } 1210 1211 void lan743x_ptp_tx_timestamp_skb(struct lan743x_adapter *adapter, 1212 struct sk_buff *skb, bool ignore_sync) 1213 { 1214 lan743x_ptp_tx_ts_enqueue_skb(adapter, skb, ignore_sync); 1215 1216 lan743x_ptp_tx_ts_complete(adapter); 1217 } 1218 1219 int lan743x_ptp_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd) 1220 { 1221 struct lan743x_adapter *adapter = netdev_priv(netdev); 1222 struct hwtstamp_config config; 1223 int ret = 0; 1224 int index; 1225 1226 if (!ifr) { 1227 netif_err(adapter, drv, adapter->netdev, 1228 "SIOCSHWTSTAMP, ifr == NULL\n"); 1229 return -EINVAL; 1230 } 1231 1232 if (copy_from_user(&config, ifr->ifr_data, sizeof(config))) 1233 return -EFAULT; 1234 1235 if (config.flags) { 1236 netif_warn(adapter, drv, adapter->netdev, 1237 "ignoring hwtstamp_config.flags == 0x%08X, expected 0\n", 1238 config.flags); 1239 } 1240 1241 switch (config.tx_type) { 1242 case HWTSTAMP_TX_OFF: 1243 for (index = 0; index < LAN743X_MAX_TX_CHANNELS; 1244 index++) 1245 lan743x_tx_set_timestamping_mode(&adapter->tx[index], 1246 false, false); 1247 lan743x_ptp_set_sync_ts_insert(adapter, false); 1248 break; 1249 case HWTSTAMP_TX_ON: 1250 for (index = 0; index < LAN743X_MAX_TX_CHANNELS; 1251 index++) 1252 lan743x_tx_set_timestamping_mode(&adapter->tx[index], 1253 true, false); 1254 lan743x_ptp_set_sync_ts_insert(adapter, false); 1255 break; 1256 case HWTSTAMP_TX_ONESTEP_SYNC: 1257 for (index = 0; index < LAN743X_MAX_TX_CHANNELS; 1258 index++) 1259 lan743x_tx_set_timestamping_mode(&adapter->tx[index], 1260 true, true); 1261 1262 lan743x_ptp_set_sync_ts_insert(adapter, true); 1263 break; 1264 default: 1265 netif_warn(adapter, drv, adapter->netdev, 1266 " tx_type = %d, UNKNOWN\n", config.tx_type); 1267 ret = -EINVAL; 1268 break; 1269 } 1270 1271 if (!ret) 1272 return copy_to_user(ifr->ifr_data, &config, 1273 sizeof(config)) ? -EFAULT : 0; 1274 return ret; 1275 } 1276