X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fregex%2Fmlx5%2Fmlx5_regex.c;h=b39181ebb57869c5d98da3871c2a3861420fdf1f;hb=fb690f71bdb4c024838f6fa5b9a1f6277e691ae1;hp=68438a6c03178c8d00d8922abbc06b396433d8f6;hpb=4d4e245ad637c0befbd6da9976c28174a1d74b88;p=dpdk.git diff --git a/drivers/regex/mlx5/mlx5_regex.c b/drivers/regex/mlx5/mlx5_regex.c index 68438a6c03..b39181ebb5 100644 --- a/drivers/regex/mlx5/mlx5_regex.c +++ b/drivers/regex/mlx5/mlx5_regex.c @@ -5,12 +5,14 @@ #include #include #include -#include #include #include #include #include +#include +#include +#include #include #include #include @@ -19,42 +21,42 @@ #include "mlx5_regex_utils.h" #include "mlx5_rxp_csrs.h" +#define MLX5_REGEX_DRIVER_NAME regex_mlx5 + int mlx5_regex_logtype; +TAILQ_HEAD(regex_mem_event, mlx5_regex_priv) mlx5_mem_event_list = + TAILQ_HEAD_INITIALIZER(mlx5_mem_event_list); +static pthread_mutex_t mem_event_list_lock = PTHREAD_MUTEX_INITIALIZER; + const struct rte_regexdev_ops mlx5_regexdev_ops = { .dev_info_get = mlx5_regex_info_get, .dev_configure = mlx5_regex_configure, .dev_db_import = mlx5_regex_rules_db_import, .dev_qp_setup = mlx5_regex_qp_setup, + .dev_start = mlx5_regex_start, + .dev_stop = mlx5_regex_stop, + .dev_close = mlx5_regex_close, }; -static struct ibv_device * -mlx5_regex_get_ib_device_match(struct rte_pci_addr *addr) +int +mlx5_regex_start(struct rte_regexdev *dev __rte_unused) { - int n; - struct ibv_device **ibv_list = mlx5_glue->get_device_list(&n); - struct ibv_device *ibv_match = NULL; + return 0; +} - if (!ibv_list) { - rte_errno = ENOSYS; - return NULL; - } - while (n-- > 0) { - struct rte_pci_addr pci_addr; - - DRV_LOG(DEBUG, "Checking device \"%s\"..", ibv_list[n]->name); - if (mlx5_dev_to_pci_addr(ibv_list[n]->ibdev_path, &pci_addr)) - continue; - if (rte_pci_addr_cmp(addr, &pci_addr)) - continue; - ibv_match = ibv_list[n]; - break; - } - if (!ibv_match) - rte_errno = ENOENT; - mlx5_glue->free_device_list(ibv_list); - return ibv_match; +int +mlx5_regex_stop(struct rte_regexdev *dev __rte_unused) +{ + return 0; +} + +int +mlx5_regex_close(struct rte_regexdev *dev __rte_unused) +{ + return 0; } + static int mlx5_regex_engines_status(struct ibv_context *ctx, int num_engines) { @@ -79,135 +81,175 @@ mlx5_regex_engines_status(struct ibv_context *ctx, int num_engines) } static void -mlx5_regex_get_name(char *name, struct rte_pci_device *pci_dev __rte_unused) +mlx5_regex_get_name(char *name, struct rte_device *dev) { - sprintf(name, "mlx5_regex_%02x:%02x.%02x", pci_dev->addr.bus, - pci_dev->addr.devid, pci_dev->addr.function); + sprintf(name, "mlx5_regex_%s", dev->name); +} + +/** + * Callback for memory event. + * + * @param event_type + * Memory event type. + * @param addr + * Address of memory. + * @param len + * Size of memory. + */ +static void +mlx5_regex_mr_mem_event_cb(enum rte_mem_event event_type, const void *addr, + size_t len, void *arg __rte_unused) +{ + struct mlx5_regex_priv *priv; + + /* Must be called from the primary process. */ + MLX5_ASSERT(rte_eal_process_type() == RTE_PROC_PRIMARY); + switch (event_type) { + case RTE_MEM_EVENT_FREE: + pthread_mutex_lock(&mem_event_list_lock); + /* Iterate all the existing mlx5 devices. */ + TAILQ_FOREACH(priv, &mlx5_mem_event_list, mem_event_cb) + mlx5_free_mr_by_addr(&priv->mr_scache, + mlx5_os_get_ctx_device_name + (priv->cdev->ctx), + addr, len); + pthread_mutex_unlock(&mem_event_list_lock); + break; + case RTE_MEM_EVENT_ALLOC: + default: + break; + } } static int -mlx5_regex_pci_probe(struct rte_pci_driver *pci_drv __rte_unused, - struct rte_pci_device *pci_dev) +mlx5_regex_dev_probe(struct mlx5_common_device *cdev) { - struct ibv_device *ibv; struct mlx5_regex_priv *priv = NULL; - struct ibv_context *ctx = NULL; - struct mlx5_hca_attr attr; + struct mlx5_hca_attr *attr = &cdev->config.hca_attr; char name[RTE_REGEXDEV_NAME_MAX_LEN]; int ret; + uint32_t val; - ibv = mlx5_regex_get_ib_device_match(&pci_dev->addr); - if (!ibv) { - DRV_LOG(ERR, "No matching IB device for PCI slot " - PCI_PRI_FMT ".", pci_dev->addr.domain, - pci_dev->addr.bus, pci_dev->addr.devid, - pci_dev->addr.function); - return -rte_errno; - } - DRV_LOG(INFO, "PCI information matches for device \"%s\".", - ibv->name); - ctx = mlx5_glue->dv_open_device(ibv); - if (!ctx) { - DRV_LOG(ERR, "Failed to open IB device \"%s\".", ibv->name); - rte_errno = ENODEV; - return -rte_errno; - } - ret = mlx5_devx_cmd_query_hca_attr(ctx, &attr); - if (ret) { - DRV_LOG(ERR, "Unable to read HCA capabilities."); - rte_errno = ENOTSUP; - goto error; - } else if (!attr.regex || attr.regexp_num_of_engines == 0) { + if ((!attr->regex && !attr->mmo_regex_sq_en && !attr->mmo_regex_qp_en) + || attr->regexp_num_of_engines == 0) { DRV_LOG(ERR, "Not enough capabilities to support RegEx, maybe " "old FW/OFED version?"); rte_errno = ENOTSUP; - goto error; + return -rte_errno; } - if (mlx5_regex_engines_status(ctx, 2)) { + if (mlx5_regex_engines_status(cdev->ctx, 2)) { DRV_LOG(ERR, "RegEx engine error."); rte_errno = ENOMEM; - goto error; + return -rte_errno; } priv = rte_zmalloc("mlx5 regex device private", sizeof(*priv), RTE_CACHE_LINE_SIZE); if (!priv) { DRV_LOG(ERR, "Failed to allocate private memory."); rte_errno = ENOMEM; - goto error; + return -rte_errno; } - priv->ctx = ctx; + priv->mmo_regex_qp_cap = attr->mmo_regex_qp_en; + priv->mmo_regex_sq_cap = attr->mmo_regex_sq_en; + priv->cdev = cdev; priv->nb_engines = 2; /* attr.regexp_num_of_engines */ + ret = mlx5_devx_regex_register_read(priv->cdev->ctx, 0, + MLX5_RXP_CSR_IDENTIFIER, &val); + if (ret) { + DRV_LOG(ERR, "CSR read failed!"); + goto dev_error; + } + if (val == MLX5_RXP_BF2_IDENTIFIER) + priv->is_bf2 = 1; /* Default RXP programming mode to Shared. */ priv->prog_mode = MLX5_RXP_SHARED_PROG_MODE; - mlx5_regex_get_name(name, pci_dev); + mlx5_regex_get_name(name, cdev->dev); priv->regexdev = rte_regexdev_register(name); if (priv->regexdev == NULL) { DRV_LOG(ERR, "Failed to register RegEx device."); rte_errno = rte_errno ? rte_errno : EINVAL; - goto error; - } - ret = mlx5_glue->devx_query_eqn(ctx, 0, &priv->eqn); - if (ret) { - DRV_LOG(ERR, "can't query event queue number."); - rte_errno = ENOMEM; - goto error; + goto dev_error; } - priv->uar = mlx5_glue->devx_alloc_uar(ctx, 0); + /* + * This PMD always claims the write memory barrier on UAR + * registers writings, it is safe to allocate UAR with any + * memory mapping type. + */ + priv->uar = mlx5_devx_alloc_uar(priv->cdev->ctx, -1); if (!priv->uar) { DRV_LOG(ERR, "can't allocate uar."); rte_errno = ENOMEM; goto error; } - priv->pd = mlx5_glue->alloc_pd(ctx); - if (!priv->pd) { - DRV_LOG(ERR, "can't allocate pd."); - rte_errno = ENOMEM; - goto error; - } priv->regexdev->dev_ops = &mlx5_regexdev_ops; priv->regexdev->enqueue = mlx5_regexdev_enqueue; - priv->regexdev->device = (struct rte_device *)pci_dev; +#ifdef HAVE_MLX5_UMR_IMKEY + if (!attr->umr_indirect_mkey_disabled && + !attr->umr_modify_entity_size_disabled) + priv->has_umr = 1; + if (priv->has_umr) + priv->regexdev->enqueue = mlx5_regexdev_enqueue_gga; +#endif + priv->regexdev->dequeue = mlx5_regexdev_dequeue; + priv->regexdev->device = cdev->dev; priv->regexdev->data->dev_private = priv; priv->regexdev->state = RTE_REGEXDEV_READY; + ret = mlx5_mr_create_cache(&priv->mr_scache, rte_socket_id()); + if (ret) { + DRV_LOG(ERR, "MR init tree failed."); + rte_errno = ENOMEM; + goto error; + } + /* Register callback function for global shared MR cache management. */ + if (TAILQ_EMPTY(&mlx5_mem_event_list)) + rte_mem_event_callback_register("MLX5_MEM_EVENT_CB", + mlx5_regex_mr_mem_event_cb, + NULL); + /* Add device to memory callback list. */ + pthread_mutex_lock(&mem_event_list_lock); + TAILQ_INSERT_TAIL(&mlx5_mem_event_list, priv, mem_event_cb); + pthread_mutex_unlock(&mem_event_list_lock); + DRV_LOG(INFO, "RegEx GGA is %s.", + priv->has_umr ? "supported" : "unsupported"); return 0; error: - if (priv->pd) - mlx5_glue->dealloc_pd(priv->pd); if (priv->uar) mlx5_glue->devx_free_uar(priv->uar); if (priv->regexdev) rte_regexdev_unregister(priv->regexdev); - if (ctx) - mlx5_glue->close_device(ctx); +dev_error: if (priv) rte_free(priv); return -rte_errno; } static int -mlx5_regex_pci_remove(struct rte_pci_device *pci_dev) +mlx5_regex_dev_remove(struct mlx5_common_device *cdev) { char name[RTE_REGEXDEV_NAME_MAX_LEN]; struct rte_regexdev *dev; struct mlx5_regex_priv *priv = NULL; - mlx5_regex_get_name(name, pci_dev); + mlx5_regex_get_name(name, cdev->dev); dev = rte_regexdev_get_device_by_name(name); if (!dev) return 0; priv = dev->data->dev_private; if (priv) { - if (priv->pd) - mlx5_glue->dealloc_pd(priv->pd); + /* Remove from memory callback device list. */ + pthread_mutex_lock(&mem_event_list_lock); + TAILQ_REMOVE(&mlx5_mem_event_list, priv, mem_event_cb); + pthread_mutex_unlock(&mem_event_list_lock); + if (TAILQ_EMPTY(&mlx5_mem_event_list)) + rte_mem_event_callback_unregister("MLX5_MEM_EVENT_CB", + NULL); + if (priv->mr_scache.cache.table) + mlx5_mr_release_cache(&priv->mr_scache); if (priv->uar) mlx5_glue->devx_free_uar(priv->uar); if (priv->regexdev) rte_regexdev_unregister(priv->regexdev); - if (priv->ctx) - mlx5_glue->close_device(priv->ctx); - if (priv->regexdev) - rte_regexdev_unregister(priv->regexdev); rte_free(priv); } return 0; @@ -218,28 +260,31 @@ static const struct rte_pci_id mlx5_regex_pci_id_map[] = { RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX, PCI_DEVICE_ID_MELLANOX_CONNECTX6DXBF) }, + { + RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX, + PCI_DEVICE_ID_MELLANOX_CONNECTX7BF) + }, { .vendor_id = 0 } }; -static struct rte_pci_driver mlx5_regex_driver = { - .driver = { - .name = "mlx5_regex", - }, +static struct mlx5_class_driver mlx5_regex_driver = { + .drv_class = MLX5_CLASS_REGEX, + .name = RTE_STR(MLX5_REGEX_DRIVER_NAME), .id_table = mlx5_regex_pci_id_map, - .probe = mlx5_regex_pci_probe, - .remove = mlx5_regex_pci_remove, - .drv_flags = 0, + .probe = mlx5_regex_dev_probe, + .remove = mlx5_regex_dev_remove, }; RTE_INIT(rte_mlx5_regex_init) { + mlx5_common_init(); if (mlx5_glue) - rte_pci_register(&mlx5_regex_driver); + mlx5_class_driver_register(&mlx5_regex_driver); } -RTE_LOG_REGISTER(mlx5_regex_logtype, pmd.regex.mlx5, NOTICE) -RTE_PMD_EXPORT_NAME(net_mlx5_regex, __COUNTER__); -RTE_PMD_REGISTER_PCI_TABLE(net_mlx5_regex, mlx5_regex_pci_id_map); -RTE_PMD_REGISTER_KMOD_DEP(net_mlx5_regex, "* ib_uverbs & mlx5_core & mlx5_ib"); +RTE_LOG_REGISTER_DEFAULT(mlx5_regex_logtype, NOTICE) +RTE_PMD_EXPORT_NAME(MLX5_REGEX_DRIVER_NAME, __COUNTER__); +RTE_PMD_REGISTER_PCI_TABLE(MLX5_REGEX_DRIVER_NAME, mlx5_regex_pci_id_map); +RTE_PMD_REGISTER_KMOD_DEP(MLX5_REGEX_DRIVER_NAME, "* ib_uverbs & mlx5_core & mlx5_ib");