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