drivers/crypto/ccp/ccp_pmd_ops.c

   1 /*   SPDX-License-Identifier: BSD-3-Clause
   2  *   Copyright(c) 2018 Advanced Micro Devices, Inc. All rights reserved.
   3  */
   4
   5 #include <string.h>
   6
   7 #include <rte_common.h>
   8 #include <rte_cryptodev_pmd.h>
   9 #include <rte_malloc.h>
  10
  11 #include "ccp_pmd_private.h"
  12 #include "ccp_dev.h"
  13 #include "ccp_crypto.h"
  14
  15 static const struct rte_cryptodev_capabilities ccp_pmd_capabilities[] = {
  16         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
  17 };
  18
  19 static int
  20 ccp_pmd_config(struct rte_cryptodev *dev __rte_unused,
  21                struct rte_cryptodev_config *config __rte_unused)
  22 {
  23         return 0;
  24 }
  25
  26 static int
  27 ccp_pmd_start(struct rte_cryptodev *dev)
  28 {
  29         return ccp_dev_start(dev);
  30 }
  31
  32 static void
  33 ccp_pmd_stop(struct rte_cryptodev *dev __rte_unused)
  34 {
  35
  36 }
  37
  38 static int
  39 ccp_pmd_close(struct rte_cryptodev *dev __rte_unused)
  40 {
  41         return 0;
  42 }
  43
  44 static void
  45 ccp_pmd_stats_get(struct rte_cryptodev *dev,
  46                   struct rte_cryptodev_stats *stats)
  47 {
  48         int qp_id;
  49
  50         for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
  51                 struct ccp_qp *qp = dev->data->queue_pairs[qp_id];
  52
  53                 stats->enqueued_count += qp->qp_stats.enqueued_count;
  54                 stats->dequeued_count += qp->qp_stats.dequeued_count;
  55
  56                 stats->enqueue_err_count += qp->qp_stats.enqueue_err_count;
  57                 stats->dequeue_err_count += qp->qp_stats.dequeue_err_count;
  58         }
  59
  60 }
  61
  62 static void
  63 ccp_pmd_stats_reset(struct rte_cryptodev *dev)
  64 {
  65         int qp_id;
  66
  67         for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
  68                 struct ccp_qp *qp = dev->data->queue_pairs[qp_id];
  69
  70                 memset(&qp->qp_stats, 0, sizeof(qp->qp_stats));
  71         }
  72 }
  73
  74 static void
  75 ccp_pmd_info_get(struct rte_cryptodev *dev,
  76                  struct rte_cryptodev_info *dev_info)
  77 {
  78         struct ccp_private *internals = dev->data->dev_private;
  79
  80         if (dev_info != NULL) {
  81                 dev_info->driver_id = dev->driver_id;
  82                 dev_info->feature_flags = dev->feature_flags;
  83                 dev_info->capabilities = ccp_pmd_capabilities;
  84                 dev_info->max_nb_queue_pairs = internals->max_nb_qpairs;
  85                 dev_info->sym.max_nb_sessions = internals->max_nb_sessions;
  86         }
  87 }
  88
  89 static int
  90 ccp_pmd_qp_release(struct rte_cryptodev *dev, uint16_t qp_id)
  91 {
  92         struct ccp_qp *qp;
  93
  94         if (dev->data->queue_pairs[qp_id] != NULL) {
  95                 qp = (struct ccp_qp *)dev->data->queue_pairs[qp_id];
  96                 rte_ring_free(qp->processed_pkts);
  97                 rte_mempool_free(qp->batch_mp);
  98                 rte_free(qp);
  99                 dev->data->queue_pairs[qp_id] = NULL;
 100         }
 101         return 0;
 102 }
 103
 104 static int
 105 ccp_pmd_qp_set_unique_name(struct rte_cryptodev *dev,
 106                 struct ccp_qp *qp)
 107 {
 108         unsigned int n = snprintf(qp->name, sizeof(qp->name),
 109                         "ccp_pmd_%u_qp_%u",
 110                         dev->data->dev_id, qp->id);
 111
 112         if (n > sizeof(qp->name))
 113                 return -1;
 114
 115         return 0;
 116 }
 117
 118 static struct rte_ring *
 119 ccp_pmd_qp_create_batch_info_ring(struct ccp_qp *qp,
 120                                   unsigned int ring_size, int socket_id)
 121 {
 122         struct rte_ring *r;
 123
 124         r = rte_ring_lookup(qp->name);
 125         if (r) {
 126                 if (r->size >= ring_size) {
 127                         CCP_LOG_INFO(
 128                                 "Reusing ring %s for processed packets",
 129                                 qp->name);
 130                         return r;
 131                 }
 132                 CCP_LOG_INFO(
 133                         "Unable to reuse ring %s for processed packets",
 134                          qp->name);
 135                 return NULL;
 136         }
 137
 138         return rte_ring_create(qp->name, ring_size, socket_id,
 139                         RING_F_SP_ENQ | RING_F_SC_DEQ);
 140 }
 141
 142 static int
 143 ccp_pmd_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id,
 144                  const struct rte_cryptodev_qp_conf *qp_conf,
 145                  int socket_id, struct rte_mempool *session_pool)
 146 {
 147         struct ccp_private *internals = dev->data->dev_private;
 148         struct ccp_qp *qp;
 149         int retval = 0;
 150
 151         if (qp_id >= internals->max_nb_qpairs) {
 152                 CCP_LOG_ERR("Invalid qp_id %u, should be less than %u",
 153                             qp_id, internals->max_nb_qpairs);
 154                 return (-EINVAL);
 155         }
 156
 157         /* Free memory prior to re-allocation if needed. */
 158         if (dev->data->queue_pairs[qp_id] != NULL)
 159                 ccp_pmd_qp_release(dev, qp_id);
 160
 161         /* Allocate the queue pair data structure. */
 162         qp = rte_zmalloc_socket("CCP Crypto PMD Queue Pair", sizeof(*qp),
 163                                         RTE_CACHE_LINE_SIZE, socket_id);
 164         if (qp == NULL) {
 165                 CCP_LOG_ERR("Failed to allocate queue pair memory");
 166                 return (-ENOMEM);
 167         }
 168
 169         qp->dev = dev;
 170         qp->id = qp_id;
 171         dev->data->queue_pairs[qp_id] = qp;
 172
 173         retval = ccp_pmd_qp_set_unique_name(dev, qp);
 174         if (retval) {
 175                 CCP_LOG_ERR("Failed to create unique name for ccp qp");
 176                 goto qp_setup_cleanup;
 177         }
 178
 179         qp->processed_pkts = ccp_pmd_qp_create_batch_info_ring(qp,
 180                         qp_conf->nb_descriptors, socket_id);
 181         if (qp->processed_pkts == NULL) {
 182                 CCP_LOG_ERR("Failed to create batch info ring");
 183                 goto qp_setup_cleanup;
 184         }
 185
 186         qp->sess_mp = session_pool;
 187
 188         /* mempool for batch info */
 189         qp->batch_mp = rte_mempool_create(
 190                                 qp->name,
 191                                 qp_conf->nb_descriptors,
 192                                 sizeof(struct ccp_batch_info),
 193                                 RTE_CACHE_LINE_SIZE,
 194                                 0, NULL, NULL, NULL, NULL,
 195                                 SOCKET_ID_ANY, 0);
 196         if (qp->batch_mp == NULL)
 197                 goto qp_setup_cleanup;
 198         memset(&qp->qp_stats, 0, sizeof(qp->qp_stats));
 199         return 0;
 200
 201 qp_setup_cleanup:
 202         dev->data->queue_pairs[qp_id] = NULL;
 203         if (qp)
 204                 rte_free(qp);
 205         return -1;
 206 }
 207
 208 static int
 209 ccp_pmd_qp_start(struct rte_cryptodev *dev __rte_unused,
 210                  uint16_t queue_pair_id __rte_unused)
 211 {
 212         return -ENOTSUP;
 213 }
 214
 215 static int
 216 ccp_pmd_qp_stop(struct rte_cryptodev *dev __rte_unused,
 217                 uint16_t queue_pair_id __rte_unused)
 218 {
 219         return -ENOTSUP;
 220 }
 221
 222 static uint32_t
 223 ccp_pmd_qp_count(struct rte_cryptodev *dev)
 224 {
 225         return dev->data->nb_queue_pairs;
 226 }
 227
 228 static unsigned
 229 ccp_pmd_session_get_size(struct rte_cryptodev *dev __rte_unused)
 230 {
 231         return sizeof(struct ccp_session);
 232 }
 233
 234 static int
 235 ccp_pmd_session_configure(struct rte_cryptodev *dev,
 236                           struct rte_crypto_sym_xform *xform,
 237                           struct rte_cryptodev_sym_session *sess,
 238                           struct rte_mempool *mempool)
 239 {
 240         int ret;
 241         void *sess_private_data;
 242
 243         if (unlikely(sess == NULL || xform == NULL)) {
 244                 CCP_LOG_ERR("Invalid session struct or xform");
 245                 return -ENOMEM;
 246         }
 247
 248         if (rte_mempool_get(mempool, &sess_private_data)) {
 249                 CCP_LOG_ERR("Couldn't get object from session mempool");
 250                 return -ENOMEM;
 251         }
 252         ret = ccp_set_session_parameters(sess_private_data, xform);
 253         if (ret != 0) {
 254                 CCP_LOG_ERR("failed configure session parameters");
 255
 256                 /* Return session to mempool */
 257                 rte_mempool_put(mempool, sess_private_data);
 258                 return ret;
 259         }
 260         set_session_private_data(sess, dev->driver_id,
 261                                  sess_private_data);
 262
 263         return 0;
 264 }
 265
 266 static void
 267 ccp_pmd_session_clear(struct rte_cryptodev *dev,
 268                       struct rte_cryptodev_sym_session *sess)
 269 {
 270         uint8_t index = dev->driver_id;
 271         void *sess_priv = get_session_private_data(sess, index);
 272
 273         if (sess_priv) {
 274                 struct rte_mempool *sess_mp = rte_mempool_from_obj(sess_priv);
 275
 276                 rte_mempool_put(sess_mp, sess_priv);
 277                 memset(sess_priv, 0, sizeof(struct ccp_session));
 278                 set_session_private_data(sess, index, NULL);
 279         }
 280 }
 281
 282 struct rte_cryptodev_ops ccp_ops = {
 283                 .dev_configure          = ccp_pmd_config,
 284                 .dev_start              = ccp_pmd_start,
 285                 .dev_stop               = ccp_pmd_stop,
 286                 .dev_close              = ccp_pmd_close,
 287
 288                 .stats_get              = ccp_pmd_stats_get,
 289                 .stats_reset            = ccp_pmd_stats_reset,
 290
 291                 .dev_infos_get          = ccp_pmd_info_get,
 292
 293                 .queue_pair_setup       = ccp_pmd_qp_setup,
 294                 .queue_pair_release     = ccp_pmd_qp_release,
 295                 .queue_pair_start       = ccp_pmd_qp_start,
 296                 .queue_pair_stop        = ccp_pmd_qp_stop,
 297                 .queue_pair_count       = ccp_pmd_qp_count,
 298
 299                 .session_get_size       = ccp_pmd_session_get_size,
 300                 .session_configure      = ccp_pmd_session_configure,
 301                 .session_clear          = ccp_pmd_session_clear,
 302 };
 303
 304 struct rte_cryptodev_ops *ccp_pmd_ops = &ccp_ops;