static int
otx_cpt_pci_remove(struct rte_pci_device *pci_dev)
{
struct rte_cryptodev *cryptodev;
char name[RTE_CRYPTODEV_NAME_MAX_LEN];
if (pci_dev == NULL)
return -EINVAL;
rte_pci_device_name(&pci_dev->addr, name, sizeof(name));
cryptodev = rte_cryptodev_pmd_get_named_dev(name);
if (cryptodev == NULL)
return -ENODEV;
if (pci_dev->driver == NULL)
return -ENODEV;
/* free crypto device */
rte_cryptodev_pmd_release_device(cryptodev);
if (rte_eal_process_type() == RTE_PROC_PRIMARY)
rte_free(cryptodev->data->dev_private);
cryptodev->device->driver = NULL;
cryptodev->device = NULL;
cryptodev->data = NULL;
/* free metapool memory */
cleanup_global_resources();
return 0;
}
static int
cryptodev_scheduler_create(const char *name,
struct rte_vdev_device *vdev,
struct scheduler_init_params *init_params)
{
struct rte_cryptodev *dev;
struct scheduler_ctx *sched_ctx;
uint32_t i;
int ret;
dev = rte_cryptodev_pmd_create(name, &vdev->device,
&init_params->def_p);
if (dev == NULL) {
CR_SCHED_LOG(ERR, "driver %s: failed to create cryptodev vdev",
name);
return -EFAULT;
}
dev->driver_id = cryptodev_driver_id;
dev->dev_ops = rte_crypto_scheduler_pmd_ops;
sched_ctx = dev->data->dev_private;
sched_ctx->max_nb_queue_pairs =
init_params->def_p.max_nb_queue_pairs;
if (init_params->mode == CDEV_SCHED_MODE_MULTICORE) {
uint16_t i;
sched_ctx->nb_wc = init_params->nb_wc;
for (i = 0; i < sched_ctx->nb_wc; i++) {
sched_ctx->wc_pool[i] = init_params->wc_pool[i];
CR_SCHED_LOG(INFO, " Worker core[%u]=%u added",
i, sched_ctx->wc_pool[i]);
}
}
if (init_params->mode > CDEV_SCHED_MODE_USERDEFINED &&
init_params->mode < CDEV_SCHED_MODE_COUNT) {
ret = rte_cryptodev_scheduler_mode_set(dev->data->dev_id,
init_params->mode);
if (ret < 0) {
rte_cryptodev_pmd_release_device(dev);
return ret;
}
for (i = 0; i < RTE_DIM(scheduler_mode_map); i++) {
if (scheduler_mode_map[i].val != sched_ctx->mode)
continue;
CR_SCHED_LOG(INFO, " Scheduling mode = %s",
scheduler_mode_map[i].name);
break;
}
}
sched_ctx->reordering_enabled = init_params->enable_ordering;
for (i = 0; i < RTE_DIM(scheduler_ordering_map); i++) {
if (scheduler_ordering_map[i].val !=
sched_ctx->reordering_enabled)
continue;
CR_SCHED_LOG(INFO, " Packet ordering = %s",
scheduler_ordering_map[i].name);
break;
}
for (i = 0; i < init_params->nb_slaves; i++) {
sched_ctx->init_slave_names[sched_ctx->nb_init_slaves] =
rte_zmalloc_socket(
NULL,
RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN, 0,
SOCKET_ID_ANY);
if (!sched_ctx->init_slave_names[
sched_ctx->nb_init_slaves]) {
CR_SCHED_LOG(ERR, "driver %s: Insufficient memory",
name);
return -ENOMEM;
}
strncpy(sched_ctx->init_slave_names[
sched_ctx->nb_init_slaves],
init_params->slave_names[i],
RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN - 1);
sched_ctx->nb_init_slaves++;
}
/*
* Initialize capabilities structure as an empty structure,
* in case device information is requested when no slaves are attached
*/
sched_ctx->capabilities = rte_zmalloc_socket(NULL,
sizeof(struct rte_cryptodev_capabilities),
0, SOCKET_ID_ANY);
if (!sched_ctx->capabilities) {
CR_SCHED_LOG(ERR, "Not enough memory for capability "
"information");
return -ENOMEM;
}
return 0;
}
static int
cryptodev_scheduler_create(const char *name,
struct scheduler_init_params *init_params)
{
struct rte_cryptodev *dev;
struct scheduler_ctx *sched_ctx;
uint32_t i;
int ret;
if (init_params->def_p.name[0] == '\0')
snprintf(init_params->def_p.name,
sizeof(init_params->def_p.name),
"%s", name);
dev = rte_cryptodev_pmd_virtual_dev_init(init_params->def_p.name,
sizeof(struct scheduler_ctx),
init_params->def_p.socket_id);
if (dev == NULL) {
CS_LOG_ERR("driver %s: failed to create cryptodev vdev",
name);
return -EFAULT;
}
dev->dev_type = RTE_CRYPTODEV_SCHEDULER_PMD;
dev->dev_ops = rte_crypto_scheduler_pmd_ops;
sched_ctx = dev->data->dev_private;
sched_ctx->max_nb_queue_pairs =
init_params->def_p.max_nb_queue_pairs;
if (init_params->mode > CDEV_SCHED_MODE_USERDEFINED &&
init_params->mode < CDEV_SCHED_MODE_COUNT) {
ret = rte_cryptodev_scheduler_mode_set(dev->data->dev_id,
init_params->mode);
if (ret < 0) {
rte_cryptodev_pmd_release_device(dev);
return ret;
}
for (i = 0; i < RTE_DIM(scheduler_mode_map); i++) {
if (scheduler_mode_map[i].val != sched_ctx->mode)
continue;
RTE_LOG(INFO, PMD, " Scheduling mode = %s\n",
scheduler_mode_map[i].name);
break;
}
}
sched_ctx->reordering_enabled = init_params->enable_ordering;
for (i = 0; i < RTE_DIM(scheduler_ordering_map); i++) {
if (scheduler_ordering_map[i].val !=
sched_ctx->reordering_enabled)
continue;
RTE_LOG(INFO, PMD, " Packet ordering = %s\n",
scheduler_ordering_map[i].name);
break;
}
for (i = 0; i < init_params->nb_slaves; i++) {
sched_ctx->init_slave_names[sched_ctx->nb_init_slaves] =
rte_zmalloc_socket(
NULL,
RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN, 0,
SOCKET_ID_ANY);
if (!sched_ctx->init_slave_names[
sched_ctx->nb_init_slaves]) {
CS_LOG_ERR("driver %s: Insufficient memory",
name);
return -ENOMEM;
}
strncpy(sched_ctx->init_slave_names[
sched_ctx->nb_init_slaves],
init_params->slave_names[i],
RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN - 1);
sched_ctx->nb_init_slaves++;
}
/*
* Initialize capabilities structure as an empty structure,
* in case device information is requested when no slaves are attached
*/
sched_ctx->capabilities = rte_zmalloc_socket(NULL,
sizeof(struct rte_cryptodev_capabilities),
0, SOCKET_ID_ANY);
if (!sched_ctx->capabilities) {
RTE_LOG(ERR, PMD, "Not enough memory for capability "
"information\n");
return -ENOMEM;
}
return 0;
}
