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 static int lan743x_get_channel(u32 ch_map) 29 { 30 int idx; 31 32 for (idx = 0; idx < 32; idx++) { 33 if (ch_map & (0x1 << idx)) 34 return idx; 35 } 36 37 return -EINVAL; 38 } 39 40 int lan743x_gpio_init(struct lan743x_adapter *adapter) 41 { 42 struct lan743x_gpio *gpio = &adapter->gpio; 43 44 spin_lock_init(&gpio->gpio_lock); 45 46 gpio->gpio_cfg0 = 0; /* set all direction to input, data = 0 */ 47 gpio->gpio_cfg1 = 0x0FFF0000;/* disable all gpio, set to open drain */ 48 gpio->gpio_cfg2 = 0;/* set all to 1588 low polarity level */ 49 gpio->gpio_cfg3 = 0;/* disable all 1588 output */ 50 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0); 51 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1); 52 lan743x_csr_write(adapter, GPIO_CFG2, gpio->gpio_cfg2); 53 lan743x_csr_write(adapter, GPIO_CFG3, gpio->gpio_cfg3); 54 55 return 0; 56 } 57 58 static void lan743x_ptp_wait_till_cmd_done(struct lan743x_adapter *adapter, 59 u32 bit_mask) 60 { 61 int timeout = PTP_CMD_CTL_TIMEOUT_CNT; 62 u32 data = 0; 63 64 while (timeout && 65 (data = (lan743x_csr_read(adapter, PTP_CMD_CTL) & 66 bit_mask))) { 67 usleep_range(1000, 20000); 68 timeout--; 69 } 70 if (data) { 71 netif_err(adapter, drv, adapter->netdev, 72 "timeout waiting for cmd to be done, cmd = 0x%08X\n", 73 bit_mask); 74 } 75 } 76 77 static void lan743x_ptp_tx_ts_enqueue_ts(struct lan743x_adapter *adapter, 78 u32 seconds, u32 nano_seconds, 79 u32 header) 80 { 81 struct lan743x_ptp *ptp = &adapter->ptp; 82 83 spin_lock_bh(&ptp->tx_ts_lock); 84 if (ptp->tx_ts_queue_size < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) { 85 ptp->tx_ts_seconds_queue[ptp->tx_ts_queue_size] = seconds; 86 ptp->tx_ts_nseconds_queue[ptp->tx_ts_queue_size] = nano_seconds; 87 ptp->tx_ts_header_queue[ptp->tx_ts_queue_size] = header; 88 ptp->tx_ts_queue_size++; 89 } else { 90 netif_err(adapter, drv, adapter->netdev, 91 "tx ts queue overflow\n"); 92 } 93 spin_unlock_bh(&ptp->tx_ts_lock); 94 } 95 96 static void lan743x_ptp_tx_ts_complete(struct lan743x_adapter *adapter) 97 { 98 struct lan743x_ptp *ptp = &adapter->ptp; 99 struct skb_shared_hwtstamps tstamps; 100 u32 header, nseconds, seconds; 101 bool ignore_sync = false; 102 struct sk_buff *skb; 103 int c, i; 104 105 spin_lock_bh(&ptp->tx_ts_lock); 106 c = ptp->tx_ts_skb_queue_size; 107 108 if (c > ptp->tx_ts_queue_size) 109 c = ptp->tx_ts_queue_size; 110 if (c <= 0) 111 goto done; 112 113 for (i = 0; i < c; i++) { 114 ignore_sync = ((ptp->tx_ts_ignore_sync_queue & 115 BIT(i)) != 0); 116 skb = ptp->tx_ts_skb_queue[i]; 117 nseconds = ptp->tx_ts_nseconds_queue[i]; 118 seconds = ptp->tx_ts_seconds_queue[i]; 119 header = ptp->tx_ts_header_queue[i]; 120 121 memset(&tstamps, 0, sizeof(tstamps)); 122 tstamps.hwtstamp = ktime_set(seconds, nseconds); 123 if (!ignore_sync || 124 ((header & PTP_TX_MSG_HEADER_MSG_TYPE_) != 125 PTP_TX_MSG_HEADER_MSG_TYPE_SYNC_)) 126 skb_tstamp_tx(skb, &tstamps); 127 128 dev_kfree_skb(skb); 129 130 ptp->tx_ts_skb_queue[i] = NULL; 131 ptp->tx_ts_seconds_queue[i] = 0; 132 ptp->tx_ts_nseconds_queue[i] = 0; 133 ptp->tx_ts_header_queue[i] = 0; 134 } 135 136 /* shift queue */ 137 ptp->tx_ts_ignore_sync_queue >>= c; 138 for (i = c; i < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS; i++) { 139 ptp->tx_ts_skb_queue[i - c] = ptp->tx_ts_skb_queue[i]; 140 ptp->tx_ts_seconds_queue[i - c] = ptp->tx_ts_seconds_queue[i]; 141 ptp->tx_ts_nseconds_queue[i - c] = ptp->tx_ts_nseconds_queue[i]; 142 ptp->tx_ts_header_queue[i - c] = ptp->tx_ts_header_queue[i]; 143 144 ptp->tx_ts_skb_queue[i] = NULL; 145 ptp->tx_ts_seconds_queue[i] = 0; 146 ptp->tx_ts_nseconds_queue[i] = 0; 147 ptp->tx_ts_header_queue[i] = 0; 148 } 149 ptp->tx_ts_skb_queue_size -= c; 150 ptp->tx_ts_queue_size -= c; 151 done: 152 ptp->pending_tx_timestamps -= c; 153 spin_unlock_bh(&ptp->tx_ts_lock); 154 } 155 156 static int lan743x_ptp_reserve_event_ch(struct lan743x_adapter *adapter, 157 int event_channel) 158 { 159 struct lan743x_ptp *ptp = &adapter->ptp; 160 int result = -ENODEV; 161 162 mutex_lock(&ptp->command_lock); 163 if (!(test_bit(event_channel, &ptp->used_event_ch))) { 164 ptp->used_event_ch |= BIT(event_channel); 165 result = event_channel; 166 } else { 167 netif_warn(adapter, drv, adapter->netdev, 168 "attempted to reserved a used event_channel = %d\n", 169 event_channel); 170 } 171 mutex_unlock(&ptp->command_lock); 172 return result; 173 } 174 175 static void lan743x_ptp_release_event_ch(struct lan743x_adapter *adapter, 176 int event_channel) 177 { 178 struct lan743x_ptp *ptp = &adapter->ptp; 179 180 mutex_lock(&ptp->command_lock); 181 if (test_bit(event_channel, &ptp->used_event_ch)) { 182 ptp->used_event_ch &= ~BIT(event_channel); 183 } else { 184 netif_warn(adapter, drv, adapter->netdev, 185 "attempted release on a not used event_channel = %d\n", 186 event_channel); 187 } 188 mutex_unlock(&ptp->command_lock); 189 } 190 191 static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter, 192 u32 *seconds, u32 *nano_seconds, 193 u32 *sub_nano_seconds); 194 static void lan743x_ptp_io_clock_get(struct lan743x_adapter *adapter, 195 u32 *sec, u32 *nsec, u32 *sub_nsec); 196 static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter, 197 s64 time_step_ns); 198 199 static void lan743x_led_mux_enable(struct lan743x_adapter *adapter, 200 int pin, bool enable) 201 { 202 struct lan743x_ptp *ptp = &adapter->ptp; 203 204 if (ptp->leds_multiplexed && 205 ptp->led_enabled[pin]) { 206 u32 val = lan743x_csr_read(adapter, HW_CFG); 207 208 if (enable) 209 val |= LAN743X_LED_ENABLE(pin); 210 else 211 val &= ~LAN743X_LED_ENABLE(pin); 212 213 lan743x_csr_write(adapter, HW_CFG, val); 214 } 215 } 216 217 static void lan743x_led_mux_save(struct lan743x_adapter *adapter) 218 { 219 struct lan743x_ptp *ptp = &adapter->ptp; 220 u32 id_rev = adapter->csr.id_rev & ID_REV_ID_MASK_; 221 222 if (id_rev == ID_REV_ID_LAN7430_) { 223 int i; 224 u32 val = lan743x_csr_read(adapter, HW_CFG); 225 226 for (i = 0; i < LAN7430_N_LED; i++) { 227 bool led_enabled = (val & LAN743X_LED_ENABLE(i)) != 0; 228 229 ptp->led_enabled[i] = led_enabled; 230 } 231 ptp->leds_multiplexed = true; 232 } else { 233 ptp->leds_multiplexed = false; 234 } 235 } 236 237 static void lan743x_led_mux_restore(struct lan743x_adapter *adapter) 238 { 239 u32 id_rev = adapter->csr.id_rev & ID_REV_ID_MASK_; 240 241 if (id_rev == ID_REV_ID_LAN7430_) { 242 int i; 243 244 for (i = 0; i < LAN7430_N_LED; i++) 245 lan743x_led_mux_enable(adapter, i, true); 246 } 247 } 248 249 static int lan743x_gpio_rsrv_ptp_out(struct lan743x_adapter *adapter, 250 int pin, int event_channel) 251 { 252 struct lan743x_gpio *gpio = &adapter->gpio; 253 unsigned long irq_flags = 0; 254 int bit_mask = BIT(pin); 255 int ret = -EBUSY; 256 257 spin_lock_irqsave(&gpio->gpio_lock, irq_flags); 258 259 if (!(gpio->used_bits & bit_mask)) { 260 gpio->used_bits |= bit_mask; 261 gpio->output_bits |= bit_mask; 262 gpio->ptp_bits |= bit_mask; 263 264 /* assign pin to GPIO function */ 265 lan743x_led_mux_enable(adapter, pin, false); 266 267 /* set as output, and zero initial value */ 268 gpio->gpio_cfg0 |= GPIO_CFG0_GPIO_DIR_BIT_(pin); 269 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DATA_BIT_(pin); 270 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0); 271 272 /* enable gpio, and set buffer type to push pull */ 273 gpio->gpio_cfg1 &= ~GPIO_CFG1_GPIOEN_BIT_(pin); 274 gpio->gpio_cfg1 |= GPIO_CFG1_GPIOBUF_BIT_(pin); 275 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1); 276 277 /* set 1588 polarity to high */ 278 gpio->gpio_cfg2 |= GPIO_CFG2_1588_POL_BIT_(pin); 279 lan743x_csr_write(adapter, GPIO_CFG2, gpio->gpio_cfg2); 280 281 if (event_channel == 0) { 282 /* use channel A */ 283 gpio->gpio_cfg3 &= ~GPIO_CFG3_1588_CH_SEL_BIT_(pin); 284 } else { 285 /* use channel B */ 286 gpio->gpio_cfg3 |= GPIO_CFG3_1588_CH_SEL_BIT_(pin); 287 } 288 gpio->gpio_cfg3 |= GPIO_CFG3_1588_OE_BIT_(pin); 289 lan743x_csr_write(adapter, GPIO_CFG3, gpio->gpio_cfg3); 290 291 ret = pin; 292 } 293 spin_unlock_irqrestore(&gpio->gpio_lock, irq_flags); 294 return ret; 295 } 296 297 static void lan743x_gpio_release(struct lan743x_adapter *adapter, int pin) 298 { 299 struct lan743x_gpio *gpio = &adapter->gpio; 300 unsigned long irq_flags = 0; 301 int bit_mask = BIT(pin); 302 303 spin_lock_irqsave(&gpio->gpio_lock, irq_flags); 304 if (gpio->used_bits & bit_mask) { 305 gpio->used_bits &= ~bit_mask; 306 if (gpio->output_bits & bit_mask) { 307 gpio->output_bits &= ~bit_mask; 308 309 if (gpio->ptp_bits & bit_mask) { 310 gpio->ptp_bits &= ~bit_mask; 311 /* disable ptp output */ 312 gpio->gpio_cfg3 &= ~GPIO_CFG3_1588_OE_BIT_(pin); 313 lan743x_csr_write(adapter, GPIO_CFG3, 314 gpio->gpio_cfg3); 315 } 316 /* release gpio output */ 317 318 /* disable gpio */ 319 gpio->gpio_cfg1 |= GPIO_CFG1_GPIOEN_BIT_(pin); 320 gpio->gpio_cfg1 &= ~GPIO_CFG1_GPIOBUF_BIT_(pin); 321 lan743x_csr_write(adapter, GPIO_CFG1, gpio->gpio_cfg1); 322 323 /* reset back to input */ 324 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DIR_BIT_(pin); 325 gpio->gpio_cfg0 &= ~GPIO_CFG0_GPIO_DATA_BIT_(pin); 326 lan743x_csr_write(adapter, GPIO_CFG0, gpio->gpio_cfg0); 327 328 /* assign pin to original function */ 329 lan743x_led_mux_enable(adapter, pin, true); 330 } 331 } 332 spin_unlock_irqrestore(&gpio->gpio_lock, irq_flags); 333 } 334 335 static int lan743x_ptpci_adjfine(struct ptp_clock_info *ptpci, long scaled_ppm) 336 { 337 struct lan743x_ptp *ptp = 338 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 339 struct lan743x_adapter *adapter = 340 container_of(ptp, struct lan743x_adapter, ptp); 341 u32 lan743x_rate_adj = 0; 342 u64 u64_delta; 343 344 if ((scaled_ppm < (-LAN743X_PTP_MAX_FINE_ADJ_IN_SCALED_PPM)) || 345 scaled_ppm > LAN743X_PTP_MAX_FINE_ADJ_IN_SCALED_PPM) { 346 return -EINVAL; 347 } 348 349 /* diff_by_scaled_ppm returns true if the difference is negative */ 350 if (diff_by_scaled_ppm(1ULL << 35, scaled_ppm, &u64_delta)) 351 lan743x_rate_adj = (u32)u64_delta; 352 else 353 lan743x_rate_adj = (u32)u64_delta | PTP_CLOCK_RATE_ADJ_DIR_; 354 355 lan743x_csr_write(adapter, PTP_CLOCK_RATE_ADJ, 356 lan743x_rate_adj); 357 358 return 0; 359 } 360 361 static int lan743x_ptpci_adjtime(struct ptp_clock_info *ptpci, s64 delta) 362 { 363 struct lan743x_ptp *ptp = 364 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 365 struct lan743x_adapter *adapter = 366 container_of(ptp, struct lan743x_adapter, ptp); 367 368 lan743x_ptp_clock_step(adapter, delta); 369 370 return 0; 371 } 372 373 static int lan743x_ptpci_gettime64(struct ptp_clock_info *ptpci, 374 struct timespec64 *ts) 375 { 376 struct lan743x_ptp *ptp = 377 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 378 struct lan743x_adapter *adapter = 379 container_of(ptp, struct lan743x_adapter, ptp); 380 u32 nano_seconds = 0; 381 u32 seconds = 0; 382 383 if (adapter->is_pci11x1x) 384 lan743x_ptp_io_clock_get(adapter, &seconds, &nano_seconds, 385 NULL); 386 else 387 lan743x_ptp_clock_get(adapter, &seconds, &nano_seconds, NULL); 388 ts->tv_sec = seconds; 389 ts->tv_nsec = nano_seconds; 390 391 return 0; 392 } 393 394 static int lan743x_ptpci_settime64(struct ptp_clock_info *ptpci, 395 const struct timespec64 *ts) 396 { 397 struct lan743x_ptp *ptp = 398 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 399 struct lan743x_adapter *adapter = 400 container_of(ptp, struct lan743x_adapter, ptp); 401 u32 nano_seconds = 0; 402 u32 seconds = 0; 403 404 if (ts->tv_sec > 0xFFFFFFFFLL) { 405 netif_warn(adapter, drv, adapter->netdev, 406 "ts->tv_sec out of range, %lld\n", 407 ts->tv_sec); 408 return -ERANGE; 409 } 410 if (ts->tv_nsec < 0) { 411 netif_warn(adapter, drv, adapter->netdev, 412 "ts->tv_nsec out of range, %ld\n", 413 ts->tv_nsec); 414 return -ERANGE; 415 } 416 seconds = ts->tv_sec; 417 nano_seconds = ts->tv_nsec; 418 lan743x_ptp_clock_set(adapter, seconds, nano_seconds, 0); 419 420 return 0; 421 } 422 423 static void lan743x_ptp_perout_off(struct lan743x_adapter *adapter, 424 unsigned int index) 425 { 426 struct lan743x_ptp *ptp = &adapter->ptp; 427 u32 general_config = 0; 428 struct lan743x_ptp_perout *perout = &ptp->perout[index]; 429 430 if (perout->gpio_pin >= 0) { 431 lan743x_gpio_release(adapter, perout->gpio_pin); 432 perout->gpio_pin = -1; 433 } 434 435 if (perout->event_ch >= 0) { 436 /* set target to far in the future, effectively disabling it */ 437 lan743x_csr_write(adapter, 438 PTP_CLOCK_TARGET_SEC_X(perout->event_ch), 439 0xFFFF0000); 440 lan743x_csr_write(adapter, 441 PTP_CLOCK_TARGET_NS_X(perout->event_ch), 442 0); 443 444 general_config = lan743x_csr_read(adapter, PTP_GENERAL_CONFIG); 445 general_config |= PTP_GENERAL_CONFIG_RELOAD_ADD_X_ 446 (perout->event_ch); 447 lan743x_csr_write(adapter, PTP_GENERAL_CONFIG, general_config); 448 lan743x_ptp_release_event_ch(adapter, perout->event_ch); 449 perout->event_ch = -1; 450 } 451 } 452 453 static int lan743x_ptp_perout(struct lan743x_adapter *adapter, int on, 454 struct ptp_perout_request *perout_request) 455 { 456 struct lan743x_ptp *ptp = &adapter->ptp; 457 u32 period_sec = 0, period_nsec = 0; 458 u32 start_sec = 0, start_nsec = 0; 459 u32 general_config = 0; 460 int pulse_width = 0; 461 int perout_pin = 0; 462 unsigned int index = perout_request->index; 463 struct lan743x_ptp_perout *perout = &ptp->perout[index]; 464 int ret = 0; 465 466 /* Reject requests with unsupported flags */ 467 if (perout_request->flags & ~PTP_PEROUT_DUTY_CYCLE) 468 return -EOPNOTSUPP; 469 470 if (on) { 471 perout_pin = ptp_find_pin(ptp->ptp_clock, PTP_PF_PEROUT, 472 perout_request->index); 473 if (perout_pin < 0) 474 return -EBUSY; 475 } else { 476 lan743x_ptp_perout_off(adapter, index); 477 return 0; 478 } 479 480 if (perout->event_ch >= 0 || 481 perout->gpio_pin >= 0) { 482 /* already on, turn off first */ 483 lan743x_ptp_perout_off(adapter, index); 484 } 485 486 perout->event_ch = lan743x_ptp_reserve_event_ch(adapter, index); 487 488 if (perout->event_ch < 0) { 489 netif_warn(adapter, drv, adapter->netdev, 490 "Failed to reserve event channel %d for PEROUT\n", 491 index); 492 ret = -EBUSY; 493 goto failed; 494 } 495 496 perout->gpio_pin = lan743x_gpio_rsrv_ptp_out(adapter, 497 perout_pin, 498 perout->event_ch); 499 500 if (perout->gpio_pin < 0) { 501 netif_warn(adapter, drv, adapter->netdev, 502 "Failed to reserve gpio %d for PEROUT\n", 503 perout_pin); 504 ret = -EBUSY; 505 goto failed; 506 } 507 508 start_sec = perout_request->start.sec; 509 start_sec += perout_request->start.nsec / 1000000000; 510 start_nsec = perout_request->start.nsec % 1000000000; 511 512 period_sec = perout_request->period.sec; 513 period_sec += perout_request->period.nsec / 1000000000; 514 period_nsec = perout_request->period.nsec % 1000000000; 515 516 if (perout_request->flags & PTP_PEROUT_DUTY_CYCLE) { 517 struct timespec64 ts_on, ts_period; 518 s64 wf_high, period64, half; 519 s32 reminder; 520 521 ts_on.tv_sec = perout_request->on.sec; 522 ts_on.tv_nsec = perout_request->on.nsec; 523 wf_high = timespec64_to_ns(&ts_on); 524 ts_period.tv_sec = perout_request->period.sec; 525 ts_period.tv_nsec = perout_request->period.nsec; 526 period64 = timespec64_to_ns(&ts_period); 527 528 if (period64 < 200) { 529 netif_warn(adapter, drv, adapter->netdev, 530 "perout period too small, minimum is 200nS\n"); 531 ret = -EOPNOTSUPP; 532 goto failed; 533 } 534 if (wf_high >= period64) { 535 netif_warn(adapter, drv, adapter->netdev, 536 "pulse width must be smaller than period\n"); 537 ret = -EINVAL; 538 goto failed; 539 } 540 541 /* Check if we can do 50% toggle on an even value of period. 542 * If the period number is odd, then check if the requested 543 * pulse width is the same as one of pre-defined width values. 544 * Otherwise, return failure. 545 */ 546 half = div_s64_rem(period64, 2, &reminder); 547 if (!reminder) { 548 if (half == wf_high) { 549 /* It's 50% match. Use the toggle option */ 550 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_TOGGLE_; 551 /* In this case, divide period value by 2 */ 552 ts_period = ns_to_timespec64(div_s64(period64, 2)); 553 period_sec = ts_period.tv_sec; 554 period_nsec = ts_period.tv_nsec; 555 556 goto program; 557 } 558 } 559 /* if we can't do toggle, then the width option needs to be the exact match */ 560 if (wf_high == 200000000) { 561 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_; 562 } else if (wf_high == 10000000) { 563 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10MS_; 564 } else if (wf_high == 1000000) { 565 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_1MS_; 566 } else if (wf_high == 100000) { 567 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100US_; 568 } else if (wf_high == 10000) { 569 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10US_; 570 } else if (wf_high == 100) { 571 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100NS_; 572 } else { 573 netif_warn(adapter, drv, adapter->netdev, 574 "duty cycle specified is not supported\n"); 575 ret = -EOPNOTSUPP; 576 goto failed; 577 } 578 } else { 579 if (period_sec == 0) { 580 if (period_nsec >= 400000000) { 581 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_; 582 } else if (period_nsec >= 20000000) { 583 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10MS_; 584 } else if (period_nsec >= 2000000) { 585 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_1MS_; 586 } else if (period_nsec >= 200000) { 587 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100US_; 588 } else if (period_nsec >= 20000) { 589 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_10US_; 590 } else if (period_nsec >= 200) { 591 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_100NS_; 592 } else { 593 netif_warn(adapter, drv, adapter->netdev, 594 "perout period too small, minimum is 200nS\n"); 595 ret = -EOPNOTSUPP; 596 goto failed; 597 } 598 } else { 599 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_; 600 } 601 } 602 program: 603 604 /* turn off by setting target far in future */ 605 lan743x_csr_write(adapter, 606 PTP_CLOCK_TARGET_SEC_X(perout->event_ch), 607 0xFFFF0000); 608 lan743x_csr_write(adapter, 609 PTP_CLOCK_TARGET_NS_X(perout->event_ch), 0); 610 611 /* Configure to pulse every period */ 612 general_config = lan743x_csr_read(adapter, PTP_GENERAL_CONFIG); 613 general_config &= ~(PTP_GENERAL_CONFIG_CLOCK_EVENT_X_MASK_ 614 (perout->event_ch)); 615 general_config |= PTP_GENERAL_CONFIG_CLOCK_EVENT_X_SET_ 616 (perout->event_ch, pulse_width); 617 general_config &= ~PTP_GENERAL_CONFIG_RELOAD_ADD_X_ 618 (perout->event_ch); 619 lan743x_csr_write(adapter, PTP_GENERAL_CONFIG, general_config); 620 621 /* set the reload to one toggle cycle */ 622 lan743x_csr_write(adapter, 623 PTP_CLOCK_TARGET_RELOAD_SEC_X(perout->event_ch), 624 period_sec); 625 lan743x_csr_write(adapter, 626 PTP_CLOCK_TARGET_RELOAD_NS_X(perout->event_ch), 627 period_nsec); 628 629 /* set the start time */ 630 lan743x_csr_write(adapter, 631 PTP_CLOCK_TARGET_SEC_X(perout->event_ch), 632 start_sec); 633 lan743x_csr_write(adapter, 634 PTP_CLOCK_TARGET_NS_X(perout->event_ch), 635 start_nsec); 636 637 return 0; 638 639 failed: 640 lan743x_ptp_perout_off(adapter, index); 641 return ret; 642 } 643 644 static void lan743x_ptp_io_perout_off(struct lan743x_adapter *adapter, 645 u32 index) 646 { 647 struct lan743x_ptp *ptp = &adapter->ptp; 648 int perout_pin; 649 int event_ch; 650 u32 gen_cfg; 651 int val; 652 653 event_ch = ptp->ptp_io_perout[index]; 654 if (event_ch >= 0) { 655 /* set target to far in the future, effectively disabling it */ 656 lan743x_csr_write(adapter, 657 PTP_CLOCK_TARGET_SEC_X(event_ch), 658 0xFFFF0000); 659 lan743x_csr_write(adapter, 660 PTP_CLOCK_TARGET_NS_X(event_ch), 661 0); 662 663 gen_cfg = lan743x_csr_read(adapter, HS_PTP_GENERAL_CONFIG); 664 gen_cfg &= ~(HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_X_MASK_ 665 (event_ch)); 666 gen_cfg &= ~(HS_PTP_GENERAL_CONFIG_EVENT_POL_X_(event_ch)); 667 gen_cfg |= HS_PTP_GENERAL_CONFIG_RELOAD_ADD_X_(event_ch); 668 lan743x_csr_write(adapter, HS_PTP_GENERAL_CONFIG, gen_cfg); 669 if (event_ch) 670 lan743x_csr_write(adapter, PTP_INT_STS, 671 PTP_INT_TIMER_INT_B_); 672 else 673 lan743x_csr_write(adapter, PTP_INT_STS, 674 PTP_INT_TIMER_INT_A_); 675 lan743x_ptp_release_event_ch(adapter, event_ch); 676 ptp->ptp_io_perout[index] = -1; 677 } 678 679 perout_pin = ptp_find_pin(ptp->ptp_clock, PTP_PF_PEROUT, index); 680 681 /* Deselect Event output */ 682 val = lan743x_csr_read(adapter, PTP_IO_EVENT_OUTPUT_CFG); 683 684 /* Disables the output of Local Time Target compare events */ 685 val &= ~PTP_IO_EVENT_OUTPUT_CFG_EN_(perout_pin); 686 lan743x_csr_write(adapter, PTP_IO_EVENT_OUTPUT_CFG, val); 687 688 /* Configured as an opendrain driver*/ 689 val = lan743x_csr_read(adapter, PTP_IO_PIN_CFG); 690 val &= ~PTP_IO_PIN_CFG_OBUF_TYPE_(perout_pin); 691 lan743x_csr_write(adapter, PTP_IO_PIN_CFG, val); 692 /* Dummy read to make sure write operation success */ 693 val = lan743x_csr_read(adapter, PTP_IO_PIN_CFG); 694 } 695 696 static int lan743x_ptp_io_perout(struct lan743x_adapter *adapter, int on, 697 struct ptp_perout_request *perout_request) 698 { 699 struct lan743x_ptp *ptp = &adapter->ptp; 700 u32 period_sec, period_nsec; 701 u32 start_sec, start_nsec; 702 u32 pulse_sec, pulse_nsec; 703 int pulse_width; 704 int perout_pin; 705 int event_ch; 706 u32 gen_cfg; 707 u32 index; 708 int val; 709 710 index = perout_request->index; 711 event_ch = ptp->ptp_io_perout[index]; 712 713 if (on) { 714 perout_pin = ptp_find_pin(ptp->ptp_clock, PTP_PF_PEROUT, index); 715 if (perout_pin < 0) 716 return -EBUSY; 717 } else { 718 lan743x_ptp_io_perout_off(adapter, index); 719 return 0; 720 } 721 722 if (event_ch >= LAN743X_PTP_N_EVENT_CHAN) { 723 /* already on, turn off first */ 724 lan743x_ptp_io_perout_off(adapter, index); 725 } 726 727 event_ch = lan743x_ptp_reserve_event_ch(adapter, index); 728 if (event_ch < 0) { 729 netif_warn(adapter, drv, adapter->netdev, 730 "Failed to reserve event channel %d for PEROUT\n", 731 index); 732 goto failed; 733 } 734 ptp->ptp_io_perout[index] = event_ch; 735 736 if (perout_request->flags & PTP_PEROUT_DUTY_CYCLE) { 737 pulse_sec = perout_request->on.sec; 738 pulse_sec += perout_request->on.nsec / 1000000000; 739 pulse_nsec = perout_request->on.nsec % 1000000000; 740 } else { 741 pulse_sec = perout_request->period.sec; 742 pulse_sec += perout_request->period.nsec / 1000000000; 743 pulse_nsec = perout_request->period.nsec % 1000000000; 744 } 745 746 if (pulse_sec == 0) { 747 if (pulse_nsec >= 400000000) { 748 pulse_width = PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_; 749 } else if (pulse_nsec >= 200000000) { 750 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_100MS_; 751 } else if (pulse_nsec >= 100000000) { 752 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_50MS_; 753 } else if (pulse_nsec >= 20000000) { 754 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_10MS_; 755 } else if (pulse_nsec >= 10000000) { 756 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_5MS_; 757 } else if (pulse_nsec >= 2000000) { 758 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_1MS_; 759 } else if (pulse_nsec >= 1000000) { 760 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_500US_; 761 } else if (pulse_nsec >= 200000) { 762 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_100US_; 763 } else if (pulse_nsec >= 100000) { 764 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_50US_; 765 } else if (pulse_nsec >= 20000) { 766 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_10US_; 767 } else if (pulse_nsec >= 10000) { 768 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_5US_; 769 } else if (pulse_nsec >= 2000) { 770 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_1US_; 771 } else if (pulse_nsec >= 1000) { 772 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_500NS_; 773 } else if (pulse_nsec >= 200) { 774 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_100NS_; 775 } else { 776 netif_warn(adapter, drv, adapter->netdev, 777 "perout period too small, min is 200nS\n"); 778 goto failed; 779 } 780 } else { 781 pulse_width = HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_200MS_; 782 } 783 784 /* turn off by setting target far in future */ 785 lan743x_csr_write(adapter, 786 PTP_CLOCK_TARGET_SEC_X(event_ch), 787 0xFFFF0000); 788 lan743x_csr_write(adapter, 789 PTP_CLOCK_TARGET_NS_X(event_ch), 0); 790 791 /* Configure to pulse every period */ 792 gen_cfg = lan743x_csr_read(adapter, HS_PTP_GENERAL_CONFIG); 793 gen_cfg &= ~(HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_X_MASK_(event_ch)); 794 gen_cfg |= HS_PTP_GENERAL_CONFIG_CLOCK_EVENT_X_SET_ 795 (event_ch, pulse_width); 796 gen_cfg |= HS_PTP_GENERAL_CONFIG_EVENT_POL_X_(event_ch); 797 gen_cfg &= ~(HS_PTP_GENERAL_CONFIG_RELOAD_ADD_X_(event_ch)); 798 lan743x_csr_write(adapter, HS_PTP_GENERAL_CONFIG, gen_cfg); 799 800 /* set the reload to one toggle cycle */ 801 period_sec = perout_request->period.sec; 802 period_sec += perout_request->period.nsec / 1000000000; 803 period_nsec = perout_request->period.nsec % 1000000000; 804 lan743x_csr_write(adapter, 805 PTP_CLOCK_TARGET_RELOAD_SEC_X(event_ch), 806 period_sec); 807 lan743x_csr_write(adapter, 808 PTP_CLOCK_TARGET_RELOAD_NS_X(event_ch), 809 period_nsec); 810 811 start_sec = perout_request->start.sec; 812 start_sec += perout_request->start.nsec / 1000000000; 813 start_nsec = perout_request->start.nsec % 1000000000; 814 815 /* set the start time */ 816 lan743x_csr_write(adapter, 817 PTP_CLOCK_TARGET_SEC_X(event_ch), 818 start_sec); 819 lan743x_csr_write(adapter, 820 PTP_CLOCK_TARGET_NS_X(event_ch), 821 start_nsec); 822 823 /* Enable LTC Target Read */ 824 val = lan743x_csr_read(adapter, PTP_CMD_CTL); 825 val |= PTP_CMD_CTL_PTP_LTC_TARGET_READ_; 826 lan743x_csr_write(adapter, PTP_CMD_CTL, val); 827 828 /* Configure as an push/pull driver */ 829 val = lan743x_csr_read(adapter, PTP_IO_PIN_CFG); 830 val |= PTP_IO_PIN_CFG_OBUF_TYPE_(perout_pin); 831 lan743x_csr_write(adapter, PTP_IO_PIN_CFG, val); 832 833 /* Select Event output */ 834 val = lan743x_csr_read(adapter, PTP_IO_EVENT_OUTPUT_CFG); 835 if (event_ch) 836 /* Channel B as the output */ 837 val |= PTP_IO_EVENT_OUTPUT_CFG_SEL_(perout_pin); 838 else 839 /* Channel A as the output */ 840 val &= ~PTP_IO_EVENT_OUTPUT_CFG_SEL_(perout_pin); 841 842 /* Enables the output of Local Time Target compare events */ 843 val |= PTP_IO_EVENT_OUTPUT_CFG_EN_(perout_pin); 844 lan743x_csr_write(adapter, PTP_IO_EVENT_OUTPUT_CFG, val); 845 846 return 0; 847 848 failed: 849 lan743x_ptp_io_perout_off(adapter, index); 850 return -ENODEV; 851 } 852 853 static void lan743x_ptp_io_extts_off(struct lan743x_adapter *adapter, 854 u32 index) 855 { 856 struct lan743x_ptp *ptp = &adapter->ptp; 857 struct lan743x_extts *extts; 858 int val; 859 860 extts = &ptp->extts[index]; 861 /* PTP Interrupt Enable Clear Register */ 862 if (extts->flags & PTP_FALLING_EDGE) 863 val = PTP_INT_EN_FE_EN_CLR_(index); 864 else 865 val = PTP_INT_EN_RE_EN_CLR_(index); 866 lan743x_csr_write(adapter, PTP_INT_EN_CLR, val); 867 868 /* Disables PTP-IO edge lock */ 869 val = lan743x_csr_read(adapter, PTP_IO_CAP_CONFIG); 870 if (extts->flags & PTP_FALLING_EDGE) { 871 val &= ~PTP_IO_CAP_CONFIG_LOCK_FE_(index); 872 val &= ~PTP_IO_CAP_CONFIG_FE_CAP_EN_(index); 873 } else { 874 val &= ~PTP_IO_CAP_CONFIG_LOCK_RE_(index); 875 val &= ~PTP_IO_CAP_CONFIG_RE_CAP_EN_(index); 876 } 877 lan743x_csr_write(adapter, PTP_IO_CAP_CONFIG, val); 878 879 /* PTP-IO De-select register */ 880 val = lan743x_csr_read(adapter, PTP_IO_SEL); 881 val &= ~PTP_IO_SEL_MASK_; 882 lan743x_csr_write(adapter, PTP_IO_SEL, val); 883 884 /* Clear timestamp */ 885 memset(&extts->ts, 0, sizeof(struct timespec64)); 886 extts->flags = 0; 887 } 888 889 static int lan743x_ptp_io_event_cap_en(struct lan743x_adapter *adapter, 890 u32 flags, u32 channel) 891 { 892 struct lan743x_ptp *ptp = &adapter->ptp; 893 int val; 894 895 if ((flags & PTP_EXTTS_EDGES) == PTP_EXTTS_EDGES) 896 return -EOPNOTSUPP; 897 898 mutex_lock(&ptp->command_lock); 899 /* PTP-IO Event Capture Enable */ 900 val = lan743x_csr_read(adapter, PTP_IO_CAP_CONFIG); 901 if (flags & PTP_FALLING_EDGE) { 902 val &= ~PTP_IO_CAP_CONFIG_LOCK_RE_(channel); 903 val &= ~PTP_IO_CAP_CONFIG_RE_CAP_EN_(channel); 904 val |= PTP_IO_CAP_CONFIG_LOCK_FE_(channel); 905 val |= PTP_IO_CAP_CONFIG_FE_CAP_EN_(channel); 906 } else { 907 /* Rising eventing as Default */ 908 val &= ~PTP_IO_CAP_CONFIG_LOCK_FE_(channel); 909 val &= ~PTP_IO_CAP_CONFIG_FE_CAP_EN_(channel); 910 val |= PTP_IO_CAP_CONFIG_LOCK_RE_(channel); 911 val |= PTP_IO_CAP_CONFIG_RE_CAP_EN_(channel); 912 } 913 lan743x_csr_write(adapter, PTP_IO_CAP_CONFIG, val); 914 915 /* PTP-IO Select */ 916 val = lan743x_csr_read(adapter, PTP_IO_SEL); 917 val &= ~PTP_IO_SEL_MASK_; 918 val |= channel << PTP_IO_SEL_SHIFT_; 919 lan743x_csr_write(adapter, PTP_IO_SEL, val); 920 921 /* PTP Interrupt Enable Register */ 922 if (flags & PTP_FALLING_EDGE) 923 val = PTP_INT_EN_FE_EN_SET_(channel); 924 else 925 val = PTP_INT_EN_RE_EN_SET_(channel); 926 lan743x_csr_write(adapter, PTP_INT_EN_SET, val); 927 928 mutex_unlock(&ptp->command_lock); 929 930 return 0; 931 } 932 933 static int lan743x_ptp_io_extts(struct lan743x_adapter *adapter, int on, 934 struct ptp_extts_request *extts_request) 935 { 936 struct lan743x_ptp *ptp = &adapter->ptp; 937 u32 flags = extts_request->flags; 938 u32 index = extts_request->index; 939 struct lan743x_extts *extts; 940 int extts_pin; 941 int ret = 0; 942 943 extts = &ptp->extts[index]; 944 945 if (on) { 946 extts_pin = ptp_find_pin(ptp->ptp_clock, PTP_PF_EXTTS, index); 947 if (extts_pin < 0) 948 return -EBUSY; 949 950 ret = lan743x_ptp_io_event_cap_en(adapter, flags, index); 951 if (!ret) 952 extts->flags = flags; 953 } else { 954 lan743x_ptp_io_extts_off(adapter, index); 955 } 956 957 return ret; 958 } 959 960 static int lan743x_ptpci_enable(struct ptp_clock_info *ptpci, 961 struct ptp_clock_request *request, int on) 962 { 963 struct lan743x_ptp *ptp = 964 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 965 struct lan743x_adapter *adapter = 966 container_of(ptp, struct lan743x_adapter, ptp); 967 968 if (request) { 969 switch (request->type) { 970 case PTP_CLK_REQ_EXTTS: 971 if (request->extts.index < ptpci->n_ext_ts) 972 return lan743x_ptp_io_extts(adapter, on, 973 &request->extts); 974 return -EINVAL; 975 case PTP_CLK_REQ_PEROUT: 976 if (request->perout.index < ptpci->n_per_out) { 977 if (adapter->is_pci11x1x) 978 return lan743x_ptp_io_perout(adapter, on, 979 &request->perout); 980 else 981 return lan743x_ptp_perout(adapter, on, 982 &request->perout); 983 } 984 return -EINVAL; 985 case PTP_CLK_REQ_PPS: 986 return -EINVAL; 987 default: 988 netif_err(adapter, drv, adapter->netdev, 989 "request->type == %d, Unknown\n", 990 request->type); 991 break; 992 } 993 } else { 994 netif_err(adapter, drv, adapter->netdev, "request == NULL\n"); 995 } 996 return 0; 997 } 998 999 static int lan743x_ptpci_verify_pin_config(struct ptp_clock_info *ptp, 1000 unsigned int pin, 1001 enum ptp_pin_function func, 1002 unsigned int chan) 1003 { 1004 struct lan743x_ptp *lan_ptp = 1005 container_of(ptp, struct lan743x_ptp, ptp_clock_info); 1006 struct lan743x_adapter *adapter = 1007 container_of(lan_ptp, struct lan743x_adapter, ptp); 1008 int result = 0; 1009 1010 /* Confirm the requested function is supported. Parameter 1011 * validation is done by the caller. 1012 */ 1013 switch (func) { 1014 case PTP_PF_NONE: 1015 case PTP_PF_PEROUT: 1016 break; 1017 case PTP_PF_EXTTS: 1018 if (!adapter->is_pci11x1x) 1019 result = -1; 1020 break; 1021 case PTP_PF_PHYSYNC: 1022 default: 1023 result = -1; 1024 break; 1025 } 1026 return result; 1027 } 1028 1029 static void lan743x_ptp_io_event_clock_get(struct lan743x_adapter *adapter, 1030 bool fe, u8 channel, 1031 struct timespec64 *ts) 1032 { 1033 struct lan743x_ptp *ptp = &adapter->ptp; 1034 struct lan743x_extts *extts; 1035 u32 sec, nsec; 1036 1037 mutex_lock(&ptp->command_lock); 1038 if (fe) { 1039 sec = lan743x_csr_read(adapter, PTP_IO_FE_LTC_SEC_CAP_X); 1040 nsec = lan743x_csr_read(adapter, PTP_IO_FE_LTC_NS_CAP_X); 1041 } else { 1042 sec = lan743x_csr_read(adapter, PTP_IO_RE_LTC_SEC_CAP_X); 1043 nsec = lan743x_csr_read(adapter, PTP_IO_RE_LTC_NS_CAP_X); 1044 } 1045 1046 mutex_unlock(&ptp->command_lock); 1047 1048 /* Update Local timestamp */ 1049 extts = &ptp->extts[channel]; 1050 extts->ts.tv_sec = sec; 1051 extts->ts.tv_nsec = nsec; 1052 ts->tv_sec = sec; 1053 ts->tv_nsec = nsec; 1054 } 1055 1056 static long lan743x_ptpci_do_aux_work(struct ptp_clock_info *ptpci) 1057 { 1058 struct lan743x_ptp *ptp = 1059 container_of(ptpci, struct lan743x_ptp, ptp_clock_info); 1060 struct lan743x_adapter *adapter = 1061 container_of(ptp, struct lan743x_adapter, ptp); 1062 u32 cap_info, cause, header, nsec, seconds; 1063 bool new_timestamp_available = false; 1064 struct ptp_clock_event ptp_event; 1065 struct timespec64 ts; 1066 int ptp_int_sts; 1067 int count = 0; 1068 int channel; 1069 s64 ns; 1070 1071 ptp_int_sts = lan743x_csr_read(adapter, PTP_INT_STS); 1072 while ((count < 100) && ptp_int_sts) { 1073 count++; 1074 1075 if (ptp_int_sts & PTP_INT_BIT_TX_TS_) { 1076 cap_info = lan743x_csr_read(adapter, PTP_CAP_INFO); 1077 1078 if (PTP_CAP_INFO_TX_TS_CNT_GET_(cap_info) > 0) { 1079 seconds = lan743x_csr_read(adapter, 1080 PTP_TX_EGRESS_SEC); 1081 nsec = lan743x_csr_read(adapter, 1082 PTP_TX_EGRESS_NS); 1083 cause = (nsec & 1084 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_MASK_); 1085 header = lan743x_csr_read(adapter, 1086 PTP_TX_MSG_HEADER); 1087 1088 if (cause == 1089 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_SW_) { 1090 nsec &= PTP_TX_EGRESS_NS_TS_NS_MASK_; 1091 lan743x_ptp_tx_ts_enqueue_ts(adapter, 1092 seconds, 1093 nsec, 1094 header); 1095 new_timestamp_available = true; 1096 } else if (cause == 1097 PTP_TX_EGRESS_NS_CAPTURE_CAUSE_AUTO_) { 1098 netif_err(adapter, drv, adapter->netdev, 1099 "Auto capture cause not supported\n"); 1100 } else { 1101 netif_warn(adapter, drv, adapter->netdev, 1102 "unknown tx timestamp capture cause\n"); 1103 } 1104 } else { 1105 netif_warn(adapter, drv, adapter->netdev, 1106 "TX TS INT but no TX TS CNT\n"); 1107 } 1108 lan743x_csr_write(adapter, PTP_INT_STS, 1109 PTP_INT_BIT_TX_TS_); 1110 } 1111 1112 if (ptp_int_sts & PTP_INT_IO_FE_MASK_) { 1113 do { 1114 channel = lan743x_get_channel((ptp_int_sts & 1115 PTP_INT_IO_FE_MASK_) >> 1116 PTP_INT_IO_FE_SHIFT_); 1117 if (channel >= 0 && 1118 channel < PCI11X1X_PTP_IO_MAX_CHANNELS) { 1119 lan743x_ptp_io_event_clock_get(adapter, 1120 true, 1121 channel, 1122 &ts); 1123 /* PTP Falling Event post */ 1124 ns = timespec64_to_ns(&ts); 1125 ptp_event.timestamp = ns; 1126 ptp_event.index = channel; 1127 ptp_event.type = PTP_CLOCK_EXTTS; 1128 ptp_clock_event(ptp->ptp_clock, 1129 &ptp_event); 1130 lan743x_csr_write(adapter, PTP_INT_STS, 1131 PTP_INT_IO_FE_SET_ 1132 (channel)); 1133 ptp_int_sts &= ~(1 << 1134 (PTP_INT_IO_FE_SHIFT_ + 1135 channel)); 1136 } else { 1137 /* Clear falling event interrupts */ 1138 lan743x_csr_write(adapter, PTP_INT_STS, 1139 PTP_INT_IO_FE_MASK_); 1140 ptp_int_sts &= ~PTP_INT_IO_FE_MASK_; 1141 } 1142 } while (ptp_int_sts & PTP_INT_IO_FE_MASK_); 1143 } 1144 1145 if (ptp_int_sts & PTP_INT_IO_RE_MASK_) { 1146 do { 1147 channel = lan743x_get_channel((ptp_int_sts & 1148 PTP_INT_IO_RE_MASK_) >> 1149 PTP_INT_IO_RE_SHIFT_); 1150 if (channel >= 0 && 1151 channel < PCI11X1X_PTP_IO_MAX_CHANNELS) { 1152 lan743x_ptp_io_event_clock_get(adapter, 1153 false, 1154 channel, 1155 &ts); 1156 /* PTP Rising Event post */ 1157 ns = timespec64_to_ns(&ts); 1158 ptp_event.timestamp = ns; 1159 ptp_event.index = channel; 1160 ptp_event.type = PTP_CLOCK_EXTTS; 1161 ptp_clock_event(ptp->ptp_clock, 1162 &ptp_event); 1163 lan743x_csr_write(adapter, PTP_INT_STS, 1164 PTP_INT_IO_RE_SET_ 1165 (channel)); 1166 ptp_int_sts &= ~(1 << 1167 (PTP_INT_IO_RE_SHIFT_ + 1168 channel)); 1169 } else { 1170 /* Clear Rising event interrupt */ 1171 lan743x_csr_write(adapter, PTP_INT_STS, 1172 PTP_INT_IO_RE_MASK_); 1173 ptp_int_sts &= ~PTP_INT_IO_RE_MASK_; 1174 } 1175 } while (ptp_int_sts & PTP_INT_IO_RE_MASK_); 1176 } 1177 1178 ptp_int_sts = lan743x_csr_read(adapter, PTP_INT_STS); 1179 } 1180 1181 if (new_timestamp_available) 1182 lan743x_ptp_tx_ts_complete(adapter); 1183 1184 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_); 1185 1186 return -1; 1187 } 1188 1189 static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter, 1190 u32 *seconds, u32 *nano_seconds, 1191 u32 *sub_nano_seconds) 1192 { 1193 struct lan743x_ptp *ptp = &adapter->ptp; 1194 1195 mutex_lock(&ptp->command_lock); 1196 1197 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_READ_); 1198 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_READ_); 1199 1200 if (seconds) 1201 (*seconds) = lan743x_csr_read(adapter, PTP_CLOCK_SEC); 1202 1203 if (nano_seconds) 1204 (*nano_seconds) = lan743x_csr_read(adapter, PTP_CLOCK_NS); 1205 1206 if (sub_nano_seconds) 1207 (*sub_nano_seconds) = 1208 lan743x_csr_read(adapter, PTP_CLOCK_SUBNS); 1209 1210 mutex_unlock(&ptp->command_lock); 1211 } 1212 1213 static void lan743x_ptp_io_clock_get(struct lan743x_adapter *adapter, 1214 u32 *sec, u32 *nsec, u32 *sub_nsec) 1215 { 1216 struct lan743x_ptp *ptp = &adapter->ptp; 1217 1218 mutex_lock(&ptp->command_lock); 1219 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_READ_); 1220 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_READ_); 1221 1222 if (sec) 1223 (*sec) = lan743x_csr_read(adapter, PTP_LTC_RD_SEC_LO); 1224 1225 if (nsec) 1226 (*nsec) = lan743x_csr_read(adapter, PTP_LTC_RD_NS); 1227 1228 if (sub_nsec) 1229 (*sub_nsec) = 1230 lan743x_csr_read(adapter, PTP_LTC_RD_SUBNS); 1231 1232 mutex_unlock(&ptp->command_lock); 1233 } 1234 1235 static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter, 1236 s64 time_step_ns) 1237 { 1238 struct lan743x_ptp *ptp = &adapter->ptp; 1239 u32 nano_seconds_step = 0; 1240 u64 abs_time_step_ns = 0; 1241 u32 unsigned_seconds = 0; 1242 u32 nano_seconds = 0; 1243 u32 remainder = 0; 1244 s32 seconds = 0; 1245 1246 if (time_step_ns > 15000000000LL) { 1247 /* convert to clock set */ 1248 if (adapter->is_pci11x1x) 1249 lan743x_ptp_io_clock_get(adapter, &unsigned_seconds, 1250 &nano_seconds, NULL); 1251 else 1252 lan743x_ptp_clock_get(adapter, &unsigned_seconds, 1253 &nano_seconds, NULL); 1254 unsigned_seconds += div_u64_rem(time_step_ns, 1000000000LL, 1255 &remainder); 1256 nano_seconds += remainder; 1257 if (nano_seconds >= 1000000000) { 1258 unsigned_seconds++; 1259 nano_seconds -= 1000000000; 1260 } 1261 lan743x_ptp_clock_set(adapter, unsigned_seconds, 1262 nano_seconds, 0); 1263 return; 1264 } else if (time_step_ns < -15000000000LL) { 1265 /* convert to clock set */ 1266 time_step_ns = -time_step_ns; 1267 1268 if (adapter->is_pci11x1x) { 1269 lan743x_ptp_io_clock_get(adapter, &unsigned_seconds, 1270 &nano_seconds, NULL); 1271 } else { 1272 lan743x_ptp_clock_get(adapter, &unsigned_seconds, 1273 &nano_seconds, NULL); 1274 } 1275 unsigned_seconds -= div_u64_rem(time_step_ns, 1000000000LL, 1276 &remainder); 1277 nano_seconds_step = remainder; 1278 if (nano_seconds < nano_seconds_step) { 1279 unsigned_seconds--; 1280 nano_seconds += 1000000000; 1281 } 1282 nano_seconds -= nano_seconds_step; 1283 lan743x_ptp_clock_set(adapter, unsigned_seconds, 1284 nano_seconds, 0); 1285 return; 1286 } 1287 1288 /* do clock step */ 1289 if (time_step_ns >= 0) { 1290 abs_time_step_ns = (u64)(time_step_ns); 1291 seconds = (s32)div_u64_rem(abs_time_step_ns, 1000000000, 1292 &remainder); 1293 nano_seconds = (u32)remainder; 1294 } else { 1295 abs_time_step_ns = (u64)(-time_step_ns); 1296 seconds = -((s32)div_u64_rem(abs_time_step_ns, 1000000000, 1297 &remainder)); 1298 nano_seconds = (u32)remainder; 1299 if (nano_seconds > 0) { 1300 /* subtracting nano seconds is not allowed 1301 * convert to subtracting from seconds, 1302 * and adding to nanoseconds 1303 */ 1304 seconds--; 1305 nano_seconds = (1000000000 - nano_seconds); 1306 } 1307 } 1308 1309 if (nano_seconds > 0) { 1310 /* add 8 ns to cover the likely normal increment */ 1311 nano_seconds += 8; 1312 } 1313 1314 if (nano_seconds >= 1000000000) { 1315 /* carry into seconds */ 1316 seconds++; 1317 nano_seconds -= 1000000000; 1318 } 1319 1320 while (seconds) { 1321 mutex_lock(&ptp->command_lock); 1322 if (seconds > 0) { 1323 u32 adjustment_value = (u32)seconds; 1324 1325 if (adjustment_value > 0xF) 1326 adjustment_value = 0xF; 1327 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ, 1328 PTP_CLOCK_STEP_ADJ_DIR_ | 1329 adjustment_value); 1330 seconds -= ((s32)adjustment_value); 1331 } else { 1332 u32 adjustment_value = (u32)(-seconds); 1333 1334 if (adjustment_value > 0xF) 1335 adjustment_value = 0xF; 1336 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ, 1337 adjustment_value); 1338 seconds += ((s32)adjustment_value); 1339 } 1340 lan743x_csr_write(adapter, PTP_CMD_CTL, 1341 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_); 1342 lan743x_ptp_wait_till_cmd_done(adapter, 1343 PTP_CMD_CTL_PTP_CLOCK_STEP_SEC_); 1344 mutex_unlock(&ptp->command_lock); 1345 } 1346 if (nano_seconds) { 1347 mutex_lock(&ptp->command_lock); 1348 lan743x_csr_write(adapter, PTP_CLOCK_STEP_ADJ, 1349 PTP_CLOCK_STEP_ADJ_DIR_ | 1350 (nano_seconds & 1351 PTP_CLOCK_STEP_ADJ_VALUE_MASK_)); 1352 lan743x_csr_write(adapter, PTP_CMD_CTL, 1353 PTP_CMD_CTL_PTP_CLK_STP_NSEC_); 1354 lan743x_ptp_wait_till_cmd_done(adapter, 1355 PTP_CMD_CTL_PTP_CLK_STP_NSEC_); 1356 mutex_unlock(&ptp->command_lock); 1357 } 1358 } 1359 1360 void lan743x_ptp_isr(void *context) 1361 { 1362 struct lan743x_adapter *adapter = (struct lan743x_adapter *)context; 1363 struct lan743x_ptp *ptp = NULL; 1364 int enable_flag = 1; 1365 u32 ptp_int_sts = 0; 1366 1367 ptp = &adapter->ptp; 1368 1369 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_); 1370 1371 ptp_int_sts = lan743x_csr_read(adapter, PTP_INT_STS); 1372 ptp_int_sts &= lan743x_csr_read(adapter, PTP_INT_EN_SET); 1373 1374 if (ptp_int_sts & PTP_INT_BIT_TX_TS_) { 1375 ptp_schedule_worker(ptp->ptp_clock, 0); 1376 enable_flag = 0;/* tasklet will re-enable later */ 1377 } 1378 if (ptp_int_sts & PTP_INT_BIT_TX_SWTS_ERR_) { 1379 netif_err(adapter, drv, adapter->netdev, 1380 "PTP TX Software Timestamp Error\n"); 1381 /* clear int status bit */ 1382 lan743x_csr_write(adapter, PTP_INT_STS, 1383 PTP_INT_BIT_TX_SWTS_ERR_); 1384 } 1385 if (ptp_int_sts & PTP_INT_BIT_TIMER_B_) { 1386 /* clear int status bit */ 1387 lan743x_csr_write(adapter, PTP_INT_STS, 1388 PTP_INT_BIT_TIMER_B_); 1389 } 1390 if (ptp_int_sts & PTP_INT_BIT_TIMER_A_) { 1391 /* clear int status bit */ 1392 lan743x_csr_write(adapter, PTP_INT_STS, 1393 PTP_INT_BIT_TIMER_A_); 1394 } 1395 1396 if (enable_flag) { 1397 /* re-enable isr */ 1398 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_); 1399 } 1400 } 1401 1402 static void lan743x_ptp_tx_ts_enqueue_skb(struct lan743x_adapter *adapter, 1403 struct sk_buff *skb, bool ignore_sync) 1404 { 1405 struct lan743x_ptp *ptp = &adapter->ptp; 1406 1407 spin_lock_bh(&ptp->tx_ts_lock); 1408 if (ptp->tx_ts_skb_queue_size < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) { 1409 ptp->tx_ts_skb_queue[ptp->tx_ts_skb_queue_size] = skb; 1410 if (ignore_sync) 1411 ptp->tx_ts_ignore_sync_queue |= 1412 BIT(ptp->tx_ts_skb_queue_size); 1413 ptp->tx_ts_skb_queue_size++; 1414 } else { 1415 /* this should never happen, so long as the tx channel 1416 * calls and honors the result from 1417 * lan743x_ptp_request_tx_timestamp 1418 */ 1419 netif_err(adapter, drv, adapter->netdev, 1420 "tx ts skb queue overflow\n"); 1421 dev_kfree_skb(skb); 1422 } 1423 spin_unlock_bh(&ptp->tx_ts_lock); 1424 } 1425 1426 static void lan743x_ptp_sync_to_system_clock(struct lan743x_adapter *adapter) 1427 { 1428 struct timespec64 ts; 1429 1430 ktime_get_clocktai_ts64(&ts); 1431 1432 lan743x_ptp_clock_set(adapter, ts.tv_sec, ts.tv_nsec, 0); 1433 } 1434 1435 void lan743x_ptp_update_latency(struct lan743x_adapter *adapter, 1436 u32 link_speed) 1437 { 1438 switch (link_speed) { 1439 case 10: 1440 lan743x_csr_write(adapter, PTP_LATENCY, 1441 PTP_LATENCY_TX_SET_(0) | 1442 PTP_LATENCY_RX_SET_(0)); 1443 break; 1444 case 100: 1445 lan743x_csr_write(adapter, PTP_LATENCY, 1446 PTP_LATENCY_TX_SET_(181) | 1447 PTP_LATENCY_RX_SET_(594)); 1448 break; 1449 case 1000: 1450 lan743x_csr_write(adapter, PTP_LATENCY, 1451 PTP_LATENCY_TX_SET_(30) | 1452 PTP_LATENCY_RX_SET_(525)); 1453 break; 1454 } 1455 } 1456 1457 int lan743x_ptp_init(struct lan743x_adapter *adapter) 1458 { 1459 struct lan743x_ptp *ptp = &adapter->ptp; 1460 int i; 1461 1462 mutex_init(&ptp->command_lock); 1463 spin_lock_init(&ptp->tx_ts_lock); 1464 ptp->used_event_ch = 0; 1465 1466 for (i = 0; i < LAN743X_PTP_N_EVENT_CHAN; i++) { 1467 ptp->perout[i].event_ch = -1; 1468 ptp->perout[i].gpio_pin = -1; 1469 } 1470 1471 lan743x_led_mux_save(adapter); 1472 1473 return 0; 1474 } 1475 1476 int lan743x_ptp_open(struct lan743x_adapter *adapter) 1477 { 1478 struct lan743x_ptp *ptp = &adapter->ptp; 1479 int ret = -ENODEV; 1480 u32 temp; 1481 int i; 1482 int n_pins; 1483 1484 lan743x_ptp_reset(adapter); 1485 lan743x_ptp_sync_to_system_clock(adapter); 1486 temp = lan743x_csr_read(adapter, PTP_TX_MOD2); 1487 temp |= PTP_TX_MOD2_TX_PTP_CLR_UDPV4_CHKSUM_; 1488 lan743x_csr_write(adapter, PTP_TX_MOD2, temp); 1489 1490 /* Default Timestamping */ 1491 lan743x_rx_set_tstamp_mode(adapter, HWTSTAMP_FILTER_NONE); 1492 1493 lan743x_ptp_enable(adapter); 1494 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_1588_); 1495 lan743x_csr_write(adapter, PTP_INT_EN_SET, 1496 PTP_INT_BIT_TX_SWTS_ERR_ | PTP_INT_BIT_TX_TS_); 1497 ptp->flags |= PTP_FLAG_ISR_ENABLED; 1498 1499 if (!IS_ENABLED(CONFIG_PTP_1588_CLOCK)) 1500 return 0; 1501 1502 switch (adapter->csr.id_rev & ID_REV_ID_MASK_) { 1503 case ID_REV_ID_LAN7430_: 1504 n_pins = LAN7430_N_GPIO; 1505 break; 1506 case ID_REV_ID_LAN7431_: 1507 case ID_REV_ID_A011_: 1508 case ID_REV_ID_A041_: 1509 n_pins = LAN7431_N_GPIO; 1510 break; 1511 default: 1512 netif_warn(adapter, drv, adapter->netdev, 1513 "Unknown LAN743x (%08x). Assuming no GPIO\n", 1514 adapter->csr.id_rev); 1515 n_pins = 0; 1516 break; 1517 } 1518 1519 if (n_pins > LAN743X_PTP_N_GPIO) 1520 n_pins = LAN743X_PTP_N_GPIO; 1521 1522 for (i = 0; i < n_pins; i++) { 1523 struct ptp_pin_desc *ptp_pin = &ptp->pin_config[i]; 1524 1525 snprintf(ptp_pin->name, 1526 sizeof(ptp_pin->name), "lan743x_ptp_pin_%02d", i); 1527 ptp_pin->index = i; 1528 ptp_pin->func = PTP_PF_NONE; 1529 } 1530 1531 ptp->ptp_clock_info.owner = THIS_MODULE; 1532 snprintf(ptp->ptp_clock_info.name, 16, "%pm", 1533 adapter->netdev->dev_addr); 1534 ptp->ptp_clock_info.max_adj = LAN743X_PTP_MAX_FREQ_ADJ_IN_PPB; 1535 ptp->ptp_clock_info.n_alarm = 0; 1536 ptp->ptp_clock_info.n_ext_ts = LAN743X_PTP_N_EXTTS; 1537 ptp->ptp_clock_info.n_per_out = LAN743X_PTP_N_EVENT_CHAN; 1538 ptp->ptp_clock_info.n_pins = n_pins; 1539 ptp->ptp_clock_info.pps = LAN743X_PTP_N_PPS; 1540 ptp->ptp_clock_info.pin_config = ptp->pin_config; 1541 ptp->ptp_clock_info.adjfine = lan743x_ptpci_adjfine; 1542 ptp->ptp_clock_info.adjtime = lan743x_ptpci_adjtime; 1543 ptp->ptp_clock_info.gettime64 = lan743x_ptpci_gettime64; 1544 ptp->ptp_clock_info.getcrosststamp = NULL; 1545 ptp->ptp_clock_info.settime64 = lan743x_ptpci_settime64; 1546 ptp->ptp_clock_info.enable = lan743x_ptpci_enable; 1547 ptp->ptp_clock_info.do_aux_work = lan743x_ptpci_do_aux_work; 1548 ptp->ptp_clock_info.verify = lan743x_ptpci_verify_pin_config; 1549 1550 ptp->ptp_clock = ptp_clock_register(&ptp->ptp_clock_info, 1551 &adapter->pdev->dev); 1552 1553 if (IS_ERR(ptp->ptp_clock)) { 1554 netif_err(adapter, ifup, adapter->netdev, 1555 "ptp_clock_register failed\n"); 1556 goto done; 1557 } 1558 ptp->flags |= PTP_FLAG_PTP_CLOCK_REGISTERED; 1559 netif_info(adapter, ifup, adapter->netdev, 1560 "successfully registered ptp clock\n"); 1561 1562 return 0; 1563 done: 1564 lan743x_ptp_close(adapter); 1565 return ret; 1566 } 1567 1568 void lan743x_ptp_close(struct lan743x_adapter *adapter) 1569 { 1570 struct lan743x_ptp *ptp = &adapter->ptp; 1571 int index; 1572 1573 if (IS_ENABLED(CONFIG_PTP_1588_CLOCK) && 1574 (ptp->flags & PTP_FLAG_PTP_CLOCK_REGISTERED)) { 1575 ptp_clock_unregister(ptp->ptp_clock); 1576 ptp->ptp_clock = NULL; 1577 ptp->flags &= ~PTP_FLAG_PTP_CLOCK_REGISTERED; 1578 netif_info(adapter, drv, adapter->netdev, 1579 "ptp clock unregister\n"); 1580 } 1581 1582 if (ptp->flags & PTP_FLAG_ISR_ENABLED) { 1583 lan743x_csr_write(adapter, PTP_INT_EN_CLR, 1584 PTP_INT_BIT_TX_SWTS_ERR_ | 1585 PTP_INT_BIT_TX_TS_); 1586 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_1588_); 1587 ptp->flags &= ~PTP_FLAG_ISR_ENABLED; 1588 } 1589 1590 /* clean up pending timestamp requests */ 1591 lan743x_ptp_tx_ts_complete(adapter); 1592 spin_lock_bh(&ptp->tx_ts_lock); 1593 for (index = 0; 1594 index < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS; 1595 index++) { 1596 struct sk_buff *skb = ptp->tx_ts_skb_queue[index]; 1597 1598 dev_kfree_skb(skb); 1599 ptp->tx_ts_skb_queue[index] = NULL; 1600 ptp->tx_ts_seconds_queue[index] = 0; 1601 ptp->tx_ts_nseconds_queue[index] = 0; 1602 } 1603 ptp->tx_ts_skb_queue_size = 0; 1604 ptp->tx_ts_queue_size = 0; 1605 ptp->pending_tx_timestamps = 0; 1606 spin_unlock_bh(&ptp->tx_ts_lock); 1607 1608 lan743x_led_mux_restore(adapter); 1609 1610 lan743x_ptp_disable(adapter); 1611 } 1612 1613 static void lan743x_ptp_set_sync_ts_insert(struct lan743x_adapter *adapter, 1614 bool ts_insert_enable) 1615 { 1616 u32 ptp_tx_mod = lan743x_csr_read(adapter, PTP_TX_MOD); 1617 1618 if (ts_insert_enable) 1619 ptp_tx_mod |= PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_; 1620 else 1621 ptp_tx_mod &= ~PTP_TX_MOD_TX_PTP_SYNC_TS_INSERT_; 1622 1623 lan743x_csr_write(adapter, PTP_TX_MOD, ptp_tx_mod); 1624 } 1625 1626 static bool lan743x_ptp_is_enabled(struct lan743x_adapter *adapter) 1627 { 1628 if (lan743x_csr_read(adapter, PTP_CMD_CTL) & PTP_CMD_CTL_PTP_ENABLE_) 1629 return true; 1630 return false; 1631 } 1632 1633 static void lan743x_ptp_enable(struct lan743x_adapter *adapter) 1634 { 1635 struct lan743x_ptp *ptp = &adapter->ptp; 1636 1637 mutex_lock(&ptp->command_lock); 1638 1639 if (lan743x_ptp_is_enabled(adapter)) { 1640 netif_warn(adapter, drv, adapter->netdev, 1641 "PTP already enabled\n"); 1642 goto done; 1643 } 1644 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_ENABLE_); 1645 done: 1646 mutex_unlock(&ptp->command_lock); 1647 } 1648 1649 static void lan743x_ptp_disable(struct lan743x_adapter *adapter) 1650 { 1651 struct lan743x_ptp *ptp = &adapter->ptp; 1652 1653 /* Disable Timestamping */ 1654 lan743x_rx_set_tstamp_mode(adapter, HWTSTAMP_FILTER_NONE); 1655 1656 mutex_lock(&ptp->command_lock); 1657 if (!lan743x_ptp_is_enabled(adapter)) { 1658 netif_warn(adapter, drv, adapter->netdev, 1659 "PTP already disabled\n"); 1660 goto done; 1661 } 1662 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_DISABLE_); 1663 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_ENABLE_); 1664 done: 1665 mutex_unlock(&ptp->command_lock); 1666 } 1667 1668 static void lan743x_ptp_reset(struct lan743x_adapter *adapter) 1669 { 1670 struct lan743x_ptp *ptp = &adapter->ptp; 1671 1672 mutex_lock(&ptp->command_lock); 1673 1674 if (lan743x_ptp_is_enabled(adapter)) { 1675 netif_err(adapter, drv, adapter->netdev, 1676 "Attempting reset while enabled\n"); 1677 goto done; 1678 } 1679 1680 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_RESET_); 1681 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_RESET_); 1682 done: 1683 mutex_unlock(&ptp->command_lock); 1684 } 1685 1686 static void lan743x_ptp_clock_set(struct lan743x_adapter *adapter, 1687 u32 seconds, u32 nano_seconds, 1688 u32 sub_nano_seconds) 1689 { 1690 struct lan743x_ptp *ptp = &adapter->ptp; 1691 1692 mutex_lock(&ptp->command_lock); 1693 1694 lan743x_csr_write(adapter, PTP_CLOCK_SEC, seconds); 1695 lan743x_csr_write(adapter, PTP_CLOCK_NS, nano_seconds); 1696 lan743x_csr_write(adapter, PTP_CLOCK_SUBNS, sub_nano_seconds); 1697 1698 lan743x_csr_write(adapter, PTP_CMD_CTL, PTP_CMD_CTL_PTP_CLOCK_LOAD_); 1699 lan743x_ptp_wait_till_cmd_done(adapter, PTP_CMD_CTL_PTP_CLOCK_LOAD_); 1700 mutex_unlock(&ptp->command_lock); 1701 } 1702 1703 bool lan743x_ptp_request_tx_timestamp(struct lan743x_adapter *adapter) 1704 { 1705 struct lan743x_ptp *ptp = &adapter->ptp; 1706 bool result = false; 1707 1708 spin_lock(&ptp->tx_ts_lock); 1709 if (ptp->pending_tx_timestamps < LAN743X_PTP_NUMBER_OF_TX_TIMESTAMPS) { 1710 /* request granted */ 1711 ptp->pending_tx_timestamps++; 1712 result = true; 1713 } 1714 spin_unlock(&ptp->tx_ts_lock); 1715 return result; 1716 } 1717 1718 void lan743x_ptp_unrequest_tx_timestamp(struct lan743x_adapter *adapter) 1719 { 1720 struct lan743x_ptp *ptp = &adapter->ptp; 1721 1722 spin_lock_bh(&ptp->tx_ts_lock); 1723 if (ptp->pending_tx_timestamps > 0) 1724 ptp->pending_tx_timestamps--; 1725 else 1726 netif_err(adapter, drv, adapter->netdev, 1727 "unrequest failed, pending_tx_timestamps==0\n"); 1728 spin_unlock_bh(&ptp->tx_ts_lock); 1729 } 1730 1731 void lan743x_ptp_tx_timestamp_skb(struct lan743x_adapter *adapter, 1732 struct sk_buff *skb, bool ignore_sync) 1733 { 1734 lan743x_ptp_tx_ts_enqueue_skb(adapter, skb, ignore_sync); 1735 1736 lan743x_ptp_tx_ts_complete(adapter); 1737 } 1738 1739 int lan743x_ptp_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd) 1740 { 1741 struct lan743x_adapter *adapter = netdev_priv(netdev); 1742 struct hwtstamp_config config; 1743 int ret = 0; 1744 int index; 1745 1746 if (!ifr) { 1747 netif_err(adapter, drv, adapter->netdev, 1748 "SIOCSHWTSTAMP, ifr == NULL\n"); 1749 return -EINVAL; 1750 } 1751 1752 if (copy_from_user(&config, ifr->ifr_data, sizeof(config))) 1753 return -EFAULT; 1754 1755 switch (config.tx_type) { 1756 case HWTSTAMP_TX_OFF: 1757 for (index = 0; index < adapter->used_tx_channels; 1758 index++) 1759 lan743x_tx_set_timestamping_mode(&adapter->tx[index], 1760 false, false); 1761 lan743x_ptp_set_sync_ts_insert(adapter, false); 1762 break; 1763 case HWTSTAMP_TX_ON: 1764 for (index = 0; index < adapter->used_tx_channels; 1765 index++) 1766 lan743x_tx_set_timestamping_mode(&adapter->tx[index], 1767 true, false); 1768 lan743x_ptp_set_sync_ts_insert(adapter, false); 1769 break; 1770 case HWTSTAMP_TX_ONESTEP_SYNC: 1771 for (index = 0; index < adapter->used_tx_channels; 1772 index++) 1773 lan743x_tx_set_timestamping_mode(&adapter->tx[index], 1774 true, true); 1775 1776 lan743x_ptp_set_sync_ts_insert(adapter, true); 1777 break; 1778 case HWTSTAMP_TX_ONESTEP_P2P: 1779 ret = -ERANGE; 1780 break; 1781 default: 1782 netif_warn(adapter, drv, adapter->netdev, 1783 " tx_type = %d, UNKNOWN\n", config.tx_type); 1784 ret = -EINVAL; 1785 break; 1786 } 1787 1788 ret = lan743x_rx_set_tstamp_mode(adapter, config.rx_filter); 1789 1790 if (!ret) 1791 return copy_to_user(ifr->ifr_data, &config, 1792 sizeof(config)) ? -EFAULT : 0; 1793 return ret; 1794 } 1795