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