drivers/event/octeontx2/otx2_evdev_adptr.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2019 Marvell International Ltd.
   3  */
   4
   5 #include "otx2_evdev.h"
   6
   7 int
   8 otx2_sso_rx_adapter_caps_get(const struct rte_eventdev *event_dev,
   9                              const struct rte_eth_dev *eth_dev, uint32_t *caps)
  10 {
  11         int rc;
  12
  13         RTE_SET_USED(event_dev);
  14         rc = strncmp(eth_dev->device->driver->name, "net_octeontx2", 13);
  15         if (rc)
  16                 *caps = RTE_EVENT_ETH_RX_ADAPTER_SW_CAP;
  17         else
  18                 *caps = RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT;
  19
  20         return 0;
  21 }
  22
  23 static inline int
  24 sso_rxq_enable(struct otx2_eth_dev *dev, uint16_t qid, uint8_t tt, uint8_t ggrp,
  25                uint16_t eth_port_id)
  26 {
  27         struct otx2_mbox *mbox = dev->mbox;
  28         struct nix_aq_enq_req *aq;
  29         int rc;
  30
  31         aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
  32         aq->qidx = qid;
  33         aq->ctype = NIX_AQ_CTYPE_CQ;
  34         aq->op = NIX_AQ_INSTOP_WRITE;
  35
  36         aq->cq.ena = 0;
  37         aq->cq.caching = 0;
  38
  39         otx2_mbox_memset(&aq->cq_mask, 0, sizeof(struct nix_cq_ctx_s));
  40         aq->cq_mask.ena = ~(aq->cq_mask.ena);
  41         aq->cq_mask.caching = ~(aq->cq_mask.caching);
  42
  43         rc = otx2_mbox_process(mbox);
  44         if (rc < 0) {
  45                 otx2_err("Failed to disable cq context");
  46                 goto fail;
  47         }
  48
  49         aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
  50         aq->qidx = qid;
  51         aq->ctype = NIX_AQ_CTYPE_RQ;
  52         aq->op = NIX_AQ_INSTOP_WRITE;
  53
  54         aq->rq.sso_ena = 1;
  55         aq->rq.sso_tt = tt;
  56         aq->rq.sso_grp = ggrp;
  57         aq->rq.ena_wqwd = 1;
  58         /* Mbuf Header generation :
  59          * > FIRST_SKIP is a super set of WQE_SKIP, dont modify first skip as
  60          * it already has data related to mbuf size, headroom, private area.
  61          * > Using WQE_SKIP we can directly assign
  62          *              mbuf = wqe - sizeof(struct mbuf);
  63          * so that mbuf header will not have unpredicted values while headroom
  64          * and private data starts at the beginning of wqe_data.
  65          */
  66         aq->rq.wqe_skip = 1;
  67         aq->rq.wqe_caching = 1;
  68         aq->rq.spb_ena = 0;
  69         aq->rq.flow_tagw = 20; /* 20-bits */
  70
  71         /* Flow Tag calculation :
  72          *
  73          * rq_tag <31:24> = good/bad_tag<8:0>;
  74          * rq_tag  <23:0> = [ltag]
  75          *
  76          * flow_tag_mask<31:0> =  (1 << flow_tagw) - 1; <31:20>
  77          * tag<31:0> = (~flow_tag_mask & rq_tag) | (flow_tag_mask & flow_tag);
  78          *
  79          * Setup :
  80          * ltag<23:0> = (eth_port_id & 0xF) << 20;
  81          * good/bad_tag<8:0> =
  82          *      ((eth_port_id >> 4) & 0xF) | (RTE_EVENT_TYPE_ETHDEV << 4);
  83          *
  84          * TAG<31:0> on getwork = <31:28>(RTE_EVENT_TYPE_ETHDEV) |
  85          *                              <27:20> (eth_port_id) | <20:0> [TAG]
  86          */
  87
  88         aq->rq.ltag = (eth_port_id & 0xF) << 20;
  89         aq->rq.good_utag = ((eth_port_id >> 4) & 0xF) |
  90                                 (RTE_EVENT_TYPE_ETHDEV << 4);
  91         aq->rq.bad_utag = aq->rq.good_utag;
  92
  93         aq->rq.ena = 0;          /* Don't enable RQ yet */
  94         aq->rq.pb_caching = 0x2; /* First cache aligned block to LLC */
  95         aq->rq.xqe_imm_size = 0; /* No pkt data copy to CQE */
  96
  97         otx2_mbox_memset(&aq->rq_mask, 0, sizeof(struct nix_rq_ctx_s));
  98         /* mask the bits to write. */
  99         aq->rq_mask.sso_ena      = ~(aq->rq_mask.sso_ena);
 100         aq->rq_mask.sso_tt       = ~(aq->rq_mask.sso_tt);
 101         aq->rq_mask.sso_grp      = ~(aq->rq_mask.sso_grp);
 102         aq->rq_mask.ena_wqwd     = ~(aq->rq_mask.ena_wqwd);
 103         aq->rq_mask.wqe_skip     = ~(aq->rq_mask.wqe_skip);
 104         aq->rq_mask.wqe_caching  = ~(aq->rq_mask.wqe_caching);
 105         aq->rq_mask.spb_ena      = ~(aq->rq_mask.spb_ena);
 106         aq->rq_mask.flow_tagw    = ~(aq->rq_mask.flow_tagw);
 107         aq->rq_mask.ltag         = ~(aq->rq_mask.ltag);
 108         aq->rq_mask.good_utag    = ~(aq->rq_mask.good_utag);
 109         aq->rq_mask.bad_utag     = ~(aq->rq_mask.bad_utag);
 110         aq->rq_mask.ena          = ~(aq->rq_mask.ena);
 111         aq->rq_mask.pb_caching   = ~(aq->rq_mask.pb_caching);
 112         aq->rq_mask.xqe_imm_size = ~(aq->rq_mask.xqe_imm_size);
 113
 114         rc = otx2_mbox_process(mbox);
 115         if (rc < 0) {
 116                 otx2_err("Failed to init rx adapter context");
 117                 goto fail;
 118         }
 119
 120         return 0;
 121 fail:
 122         return rc;
 123 }
 124
 125 static inline int
 126 sso_rxq_disable(struct otx2_eth_dev *dev, uint16_t qid)
 127 {
 128         struct otx2_mbox *mbox = dev->mbox;
 129         struct nix_aq_enq_req *aq;
 130         int rc;
 131
 132         aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
 133         aq->qidx = qid;
 134         aq->ctype = NIX_AQ_CTYPE_CQ;
 135         aq->op = NIX_AQ_INSTOP_INIT;
 136
 137         aq->cq.ena = 1;
 138         aq->cq.caching = 1;
 139
 140         otx2_mbox_memset(&aq->cq_mask, 0, sizeof(struct nix_cq_ctx_s));
 141         aq->cq_mask.ena = ~(aq->cq_mask.ena);
 142         aq->cq_mask.caching = ~(aq->cq_mask.caching);
 143
 144         rc = otx2_mbox_process(mbox);
 145         if (rc < 0) {
 146                 otx2_err("Failed to init cq context");
 147                 goto fail;
 148         }
 149
 150         aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
 151         aq->qidx = qid;
 152         aq->ctype = NIX_AQ_CTYPE_RQ;
 153         aq->op = NIX_AQ_INSTOP_WRITE;
 154
 155         aq->rq.sso_ena = 0;
 156         aq->rq.sso_tt = SSO_TT_UNTAGGED;
 157         aq->rq.sso_grp = 0;
 158         aq->rq.ena_wqwd = 0;
 159         aq->rq.wqe_caching = 0;
 160         aq->rq.wqe_skip = 0;
 161         aq->rq.spb_ena = 0;
 162         aq->rq.flow_tagw = 0x20;
 163         aq->rq.ltag = 0;
 164         aq->rq.good_utag = 0;
 165         aq->rq.bad_utag = 0;
 166         aq->rq.ena = 1;
 167         aq->rq.pb_caching = 0x2; /* First cache aligned block to LLC */
 168         aq->rq.xqe_imm_size = 0; /* No pkt data copy to CQE */
 169
 170         otx2_mbox_memset(&aq->rq_mask, 0, sizeof(struct nix_rq_ctx_s));
 171         /* mask the bits to write. */
 172         aq->rq_mask.sso_ena      = ~(aq->rq_mask.sso_ena);
 173         aq->rq_mask.sso_tt       = ~(aq->rq_mask.sso_tt);
 174         aq->rq_mask.sso_grp      = ~(aq->rq_mask.sso_grp);
 175         aq->rq_mask.ena_wqwd     = ~(aq->rq_mask.ena_wqwd);
 176         aq->rq_mask.wqe_caching  = ~(aq->rq_mask.wqe_caching);
 177         aq->rq_mask.wqe_skip     = ~(aq->rq_mask.wqe_skip);
 178         aq->rq_mask.spb_ena      = ~(aq->rq_mask.spb_ena);
 179         aq->rq_mask.flow_tagw    = ~(aq->rq_mask.flow_tagw);
 180         aq->rq_mask.ltag         = ~(aq->rq_mask.ltag);
 181         aq->rq_mask.good_utag    = ~(aq->rq_mask.good_utag);
 182         aq->rq_mask.bad_utag     = ~(aq->rq_mask.bad_utag);
 183         aq->rq_mask.ena          = ~(aq->rq_mask.ena);
 184         aq->rq_mask.pb_caching   = ~(aq->rq_mask.pb_caching);
 185         aq->rq_mask.xqe_imm_size = ~(aq->rq_mask.xqe_imm_size);
 186
 187         rc = otx2_mbox_process(mbox);
 188         if (rc < 0) {
 189                 otx2_err("Failed to clear rx adapter context");
 190                 goto fail;
 191         }
 192
 193         return 0;
 194 fail:
 195         return rc;
 196 }
 197
 198 void
 199 sso_updt_xae_cnt(struct otx2_sso_evdev *dev, void *data, uint32_t event_type)
 200 {
 201         switch (event_type) {
 202         case RTE_EVENT_TYPE_ETHDEV:
 203         {
 204                 struct otx2_eth_rxq *rxq = data;
 205                 int i, match = false;
 206                 uint64_t *old_ptr;
 207
 208                 for (i = 0; i < dev->rx_adptr_pool_cnt; i++) {
 209                         if ((uint64_t)rxq->pool == dev->rx_adptr_pools[i])
 210                                 match = true;
 211                 }
 212
 213                 if (!match) {
 214                         dev->rx_adptr_pool_cnt++;
 215                         old_ptr = dev->rx_adptr_pools;
 216                         dev->rx_adptr_pools = rte_realloc(dev->rx_adptr_pools,
 217                                                           sizeof(uint64_t) *
 218                                                           dev->rx_adptr_pool_cnt
 219                                                           , 0);
 220                         if (dev->rx_adptr_pools == NULL) {
 221                                 dev->adptr_xae_cnt += rxq->pool->size;
 222                                 dev->rx_adptr_pools = old_ptr;
 223                                 dev->rx_adptr_pool_cnt--;
 224                                 return;
 225                         }
 226                         dev->rx_adptr_pools[dev->rx_adptr_pool_cnt - 1] =
 227                                 (uint64_t)rxq->pool;
 228
 229                         dev->adptr_xae_cnt += rxq->pool->size;
 230                 }
 231                 break;
 232         }
 233         case RTE_EVENT_TYPE_TIMER:
 234         {
 235                 dev->adptr_xae_cnt += (*(uint64_t *)data);
 236                 break;
 237         }
 238         default:
 239                 break;
 240         }
 241 }
 242
 243 static inline void
 244 sso_updt_lookup_mem(const struct rte_eventdev *event_dev, void *lookup_mem)
 245 {
 246         struct otx2_sso_evdev *dev = sso_pmd_priv(event_dev);
 247         int i;
 248
 249         for (i = 0; i < dev->nb_event_ports; i++) {
 250                 if (dev->dual_ws) {
 251                         struct otx2_ssogws_dual *ws = event_dev->data->ports[i];
 252
 253                         ws->lookup_mem = lookup_mem;
 254                 } else {
 255                         struct otx2_ssogws *ws = event_dev->data->ports[i];
 256
 257                         ws->lookup_mem = lookup_mem;
 258                 }
 259         }
 260 }
 261
 262 int
 263 otx2_sso_rx_adapter_queue_add(const struct rte_eventdev *event_dev,
 264                               const struct rte_eth_dev *eth_dev,
 265                               int32_t rx_queue_id,
 266                 const struct rte_event_eth_rx_adapter_queue_conf *queue_conf)
 267 {
 268         struct otx2_eth_dev *otx2_eth_dev = eth_dev->data->dev_private;
 269         struct otx2_sso_evdev *dev = sso_pmd_priv(event_dev);
 270         uint16_t port = eth_dev->data->port_id;
 271         struct otx2_eth_rxq *rxq;
 272         int i, rc;
 273
 274         rc = strncmp(eth_dev->device->driver->name, "net_octeontx2", 13);
 275         if (rc)
 276                 return -EINVAL;
 277
 278         if (rx_queue_id < 0) {
 279                 for (i = 0 ; i < eth_dev->data->nb_rx_queues; i++) {
 280                         rxq = eth_dev->data->rx_queues[i];
 281                         sso_updt_xae_cnt(dev, rxq, RTE_EVENT_TYPE_ETHDEV);
 282                         rc = sso_xae_reconfigure((struct rte_eventdev *)
 283                                                  (uintptr_t)event_dev);
 284                         rc |= sso_rxq_enable(otx2_eth_dev, i,
 285                                              queue_conf->ev.sched_type,
 286                                              queue_conf->ev.queue_id, port);
 287                 }
 288                 rxq = eth_dev->data->rx_queues[0];
 289                 sso_updt_lookup_mem(event_dev, rxq->lookup_mem);
 290         } else {
 291                 rxq = eth_dev->data->rx_queues[rx_queue_id];
 292                 sso_updt_xae_cnt(dev, rxq, RTE_EVENT_TYPE_ETHDEV);
 293                 rc = sso_xae_reconfigure((struct rte_eventdev *)
 294                                          (uintptr_t)event_dev);
 295                 rc |= sso_rxq_enable(otx2_eth_dev, (uint16_t)rx_queue_id,
 296                                      queue_conf->ev.sched_type,
 297                                      queue_conf->ev.queue_id, port);
 298                 sso_updt_lookup_mem(event_dev, rxq->lookup_mem);
 299         }
 300
 301         if (rc < 0) {
 302                 otx2_err("Failed to configure Rx adapter port=%d, q=%d", port,
 303                          queue_conf->ev.queue_id);
 304                 return rc;
 305         }
 306
 307         dev->rx_offloads |= otx2_eth_dev->rx_offload_flags;
 308         dev->tstamp = &otx2_eth_dev->tstamp;
 309         sso_fastpath_fns_set((struct rte_eventdev *)(uintptr_t)event_dev);
 310
 311         return 0;
 312 }
 313
 314 int
 315 otx2_sso_rx_adapter_queue_del(const struct rte_eventdev *event_dev,
 316                               const struct rte_eth_dev *eth_dev,
 317                               int32_t rx_queue_id)
 318 {
 319         struct otx2_eth_dev *dev = eth_dev->data->dev_private;
 320         int i, rc;
 321
 322         RTE_SET_USED(event_dev);
 323         rc = strncmp(eth_dev->device->driver->name, "net_octeontx2", 13);
 324         if (rc)
 325                 return -EINVAL;
 326
 327         if (rx_queue_id < 0) {
 328                 for (i = 0 ; i < eth_dev->data->nb_rx_queues; i++)
 329                         rc = sso_rxq_disable(dev, i);
 330         } else {
 331                 rc = sso_rxq_disable(dev, (uint16_t)rx_queue_id);
 332         }
 333
 334         if (rc < 0)
 335                 otx2_err("Failed to clear Rx adapter config port=%d, q=%d",
 336                          eth_dev->data->port_id, rx_queue_id);
 337
 338         return rc;
 339 }
 340
 341 int
 342 otx2_sso_rx_adapter_start(const struct rte_eventdev *event_dev,
 343                           const struct rte_eth_dev *eth_dev)
 344 {
 345         RTE_SET_USED(event_dev);
 346         RTE_SET_USED(eth_dev);
 347
 348         return 0;
 349 }
 350
 351 int
 352 otx2_sso_rx_adapter_stop(const struct rte_eventdev *event_dev,
 353                          const struct rte_eth_dev *eth_dev)
 354 {
 355         RTE_SET_USED(event_dev);
 356         RTE_SET_USED(eth_dev);
 357
 358         return 0;
 359 }
 360
 361 int
 362 otx2_sso_tx_adapter_caps_get(const struct rte_eventdev *dev,
 363                              const struct rte_eth_dev *eth_dev, uint32_t *caps)
 364 {
 365         int ret;
 366
 367         RTE_SET_USED(dev);
 368         ret = strncmp(eth_dev->device->driver->name, "net_octeontx2,", 13);
 369         if (ret)
 370                 *caps = 0;
 371         else
 372                 *caps = RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT;
 373
 374         return 0;
 375 }
 376
 377 static int
 378 sso_sqb_aura_limit_edit(struct rte_mempool *mp, uint16_t nb_sqb_bufs)
 379 {
 380         struct otx2_npa_lf *npa_lf = otx2_intra_dev_get_cfg()->npa_lf;
 381         struct npa_aq_enq_req *aura_req;
 382
 383         aura_req = otx2_mbox_alloc_msg_npa_aq_enq(npa_lf->mbox);
 384         aura_req->aura_id = npa_lf_aura_handle_to_aura(mp->pool_id);
 385         aura_req->ctype = NPA_AQ_CTYPE_AURA;
 386         aura_req->op = NPA_AQ_INSTOP_WRITE;
 387
 388         aura_req->aura.limit = nb_sqb_bufs;
 389         aura_req->aura_mask.limit = ~(aura_req->aura_mask.limit);
 390
 391         return otx2_mbox_process(npa_lf->mbox);
 392 }
 393
 394 int
 395 otx2_sso_tx_adapter_queue_add(uint8_t id, const struct rte_eventdev *event_dev,
 396                               const struct rte_eth_dev *eth_dev,
 397                               int32_t tx_queue_id)
 398 {
 399         struct otx2_eth_dev *otx2_eth_dev = eth_dev->data->dev_private;
 400         struct otx2_sso_evdev *dev = sso_pmd_priv(event_dev);
 401         struct otx2_eth_txq *txq;
 402         int i;
 403
 404         RTE_SET_USED(id);
 405         if (tx_queue_id < 0) {
 406                 for (i = 0 ; i < eth_dev->data->nb_tx_queues; i++) {
 407                         txq = eth_dev->data->tx_queues[i];
 408                         sso_sqb_aura_limit_edit(txq->sqb_pool,
 409                                                 OTX2_SSO_SQB_LIMIT);
 410                 }
 411         } else {
 412                 txq = eth_dev->data->tx_queues[tx_queue_id];
 413                 sso_sqb_aura_limit_edit(txq->sqb_pool, OTX2_SSO_SQB_LIMIT);
 414         }
 415
 416         dev->tx_offloads |= otx2_eth_dev->tx_offload_flags;
 417         sso_fastpath_fns_set((struct rte_eventdev *)(uintptr_t)event_dev);
 418
 419         return 0;
 420 }
 421
 422 int
 423 otx2_sso_tx_adapter_queue_del(uint8_t id, const struct rte_eventdev *event_dev,
 424                               const struct rte_eth_dev *eth_dev,
 425                               int32_t tx_queue_id)
 426 {
 427         struct otx2_eth_txq *txq;
 428         int i;
 429
 430         RTE_SET_USED(id);
 431         RTE_SET_USED(eth_dev);
 432         RTE_SET_USED(event_dev);
 433         if (tx_queue_id < 0) {
 434                 for (i = 0 ; i < eth_dev->data->nb_tx_queues; i++) {
 435                         txq = eth_dev->data->tx_queues[i];
 436                         sso_sqb_aura_limit_edit(txq->sqb_pool,
 437                                                 txq->nb_sqb_bufs);
 438                 }
 439         } else {
 440                 txq = eth_dev->data->tx_queues[tx_queue_id];
 441                 sso_sqb_aura_limit_edit(txq->sqb_pool, txq->nb_sqb_bufs);
 442         }
 443
 444         return 0;
 445 }