1795 lines · c
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 20static bool lan743x_ptp_is_enabled(struct lan743x_adapter *adapter);21static void lan743x_ptp_enable(struct lan743x_adapter *adapter);22static void lan743x_ptp_disable(struct lan743x_adapter *adapter);23static void lan743x_ptp_reset(struct lan743x_adapter *adapter);24static void lan743x_ptp_clock_set(struct lan743x_adapter *adapter,25 u32 seconds, u32 nano_seconds,26 u32 sub_nano_seconds);27 28static 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 40int 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 58static 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 77static 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 96static 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;151done:152 ptp->pending_tx_timestamps -= c;153 spin_unlock_bh(&ptp->tx_ts_lock);154}155 156static 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 175static 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 191static void lan743x_ptp_clock_get(struct lan743x_adapter *adapter,192 u32 *seconds, u32 *nano_seconds,193 u32 *sub_nano_seconds);194static void lan743x_ptp_io_clock_get(struct lan743x_adapter *adapter,195 u32 *sec, u32 *nsec, u32 *sub_nsec);196static void lan743x_ptp_clock_step(struct lan743x_adapter *adapter,197 s64 time_step_ns);198 199static 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 else211 val &= ~LAN743X_LED_ENABLE(pin);212 213 lan743x_csr_write(adapter, HW_CFG, val);214 }215}216 217static 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 237static 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 249static 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 297static 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 335static 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 else353 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 361static 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 373static 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 else387 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 394static 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 423static 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 453static 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 requested543 * 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 }602program: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 639failed:640 lan743x_ptp_perout_off(adapter, index);641 return ret;642}643 644static 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 else673 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 696static 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 else839 /* 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 848failed:849 lan743x_ptp_io_perout_off(adapter, index);850 return -ENODEV;851}852 853static 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 else865 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 889static 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 else925 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 933static 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 960static 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 else981 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 999static 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. Parameter1011 * 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 1029static 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 1056static 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 1189static 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 1213static 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 1235static 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 else1252 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 allowed1301 * convert to subtracting from seconds,1302 * and adding to nanoseconds1303 */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 1360void 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 1402static 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 channel1416 * calls and honors the result from1417 * lan743x_ptp_request_tx_timestamp1418 */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 1426static 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 1435void 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 1457int 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 1476int 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;1563done:1564 lan743x_ptp_close(adapter);1565 return ret;1566}1567 1568void 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 1613static 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 else1621 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 1626static 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 1633static 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_);1645done:1646 mutex_unlock(&ptp->command_lock);1647}1648 1649static 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_);1664done:1665 mutex_unlock(&ptp->command_lock);1666}1667 1668static 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_);1682done:1683 mutex_unlock(&ptp->command_lock);1684}1685 1686static 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 1703bool 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 1718void 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 else1726 netif_err(adapter, drv, adapter->netdev,1727 "unrequest failed, pending_tx_timestamps==0\n");1728 spin_unlock_bh(&ptp->tx_ts_lock);1729}1730 1731void 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 1739int 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