drivers/crypto/qat/rte_qat_cryptodev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2018 Intel Corporation
   3  */
   4
   5 #include <rte_bus_pci.h>
   6 #include <rte_common.h>
   7 #include <rte_dev.h>
   8 #include <rte_malloc.h>
   9 #include <rte_pci.h>
  10 #include <rte_cryptodev_pmd.h>
  11
  12 #include "qat_sym.h"
  13 #include "qat_sym_session.h"
  14 #include "qat_logs.h"
  15
  16 uint8_t cryptodev_qat_driver_id;
  17
  18 static const struct rte_cryptodev_capabilities qat_gen1_sym_capabilities[] = {
  19         QAT_BASE_GEN1_SYM_CAPABILITIES,
  20         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
  21 };
  22
  23 static const struct rte_cryptodev_capabilities qat_gen2_sym_capabilities[] = {
  24         QAT_BASE_GEN1_SYM_CAPABILITIES,
  25         QAT_EXTRA_GEN2_SYM_CAPABILITIES,
  26         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
  27 };
  28
  29 static struct rte_cryptodev_ops crypto_qat_ops = {
  30
  31                 /* Device related operations */
  32                 .dev_configure          = qat_dev_config,
  33                 .dev_start              = qat_dev_start,
  34                 .dev_stop               = qat_dev_stop,
  35                 .dev_close              = qat_dev_close,
  36                 .dev_infos_get          = qat_dev_info_get,
  37
  38                 .stats_get              = qat_sym_stats_get,
  39                 .stats_reset            = qat_sym_stats_reset,
  40                 .queue_pair_setup       = qat_sym_qp_setup,
  41                 .queue_pair_release     = qat_sym_qp_release,
  42                 .queue_pair_start       = NULL,
  43                 .queue_pair_stop        = NULL,
  44                 .queue_pair_count       = NULL,
  45
  46                 /* Crypto related operations */
  47                 .session_get_size       = qat_sym_session_get_private_size,
  48                 .session_configure      = qat_sym_session_configure,
  49                 .session_clear          = qat_sym_session_clear
  50 };
  51
  52 /*
  53  * The set of PCI devices this driver supports
  54  */
  55
  56 static const struct rte_pci_id pci_id_qat_map[] = {
  57                 {
  58                         RTE_PCI_DEVICE(0x8086, 0x0443),
  59                 },
  60                 {
  61                         RTE_PCI_DEVICE(0x8086, 0x37c9),
  62                 },
  63                 {
  64                         RTE_PCI_DEVICE(0x8086, 0x19e3),
  65                 },
  66                 {
  67                         RTE_PCI_DEVICE(0x8086, 0x6f55),
  68                 },
  69                 {.device_id = 0},
  70 };
  71
  72
  73
  74 static int
  75 qat_sym_dev_create(struct qat_pci_device *qat_pci_dev)
  76 {
  77         struct rte_cryptodev_pmd_init_params init_params = {
  78                         .name = "",
  79                         .socket_id = qat_pci_dev->pci_dev->device.numa_node,
  80                         .private_data_size = sizeof(struct qat_pmd_private),
  81                         .max_nb_sessions = RTE_QAT_PMD_MAX_NB_SESSIONS
  82         };
  83         char name[RTE_CRYPTODEV_NAME_MAX_LEN];
  84         struct rte_cryptodev *cryptodev;
  85         struct qat_pmd_private *internals;
  86
  87         snprintf(name, RTE_CRYPTODEV_NAME_MAX_LEN, "%s_%s",
  88                         qat_pci_dev->name, "sym");
  89         PMD_DRV_LOG(DEBUG, "Creating QAT SYM device %s", name);
  90
  91         cryptodev = rte_cryptodev_pmd_create(name,
  92                         &qat_pci_dev->pci_dev->device, &init_params);
  93
  94         if (cryptodev == NULL)
  95                 return -ENODEV;
  96
  97         cryptodev->driver_id = cryptodev_qat_driver_id;
  98         cryptodev->dev_ops = &crypto_qat_ops;
  99
 100         cryptodev->enqueue_burst = qat_sym_pmd_enqueue_op_burst;
 101         cryptodev->dequeue_burst = qat_sym_pmd_dequeue_op_burst;
 102
 103         cryptodev->feature_flags = RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO |
 104                         RTE_CRYPTODEV_FF_HW_ACCELERATED |
 105                         RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING |
 106                         RTE_CRYPTODEV_FF_MBUF_SCATTER_GATHER;
 107
 108         internals = cryptodev->data->dev_private;
 109         internals->qat_dev = qat_pci_dev;
 110         qat_pci_dev->sym_dev = internals;
 111
 112         internals->max_nb_sessions = init_params.max_nb_sessions;
 113         internals->pci_dev = RTE_DEV_TO_PCI(cryptodev->device);
 114         internals->dev_id = cryptodev->data->dev_id;
 115         switch (internals->pci_dev->id.device_id) {
 116         case 0x0443:
 117                 internals->qat_dev_gen = QAT_GEN1;
 118                 internals->qat_dev_capabilities = qat_gen1_sym_capabilities;
 119                 break;
 120         case 0x37c9:
 121         case 0x19e3:
 122         case 0x6f55:
 123                 internals->qat_dev_gen = QAT_GEN2;
 124                 internals->qat_dev_capabilities = qat_gen2_sym_capabilities;
 125                 break;
 126         default:
 127                 PMD_DRV_LOG(ERR,
 128                                 "Invalid dev_id, can't determine capabilities");
 129                 break;
 130         }
 131
 132                 return 0;
 133 }
 134
 135 static int
 136 qat_sym_dev_destroy(struct qat_pci_device *qat_pci_dev)
 137 {
 138         struct rte_cryptodev *cryptodev;
 139
 140         if (qat_pci_dev == NULL)
 141                 return -ENODEV;
 142         if (qat_pci_dev->sym_dev == NULL)
 143                 return 0;
 144
 145         /* free crypto device */
 146         cryptodev = rte_cryptodev_pmd_get_dev(qat_pci_dev->sym_dev->dev_id);
 147         rte_cryptodev_pmd_destroy(cryptodev);
 148         qat_pci_dev->sym_dev = NULL;
 149
 150         return 0;
 151 }
 152
 153 static int
 154 qat_comp_dev_create(struct qat_pci_device *qat_pci_dev __rte_unused)
 155 {
 156         return 0;
 157 }
 158
 159 static int
 160 qat_comp_dev_destroy(struct qat_pci_device *qat_pci_dev __rte_unused)
 161 {
 162         return 0;
 163 }
 164
 165 static int
 166 qat_asym_dev_create(struct qat_pci_device *qat_pci_dev __rte_unused)
 167 {
 168         return 0;
 169 }
 170
 171 static int
 172 qat_asym_dev_destroy(struct qat_pci_device *qat_pci_dev __rte_unused)
 173 {
 174         return 0;
 175 }
 176
 177 static int
 178 qat_pci_dev_destroy(struct qat_pci_device *qat_pci_dev,
 179                 struct rte_pci_device *pci_dev)
 180 {
 181         qat_sym_dev_destroy(qat_pci_dev);
 182         qat_comp_dev_destroy(qat_pci_dev);
 183         qat_asym_dev_destroy(qat_pci_dev);
 184         return qat_pci_device_release(pci_dev);
 185 }
 186
 187 static int qat_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
 188                 struct rte_pci_device *pci_dev)
 189 {
 190         int ret = 0;
 191         struct qat_pci_device *qat_pci_dev;
 192
 193         PMD_DRV_LOG(DEBUG, "Found QAT device at %02x:%02x.%x",
 194                         pci_dev->addr.bus,
 195                         pci_dev->addr.devid,
 196                         pci_dev->addr.function);
 197
 198         qat_pci_dev = qat_pci_device_allocate(pci_dev);
 199         if (qat_pci_dev == NULL)
 200                 return -ENODEV;
 201
 202         ret = qat_sym_dev_create(qat_pci_dev);
 203         if (ret != 0)
 204                 goto error_out;
 205
 206         ret = qat_comp_dev_create(qat_pci_dev);
 207         if (ret != 0)
 208                 goto error_out;
 209
 210         ret = qat_asym_dev_create(qat_pci_dev);
 211         if (ret != 0)
 212                 goto error_out;
 213
 214         return 0;
 215
 216 error_out:
 217         qat_pci_dev_destroy(qat_pci_dev, pci_dev);
 218         return ret;
 219
 220 }
 221
 222 static int qat_pci_remove(struct rte_pci_device *pci_dev)
 223 {
 224         struct qat_pci_device *qat_pci_dev;
 225
 226         if (pci_dev == NULL)
 227                 return -EINVAL;
 228
 229         qat_pci_dev = qat_get_qat_dev_from_pci_dev(pci_dev);
 230         if (qat_pci_dev == NULL)
 231                 return 0;
 232
 233         return qat_pci_dev_destroy(qat_pci_dev, pci_dev);
 234
 235 }
 236
 237
 238 /* An rte_driver is needed in the registration of both the device and the driver
 239  * with cryptodev.
 240  * The actual qat pci's rte_driver can't be used as its name represents
 241  * the whole pci device with all services. Think of this as a holder for a name
 242  * for the crypto part of the pci device.
 243  */
 244 static const char qat_sym_drv_name[] = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
 245 static struct rte_driver cryptodev_qat_sym_driver = {
 246         .name = qat_sym_drv_name,
 247         .alias = qat_sym_drv_name
 248 };
 249 static struct cryptodev_driver qat_crypto_drv;
 250 RTE_PMD_REGISTER_CRYPTO_DRIVER(qat_crypto_drv, cryptodev_qat_sym_driver,
 251                 cryptodev_qat_driver_id);
 252
 253 static struct rte_pci_driver rte_qat_pmd = {
 254         .id_table = pci_id_qat_map,
 255         .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
 256         .probe = qat_pci_probe,
 257         .remove = qat_pci_remove
 258 };
 259 RTE_PMD_REGISTER_PCI(QAT_PCI_NAME, rte_qat_pmd);
 260 RTE_PMD_REGISTER_PCI_TABLE(QAT_PCI_NAME, pci_id_qat_map);