drivers/event/octeontx2/otx2_tim_evdev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2019 Marvell International Ltd.
   3  */
   4
   5 #include <rte_kvargs.h>
   6 #include <rte_malloc.h>
   7 #include <rte_mbuf_pool_ops.h>
   8
   9 #include "otx2_evdev.h"
  10 #include "otx2_tim_evdev.h"
  11
  12 static struct rte_event_timer_adapter_ops otx2_tim_ops;
  13
  14 static inline int
  15 tim_get_msix_offsets(void)
  16 {
  17         struct otx2_tim_evdev *dev = tim_priv_get();
  18         struct otx2_mbox *mbox = dev->mbox;
  19         struct msix_offset_rsp *msix_rsp;
  20         int i, rc;
  21
  22         /* Get TIM MSIX vector offsets */
  23         otx2_mbox_alloc_msg_msix_offset(mbox);
  24         rc = otx2_mbox_process_msg(mbox, (void *)&msix_rsp);
  25
  26         for (i = 0; i < dev->nb_rings; i++)
  27                 dev->tim_msixoff[i] = msix_rsp->timlf_msixoff[i];
  28
  29         return rc;
  30 }
  31
  32 static void
  33 tim_optimze_bkt_param(struct otx2_tim_ring *tim_ring)
  34 {
  35         uint64_t tck_nsec;
  36         uint32_t hbkts;
  37         uint32_t lbkts;
  38
  39         hbkts = rte_align32pow2(tim_ring->nb_bkts);
  40         tck_nsec = RTE_ALIGN_MUL_CEIL(tim_ring->max_tout / (hbkts - 1), 10);
  41
  42         if ((tck_nsec < TICK2NSEC(OTX2_TIM_MIN_TMO_TKS,
  43                                   tim_ring->tenns_clk_freq) ||
  44             hbkts > OTX2_TIM_MAX_BUCKETS))
  45                 hbkts = 0;
  46
  47         lbkts = rte_align32prevpow2(tim_ring->nb_bkts);
  48         tck_nsec = RTE_ALIGN_MUL_CEIL((tim_ring->max_tout / (lbkts - 1)), 10);
  49
  50         if ((tck_nsec < TICK2NSEC(OTX2_TIM_MIN_TMO_TKS,
  51                                   tim_ring->tenns_clk_freq) ||
  52             lbkts > OTX2_TIM_MAX_BUCKETS))
  53                 lbkts = 0;
  54
  55         if (!hbkts && !lbkts)
  56                 return;
  57
  58         if (!hbkts) {
  59                 tim_ring->nb_bkts = lbkts;
  60                 goto end;
  61         } else if (!lbkts) {
  62                 tim_ring->nb_bkts = hbkts;
  63                 goto end;
  64         }
  65
  66         tim_ring->nb_bkts = (hbkts - tim_ring->nb_bkts) <
  67                 (tim_ring->nb_bkts - lbkts) ? hbkts : lbkts;
  68 end:
  69         tim_ring->optimized = true;
  70         tim_ring->tck_nsec = RTE_ALIGN_MUL_CEIL((tim_ring->max_tout /
  71                                                 (tim_ring->nb_bkts - 1)), 10);
  72         otx2_tim_dbg("Optimized configured values");
  73         otx2_tim_dbg("Nb_bkts  : %" PRIu32 "", tim_ring->nb_bkts);
  74         otx2_tim_dbg("Tck_nsec : %" PRIu64 "", tim_ring->tck_nsec);
  75 }
  76
  77 static int
  78 tim_chnk_pool_create(struct otx2_tim_ring *tim_ring,
  79                      struct rte_event_timer_adapter_conf *rcfg)
  80 {
  81         unsigned int cache_sz = (tim_ring->nb_chunks / 1.5);
  82         unsigned int mp_flags = 0;
  83         char pool_name[25];
  84         int rc;
  85
  86         /* Create chunk pool. */
  87         if (rcfg->flags & RTE_EVENT_TIMER_ADAPTER_F_SP_PUT) {
  88                 mp_flags = MEMPOOL_F_SP_PUT | MEMPOOL_F_SC_GET;
  89                 otx2_tim_dbg("Using single producer mode");
  90                 tim_ring->prod_type_sp = true;
  91         }
  92
  93         snprintf(pool_name, sizeof(pool_name), "otx2_tim_chunk_pool%d",
  94                  tim_ring->ring_id);
  95
  96         if (cache_sz > RTE_MEMPOOL_CACHE_MAX_SIZE)
  97                 cache_sz = RTE_MEMPOOL_CACHE_MAX_SIZE;
  98
  99         if (!tim_ring->disable_npa) {
 100                 /* NPA need not have cache as free is not visible to SW */
 101                 tim_ring->chunk_pool = rte_mempool_create_empty(pool_name,
 102                                 tim_ring->nb_chunks, tim_ring->chunk_sz,
 103                                 0, 0, rte_socket_id(), mp_flags);
 104
 105                 if (tim_ring->chunk_pool == NULL) {
 106                         otx2_err("Unable to create chunkpool.");
 107                         return -ENOMEM;
 108                 }
 109
 110                 rc = rte_mempool_set_ops_byname(tim_ring->chunk_pool,
 111                                                 rte_mbuf_platform_mempool_ops(),
 112                                                 NULL);
 113                 if (rc < 0) {
 114                         otx2_err("Unable to set chunkpool ops");
 115                         goto free;
 116                 }
 117
 118                 rc = rte_mempool_populate_default(tim_ring->chunk_pool);
 119                 if (rc < 0) {
 120                         otx2_err("Unable to set populate chunkpool.");
 121                         goto free;
 122                 }
 123                 tim_ring->aura = npa_lf_aura_handle_to_aura(
 124                                 tim_ring->chunk_pool->pool_id);
 125                 tim_ring->ena_dfb = 0;
 126         } else {
 127                 tim_ring->chunk_pool = rte_mempool_create(pool_name,
 128                                 tim_ring->nb_chunks, tim_ring->chunk_sz,
 129                                 cache_sz, 0, NULL, NULL, NULL, NULL,
 130                                 rte_socket_id(),
 131                                 mp_flags);
 132                 if (tim_ring->chunk_pool == NULL) {
 133                         otx2_err("Unable to create chunkpool.");
 134                         return -ENOMEM;
 135                 }
 136                 tim_ring->ena_dfb = 1;
 137         }
 138
 139         return 0;
 140
 141 free:
 142         rte_mempool_free(tim_ring->chunk_pool);
 143         return rc;
 144 }
 145
 146 static void
 147 tim_err_desc(int rc)
 148 {
 149         switch (rc) {
 150         case TIM_AF_NO_RINGS_LEFT:
 151                 otx2_err("Unable to allocat new TIM ring.");
 152                 break;
 153         case TIM_AF_INVALID_NPA_PF_FUNC:
 154                 otx2_err("Invalid NPA pf func.");
 155                 break;
 156         case TIM_AF_INVALID_SSO_PF_FUNC:
 157                 otx2_err("Invalid SSO pf func.");
 158                 break;
 159         case TIM_AF_RING_STILL_RUNNING:
 160                 otx2_tim_dbg("Ring busy.");
 161                 break;
 162         case TIM_AF_LF_INVALID:
 163                 otx2_err("Invalid Ring id.");
 164                 break;
 165         case TIM_AF_CSIZE_NOT_ALIGNED:
 166                 otx2_err("Chunk size specified needs to be multiple of 16.");
 167                 break;
 168         case TIM_AF_CSIZE_TOO_SMALL:
 169                 otx2_err("Chunk size too small.");
 170                 break;
 171         case TIM_AF_CSIZE_TOO_BIG:
 172                 otx2_err("Chunk size too big.");
 173                 break;
 174         case TIM_AF_INTERVAL_TOO_SMALL:
 175                 otx2_err("Bucket traversal interval too small.");
 176                 break;
 177         case TIM_AF_INVALID_BIG_ENDIAN_VALUE:
 178                 otx2_err("Invalid Big endian value.");
 179                 break;
 180         case TIM_AF_INVALID_CLOCK_SOURCE:
 181                 otx2_err("Invalid Clock source specified.");
 182                 break;
 183         case TIM_AF_GPIO_CLK_SRC_NOT_ENABLED:
 184                 otx2_err("GPIO clock source not enabled.");
 185                 break;
 186         case TIM_AF_INVALID_BSIZE:
 187                 otx2_err("Invalid bucket size.");
 188                 break;
 189         case TIM_AF_INVALID_ENABLE_PERIODIC:
 190                 otx2_err("Invalid bucket size.");
 191                 break;
 192         case TIM_AF_INVALID_ENABLE_DONTFREE:
 193                 otx2_err("Invalid Don't free value.");
 194                 break;
 195         case TIM_AF_ENA_DONTFRE_NSET_PERIODIC:
 196                 otx2_err("Don't free bit not set when periodic is enabled.");
 197                 break;
 198         case TIM_AF_RING_ALREADY_DISABLED:
 199                 otx2_err("Ring already stopped");
 200                 break;
 201         default:
 202                 otx2_err("Unknown Error.");
 203         }
 204 }
 205
 206 static int
 207 otx2_tim_ring_create(struct rte_event_timer_adapter *adptr)
 208 {
 209         struct rte_event_timer_adapter_conf *rcfg = &adptr->data->conf;
 210         struct otx2_tim_evdev *dev = tim_priv_get();
 211         struct otx2_tim_ring *tim_ring;
 212         struct tim_config_req *cfg_req;
 213         struct tim_ring_req *free_req;
 214         struct tim_lf_alloc_req *req;
 215         struct tim_lf_alloc_rsp *rsp;
 216         uint64_t nb_timers;
 217         int rc;
 218
 219         if (dev == NULL)
 220                 return -ENODEV;
 221
 222         if (adptr->data->id >= dev->nb_rings)
 223                 return -ENODEV;
 224
 225         req = otx2_mbox_alloc_msg_tim_lf_alloc(dev->mbox);
 226         req->npa_pf_func = otx2_npa_pf_func_get();
 227         req->sso_pf_func = otx2_sso_pf_func_get();
 228         req->ring = adptr->data->id;
 229
 230         rc = otx2_mbox_process_msg(dev->mbox, (void **)&rsp);
 231         if (rc < 0) {
 232                 tim_err_desc(rc);
 233                 return -ENODEV;
 234         }
 235
 236         if (NSEC2TICK(RTE_ALIGN_MUL_CEIL(rcfg->timer_tick_ns, 10),
 237                       rsp->tenns_clk) < OTX2_TIM_MIN_TMO_TKS) {
 238                 if (rcfg->flags & RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES)
 239                         rcfg->timer_tick_ns = TICK2NSEC(OTX2_TIM_MIN_TMO_TKS,
 240                                         rsp->tenns_clk);
 241                 else {
 242                         rc = -ERANGE;
 243                         goto rng_mem_err;
 244                 }
 245         }
 246
 247         tim_ring = rte_zmalloc("otx2_tim_prv", sizeof(struct otx2_tim_ring), 0);
 248         if (tim_ring == NULL) {
 249                 rc =  -ENOMEM;
 250                 goto rng_mem_err;
 251         }
 252
 253         adptr->data->adapter_priv = tim_ring;
 254
 255         tim_ring->tenns_clk_freq = rsp->tenns_clk;
 256         tim_ring->clk_src = (int)rcfg->clk_src;
 257         tim_ring->ring_id = adptr->data->id;
 258         tim_ring->tck_nsec = RTE_ALIGN_MUL_CEIL(rcfg->timer_tick_ns, 10);
 259         tim_ring->max_tout = rcfg->max_tmo_ns;
 260         tim_ring->nb_bkts = (tim_ring->max_tout / tim_ring->tck_nsec);
 261         tim_ring->chunk_sz = dev->chunk_sz;
 262         nb_timers = rcfg->nb_timers;
 263         tim_ring->disable_npa = dev->disable_npa;
 264
 265         tim_ring->nb_chunks = nb_timers / OTX2_TIM_NB_CHUNK_SLOTS(
 266                                                         tim_ring->chunk_sz);
 267         tim_ring->nb_chunk_slots = OTX2_TIM_NB_CHUNK_SLOTS(tim_ring->chunk_sz);
 268
 269         /* Try to optimize the bucket parameters. */
 270         if ((rcfg->flags & RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES)) {
 271                 if (rte_is_power_of_2(tim_ring->nb_bkts))
 272                         tim_ring->optimized = true;
 273                 else
 274                         tim_optimze_bkt_param(tim_ring);
 275         }
 276
 277         tim_ring->nb_chunks = tim_ring->nb_chunks * tim_ring->nb_bkts;
 278         /* Create buckets. */
 279         tim_ring->bkt = rte_zmalloc("otx2_tim_bucket", (tim_ring->nb_bkts) *
 280                                     sizeof(struct otx2_tim_bkt),
 281                                     RTE_CACHE_LINE_SIZE);
 282         if (tim_ring->bkt == NULL)
 283                 goto bkt_mem_err;
 284
 285         rc = tim_chnk_pool_create(tim_ring, rcfg);
 286         if (rc < 0)
 287                 goto chnk_mem_err;
 288
 289         cfg_req = otx2_mbox_alloc_msg_tim_config_ring(dev->mbox);
 290
 291         cfg_req->ring = tim_ring->ring_id;
 292         cfg_req->bigendian = false;
 293         cfg_req->clocksource = tim_ring->clk_src;
 294         cfg_req->enableperiodic = false;
 295         cfg_req->enabledontfreebuffer = tim_ring->ena_dfb;
 296         cfg_req->bucketsize = tim_ring->nb_bkts;
 297         cfg_req->chunksize = tim_ring->chunk_sz;
 298         cfg_req->interval = NSEC2TICK(tim_ring->tck_nsec,
 299                                       tim_ring->tenns_clk_freq);
 300
 301         rc = otx2_mbox_process(dev->mbox);
 302         if (rc < 0) {
 303                 tim_err_desc(rc);
 304                 goto chnk_mem_err;
 305         }
 306
 307         tim_ring->base = dev->bar2 +
 308                 (RVU_BLOCK_ADDR_TIM << 20 | tim_ring->ring_id << 12);
 309
 310         rc = tim_register_irq(tim_ring->ring_id);
 311         if (rc < 0)
 312                 goto chnk_mem_err;
 313
 314         otx2_write64((uint64_t)tim_ring->bkt,
 315                      tim_ring->base + TIM_LF_RING_BASE);
 316         otx2_write64(tim_ring->aura, tim_ring->base + TIM_LF_RING_AURA);
 317
 318         /* Update SSO xae count. */
 319         sso_updt_xae_cnt(sso_pmd_priv(dev->event_dev), (void *)&nb_timers,
 320                          RTE_EVENT_TYPE_TIMER);
 321         sso_xae_reconfigure(dev->event_dev);
 322
 323         return rc;
 324
 325 chnk_mem_err:
 326         rte_free(tim_ring->bkt);
 327 bkt_mem_err:
 328         rte_free(tim_ring);
 329 rng_mem_err:
 330         free_req = otx2_mbox_alloc_msg_tim_lf_free(dev->mbox);
 331         free_req->ring = adptr->data->id;
 332         otx2_mbox_process(dev->mbox);
 333         return rc;
 334 }
 335
 336 static int
 337 otx2_tim_ring_free(struct rte_event_timer_adapter *adptr)
 338 {
 339         struct otx2_tim_ring *tim_ring = adptr->data->adapter_priv;
 340         struct otx2_tim_evdev *dev = tim_priv_get();
 341         struct tim_ring_req *req;
 342         int rc;
 343
 344         if (dev == NULL)
 345                 return -ENODEV;
 346
 347         tim_unregister_irq(tim_ring->ring_id);
 348
 349         req = otx2_mbox_alloc_msg_tim_lf_free(dev->mbox);
 350         req->ring = tim_ring->ring_id;
 351
 352         rc = otx2_mbox_process(dev->mbox);
 353         if (rc < 0) {
 354                 tim_err_desc(rc);
 355                 return -EBUSY;
 356         }
 357
 358         rte_free(tim_ring->bkt);
 359         rte_mempool_free(tim_ring->chunk_pool);
 360         rte_free(adptr->data->adapter_priv);
 361
 362         return 0;
 363 }
 364
 365 int
 366 otx2_tim_caps_get(const struct rte_eventdev *evdev, uint64_t flags,
 367                   uint32_t *caps,
 368                   const struct rte_event_timer_adapter_ops **ops)
 369 {
 370         struct otx2_tim_evdev *dev = tim_priv_get();
 371
 372         RTE_SET_USED(flags);
 373         if (dev == NULL)
 374                 return -ENODEV;
 375
 376         otx2_tim_ops.init = otx2_tim_ring_create;
 377         otx2_tim_ops.uninit = otx2_tim_ring_free;
 378
 379         /* Store evdev pointer for later use. */
 380         dev->event_dev = (struct rte_eventdev *)(uintptr_t)evdev;
 381         *caps = RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT;
 382         *ops = &otx2_tim_ops;
 383
 384         return 0;
 385 }
 386
 387 #define OTX2_TIM_DISABLE_NPA    "tim_disable_npa"
 388 #define OTX2_TIM_CHNK_SLOTS     "tim_chnk_slots"
 389
 390 static void
 391 tim_parse_devargs(struct rte_devargs *devargs, struct otx2_tim_evdev *dev)
 392 {
 393         struct rte_kvargs *kvlist;
 394
 395         if (devargs == NULL)
 396                 return;
 397
 398         kvlist = rte_kvargs_parse(devargs->args, NULL);
 399         if (kvlist == NULL)
 400                 return;
 401
 402         rte_kvargs_process(kvlist, OTX2_TIM_DISABLE_NPA,
 403                            &parse_kvargs_flag, &dev->disable_npa);
 404         rte_kvargs_process(kvlist, OTX2_TIM_CHNK_SLOTS,
 405                            &parse_kvargs_value, &dev->chunk_slots);
 406 }
 407
 408 void
 409 otx2_tim_init(struct rte_pci_device *pci_dev, struct otx2_dev *cmn_dev)
 410 {
 411         struct rsrc_attach_req *atch_req;
 412         struct rsrc_detach_req *dtch_req;
 413         struct free_rsrcs_rsp *rsrc_cnt;
 414         const struct rte_memzone *mz;
 415         struct otx2_tim_evdev *dev;
 416         int rc;
 417
 418         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
 419                 return;
 420
 421         mz = rte_memzone_reserve(RTE_STR(OTX2_TIM_EVDEV_NAME),
 422                                  sizeof(struct otx2_tim_evdev),
 423                                  rte_socket_id(), 0);
 424         if (mz == NULL) {
 425                 otx2_tim_dbg("Unable to allocate memory for TIM Event device");
 426                 return;
 427         }
 428
 429         dev = mz->addr;
 430         dev->pci_dev = pci_dev;
 431         dev->mbox = cmn_dev->mbox;
 432         dev->bar2 = cmn_dev->bar2;
 433
 434         tim_parse_devargs(pci_dev->device.devargs, dev);
 435
 436         otx2_mbox_alloc_msg_free_rsrc_cnt(dev->mbox);
 437         rc = otx2_mbox_process_msg(dev->mbox, (void *)&rsrc_cnt);
 438         if (rc < 0) {
 439                 otx2_err("Unable to get free rsrc count.");
 440                 goto mz_free;
 441         }
 442
 443         dev->nb_rings = rsrc_cnt->tim;
 444
 445         if (!dev->nb_rings) {
 446                 otx2_tim_dbg("No TIM Logical functions provisioned.");
 447                 goto mz_free;
 448         }
 449
 450         atch_req = otx2_mbox_alloc_msg_attach_resources(dev->mbox);
 451         atch_req->modify = true;
 452         atch_req->timlfs = dev->nb_rings;
 453
 454         rc = otx2_mbox_process(dev->mbox);
 455         if (rc < 0) {
 456                 otx2_err("Unable to attach TIM rings.");
 457                 goto mz_free;
 458         }
 459
 460         rc = tim_get_msix_offsets();
 461         if (rc < 0) {
 462                 otx2_err("Unable to get MSIX offsets for TIM.");
 463                 goto detach;
 464         }
 465
 466         if (dev->chunk_slots &&
 467             dev->chunk_slots <= OTX2_TIM_MAX_CHUNK_SLOTS &&
 468             dev->chunk_slots >= OTX2_TIM_MIN_CHUNK_SLOTS) {
 469                 dev->chunk_sz = (dev->chunk_slots + 1) *
 470                         OTX2_TIM_CHUNK_ALIGNMENT;
 471         } else {
 472                 dev->chunk_sz = OTX2_TIM_RING_DEF_CHUNK_SZ;
 473         }
 474
 475         return;
 476
 477 detach:
 478         dtch_req = otx2_mbox_alloc_msg_detach_resources(dev->mbox);
 479         dtch_req->partial = true;
 480         dtch_req->timlfs = true;
 481
 482         otx2_mbox_process(dev->mbox);
 483 mz_free:
 484         rte_memzone_free(mz);
 485 }
 486
 487 void
 488 otx2_tim_fini(void)
 489 {
 490         struct otx2_tim_evdev *dev = tim_priv_get();
 491         struct rsrc_detach_req *dtch_req;
 492
 493         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
 494                 return;
 495
 496         dtch_req = otx2_mbox_alloc_msg_detach_resources(dev->mbox);
 497         dtch_req->partial = true;
 498         dtch_req->timlfs = true;
 499
 500         otx2_mbox_process(dev->mbox);
 501         rte_memzone_free(rte_memzone_lookup(RTE_STR(OTX2_TIM_EVDEV_NAME)));
 502 }