crypto/zuc: use IPsec library

[dpdk.git] / drivers / crypto / zuc / rte_zuc_pmd.c

diff --git a/drivers/crypto/zuc/rte_zuc_pmd.c b/drivers/crypto/zuc/rte_zuc_pmd.c
index 8e214cd..9e06ab7 100644 (file)
--- a/drivers/crypto/zuc/rte_zuc_pmd.c
+++ b/drivers/crypto/zuc/rte_zuc_pmd.c
@@ -11,7 +11,7 @@
 #include <rte_cpuflags.h>
 
 #include "zuc_pmd_private.h"
-#define ZUC_MAX_BURST 4
+#define ZUC_MAX_BURST 16
 #define BYTE_LEN 8
 
 static uint8_t cryptodev_driver_id;
@@ -170,16 +170,17 @@ zuc_get_session(struct zuc_qp *qp, struct rte_crypto_op *op)
 
 /** Encrypt/decrypt mbufs. */
 static uint8_t
-process_zuc_cipher_op(struct rte_crypto_op **ops,
+process_zuc_cipher_op(struct zuc_qp *qp, struct rte_crypto_op **ops,
                struct zuc_session **sessions,
                uint8_t num_ops)
 {
        unsigned i;
        uint8_t processed_ops = 0;
-       uint8_t *src[ZUC_MAX_BURST], *dst[ZUC_MAX_BURST];
-       uint8_t *iv[ZUC_MAX_BURST];
+       const void *src[ZUC_MAX_BURST];
+       void *dst[ZUC_MAX_BURST];
+       const void *iv[ZUC_MAX_BURST];
        uint32_t num_bytes[ZUC_MAX_BURST];
-       uint8_t *cipher_keys[ZUC_MAX_BURST];
+       const void *cipher_keys[ZUC_MAX_BURST];
        struct zuc_session *sess;
 
        for (i = 0; i < num_ops; i++) {
@@ -222,7 +223,8 @@ process_zuc_cipher_op(struct rte_crypto_op **ops,
                processed_ops++;
        }
 
-       sso_zuc_eea3_n_buffer(cipher_keys, iv, src, dst,
+       IMB_ZUC_EEA3_N_BUFFER(qp->mb_mgr, (const void **)cipher_keys,
+                       (const void **)iv, (const void **)src, (void **)dst,
                        num_bytes, processed_ops);
 
        return processed_ops;
@@ -262,7 +264,7 @@ process_zuc_hash_op(struct zuc_qp *qp, struct rte_crypto_op **ops,
                if (sess->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY) {
                        dst = (uint32_t *)qp->temp_digest;
 
-                       sso_zuc_eia3_1_buffer(sess->pKey_hash,
+                       IMB_ZUC_EIA3_1_BUFFER(qp->mb_mgr, sess->pKey_hash,
                                        iv, src,
                                        length_in_bits, dst);
                        /* Verify digest. */
@@ -272,7 +274,7 @@ process_zuc_hash_op(struct zuc_qp *qp, struct rte_crypto_op **ops,
                } else  {
                        dst = (uint32_t *)ops[i]->sym->auth.digest.data;
 
-                       sso_zuc_eia3_1_buffer(sess->pKey_hash,
+                       IMB_ZUC_EIA3_1_BUFFER(qp->mb_mgr, sess->pKey_hash,
                                        iv, src,
                                        length_in_bits, dst);
                }
@@ -294,7 +296,7 @@ process_ops(struct rte_crypto_op **ops, enum zuc_operation op_type,
 
        switch (op_type) {
        case ZUC_OP_ONLY_CIPHER:
-               processed_ops = process_zuc_cipher_op(ops,
+               processed_ops = process_zuc_cipher_op(qp, ops,
                                sessions, num_ops);
                break;
        case ZUC_OP_ONLY_AUTH:
@@ -302,14 +304,14 @@ process_ops(struct rte_crypto_op **ops, enum zuc_operation op_type,
                                num_ops);
                break;
        case ZUC_OP_CIPHER_AUTH:
-               processed_ops = process_zuc_cipher_op(ops, sessions,
+               processed_ops = process_zuc_cipher_op(qp, ops, sessions,
                                num_ops);
                process_zuc_hash_op(qp, ops, sessions, processed_ops);
                break;
        case ZUC_OP_AUTH_CIPHER:
                processed_ops = process_zuc_hash_op(qp, ops, sessions,
                                num_ops);
-               process_zuc_cipher_op(ops, sessions, processed_ops);
+               process_zuc_cipher_op(qp, ops, sessions, processed_ops);
                break;
        default:
                /* Operation not supported. */
@@ -457,8 +459,7 @@ cryptodev_zuc_create(const char *name,
 {
        struct rte_cryptodev *dev;
        struct zuc_private *internals;
-       uint64_t cpu_flags = RTE_CRYPTODEV_FF_CPU_SSE;
-
+       MB_MGR *mb_mgr;
 
        dev = rte_cryptodev_pmd_create(name, &vdev->device, init_params);
        if (dev == NULL) {
@@ -466,6 +467,27 @@ cryptodev_zuc_create(const char *name,
                goto init_error;
        }
 
+       dev->feature_flags = RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO |
+                       RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING;
+
+       mb_mgr = alloc_mb_mgr(0);
+       if (mb_mgr == NULL)
+               return -ENOMEM;
+
+       if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512F)) {
+               dev->feature_flags |= RTE_CRYPTODEV_FF_CPU_AVX512;
+               init_mb_mgr_avx512(mb_mgr);
+       } else if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX2)) {
+               dev->feature_flags |= RTE_CRYPTODEV_FF_CPU_AVX2;
+               init_mb_mgr_avx2(mb_mgr);
+       } else if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX)) {
+               dev->feature_flags |= RTE_CRYPTODEV_FF_CPU_AVX;
+               init_mb_mgr_avx(mb_mgr);
+       } else {
+               dev->feature_flags |= RTE_CRYPTODEV_FF_CPU_SSE;
+               init_mb_mgr_sse(mb_mgr);
+       }
+
        dev->driver_id = cryptodev_driver_id;
        dev->dev_ops = rte_zuc_pmd_ops;
 
@@ -473,11 +495,8 @@ cryptodev_zuc_create(const char *name,
        dev->dequeue_burst = zuc_pmd_dequeue_burst;
        dev->enqueue_burst = zuc_pmd_enqueue_burst;
 
-       dev->feature_flags = RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO |
-                       RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING |
-                       cpu_flags;
-
        internals = dev->data->dev_private;
+       internals->mb_mgr = mb_mgr;
 
        internals->max_nb_queue_pairs = init_params->max_nb_queue_pairs;
 
@@ -518,6 +537,7 @@ cryptodev_zuc_remove(struct rte_vdev_device *vdev)
 
        struct rte_cryptodev *cryptodev;
        const char *name;
+       struct zuc_private *internals;
 
        name = rte_vdev_device_name(vdev);
        if (name == NULL)
@@ -527,6 +547,10 @@ cryptodev_zuc_remove(struct rte_vdev_device *vdev)
        if (cryptodev == NULL)
                return -ENODEV;
 
+       internals = cryptodev->data->dev_private;
+
+       free_mb_mgr(internals->mb_mgr);
+
        return rte_cryptodev_pmd_destroy(cryptodev);
 }