lib: reduce global variable usage

[dpdk.git] / lib / librte_cryptodev / rte_cryptodev.c

diff --git a/lib/librte_cryptodev/rte_cryptodev.c b/lib/librte_cryptodev/rte_cryptodev.c
index da0d322..a52eaaa 100644 (file)
--- a/lib/librte_cryptodev/rte_cryptodev.c
+++ b/lib/librte_cryptodev/rte_cryptodev.c
@@ -43,19 +43,17 @@
 
 static uint8_t nb_drivers;
 
-struct rte_cryptodev rte_crypto_devices[RTE_CRYPTO_MAX_DEVS];
+static struct rte_cryptodev rte_crypto_devices[RTE_CRYPTO_MAX_DEVS];
 
-struct rte_cryptodev *rte_cryptodevs = &rte_crypto_devices[0];
+struct rte_cryptodev *rte_cryptodevs = rte_crypto_devices;
 
 static struct rte_cryptodev_global cryptodev_globals = {
-               .devs                   = &rte_crypto_devices[0],
+               .devs                   = rte_crypto_devices,
                .data                   = { NULL },
                .nb_devs                = 0,
                .max_devs               = RTE_CRYPTO_MAX_DEVS
 };
 
-struct rte_cryptodev_global *rte_cryptodev_globals = &cryptodev_globals;
-
 /* spinlock for crypto device callbacks */
 static rte_spinlock_t rte_cryptodev_cb_lock = RTE_SPINLOCK_INITIALIZER;
 
@@ -242,6 +240,24 @@ rte_cryptodev_get_aead_algo_enum(enum rte_crypto_aead_algorithm *algo_enum,
        return -1;
 }
 
+int __rte_experimental
+rte_cryptodev_asym_get_xform_enum(enum rte_crypto_asym_xform_type *xform_enum,
+               const char *xform_string)
+{
+       unsigned int i;
+
+       for (i = 1; i < RTE_DIM(rte_crypto_asym_xform_strings); i++) {
+               if (strcmp(xform_string,
+                       rte_crypto_asym_xform_strings[i]) == 0) {
+                       *xform_enum = (enum rte_crypto_asym_xform_type) i;
+                       return 0;
+               }
+       }
+
+       /* Invalid string */
+       return -1;
+}
+
 /**
  * The crypto auth operation strings identifiers.
  * It could be used in application command line.
@@ -312,6 +328,28 @@ param_range_check(uint16_t size, const struct rte_crypto_param_range *range)
        return -1;
 }
 
+const struct rte_cryptodev_asymmetric_xform_capability * __rte_experimental
+rte_cryptodev_asym_capability_get(uint8_t dev_id,
+               const struct rte_cryptodev_asym_capability_idx *idx)
+{
+       const struct rte_cryptodev_capabilities *capability;
+       struct rte_cryptodev_info dev_info;
+       unsigned int i = 0;
+
+       memset(&dev_info, 0, sizeof(struct rte_cryptodev_info));
+       rte_cryptodev_info_get(dev_id, &dev_info);
+
+       while ((capability = &dev_info.capabilities[i++])->op !=
+                       RTE_CRYPTO_OP_TYPE_UNDEFINED) {
+               if (capability->op != RTE_CRYPTO_OP_TYPE_ASYMMETRIC)
+                       continue;
+
+               if (capability->asym.xform_capa.xform_type == idx->type)
+                       return &capability->asym.xform_capa;
+       }
+       return NULL;
+};
+
 int
 rte_cryptodev_sym_capability_check_cipher(
                const struct rte_cryptodev_symmetric_capability *capability,
@@ -363,6 +401,42 @@ rte_cryptodev_sym_capability_check_aead(
 
        return 0;
 }
+int __rte_experimental
+rte_cryptodev_asym_xform_capability_check_optype(
+       const struct rte_cryptodev_asymmetric_xform_capability *capability,
+       enum rte_crypto_asym_op_type op_type)
+{
+       if (capability->op_types & (1 << op_type))
+               return 1;
+
+       return 0;
+}
+
+int __rte_experimental
+rte_cryptodev_asym_xform_capability_check_modlen(
+       const struct rte_cryptodev_asymmetric_xform_capability *capability,
+       uint16_t modlen)
+{
+       /* no need to check for limits, if min or max = 0 */
+       if (capability->modlen.min != 0) {
+               if (modlen < capability->modlen.min)
+                       return -1;
+       }
+
+       if (capability->modlen.max != 0) {
+               if (modlen > capability->modlen.max)
+                       return -1;
+       }
+
+       /* in any case, check if given modlen is module increment */
+       if (capability->modlen.increment != 0) {
+               if (modlen % (capability->modlen.increment))
+                       return -1;
+       }
+
+       return 0;
+}
+
 
 const char *
 rte_cryptodev_get_feature_name(uint64_t flag)
