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