drivers/crypto/qat/qat_asym_pmd.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019 Intel Corporation
   3  */
   4
   5 #include <rte_cryptodev_pmd.h>
   6
   7 #include "qat_logs.h"
   8
   9 #include "qat_asym.h"
  10 #include "qat_asym_pmd.h"
  11 #include "qat_sym_capabilities.h"
  12 #include "qat_asym_capabilities.h"
  13
  14 uint8_t cryptodev_qat_asym_driver_id;
  15
  16 static const struct rte_cryptodev_capabilities qat_gen1_asym_capabilities[] = {
  17         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
  18 };
  19
  20 static int qat_asym_qp_release(struct rte_cryptodev *dev,
  21                                uint16_t queue_pair_id);
  22
  23 static int qat_asym_dev_config(__rte_unused struct rte_cryptodev *dev,
  24                                __rte_unused struct rte_cryptodev_config *config)
  25 {
  26         return 0;
  27 }
  28
  29 static int qat_asym_dev_start(__rte_unused struct rte_cryptodev *dev)
  30 {
  31         return 0;
  32 }
  33
  34 static void qat_asym_dev_stop(__rte_unused struct rte_cryptodev *dev)
  35 {
  36
  37 }
  38
  39 static int qat_asym_dev_close(struct rte_cryptodev *dev)
  40 {
  41         int i, ret;
  42
  43         for (i = 0; i < dev->data->nb_queue_pairs; i++) {
  44                 ret = qat_asym_qp_release(dev, i);
  45                 if (ret < 0)
  46                         return ret;
  47         }
  48
  49         return 0;
  50 }
  51
  52 static void qat_asym_dev_info_get(struct rte_cryptodev *dev,
  53                                   struct rte_cryptodev_info *info)
  54 {
  55         struct qat_asym_dev_private *internals = dev->data->dev_private;
  56         const struct qat_qp_hw_data *asym_hw_qps =
  57                 qat_gen_config[internals->qat_dev->qat_dev_gen]
  58                               .qp_hw_data[QAT_SERVICE_ASYMMETRIC];
  59
  60         if (info != NULL) {
  61                 info->max_nb_queue_pairs = qat_qps_per_service(asym_hw_qps,
  62                                                         QAT_SERVICE_ASYMMETRIC);
  63                 info->feature_flags = dev->feature_flags;
  64                 info->capabilities = internals->qat_dev_capabilities;
  65                 info->driver_id = cryptodev_qat_asym_driver_id;
  66                 /* No limit of number of sessions */
  67                 info->sym.max_nb_sessions = 0;
  68         }
  69 }
  70
  71 static void qat_asym_stats_get(struct rte_cryptodev *dev,
  72                                struct rte_cryptodev_stats *stats)
  73 {
  74         struct qat_common_stats qat_stats = {0};
  75         struct qat_asym_dev_private *qat_priv;
  76
  77         if (stats == NULL || dev == NULL) {
  78                 QAT_LOG(ERR, "invalid ptr: stats %p, dev %p", stats, dev);
  79                 return;
  80         }
  81         qat_priv = dev->data->dev_private;
  82
  83         qat_stats_get(qat_priv->qat_dev, &qat_stats, QAT_SERVICE_ASYMMETRIC);
  84         stats->enqueued_count = qat_stats.enqueued_count;
  85         stats->dequeued_count = qat_stats.dequeued_count;
  86         stats->enqueue_err_count = qat_stats.enqueue_err_count;
  87         stats->dequeue_err_count = qat_stats.dequeue_err_count;
  88 }
  89
  90 static void qat_asym_stats_reset(struct rte_cryptodev *dev)
  91 {
  92         struct qat_asym_dev_private *qat_priv;
  93
  94         if (dev == NULL) {
  95                 QAT_LOG(ERR, "invalid asymmetric cryptodev ptr %p", dev);
  96                 return;
  97         }
  98         qat_priv = dev->data->dev_private;
  99
 100         qat_stats_reset(qat_priv->qat_dev, QAT_SERVICE_ASYMMETRIC);
 101 }
 102
 103 static int qat_asym_qp_release(struct rte_cryptodev *dev,
 104                                uint16_t queue_pair_id)
 105 {
 106         struct qat_asym_dev_private *qat_private = dev->data->dev_private;
 107
 108         QAT_LOG(DEBUG, "Release asym qp %u on device %d",
 109                                 queue_pair_id, dev->data->dev_id);
 110
 111         qat_private->qat_dev->qps_in_use[QAT_SERVICE_ASYMMETRIC][queue_pair_id]
 112                                                 = NULL;
 113
 114         return qat_qp_release((struct qat_qp **)
 115                         &(dev->data->queue_pairs[queue_pair_id]));
 116 }
 117
 118 static int qat_asym_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id,
 119                              const struct rte_cryptodev_qp_conf *qp_conf,
 120                              int socket_id)
 121 {
 122         struct qat_qp_config qat_qp_conf;
 123         struct qat_qp *qp;
 124         int ret = 0;
 125         uint32_t i;
 126
 127         struct qat_qp **qp_addr =
 128                         (struct qat_qp **)&(dev->data->queue_pairs[qp_id]);
 129         struct qat_asym_dev_private *qat_private = dev->data->dev_private;
 130         const struct qat_qp_hw_data *asym_hw_qps =
 131                         qat_gen_config[qat_private->qat_dev->qat_dev_gen]
 132                                       .qp_hw_data[QAT_SERVICE_ASYMMETRIC];
 133         const struct qat_qp_hw_data *qp_hw_data = asym_hw_qps + qp_id;
 134
 135         /* If qp is already in use free ring memory and qp metadata. */
 136         if (*qp_addr != NULL) {
 137                 ret = qat_asym_qp_release(dev, qp_id);
 138                 if (ret < 0)
 139                         return ret;
 140         }
 141         if (qp_id >= qat_qps_per_service(asym_hw_qps, QAT_SERVICE_ASYMMETRIC)) {
 142                 QAT_LOG(ERR, "qp_id %u invalid for this device", qp_id);
 143                 return -EINVAL;
 144         }
 145
 146         qat_qp_conf.hw = qp_hw_data;
 147         qat_qp_conf.build_request = qat_asym_build_request;
 148         qat_qp_conf.cookie_size = sizeof(struct qat_asym_op_cookie);
 149         qat_qp_conf.nb_descriptors = qp_conf->nb_descriptors;
 150         qat_qp_conf.socket_id = socket_id;
 151         qat_qp_conf.service_str = "asym";
 152
 153         ret = qat_qp_setup(qat_private->qat_dev, qp_addr, qp_id, &qat_qp_conf);
 154         if (ret != 0)
 155                 return ret;
 156
 157         /* store a link to the qp in the qat_pci_device */
 158         qat_private->qat_dev->qps_in_use[QAT_SERVICE_ASYMMETRIC][qp_id]
 159                                                         = *qp_addr;
 160
 161         qp = (struct qat_qp *)*qp_addr;
 162
 163         for (i = 0; i < qp->nb_descriptors; i++) {
 164                 int j;
 165
 166                 struct qat_asym_op_cookie __rte_unused *cookie =
 167                                 qp->op_cookies[i];
 168                 cookie->input_addr = rte_mempool_virt2iova(cookie) +
 169                                 offsetof(struct qat_asym_op_cookie,
 170                                                 input_params_ptrs);
 171
 172                 cookie->output_addr = rte_mempool_virt2iova(cookie) +
 173                                 offsetof(struct qat_asym_op_cookie,
 174                                                 output_params_ptrs);
 175
 176                 for (j = 0; j < 8; j++) {
 177                         cookie->input_params_ptrs[j] =
 178                                         rte_mempool_virt2iova(cookie) +
 179                                         offsetof(struct qat_asym_op_cookie,
 180                                                         input_array[j]);
 181                         cookie->output_params_ptrs[j] =
 182                                         rte_mempool_virt2iova(cookie) +
 183                                         offsetof(struct qat_asym_op_cookie,
 184                                                         output_array[j]);
 185                 }
 186         }
 187
 188         return ret;
 189 }
 190
 191 struct rte_cryptodev_ops crypto_qat_ops = {
 192
 193         /* Device related operations */
 194         .dev_configure          = qat_asym_dev_config,
 195         .dev_start              = qat_asym_dev_start,
 196         .dev_stop               = qat_asym_dev_stop,
 197         .dev_close              = qat_asym_dev_close,
 198         .dev_infos_get          = qat_asym_dev_info_get,
 199
 200         .stats_get              = qat_asym_stats_get,
 201         .stats_reset            = qat_asym_stats_reset,
 202         .queue_pair_setup       = qat_asym_qp_setup,
 203         .queue_pair_release     = qat_asym_qp_release,
 204         .queue_pair_count       = NULL,
 205
 206         /* Crypto related operations */
 207         .asym_session_get_size  = qat_asym_session_get_private_size,
 208         .asym_session_configure = qat_asym_session_configure,
 209         .asym_session_clear     = qat_asym_session_clear
 210 };
 211
 212 uint16_t qat_asym_pmd_enqueue_op_burst(void *qp, struct rte_crypto_op **ops,
 213                                        uint16_t nb_ops)
 214 {
 215         return qat_enqueue_op_burst(qp, (void **)ops, nb_ops);
 216 }
 217
 218 uint16_t qat_asym_pmd_dequeue_op_burst(void *qp, struct rte_crypto_op **ops,
 219                                        uint16_t nb_ops)
 220 {
 221         return qat_dequeue_op_burst(qp, (void **)ops, nb_ops);
 222 }
 223
 224 /* An rte_driver is needed in the registration of both the device and the driver
 225  * with cryptodev.
 226  * The actual qat pci's rte_driver can't be used as its name represents
 227  * the whole pci device with all services. Think of this as a holder for a name
 228  * for the crypto part of the pci device.
 229  */
 230 static const char qat_asym_drv_name[] = RTE_STR(CRYPTODEV_NAME_QAT_ASYM_PMD);
 231 static const struct rte_driver cryptodev_qat_asym_driver = {
 232         .name = qat_asym_drv_name,
 233         .alias = qat_asym_drv_name
 234 };
 235
 236 int
 237 qat_asym_dev_create(struct qat_pci_device *qat_pci_dev)
 238 {
 239         struct rte_cryptodev_pmd_init_params init_params = {
 240                         .name = "",
 241                         .socket_id = qat_pci_dev->pci_dev->device.numa_node,
 242                         .private_data_size = sizeof(struct qat_asym_dev_private)
 243         };
 244         char name[RTE_CRYPTODEV_NAME_MAX_LEN];
 245         struct rte_cryptodev *cryptodev;
 246         struct qat_asym_dev_private *internals;
 247
 248         snprintf(name, RTE_CRYPTODEV_NAME_MAX_LEN, "%s_%s",
 249                         qat_pci_dev->name, "asym");
 250         QAT_LOG(DEBUG, "Creating QAT ASYM device %s\n", name);
 251
 252         /* Populate subset device to use in cryptodev device creation */
 253         qat_pci_dev->asym_rte_dev.driver = &cryptodev_qat_asym_driver;
 254         qat_pci_dev->asym_rte_dev.numa_node =
 255                                 qat_pci_dev->pci_dev->device.numa_node;
 256         qat_pci_dev->asym_rte_dev.devargs = NULL;
 257
 258         cryptodev = rte_cryptodev_pmd_create(name,
 259                         &(qat_pci_dev->asym_rte_dev), &init_params);
 260
 261         if (cryptodev == NULL)
 262                 return -ENODEV;
 263
 264         qat_pci_dev->asym_rte_dev.name = cryptodev->data->name;
 265         cryptodev->driver_id = cryptodev_qat_asym_driver_id;
 266         cryptodev->dev_ops = &crypto_qat_ops;
 267
 268         cryptodev->enqueue_burst = qat_asym_pmd_enqueue_op_burst;
 269         cryptodev->dequeue_burst = qat_asym_pmd_dequeue_op_burst;
 270
 271         cryptodev->feature_flags = RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO |
 272                         RTE_CRYPTODEV_FF_HW_ACCELERATED;
 273         internals = cryptodev->data->dev_private;
 274         internals->qat_dev = qat_pci_dev;
 275         qat_pci_dev->asym_dev = internals;
 276
 277         internals->asym_dev_id = cryptodev->data->dev_id;
 278         internals->qat_dev_capabilities = qat_gen1_asym_capabilities;
 279
 280         QAT_LOG(DEBUG, "Created QAT ASYM device %s as cryptodev instance %d",
 281                         cryptodev->data->name, internals->asym_dev_id);
 282         return 0;
 283 }
 284
 285 int
 286 qat_asym_dev_destroy(struct qat_pci_device *qat_pci_dev)
 287 {
 288         struct rte_cryptodev *cryptodev;
 289
 290         if (qat_pci_dev == NULL)
 291                 return -ENODEV;
 292         if (qat_pci_dev->asym_dev == NULL)
 293                 return 0;
 294
 295         /* free crypto device */
 296         cryptodev = rte_cryptodev_pmd_get_dev(
 297                         qat_pci_dev->asym_dev->asym_dev_id);
 298         rte_cryptodev_pmd_destroy(cryptodev);
 299         qat_pci_dev->asym_rte_dev.name = NULL;
 300         qat_pci_dev->asym_dev = NULL;
 301
 302         return 0;
 303 }
 304
 305 static struct cryptodev_driver qat_crypto_drv;
 306 RTE_PMD_REGISTER_CRYPTO_DRIVER(qat_crypto_drv,
 307                 cryptodev_qat_asym_driver,
 308                 cryptodev_qat_asym_driver_id);