drivers/net/octeontx2/otx2_ptp.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2019 Marvell International Ltd.
   3  */
   4
   5 #include <rte_ethdev_driver.h>
   6
   7 #include "otx2_ethdev.h"
   8
   9 #define PTP_FREQ_ADJUST (1 << 9)
  10
  11 /* Function to enable ptp config for VFs */
  12 void
  13 otx2_nix_ptp_enable_vf(struct rte_eth_dev *eth_dev)
  14 {
  15         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
  16
  17         if (otx2_nix_recalc_mtu(eth_dev))
  18                 otx2_err("Failed to set MTU size for ptp");
  19
  20         dev->scalar_ena = true;
  21         dev->rx_offload_flags |= NIX_RX_OFFLOAD_TSTAMP_F;
  22
  23         /* Setting up the function pointers as per new offload flags */
  24         otx2_eth_set_rx_function(eth_dev);
  25         otx2_eth_set_tx_function(eth_dev);
  26 }
  27
  28 static uint16_t
  29 nix_eth_ptp_vf_burst(void *queue, struct rte_mbuf **mbufs, uint16_t pkts)
  30 {
  31         struct otx2_eth_rxq *rxq = queue;
  32         struct rte_eth_dev *eth_dev;
  33
  34         RTE_SET_USED(mbufs);
  35         RTE_SET_USED(pkts);
  36
  37         eth_dev = rxq->eth_dev;
  38         otx2_nix_ptp_enable_vf(eth_dev);
  39
  40         return 0;
  41 }
  42
  43 static int
  44 nix_read_raw_clock(struct otx2_eth_dev *dev, uint64_t *clock, uint64_t *tsc,
  45                    uint8_t is_pmu)
  46 {
  47         struct otx2_mbox *mbox = dev->mbox;
  48         struct ptp_req *req;
  49         struct ptp_rsp *rsp;
  50         int rc;
  51
  52         req = otx2_mbox_alloc_msg_ptp_op(mbox);
  53         req->op = PTP_OP_GET_CLOCK;
  54         req->is_pmu = is_pmu;
  55         rc = otx2_mbox_process_msg(mbox, (void *)&rsp);
  56         if (rc)
  57                 goto fail;
  58
  59         if (clock)
  60                 *clock = rsp->clk;
  61         if (tsc)
  62                 *tsc = rsp->tsc;
  63
  64 fail:
  65         return rc;
  66 }
  67
  68 /* This function calculates two parameters "clk_freq_mult" and
  69  * "clk_delta" which is useful in deriving PTP HI clock from
  70  * timestamp counter (tsc) value.
  71  */
  72 int
  73 otx2_nix_raw_clock_tsc_conv(struct otx2_eth_dev *dev)
  74 {
  75         uint64_t ticks_base = 0, ticks = 0, tsc = 0, t_freq;
  76         int rc, val;
  77
  78         /* Calculating the frequency at which PTP HI clock is running */
  79         rc = nix_read_raw_clock(dev, &ticks_base, &tsc, false);
  80         if (rc) {
  81                 otx2_err("Failed to read the raw clock value: %d", rc);
  82                 goto fail;
  83         }
  84
  85         rte_delay_ms(100);
  86
  87         rc = nix_read_raw_clock(dev, &ticks, &tsc, false);
  88         if (rc) {
  89                 otx2_err("Failed to read the raw clock value: %d", rc);
  90                 goto fail;
  91         }
  92
  93         t_freq = (ticks - ticks_base) * 10;
  94
  95         /* Calculating the freq multiplier viz the ratio between the
  96          * frequency at which PTP HI clock works and tsc clock runs
  97          */
  98         dev->clk_freq_mult =
  99                 (double)pow(10, floor(log10(t_freq))) / rte_get_timer_hz();
 100
 101         val = false;
 102 #ifdef RTE_ARM_EAL_RDTSC_USE_PMU
 103         val = true;
 104 #endif
 105         rc = nix_read_raw_clock(dev, &ticks, &tsc, val);
 106         if (rc) {
 107                 otx2_err("Failed to read the raw clock value: %d", rc);
 108                 goto fail;
 109         }
 110
 111         /* Calculating delta between PTP HI clock and tsc */
 112         dev->clk_delta = ((uint64_t)(ticks / dev->clk_freq_mult) - tsc);
 113
 114 fail:
 115         return rc;
 116 }
 117
 118 static void
 119 nix_start_timecounters(struct rte_eth_dev *eth_dev)
 120 {
 121         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 122
 123         memset(&dev->systime_tc, 0, sizeof(struct rte_timecounter));
 124         memset(&dev->rx_tstamp_tc, 0, sizeof(struct rte_timecounter));
 125         memset(&dev->tx_tstamp_tc, 0, sizeof(struct rte_timecounter));
 126
 127         dev->systime_tc.cc_mask = OTX2_CYCLECOUNTER_MASK;
 128         dev->rx_tstamp_tc.cc_mask = OTX2_CYCLECOUNTER_MASK;
 129         dev->tx_tstamp_tc.cc_mask = OTX2_CYCLECOUNTER_MASK;
 130 }
 131
 132 static int
 133 nix_ptp_config(struct rte_eth_dev *eth_dev, int en)
 134 {
 135         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 136         struct otx2_mbox *mbox = dev->mbox;
 137         uint8_t rc = -EINVAL;
 138
 139         if (otx2_dev_is_vf_or_sdp(dev) || otx2_dev_is_lbk(dev))
 140                 return rc;
 141
 142         if (en) {
 143                 /* Enable time stamping of sent PTP packets. */
 144                 otx2_mbox_alloc_msg_nix_lf_ptp_tx_enable(mbox);
 145                 rc = otx2_mbox_process(mbox);
 146                 if (rc) {
 147                         otx2_err("MBOX ptp tx conf enable failed: err %d", rc);
 148                         return rc;
 149                 }
 150                 /* Enable time stamping of received PTP packets. */
 151                 otx2_mbox_alloc_msg_cgx_ptp_rx_enable(mbox);
 152         } else {
 153                 /* Disable time stamping of sent PTP packets. */
 154                 otx2_mbox_alloc_msg_nix_lf_ptp_tx_disable(mbox);
 155                 rc = otx2_mbox_process(mbox);
 156                 if (rc) {
 157                         otx2_err("MBOX ptp tx conf disable failed: err %d", rc);
 158                         return rc;
 159                 }
 160                 /* Disable time stamping of received PTP packets. */
 161                 otx2_mbox_alloc_msg_cgx_ptp_rx_disable(mbox);
 162         }
 163
 164         return otx2_mbox_process(mbox);
 165 }
 166
 167 int
 168 otx2_eth_dev_ptp_info_update(struct otx2_dev *dev, bool ptp_en)
 169 {
 170         struct otx2_eth_dev *otx2_dev = (struct otx2_eth_dev *)dev;
 171         struct rte_eth_dev *eth_dev;
 172         int i;
 173
 174         if (!dev)
 175                 return -EINVAL;
 176
 177         eth_dev = otx2_dev->eth_dev;
 178         if (!eth_dev)
 179                 return -EINVAL;
 180
 181         otx2_dev->ptp_en = ptp_en;
 182         for (i = 0; i < eth_dev->data->nb_rx_queues; i++) {
 183                 struct otx2_eth_rxq *rxq = eth_dev->data->rx_queues[i];
 184                 rxq->mbuf_initializer =
 185                         otx2_nix_rxq_mbuf_setup(otx2_dev,
 186                                                 eth_dev->data->port_id);
 187         }
 188         if (otx2_dev_is_vf(otx2_dev) && !(otx2_dev_is_sdp(otx2_dev)) &&
 189             !(otx2_dev_is_lbk(otx2_dev))) {
 190                 /* In case of VF, setting of MTU cant be done directly in this
 191                  * function as this is running as part of MBOX request(PF->VF)
 192                  * and MTU setting also requires MBOX message to be
 193                  * sent(VF->PF)
 194                  */
 195                 eth_dev->rx_pkt_burst = nix_eth_ptp_vf_burst;
 196                 rte_mb();
 197         }
 198
 199         return 0;
 200 }
 201
 202 int
 203 otx2_nix_timesync_enable(struct rte_eth_dev *eth_dev)
 204 {
 205         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 206         int i, rc = 0;
 207
 208         /* If we are VF/SDP/LBK, ptp cannot not be enabled */
 209         if (otx2_dev_is_vf_or_sdp(dev) || otx2_dev_is_lbk(dev)) {
 210                 otx2_info("PTP cannot be enabled in case of VF/SDP/LBK");
 211                 return -EINVAL;
 212         }
 213
 214         if (otx2_ethdev_is_ptp_en(dev)) {
 215                 otx2_info("PTP mode is already enabled");
 216                 return -EINVAL;
 217         }
 218
 219         if (!(dev->rx_offload_flags & NIX_RX_OFFLOAD_PTYPE_F)) {
 220                 otx2_err("Ptype offload is disabled, it should be enabled");
 221                 return -EINVAL;
 222         }
 223
 224         if (dev->npc_flow.switch_header_type == OTX2_PRIV_FLAGS_HIGIG) {
 225                 otx2_err("Both PTP and switch header enabled");
 226                 return -EINVAL;
 227         }
 228
 229         /* Allocating a iova address for tx tstamp */
 230         const struct rte_memzone *ts;
 231         ts = rte_eth_dma_zone_reserve(eth_dev, "otx2_ts",
 232                                       0, OTX2_ALIGN, OTX2_ALIGN,
 233                                       dev->node);
 234         if (ts == NULL) {
 235                 otx2_err("Failed to allocate mem for tx tstamp addr");
 236                 return -ENOMEM;
 237         }
 238
 239         dev->tstamp.tx_tstamp_iova = ts->iova;
 240         dev->tstamp.tx_tstamp = ts->addr;
 241
 242         /* System time should be already on by default */
 243         nix_start_timecounters(eth_dev);
 244
 245         dev->rx_offloads |= DEV_RX_OFFLOAD_TIMESTAMP;
 246         dev->rx_offload_flags |= NIX_RX_OFFLOAD_TSTAMP_F;
 247         dev->tx_offload_flags |= NIX_TX_OFFLOAD_TSTAMP_F;
 248
 249         rc = nix_ptp_config(eth_dev, 1);
 250         if (!rc) {
 251                 for (i = 0; i < eth_dev->data->nb_tx_queues; i++) {
 252                         struct otx2_eth_txq *txq = eth_dev->data->tx_queues[i];
 253                         otx2_nix_form_default_desc(txq);
 254                 }
 255
 256                 /* Setting up the function pointers as per new offload flags */
 257                 otx2_eth_set_rx_function(eth_dev);
 258                 otx2_eth_set_tx_function(eth_dev);
 259         }
 260
 261         rc = otx2_nix_recalc_mtu(eth_dev);
 262         if (rc)
 263                 otx2_err("Failed to set MTU size for ptp");
 264
 265         return rc;
 266 }
 267
 268 int
 269 otx2_nix_timesync_disable(struct rte_eth_dev *eth_dev)
 270 {
 271         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 272         int i, rc = 0;
 273
 274         if (!otx2_ethdev_is_ptp_en(dev)) {
 275                 otx2_nix_dbg("PTP mode is disabled");
 276                 return -EINVAL;
 277         }
 278
 279         if (otx2_dev_is_vf_or_sdp(dev) || otx2_dev_is_lbk(dev))
 280                 return -EINVAL;
 281
 282         dev->rx_offloads &= ~DEV_RX_OFFLOAD_TIMESTAMP;
 283         dev->rx_offload_flags &= ~NIX_RX_OFFLOAD_TSTAMP_F;
 284         dev->tx_offload_flags &= ~NIX_TX_OFFLOAD_TSTAMP_F;
 285
 286         rc = nix_ptp_config(eth_dev, 0);
 287         if (!rc) {
 288                 for (i = 0; i < eth_dev->data->nb_tx_queues; i++) {
 289                         struct otx2_eth_txq *txq = eth_dev->data->tx_queues[i];
 290                         otx2_nix_form_default_desc(txq);
 291                 }
 292
 293                 /* Setting up the function pointers as per new offload flags */
 294                 otx2_eth_set_rx_function(eth_dev);
 295                 otx2_eth_set_tx_function(eth_dev);
 296         }
 297
 298         rc = otx2_nix_recalc_mtu(eth_dev);
 299         if (rc)
 300                 otx2_err("Failed to set MTU size for ptp");
 301
 302         return rc;
 303 }
 304
 305 int
 306 otx2_nix_timesync_read_rx_timestamp(struct rte_eth_dev *eth_dev,
 307                                     struct timespec *timestamp,
 308                                     uint32_t __rte_unused flags)
 309 {
 310         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 311         struct otx2_timesync_info *tstamp = &dev->tstamp;
 312         uint64_t ns;
 313
 314         if (!tstamp->rx_ready)
 315                 return -EINVAL;
 316
 317         ns = rte_timecounter_update(&dev->rx_tstamp_tc, tstamp->rx_tstamp);
 318         *timestamp = rte_ns_to_timespec(ns);
 319         tstamp->rx_ready = 0;
 320
 321         otx2_nix_dbg("rx timestamp: %"PRIu64" sec: %"PRIu64" nsec %"PRIu64"",
 322                      (uint64_t)tstamp->rx_tstamp, (uint64_t)timestamp->tv_sec,
 323                      (uint64_t)timestamp->tv_nsec);
 324
 325         return 0;
 326 }
 327
 328 int
 329 otx2_nix_timesync_read_tx_timestamp(struct rte_eth_dev *eth_dev,
 330                                     struct timespec *timestamp)
 331 {
 332         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 333         struct otx2_timesync_info *tstamp = &dev->tstamp;
 334         uint64_t ns;
 335
 336         if (*tstamp->tx_tstamp == 0)
 337                 return -EINVAL;
 338
 339         ns = rte_timecounter_update(&dev->tx_tstamp_tc, *tstamp->tx_tstamp);
 340         *timestamp = rte_ns_to_timespec(ns);
 341
 342         otx2_nix_dbg("tx timestamp: %"PRIu64" sec: %"PRIu64" nsec %"PRIu64"",
 343                      *tstamp->tx_tstamp, (uint64_t)timestamp->tv_sec,
 344                      (uint64_t)timestamp->tv_nsec);
 345
 346         *tstamp->tx_tstamp = 0;
 347         rte_wmb();
 348
 349         return 0;
 350 }
 351
 352 int
 353 otx2_nix_timesync_adjust_time(struct rte_eth_dev *eth_dev, int64_t delta)
 354 {
 355         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 356         struct otx2_mbox *mbox = dev->mbox;
 357         struct ptp_req *req;
 358         struct ptp_rsp *rsp;
 359         int rc;
 360
 361         /* Adjust the frequent to make tics increments in 10^9 tics per sec */
 362         if (delta < PTP_FREQ_ADJUST && delta > -PTP_FREQ_ADJUST) {
 363                 req = otx2_mbox_alloc_msg_ptp_op(mbox);
 364                 req->op = PTP_OP_ADJFINE;
 365                 req->scaled_ppm = delta;
 366
 367                 rc = otx2_mbox_process_msg(mbox, (void *)&rsp);
 368                 if (rc)
 369                         return rc;
 370                 /* Since the frequency of PTP comp register is tuned, delta and
 371                  * freq mult calculation for deriving PTP_HI from timestamp
 372                  * counter should be done again.
 373                  */
 374                 rc = otx2_nix_raw_clock_tsc_conv(dev);
 375                 if (rc)
 376                         otx2_err("Failed to calculate delta and freq mult");
 377         }
 378         dev->systime_tc.nsec += delta;
 379         dev->rx_tstamp_tc.nsec += delta;
 380         dev->tx_tstamp_tc.nsec += delta;
 381
 382         return 0;
 383 }
 384
 385 int
 386 otx2_nix_timesync_write_time(struct rte_eth_dev *eth_dev,
 387                              const struct timespec *ts)
 388 {
 389         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 390         uint64_t ns;
 391
 392         ns = rte_timespec_to_ns(ts);
 393         /* Set the time counters to a new value. */
 394         dev->systime_tc.nsec = ns;
 395         dev->rx_tstamp_tc.nsec = ns;
 396         dev->tx_tstamp_tc.nsec = ns;
 397
 398         return 0;
 399 }
 400
 401 int
 402 otx2_nix_timesync_read_time(struct rte_eth_dev *eth_dev, struct timespec *ts)
 403 {
 404         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 405         struct otx2_mbox *mbox = dev->mbox;
 406         struct ptp_req *req;
 407         struct ptp_rsp *rsp;
 408         uint64_t ns;
 409         int rc;
 410
 411         req = otx2_mbox_alloc_msg_ptp_op(mbox);
 412         req->op = PTP_OP_GET_CLOCK;
 413         rc = otx2_mbox_process_msg(mbox, (void *)&rsp);
 414         if (rc)
 415                 return rc;
 416
 417         ns = rte_timecounter_update(&dev->systime_tc, rsp->clk);
 418         *ts = rte_ns_to_timespec(ns);
 419
 420         otx2_nix_dbg("PTP time read: %"PRIu64" .%09"PRIu64"",
 421                      (uint64_t)ts->tv_sec, (uint64_t)ts->tv_nsec);
 422
 423         return 0;
 424 }
 425
 426
 427 int
 428 otx2_nix_read_clock(struct rte_eth_dev *eth_dev, uint64_t *clock)
 429 {
 430         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 431
 432         /* This API returns the raw PTP HI clock value. Since LFs doesn't
 433          * have direct access to PTP registers and it requires mbox msg
 434          * to AF for this value. In fastpath reading this value for every
 435          * packet (which involes mbox call) becomes very expensive, hence
 436          * we should be able to derive PTP HI clock value from tsc by
 437          * using freq_mult and clk_delta calculated during configure stage.
 438          */
 439         *clock = (rte_get_tsc_cycles() + dev->clk_delta) * dev->clk_freq_mult;
 440
 441         return 0;
 442 }