From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 8F7D4A04C2; Wed, 12 Aug 2020 08:32:20 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 751B21C0C9; Wed, 12 Aug 2020 08:31:52 +0200 (CEST) Received: from mail-qk1-f195.google.com (mail-qk1-f195.google.com [209.85.222.195]) by dpdk.org (Postfix) with ESMTP id 48C2D1C025 for ; Wed, 12 Aug 2020 08:31:51 +0200 (CEST) Received: by mail-qk1-f195.google.com with SMTP id m7so1117952qki.12 for ; Tue, 11 Aug 2020 23:31:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=broadcom.com; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=2XsR9cEA4NtR7q7qp3i+swYxtp7XKJGvOSiBLTGPnFE=; b=IlLAnzhpQl3cgx8xg4o4RMLHnP6sh51aXlKbxPPZ/dNH+gB58RCHOoFgjI+szTx5Y6 GyOYp9zjQLdpQbTjddzfkerjliUNqmoGqbJGRYe6S0hNe5ygcDA0orudvI6oifgniy4Y kRlyiWIOnkfCkOOEWW2JNxtrR/jnvs7GPDMbA= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=2XsR9cEA4NtR7q7qp3i+swYxtp7XKJGvOSiBLTGPnFE=; b=kUj06rlVAGD6pYuf6Nj2chMF8BNw5OC+D9XaT3OcNlZszeoW00FBUeuU11q383JYLd GDy/BmyX564XcA42pHFcLsWsOUUv304Gi9kjmMFmz142tKob+ejJ+waIanoPipIjQ1An 5pb3dfCX/OI6YXgxqJlFT00h/xUp0urDtNvY0AJqVU+ZIkSVOGKuPeWclufmnO2DFqLq DfqsILUjA9mp44TMBaOM+iL1i1/apOXW+Ppp4qVfmDG08RnyE38z0SVnthNyKbG5oGGP kmNIV1uniGe7LkCbg3PkF02o+C14ZNF5Ce5GuFFRrXQSX8UJ2FZLs+jifZ7RbflnP/Oy ohng== X-Gm-Message-State: AOAM5322tNf6WxzVIL10LNPywvhlsGDmyNeIAozJaBbEDDsn47p/Nw7g N/1vpRCFyL3OVIfFytPczqwzVLVZHI/B49Lttko/u7fYLesSqJCcucOlXHtAIv7C2kOxa+hsijY TGsmBRz2ugblcmx1rNBMVN6gie/AYfQUfvTukmMWPISKQ9PC0FsKuPNLMQOSV X-Google-Smtp-Source: ABdhPJy0eKQWO/rK/QMV1qLVa2hLdK8A9McOV2si+0Ci3QmwH2gVvY4gnXQqxKh5qbxcoKmiCqFB0g== X-Received: by 2002:a37:7245:: with SMTP id n66mr4646773qkc.83.1597213909610; Tue, 11 Aug 2020 23:31:49 -0700 (PDT) Received: from rahul_yocto_ubuntu18.ibn.broadcom.net ([192.19.234.250]) by smtp.gmail.com with ESMTPSA id x3sm1301552qkx.3.2020.08.11.23.31.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 11 Aug 2020 23:31:49 -0700 (PDT) From: Vikas Gupta To: dev@dpdk.org, akhil.goyal@nxp.com Cc: ajit.khaparde@broadcom.com, vikram.prakash@broadcom.com, Vikas Gupta , Raveendra Padasalagi Date: Wed, 12 Aug 2020 12:01:22 +0530 Message-Id: <20200812063127.8687-4-vikas.gupta@broadcom.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200812063127.8687-1-vikas.gupta@broadcom.com> References: <20200811145813.44754-1-vikas.gupta@broadcom.com> <20200812063127.8687-1-vikas.gupta@broadcom.com> Subject: [dpdk-dev] [PATCH v1 3/8] crypto/bcmfs: add apis for queue pair management X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Add queue pair management APIs which will be used by Crypto device to manage h/w queues. A bcmfs device structure owns multiple queue-pairs based on the mapped address allocated to it. Signed-off-by: Vikas Gupta Signed-off-by: Raveendra Padasalagi Reviewed-by: Ajit Khaparde --- drivers/crypto/bcmfs/Makefile | 28 --- drivers/crypto/bcmfs/bcmfs_device.c | 4 + drivers/crypto/bcmfs/bcmfs_device.h | 5 + drivers/crypto/bcmfs/bcmfs_hw_defs.h | 38 +++ drivers/crypto/bcmfs/bcmfs_qp.c | 345 +++++++++++++++++++++++++++ drivers/crypto/bcmfs/bcmfs_qp.h | 122 ++++++++++ drivers/crypto/bcmfs/meson.build | 3 +- 7 files changed, 516 insertions(+), 29 deletions(-) delete mode 100644 drivers/crypto/bcmfs/Makefile create mode 100644 drivers/crypto/bcmfs/bcmfs_hw_defs.h create mode 100644 drivers/crypto/bcmfs/bcmfs_qp.c create mode 100644 drivers/crypto/bcmfs/bcmfs_qp.h diff --git a/drivers/crypto/bcmfs/Makefile b/drivers/crypto/bcmfs/Makefile deleted file mode 100644 index 5f691f7ba..000000000 --- a/drivers/crypto/bcmfs/Makefile +++ /dev/null @@ -1,28 +0,0 @@ -# SPDX-License-Identifier: BSD-3-Clause -# Copyright(C) 2020 Broadcom -# All rights reserved. -# - -include $(RTE_SDK)/mk/rte.vars.mk - -# -# library name -# -LIB = librte_pmd_bcmfs.a - -CFLAGS += $(WERROR_FLAGS) -CFLAGS += -I$(RTE_SDK)/drivers/crypto/bcmfs -CFLAGS += -DALLOW_EXPERIMENTAL_API - -# -# all source are stored in SRCS-y -# -SRCS-y += bcmfs_logs.c -SRCS-y += bcmfs_device.c -SRCS-y += bcmfs_vfio.c - -LDLIBS += -lrte_eal -lrte_bus_vdev - -EXPORT_MAP := rte_pmd_bcmfs_version.map - -include $(RTE_SDK)/mk/rte.lib.mk diff --git a/drivers/crypto/bcmfs/bcmfs_device.c b/drivers/crypto/bcmfs/bcmfs_device.c index 3b5cc9e98..b475c2933 100644 --- a/drivers/crypto/bcmfs/bcmfs_device.c +++ b/drivers/crypto/bcmfs/bcmfs_device.c @@ -11,6 +11,7 @@ #include "bcmfs_device.h" #include "bcmfs_logs.h" +#include "bcmfs_qp.h" #include "bcmfs_vfio.h" struct bcmfs_device_attr { @@ -76,6 +77,9 @@ fsdev_allocate_one_dev(struct rte_vdev_device *vdev, if (bcmfs_attach_vfio(fsdev)) goto cleanup; + /* Maximum number of QPs supported */ + fsdev->max_hw_qps = fsdev->mmap_size / BCMFS_HW_QUEUE_IO_ADDR_LEN; + TAILQ_INSERT_TAIL(&fsdev_list, fsdev, next); return fsdev; diff --git a/drivers/crypto/bcmfs/bcmfs_device.h b/drivers/crypto/bcmfs/bcmfs_device.h index 5232bdea5..e03ce5b5b 100644 --- a/drivers/crypto/bcmfs/bcmfs_device.h +++ b/drivers/crypto/bcmfs/bcmfs_device.h @@ -11,6 +11,7 @@ #include #include "bcmfs_logs.h" +#include "bcmfs_qp.h" /* max number of dev nodes */ #define BCMFS_MAX_NODES 4 @@ -41,6 +42,10 @@ struct bcmfs_device { uint8_t *mmap_addr; /* mapped size */ uint32_t mmap_size; + /* max number of h/w queue pairs detected */ + uint16_t max_hw_qps; + /* current qpairs in use */ + struct bcmfs_qp *qps_in_use[BCMFS_MAX_HW_QUEUES]; }; #endif /* _BCMFS_DEV_H_ */ diff --git a/drivers/crypto/bcmfs/bcmfs_hw_defs.h b/drivers/crypto/bcmfs/bcmfs_hw_defs.h new file mode 100644 index 000000000..ecb0c09ba --- /dev/null +++ b/drivers/crypto/bcmfs/bcmfs_hw_defs.h @@ -0,0 +1,38 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 Broadcom + * All rights reserved. + */ + +#ifndef _BCMFS_RM_DEFS_H_ +#define _BCMFS_RM_DEFS_H_ + +#include +#include +#include +#include + +/* 32-bit MMIO register write */ +#define FS_MMIO_WRITE32(value, addr) rte_write32_relaxed((value), (addr)) + +/* 32-bit MMIO register read */ +#define FS_MMIO_READ32(addr) rte_read32_relaxed((addr)) + +#ifndef BIT +#define BIT(nr) (1UL << (nr)) +#endif + +#define FS_RING_REGS_SIZE 0x10000 +#define FS_RING_DESC_SIZE 8 +#define FS_RING_BD_ALIGN_ORDER 12 +#define FS_RING_BD_DESC_PER_REQ 32 +#define FS_RING_CMPL_ALIGN_ORDER 13 +#define FS_RING_CMPL_SIZE (1024 * FS_RING_DESC_SIZE) +#define FS_RING_MAX_REQ_COUNT 1024 +#define FS_RING_PAGE_SHFT 12 +#define FS_RING_PAGE_SIZE BIT(FS_RING_PAGE_SHFT) + +/* Minimum and maximum number of requests supported */ +#define FS_RM_MAX_REQS 1024 +#define FS_RM_MIN_REQS 32 + +#endif /* BCMFS_RM_DEFS_H_ */ diff --git a/drivers/crypto/bcmfs/bcmfs_qp.c b/drivers/crypto/bcmfs/bcmfs_qp.c new file mode 100644 index 000000000..864e7bb74 --- /dev/null +++ b/drivers/crypto/bcmfs/bcmfs_qp.c @@ -0,0 +1,345 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(C) 2020 Broadcom. + * All rights reserved. + */ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "bcmfs_logs.h" +#include "bcmfs_qp.h" +#include "bcmfs_hw_defs.h" + +/* TX or submission queue name */ +static const char *txq_name = "tx"; +/* Completion or receive queue name */ +static const char *cmplq_name = "cmpl"; + +/* Helper function */ +static int +bcmfs_qp_check_queue_alignment(uint64_t phys_addr, + uint32_t align) +{ + if (((align - 1) & phys_addr) != 0) + return -EINVAL; + return 0; +} + +static void +bcmfs_queue_delete(struct bcmfs_queue *queue, + uint16_t queue_pair_id) +{ + const struct rte_memzone *mz; + int status = 0; + + if (queue == NULL) { + BCMFS_LOG(DEBUG, "Invalid queue"); + return; + } + BCMFS_LOG(DEBUG, "Free ring %d type %d, memzone: %s", + queue_pair_id, queue->q_type, queue->memz_name); + + mz = rte_memzone_lookup(queue->memz_name); + if (mz != NULL) { + /* Write an unused pattern to the queue memory. */ + memset(queue->base_addr, 0x9B, queue->queue_size); + status = rte_memzone_free(mz); + if (status != 0) + BCMFS_LOG(ERR, "Error %d on freeing queue %s", + status, queue->memz_name); + } else { + BCMFS_LOG(DEBUG, "queue %s doesn't exist", + queue->memz_name); + } +} + +static const struct rte_memzone * +queue_dma_zone_reserve(const char *queue_name, uint32_t queue_size, + int socket_id, unsigned int align) +{ + const struct rte_memzone *mz; + + mz = rte_memzone_lookup(queue_name); + if (mz != NULL) { + if (((size_t)queue_size <= mz->len) && + (socket_id == SOCKET_ID_ANY || + socket_id == mz->socket_id)) { + BCMFS_LOG(DEBUG, "re-use memzone already " + "allocated for %s", queue_name); + return mz; + } + + BCMFS_LOG(ERR, "Incompatible memzone already " + "allocated %s, size %u, socket %d. " + "Requested size %u, socket %u", + queue_name, (uint32_t)mz->len, + mz->socket_id, queue_size, socket_id); + return NULL; + } + + BCMFS_LOG(DEBUG, "Allocate memzone for %s, size %u on socket %u", + queue_name, queue_size, socket_id); + return rte_memzone_reserve_aligned(queue_name, queue_size, + socket_id, RTE_MEMZONE_IOVA_CONTIG, align); +} + +static int +bcmfs_queue_create(struct bcmfs_queue *queue, + struct bcmfs_qp_config *qp_conf, + uint16_t queue_pair_id, + enum bcmfs_queue_type qtype) +{ + const struct rte_memzone *qp_mz; + char q_name[16]; + unsigned int align; + uint32_t queue_size_bytes; + int ret; + + if (qtype == BCMFS_RM_TXQ) { + strlcpy(q_name, txq_name, sizeof(q_name)); + align = 1U << FS_RING_BD_ALIGN_ORDER; + queue_size_bytes = qp_conf->nb_descriptors * + qp_conf->max_descs_req * FS_RING_DESC_SIZE; + queue_size_bytes = RTE_ALIGN_MUL_CEIL(queue_size_bytes, + FS_RING_PAGE_SIZE); + /* make queue size to multiple for 4K pages */ + } else if (qtype == BCMFS_RM_CPLQ) { + strlcpy(q_name, cmplq_name, sizeof(q_name)); + align = 1U << FS_RING_CMPL_ALIGN_ORDER; + + /* + * Memory size for cmpl + MSI + * For MSI allocate here itself and so we allocate twice + */ + queue_size_bytes = 2 * FS_RING_CMPL_SIZE; + } else { + BCMFS_LOG(ERR, "Invalid queue selection"); + return -EINVAL; + } + + queue->q_type = qtype; + + /* + * Allocate a memzone for the queue - create a unique name. + */ + snprintf(queue->memz_name, sizeof(queue->memz_name), + "%s_%d_%s_%d_%s", "bcmfs", qtype, "qp_mem", + queue_pair_id, q_name); + qp_mz = queue_dma_zone_reserve(queue->memz_name, queue_size_bytes, + 0, align); + if (qp_mz == NULL) { + BCMFS_LOG(ERR, "Failed to allocate ring memzone"); + return -ENOMEM; + } + + if (bcmfs_qp_check_queue_alignment(qp_mz->iova, align)) { + BCMFS_LOG(ERR, "Invalid alignment on queue create " + " 0x%" PRIx64 "\n", + queue->base_phys_addr); + ret = -EFAULT; + goto queue_create_err; + } + + queue->base_addr = (char *)qp_mz->addr; + queue->base_phys_addr = qp_mz->iova; + queue->queue_size = queue_size_bytes; + + return 0; + +queue_create_err: + rte_memzone_free(qp_mz); + + return ret; +} + +int +bcmfs_qp_release(struct bcmfs_qp **qp_addr) +{ + struct bcmfs_qp *qp = *qp_addr; + + if (qp == NULL) { + BCMFS_LOG(DEBUG, "qp already freed"); + return 0; + } + + /* Don't free memory if there are still responses to be processed */ + if ((qp->stats.enqueued_count - qp->stats.dequeued_count) == 0) { + /* Stop the h/w ring */ + qp->ops->stopq(qp); + /* Delete the queue pairs */ + bcmfs_queue_delete(&qp->tx_q, qp->qpair_id); + bcmfs_queue_delete(&qp->cmpl_q, qp->qpair_id); + } else { + return -EAGAIN; + } + + rte_bitmap_reset(qp->ctx_bmp); + rte_free(qp->ctx_bmp_mem); + rte_free(qp->ctx_pool); + + rte_free(qp); + *qp_addr = NULL; + + return 0; +} + +int +bcmfs_qp_setup(struct bcmfs_qp **qp_addr, + uint16_t queue_pair_id, + struct bcmfs_qp_config *qp_conf) +{ + struct bcmfs_qp *qp; + uint32_t bmp_size; + uint32_t nb_descriptors = qp_conf->nb_descriptors; + uint16_t i; + int rc; + + if (nb_descriptors < FS_RM_MIN_REQS) { + BCMFS_LOG(ERR, "Can't create qp for %u descriptors", + nb_descriptors); + return -EINVAL; + } + + if (nb_descriptors > FS_RM_MAX_REQS) + nb_descriptors = FS_RM_MAX_REQS; + + if (qp_conf->iobase == NULL) { + BCMFS_LOG(ERR, "IO onfig space null"); + return -EINVAL; + } + + qp = rte_zmalloc_socket("BCM FS PMD qp metadata", + sizeof(*qp), RTE_CACHE_LINE_SIZE, + qp_conf->socket_id); + if (qp == NULL) { + BCMFS_LOG(ERR, "Failed to alloc mem for qp struct"); + return -ENOMEM; + } + + qp->qpair_id = queue_pair_id; + qp->ioreg = qp_conf->iobase; + qp->nb_descriptors = nb_descriptors; + + qp->stats.enqueued_count = 0; + qp->stats.dequeued_count = 0; + + rc = bcmfs_queue_create(&qp->tx_q, qp_conf, qp->qpair_id, + BCMFS_RM_TXQ); + if (rc) { + BCMFS_LOG(ERR, "Tx queue create failed queue_pair_id %u", + queue_pair_id); + goto create_err; + } + + rc = bcmfs_queue_create(&qp->cmpl_q, qp_conf, qp->qpair_id, + BCMFS_RM_CPLQ); + if (rc) { + BCMFS_LOG(ERR, "Cmpl queue create failed queue_pair_id= %u", + queue_pair_id); + goto q_create_err; + } + + /* ctx saving bitmap */ + bmp_size = rte_bitmap_get_memory_footprint(nb_descriptors); + + /* Allocate memory for bitmap */ + qp->ctx_bmp_mem = rte_zmalloc("ctx_bmp_mem", bmp_size, + RTE_CACHE_LINE_SIZE); + if (qp->ctx_bmp_mem == NULL) { + rc = -ENOMEM; + goto qp_create_err; + } + + /* Initialize pool resource bitmap array */ + qp->ctx_bmp = rte_bitmap_init(nb_descriptors, qp->ctx_bmp_mem, + bmp_size); + if (qp->ctx_bmp == NULL) { + rc = -EINVAL; + goto bmap_mem_free; + } + + /* Mark all pools available */ + for (i = 0; i < nb_descriptors; i++) + rte_bitmap_set(qp->ctx_bmp, i); + + /* Allocate memory for context */ + qp->ctx_pool = rte_zmalloc("qp_ctx_pool", + sizeof(unsigned long) * + nb_descriptors, 0); + if (qp->ctx_pool == NULL) { + BCMFS_LOG(ERR, "ctx allocation pool fails"); + rc = -ENOMEM; + goto bmap_free; + } + + /* Start h/w ring */ + qp->ops->startq(qp); + + *qp_addr = qp; + + return 0; + +bmap_free: + rte_bitmap_reset(qp->ctx_bmp); +bmap_mem_free: + rte_free(qp->ctx_bmp_mem); +qp_create_err: + bcmfs_queue_delete(&qp->cmpl_q, queue_pair_id); +q_create_err: + bcmfs_queue_delete(&qp->tx_q, queue_pair_id); +create_err: + rte_free(qp); + + return rc; +} + +uint16_t +bcmfs_enqueue_op_burst(void *qp, void **ops, uint16_t nb_ops) +{ + struct bcmfs_qp *tmp_qp = (struct bcmfs_qp *)qp; + register uint32_t nb_ops_sent = 0; + uint16_t nb_ops_possible = nb_ops; + int ret; + + if (unlikely(nb_ops == 0)) + return 0; + + while (nb_ops_sent != nb_ops_possible) { + ret = tmp_qp->ops->enq_one_req(qp, *ops); + if (ret != 0) { + tmp_qp->stats.enqueue_err_count++; + /* This message cannot be enqueued */ + if (nb_ops_sent == 0) + return 0; + goto ring_db; + } + + ops++; + nb_ops_sent++; + } + +ring_db: + tmp_qp->stats.enqueued_count += nb_ops_sent; + tmp_qp->ops->ring_db(tmp_qp); + + return nb_ops_sent; +} + +uint16_t +bcmfs_dequeue_op_burst(void *qp, void **ops, uint16_t nb_ops) +{ + struct bcmfs_qp *tmp_qp = (struct bcmfs_qp *)qp; + uint32_t deq = tmp_qp->ops->dequeue(tmp_qp, ops, nb_ops); + + tmp_qp->stats.dequeued_count += deq; + + return deq; +} diff --git a/drivers/crypto/bcmfs/bcmfs_qp.h b/drivers/crypto/bcmfs/bcmfs_qp.h new file mode 100644 index 000000000..027d7a50c --- /dev/null +++ b/drivers/crypto/bcmfs/bcmfs_qp.h @@ -0,0 +1,122 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 Broadcom + * All rights reserved. + */ + +#ifndef _BCMFS_QP_H_ +#define _BCMFS_QP_H_ + +#include + +/* Maximum number of h/w queues supported by device */ +#define BCMFS_MAX_HW_QUEUES 32 + +/* H/W queue IO address space len */ +#define BCMFS_HW_QUEUE_IO_ADDR_LEN (64 * 1024) + +/* Maximum size of device ops name */ +#define BCMFS_HW_OPS_NAMESIZE 32 + +enum bcmfs_queue_type { + /* TX or submission queue */ + BCMFS_RM_TXQ, + /* Completion or receive queue */ + BCMFS_RM_CPLQ +}; + +struct bcmfs_qp_stats { + /* Count of all operations enqueued */ + uint64_t enqueued_count; + /* Count of all operations dequeued */ + uint64_t dequeued_count; + /* Total error count on operations enqueued */ + uint64_t enqueue_err_count; + /* Total error count on operations dequeued */ + uint64_t dequeue_err_count; +}; + +struct bcmfs_qp_config { + /* Socket to allocate memory on */ + int socket_id; + /* Mapped iobase for qp */ + void *iobase; + /* nb_descriptors or requests a h/w queue can accommodate */ + uint16_t nb_descriptors; + /* Maximum number of h/w descriptors needed by a request */ + uint16_t max_descs_req; +}; + +struct bcmfs_queue { + /* Base virt address */ + void *base_addr; + /* Base iova */ + rte_iova_t base_phys_addr; + /* Queue type */ + enum bcmfs_queue_type q_type; + /* Queue size based on nb_descriptors and max_descs_reqs */ + uint32_t queue_size; + union { + /* s/w pointer for tx h/w queue*/ + uint32_t tx_write_ptr; + /* s/w pointer for completion h/w queue*/ + uint32_t cmpl_read_ptr; + }; + /* Memzone name */ + char memz_name[RTE_MEMZONE_NAMESIZE]; +}; + +struct bcmfs_qp { + /* Queue-pair ID */ + uint16_t qpair_id; + /* Mapped IO address */ + void *ioreg; + /* A TX queue */ + struct bcmfs_queue tx_q; + /* A Completion queue */ + struct bcmfs_queue cmpl_q; + /* Number of requests queue can acommodate */ + uint32_t nb_descriptors; + /* Number of pending requests and enqueued to h/w queue */ + uint16_t nb_pending_requests; + /* A pool which act as a hash for pair */ + unsigned long *ctx_pool; + /* virt address for mem allocated for bitmap */ + void *ctx_bmp_mem; + /* Bitmap */ + struct rte_bitmap *ctx_bmp; + /* Associated stats */ + struct bcmfs_qp_stats stats; + /* h/w ops associated with qp */ + struct bcmfs_hw_queue_pair_ops *ops; + +} __rte_cache_aligned; + +/* Structure defining h/w queue pair operations */ +struct bcmfs_hw_queue_pair_ops { + /* ops name */ + char name[BCMFS_HW_OPS_NAMESIZE]; + /* Enqueue an object */ + int (*enq_one_req)(struct bcmfs_qp *qp, void *obj); + /* Ring doorbell */ + void (*ring_db)(struct bcmfs_qp *qp); + /* Dequeue objects */ + uint16_t (*dequeue)(struct bcmfs_qp *qp, void **obj, + uint16_t nb_ops); + /* Start the h/w queue */ + int (*startq)(struct bcmfs_qp *qp); + /* Stop the h/w queue */ + void (*stopq)(struct bcmfs_qp *qp); +}; + +uint16_t +bcmfs_enqueue_op_burst(void *qp, void **ops, uint16_t nb_ops); +uint16_t +bcmfs_dequeue_op_burst(void *qp, void **ops, uint16_t nb_ops); +int +bcmfs_qp_release(struct bcmfs_qp **qp_addr); +int +bcmfs_qp_setup(struct bcmfs_qp **qp_addr, + uint16_t queue_pair_id, + struct bcmfs_qp_config *bcmfs_conf); + +#endif /* _BCMFS_QP_H_ */ diff --git a/drivers/crypto/bcmfs/meson.build b/drivers/crypto/bcmfs/meson.build index fd39eba20..7e2bcbf14 100644 --- a/drivers/crypto/bcmfs/meson.build +++ b/drivers/crypto/bcmfs/meson.build @@ -7,5 +7,6 @@ deps += ['eal', 'bus_vdev'] sources = files( 'bcmfs_logs.c', 'bcmfs_device.c', - 'bcmfs_vfio.c' + 'bcmfs_vfio.c', + 'bcmfs_qp.c' ) -- 2.17.1