cryptodev: add asymmetric capability

Extend cryptodev with asymmetric capability APIs and
definitions.

Signed-off-by: Shally Verma <shally.verma@caviumnetworks.com>
Signed-off-by: Sunila Sahu <sunila.sahu@caviumnetworks.com>
Signed-off-by: Ashish Gupta <ashish.gupta@caviumnetworks.com>
Signed-off-by: Umesh Kartha <umesh.kartha@caviumnetworks.com>
Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>

diff --git a/lib/librte_cryptodev/rte_cryptodev.c b/lib/librte_cryptodev/rte_cryptodev.c
index da0d322..63ae23f 100644 (file)
--- a/lib/librte_cryptodev/rte_cryptodev.c
+++ b/lib/librte_cryptodev/rte_cryptodev.c
@@ -242,6 +242,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 +330,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 +403,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)

diff --git a/lib/librte_cryptodev/rte_cryptodev.h b/lib/librte_cryptodev/rte_cryptodev.h
index 24e8d0b..4099823 100644 (file)
--- a/lib/librte_cryptodev/rte_cryptodev.h
+++ b/lib/librte_cryptodev/rte_cryptodev.h
@@ -143,6 +143,35 @@ struct rte_cryptodev_symmetric_capability {
        };
 };
 
+/**
+ * Asymmetric Xform Crypto Capability
+ *
+ */
+struct rte_cryptodev_asymmetric_xform_capability {
+       enum rte_crypto_asym_xform_type xform_type;
+       /**< Transform type: RSA/MODEXP/DH/DSA/MODINV */
+
+       uint32_t op_types;
+       /**< bitmask for supported rte_crypto_asym_op_type */
+
+       __extension__
+       union {
+               struct rte_crypto_param_range modlen;
+               /**< Range of modulus length supported by modulus based xform.
+                * Value 0 mean implementation default
+                */
+       };
+};
+
+/**
+ * Asymmetric Crypto Capability
+ *
+ */
+struct rte_cryptodev_asymmetric_capability {
+       struct rte_cryptodev_asymmetric_xform_capability xform_capa;
+};
+
+
 /** Structure used to capture a capability of a crypto device */
 struct rte_cryptodev_capabilities {
        enum rte_crypto_op_type op;
@@ -152,6 +181,8 @@ struct rte_cryptodev_capabilities {
        union {
                struct rte_cryptodev_symmetric_capability sym;
                /**< Symmetric operation capability parameters */
+               struct rte_cryptodev_asymmetric_capability asym;
+               /**< Asymmetric operation capability parameters */
        };
 };
 
@@ -166,7 +197,17 @@ struct rte_cryptodev_sym_capability_idx {
 };
 
 /**
- *  Provide capabilities available for defined device and algorithm
+ * Structure used to describe asymmetric crypto xforms
+ * Each xform maps to one asym algorithm.
+ *
+ */
+struct rte_cryptodev_asym_capability_idx {
+       enum rte_crypto_asym_xform_type type;
+       /**< Asymmetric xform (algo) type */
+};
+
+/**
+ * Provide capabilities available for defined device and algorithm
  *
  * @param      dev_id          The identifier of the device.
  * @param      idx             Description of crypto algorithms.
@@ -179,6 +220,20 @@ const struct rte_cryptodev_symmetric_capability *
 rte_cryptodev_sym_capability_get(uint8_t dev_id,
                const struct rte_cryptodev_sym_capability_idx *idx);
 
+/**
+ *  Provide capabilities available for defined device and xform
+ *
+ * @param      dev_id          The identifier of the device.
+ * @param      idx             Description of asym crypto xform.
+ *
+ * @return
+ *   - Return description of the asymmetric crypto capability if exist.
+ *   - Return NULL if the capability not exist.
+ */
+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);
+
 /**
  * Check if key size and initial vector are supported
  * in crypto cipher capability
@@ -234,6 +289,36 @@ rte_cryptodev_sym_capability_check_aead(
                uint16_t key_size, uint16_t digest_size, uint16_t aad_size,
                uint16_t iv_size);
 
+/**
+ * Check if op type is supported
+ *
+ * @param      capability      Description of the asymmetric crypto capability.
+ * @param      op_type         op type
+ *
+ * @return
+ *   - Return 1 if the op type is supported
+ *   - Return 0 if unsupported
+ */
+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);
+
+/**
+ * Check if modulus length is in supported range
+ *
+ * @param      capability      Description of the asymmetric crypto capability.
+ * @param      modlen          modulus length.
+ *
+ * @return
+ *   - Return 0 if the parameters are in range of the capability.
+ *   - Return -1 if the parameters are out of range of the capability.
+ */
+int __rte_experimental
+rte_cryptodev_asym_xform_capability_check_modlen(
+       const struct rte_cryptodev_asymmetric_xform_capability *capability,
+               uint16_t modlen);
+
 /**
  * Provide the cipher algorithm enum, given an algorithm string
  *
@@ -279,6 +364,22 @@ int
 rte_cryptodev_get_aead_algo_enum(enum rte_crypto_aead_algorithm *algo_enum,
                const char *algo_string);
 
+/**
+ * Provide the Asymmetric xform enum, given an xform string
+ *
+ * @param      xform_enum      A pointer to the xform type
+ *                             enum to be filled
+ * @param      xform_string    xform string
+ *
+ * @return
+ * - Return -1 if string is not valid
+ * - Return 0 if the string is valid
+ */
+int __rte_experimental
+rte_cryptodev_asym_get_xform_enum(enum rte_crypto_asym_xform_type *xform_enum,
+               const char *xform_string);
+
+
 /** Macro used at end of crypto PMD list */
 #define RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST() \
        { RTE_CRYPTO_OP_TYPE_UNDEFINED }

diff --git a/lib/librte_cryptodev/rte_cryptodev_version.map b/lib/librte_cryptodev/rte_cryptodev_version.map
index e63b51a..7ca0073 100644 (file)
--- a/lib/librte_cryptodev/rte_cryptodev_version.map
+++ b/lib/librte_cryptodev/rte_cryptodev_version.map
@@ -91,12 +91,18 @@ DPDK_18.05 {
 EXPERIMENTAL {
         global:
 
+       rte_cryptodev_asym_capability_get;
        rte_cryptodev_asym_get_header_session_size;
        rte_cryptodev_asym_get_private_session_size;
+       rte_cryptodev_asym_get_xform_enum;
        rte_cryptodev_asym_session_clear;
        rte_cryptodev_asym_session_create;
        rte_cryptodev_asym_session_free;
        rte_cryptodev_asym_session_init;
+       rte_cryptodev_asym_xform_capability_check_modlen;
+       rte_cryptodev_asym_xform_capability_check_optype;
        rte_cryptodev_sym_session_get_user_data;
        rte_cryptodev_sym_session_set_user_data;
+       rte_crypto_asym_op_strings;
+       rte_crypto_asym_xform_strings;
 };