drivers/crypto/ccp/rte_ccp_pmd.c

   1 /*   SPDX-License-Identifier: BSD-3-Clause
   2  *   Copyright(c) 2018 Advanced Micro Devices, Inc. All rights reserved.
   3  */
   4
   5 #include <rte_bus_pci.h>
   6 #include <rte_bus_vdev.h>
   7 #include <rte_common.h>
   8 #include <rte_config.h>
   9 #include <rte_cryptodev.h>
  10 #include <rte_cryptodev_pmd.h>
  11 #include <rte_pci.h>
  12 #include <rte_dev.h>
  13 #include <rte_malloc.h>
  14
  15 #include "ccp_crypto.h"
  16 #include "ccp_dev.h"
  17 #include "ccp_pmd_private.h"
  18
  19 /**
  20  * Global static parameter used to find if CCP device is already initialized.
  21  */
  22 static unsigned int ccp_pmd_init_done;
  23 uint8_t ccp_cryptodev_driver_id;
  24
  25 static struct ccp_session *
  26 get_ccp_session(struct ccp_qp *qp __rte_unused, struct rte_crypto_op *op)
  27 {
  28         struct ccp_session *sess = NULL;
  29
  30         if (op->sess_type == RTE_CRYPTO_OP_WITH_SESSION) {
  31                 if (unlikely(op->sym->session == NULL))
  32                         return NULL;
  33
  34                 sess = (struct ccp_session *)
  35                         get_session_private_data(
  36                                 op->sym->session,
  37                                 ccp_cryptodev_driver_id);
  38         }
  39
  40         return sess;
  41 }
  42
  43 static uint16_t
  44 ccp_pmd_enqueue_burst(void *queue_pair, struct rte_crypto_op **ops,
  45                       uint16_t nb_ops)
  46 {
  47         struct ccp_session *sess = NULL;
  48         struct ccp_qp *qp = queue_pair;
  49         struct ccp_queue *cmd_q;
  50         struct rte_cryptodev *dev = qp->dev;
  51         uint16_t i, enq_cnt = 0, slots_req = 0;
  52
  53         if (nb_ops == 0)
  54                 return 0;
  55
  56         if (unlikely(rte_ring_full(qp->processed_pkts) != 0))
  57                 return 0;
  58
  59         for (i = 0; i < nb_ops; i++) {
  60                 sess = get_ccp_session(qp, ops[i]);
  61                 if (unlikely(sess == NULL) && (i == 0)) {
  62                         qp->qp_stats.enqueue_err_count++;
  63                         return 0;
  64                 } else if (sess == NULL) {
  65                         nb_ops = i;
  66                         break;
  67                 }
  68                 slots_req += ccp_compute_slot_count(sess);
  69         }
  70
  71         cmd_q = ccp_allot_queue(dev, slots_req);
  72         if (unlikely(cmd_q == NULL))
  73                 return 0;
  74
  75         enq_cnt = process_ops_to_enqueue(qp, ops, cmd_q, nb_ops, slots_req);
  76         qp->qp_stats.enqueued_count += enq_cnt;
  77         return enq_cnt;
  78 }
  79
  80 static uint16_t
  81 ccp_pmd_dequeue_burst(void *queue_pair, struct rte_crypto_op **ops,
  82                 uint16_t nb_ops)
  83 {
  84         struct ccp_qp *qp = queue_pair;
  85         uint16_t nb_dequeued = 0;
  86
  87         nb_dequeued = process_ops_to_dequeue(qp, ops, nb_ops);
  88
  89         qp->qp_stats.dequeued_count += nb_dequeued;
  90
  91         return nb_dequeued;
  92 }
  93
  94 /*
  95  * The set of PCI devices this driver supports
  96  */
  97 static struct rte_pci_id ccp_pci_id[] = {
  98         {
  99                 RTE_PCI_DEVICE(0x1022, 0x1456), /* AMD CCP-5a */
 100         },
 101         {
 102                 RTE_PCI_DEVICE(0x1022, 0x1468), /* AMD CCP-5b */
 103         },
 104         {.device_id = 0},
 105 };
 106
 107 /** Remove ccp pmd */
 108 static int
 109 cryptodev_ccp_remove(struct rte_vdev_device *dev)
 110 {
 111         const char *name;
 112
 113         ccp_pmd_init_done = 0;
 114         name = rte_vdev_device_name(dev);
 115         if (name == NULL)
 116                 return -EINVAL;
 117
 118         RTE_LOG(INFO, PMD, "Closing ccp device %s on numa socket %u\n",
 119                         name, rte_socket_id());
 120
 121         return 0;
 122 }
 123
 124 /** Create crypto device */
 125 static int
 126 cryptodev_ccp_create(const char *name,
 127                      struct rte_vdev_device *vdev,
 128                      struct rte_cryptodev_pmd_init_params *init_params)
 129 {
 130         struct rte_cryptodev *dev;
 131         struct ccp_private *internals;
 132         uint8_t cryptodev_cnt = 0;
 133
 134         if (init_params->name[0] == '\0')
 135                 snprintf(init_params->name, sizeof(init_params->name),
 136                                 "%s", name);
 137
 138         dev = rte_cryptodev_pmd_create(init_params->name,
 139                                        &vdev->device,
 140                                        init_params);
 141         if (dev == NULL) {
 142                 CCP_LOG_ERR("failed to create cryptodev vdev");
 143                 goto init_error;
 144         }
 145
 146         cryptodev_cnt = ccp_probe_devices(ccp_pci_id);
 147
 148         if (cryptodev_cnt == 0) {
 149                 CCP_LOG_ERR("failed to detect CCP crypto device");
 150                 goto init_error;
 151         }
 152
 153         printf("CCP : Crypto device count = %d\n", cryptodev_cnt);
 154         dev->driver_id = ccp_cryptodev_driver_id;
 155
 156         /* register rx/tx burst functions for data path */
 157         dev->dev_ops = ccp_pmd_ops;
 158         dev->enqueue_burst = ccp_pmd_enqueue_burst;
 159         dev->dequeue_burst = ccp_pmd_dequeue_burst;
 160
 161         dev->feature_flags = RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO |
 162                         RTE_CRYPTODEV_FF_HW_ACCELERATED |
 163                         RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING;
 164
 165         internals = dev->data->dev_private;
 166
 167         internals->max_nb_qpairs = init_params->max_nb_queue_pairs;
 168         internals->max_nb_sessions = init_params->max_nb_sessions;
 169         internals->crypto_num_dev = cryptodev_cnt;
 170
 171         return 0;
 172
 173 init_error:
 174         CCP_LOG_ERR("driver %s: %s() failed",
 175                     init_params->name, __func__);
 176         cryptodev_ccp_remove(vdev);
 177
 178         return -EFAULT;
 179 }
 180
 181 /** Probe ccp pmd */
 182 static int
 183 cryptodev_ccp_probe(struct rte_vdev_device *vdev)
 184 {
 185         int rc = 0;
 186         const char *name;
 187         struct rte_cryptodev_pmd_init_params init_params = {
 188                 "",
 189                 sizeof(struct ccp_private),
 190                 rte_socket_id(),
 191                 CCP_PMD_MAX_QUEUE_PAIRS,
 192                 RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS
 193         };
 194         const char *input_args;
 195
 196         if (ccp_pmd_init_done) {
 197                 RTE_LOG(INFO, PMD, "CCP PMD already initialized\n");
 198                 return -EFAULT;
 199         }
 200         name = rte_vdev_device_name(vdev);
 201         if (name == NULL)
 202                 return -EINVAL;
 203
 204         input_args = rte_vdev_device_args(vdev);
 205         rte_cryptodev_pmd_parse_input_args(&init_params, input_args);
 206         init_params.max_nb_queue_pairs = CCP_PMD_MAX_QUEUE_PAIRS;
 207
 208         RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n", name,
 209                         init_params.socket_id);
 210         RTE_LOG(INFO, PMD, "Max number of queue pairs = %d\n",
 211                         init_params.max_nb_queue_pairs);
 212         RTE_LOG(INFO, PMD, "Max number of sessions = %d\n",
 213                         init_params.max_nb_sessions);
 214
 215         rc = cryptodev_ccp_create(name, vdev, &init_params);
 216         if (rc)
 217                 return rc;
 218         ccp_pmd_init_done = 1;
 219         return 0;
 220 }
 221
 222 static struct rte_vdev_driver cryptodev_ccp_pmd_drv = {
 223         .probe = cryptodev_ccp_probe,
 224         .remove = cryptodev_ccp_remove
 225 };
 226
 227 static struct cryptodev_driver ccp_crypto_drv;
 228
 229 RTE_PMD_REGISTER_VDEV(CRYPTODEV_NAME_CCP_PMD, cryptodev_ccp_pmd_drv);
 230 RTE_PMD_REGISTER_PARAM_STRING(CRYPTODEV_NAME_CCP_PMD,
 231         "max_nb_queue_pairs=<int> max_nb_sessions=<int> socket_id=<int>");
 232 RTE_PMD_REGISTER_CRYPTO_DRIVER(ccp_crypto_drv, cryptodev_ccp_pmd_drv.driver,
 233                                ccp_cryptodev_driver_id);