qat_device.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 #include "qat_device.h"
   6 #include "adf_transport_access_macros.h"
   7 #include "qat_qp.h"
   8
   9 /* Hardware device information per generation */
  10 __extension__
  11 struct qat_gen_hw_data qp_gen_config[] =  {
  12         [QAT_GEN1] = {
  13                 .dev_gen = QAT_GEN1,
  14                 .qp_hw_data = qat_gen1_qps,
  15         },
  16         [QAT_GEN2] = {
  17                 .dev_gen = QAT_GEN2,
  18                 .qp_hw_data = qat_gen1_qps,
  19                 /* gen2 has same ring layout as gen1 */
  20         },
  21 };
  22
  23
  24 static struct qat_pci_device qat_pci_devices[QAT_MAX_PCI_DEVICES];
  25 static int qat_nb_pci_devices;
  26
  27 int qat_dev_config(__rte_unused struct rte_cryptodev *dev,
  28                 __rte_unused struct rte_cryptodev_config *config)
  29 {
  30         PMD_INIT_FUNC_TRACE();
  31         return 0;
  32 }
  33
  34 int qat_dev_start(__rte_unused struct rte_cryptodev *dev)
  35 {
  36         PMD_INIT_FUNC_TRACE();
  37         return 0;
  38 }
  39
  40 void qat_dev_stop(__rte_unused struct rte_cryptodev *dev)
  41 {
  42         PMD_INIT_FUNC_TRACE();
  43 }
  44
  45 int qat_dev_close(struct rte_cryptodev *dev)
  46 {
  47         int i, ret;
  48
  49         PMD_INIT_FUNC_TRACE();
  50
  51         for (i = 0; i < dev->data->nb_queue_pairs; i++) {
  52                 ret = qat_sym_qp_release(dev, i);
  53                 if (ret < 0)
  54                         return ret;
  55         }
  56
  57         return 0;
  58 }
  59
  60 void qat_dev_info_get(struct rte_cryptodev *dev,
  61                         struct rte_cryptodev_info *info)
  62 {
  63         struct qat_pmd_private *internals = dev->data->dev_private;
  64         const struct qat_qp_hw_data *sym_hw_qps =
  65                 qp_gen_config[internals->qat_dev_gen]
  66                               .qp_hw_data[QAT_SERVICE_SYMMETRIC];
  67
  68         PMD_INIT_FUNC_TRACE();
  69         if (info != NULL) {
  70                 info->max_nb_queue_pairs =
  71                         qat_qps_per_service(sym_hw_qps, QAT_SERVICE_SYMMETRIC);
  72                 info->feature_flags = dev->feature_flags;
  73                 info->capabilities = internals->qat_dev_capabilities;
  74                 info->sym.max_nb_sessions = internals->max_nb_sessions;
  75                 info->driver_id = cryptodev_qat_driver_id;
  76                 info->pci_dev = RTE_DEV_TO_PCI(dev->device);
  77         }
  78 }
  79
  80
  81 static struct qat_pci_device *
  82 qat_pci_get_dev(uint8_t dev_id)
  83 {
  84         return &qat_pci_devices[dev_id];
  85 }
  86 static struct qat_pci_device *
  87 qat_pci_get_named_dev(const char *name)
  88 {
  89         struct qat_pci_device *dev;
  90         unsigned int i;
  91
  92         if (name == NULL)
  93                 return NULL;
  94
  95         for (i = 0; i < QAT_MAX_PCI_DEVICES; i++) {
  96                 dev = &qat_pci_devices[i];
  97
  98                 if ((dev->attached == QAT_ATTACHED) &&
  99                                 (strcmp(dev->name, name) == 0))
 100                         return dev;
 101         }
 102
 103         return NULL;
 104 }
 105
 106 static uint8_t
 107 qat_pci_find_free_device_index(void)
 108 {
 109         uint8_t dev_id;
 110
 111         for (dev_id = 0; dev_id < QAT_MAX_PCI_DEVICES; dev_id++) {
 112                 if (qat_pci_devices[dev_id].attached == QAT_DETACHED)
 113                         break;
 114         }
 115         return dev_id;
 116 }
 117
 118 struct qat_pci_device *
 119 qat_get_qat_dev_from_pci_dev(struct rte_pci_device *pci_dev)
 120 {
 121         char name[QAT_DEV_NAME_MAX_LEN];
 122
 123         rte_pci_device_name(&pci_dev->addr, name, sizeof(name));
 124
 125         return qat_pci_get_named_dev(name);
 126 }
 127
 128 struct qat_pci_device *
 129 qat_pci_device_allocate(struct rte_pci_device *pci_dev)
 130 {
 131         struct qat_pci_device *qat_dev;
 132         uint8_t qat_dev_id;
 133         char name[QAT_DEV_NAME_MAX_LEN];
 134
 135         rte_pci_device_name(&pci_dev->addr, name, sizeof(name));
 136
 137         if (qat_pci_get_named_dev(name) != NULL) {
 138                 PMD_DRV_LOG(ERR, "QAT device with name %s already allocated!",
 139                                 name);
 140                 return NULL;
 141         }
 142
 143         qat_dev_id = qat_pci_find_free_device_index();
 144         if (qat_dev_id == QAT_MAX_PCI_DEVICES) {
 145                 PMD_DRV_LOG(ERR, "Reached maximum number of QAT devices");
 146                 return NULL;
 147         }
 148
 149         qat_dev = qat_pci_get_dev(qat_dev_id);
 150         snprintf(qat_dev->name, QAT_DEV_NAME_MAX_LEN, "%s", name);
 151         qat_dev->pci_dev = pci_dev;
 152         switch (qat_dev->pci_dev->id.device_id) {
 153         case 0x0443:
 154                 qat_dev->qat_dev_gen = QAT_GEN1;
 155                 break;
 156         case 0x37c9:
 157         case 0x19e3:
 158         case 0x6f55:
 159                 qat_dev->qat_dev_gen = QAT_GEN2;
 160                 break;
 161         default:
 162                 PMD_DRV_LOG(ERR, "Invalid dev_id, can't determine generation");
 163                 return NULL;
 164         }
 165
 166         rte_spinlock_init(&qat_dev->arb_csr_lock);
 167
 168         qat_dev->attached = QAT_ATTACHED;
 169
 170         qat_nb_pci_devices++;
 171
 172         PMD_DRV_LOG(DEBUG, "QAT device %d allocated, total QATs %d",
 173                                 qat_dev_id, qat_nb_pci_devices);
 174
 175         return qat_dev;
 176 }
 177
 178 int
 179 qat_pci_device_release(struct rte_pci_device *pci_dev)
 180 {
 181         struct qat_pci_device *qat_dev;
 182         char name[QAT_DEV_NAME_MAX_LEN];
 183
 184         if (pci_dev == NULL)
 185                 return -EINVAL;
 186
 187         rte_pci_device_name(&pci_dev->addr, name, sizeof(name));
 188         qat_dev = qat_pci_get_named_dev(name);
 189         if (qat_dev != NULL) {
 190
 191                 /* Check that there are no service devs still on pci device */
 192                 if (qat_dev->sym_dev != NULL)
 193                         return -EBUSY;
 194
 195                 qat_dev->attached = QAT_DETACHED;
 196                 qat_nb_pci_devices--;
 197         }
 198         PMD_DRV_LOG(DEBUG, "QAT device %s released, total QATs %d",
 199                                 name, qat_nb_pci_devices);
 200         return 0;
 201 }