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
 207                 for (i = 0; i < dev->rx_adptr_pool_cnt; i++) {
 208                         if ((uint64_t)rxq->pool == dev->rx_adptr_pools[i])
 209                                 match = true;
 210                 }
 211
 212                 if (!match) {
 213                         dev->rx_adptr_pool_cnt++;
 214                         dev->rx_adptr_pools = rte_realloc(dev->rx_adptr_pools,
 215                                                           sizeof(uint64_t) *
 216                                                           dev->rx_adptr_pool_cnt
 217                                                           , 0);
 218                         dev->rx_adptr_pools[dev->rx_adptr_pool_cnt - 1] =
 219                                 (uint64_t)rxq->pool;
 220
 221                         dev->adptr_xae_cnt += rxq->pool->size;
 222                 }
 223                 break;
 224         }
 225         case RTE_EVENT_TYPE_TIMER:
 226         {
 227                 dev->adptr_xae_cnt += (*(uint64_t *)data);
 228                 break;
 229         }
 230         default:
 231                 break;
 232         }
 233 }
 234
 235 int
 236 otx2_sso_rx_adapter_queue_add(const struct rte_eventdev *event_dev,
 237                               const struct rte_eth_dev *eth_dev,
 238                               int32_t rx_queue_id,
 239                 const struct rte_event_eth_rx_adapter_queue_conf *queue_conf)
 240 {
 241         struct otx2_eth_dev *otx2_eth_dev = eth_dev->data->dev_private;
 242         struct otx2_sso_evdev *dev = sso_pmd_priv(event_dev);
 243         uint16_t port = eth_dev->data->port_id;
 244         struct otx2_eth_rxq *rxq;
 245         int i, rc;
 246
 247         rc = strncmp(eth_dev->device->driver->name, "net_octeontx2", 13);
 248         if (rc)
 249                 return -EINVAL;
 250
 251         if (rx_queue_id < 0) {
 252                 for (i = 0 ; i < eth_dev->data->nb_rx_queues; i++) {
 253                         rxq = eth_dev->data->rx_queues[i];
 254                         sso_updt_xae_cnt(dev, rxq, RTE_EVENT_TYPE_ETHDEV);
 255                         rc = sso_xae_reconfigure((struct rte_eventdev *)
 256                                                  (uintptr_t)event_dev);
 257                         rc |= sso_rxq_enable(otx2_eth_dev, i,
 258                                              queue_conf->ev.sched_type,
 259                                              queue_conf->ev.queue_id, port);
 260                 }
 261         } else {
 262                 rxq = eth_dev->data->rx_queues[rx_queue_id];
 263                 sso_updt_xae_cnt(dev, rxq, RTE_EVENT_TYPE_ETHDEV);
 264                 rc = sso_xae_reconfigure((struct rte_eventdev *)
 265                                          (uintptr_t)event_dev);
 266                 rc |= sso_rxq_enable(otx2_eth_dev, (uint16_t)rx_queue_id,
 267                                      queue_conf->ev.sched_type,
 268                                      queue_conf->ev.queue_id, port);
 269         }
 270
 271         if (rc < 0) {
 272                 otx2_err("Failed to configure Rx adapter port=%d, q=%d", port,
 273                          queue_conf->ev.queue_id);
 274                 return rc;
 275         }
 276
 277         return 0;
 278 }
 279
 280 int
 281 otx2_sso_rx_adapter_queue_del(const struct rte_eventdev *event_dev,
 282                               const struct rte_eth_dev *eth_dev,
 283                               int32_t rx_queue_id)
 284 {
 285         struct otx2_eth_dev *dev = eth_dev->data->dev_private;
 286         int i, rc;
 287
 288         RTE_SET_USED(event_dev);
 289         rc = strncmp(eth_dev->device->driver->name, "net_octeontx2", 13);
 290         if (rc)
 291                 return -EINVAL;
 292
 293         if (rx_queue_id < 0) {
 294                 for (i = 0 ; i < eth_dev->data->nb_rx_queues; i++)
 295                         rc = sso_rxq_disable(dev, i);
 296         } else {
 297                 rc = sso_rxq_disable(dev, (uint16_t)rx_queue_id);
 298         }
 299
 300         if (rc < 0)
 301                 otx2_err("Failed to clear Rx adapter config port=%d, q=%d",
 302                          eth_dev->data->port_id, rx_queue_id);
 303
 304         return rc;
 305 }