@@ -410,7 +484,7 @@ rte_cryptodev_get_feature_name(uint64_t flag)
 struct rte_cryptodev *
 rte_cryptodev_pmd_get_dev(uint8_t dev_id)
 {
-       return &rte_cryptodev_globals->devs[dev_id];
+       return &cryptodev_globals.devs[dev_id];
 }
 
 struct rte_cryptodev *
@@ -422,8 +496,8 @@ rte_cryptodev_pmd_get_named_dev(const char *name)
        if (name == NULL)
                return NULL;
 
-       for (i = 0; i < rte_cryptodev_globals->max_devs; i++) {
-               dev = &rte_cryptodev_globals->devs[i];
+       for (i = 0; i < cryptodev_globals.max_devs; i++) {
+               dev = &cryptodev_globals.devs[i];
 
                if ((dev->attached == RTE_CRYPTODEV_ATTACHED) &&
                                (strcmp(dev->data->name, name) == 0))
@@ -438,7 +512,7 @@ rte_cryptodev_pmd_is_valid_dev(uint8_t dev_id)
 {
        struct rte_cryptodev *dev = NULL;
 
-       if (dev_id >= rte_cryptodev_globals->nb_devs)
+       if (dev_id >= cryptodev_globals.nb_devs)
                return 0;
 
        dev = rte_cryptodev_pmd_get_dev(dev_id);
@@ -457,10 +531,10 @@ rte_cryptodev_get_dev_id(const char *name)
        if (name == NULL)
                return -1;
 
-       for (i = 0; i < rte_cryptodev_globals->nb_devs; i++)
-               if ((strcmp(rte_cryptodev_globals->devs[i].data->name, name)
+       for (i = 0; i < cryptodev_globals.nb_devs; i++)
+               if ((strcmp(cryptodev_globals.devs[i].data->name, name)
                                == 0) &&
-                               (rte_cryptodev_globals->devs[i].attached ==
+                               (cryptodev_globals.devs[i].attached ==
                                                RTE_CRYPTODEV_ATTACHED))
                        return i;
 
@@ -470,7 +544,7 @@ rte_cryptodev_get_dev_id(const char *name)
 uint8_t
 rte_cryptodev_count(void)
 {
-       return rte_cryptodev_globals->nb_devs;
+       return cryptodev_globals.nb_devs;
 }
 
 uint8_t
@@ -478,9 +552,9 @@ rte_cryptodev_device_count_by_driver(uint8_t driver_id)
 {
        uint8_t i, dev_count = 0;
 
-       for (i = 0; i < rte_cryptodev_globals->max_devs; i++)
-               if (rte_cryptodev_globals->devs[i].driver_id == driver_id &&
-                       rte_cryptodev_globals->devs[i].attached ==
+       for (i = 0; i < cryptodev_globals.max_devs; i++)
+               if (cryptodev_globals.devs[i].driver_id == driver_id &&
+                       cryptodev_globals.devs[i].attached ==
                                        RTE_CRYPTODEV_ATTACHED)
                        dev_count++;
 
@@ -492,8 +566,8 @@ rte_cryptodev_devices_get(const char *driver_name, uint8_t *devices,
        uint8_t nb_devices)
 {
        uint8_t i, count = 0;
-       struct rte_cryptodev *devs = rte_cryptodev_globals->devs;
-       uint8_t max_devs = rte_cryptodev_globals->max_devs;
+       struct rte_cryptodev *devs = cryptodev_globals.devs;
+       uint8_t max_devs = cryptodev_globals.max_devs;
 
        for (i = 0; i < max_devs && count < nb_devices; i++) {
 
@@ -1401,6 +1475,9 @@ rte_crypto_op_pool_create(const char *name, enum rte_crypto_op_type type,
                elt_size += sizeof(struct rte_crypto_sym_op);
        } else if (type == RTE_CRYPTO_OP_TYPE_ASYMMETRIC) {
                elt_size += sizeof(struct rte_crypto_asym_op);
+       } else if (type == RTE_CRYPTO_OP_TYPE_UNDEFINED) {
+               elt_size += RTE_MAX(sizeof(struct rte_crypto_sym_op),
+                                   sizeof(struct rte_crypto_asym_op));
        } else {
                CDEV_LOG_ERR("Invalid op_type\n");
                return NULL;