d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

common/qat: improve multi-process handling

Browse Source 
This patch refactors qat data into structures
which are local to the process and structures which
are intended to be shared by primary and secondary
processes. This enables qat devices to be used by
multi process applications.

Signed-off-by: Arek Kusztal <arkadiuszx.kusztal@intel.com>
Acked-by: Fiona Trahe <fiona.trahe@intel.com>
This commit is contained in:
Arek Kusztal 2020-07-07 17:02:37 +02:00 committed by Thomas Monjalon
parent d55db36986
commit 9904ff6849
7 changed files with 179 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
doc/guides/rel_notes/release_20_08.rst
View File

@ -130,6 +130,7 @@ New Features
* Added support for lookaside protocol offload for DOCSIS through the
``rte_security`` API.
* Improved handling of multi process in QAT crypto and compression PMDs.
* **Updated the OCTEON TX2 crypto PMD.**

111
drivers/common/qat/qat_device.c
View File

@ -32,8 +32,8 @@ struct qat_gen_hw_data qat_gen_config[] = {
},
};
static struct qat_pci_device qat_pci_devices[RTE_PMD_QAT_MAX_PCI_DEVICES];
/* per-process array of device data */
struct qat_device_info qat_pci_devs[RTE_PMD_QAT_MAX_PCI_DEVICES];
static int qat_nb_pci_devices;
/*
@ -59,27 +59,21 @@ static const struct rte_pci_id pci_id_qat_map[] = {
{.device_id = 0},
};
static struct qat_pci_device *
qat_pci_get_dev(uint8_t dev_id)
{
return &qat_pci_devices[dev_id];
}
static struct qat_pci_device *
qat_pci_get_named_dev(const char *name)
{
struct qat_pci_device *dev;
unsigned int i;
if (name == NULL)
return NULL;
for (i = 0; i < RTE_PMD_QAT_MAX_PCI_DEVICES; i++) {
dev = &qat_pci_devices[i];
if ((dev->attached == QAT_ATTACHED) &&
(strcmp(dev->name, name) == 0))
return dev;
if (qat_pci_devs[i].mz &&
(strcmp(((struct qat_pci_device *)
qat_pci_devs[i].mz->addr)->name, name)
== 0))
return (struct qat_pci_device *)
qat_pci_devs[i].mz->addr;
}
return NULL;
@ -88,13 +82,14 @@ qat_pci_get_named_dev(const char *name)
static uint8_t
qat_pci_find_free_device_index(void)
{
uint8_t dev_id;
uint8_t dev_id;
for (dev_id = 0; dev_id < RTE_PMD_QAT_MAX_PCI_DEVICES; dev_id++) {
if (qat_pci_devices[dev_id].attached == QAT_DETACHED)
break;
}
return dev_id;
for (dev_id = 0; dev_id < RTE_PMD_QAT_MAX_PCI_DEVICES;
dev_id++) {
if (qat_pci_devs[dev_id].mz == NULL)
break;
}
return dev_id;
}
struct qat_pci_device *
@ -169,12 +164,31 @@ qat_pci_device_allocate(struct rte_pci_device *pci_dev,
struct qat_dev_cmd_param *qat_dev_cmd_param)
{
struct qat_pci_device *qat_dev;
uint8_t qat_dev_id;
uint8_t qat_dev_id = 0;
char name[QAT_DEV_NAME_MAX_LEN];
struct rte_devargs *devargs = pci_dev->device.devargs;
rte_pci_device_name(&pci_dev->addr, name, sizeof(name));
snprintf(name+strlen(name), QAT_DEV_NAME_MAX_LEN-strlen(name), "_qat");
if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
const struct rte_memzone *mz = rte_memzone_lookup(name);
if (mz == NULL) {
QAT_LOG(ERR,
"Secondary can't find %s mz, did primary create device?",
name);
return NULL;
}
qat_dev = mz->addr;
qat_pci_devs[qat_dev->qat_dev_id].mz = mz;
qat_pci_devs[qat_dev->qat_dev_id].pci_dev = pci_dev;
qat_nb_pci_devices++;
QAT_LOG(DEBUG, "QAT device %d found, name %s, total QATs %d",
qat_dev->qat_dev_id, qat_dev->name, qat_nb_pci_devices);
return qat_dev;
}
if (qat_pci_get_named_dev(name) != NULL) {
QAT_LOG(ERR, "QAT device with name %s already allocated!",
name);
@ -187,12 +201,22 @@ qat_pci_device_allocate(struct rte_pci_device *pci_dev,
return NULL;
}
qat_dev = qat_pci_get_dev(qat_dev_id);
qat_pci_devs[qat_dev_id].mz = rte_memzone_reserve(name,
sizeof(struct qat_pci_device),
rte_socket_id(), 0);
if (qat_pci_devs[qat_dev_id].mz == NULL) {
QAT_LOG(ERR, "Error when allocating memzone for QAT_%d",
qat_dev_id);
return NULL;
}
qat_dev = qat_pci_devs[qat_dev_id].mz->addr;
memset(qat_dev, 0, sizeof(*qat_dev));
strlcpy(qat_dev->name, name, QAT_DEV_NAME_MAX_LEN);
qat_dev->qat_dev_id = qat_dev_id;
qat_dev->pci_dev = pci_dev;
switch (qat_dev->pci_dev->id.device_id) {
qat_pci_devs[qat_dev_id].pci_dev = pci_dev;
switch (pci_dev->id.device_id) {
case 0x0443:
qat_dev->qat_dev_gen = QAT_GEN1;
break;
@ -206,6 +230,7 @@ qat_pci_device_allocate(struct rte_pci_device *pci_dev,
break;
default:
QAT_LOG(ERR, "Invalid dev_id, can't determine generation");
rte_memzone_free(qat_pci_devs[qat_dev->qat_dev_id].mz);
return NULL;
}
@ -213,22 +238,20 @@ qat_pci_device_allocate(struct rte_pci_device *pci_dev,
qat_dev_parse_cmd(devargs->drv_str, qat_dev_cmd_param);
rte_spinlock_init(&qat_dev->arb_csr_lock);
qat_dev->attached = QAT_ATTACHED;
qat_nb_pci_devices++;
QAT_LOG(DEBUG, "QAT device %d allocated, name %s, total QATs %d",
QAT_LOG(DEBUG, "QAT device %d found, name %s, total QATs %d",
qat_dev->qat_dev_id, qat_dev->name, qat_nb_pci_devices);
return qat_dev;
}
int
static int
qat_pci_device_release(struct rte_pci_device *pci_dev)
{
struct qat_pci_device *qat_dev;
char name[QAT_DEV_NAME_MAX_LEN];
int busy = 0;
if (pci_dev == NULL)
return -EINVAL;
@ -238,15 +261,35 @@ qat_pci_device_release(struct rte_pci_device *pci_dev)
qat_dev = qat_pci_get_named_dev(name);
if (qat_dev != NULL) {
struct qat_device_info *inst =
&qat_pci_devs[qat_dev->qat_dev_id];
/* Check that there are no service devs still on pci device */
if (qat_dev->sym_dev != NULL)
return -EBUSY;
qat_dev->attached = QAT_DETACHED;
if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
if (qat_dev->sym_dev != NULL) {
QAT_LOG(DEBUG, "QAT sym device %s is busy",
name);
busy = 1;
}
if (qat_dev->asym_dev != NULL) {
QAT_LOG(DEBUG, "QAT asym device %s is busy",
name);
busy = 1;
}
if (qat_dev->comp_dev != NULL) {
QAT_LOG(DEBUG, "QAT comp device %s is busy",
name);
busy = 1;
}
if (busy)
return -EBUSY;
rte_memzone_free(inst->mz);
}
memset(inst, 0, sizeof(struct qat_device_info));
qat_nb_pci_devices--;
QAT_LOG(DEBUG, "QAT device %s released, total QATs %d",
name, qat_nb_pci_devices);
}
QAT_LOG(DEBUG, "QAT device %s released, total QATs %d",
name, qat_nb_pci_devices);
return 0;
}

