drivers/regex/mlx5/mlx5_regex_control.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2020 Mellanox Technologies, Ltd
   3  */
   4
   5 #include <errno.h>
   6
   7 #include <rte_log.h>
   8 #include <rte_errno.h>
   9 #include <rte_malloc.h>
  10 #include <rte_regexdev.h>
  11 #include <rte_regexdev_core.h>
  12 #include <rte_regexdev_driver.h>
  13 #include <rte_dev.h>
  14
  15 #include <mlx5_common.h>
  16 #include <mlx5_glue.h>
  17 #include <mlx5_devx_cmds.h>
  18 #include <mlx5_prm.h>
  19 #include <mlx5_common_os.h>
  20
  21 #include "mlx5_regex.h"
  22 #include "mlx5_regex_utils.h"
  23 #include "mlx5_rxp_csrs.h"
  24 #include "mlx5_rxp.h"
  25
  26 #define MLX5_REGEX_NUM_WQE_PER_PAGE (4096/64)
  27
  28 /**
  29  * Returns the number of qp obj to be created.
  30  *
  31  * @param nb_desc
  32  *   The number of descriptors for the queue.
  33  *
  34  * @return
  35  *   The number of obj to be created.
  36  */
  37 static uint16_t
  38 regex_ctrl_get_nb_obj(uint16_t nb_desc)
  39 {
  40         return ((nb_desc / MLX5_REGEX_NUM_WQE_PER_PAGE) +
  41                 !!(nb_desc % MLX5_REGEX_NUM_WQE_PER_PAGE));
  42 }
  43
  44 /**
  45  * destroy CQ.
  46  *
  47  * @param priv
  48  *   Pointer to the priv object.
  49  * @param cp
  50  *   Pointer to the CQ to be destroyed.
  51  *
  52  * @return
  53  *   0 on success, a negative errno value otherwise and rte_errno is set.
  54  */
  55 static int
  56 regex_ctrl_destroy_cq(struct mlx5_regex_priv *priv, struct mlx5_regex_cq *cq)
  57 {
  58         if (cq->cqe_umem) {
  59                 mlx5_glue->devx_umem_dereg(cq->cqe_umem);
  60                 cq->cqe_umem = NULL;
  61         }
  62         if (cq->cqe) {
  63                 rte_free((void *)(uintptr_t)cq->cqe);
  64                 cq->cqe = NULL;
  65         }
  66         if (cq->dbr_offset) {
  67                 mlx5_release_dbr(&priv->dbrpgs, cq->dbr_umem, cq->dbr_offset);
  68                 cq->dbr_offset = -1;
  69         }
  70         if (cq->obj) {
  71                 mlx5_devx_cmd_destroy(cq->obj);
  72                 cq->obj = NULL;
  73         }
  74         return 0;
  75 }
  76
  77 /**
  78  * create the CQ object.
  79  *
  80  * @param priv
  81  *   Pointer to the priv object.
  82  * @param cp
  83  *   Pointer to the CQ to be created.
  84  *
  85  * @return
  86  *   0 on success, a negative errno value otherwise and rte_errno is set.
  87  */
  88 static int
  89 regex_ctrl_create_cq(struct mlx5_regex_priv *priv, struct mlx5_regex_cq *cq)
  90 {
  91         struct mlx5_devx_cq_attr attr = {
  92                 .q_umem_valid = 1,
  93                 .db_umem_valid = 1,
  94                 .eqn = priv->eqn,
  95         };
  96         struct mlx5_devx_dbr_page *dbr_page = NULL;
  97         void *buf = NULL;
  98         size_t pgsize = sysconf(_SC_PAGESIZE);
  99         uint32_t cq_size = 1 << cq->log_nb_desc;
 100         uint32_t i;
 101
 102         cq->dbr_offset = mlx5_get_dbr(priv->ctx, &priv->dbrpgs, &dbr_page);
 103         if (cq->dbr_offset < 0) {
 104                 DRV_LOG(ERR, "Can't allocate cq door bell record.");
 105                 rte_errno  = ENOMEM;
 106                 goto error;
 107         }
 108         cq->dbr_umem = mlx5_os_get_umem_id(dbr_page->umem);
 109         cq->dbr = (uint32_t *)((uintptr_t)dbr_page->dbrs +
 110                                (uintptr_t)cq->dbr_offset);
 111
 112         buf = rte_calloc(NULL, 1, sizeof(struct mlx5_cqe) * cq_size, 4096);
 113         if (!buf) {
 114                 DRV_LOG(ERR, "Can't allocate cqe buffer.");
 115                 rte_errno  = ENOMEM;
 116                 goto error;
 117         }
 118         cq->cqe = buf;
 119         for (i = 0; i < cq_size; i++)
 120                 cq->cqe[i].op_own = 0xff;
 121         cq->cqe_umem = mlx5_glue->devx_umem_reg(priv->ctx, buf,
 122                                                 sizeof(struct mlx5_cqe) *
 123                                                 cq_size, 7);
 124         cq->ci = 0;
 125         if (!cq->cqe_umem) {
 126                 DRV_LOG(ERR, "Can't register cqe mem.");
 127                 rte_errno  = ENOMEM;
 128                 goto error;
 129         }
 130         attr.db_umem_offset = cq->dbr_offset;
 131         attr.db_umem_id = cq->dbr_umem;
 132         attr.q_umem_id = mlx5_os_get_umem_id(cq->cqe_umem);
 133         attr.log_cq_size = cq->log_nb_desc;
 134         attr.uar_page_id = priv->uar->page_id;
 135         attr.log_page_size = rte_log2_u32(pgsize);
 136         cq->obj = mlx5_devx_cmd_create_cq(priv->ctx, &attr);
 137         if (!cq->obj) {
 138                 DRV_LOG(ERR, "Can't create cq object.");
 139                 rte_errno  = ENOMEM;
 140                 goto error;
 141         }
 142         return 0;
 143 error:
 144         if (cq->cqe_umem)
 145                 mlx5_glue->devx_umem_dereg(cq->cqe_umem);
 146         if (buf)
 147                 rte_free(buf);
 148         if (cq->dbr_offset)
 149                 mlx5_release_dbr(&priv->dbrpgs, cq->dbr_umem, cq->dbr_offset);
 150         return -rte_errno;
 151 }
 152
 153 #ifdef HAVE_IBV_FLOW_DV_SUPPORT
 154 static int
 155 regex_get_pdn(void *pd, uint32_t *pdn)
 156 {
 157         struct mlx5dv_obj obj;
 158         struct mlx5dv_pd pd_info;
 159         int ret = 0;
 160
 161         obj.pd.in = pd;
 162         obj.pd.out = &pd_info;
 163         ret = mlx5_glue->dv_init_obj(&obj, MLX5DV_OBJ_PD);
 164         if (ret) {
 165                 DRV_LOG(DEBUG, "Fail to get PD object info");
 166                 return ret;
 167         }
 168         *pdn = pd_info.pdn;
 169         return 0;
 170 }
 171 #endif
 172
 173 /**
 174  * create the SQ object.
 175  *
 176  * @param priv
 177  *   Pointer to the priv object.
 178  * @param qp
 179  *   Pointer to the QP element
 180  * @param q_ind
 181  *   The index of the queue.
 182  * @param log_nb_desc
 183  *   Log 2 of the number of descriptors to be used.
 184  *
 185  * @return
 186  *   0 on success, a negative errno value otherwise and rte_errno is set.
 187  */
 188 static int
 189 regex_ctrl_create_sq(struct mlx5_regex_priv *priv, struct mlx5_regex_qp *qp,
 190                      uint16_t q_ind, uint16_t log_nb_desc)
 191 {
 192 #ifdef HAVE_IBV_FLOW_DV_SUPPORT
 193         struct mlx5_devx_create_sq_attr attr = { 0 };
 194         struct mlx5_devx_modify_sq_attr modify_attr = { 0 };
 195         struct mlx5_devx_wq_attr *wq_attr = &attr.wq_attr;
 196         struct mlx5_devx_dbr_page *dbr_page = NULL;
 197         struct mlx5_regex_sq *sq = &qp->sqs[q_ind];
 198         void *buf = NULL;
 199         uint32_t sq_size;
 200         uint32_t pd_num = 0;
 201         int ret;
 202
 203         sq->log_nb_desc = log_nb_desc;
 204         sq_size = 1 << sq->log_nb_desc;
 205         sq->dbr_offset = mlx5_get_dbr(priv->ctx, &priv->dbrpgs, &dbr_page);
 206         if (sq->dbr_offset < 0) {
 207                 DRV_LOG(ERR, "Can't allocate sq door bell record.");
 208                 rte_errno  = ENOMEM;
 209                 goto error;
 210         }
 211         sq->dbr_umem = mlx5_os_get_umem_id(dbr_page->umem);
 212         sq->dbr = (uint32_t *)((uintptr_t)dbr_page->dbrs +
 213                                (uintptr_t)sq->dbr_offset);
 214
 215         buf = rte_calloc(NULL, 1, 64 * sq_size, 4096);
 216         if (!buf) {
 217                 DRV_LOG(ERR, "Can't allocate wqe buffer.");
 218                 rte_errno  = ENOMEM;
 219                 goto error;
 220         }
 221         sq->wqe = buf;
 222         sq->wqe_umem = mlx5_glue->devx_umem_reg(priv->ctx, buf, 64 * sq_size,
 223                                                 7);
 224         sq->ci = 0;
 225         sq->pi = 0;
 226         if (!sq->wqe_umem) {
 227                 DRV_LOG(ERR, "Can't register wqe mem.");
 228                 rte_errno  = ENOMEM;
 229                 goto error;
 230         }
 231         attr.state = MLX5_SQC_STATE_RST;
 232         attr.tis_lst_sz = 0;
 233         attr.tis_num = 0;
 234         attr.user_index = q_ind;
 235         attr.cqn = qp->cq.obj->id;
 236         wq_attr->uar_page = priv->uar->page_id;
 237         regex_get_pdn(priv->pd, &pd_num);
 238         wq_attr->pd = pd_num;
 239         wq_attr->wq_type = MLX5_WQ_TYPE_CYCLIC;
 240         wq_attr->dbr_umem_id = sq->dbr_umem;
 241         wq_attr->dbr_addr = sq->dbr_offset;
 242         wq_attr->dbr_umem_valid = 1;
 243         wq_attr->wq_umem_id = mlx5_os_get_umem_id(sq->wqe_umem);
 244         wq_attr->wq_umem_offset = 0;
 245         wq_attr->wq_umem_valid = 1;
 246         wq_attr->log_wq_stride = 6;
 247         wq_attr->log_wq_sz = sq->log_nb_desc;
 248         sq->obj = mlx5_devx_cmd_create_sq(priv->ctx, &attr);
 249         if (!sq->obj) {
 250                 DRV_LOG(ERR, "Can't create sq object.");
 251                 rte_errno  = ENOMEM;
 252                 goto error;
 253         }
 254         modify_attr.state = MLX5_SQC_STATE_RDY;
 255         ret = mlx5_devx_cmd_modify_sq(sq->obj, &modify_attr);
 256         if (ret) {
 257                 DRV_LOG(ERR, "Can't change sq state to ready.");
 258                 rte_errno  = ENOMEM;
 259                 goto error;
 260         }
 261
 262         return 0;
 263 error:
 264         if (sq->wqe_umem)
 265                 mlx5_glue->devx_umem_dereg(sq->wqe_umem);
 266         if (buf)
 267                 rte_free(buf);
 268         if (sq->dbr_offset)
 269                 mlx5_release_dbr(&priv->dbrpgs, sq->dbr_umem, sq->dbr_offset);
 270         return -rte_errno;
 271 #else
 272         (void)priv;
 273         (void)qp;
 274         (void)q_ind;
 275         (void)log_nb_desc;
 276         DRV_LOG(ERR, "Cannot get pdn - no DV support.");
 277         return -ENOTSUP;
 278 #endif
 279 }
 280
 281 /**
 282  * Destroy the SQ object.
 283  *
 284  * @param priv
 285  *   Pointer to the priv object.
 286  * @param qp
 287  *   Pointer to the QP element
 288  * @param q_ind
 289  *   The index of the queue.
 290  *
 291  * @return
 292  *   0 on success, a negative errno value otherwise and rte_errno is set.
 293  */
 294 static int
 295 regex_ctrl_destroy_sq(struct mlx5_regex_priv *priv, struct mlx5_regex_qp *qp,
 296                       uint16_t q_ind)
 297 {
 298         struct mlx5_regex_sq *sq = &qp->sqs[q_ind];
 299
 300         if (sq->wqe_umem) {
 301                 mlx5_glue->devx_umem_dereg(sq->wqe_umem);
 302                 sq->wqe_umem = NULL;
 303         }
 304         if (sq->wqe) {
 305                 rte_free((void *)(uintptr_t)sq->wqe);
 306                 sq->wqe = NULL;
 307         }
 308         if (sq->dbr_offset) {
 309                 mlx5_release_dbr(&priv->dbrpgs, sq->dbr_umem, sq->dbr_offset);
 310                 sq->dbr_offset = -1;
 311         }
 312         if (sq->obj) {
 313                 mlx5_devx_cmd_destroy(sq->obj);
 314                 sq->obj = NULL;
 315         }
 316         return 0;
 317 }
 318
 319 /**
 320  * Setup the qp.
 321  *
 322  * @param dev
 323  *   Pointer to RegEx dev structure.
 324  * @param qp_ind
 325  *   The queue index to setup.
 326  * @param cfg
 327  *   The queue requested configuration.
 328  *
 329  * @return
 330  *   0 on success, a negative errno value otherwise and rte_errno is set.
 331  */
 332 int
 333 mlx5_regex_qp_setup(struct rte_regexdev *dev, uint16_t qp_ind,
 334                     const struct rte_regexdev_qp_conf *cfg)
 335 {
 336         struct mlx5_regex_priv *priv = dev->data->dev_private;
 337         struct mlx5_regex_qp *qp;
 338         int i;
 339         int ret;
 340         uint16_t log_desc;
 341
 342         qp = &priv->qps[qp_ind];
 343         qp->flags = cfg->qp_conf_flags;
 344         qp->cq.log_nb_desc = rte_log2_u32(cfg->nb_desc);
 345         qp->nb_desc = 1 << qp->cq.log_nb_desc;
 346         if (qp->flags & RTE_REGEX_QUEUE_PAIR_CFG_OOS_F)
 347                 qp->nb_obj = regex_ctrl_get_nb_obj(qp->nb_desc);
 348         else
 349                 qp->nb_obj = 1;
 350         qp->sqs = rte_malloc(NULL,
 351                              qp->nb_obj * sizeof(struct mlx5_regex_sq), 64);
 352         if (!qp->sqs) {
 353                 DRV_LOG(ERR, "Can't allocate sq array memory.");
 354                 rte_errno = ENOMEM;
 355                 return -rte_errno;
 356         }
 357         log_desc = rte_log2_u32(qp->nb_desc / qp->nb_obj);
 358         ret = regex_ctrl_create_cq(priv, &qp->cq);
 359         if (ret) {
 360                 DRV_LOG(ERR, "Can't create cq.");
 361                 goto err_cq;
 362         }
 363         for (i = 0; i < qp->nb_obj; i++) {
 364                 ret = regex_ctrl_create_sq(priv, qp, i, log_desc);
 365                 if (ret) {
 366                         DRV_LOG(ERR, "Can't create sq.");
 367                         goto err_sq;
 368                 }
 369         }
 370
 371         ret = mlx5_mr_btree_init(&qp->mr_ctrl.cache_bh, MLX5_MR_BTREE_CACHE_N,
 372                                  rte_socket_id());
 373         if (ret) {
 374                 DRV_LOG(ERR, "Error setting up mr btree");
 375                 goto err_btree;
 376         }
 377
 378         ret = mlx5_regexdev_setup_fastpath(priv, qp_ind);
 379         if (ret) {
 380                 DRV_LOG(ERR, "Error setting up fastpath");
 381                 goto err_fp;
 382         }
 383         return 0;
 384
 385 err_fp:
 386         mlx5_mr_btree_free(&qp->mr_ctrl.cache_bh);
 387 err_btree:
 388         for (i = 0; i < qp->nb_obj; i++)
 389                 regex_ctrl_destroy_sq(priv, qp, i);
 390 err_sq:
 391         regex_ctrl_destroy_cq(priv, &qp->cq);
 392 err_cq:
 393         rte_free(qp->sqs);
 394         return ret;
 395 }