65
drivers/common/qat/qat_device.h
View File

@ -32,6 +32,37 @@ enum qat_comp_num_im_buffers {
QAT_NUM_INTERM_BUFS_GEN3 = 20
};
struct qat_device_info {
const struct rte_memzone *mz;
/**< mz to store the qat_pci_device so it can be
* shared across processes
*/
struct rte_pci_device *pci_dev;
struct rte_device sym_rte_dev;
/**< This represents the crypto sym subset of this pci device.
* Register with this rather than with the one in
* pci_dev so that its driver can have a crypto-specific name
*/
struct rte_device asym_rte_dev;
/**< This represents the crypto asym subset of this pci device.
* Register with this rather than with the one in
* pci_dev so that its driver can have a crypto-specific name
*/
struct rte_device comp_rte_dev;
/**< This represents the compression subset of this pci device.
* Register with this rather than with the one in
* pci_dev so that its driver can have a compression-specific name
*/
};
extern struct qat_device_info qat_pci_devs[];
struct qat_sym_dev_private;
struct qat_asym_dev_private;
struct qat_comp_dev_private;
/*
* This struct holds all the data about a QAT pci device
* including data about all services it supports.
@ -39,27 +70,20 @@ enum qat_comp_num_im_buffers {
* - hw_data
* - config data
* - runtime data
* Note: as this data can be shared in a multi-process scenario,
* any pointers in it must also point to shared memory.
*/
struct qat_sym_dev_private;
struct qat_asym_dev_private;
struct qat_comp_dev_private;
struct qat_pci_device {
/* Data used by all services */
char name[QAT_DEV_NAME_MAX_LEN];
/**< Name of qat pci device */
uint8_t qat_dev_id;
/**< Device instance for this qat pci device */
struct rte_pci_device *pci_dev;
/**< PCI information. */
/**< Id of device instance for this qat pci device */
enum qat_device_gen qat_dev_gen;
/**< QAT device generation */
rte_spinlock_t arb_csr_lock;
/**< lock to protect accesses to the arbiter CSR */
__extension__
uint8_t attached : 1;
/**< Flag indicating the device is attached */
struct qat_qp *qps_in_use[QAT_MAX_SERVICES][ADF_MAX_QPS_ON_ANY_SERVICE];
/**< links to qps set up for each service, index same as on API */
@ -67,32 +91,14 @@ struct qat_pci_device {
/* Data relating to symmetric crypto service */
struct qat_sym_dev_private *sym_dev;
/**< link back to cryptodev private data */
struct rte_device sym_rte_dev;
/**< This represents the crypto sym subset of this pci device.
* Register with this rather than with the one in
* pci_dev so that its driver can have a crypto-specific name
*/
/* Data relating to asymmetric crypto service */
struct qat_asym_dev_private *asym_dev;
/**< link back to cryptodev private data */
struct rte_device asym_rte_dev;
/**< This represents the crypto asym subset of this pci device.
* Register with this rather than with the one in
* pci_dev so that its driver can have a crypto-specific name
*/
/* Data relating to compression service */
struct qat_comp_dev_private *comp_dev;
/**< link back to compressdev private data */
struct rte_device comp_rte_dev;
/**< This represents the compression subset of this pci device.
* Register with this rather than with the one in
* pci_dev so that its driver can have a compression-specific name
*/
/* Data relating to asymmetric crypto service */
};
struct qat_gen_hw_data {
@ -107,9 +113,6 @@ struct qat_pci_device *
qat_pci_device_allocate(struct rte_pci_device *pci_dev,
struct qat_dev_cmd_param *qat_dev_cmd_param);
int
qat_pci_device_release(struct rte_pci_device *pci_dev);
struct qat_pci_device *
qat_get_qat_dev_from_pci_dev(struct rte_pci_device *pci_dev);

26
drivers/common/qat/qat_qp.c
View File

@ -193,7 +193,8 @@ int qat_qp_setup(struct qat_pci_device *qat_dev,
{
struct qat_qp *qp;
struct rte_pci_device *pci_dev = qat_dev->pci_dev;
struct rte_pci_device *pci_dev =
qat_pci_devs[qat_dev->qat_dev_id].pci_dev;
char op_cookie_pool_name[RTE_RING_NAMESIZE];
uint32_t i;
@ -274,7 +275,7 @@ int qat_qp_setup(struct qat_pci_device *qat_dev,
qp->nb_descriptors,
qat_qp_conf->cookie_size, 64, 0,
NULL, NULL, NULL, NULL,
qat_dev->pci_dev->device.numa_node,
pci_dev->device.numa_node,
0);
if (!qp->op_cookie_pool) {
QAT_LOG(ERR, "QAT PMD Cannot create"
@ -379,7 +380,8 @@ qat_queue_create(struct qat_pci_device *qat_dev, struct qat_queue *queue,
uint64_t queue_base;
void *io_addr;
const struct rte_memzone *qp_mz;
struct rte_pci_device *pci_dev = qat_dev->pci_dev;
struct rte_pci_device *pci_dev =
qat_pci_devs[qat_dev->qat_dev_id].pci_dev;
int ret = 0;
uint16_t desc_size = (dir == ADF_RING_DIR_TX ?
qp_conf->hw->tx_msg_size : qp_conf->hw->rx_msg_size);
@ -403,7 +405,7 @@ qat_queue_create(struct qat_pci_device *qat_dev, struct qat_queue *queue,
qp_conf->service_str, "qp_mem",
queue->hw_bundle_number, queue->hw_queue_number);
qp_mz = queue_dma_zone_reserve(queue->memz_name, queue_size_bytes,
qat_dev->pci_dev->device.numa_node);
pci_dev->device.numa_node);
if (qp_mz == NULL) {
QAT_LOG(ERR, "Failed to allocate ring memzone");
return -ENOMEM;
@ -627,9 +629,23 @@ qat_enqueue_op_burst(void *qp, void **ops, uint16_t nb_ops)
while (nb_ops_sent != nb_ops_possible) {
ret = tmp_qp->build_request(*ops, base_addr + tail,
if (tmp_qp->service_type == QAT_SERVICE_SYMMETRIC) {
#ifdef BUILD_QAT_SYM
ret = qat_sym_build_request(*ops, base_addr + tail,
tmp_qp->op_cookies[tail >> queue->trailz],
tmp_qp->qat_dev_gen);
#endif
} else if (tmp_qp->service_type == QAT_SERVICE_COMPRESSION) {
ret = qat_comp_build_request(*ops, base_addr + tail,
tmp_qp->op_cookies[tail >> queue->trailz],
tmp_qp->qat_dev_gen);
} else if (tmp_qp->service_type == QAT_SERVICE_ASYMMETRIC) {
#ifdef BUILD_QAT_ASYM
ret = qat_asym_build_request(*ops, base_addr + tail,
tmp_qp->op_cookies[tail >> queue->trailz],
tmp_qp->qat_dev_gen);
#endif
}
if (ret != 0) {
tmp_qp->stats.enqueue_err_count++;
/* This message cannot be enqueued */

20
drivers/compress/qat/qat_comp_pmd.c
View File

@ -655,6 +655,8 @@ qat_comp_dev_create(struct qat_pci_device *qat_pci_dev,
struct qat_dev_cmd_param *qat_dev_cmd_param)
{
int i = 0;
struct qat_device_info *qat_dev_instance =
&qat_pci_devs[qat_pci_dev->qat_dev_id];
if (qat_pci_dev->qat_dev_gen == QAT_GEN3) {
QAT_LOG(ERR, "Compression PMD not supported on QAT P5xxx");
return 0;
@ -662,7 +664,7 @@ qat_comp_dev_create(struct qat_pci_device *qat_pci_dev,
struct rte_compressdev_pmd_init_params init_params = {
.name = "",
.socket_id = qat_pci_dev->pci_dev->device.numa_node,
.socket_id = qat_dev_instance->pci_dev->device.numa_node,
};
char name[RTE_COMPRESSDEV_NAME_MAX_LEN];
struct rte_compressdev *compressdev;
@ -673,13 +675,13 @@ qat_comp_dev_create(struct qat_pci_device *qat_pci_dev,
QAT_LOG(DEBUG, "Creating QAT COMP device %s", name);
/* Populate subset device to use in compressdev device creation */
qat_pci_dev->comp_rte_dev.driver = &compdev_qat_driver;
qat_pci_dev->comp_rte_dev.numa_node =
qat_pci_dev->pci_dev->device.numa_node;
qat_pci_dev->comp_rte_dev.devargs = NULL;
qat_dev_instance->comp_rte_dev.driver = &compdev_qat_driver;
qat_dev_instance->comp_rte_dev.numa_node =
qat_dev_instance->pci_dev->device.numa_node;
qat_dev_instance->comp_rte_dev.devargs = NULL;
compressdev = rte_compressdev_pmd_create(name,
&(qat_pci_dev->comp_rte_dev),
&(qat_dev_instance->comp_rte_dev),
sizeof(struct qat_comp_dev_private),
&init_params);
@ -694,10 +696,12 @@ qat_comp_dev_create(struct qat_pci_device *qat_pci_dev,
compressdev->feature_flags = RTE_COMPDEV_FF_HW_ACCELERATED;
if (rte_eal_process_type() != RTE_PROC_PRIMARY)
return 0;
comp_dev = compressdev->data->dev_private;
comp_dev->qat_dev = qat_pci_dev;
comp_dev->compressdev = compressdev;
qat_pci_dev->comp_dev = comp_dev;
switch (qat_pci_dev->qat_dev_gen) {
case QAT_GEN1:
@ -706,7 +710,6 @@ qat_comp_dev_create(struct qat_pci_device *qat_pci_dev,
comp_dev->qat_dev_capabilities = qat_comp_gen_capabilities;
break;
default:
comp_dev->qat_dev_capabilities = qat_comp_gen_capabilities;
QAT_LOG(DEBUG,
"QAT gen %d capabilities unknown, default to GEN1",
qat_pci_dev->qat_dev_gen);
@ -721,6 +724,7 @@ qat_comp_dev_create(struct qat_pci_device *qat_pci_dev,
qat_dev_cmd_param[i].val;
i++;
}
qat_pci_dev->comp_dev = comp_dev;
QAT_LOG(DEBUG,
"Created QAT COMP device %s as compressdev instance %d",

26
drivers/crypto/qat/qat_asym_pmd.c
View File

@ -239,9 +239,12 @@ qat_asym_dev_create(struct qat_pci_device *qat_pci_dev,
struct qat_dev_cmd_param *qat_dev_cmd_param)
{
int i = 0;
struct qat_device_info *qat_dev_instance =
&qat_pci_devs[qat_pci_dev->qat_dev_id];
struct rte_cryptodev_pmd_init_params init_params = {
.name = "",
.socket_id = qat_pci_dev->pci_dev->device.numa_node,
.socket_id =
qat_dev_instance->pci_dev->device.numa_node,
.private_data_size = sizeof(struct qat_asym_dev_private)
};
char name[RTE_CRYPTODEV_NAME_MAX_LEN];
@ -253,18 +256,18 @@ qat_asym_dev_create(struct qat_pci_device *qat_pci_dev,
QAT_LOG(DEBUG, "Creating QAT ASYM device %s\n", name);
/* Populate subset device to use in cryptodev device creation */
qat_pci_dev->asym_rte_dev.driver = &cryptodev_qat_asym_driver;
qat_pci_dev->asym_rte_dev.numa_node =
qat_pci_dev->pci_dev->device.numa_node;
qat_pci_dev->asym_rte_dev.devargs = NULL;
qat_dev_instance->asym_rte_dev.driver = &cryptodev_qat_asym_driver;
qat_dev_instance->asym_rte_dev.numa_node =
qat_dev_instance->pci_dev->device.numa_node;
qat_dev_instance->asym_rte_dev.devargs = NULL;
cryptodev = rte_cryptodev_pmd_create(name,
&(qat_pci_dev->asym_rte_dev), &init_params);
&(qat_dev_instance->asym_rte_dev), &init_params);
if (cryptodev == NULL)
return -ENODEV;
qat_pci_dev->asym_rte_dev.name = cryptodev->data->name;
qat_dev_instance->asym_rte_dev.name = cryptodev->data->name;
cryptodev->driver_id = cryptodev_qat_asym_driver_id;
cryptodev->dev_ops = &crypto_qat_ops;
@ -276,10 +279,12 @@ qat_asym_dev_create(struct qat_pci_device *qat_pci_dev,
RTE_CRYPTODEV_FF_ASYM_SESSIONLESS |
RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_EXP |
RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_QT;
if (rte_eal_process_type() != RTE_PROC_PRIMARY)
return 0;
internals = cryptodev->data->dev_private;
internals->qat_dev = qat_pci_dev;
qat_pci_dev->asym_dev = internals;
internals->asym_dev_id = cryptodev->data->dev_id;
internals->qat_dev_capabilities = qat_gen1_asym_capabilities;
@ -292,6 +297,7 @@ qat_asym_dev_create(struct qat_pci_device *qat_pci_dev,
i++;
}
qat_pci_dev->asym_dev = internals;
QAT_LOG(DEBUG, "Created QAT ASYM device %s as cryptodev instance %d",
cryptodev->data->name, internals->asym_dev_id);
return 0;
@ -311,7 +317,7 @@ qat_asym_dev_destroy(struct qat_pci_device *qat_pci_dev)
cryptodev = rte_cryptodev_pmd_get_dev(
qat_pci_dev->asym_dev->asym_dev_id);
rte_cryptodev_pmd_destroy(cryptodev);
qat_pci_dev->asym_rte_dev.name = NULL;
qat_pci_devs[qat_pci_dev->qat_dev_id].asym_rte_dev.name = NULL;
qat_pci_dev->asym_dev = NULL;
return 0;

28
drivers/crypto/qat/qat_sym_pmd.c
View File

@ -304,14 +304,19 @@ qat_sym_dev_create(struct qat_pci_device *qat_pci_dev,
struct qat_dev_cmd_param *qat_dev_cmd_param __rte_unused)
{
int i = 0;
struct qat_device_info *qat_dev_instance =
&qat_pci_devs[qat_pci_dev->qat_dev_id];
struct rte_cryptodev_pmd_init_params init_params = {
.name = "",
.socket_id = qat_pci_dev->pci_dev->device.numa_node,
.socket_id =
qat_dev_instance->pci_dev->device.numa_node,
.private_data_size = sizeof(struct qat_sym_dev_private)
};
char name[RTE_CRYPTODEV_NAME_MAX_LEN];
struct rte_cryptodev *cryptodev;
struct qat_sym_dev_private *internals;
#ifdef RTE_LIBRTE_SECURITY
struct rte_security_ctx *security_instance;
#endif
@ -321,18 +326,18 @@ qat_sym_dev_create(struct qat_pci_device *qat_pci_dev,
QAT_LOG(DEBUG, "Creating QAT SYM device %s", name);
/* Populate subset device to use in cryptodev device creation */
qat_pci_dev->sym_rte_dev.driver = &cryptodev_qat_sym_driver;
qat_pci_dev->sym_rte_dev.numa_node =
qat_pci_dev->pci_dev->device.numa_node;
qat_pci_dev->sym_rte_dev.devargs = NULL;
qat_dev_instance->sym_rte_dev.driver = &cryptodev_qat_sym_driver;
qat_dev_instance->sym_rte_dev.numa_node =
qat_dev_instance->pci_dev->device.numa_node;
qat_dev_instance->sym_rte_dev.devargs = NULL;
cryptodev = rte_cryptodev_pmd_create(name,
&(qat_pci_dev->sym_rte_dev), &init_params);
&(qat_dev_instance->sym_rte_dev), &init_params);
if (cryptodev == NULL)
return -ENODEV;
qat_pci_dev->sym_rte_dev.name = cryptodev->data->name;
qat_dev_instance->sym_rte_dev.name = cryptodev->data->name;
cryptodev->driver_id = cryptodev_qat_driver_id;
cryptodev->dev_ops = &crypto_qat_ops;
@ -350,6 +355,9 @@ qat_sym_dev_create(struct qat_pci_device *qat_pci_dev,
RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED |
RTE_CRYPTODEV_FF_SECURITY;
if (rte_eal_process_type() != RTE_PROC_PRIMARY)
return 0;
#ifdef RTE_LIBRTE_SECURITY
security_instance = rte_malloc("qat_sec",
sizeof(struct rte_security_ctx),
@ -368,7 +376,6 @@ qat_sym_dev_create(struct qat_pci_device *qat_pci_dev,
internals = cryptodev->data->dev_private;
internals->qat_dev = qat_pci_dev;
qat_pci_dev->sym_dev = internals;
internals->sym_dev_id = cryptodev->data->dev_id;
switch (qat_pci_dev->qat_dev_gen) {
@ -380,7 +387,6 @@ qat_sym_dev_create(struct qat_pci_device *qat_pci_dev,
internals->qat_dev_capabilities = qat_gen2_sym_capabilities;
break;
default:
internals->qat_dev_capabilities = qat_gen2_sym_capabilities;
QAT_LOG(DEBUG,
"QAT gen %d capabilities unknown, default to GEN2",
qat_pci_dev->qat_dev_gen);
@ -396,8 +402,10 @@ qat_sym_dev_create(struct qat_pci_device *qat_pci_dev,
i++;
}
qat_pci_dev->sym_dev = internals;
QAT_LOG(DEBUG, "Created QAT SYM device %s as cryptodev instance %d",
cryptodev->data->name, internals->sym_dev_id);
return 0;
}
@ -417,7 +425,7 @@ qat_sym_dev_destroy(struct qat_pci_device *qat_pci_dev)
rte_free(cryptodev->security_ctx);
#endif
rte_cryptodev_pmd_destroy(cryptodev);
qat_pci_dev->sym_rte_dev.name = NULL;
qat_pci_devs[qat_pci_dev->qat_dev_id].sym_rte_dev.name = NULL;
qat_pci_dev->sym_dev = NULL;
return 0;