test/crypto: add AES-CCM tests
[dpdk.git] / test / test / test_cryptodev.c
index 204933a..8be8e57 100644 (file)
 #include "test_cryptodev_snow3g_test_vectors.h"
 #include "test_cryptodev_snow3g_hash_test_vectors.h"
 #include "test_cryptodev_zuc_test_vectors.h"
-#include "test_cryptodev_gcm_test_vectors.h"
+#include "test_cryptodev_aead_test_vectors.h"
 #include "test_cryptodev_hmac_test_vectors.h"
 
-static enum rte_cryptodev_type gbl_cryptodev_type;
+static int gbl_driver_id;
 
 struct crypto_testsuite_params {
        struct rte_mempool *mbuf_pool;
        struct rte_mempool *large_mbuf_pool;
        struct rte_mempool *op_mpool;
+       struct rte_mempool *session_mpool;
        struct rte_cryptodev_config conf;
        struct rte_cryptodev_qp_conf qp_conf;
 
@@ -77,6 +78,7 @@ struct crypto_testsuite_params {
 struct crypto_unittest_params {
        struct rte_crypto_sym_xform cipher_xform;
        struct rte_crypto_sym_xform auth_xform;
+       struct rte_crypto_sym_xform aead_xform;
 
        struct rte_cryptodev_sym_session *sess;
 
@@ -212,14 +214,11 @@ testsuite_setup(void)
        }
 
        /* Create an AESNI MB device if required */
-       if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD) {
-#ifndef RTE_LIBRTE_PMD_AESNI_MB
-               RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
-                       " enabled in config file to run this testsuite.\n");
-               return TEST_FAILED;
-#endif
-               nb_devs = rte_cryptodev_count_devtype(
-                               RTE_CRYPTODEV_AESNI_MB_PMD);
+       if (gbl_driver_id == rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
+               nb_devs = rte_cryptodev_device_count_by_driver(
+                               rte_cryptodev_driver_id_get(
+                               RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
                if (nb_devs < 1) {
                        ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
@@ -232,14 +231,11 @@ testsuite_setup(void)
        }
 
        /* Create an AESNI GCM device if required */
-       if (gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_GCM_PMD) {
-#ifndef RTE_LIBRTE_PMD_AESNI_GCM
-               RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM must be"
-                       " enabled in config file to run this testsuite.\n");
-               return TEST_FAILED;
-#endif
-               nb_devs = rte_cryptodev_count_devtype(
-                               RTE_CRYPTODEV_AESNI_GCM_PMD);
+       if (gbl_driver_id == rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
+               nb_devs = rte_cryptodev_device_count_by_driver(
+                               rte_cryptodev_driver_id_get(
+                               RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
                if (nb_devs < 1) {
                        TEST_ASSERT_SUCCESS(rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
@@ -250,13 +246,11 @@ testsuite_setup(void)
        }
 
        /* Create a SNOW 3G device if required */
-       if (gbl_cryptodev_type == RTE_CRYPTODEV_SNOW3G_PMD) {
-#ifndef RTE_LIBRTE_PMD_SNOW3G
-               RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_SNOW3G must be"
-                       " enabled in config file to run this testsuite.\n");
-               return TEST_FAILED;
-#endif
-               nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD);
+       if (gbl_driver_id == rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
+               nb_devs = rte_cryptodev_device_count_by_driver(
+                               rte_cryptodev_driver_id_get(
+                               RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
                if (nb_devs < 1) {
                        TEST_ASSERT_SUCCESS(rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
@@ -267,13 +261,11 @@ testsuite_setup(void)
        }
 
        /* Create a KASUMI device if required */
-       if (gbl_cryptodev_type == RTE_CRYPTODEV_KASUMI_PMD) {
-#ifndef RTE_LIBRTE_PMD_KASUMI
-               RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_KASUMI must be"
-                       " enabled in config file to run this testsuite.\n");
-               return TEST_FAILED;
-#endif
-               nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_KASUMI_PMD);
+       if (gbl_driver_id == rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_KASUMI_PMD))) {
+               nb_devs = rte_cryptodev_device_count_by_driver(
+                               rte_cryptodev_driver_id_get(
+                               RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)));
                if (nb_devs < 1) {
                        TEST_ASSERT_SUCCESS(rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
@@ -284,13 +276,11 @@ testsuite_setup(void)
        }
 
        /* Create a ZUC device if required */
-       if (gbl_cryptodev_type == RTE_CRYPTODEV_ZUC_PMD) {
-#ifndef RTE_LIBRTE_PMD_ZUC
-               RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ZUC must be"
-                       " enabled in config file to run this testsuite.\n");
-               return TEST_FAILED;
-#endif
-               nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_ZUC_PMD);
+       if (gbl_driver_id == rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) {
+               nb_devs = rte_cryptodev_device_count_by_driver(
+                               rte_cryptodev_driver_id_get(
+                               RTE_STR(CRYPTODEV_NAME_ZUC_PMD)));
                if (nb_devs < 1) {
                        TEST_ASSERT_SUCCESS(rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
@@ -301,14 +291,11 @@ testsuite_setup(void)
        }
 
        /* Create a NULL device if required */
-       if (gbl_cryptodev_type == RTE_CRYPTODEV_NULL_PMD) {
-#ifndef RTE_LIBRTE_PMD_NULL_CRYPTO
-               RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_NULL_CRYPTO must be"
-                       " enabled in config file to run this testsuite.\n");
-               return TEST_FAILED;
-#endif
-               nb_devs = rte_cryptodev_count_devtype(
-                               RTE_CRYPTODEV_NULL_PMD);
+       if (gbl_driver_id == rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_NULL_PMD))) {
+               nb_devs = rte_cryptodev_device_count_by_driver(
+                               rte_cryptodev_driver_id_get(
+                               RTE_STR(CRYPTODEV_NAME_NULL_PMD)));
                if (nb_devs < 1) {
                        ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
@@ -321,14 +308,11 @@ testsuite_setup(void)
        }
 
        /* Create an OPENSSL device if required */
-       if (gbl_cryptodev_type == RTE_CRYPTODEV_OPENSSL_PMD) {
-#ifndef RTE_LIBRTE_PMD_OPENSSL
-               RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_OPENSSL must be"
-                       " enabled in config file to run this testsuite.\n");
-               return TEST_FAILED;
-#endif
-               nb_devs = rte_cryptodev_count_devtype(
-                               RTE_CRYPTODEV_OPENSSL_PMD);
+       if (gbl_driver_id == rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
+               nb_devs = rte_cryptodev_device_count_by_driver(
+                               rte_cryptodev_driver_id_get(
+                               RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
                if (nb_devs < 1) {
                        ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
@@ -341,14 +325,11 @@ testsuite_setup(void)
        }
 
        /* Create a ARMv8 device if required */
-       if (gbl_cryptodev_type == RTE_CRYPTODEV_ARMV8_PMD) {
-#ifndef RTE_LIBRTE_PMD_ARMV8_CRYPTO
-               RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ARMV8_CRYPTO must be"
-                       " enabled in config file to run this testsuite.\n");
-               return TEST_FAILED;
-#endif
-               nb_devs = rte_cryptodev_count_devtype(
-                               RTE_CRYPTODEV_ARMV8_PMD);
+       if (gbl_driver_id == rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
+               nb_devs = rte_cryptodev_device_count_by_driver(
+                               rte_cryptodev_driver_id_get(
+                               RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
                if (nb_devs < 1) {
                        ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
@@ -361,15 +342,12 @@ testsuite_setup(void)
        }
 
 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
-       if (gbl_cryptodev_type == RTE_CRYPTODEV_SCHEDULER_PMD) {
+       if (gbl_driver_id == rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
 
-#ifndef RTE_LIBRTE_PMD_AESNI_MB
-               RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
-                       " enabled in config file to run this testsuite.\n");
-               return TEST_FAILED;
-#endif
-               nb_devs = rte_cryptodev_count_devtype(
-                               RTE_CRYPTODEV_SCHEDULER_PMD);
+               nb_devs = rte_cryptodev_device_count_by_driver(
+                               rte_cryptodev_driver_id_get(
+                               RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
                if (nb_devs < 1) {
                        ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
@@ -383,14 +361,6 @@ testsuite_setup(void)
        }
 #endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
 
-#ifndef RTE_LIBRTE_PMD_QAT
-       if (gbl_cryptodev_type == RTE_CRYPTODEV_QAT_SYM_PMD) {
-               RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled "
-                               "in config file to run this testsuite.\n");
-               return TEST_FAILED;
-       }
-#endif
-
        nb_devs = rte_cryptodev_count();
        if (nb_devs < 1) {
                RTE_LOG(ERR, USER1, "No crypto devices found?\n");
@@ -400,7 +370,7 @@ testsuite_setup(void)
        /* Create list of valid crypto devs */
        for (i = 0; i < nb_devs; i++) {
                rte_cryptodev_info_get(i, &info);
-               if (info.dev_type == gbl_cryptodev_type)
+               if (info.driver_id == gbl_driver_id)
                        ts_params->valid_devs[ts_params->valid_dev_count++] = i;
        }
 
@@ -415,7 +385,23 @@ testsuite_setup(void)
 
        ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
        ts_params->conf.socket_id = SOCKET_ID_ANY;
-       ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
+
+       unsigned int session_size = rte_cryptodev_get_private_session_size(dev_id);
+
+       /*
+        * Create mempool with maximum number of sessions * 2,
+        * to include the session headers
+        */
+       ts_params->session_mpool = rte_mempool_create(
+                               "test_sess_mp",
+                               info.sym.max_nb_sessions * 2,
+                               session_size,
+                               0, 0, NULL, NULL, NULL,
+                               NULL, SOCKET_ID_ANY,
+                               0);
+
+       TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
+                       "session mempool allocation failed");
 
        TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
                        &ts_params->conf),
@@ -427,7 +413,8 @@ testsuite_setup(void)
        for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
                TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
                        dev_id, qp_id, &ts_params->qp_conf,
-                       rte_cryptodev_socket_id(dev_id)),
+                       rte_cryptodev_socket_id(dev_id),
+                       ts_params->session_mpool),
                        "Failed to setup queue pair %u on cryptodev %u",
                        qp_id, dev_id);
        }
@@ -450,6 +437,11 @@ testsuite_teardown(void)
                rte_mempool_avail_count(ts_params->op_mpool));
        }
 
+       /* Free session mempools */
+       if (ts_params->session_mpool != NULL) {
+               rte_mempool_free(ts_params->session_mpool);
+               ts_params->session_mpool = NULL;
+       }
 }
 
 static int
@@ -465,7 +457,6 @@ ut_setup(void)
 
        /* Reconfigure device to default parameters */
        ts_params->conf.socket_id = SOCKET_ID_ANY;
-       ts_params->conf.session_mp.nb_objs = DEFAULT_NUM_OPS_INFLIGHT;
 
        TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
                        &ts_params->conf),
@@ -476,7 +467,8 @@ ut_setup(void)
                TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
                        ts_params->valid_devs[0], qp_id,
                        &ts_params->qp_conf,
-                       rte_cryptodev_socket_id(ts_params->valid_devs[0])),
+                       rte_cryptodev_socket_id(ts_params->valid_devs[0]),
+                       ts_params->session_mpool),
                        "Failed to setup queue pair %u on cryptodev %u",
                        qp_id, ts_params->valid_devs[0]);
        }
@@ -501,8 +493,9 @@ ut_teardown(void)
 
        /* free crypto session structure */
        if (ut_params->sess) {
-               rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
+               rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
                                ut_params->sess);
+               rte_cryptodev_sym_session_free(ut_params->sess);
                ut_params->sess = NULL;
        }
 
@@ -595,7 +588,8 @@ test_device_configure_invalid_queue_pair_ids(void)
        TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
                        &ts_params->conf),
                        "Failed to configure cryptodev: dev_id %u, qp_id %u",
-                       ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
+                       ts_params->valid_devs[0],
+                       ts_params->conf.nb_queue_pairs);
 
 
        /* invalid - zero queue pairs */
@@ -653,13 +647,11 @@ test_queue_pair_descriptor_setup(void)
 
        rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
-       ts_params->conf.session_mp.nb_objs = dev_info.sym.max_nb_sessions;
-
        TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
-                       &ts_params->conf), "Failed to configure cryptodev %u",
+                       &ts_params->conf),
+                       "Failed to configure cryptodev %u",
                        ts_params->valid_devs[0]);
 
-
        /*
         * Test various ring sizes on this device. memzones can't be
         * freed so are re-used if ring is released and re-created.
@@ -670,7 +662,8 @@ test_queue_pair_descriptor_setup(void)
                TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
                                ts_params->valid_devs[0], qp_id, &qp_conf,
                                rte_cryptodev_socket_id(
-                                               ts_params->valid_devs[0])),
+                                               ts_params->valid_devs[0]),
+                               ts_params->session_mpool),
                                "Failed test for "
                                "rte_cryptodev_queue_pair_setup: num_inflights "
                                "%u on qp %u on cryptodev %u",
@@ -684,7 +677,8 @@ test_queue_pair_descriptor_setup(void)
                TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
                                ts_params->valid_devs[0], qp_id, &qp_conf,
                                rte_cryptodev_socket_id(
-                                               ts_params->valid_devs[0])),
+                                               ts_params->valid_devs[0]),
+                               ts_params->session_mpool),
                                "Failed test for"
                                " rte_cryptodev_queue_pair_setup: num_inflights"
                                " %u on qp %u on cryptodev %u",
@@ -698,7 +692,8 @@ test_queue_pair_descriptor_setup(void)
                TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
                                ts_params->valid_devs[0], qp_id, &qp_conf,
                                rte_cryptodev_socket_id(
-                                               ts_params->valid_devs[0])),
+                                               ts_params->valid_devs[0]),
+                               ts_params->session_mpool),
                                "Failed test for "
                                "rte_cryptodev_queue_pair_setup: num_inflights"
                                " %u on qp %u on cryptodev %u",
@@ -713,7 +708,8 @@ test_queue_pair_descriptor_setup(void)
                TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
                                ts_params->valid_devs[0], qp_id, &qp_conf,
                                rte_cryptodev_socket_id(
-                                               ts_params->valid_devs[0])),
+                                               ts_params->valid_devs[0]),
+                               ts_params->session_mpool),
                                "Unexpectedly passed test for "
                                "rte_cryptodev_queue_pair_setup:"
                                "num_inflights %u on qp %u on cryptodev %u",
@@ -728,7 +724,8 @@ test_queue_pair_descriptor_setup(void)
                TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
                                ts_params->valid_devs[0], qp_id, &qp_conf,
                                rte_cryptodev_socket_id(
-                                               ts_params->valid_devs[0])),
+                                               ts_params->valid_devs[0]),
+                               ts_params->session_mpool),
                                "Unexpectedly passed test for "
                                "rte_cryptodev_queue_pair_setup:"
                                "num_inflights %u on qp %u on cryptodev %u",
@@ -742,7 +739,8 @@ test_queue_pair_descriptor_setup(void)
                TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
                                ts_params->valid_devs[0], qp_id, &qp_conf,
                                rte_cryptodev_socket_id(
-                                               ts_params->valid_devs[0])),
+                                               ts_params->valid_devs[0]),
+                               ts_params->session_mpool),
                                "Failed test for"
                                " rte_cryptodev_queue_pair_setup:"
                                "num_inflights %u on qp %u on cryptodev %u",
@@ -757,7 +755,8 @@ test_queue_pair_descriptor_setup(void)
                TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
                                ts_params->valid_devs[0], qp_id, &qp_conf,
                                rte_cryptodev_socket_id(
-                                               ts_params->valid_devs[0])),
+                                               ts_params->valid_devs[0]),
+                               ts_params->session_mpool),
                                "Unexpectedly passed test for "
                                "rte_cryptodev_queue_pair_setup:"
                                "num_inflights %u on qp %u on cryptodev %u",
@@ -773,7 +772,8 @@ test_queue_pair_descriptor_setup(void)
        TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
                        ts_params->valid_devs[0],
                        qp_id, &qp_conf,
-                       rte_cryptodev_socket_id(ts_params->valid_devs[0])),
+                       rte_cryptodev_socket_id(ts_params->valid_devs[0]),
+                       ts_params->session_mpool),
                        "Failed test for rte_cryptodev_queue_pair_setup:"
                        "invalid qp %u on cryptodev %u",
                        qp_id, ts_params->valid_devs[0]);
@@ -783,7 +783,8 @@ test_queue_pair_descriptor_setup(void)
        TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
                        ts_params->valid_devs[0],
                        qp_id, &qp_conf,
-                       rte_cryptodev_socket_id(ts_params->valid_devs[0])),
+                       rte_cryptodev_socket_id(ts_params->valid_devs[0]),
+                       ts_params->session_mpool),
                        "Failed test for rte_cryptodev_queue_pair_setup:"
                        "invalid qp %u on cryptodev %u",
                        qp_id, ts_params->valid_devs[0]);
@@ -1285,10 +1286,13 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
        ut_params->auth_xform.auth.key.data = hmac_sha1_key;
        ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
 
-       /* Create crypto session*/
        ut_params->sess = rte_cryptodev_sym_session_create(
-                       ts_params->valid_devs[0],
-                       &ut_params->cipher_xform);
+                       ts_params->session_mpool);
+
+       /* Create crypto session*/
+       rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+                       ut_params->sess, &ut_params->cipher_xform,
+                       ts_params->session_mpool);
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
        /* Generate crypto op data structure */
@@ -1308,7 +1312,6 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
        sym_op->auth.digest.data = ut_params->digest;
        sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                        ut_params->ibuf, QUOTE_512_BYTES);
-       sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA1;
 
        sym_op->auth.data.offset = 0;
        sym_op->auth.data.length = QUOTE_512_BYTES;
@@ -1341,7 +1344,8 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
 
        TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
                        catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
-                       gbl_cryptodev_type == RTE_CRYPTODEV_AESNI_MB_PMD ?
+                       gbl_driver_id == rte_cryptodev_driver_id_get(
+                                       RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
                                        TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
                                        DIGEST_BYTE_LENGTH_SHA1,
                        "Generated digest data not as expected");
@@ -1460,7 +1464,6 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
        sym_op->auth.digest.data = ut_params->digest;
        sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                        ut_params->ibuf, QUOTE_512_BYTES);
-       sym_op->auth.digest.length = DIGEST_BYTE_LENGTH_SHA512;
 
        sym_op->auth.data.offset = 0;
        sym_op->auth.data.length = QUOTE_512_BYTES;
@@ -1502,8 +1505,11 @@ test_AES_cipheronly_mb_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_AESNI_MB_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
                BLKCIPHER_AES_CIPHERONLY_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1518,8 +1524,11 @@ test_AES_docsis_mb_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_AESNI_MB_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
                BLKCIPHER_AES_DOCSIS_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1534,8 +1543,11 @@ test_AES_docsis_qat_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_QAT_SYM_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
                BLKCIPHER_AES_DOCSIS_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1550,8 +1562,11 @@ test_DES_docsis_qat_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_QAT_SYM_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
                BLKCIPHER_DES_DOCSIS_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1566,8 +1581,11 @@ test_authonly_mb_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_AESNI_MB_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
                BLKCIPHER_AUTHONLY_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1575,6 +1593,24 @@ test_authonly_mb_all(void)
        return TEST_SUCCESS;
 }
 
+static int
+test_authonly_qat_all(void)
+{
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
+       int status;
+
+       status = test_blockcipher_all_tests(ts_params->mbuf_pool,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
+               BLKCIPHER_AUTHONLY_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
 static int
 test_AES_chain_mb_all(void)
 {
@@ -1582,8 +1618,11 @@ test_AES_chain_mb_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_AESNI_MB_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
                BLKCIPHER_AES_CHAIN_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1600,8 +1639,11 @@ test_AES_cipheronly_scheduler_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_SCHEDULER_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
                BLKCIPHER_AES_CIPHERONLY_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1616,8 +1658,11 @@ test_AES_chain_scheduler_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_SCHEDULER_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
                BLKCIPHER_AES_CHAIN_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1632,8 +1677,11 @@ test_authonly_scheduler_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_SCHEDULER_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)),
                BLKCIPHER_AUTHONLY_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1650,8 +1698,11 @@ test_AES_chain_openssl_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_OPENSSL_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
                BLKCIPHER_AES_CHAIN_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1666,8 +1717,11 @@ test_AES_cipheronly_openssl_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_OPENSSL_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
                BLKCIPHER_AES_CIPHERONLY_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1682,8 +1736,11 @@ test_AES_chain_qat_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_QAT_SYM_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
                BLKCIPHER_AES_CHAIN_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1698,8 +1755,11 @@ test_AES_cipheronly_qat_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_QAT_SYM_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
                BLKCIPHER_AES_CIPHERONLY_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1714,8 +1774,11 @@ test_AES_chain_dpaa2_sec_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_DPAA2_SEC_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
                BLKCIPHER_AES_CHAIN_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1730,8 +1793,11 @@ test_AES_cipheronly_dpaa2_sec_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_DPAA2_SEC_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
                BLKCIPHER_AES_CIPHERONLY_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1739,6 +1805,25 @@ test_AES_cipheronly_dpaa2_sec_all(void)
        return TEST_SUCCESS;
 }
 
+static int
+test_authonly_dpaa2_sec_all(void)
+{
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
+       int status;
+
+       status = test_blockcipher_all_tests(ts_params->mbuf_pool,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
+               BLKCIPHER_AUTHONLY_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
 static int
 test_authonly_openssl_all(void)
 {
@@ -1746,8 +1831,11 @@ test_authonly_openssl_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_OPENSSL_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
                BLKCIPHER_AUTHONLY_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1762,8 +1850,11 @@ test_AES_chain_armv8_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_ARMV8_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)),
                BLKCIPHER_AES_CHAIN_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1781,6 +1872,7 @@ create_wireless_algo_hash_session(uint8_t dev_id,
 {
        uint8_t hash_key[key_len];
 
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
 
        memcpy(hash_key, key, key_len);
@@ -1798,8 +1890,11 @@ create_wireless_algo_hash_session(uint8_t dev_id,
        ut_params->auth_xform.auth.digest_length = auth_len;
        ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
        ut_params->auth_xform.auth.iv.length = iv_len;
-       ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
-                               &ut_params->auth_xform);
+       ut_params->sess = rte_cryptodev_sym_session_create(
+                       ts_params->session_mpool);
+
+       rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+                       &ut_params->auth_xform, ts_params->session_mpool);
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
        return 0;
 }
@@ -1813,6 +1908,7 @@ create_wireless_algo_cipher_session(uint8_t dev_id,
 {
        uint8_t cipher_key[key_len];
 
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
 
        memcpy(cipher_key, key, key_len);
@@ -1831,9 +1927,11 @@ create_wireless_algo_cipher_session(uint8_t dev_id,
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
        /* Create Crypto session */
-       ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
-                                               &ut_params->
-                                               cipher_xform);
+       ut_params->sess = rte_cryptodev_sym_session_create(
+                       ts_params->session_mpool);
+
+       rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+                       &ut_params->cipher_xform, ts_params->session_mpool);
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
        return 0;
 }
@@ -1912,6 +2010,7 @@ create_wireless_algo_cipher_auth_session(uint8_t dev_id,
 {
        uint8_t cipher_auth_key[key_len];
 
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
 
        memcpy(cipher_auth_key, key, key_len);
@@ -1944,8 +2043,11 @@ create_wireless_algo_cipher_auth_session(uint8_t dev_id,
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
        /* Create Crypto session*/
-       ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
-                               &ut_params->cipher_xform);
+       ut_params->sess = rte_cryptodev_sym_session_create(
+                       ts_params->session_mpool);
+
+       rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+                       &ut_params->cipher_xform, ts_params->session_mpool);
 
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
        return 0;
@@ -1962,6 +2064,7 @@ create_wireless_cipher_auth_session(uint8_t dev_id,
        const uint8_t key_len = tdata->key.len;
        uint8_t cipher_auth_key[key_len];
 
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
        const uint8_t *key = tdata->key.data;
        const uint8_t auth_len = tdata->digest.len;
@@ -1999,8 +2102,11 @@ create_wireless_cipher_auth_session(uint8_t dev_id,
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
        /* Create Crypto session*/
-       ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
-                               &ut_params->cipher_xform);
+       ut_params->sess = rte_cryptodev_sym_session_create(
+                       ts_params->session_mpool);
+
+       rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+                       &ut_params->cipher_xform, ts_params->session_mpool);
 
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
        return 0;
@@ -2028,6 +2134,7 @@ create_wireless_algo_auth_cipher_session(uint8_t dev_id,
 {
        uint8_t auth_cipher_key[key_len];
 
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
 
        memcpy(auth_cipher_key, key, key_len);
@@ -2057,8 +2164,11 @@ create_wireless_algo_auth_cipher_session(uint8_t dev_id,
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
        /* Create Crypto session*/
-       ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
-                               &ut_params->auth_xform);
+       ut_params->sess = rte_cryptodev_sym_session_create(
+                       ts_params->session_mpool);
+
+       rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+                       &ut_params->auth_xform, ts_params->session_mpool);
 
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
@@ -2103,7 +2213,6 @@ create_wireless_algo_hash_operation(const uint8_t *auth_tag,
        ut_params->digest = sym_op->auth.digest.data;
        sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                        ut_params->ibuf, data_pad_len);
-       sym_op->auth.digest.length = auth_tag_len;
        if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
                memset(sym_op->auth.digest.data, 0, auth_tag_len);
        else
@@ -2111,7 +2220,7 @@ create_wireless_algo_hash_operation(const uint8_t *auth_tag,
 
        TEST_HEXDUMP(stdout, "digest:",
                sym_op->auth.digest.data,
-               sym_op->auth.digest.length);
+               auth_tag_len);
 
        sym_op->auth.data.length = auth_len;
        sym_op->auth.data.offset = auth_offset;
@@ -2160,7 +2269,6 @@ create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
        ut_params->digest = sym_op->auth.digest.data;
        sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                        ut_params->ibuf, data_pad_len);
-       sym_op->auth.digest.length = auth_tag_len;
        if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
                memset(sym_op->auth.digest.data, 0, auth_tag_len);
        else
@@ -2168,7 +2276,7 @@ create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
 
        TEST_HEXDUMP(stdout, "digest:",
                sym_op->auth.digest.data,
-               sym_op->auth.digest.length);
+               auth_tag_len);
 
        /* Copy cipher and auth IVs at the end of the crypto operation */
        uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
@@ -2228,7 +2336,6 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
        ut_params->digest = sym_op->auth.digest.data;
        sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                        ut_params->ibuf, data_pad_len);
-       sym_op->auth.digest.length = auth_tag_len;
        if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
                memset(sym_op->auth.digest.data, 0, auth_tag_len);
        else
@@ -2236,7 +2343,7 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
 
        TEST_HEXDUMP(stdout, "digest:",
                sym_op->auth.digest.data,
-               sym_op->auth.digest.length);
+               auth_tag_len);
 
        /* Copy cipher and auth IVs at the end of the crypto operation */
        uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
@@ -2246,9 +2353,9 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
        rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
 
        sym_op->cipher.data.length = cipher_len;
-       sym_op->cipher.data.offset = cipher_offset + auth_offset;
+       sym_op->cipher.data.offset = cipher_offset;
        sym_op->auth.data.length = auth_len;
-       sym_op->auth.data.offset = auth_offset + cipher_offset;
+       sym_op->auth.data.offset = auth_offset;
 
        return 0;
 }
@@ -2287,13 +2394,12 @@ create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len,
 
        sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                        ut_params->ibuf, data_pad_len);
-       sym_op->auth.digest.length = auth_tag_len;
 
        memset(sym_op->auth.digest.data, 0, auth_tag_len);
 
        TEST_HEXDUMP(stdout, "digest:",
                        sym_op->auth.digest.data,
-                       sym_op->auth.digest.length);
+                       auth_tag_len);
 
        /* Copy cipher and auth IVs at the end of the crypto operation */
        uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
@@ -2303,10 +2409,10 @@ create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len,
        rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
 
        sym_op->cipher.data.length = cipher_len;
-       sym_op->cipher.data.offset = auth_offset + cipher_offset;
+       sym_op->cipher.data.offset = cipher_offset;
 
        sym_op->auth.data.length = auth_len;
-       sym_op->auth.data.offset = auth_offset + cipher_offset;
+       sym_op->auth.data.offset = auth_offset;
 
        return 0;
 }
@@ -2445,7 +2551,7 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
        /* Create KASUMI session */
        retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
                        tdata->key.data, tdata->key.len,
-                       tdata->auth_iv.len, tdata->digest.len,
+                       0, tdata->digest.len,
                        RTE_CRYPTO_AUTH_OP_GENERATE,
                        RTE_CRYPTO_AUTH_KASUMI_F9);
        if (retval < 0)
@@ -2467,9 +2573,9 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
 
        /* Create KASUMI operation */
        retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
-                       tdata->auth_iv.data, tdata->auth_iv.len,
+                       NULL, 0,
                        plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
-                       tdata->validAuthLenInBits.len,
+                       tdata->plaintext.len,
                        0);
        if (retval < 0)
                return retval;
@@ -2505,7 +2611,7 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
        /* Create KASUMI session */
        retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
                                tdata->key.data, tdata->key.len,
-                               tdata->auth_iv.len, tdata->digest.len,
+                               0, tdata->digest.len,
                                RTE_CRYPTO_AUTH_OP_VERIFY,
                                RTE_CRYPTO_AUTH_KASUMI_F9);
        if (retval < 0)
@@ -2527,10 +2633,10 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
        /* Create KASUMI operation */
        retval = create_wireless_algo_hash_operation(tdata->digest.data,
                        tdata->digest.len,
-                       tdata->auth_iv.data, tdata->auth_iv.len,
+                       NULL, 0,
                        plaintext_pad_len,
                        RTE_CRYPTO_AUTH_OP_VERIFY,
-                       tdata->validAuthLenInBits.len,
+                       tdata->plaintext.len,
                        0);
        if (retval < 0)
                return retval;
@@ -2728,9 +2834,9 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
 
        /* Create KASUMI operation */
        retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
-                                       tdata->cipher_iv.len,
-                                       tdata->plaintext.len,
-                                       0);
+                               tdata->cipher_iv.len,
+                               RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
+                               tdata->validCipherOffsetInBits.len);
        if (retval < 0)
                return retval;
 
@@ -2742,14 +2848,16 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
        if (ut_params->obuf)
                ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
-               ciphertext = plaintext;
+               ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
 
        TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
 
+       const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+                               (tdata->validCipherOffsetInBits.len >> 3);
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
                ciphertext,
-               tdata->ciphertext.data,
+               reference_ciphertext,
                tdata->validCipherLenInBits.len,
                "KASUMI Ciphertext data not as expected");
        return 0;
@@ -2801,9 +2909,9 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
 
        /* Create KASUMI operation */
        retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
-                                       tdata->cipher_iv.len,
-                                       tdata->plaintext.len,
-                                       0);
+                               tdata->cipher_iv.len,
+                               RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
+                               tdata->validCipherOffsetInBits.len);
        if (retval < 0)
                return retval;
 
@@ -2817,19 +2925,22 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
                ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
                                plaintext_len, buffer);
        else
-               ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
+               ciphertext = rte_pktmbuf_read(ut_params->ibuf,
+                               tdata->validCipherOffsetInBits.len >> 3,
                                plaintext_len, buffer);
 
        /* Validate obuf */
        TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
 
-               /* Validate obuf */
-               TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
-                       ciphertext,
-                       tdata->ciphertext.data,
-                       tdata->validCipherLenInBits.len,
-                       "KASUMI Ciphertext data not as expected");
-               return 0;
+       const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+                               (tdata->validCipherOffsetInBits.len >> 3);
+       /* Validate obuf */
+       TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+               ciphertext,
+               reference_ciphertext,
+               tdata->validCipherLenInBits.len,
+               "KASUMI Ciphertext data not as expected");
+       return 0;
 }
 
 static int
@@ -2872,9 +2983,9 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
 
        /* Create KASUMI operation */
        retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
-                                       tdata->cipher_iv.len,
-                                       tdata->plaintext.len,
-                                       0);
+                               tdata->cipher_iv.len,
+                               RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
+                               tdata->validCipherOffsetInBits.len);
        if (retval < 0)
                return retval;
 
@@ -2886,14 +2997,16 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
        if (ut_params->obuf)
                ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
-               ciphertext = plaintext;
+               ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
 
        TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
 
+       const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+                               (tdata->validCipherOffsetInBits.len >> 3);
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
                ciphertext,
-               tdata->ciphertext.data,
+               reference_ciphertext,
                tdata->validCipherLenInBits.len,
                "KASUMI Ciphertext data not as expected");
        return 0;
@@ -2946,9 +3059,9 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
 
        /* Create KASUMI operation */
        retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
-                                       tdata->cipher_iv.len,
-                                       tdata->plaintext.len,
-                                       0);
+                               tdata->cipher_iv.len,
+                               RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
+                               tdata->validCipherOffsetInBits.len);
        if (retval < 0)
                return retval;
 
@@ -2961,13 +3074,16 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
                ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
                                plaintext_pad_len, buffer);
        else
-               ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
+               ciphertext = rte_pktmbuf_read(ut_params->ibuf,
+                               tdata->validCipherOffsetInBits.len >> 3,
                                plaintext_pad_len, buffer);
 
+       const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+                               (tdata->validCipherOffsetInBits.len >> 3);
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
                ciphertext,
-               tdata->ciphertext.data,
+               reference_ciphertext,
                tdata->validCipherLenInBits.len,
                "KASUMI Ciphertext data not as expected");
        return 0;
@@ -3014,9 +3130,9 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
 
        /* Create KASUMI operation */
        retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
-                                       tdata->cipher_iv.len,
-                                       tdata->ciphertext.len,
-                                       0);
+                               tdata->cipher_iv.len,
+                               RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
+                               tdata->validCipherOffsetInBits.len);
        if (retval < 0)
                return retval;
 
@@ -3028,14 +3144,16 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
        if (ut_params->obuf)
                plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
-               plaintext = ciphertext;
+               plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
 
        TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
 
+       const uint8_t *reference_plaintext = tdata->plaintext.data +
+                               (tdata->validCipherOffsetInBits.len >> 3);
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
                plaintext,
-               tdata->plaintext.data,
+               reference_plaintext,
                tdata->validCipherLenInBits.len,
                "KASUMI Plaintext data not as expected");
        return 0;
@@ -3081,7 +3199,7 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
                                        tdata->cipher_iv.len,
                                        tdata->ciphertext.len,
-                                       0);
+                                       tdata->validCipherOffsetInBits.len);
        if (retval < 0)
                return retval;
 
@@ -3093,14 +3211,16 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
        if (ut_params->obuf)
                plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
        else
-               plaintext = ciphertext;
+               plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
 
        TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
 
+       const uint8_t *reference_plaintext = tdata->plaintext.data +
+                               (tdata->validCipherOffsetInBits.len >> 3);
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
                plaintext,
-               tdata->plaintext.data,
+               reference_plaintext,
                tdata->validCipherLenInBits.len,
                "KASUMI Plaintext data not as expected");
        return 0;
@@ -3841,7 +3961,7 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
                        RTE_CRYPTO_AUTH_KASUMI_F9,
                        RTE_CRYPTO_CIPHER_KASUMI_F8,
                        tdata->key.data, tdata->key.len,
-                       tdata->auth_iv.len, tdata->digest.len,
+                       0, tdata->digest.len,
                        tdata->cipher_iv.len);
        if (retval < 0)
                return retval;
@@ -3864,10 +3984,10 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
        /* Create KASUMI operation */
        retval = create_wireless_algo_auth_cipher_operation(tdata->digest.len,
                                tdata->cipher_iv.data, tdata->cipher_iv.len,
-                               tdata->auth_iv.data, tdata->auth_iv.len,
+                               NULL, 0,
                                plaintext_pad_len,
                                tdata->validCipherLenInBits.len,
-                               0,
+                               tdata->validCipherOffsetInBits.len,
                                tdata->validAuthLenInBits.len,
                                0
                                );
@@ -3878,19 +3998,23 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
        ut_params->op = process_crypto_request(ts_params->valid_devs[0],
                        ut_params->op);
        TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-       ut_params->obuf = ut_params->op->sym->m_src;
-       if (ut_params->obuf)
-               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+       if (ut_params->op->sym->m_dst)
+               ut_params->obuf = ut_params->op->sym->m_dst;
        else
-               ciphertext = plaintext;
+               ut_params->obuf = ut_params->op->sym->m_src;
+
+       ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
+                               tdata->validCipherOffsetInBits.len >> 3);
 
+       const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+                               (tdata->validCipherOffsetInBits.len >> 3);
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
                        ciphertext,
-                       tdata->ciphertext.data,
+                       reference_ciphertext,
                        tdata->validCipherLenInBits.len,
                        "KASUMI Ciphertext data not as expected");
-       ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
+       ut_params->digest = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *)
            + plaintext_pad_len;
 
        /* Validate obuf */
@@ -3922,7 +4046,7 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
                        RTE_CRYPTO_AUTH_KASUMI_F9,
                        RTE_CRYPTO_CIPHER_KASUMI_F8,
                        tdata->key.data, tdata->key.len,
-                       tdata->auth_iv.len, tdata->digest.len,
+                       0, tdata->digest.len,
                        tdata->cipher_iv.len);
        if (retval < 0)
                return retval;
@@ -3945,12 +4069,11 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
 
        /* Create KASUMI operation */
        retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
-                               tdata->digest.len, tdata->auth_iv.data,
-                               tdata->auth_iv.len,
+                               tdata->digest.len, NULL, 0,
                                plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
                                tdata->cipher_iv.data, tdata->cipher_iv.len,
-                               tdata->validCipherLenInBits.len,
-                               0,
+                               RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
+                               tdata->validCipherOffsetInBits.len,
                                tdata->validAuthLenInBits.len,
                                0
                                );
@@ -3960,19 +4083,24 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
        ut_params->op = process_crypto_request(ts_params->valid_devs[0],
                        ut_params->op);
        TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
-       ut_params->obuf = ut_params->op->sym->m_src;
-       if (ut_params->obuf)
-               ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
+
+       if (ut_params->op->sym->m_dst)
+               ut_params->obuf = ut_params->op->sym->m_dst;
        else
-               ciphertext = plaintext;
+               ut_params->obuf = ut_params->op->sym->m_src;
+
+       ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
+                               tdata->validCipherOffsetInBits.len >> 3);
 
        ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
                        + plaintext_pad_len;
 
+       const uint8_t *reference_ciphertext = tdata->ciphertext.data +
+                               (tdata->validCipherOffsetInBits.len >> 3);
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
                ciphertext,
-               tdata->ciphertext.data,
+               reference_ciphertext,
                tdata->validCipherLenInBits.len,
                "KASUMI Ciphertext data not as expected");
 
@@ -4512,8 +4640,11 @@ test_3DES_chain_qat_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_QAT_SYM_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
                BLKCIPHER_3DES_CHAIN_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -4528,8 +4659,30 @@ test_DES_cipheronly_qat_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_QAT_SYM_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
+               BLKCIPHER_DES_CIPHERONLY_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
+static int
+test_DES_cipheronly_openssl_all(void)
+{
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
+       int status;
+
+       status = test_blockcipher_all_tests(ts_params->mbuf_pool,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
                BLKCIPHER_DES_CIPHERONLY_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -4544,8 +4697,49 @@ test_DES_docsis_openssl_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_OPENSSL_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
+               BLKCIPHER_DES_DOCSIS_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
+static int
+test_DES_cipheronly_mb_all(void)
+{
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
+       int status;
+
+       status = test_blockcipher_all_tests(ts_params->mbuf_pool,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
+               BLKCIPHER_DES_CIPHERONLY_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
+static int
+test_DES_docsis_mb_all(void)
+{
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
+       int status;
+
+       status = test_blockcipher_all_tests(ts_params->mbuf_pool,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)),
                BLKCIPHER_DES_DOCSIS_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -4560,8 +4754,11 @@ test_3DES_chain_dpaa2_sec_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_DPAA2_SEC_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
                BLKCIPHER_3DES_CHAIN_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -4576,8 +4773,11 @@ test_3DES_cipheronly_dpaa2_sec_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_DPAA2_SEC_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
                BLKCIPHER_3DES_CIPHERONLY_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -4592,8 +4792,11 @@ test_3DES_cipheronly_qat_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_QAT_SYM_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD)),
                BLKCIPHER_3DES_CIPHERONLY_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -4608,8 +4811,11 @@ test_3DES_chain_openssl_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_OPENSSL_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
                BLKCIPHER_3DES_CHAIN_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -4624,8 +4830,11 @@ test_3DES_cipheronly_openssl_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
-               RTE_CRYPTODEV_OPENSSL_PMD,
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
+               rte_cryptodev_driver_id_get(
+               RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)),
                BLKCIPHER_3DES_CIPHERONLY_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -4633,57 +4842,42 @@ test_3DES_cipheronly_openssl_all(void)
        return TEST_SUCCESS;
 }
 
-/* ***** AES-GCM Tests ***** */
+/* ***** AEAD algorithm Tests ***** */
 
 static int
-create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op,
+create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
+               enum rte_crypto_aead_operation op,
                const uint8_t *key, const uint8_t key_len,
                const uint16_t aad_len, const uint8_t auth_len,
-               uint8_t iv_len,
-               enum rte_crypto_auth_operation auth_op)
+               uint8_t iv_len)
 {
-       uint8_t cipher_key[key_len];
+       uint8_t aead_key[key_len];
 
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
 
-       memcpy(cipher_key, key, key_len);
-
-       /* Setup Cipher Parameters */
-       ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-       ut_params->cipher_xform.next = NULL;
+       memcpy(aead_key, key, key_len);
 
-       ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
-       ut_params->auth_xform.auth.op = auth_op;
-       ut_params->cipher_xform.cipher.op = op;
-       ut_params->cipher_xform.cipher.key.data = cipher_key;
-       ut_params->cipher_xform.cipher.key.length = key_len;
-       ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
-       ut_params->cipher_xform.cipher.iv.length = iv_len;
+       /* Setup AEAD Parameters */
+       ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
+       ut_params->aead_xform.next = NULL;
+       ut_params->aead_xform.aead.algo = algo;
+       ut_params->aead_xform.aead.op = op;
+       ut_params->aead_xform.aead.key.data = aead_key;
+       ut_params->aead_xform.aead.key.length = key_len;
+       ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
+       ut_params->aead_xform.aead.iv.length = iv_len;
+       ut_params->aead_xform.aead.digest_length = auth_len;
+       ut_params->aead_xform.aead.aad_length = aad_len;
 
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
-       /* Setup Authentication Parameters */
-       ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
-       ut_params->auth_xform.next = NULL;
-
-       ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
-
-       ut_params->auth_xform.auth.digest_length = auth_len;
-       ut_params->auth_xform.auth.add_auth_data_length = aad_len;
-       ut_params->auth_xform.auth.key.length = 0;
-       ut_params->auth_xform.auth.key.data = NULL;
-
-       if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
-               ut_params->cipher_xform.next = &ut_params->auth_xform;
+       /* Create Crypto session*/
+       ut_params->sess = rte_cryptodev_sym_session_create(
+                       ts_params->session_mpool);
 
-               /* Create Crypto session*/
-               ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
-                               &ut_params->cipher_xform);
-       } else {/* Create Crypto session*/
-               ut_params->auth_xform.next = &ut_params->cipher_xform;
-               ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
-                               &ut_params->auth_xform);
-       }
+       rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+                       &ut_params->aead_xform, ts_params->session_mpool);
 
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
@@ -4691,45 +4885,38 @@ create_gcm_session(uint8_t dev_id, enum rte_crypto_cipher_operation op,
 }
 
 static int
-create_gcm_xforms(struct rte_crypto_op *op,
-               enum rte_crypto_cipher_operation cipher_op,
+create_aead_xform(struct rte_crypto_op *op,
+               enum rte_crypto_aead_algorithm algo,
+               enum rte_crypto_aead_operation aead_op,
                uint8_t *key, const uint8_t key_len,
                const uint8_t aad_len, const uint8_t auth_len,
-               uint8_t iv_len,
-               enum rte_crypto_auth_operation auth_op)
+               uint8_t iv_len)
 {
-       TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 2),
-                       "failed to allocate space for crypto transforms");
+       TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
+                       "failed to allocate space for crypto transform");
 
        struct rte_crypto_sym_op *sym_op = op->sym;
 
-       /* Setup Cipher Parameters */
-       sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-       sym_op->xform->cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
-       sym_op->xform->cipher.op = cipher_op;
-       sym_op->xform->cipher.key.data = key;
-       sym_op->xform->cipher.key.length = key_len;
-       sym_op->xform->cipher.iv.offset = IV_OFFSET;
-       sym_op->xform->cipher.iv.length = iv_len;
+       /* Setup AEAD Parameters */
+       sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
+       sym_op->xform->next = NULL;
+       sym_op->xform->aead.algo = algo;
+       sym_op->xform->aead.op = aead_op;
+       sym_op->xform->aead.key.data = key;
+       sym_op->xform->aead.key.length = key_len;
+       sym_op->xform->aead.iv.offset = IV_OFFSET;
+       sym_op->xform->aead.iv.length = iv_len;
+       sym_op->xform->aead.digest_length = auth_len;
+       sym_op->xform->aead.aad_length = aad_len;
 
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
-       /* Setup Authentication Parameters */
-       sym_op->xform->next->type = RTE_CRYPTO_SYM_XFORM_AUTH;
-       sym_op->xform->next->auth.algo = RTE_CRYPTO_AUTH_AES_GCM;
-       sym_op->xform->next->auth.op = auth_op;
-       sym_op->xform->next->auth.digest_length = auth_len;
-       sym_op->xform->next->auth.add_auth_data_length = aad_len;
-       sym_op->xform->next->auth.key.length = 0;
-       sym_op->xform->next->auth.key.data = NULL;
-       sym_op->xform->next->next = NULL;
-
        return 0;
 }
 
 static int
-create_gcm_operation(enum rte_crypto_cipher_operation op,
-               const struct gcm_test_data *tdata)
+create_aead_operation(enum rte_crypto_aead_operation op,
+               const struct aead_test_data *tdata)
 {
        struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
@@ -4746,28 +4933,52 @@ create_gcm_operation(enum rte_crypto_cipher_operation op,
        struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
        /* Append aad data */
-       aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
-       sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-                       aad_pad_len);
-       TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
-                       "no room to append aad");
-
-       sym_op->auth.aad.phys_addr =
-                       rte_pktmbuf_mtophys(ut_params->ibuf);
-       memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len);
-       TEST_HEXDUMP(stdout, "aad:", sym_op->auth.aad.data,
-               tdata->aad.len);
-
-       /* Append IV at the end of the crypto operation*/
-       uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
-                       uint8_t *, IV_OFFSET);
-
-       rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
-       TEST_HEXDUMP(stdout, "iv:", iv_ptr,
-               tdata->iv.len);
+       if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
+               aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
+               sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+                               aad_pad_len);
+               TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
+                               "no room to append aad");
+
+               sym_op->aead.aad.phys_addr =
+                               rte_pktmbuf_mtophys(ut_params->ibuf);
+               /* Copy AAD 18 bytes after the AAD pointer, according to the API */
+               memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
+               TEST_HEXDUMP(stdout, "aad:", sym_op->aead.aad.data,
+                       tdata->aad.len);
+
+               /* Append IV at the end of the crypto operation*/
+               uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
+                               uint8_t *, IV_OFFSET);
+
+               /* Copy IV 1 byte after the IV pointer, according to the API */
+               rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
+               TEST_HEXDUMP(stdout, "iv:", iv_ptr,
+                       tdata->iv.len);
+       } else {
+               aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
+               sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+                               aad_pad_len);
+               TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
+                               "no room to append aad");
+
+               sym_op->aead.aad.phys_addr =
+                               rte_pktmbuf_mtophys(ut_params->ibuf);
+               memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
+               TEST_HEXDUMP(stdout, "aad:", sym_op->aead.aad.data,
+                       tdata->aad.len);
+
+               /* Append IV at the end of the crypto operation*/
+               uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
+                               uint8_t *, IV_OFFSET);
+
+               rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
+               TEST_HEXDUMP(stdout, "iv:", iv_ptr,
+                       tdata->iv.len);
+       }
 
        /* Append plaintext/ciphertext */
-       if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
+       if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
                plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
                plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
                                plaintext_pad_len);
@@ -4812,48 +5023,43 @@ create_gcm_operation(enum rte_crypto_cipher_operation op,
        }
 
        /* Append digest data */
-       if (op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
-               sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
+       if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
+               sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
                                ut_params->obuf ? ut_params->obuf :
                                                ut_params->ibuf,
                                                tdata->auth_tag.len);
-               TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+               TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
                                "no room to append digest");
-               memset(sym_op->auth.digest.data, 0, tdata->auth_tag.len);
-               sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+               memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
+               sym_op->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                                ut_params->obuf ? ut_params->obuf :
                                                ut_params->ibuf,
                                                plaintext_pad_len +
                                                aad_pad_len);
-               sym_op->auth.digest.length = tdata->auth_tag.len;
        } else {
-               sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
+               sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
                                ut_params->ibuf, tdata->auth_tag.len);
-               TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+               TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
                                "no room to append digest");
-               sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+               sym_op->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                                ut_params->ibuf,
                                plaintext_pad_len + aad_pad_len);
-               sym_op->auth.digest.length = tdata->auth_tag.len;
 
-               rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data,
+               rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
                        tdata->auth_tag.len);
                TEST_HEXDUMP(stdout, "digest:",
-                       sym_op->auth.digest.data,
-                       sym_op->auth.digest.length);
+                       sym_op->aead.digest.data,
+                       tdata->auth_tag.len);
        }
 
-       sym_op->cipher.data.length = tdata->plaintext.len;
-       sym_op->cipher.data.offset = aad_pad_len;
-
-       sym_op->auth.data.length = tdata->plaintext.len;
-       sym_op->auth.data.offset = aad_pad_len;
+       sym_op->aead.data.length = tdata->plaintext.len;
+       sym_op->aead.data.offset = aad_pad_len;
 
        return 0;
 }
 
 static int
-test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
+test_authenticated_encryption(const struct aead_test_data *tdata)
 {
        struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
@@ -4863,20 +5069,20 @@ test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
        uint16_t plaintext_pad_len;
        uint32_t i;
 
-       /* Create GCM session */
-       retval = create_gcm_session(ts_params->valid_devs[0],
-                       RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+       /* Create AEAD session */
+       retval = create_aead_session(ts_params->valid_devs[0],
+                       tdata->algo,
+                       RTE_CRYPTO_AEAD_OP_ENCRYPT,
                        tdata->key.data, tdata->key.len,
                        tdata->aad.len, tdata->auth_tag.len,
-                       tdata->iv.len,
-                       RTE_CRYPTO_AUTH_OP_GENERATE);
+                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
        if (tdata->aad.len > MBUF_SIZE) {
                ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
                /* Populate full size of add data */
-               for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32)
+               for (i = 32; i < MAX_AAD_LENGTH; i += 32)
                        memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
        } else
                ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
@@ -4885,8 +5091,8 @@ test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
        memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
                        rte_pktmbuf_tailroom(ut_params->ibuf));
 
-       /* Create GCM operation */
-       retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata);
+       /* Create AEAD operation */
+       retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
        if (retval < 0)
                return retval;
 
@@ -4923,139 +5129,181 @@ test_mb_AES_GCM_authenticated_encryption(const struct gcm_test_data *tdata)
                        ciphertext,
                        tdata->ciphertext.data,
                        tdata->ciphertext.len,
-                       "GCM Ciphertext data not as expected");
+                       "Ciphertext data not as expected");
 
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
                        auth_tag,
                        tdata->auth_tag.data,
                        tdata->auth_tag.len,
-                       "GCM Generated auth tag not as expected");
+                       "Generated auth tag not as expected");
 
        return 0;
 
 }
 
 static int
-test_mb_AES_GCM_authenticated_encryption_test_case_1(void)
+test_AES_GCM_authenticated_encryption_test_case_1(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_1);
+       return test_authenticated_encryption(&gcm_test_case_1);
 }
 
 static int
-test_mb_AES_GCM_authenticated_encryption_test_case_2(void)
+test_AES_GCM_authenticated_encryption_test_case_2(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_2);
+       return test_authenticated_encryption(&gcm_test_case_2);
 }
 
 static int
-test_mb_AES_GCM_authenticated_encryption_test_case_3(void)
+test_AES_GCM_authenticated_encryption_test_case_3(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_3);
+       return test_authenticated_encryption(&gcm_test_case_3);
 }
 
 static int
-test_mb_AES_GCM_authenticated_encryption_test_case_4(void)
+test_AES_GCM_authenticated_encryption_test_case_4(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_4);
+       return test_authenticated_encryption(&gcm_test_case_4);
 }
 
 static int
-test_mb_AES_GCM_authenticated_encryption_test_case_5(void)
+test_AES_GCM_authenticated_encryption_test_case_5(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_5);
+       return test_authenticated_encryption(&gcm_test_case_5);
 }
 
 static int
-test_mb_AES_GCM_authenticated_encryption_test_case_6(void)
+test_AES_GCM_authenticated_encryption_test_case_6(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_6);
+       return test_authenticated_encryption(&gcm_test_case_6);
 }
 
 static int
-test_mb_AES_GCM_authenticated_encryption_test_case_7(void)
+test_AES_GCM_authenticated_encryption_test_case_7(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_7);
+       return test_authenticated_encryption(&gcm_test_case_7);
 }
 
 static int
-test_mb_AES_GCM_auth_encryption_test_case_256_1(void)
+test_AES_GCM_auth_encryption_test_case_192_1(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_1);
+       return test_authenticated_encryption(&gcm_test_case_192_1);
 }
 
 static int
-test_mb_AES_GCM_auth_encryption_test_case_256_2(void)
+test_AES_GCM_auth_encryption_test_case_192_2(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_2);
+       return test_authenticated_encryption(&gcm_test_case_192_2);
 }
 
 static int
-test_mb_AES_GCM_auth_encryption_test_case_256_3(void)
+test_AES_GCM_auth_encryption_test_case_192_3(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_3);
+       return test_authenticated_encryption(&gcm_test_case_192_3);
 }
 
 static int
-test_mb_AES_GCM_auth_encryption_test_case_256_4(void)
+test_AES_GCM_auth_encryption_test_case_192_4(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_4);
+       return test_authenticated_encryption(&gcm_test_case_192_4);
 }
 
 static int
-test_mb_AES_GCM_auth_encryption_test_case_256_5(void)
+test_AES_GCM_auth_encryption_test_case_192_5(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_5);
+       return test_authenticated_encryption(&gcm_test_case_192_5);
 }
 
 static int
-test_mb_AES_GCM_auth_encryption_test_case_256_6(void)
+test_AES_GCM_auth_encryption_test_case_192_6(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_6);
+       return test_authenticated_encryption(&gcm_test_case_192_6);
 }
 
 static int
-test_mb_AES_GCM_auth_encryption_test_case_256_7(void)
+test_AES_GCM_auth_encryption_test_case_192_7(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_256_7);
+       return test_authenticated_encryption(&gcm_test_case_192_7);
 }
 
 static int
-test_mb_AES_GCM_auth_encryption_test_case_aad_1(void)
+test_AES_GCM_auth_encryption_test_case_256_1(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_aad_1);
+       return test_authenticated_encryption(&gcm_test_case_256_1);
 }
 
 static int
-test_mb_AES_GCM_auth_encryption_test_case_aad_2(void)
+test_AES_GCM_auth_encryption_test_case_256_2(void)
 {
-       return test_mb_AES_GCM_authenticated_encryption(&gcm_test_case_aad_2);
+       return test_authenticated_encryption(&gcm_test_case_256_2);
 }
 
 static int
-test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
+test_AES_GCM_auth_encryption_test_case_256_3(void)
 {
-       struct crypto_testsuite_params *ts_params = &testsuite_params;
-       struct crypto_unittest_params *ut_params = &unittest_params;
+       return test_authenticated_encryption(&gcm_test_case_256_3);
+}
 
-       int retval;
-       uint8_t *plaintext;
-       uint32_t i;
+static int
+test_AES_GCM_auth_encryption_test_case_256_4(void)
+{
+       return test_authenticated_encryption(&gcm_test_case_256_4);
+}
 
-       /* Create GCM session */
-       retval = create_gcm_session(ts_params->valid_devs[0],
-                       RTE_CRYPTO_CIPHER_OP_DECRYPT,
-                       tdata->key.data, tdata->key.len,
-                       tdata->aad.len, tdata->auth_tag.len,
-                       tdata->iv.len,
-                       RTE_CRYPTO_AUTH_OP_VERIFY);
-       if (retval < 0)
+static int
+test_AES_GCM_auth_encryption_test_case_256_5(void)
+{
+       return test_authenticated_encryption(&gcm_test_case_256_5);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_256_6(void)
+{
+       return test_authenticated_encryption(&gcm_test_case_256_6);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_256_7(void)
+{
+       return test_authenticated_encryption(&gcm_test_case_256_7);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_aad_1(void)
+{
+       return test_authenticated_encryption(&gcm_test_case_aad_1);
+}
+
+static int
+test_AES_GCM_auth_encryption_test_case_aad_2(void)
+{
+       return test_authenticated_encryption(&gcm_test_case_aad_2);
+}
+
+static int
+test_authenticated_decryption(const struct aead_test_data *tdata)
+{
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
+       struct crypto_unittest_params *ut_params = &unittest_params;
+
+       int retval;
+       uint8_t *plaintext;
+       uint32_t i;
+
+       /* Create AEAD session */
+       retval = create_aead_session(ts_params->valid_devs[0],
+                       tdata->algo,
+                       RTE_CRYPTO_AEAD_OP_DECRYPT,
+                       tdata->key.data, tdata->key.len,
+                       tdata->aad.len, tdata->auth_tag.len,
+                       tdata->iv.len);
+       if (retval < 0)
                return retval;
 
        /* alloc mbuf and set payload */
        if (tdata->aad.len > MBUF_SIZE) {
                ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
                /* Populate full size of add data */
-               for (i = 32; i < GCM_MAX_AAD_LENGTH; i += 32)
+               for (i = 32; i < MAX_AAD_LENGTH; i += 32)
                        memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
        } else
                ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
@@ -5063,8 +5311,8 @@ test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
        memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
                        rte_pktmbuf_tailroom(ut_params->ibuf));
 
-       /* Create GCM operation */
-       retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata);
+       /* Create AEAD operation */
+       retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
        if (retval < 0)
                return retval;
 
@@ -5094,112 +5342,154 @@ test_mb_AES_GCM_authenticated_decryption(const struct gcm_test_data *tdata)
                        plaintext,
                        tdata->plaintext.data,
                        tdata->plaintext.len,
-                       "GCM plaintext data not as expected");
+                       "Plaintext data not as expected");
 
        TEST_ASSERT_EQUAL(ut_params->op->status,
                        RTE_CRYPTO_OP_STATUS_SUCCESS,
-                       "GCM authentication failed");
+                       "Authentication failed");
        return 0;
 }
 
 static int
-test_mb_AES_GCM_authenticated_decryption_test_case_1(void)
+test_AES_GCM_authenticated_decryption_test_case_1(void)
+{
+       return test_authenticated_decryption(&gcm_test_case_1);
+}
+
+static int
+test_AES_GCM_authenticated_decryption_test_case_2(void)
+{
+       return test_authenticated_decryption(&gcm_test_case_2);
+}
+
+static int
+test_AES_GCM_authenticated_decryption_test_case_3(void)
+{
+       return test_authenticated_decryption(&gcm_test_case_3);
+}
+
+static int
+test_AES_GCM_authenticated_decryption_test_case_4(void)
+{
+       return test_authenticated_decryption(&gcm_test_case_4);
+}
+
+static int
+test_AES_GCM_authenticated_decryption_test_case_5(void)
+{
+       return test_authenticated_decryption(&gcm_test_case_5);
+}
+
+static int
+test_AES_GCM_authenticated_decryption_test_case_6(void)
+{
+       return test_authenticated_decryption(&gcm_test_case_6);
+}
+
+static int
+test_AES_GCM_authenticated_decryption_test_case_7(void)
+{
+       return test_authenticated_decryption(&gcm_test_case_7);
+}
+
+static int
+test_AES_GCM_auth_decryption_test_case_192_1(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_1);
+       return test_authenticated_decryption(&gcm_test_case_192_1);
 }
 
 static int
-test_mb_AES_GCM_authenticated_decryption_test_case_2(void)
+test_AES_GCM_auth_decryption_test_case_192_2(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_2);
+       return test_authenticated_decryption(&gcm_test_case_192_2);
 }
 
 static int
-test_mb_AES_GCM_authenticated_decryption_test_case_3(void)
+test_AES_GCM_auth_decryption_test_case_192_3(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_3);
+       return test_authenticated_decryption(&gcm_test_case_192_3);
 }
 
 static int
-test_mb_AES_GCM_authenticated_decryption_test_case_4(void)
+test_AES_GCM_auth_decryption_test_case_192_4(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_4);
+       return test_authenticated_decryption(&gcm_test_case_192_4);
 }
 
 static int
-test_mb_AES_GCM_authenticated_decryption_test_case_5(void)
+test_AES_GCM_auth_decryption_test_case_192_5(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_5);
+       return test_authenticated_decryption(&gcm_test_case_192_5);
 }
 
 static int
-test_mb_AES_GCM_authenticated_decryption_test_case_6(void)
+test_AES_GCM_auth_decryption_test_case_192_6(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_6);
+       return test_authenticated_decryption(&gcm_test_case_192_6);
 }
 
 static int
-test_mb_AES_GCM_authenticated_decryption_test_case_7(void)
+test_AES_GCM_auth_decryption_test_case_192_7(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_7);
+       return test_authenticated_decryption(&gcm_test_case_192_7);
 }
 
 static int
-test_mb_AES_GCM_auth_decryption_test_case_256_1(void)
+test_AES_GCM_auth_decryption_test_case_256_1(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_1);
+       return test_authenticated_decryption(&gcm_test_case_256_1);
 }
 
 static int
-test_mb_AES_GCM_auth_decryption_test_case_256_2(void)
+test_AES_GCM_auth_decryption_test_case_256_2(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_2);
+       return test_authenticated_decryption(&gcm_test_case_256_2);
 }
 
 static int
-test_mb_AES_GCM_auth_decryption_test_case_256_3(void)
+test_AES_GCM_auth_decryption_test_case_256_3(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_3);
+       return test_authenticated_decryption(&gcm_test_case_256_3);
 }
 
 static int
-test_mb_AES_GCM_auth_decryption_test_case_256_4(void)
+test_AES_GCM_auth_decryption_test_case_256_4(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_4);
+       return test_authenticated_decryption(&gcm_test_case_256_4);
 }
 
 static int
-test_mb_AES_GCM_auth_decryption_test_case_256_5(void)
+test_AES_GCM_auth_decryption_test_case_256_5(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_5);
+       return test_authenticated_decryption(&gcm_test_case_256_5);
 }
 
 static int
-test_mb_AES_GCM_auth_decryption_test_case_256_6(void)
+test_AES_GCM_auth_decryption_test_case_256_6(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_6);
+       return test_authenticated_decryption(&gcm_test_case_256_6);
 }
 
 static int
-test_mb_AES_GCM_auth_decryption_test_case_256_7(void)
+test_AES_GCM_auth_decryption_test_case_256_7(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_256_7);
+       return test_authenticated_decryption(&gcm_test_case_256_7);
 }
 
 static int
-test_mb_AES_GCM_auth_decryption_test_case_aad_1(void)
+test_AES_GCM_auth_decryption_test_case_aad_1(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_aad_1);
+       return test_authenticated_decryption(&gcm_test_case_aad_1);
 }
 
 static int
-test_mb_AES_GCM_auth_decryption_test_case_aad_2(void)
+test_AES_GCM_auth_decryption_test_case_aad_2(void)
 {
-       return test_mb_AES_GCM_authenticated_decryption(&gcm_test_case_aad_2);
+       return test_authenticated_decryption(&gcm_test_case_aad_2);
 }
 
 static int
-test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata)
+test_authenticated_encryption_oop(const struct aead_test_data *tdata)
 {
        struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
@@ -5208,13 +5498,13 @@ test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata)
        uint8_t *ciphertext, *auth_tag;
        uint16_t plaintext_pad_len;
 
-       /* Create GCM session */
-       retval = create_gcm_session(ts_params->valid_devs[0],
-                       RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+       /* Create AEAD session */
+       retval = create_aead_session(ts_params->valid_devs[0],
+                       tdata->algo,
+                       RTE_CRYPTO_AEAD_OP_ENCRYPT,
                        tdata->key.data, tdata->key.len,
                        tdata->aad.len, tdata->auth_tag.len,
-                       tdata->iv.len,
-                       RTE_CRYPTO_AUTH_OP_GENERATE);
+                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -5227,8 +5517,8 @@ test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata)
        memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
                        rte_pktmbuf_tailroom(ut_params->obuf));
 
-       /* Create GCM operation */
-       retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata);
+       /* Create AEAD operation */
+       retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
        if (retval < 0)
                return retval;
 
@@ -5258,26 +5548,26 @@ test_AES_GCM_authenticated_encryption_oop(const struct gcm_test_data *tdata)
                        ciphertext,
                        tdata->ciphertext.data,
                        tdata->ciphertext.len,
-                       "GCM Ciphertext data not as expected");
+                       "Ciphertext data not as expected");
 
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
                        auth_tag,
                        tdata->auth_tag.data,
                        tdata->auth_tag.len,
-                       "GCM Generated auth tag not as expected");
+                       "Generated auth tag not as expected");
 
        return 0;
 
 }
 
 static int
-test_mb_AES_GCM_authenticated_encryption_oop(void)
+test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
 {
-       return test_AES_GCM_authenticated_encryption_oop(&gcm_test_case_5);
+       return test_authenticated_encryption_oop(&gcm_test_case_5);
 }
 
 static int
-test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata)
+test_authenticated_decryption_oop(const struct aead_test_data *tdata)
 {
        struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
@@ -5285,13 +5575,13 @@ test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata)
        int retval;
        uint8_t *plaintext;
 
-       /* Create GCM session */
-       retval = create_gcm_session(ts_params->valid_devs[0],
-                       RTE_CRYPTO_CIPHER_OP_DECRYPT,
+       /* Create AEAD session */
+       retval = create_aead_session(ts_params->valid_devs[0],
+                       tdata->algo,
+                       RTE_CRYPTO_AEAD_OP_DECRYPT,
                        tdata->key.data, tdata->key.len,
                        tdata->aad.len, tdata->auth_tag.len,
-                       tdata->iv.len,
-                       RTE_CRYPTO_AUTH_OP_VERIFY);
+                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -5304,8 +5594,8 @@ test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata)
        memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
                        rte_pktmbuf_tailroom(ut_params->obuf));
 
-       /* Create GCM operation */
-       retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata);
+       /* Create AEAD operation */
+       retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
        if (retval < 0)
                return retval;
 
@@ -5331,23 +5621,23 @@ test_AES_GCM_authenticated_decryption_oop(const struct gcm_test_data *tdata)
                        plaintext,
                        tdata->plaintext.data,
                        tdata->plaintext.len,
-                       "GCM plaintext data not as expected");
+                       "Plaintext data not as expected");
 
        TEST_ASSERT_EQUAL(ut_params->op->status,
                        RTE_CRYPTO_OP_STATUS_SUCCESS,
-                       "GCM authentication failed");
+                       "Authentication failed");
        return 0;
 }
 
 static int
-test_mb_AES_GCM_authenticated_decryption_oop(void)
+test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
 {
-       return test_AES_GCM_authenticated_decryption_oop(&gcm_test_case_5);
+       return test_authenticated_decryption_oop(&gcm_test_case_5);
 }
 
 static int
-test_AES_GCM_authenticated_encryption_sessionless(
-               const struct gcm_test_data *tdata)
+test_authenticated_encryption_sessionless(
+               const struct aead_test_data *tdata)
 {
        struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
@@ -5363,19 +5653,19 @@ test_AES_GCM_authenticated_encryption_sessionless(
        memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
                        rte_pktmbuf_tailroom(ut_params->ibuf));
 
-       /* Create GCM operation */
-       retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_ENCRYPT, tdata);
+       /* Create AEAD operation */
+       retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
        if (retval < 0)
                return retval;
 
-       /* Create GCM xforms */
+       /* Create GCM xform */
        memcpy(key, tdata->key.data, tdata->key.len);
-       retval = create_gcm_xforms(ut_params->op,
-                       RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+       retval = create_aead_xform(ut_params->op,
+                       tdata->algo,
+                       RTE_CRYPTO_AEAD_OP_ENCRYPT,
                        key, tdata->key.len,
                        tdata->aad.len, tdata->auth_tag.len,
-                       tdata->iv.len,
-                       RTE_CRYPTO_AUTH_OP_GENERATE);
+                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -5408,28 +5698,28 @@ test_AES_GCM_authenticated_encryption_sessionless(
                        ciphertext,
                        tdata->ciphertext.data,
                        tdata->ciphertext.len,
-                       "GCM Ciphertext data not as expected");
+                       "Ciphertext data not as expected");
 
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
                        auth_tag,
                        tdata->auth_tag.data,
                        tdata->auth_tag.len,
-                       "GCM Generated auth tag not as expected");
+                       "Generated auth tag not as expected");
 
        return 0;
 
 }
 
 static int
-test_mb_AES_GCM_authenticated_encryption_sessionless(void)
+test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
 {
-       return test_AES_GCM_authenticated_encryption_sessionless(
+       return test_authenticated_encryption_sessionless(
                        &gcm_test_case_5);
 }
 
 static int
-test_AES_GCM_authenticated_decryption_sessionless(
-               const struct gcm_test_data *tdata)
+test_authenticated_decryption_sessionless(
+               const struct aead_test_data *tdata)
 {
        struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
@@ -5444,19 +5734,19 @@ test_AES_GCM_authenticated_decryption_sessionless(
        memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
                        rte_pktmbuf_tailroom(ut_params->ibuf));
 
-       /* Create GCM operation */
-       retval = create_gcm_operation(RTE_CRYPTO_CIPHER_OP_DECRYPT, tdata);
+       /* Create AEAD operation */
+       retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
        if (retval < 0)
                return retval;
 
-       /* Create GCM xforms */
+       /* Create AEAD xform */
        memcpy(key, tdata->key.data, tdata->key.len);
-       retval = create_gcm_xforms(ut_params->op,
-                       RTE_CRYPTO_CIPHER_OP_DECRYPT,
+       retval = create_aead_xform(ut_params->op,
+                       tdata->algo,
+                       RTE_CRYPTO_AEAD_OP_DECRYPT,
                        key, tdata->key.len,
                        tdata->aad.len, tdata->auth_tag.len,
-                       tdata->iv.len,
-                       RTE_CRYPTO_AUTH_OP_VERIFY);
+                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -5485,21 +5775,129 @@ test_AES_GCM_authenticated_decryption_sessionless(
                        plaintext,
                        tdata->plaintext.data,
                        tdata->plaintext.len,
-                       "GCM plaintext data not as expected");
+                       "Plaintext data not as expected");
 
        TEST_ASSERT_EQUAL(ut_params->op->status,
                        RTE_CRYPTO_OP_STATUS_SUCCESS,
-                       "GCM authentication failed");
+                       "Authentication failed");
        return 0;
 }
 
 static int
-test_mb_AES_GCM_authenticated_decryption_sessionless(void)
+test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
 {
-       return test_AES_GCM_authenticated_decryption_sessionless(
+       return test_authenticated_decryption_sessionless(
                        &gcm_test_case_5);
 }
 
+static int
+test_AES_CCM_authenticated_encryption_test_case_128_1(void)
+{
+       return test_authenticated_encryption(&ccm_test_case_128_1);
+}
+
+static int
+test_AES_CCM_authenticated_encryption_test_case_128_2(void)
+{
+       return test_authenticated_encryption(&ccm_test_case_128_2);
+}
+
+static int
+test_AES_CCM_authenticated_encryption_test_case_128_3(void)
+{
+       return test_authenticated_encryption(&ccm_test_case_128_3);
+}
+
+static int
+test_AES_CCM_authenticated_decryption_test_case_128_1(void)
+{
+       return test_authenticated_decryption(&ccm_test_case_128_1);
+}
+
+static int
+test_AES_CCM_authenticated_decryption_test_case_128_2(void)
+{
+       return test_authenticated_decryption(&ccm_test_case_128_2);
+}
+
+static int
+test_AES_CCM_authenticated_decryption_test_case_128_3(void)
+{
+       return test_authenticated_decryption(&ccm_test_case_128_3);
+}
+
+static int
+test_AES_CCM_authenticated_encryption_test_case_192_1(void)
+{
+       return test_authenticated_encryption(&ccm_test_case_192_1);
+}
+
+static int
+test_AES_CCM_authenticated_encryption_test_case_192_2(void)
+{
+       return test_authenticated_encryption(&ccm_test_case_192_2);
+}
+
+static int
+test_AES_CCM_authenticated_encryption_test_case_192_3(void)
+{
+       return test_authenticated_encryption(&ccm_test_case_192_3);
+}
+
+static int
+test_AES_CCM_authenticated_decryption_test_case_192_1(void)
+{
+       return test_authenticated_decryption(&ccm_test_case_192_1);
+}
+
+static int
+test_AES_CCM_authenticated_decryption_test_case_192_2(void)
+{
+       return test_authenticated_decryption(&ccm_test_case_192_2);
+}
+
+static int
+test_AES_CCM_authenticated_decryption_test_case_192_3(void)
+{
+       return test_authenticated_decryption(&ccm_test_case_192_3);
+}
+
+static int
+test_AES_CCM_authenticated_encryption_test_case_256_1(void)
+{
+       return test_authenticated_encryption(&ccm_test_case_256_1);
+}
+
+static int
+test_AES_CCM_authenticated_encryption_test_case_256_2(void)
+{
+       return test_authenticated_encryption(&ccm_test_case_256_2);
+}
+
+static int
+test_AES_CCM_authenticated_encryption_test_case_256_3(void)
+{
+       return test_authenticated_encryption(&ccm_test_case_256_3);
+}
+
+static int
+test_AES_CCM_authenticated_decryption_test_case_256_1(void)
+{
+       return test_authenticated_decryption(&ccm_test_case_256_1);
+}
+
+static int
+test_AES_CCM_authenticated_decryption_test_case_256_2(void)
+{
+       return test_authenticated_decryption(&ccm_test_case_256_2);
+}
+
+static int
+test_AES_CCM_authenticated_decryption_test_case_256_3(void)
+{
+       return test_authenticated_decryption(&ccm_test_case_256_3);
+}
+
 static int
 test_stats(void)
 {
@@ -5575,12 +5973,15 @@ static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
        ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
 
        ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
-       ut_params->auth_xform.auth.add_auth_data_length = 0;
        ut_params->auth_xform.auth.key.length = test_case->key.len;
        ut_params->auth_xform.auth.key.data = key;
 
        ut_params->sess = rte_cryptodev_sym_session_create(
-               ts_params->valid_devs[0], &ut_params->auth_xform);
+                       ts_params->session_mpool);
+
+       rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+                       ut_params->sess, &ut_params->auth_xform,
+                       ts_params->session_mpool);
 
        if (ut_params->sess == NULL)
                return TEST_FAILED;
@@ -5615,7 +6016,6 @@ static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
                        "no room to append digest");
        sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                        ut_params->ibuf, plaintext_pad_len);
-       sym_op->auth.digest.length = MD5_DIGEST_LEN;
 
        if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
                rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
@@ -5756,9 +6156,13 @@ test_multi_session(void)
 
        /* Create multiple crypto sessions*/
        for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
+
                sessions[i] = rte_cryptodev_sym_session_create(
-                               ts_params->valid_devs[0],
-                       &ut_params->auth_xform);
+                               ts_params->session_mpool);
+
+               rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+                               sessions[i], &ut_params->auth_xform,
+                               ts_params->session_mpool);
                TEST_ASSERT_NOT_NULL(sessions[i],
                                "Session creation failed at session number %u",
                                i);
@@ -5794,14 +6198,17 @@ test_multi_session(void)
        }
 
        /* Next session create should fail */
-       sessions[i] = rte_cryptodev_sym_session_create(ts_params->valid_devs[0],
-                       &ut_params->auth_xform);
+       rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+                       sessions[i], &ut_params->auth_xform,
+                       ts_params->session_mpool);
        TEST_ASSERT_NULL(sessions[i],
                        "Session creation succeeded unexpectedly!");
 
-       for (i = 0; i < dev_info.sym.max_nb_sessions; i++)
-               rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
+       for (i = 0; i < dev_info.sym.max_nb_sessions; i++) {
+               rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
                                sessions[i]);
+               rte_cryptodev_sym_session_free(sessions[i]);
+       }
 
        rte_free(sessions);
 
@@ -5859,6 +6266,9 @@ test_multi_session_random_usage(void)
                                        * dev_info.sym.max_nb_sessions) + 1, 0);
 
        for (i = 0; i < MB_SESSION_NUMBER; i++) {
+               sessions[i] = rte_cryptodev_sym_session_create(
+                               ts_params->session_mpool);
+
                rte_memcpy(&ut_paramz[i].ut_params, &testsuite_params,
                                sizeof(struct crypto_unittest_params));
 
@@ -5867,9 +6277,11 @@ test_multi_session_random_usage(void)
                                ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
 
                /* Create multiple crypto sessions*/
-               sessions[i] = rte_cryptodev_sym_session_create(
+               rte_cryptodev_sym_session_init(
                                ts_params->valid_devs[0],
-                               &ut_paramz[i].ut_params.auth_xform);
+                               sessions[i],
+                               &ut_paramz[i].ut_params.auth_xform,
+                               ts_params->session_mpool);
 
                TEST_ASSERT_NOT_NULL(sessions[i],
                                "Session creation failed at session number %u",
@@ -5912,9 +6324,11 @@ test_multi_session_random_usage(void)
                }
        }
 
-       for (i = 0; i < MB_SESSION_NUMBER; i++)
-               rte_cryptodev_sym_session_free(ts_params->valid_devs[0],
+       for (i = 0; i < MB_SESSION_NUMBER; i++) {
+               rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
                                sessions[i]);
+               rte_cryptodev_sym_session_free(sessions[i]);
+       }
 
        rte_free(sessions);
 
@@ -5938,9 +6352,14 @@ test_null_cipher_only_operation(void)
        ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
        ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
 
-       /* Create Crypto session*/
        ut_params->sess = rte_cryptodev_sym_session_create(
-                       ts_params->valid_devs[0], &ut_params->cipher_xform);
+                       ts_params->session_mpool);
+
+       /* Create Crypto session*/
+       rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+                               ut_params->sess,
+                               &ut_params->cipher_xform,
+                               ts_params->session_mpool);
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
        /* Generate Crypto op data structure */
@@ -5995,9 +6414,13 @@ test_null_auth_only_operation(void)
        ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
        ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 
-       /* Create Crypto session*/
        ut_params->sess = rte_cryptodev_sym_session_create(
-                       ts_params->valid_devs[0], &ut_params->auth_xform);
+                       ts_params->session_mpool);
+
+       /* Create Crypto session*/
+       rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+                       ut_params->sess, &ut_params->auth_xform,
+                       ts_params->session_mpool);
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
        /* Generate Crypto op data structure */
@@ -6051,9 +6474,13 @@ test_null_cipher_auth_operation(void)
        ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
        ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 
-       /* Create Crypto session*/
        ut_params->sess = rte_cryptodev_sym_session_create(
-                       ts_params->valid_devs[0], &ut_params->cipher_xform);
+                       ts_params->session_mpool);
+
+       /* Create Crypto session*/
+       rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+                       ut_params->sess, &ut_params->cipher_xform,
+                       ts_params->session_mpool);
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
        /* Generate Crypto op data structure */
@@ -6117,9 +6544,13 @@ test_null_auth_cipher_operation(void)
        ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
        ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 
-       /* Create Crypto session*/
        ut_params->sess = rte_cryptodev_sym_session_create(
-                       ts_params->valid_devs[0], &ut_params->cipher_xform);
+                       ts_params->session_mpool);
+
+       /* Create Crypto session*/
+       rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+                       ut_params->sess, &ut_params->cipher_xform,
+                       ts_params->session_mpool);
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
        /* Generate Crypto op data structure */
@@ -6165,6 +6596,7 @@ test_null_invalid_operation(void)
 {
        struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
+       int ret;
 
        /* Setup Cipher Parameters */
        ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
@@ -6173,10 +6605,14 @@ test_null_invalid_operation(void)
        ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
        ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
 
-       /* Create Crypto session*/
        ut_params->sess = rte_cryptodev_sym_session_create(
-                       ts_params->valid_devs[0], &ut_params->cipher_xform);
-       TEST_ASSERT_NULL(ut_params->sess,
+                       ts_params->session_mpool);
+
+       /* Create Crypto session*/
+       ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+                       ut_params->sess, &ut_params->cipher_xform,
+                       ts_params->session_mpool);
+       TEST_ASSERT(ret < 0,
                        "Session creation succeeded unexpectedly");
 
 
@@ -6187,10 +6623,14 @@ test_null_invalid_operation(void)
        ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
        ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 
-       /* Create Crypto session*/
        ut_params->sess = rte_cryptodev_sym_session_create(
-                       ts_params->valid_devs[0], &ut_params->auth_xform);
-       TEST_ASSERT_NULL(ut_params->sess,
+                       ts_params->session_mpool);
+
+       /* Create Crypto session*/
+       ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+                       ut_params->sess, &ut_params->auth_xform,
+                       ts_params->session_mpool);
+       TEST_ASSERT(ret < 0,
                        "Session creation succeeded unexpectedly");
 
        return TEST_SUCCESS;
@@ -6224,9 +6664,13 @@ test_null_burst_operation(void)
        ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
        ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
 
-       /* Create Crypto session*/
        ut_params->sess = rte_cryptodev_sym_session_create(
-                       ts_params->valid_devs[0], &ut_params->cipher_xform);
+                       ts_params->session_mpool);
+
+       /* Create Crypto session*/
+       rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+                       ut_params->sess, &ut_params->cipher_xform,
+                       ts_params->session_mpool);
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
        TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
@@ -6291,17 +6735,7 @@ create_gmac_operation(enum rte_crypto_auth_operation op,
        struct crypto_unittest_params *ut_params = &unittest_params;
        struct rte_crypto_sym_op *sym_op;
 
-       unsigned aad_pad_len;
-
-       aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
-
-       /*
-        * Runtime generate the large plain text instead of use hard code
-        * plain text vector. It is done to avoid create huge source file
-        * with the test vector.
-        */
-       if (tdata->aad.len == GMAC_LARGE_PLAINTEXT_LENGTH)
-               generate_gmac_large_plaintext(tdata->aad.data);
+       uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
 
        /* Generate Crypto op data structure */
        ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
@@ -6310,14 +6744,6 @@ create_gmac_operation(enum rte_crypto_auth_operation op,
                        "Failed to allocate symmetric crypto operation struct");
 
        sym_op = ut_params->op->sym;
-       sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-                       aad_pad_len);
-       TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
-                       "no room to append aad");
-
-       sym_op->auth.aad.phys_addr =
-                       rte_pktmbuf_mtophys(ut_params->ibuf);
-       memcpy(sym_op->auth.aad.data, tdata->aad.data, tdata->aad.len);
 
        sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
                        ut_params->ibuf, tdata->gmac_tag.len);
@@ -6325,15 +6751,14 @@ create_gmac_operation(enum rte_crypto_auth_operation op,
                        "no room to append digest");
 
        sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
-                       ut_params->ibuf, aad_pad_len);
-       sym_op->auth.digest.length = tdata->gmac_tag.len;
+                       ut_params->ibuf, plaintext_pad_len);
 
        if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
                rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
                                tdata->gmac_tag.len);
                TEST_HEXDUMP(stdout, "digest:",
                                sym_op->auth.digest.data,
-                               sym_op->auth.digest.length);
+                               tdata->gmac_tag.len);
        }
 
        uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
@@ -6347,31 +6772,21 @@ create_gmac_operation(enum rte_crypto_auth_operation op,
        sym_op->cipher.data.offset = 0;
 
        sym_op->auth.data.offset = 0;
-       sym_op->auth.data.length = 0;
+       sym_op->auth.data.length = tdata->plaintext.len;
 
        return 0;
 }
 
 static int create_gmac_session(uint8_t dev_id,
-               enum rte_crypto_cipher_operation op,
                const struct gmac_test_data *tdata,
                enum rte_crypto_auth_operation auth_op)
 {
-       uint8_t cipher_key[tdata->key.len];
+       uint8_t auth_key[tdata->key.len];
 
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
 
-       memcpy(cipher_key, tdata->key.data, tdata->key.len);
-
-       /* For GMAC we setup cipher parameters */
-       ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-       ut_params->cipher_xform.next = NULL;
-       ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_GCM;
-       ut_params->cipher_xform.cipher.op = op;
-       ut_params->cipher_xform.cipher.key.data = cipher_key;
-       ut_params->cipher_xform.cipher.key.length = tdata->key.len;
-       ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
-       ut_params->cipher_xform.cipher.iv.length = tdata->iv.len;
+       memcpy(auth_key, tdata->key.data, tdata->key.len);
 
        ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
        ut_params->auth_xform.next = NULL;
@@ -6379,14 +6794,18 @@ static int create_gmac_session(uint8_t dev_id,
        ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
        ut_params->auth_xform.auth.op = auth_op;
        ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
-       ut_params->auth_xform.auth.add_auth_data_length = tdata->aad.len;
-       ut_params->auth_xform.auth.key.length = 0;
-       ut_params->auth_xform.auth.key.data = NULL;
+       ut_params->auth_xform.auth.key.length = tdata->key.len;
+       ut_params->auth_xform.auth.key.data = auth_key;
+       ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
+       ut_params->auth_xform.auth.iv.length = tdata->iv.len;
 
-       ut_params->cipher_xform.next = &ut_params->auth_xform;
 
-       ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
-                       &ut_params->cipher_xform);
+       ut_params->sess = rte_cryptodev_sym_session_create(
+                       ts_params->session_mpool);
+
+       rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+                       &ut_params->auth_xform,
+                       ts_params->session_mpool);
 
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
@@ -6401,20 +6820,19 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
 
        int retval;
 
-       uint8_t *auth_tag, *p;
-       uint16_t aad_pad_len;
+       uint8_t *auth_tag, *plaintext;
+       uint16_t plaintext_pad_len;
 
        TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
                              "No GMAC length in the source data");
 
        retval = create_gmac_session(ts_params->valid_devs[0],
-                       RTE_CRYPTO_CIPHER_OP_ENCRYPT,
                        tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
 
        if (retval < 0)
                return retval;
 
-       if (tdata->aad.len > MBUF_SIZE)
+       if (tdata->plaintext.len > MBUF_SIZE)
                ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
        else
                ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
@@ -6424,9 +6842,22 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
        memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
                        rte_pktmbuf_tailroom(ut_params->ibuf));
 
-       aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
+       plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
+       /*
+        * Runtime generate the large plain text instead of use hard code
+        * plain text vector. It is done to avoid create huge source file
+        * with the test vector.
+        */
+       if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
+               generate_gmac_large_plaintext(tdata->plaintext.data);
+
+       plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+                               plaintext_pad_len);
+       TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
 
-       p = rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *);
+       memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
+       TEST_HEXDUMP(stdout, "plaintext:", plaintext,
+                       tdata->plaintext.len);
 
        retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
                        tdata);
@@ -6446,9 +6877,9 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
 
        if (ut_params->op->sym->m_dst) {
                auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
-                               uint8_t *, aad_pad_len);
+                               uint8_t *, plaintext_pad_len);
        } else {
-               auth_tag = p + aad_pad_len;
+               auth_tag = plaintext + plaintext_pad_len;
        }
 
        TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
@@ -6492,18 +6923,19 @@ test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
        struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
        int retval;
+       uint32_t plaintext_pad_len;
+       uint8_t *plaintext;
 
        TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
                              "No GMAC length in the source data");
 
        retval = create_gmac_session(ts_params->valid_devs[0],
-                       RTE_CRYPTO_CIPHER_OP_DECRYPT,
                        tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
 
        if (retval < 0)
                return retval;
 
-       if (tdata->aad.len > MBUF_SIZE)
+       if (tdata->plaintext.len > MBUF_SIZE)
                ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
        else
                ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
@@ -6513,6 +6945,24 @@ test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
        memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
                        rte_pktmbuf_tailroom(ut_params->ibuf));
 
+       plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
+
+       /*
+        * Runtime generate the large plain text instead of use hard code
+        * plain text vector. It is done to avoid create huge source file
+        * with the test vector.
+        */
+       if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
+               generate_gmac_large_plaintext(tdata->plaintext.data);
+
+       plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+                               plaintext_pad_len);
+       TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
+
+       memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
+       TEST_HEXDUMP(stdout, "plaintext:", plaintext,
+                       tdata->plaintext.len);
+
        retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
                        tdata);
 
@@ -6626,8 +7076,7 @@ hmac_sha1_test_crypto_vector = {
 static const struct test_crypto_vector
 aes128_gmac_test_vector = {
        .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
-       .crypto_algo = RTE_CRYPTO_CIPHER_AES_GCM,
-       .aad = {
+       .plaintext = {
                .data = plaintext_hash,
                .len = 512
        },
@@ -6638,7 +7087,7 @@ aes128_gmac_test_vector = {
                },
                .len = 12
        },
-       .cipher_key = {
+       .auth_key = {
                .data = {
                        0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
                        0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
@@ -6716,6 +7165,7 @@ create_auth_session(struct crypto_unittest_params *ut_params,
                const struct test_crypto_vector *reference,
                enum rte_crypto_auth_operation auth_op)
 {
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
        uint8_t auth_key[reference->auth_key.len + 1];
 
        memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
@@ -6728,11 +7178,14 @@ create_auth_session(struct crypto_unittest_params *ut_params,
        ut_params->auth_xform.auth.key.length = reference->auth_key.len;
        ut_params->auth_xform.auth.key.data = auth_key;
        ut_params->auth_xform.auth.digest_length = reference->digest.len;
-       ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
 
        /* Create Crypto session*/
-       ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
-                               &ut_params->auth_xform);
+       ut_params->sess = rte_cryptodev_sym_session_create(
+                       ts_params->session_mpool);
+
+       rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+                               &ut_params->auth_xform,
+                               ts_params->session_mpool);
 
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
@@ -6746,6 +7199,7 @@ create_auth_cipher_session(struct crypto_unittest_params *ut_params,
                enum rte_crypto_auth_operation auth_op,
                enum rte_crypto_cipher_operation cipher_op)
 {
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
        uint8_t cipher_key[reference->cipher_key.len + 1];
        uint8_t auth_key[reference->auth_key.len + 1];
 
@@ -6756,26 +7210,35 @@ create_auth_cipher_session(struct crypto_unittest_params *ut_params,
        /* Setup Authentication Parameters */
        ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
        ut_params->auth_xform.auth.op = auth_op;
-       ut_params->auth_xform.next = &ut_params->cipher_xform;
        ut_params->auth_xform.auth.algo = reference->auth_algo;
        ut_params->auth_xform.auth.key.length = reference->auth_key.len;
        ut_params->auth_xform.auth.key.data = auth_key;
        ut_params->auth_xform.auth.digest_length = reference->digest.len;
-       ut_params->auth_xform.auth.add_auth_data_length = reference->aad.len;
 
-       /* Setup Cipher Parameters */
-       ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
-       ut_params->cipher_xform.next = NULL;
-       ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
-       ut_params->cipher_xform.cipher.op = cipher_op;
-       ut_params->cipher_xform.cipher.key.data = cipher_key;
-       ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
-       ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
-       ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
+       if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
+               ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
+               ut_params->auth_xform.auth.iv.length = reference->iv.len;
+       } else {
+               ut_params->auth_xform.next = &ut_params->cipher_xform;
+
+               /* Setup Cipher Parameters */
+               ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+               ut_params->cipher_xform.next = NULL;
+               ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
+               ut_params->cipher_xform.cipher.op = cipher_op;
+               ut_params->cipher_xform.cipher.key.data = cipher_key;
+               ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
+               ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
+               ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
+       }
 
        /* Create Crypto session*/
-       ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
-                               &ut_params->auth_xform);
+       ut_params->sess = rte_cryptodev_sym_session_create(
+                       ts_params->session_mpool);
+
+       rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
+                               &ut_params->auth_xform,
+                               ts_params->session_mpool);
 
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
@@ -6811,7 +7274,6 @@ create_auth_operation(struct crypto_testsuite_params *ts_params,
 
        sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                        ut_params->ibuf, reference->plaintext.len);
-       sym_op->auth.digest.length = reference->digest.len;
 
        if (auth_generate)
                memset(sym_op->auth.digest.data, 0, reference->digest.len);
@@ -6822,7 +7284,7 @@ create_auth_operation(struct crypto_testsuite_params *ts_params,
 
        TEST_HEXDUMP(stdout, "digest:",
                        sym_op->auth.digest.data,
-                       sym_op->auth.digest.length);
+                       reference->digest.len);
 
        sym_op->auth.data.length = reference->plaintext.len;
        sym_op->auth.data.offset = 0;
@@ -6850,16 +7312,6 @@ create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
        /* set crypto operation source mbuf */
        sym_op->m_src = ut_params->ibuf;
 
-       /* aad */
-       sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
-                       reference->aad.len);
-       TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data, "no room to append AAD");
-       memcpy(sym_op->auth.aad.data, reference->aad.data, reference->aad.len);
-
-       TEST_HEXDUMP(stdout, "AAD:", sym_op->auth.aad.data, reference->aad.len);
-
-       sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(ut_params->ibuf);
-
        /* digest */
        sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
                        ut_params->ibuf, reference->digest.len);
@@ -6869,7 +7321,6 @@ create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
 
        sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                        ut_params->ibuf, reference->ciphertext.len);
-       sym_op->auth.digest.length = reference->digest.len;
 
        if (auth_generate)
                memset(sym_op->auth.digest.data, 0, reference->digest.len);
@@ -6880,7 +7331,7 @@ create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
 
        TEST_HEXDUMP(stdout, "digest:",
                        sym_op->auth.digest.data,
-                       sym_op->auth.digest.length);
+                       reference->digest.len);
 
        rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
                        reference->iv.data, reference->iv.len);
@@ -6888,7 +7339,7 @@ create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
        sym_op->cipher.data.length = 0;
        sym_op->cipher.data.offset = 0;
 
-       sym_op->auth.data.length = 0;
+       sym_op->auth.data.length = reference->plaintext.len;
        sym_op->auth.data.offset = 0;
 
        return 0;
@@ -6923,7 +7374,6 @@ create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
 
        sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
                        ut_params->ibuf, reference->ciphertext.len);
-       sym_op->auth.digest.length = reference->digest.len;
 
        if (auth_generate)
                memset(sym_op->auth.digest.data, 0, reference->digest.len);
@@ -6934,7 +7384,7 @@ create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
 
        TEST_HEXDUMP(stdout, "digest:",
                        sym_op->auth.digest.data,
-                       sym_op->auth.digest.length);
+                       reference->digest.len);
 
        rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
                        reference->iv.data, reference->iv.len);
@@ -7039,6 +7489,7 @@ test_authentication_verify_GMAC_fail_when_corruption(
                unsigned int data_corrupted)
 {
        int retval;
+       uint8_t *plaintext;
 
        /* Create session */
        retval = create_auth_cipher_session(ut_params,
@@ -7057,19 +7508,25 @@ test_authentication_verify_GMAC_fail_when_corruption(
        memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
                        rte_pktmbuf_tailroom(ut_params->ibuf));
 
-       /* Create operation */
-       retval = create_auth_verify_GMAC_operation(ts_params,
-                       ut_params,
-                       reference);
-
+       plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
+                       reference->plaintext.len);
+       TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
+       memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
+
+       TEST_HEXDUMP(stdout, "plaintext:", plaintext, reference->plaintext.len);
+
+       /* Create operation */
+       retval = create_auth_verify_GMAC_operation(ts_params,
+                       ut_params,
+                       reference);
+
        if (retval < 0)
                return retval;
 
        if (data_corrupted)
-               data_corruption(ut_params->op->sym->auth.aad.data);
+               data_corruption(plaintext);
        else
-               tag_corruption(ut_params->op->sym->auth.aad.data,
-                               reference->aad.len);
+               tag_corruption(plaintext, reference->aad.len);
 
        ut_params->op = process_crypto_request(ts_params->valid_devs[0],
                        ut_params->op);
@@ -7146,8 +7603,8 @@ test_authenticated_decryption_fail_when_corruption(
 }
 
 static int
-create_gcm_operation_SGL(enum rte_crypto_cipher_operation op,
-               const struct gcm_test_data *tdata,
+create_aead_operation_SGL(enum rte_crypto_aead_operation op,
+               const struct aead_test_data *tdata,
                void *digest_mem, uint64_t digest_phys)
 {
        struct crypto_testsuite_params *ts_params = &testsuite_params;
@@ -7155,7 +7612,7 @@ create_gcm_operation_SGL(enum rte_crypto_cipher_operation op,
 
        const unsigned int auth_tag_len = tdata->auth_tag.len;
        const unsigned int iv_len = tdata->iv.len;
-       const unsigned int aad_len = tdata->aad.len;
+       unsigned int aad_len = tdata->aad.len;
 
        /* Generate Crypto op data structure */
        ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
@@ -7165,46 +7622,68 @@ create_gcm_operation_SGL(enum rte_crypto_cipher_operation op,
 
        struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
 
-       sym_op->auth.digest.data = digest_mem;
+       sym_op->aead.digest.data = digest_mem;
 
-       TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
+       TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
                        "no room to append digest");
 
-       sym_op->auth.digest.phys_addr = digest_phys;
-       sym_op->auth.digest.length = auth_tag_len;
+       sym_op->aead.digest.phys_addr = digest_phys;
 
-       if (op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
-               rte_memcpy(sym_op->auth.digest.data, tdata->auth_tag.data,
+       if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
+               rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
                                auth_tag_len);
                TEST_HEXDUMP(stdout, "digest:",
-                               sym_op->auth.digest.data,
-                               sym_op->auth.digest.length);
+                               sym_op->aead.digest.data,
+                               auth_tag_len);
        }
 
-       uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
-                       uint8_t *, IV_OFFSET);
+       /* Append aad data */
+       if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
+               uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
+                               uint8_t *, IV_OFFSET);
 
-       rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
+               /* Copy IV 1 byte after the IV pointer, according to the API */
+               rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
 
-       sym_op->auth.aad.data = (uint8_t *)rte_pktmbuf_prepend(
-                       ut_params->ibuf, aad_len);
-       TEST_ASSERT_NOT_NULL(sym_op->auth.aad.data,
-                       "no room to prepend aad");
-       sym_op->auth.aad.phys_addr = rte_pktmbuf_mtophys(
-                       ut_params->ibuf);
+               aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
 
-       memset(sym_op->auth.aad.data, 0, aad_len);
-       rte_memcpy(sym_op->auth.aad.data, tdata->aad.data, aad_len);
+               sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
+                               ut_params->ibuf, aad_len);
+               TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
+                               "no room to prepend aad");
+               sym_op->aead.aad.phys_addr = rte_pktmbuf_mtophys(
+                               ut_params->ibuf);
 
-       TEST_HEXDUMP(stdout, "iv:", iv_ptr, iv_len);
-       TEST_HEXDUMP(stdout, "aad:",
-                       sym_op->auth.aad.data, aad_len);
+               memset(sym_op->aead.aad.data, 0, aad_len);
+               /* Copy AAD 18 bytes after the AAD pointer, according to the API */
+               rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
 
-       sym_op->cipher.data.length = tdata->plaintext.len;
-       sym_op->cipher.data.offset = aad_len;
+               TEST_HEXDUMP(stdout, "iv:", iv_ptr, iv_len);
+               TEST_HEXDUMP(stdout, "aad:",
+                               sym_op->aead.aad.data, aad_len);
+       } else {
+               uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
+                               uint8_t *, IV_OFFSET);
 
-       sym_op->auth.data.offset = aad_len;
-       sym_op->auth.data.length = tdata->plaintext.len;
+               rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
+
+               sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
+                               ut_params->ibuf, aad_len);
+               TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
+                               "no room to prepend aad");
+               sym_op->aead.aad.phys_addr = rte_pktmbuf_mtophys(
+                               ut_params->ibuf);
+
+               memset(sym_op->aead.aad.data, 0, aad_len);
+               rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
+
+               TEST_HEXDUMP(stdout, "iv:", iv_ptr, iv_len);
+               TEST_HEXDUMP(stdout, "aad:",
+                               sym_op->aead.aad.data, aad_len);
+       }
+
+       sym_op->aead.data.length = tdata->plaintext.len;
+       sym_op->aead.data.offset = aad_len;
 
        return 0;
 }
@@ -7212,7 +7691,7 @@ create_gcm_operation_SGL(enum rte_crypto_cipher_operation op,
 #define SGL_MAX_NO     16
 
 static int
-test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
+test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
                const int oop, uint32_t fragsz, uint32_t fragsz_oop)
 {
        struct crypto_testsuite_params *ts_params = &testsuite_params;
@@ -7257,13 +7736,13 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
                buf_oop = ut_params->obuf;
        }
 
-       /* Create GCM session */
-       retval = create_gcm_session(ts_params->valid_devs[0],
-                       RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+       /* Create AEAD session */
+       retval = create_aead_session(ts_params->valid_devs[0],
+                       tdata->algo,
+                       RTE_CRYPTO_AEAD_OP_ENCRYPT,
                        tdata->key.data, tdata->key.len,
                        tdata->aad.len, tdata->auth_tag.len,
-                       tdata->iv.len,
-                       RTE_CRYPTO_AUTH_OP_GENERATE);
+                       tdata->iv.len);
        if (retval < 0)
                return retval;
 
@@ -7388,8 +7867,8 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
                                tdata->plaintext.len);
        }
 
-       /* Create GCM opertaion */
-       retval = create_gcm_operation_SGL(RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+       /* Create AEAD operation */
+       retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
                        tdata, digest_mem, digest_phys);
 
        if (retval < 0)
@@ -7423,7 +7902,7 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
                        ciphertext,
                        tdata->ciphertext.data,
                        fragsz,
-                       "GCM Ciphertext data not as expected");
+                       "Ciphertext data not as expected");
 
        buf = ut_params->op->sym->m_src->next;
        if (oop)
@@ -7440,7 +7919,7 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
                                ciphertext,
                                tdata->ciphertext.data + off,
                                to_trn_tbl[ecx],
-                               "GCM Ciphertext data not as expected");
+                               "Ciphertext data not as expected");
 
                off += to_trn_tbl[ecx++];
                buf = buf->next;
@@ -7451,7 +7930,7 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
                        auth_tag,
                        tdata->auth_tag.data,
                        tdata->auth_tag.len,
-                       "GCM Generated auth tag not as expected");
+                       "Generated auth tag not as expected");
 
        return 0;
 }
@@ -7462,21 +7941,21 @@ test_AES_GCM_authenticated_encryption_SGL(const struct gcm_test_data *tdata,
 static int
 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
 {
-       return test_AES_GCM_authenticated_encryption_SGL(
+       return test_authenticated_encryption_SGL(
                        &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
 }
 
 static int
 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
 {
-       return test_AES_GCM_authenticated_encryption_SGL(
+       return test_authenticated_encryption_SGL(
                        &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
 }
 
 static int
 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
 {
-       return test_AES_GCM_authenticated_encryption_SGL(
+       return test_authenticated_encryption_SGL(
                        &gcm_test_case_8, OUT_OF_PLACE, 400,
                        gcm_test_case_8.plaintext.len);
 }
@@ -7485,7 +7964,7 @@ static int
 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
 {
 
-       return test_AES_GCM_authenticated_encryption_SGL(
+       return test_authenticated_encryption_SGL(
                        &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
 }
 
@@ -7614,8 +8093,9 @@ test_scheduler_attach_slave_op(void)
        char vdev_name[32];
 
        /* create 2 AESNI_MB if necessary */
-       nb_devs = rte_cryptodev_count_devtype(
-                       RTE_CRYPTODEV_AESNI_MB_PMD);
+       nb_devs = rte_cryptodev_device_count_by_driver(
+                       rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
        if (nb_devs < 2) {
                for (i = nb_devs; i < 2; i++) {
                        snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
@@ -7636,9 +8116,37 @@ test_scheduler_attach_slave_op(void)
                struct rte_cryptodev_info info;
 
                rte_cryptodev_info_get(i, &info);
-               if (info.dev_type != RTE_CRYPTODEV_AESNI_MB_PMD)
+               if (info.driver_id != rte_cryptodev_driver_id_get(
+                               RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
                        continue;
 
+               /*
+                * Create the session mempool again, since now there are new devices
+                * to use the mempool.
+                */
+               if (ts_params->session_mpool) {
+                       rte_mempool_free(ts_params->session_mpool);
+                       ts_params->session_mpool = NULL;
+               }
+               unsigned int session_size = rte_cryptodev_get_private_session_size(i);
+
+               /*
+                * Create mempool with maximum number of sessions * 2,
+                * to include the session headers
+                */
+               if (ts_params->session_mpool == NULL) {
+                       ts_params->session_mpool = rte_mempool_create(
+                                       "test_sess_mp",
+                                       info.sym.max_nb_sessions * 2,
+                                       session_size,
+                                       0, 0, NULL, NULL, NULL,
+                                       NULL, SOCKET_ID_ANY,
+                                       0);
+
+                       TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
+                                       "session mempool allocation failed");
+               }
+
                ret = rte_cryptodev_scheduler_slave_attach(sched_id,
                                (uint8_t)i);
 
@@ -7750,8 +8258,25 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                                                test_AES_docsis_qat_all),
                TEST_CASE_ST(ut_setup, ut_teardown,
                                                test_DES_docsis_qat_all),
+               TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_qat_all),
                TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
 
+               /** AES CCM Authenticated Encryption 128 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_128_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_128_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_128_3),
+
+               /** AES CCM Authenticated Decryption 128 bits key*/
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_128_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_128_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_128_3),
+
                /** AES GCM Authenticated Encryption */
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
@@ -7760,35 +8285,83 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_1),
+                       test_AES_GCM_authenticated_encryption_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_2),
+                       test_AES_GCM_authenticated_encryption_test_case_2),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_3),
+                       test_AES_GCM_authenticated_encryption_test_case_3),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_4),
+                       test_AES_GCM_authenticated_encryption_test_case_4),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_5),
+                       test_AES_GCM_authenticated_encryption_test_case_5),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_6),
+                       test_AES_GCM_authenticated_encryption_test_case_6),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_7),
+                       test_AES_GCM_authenticated_encryption_test_case_7),
 
                /** AES GCM Authenticated Decryption */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_1),
+                       test_AES_GCM_authenticated_decryption_test_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_7),
+
+               /** AES GCM Authenticated Encryption 192 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_2),
+                       test_AES_GCM_auth_encryption_test_case_192_2),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_3),
+                       test_AES_GCM_auth_encryption_test_case_192_3),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_4),
+                       test_AES_GCM_auth_encryption_test_case_192_4),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_5),
+                       test_AES_GCM_auth_encryption_test_case_192_5),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_6),
+                       test_AES_GCM_auth_encryption_test_case_192_6),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_7),
+                       test_AES_GCM_auth_encryption_test_case_192_7),
+
+               /** AES GCM Authenticated Decryption 192 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_7),
+
+               /** AES GCM Authenticated Encryption 256 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_256_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_256_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_256_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_256_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_256_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_256_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_256_7),
 
                /** AES GMAC Authentication */
                TEST_CASE_ST(ut_setup, ut_teardown,
@@ -7895,10 +8468,31 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_null_auth_cipher_operation),
 
+               /** KASUMI tests */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_kasumi_hash_generate_test_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_kasumi_hash_generate_test_case_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_kasumi_hash_generate_test_case_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_kasumi_hash_generate_test_case_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_kasumi_hash_generate_test_case_5),
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_kasumi_hash_generate_test_case_6),
 
-               /** KASUMI tests */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_kasumi_hash_verify_test_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_kasumi_hash_verify_test_case_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_kasumi_hash_verify_test_case_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_kasumi_hash_verify_test_case_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_kasumi_hash_verify_test_case_5),
+
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_kasumi_encryption_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
@@ -7935,6 +8529,10 @@ static struct unit_test_suite cryptodev_aesni_mb_testsuite  = {
                TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_mb_all),
                TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_mb_all),
                TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_mb_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                                               test_DES_cipheronly_mb_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                                               test_DES_docsis_mb_all),
 
                TEST_CASES_END() /**< NULL terminate unit test array */
        }
@@ -7956,6 +8554,8 @@ static struct unit_test_suite cryptodev_openssl_testsuite  = {
                                test_3DES_chain_openssl_all),
                TEST_CASE_ST(ut_setup, ut_teardown,
                                test_3DES_cipheronly_openssl_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                               test_DES_cipheronly_openssl_all),
                TEST_CASE_ST(ut_setup, ut_teardown,
                                test_DES_docsis_openssl_all),
                TEST_CASE_ST(ut_setup, ut_teardown,
@@ -7963,35 +8563,100 @@ static struct unit_test_suite cryptodev_openssl_testsuite  = {
 
                /** AES GCM Authenticated Encryption */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_1),
+                       test_AES_GCM_authenticated_encryption_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_2),
+                       test_AES_GCM_authenticated_encryption_test_case_2),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_3),
+                       test_AES_GCM_authenticated_encryption_test_case_3),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_4),
+                       test_AES_GCM_authenticated_encryption_test_case_4),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_5),
+                       test_AES_GCM_authenticated_encryption_test_case_5),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_6),
+                       test_AES_GCM_authenticated_encryption_test_case_6),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_7),
+                       test_AES_GCM_authenticated_encryption_test_case_7),
 
                /** AES GCM Authenticated Decryption */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_1),
+                       test_AES_GCM_authenticated_decryption_test_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_7),
+
+
+               /** AES GCM Authenticated Encryption 192 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_7),
+
+               /** AES GCM Authenticated Decryption 192 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_7),
+
+               /** AES GCM Authenticated Encryption 256 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_256_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_2),
+                       test_AES_GCM_auth_encryption_test_case_256_2),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_3),
+                       test_AES_GCM_auth_encryption_test_case_256_3),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_4),
+                       test_AES_GCM_auth_encryption_test_case_256_4),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_5),
+                       test_AES_GCM_auth_encryption_test_case_256_5),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_6),
+                       test_AES_GCM_auth_encryption_test_case_256_6),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_7),
+                       test_AES_GCM_auth_encryption_test_case_256_7),
+
+               /** AES GCM Authenticated Decryption 256 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_7),
 
                /** AES GMAC Authentication */
                TEST_CASE_ST(ut_setup, ut_teardown,
@@ -8011,6 +8676,54 @@ static struct unit_test_suite cryptodev_openssl_testsuite  = {
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_AES_GMAC_authentication_verify_test_case_4),
 
+               /** AES CCM Authenticated Encryption 128 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_128_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_128_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_128_3),
+
+               /** AES CCM Authenticated Decryption 128 bits key*/
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_128_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_128_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_128_3),
+
+               /** AES CCM Authenticated Encryption 192 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_192_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_192_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_192_3),
+
+               /** AES CCM Authenticated Decryption 192 bits key*/
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_192_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_192_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_192_3),
+
+               /** AES CCM Authenticated Encryption 256 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_256_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_256_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_encryption_test_case_256_3),
+
+               /** AES CCM Authenticated Decryption 256 bits key*/
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_256_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_256_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_CCM_authenticated_decryption_test_case_256_3),
+
                /** Scatter-Gather */
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
@@ -8040,79 +8753,111 @@ static struct unit_test_suite cryptodev_aesni_gcm_testsuite  = {
        .unit_test_cases = {
                /** AES GCM Authenticated Encryption */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_1),
+                       test_AES_GCM_authenticated_encryption_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_2),
+                       test_AES_GCM_authenticated_encryption_test_case_2),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_3),
+                       test_AES_GCM_authenticated_encryption_test_case_3),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_4),
+                       test_AES_GCM_authenticated_encryption_test_case_4),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_5),
+                       test_AES_GCM_authenticated_encryption_test_case_5),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_6),
+                       test_AES_GCM_authenticated_encryption_test_case_6),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_test_case_7),
+                       test_AES_GCM_authenticated_encryption_test_case_7),
 
                /** AES GCM Authenticated Decryption */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_1),
+                       test_AES_GCM_authenticated_decryption_test_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_7),
+
+               /** AES GCM Authenticated Encryption 192 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_7),
+
+               /** AES GCM Authenticated Decryption 192 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_2),
+                       test_AES_GCM_auth_decryption_test_case_192_2),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_3),
+                       test_AES_GCM_auth_decryption_test_case_192_3),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_4),
+                       test_AES_GCM_auth_decryption_test_case_192_4),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_5),
+                       test_AES_GCM_auth_decryption_test_case_192_5),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_6),
+                       test_AES_GCM_auth_decryption_test_case_192_6),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_test_case_7),
+                       test_AES_GCM_auth_decryption_test_case_192_7),
 
                /** AES GCM Authenticated Encryption 256 bits key */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_encryption_test_case_256_1),
+                       test_AES_GCM_auth_encryption_test_case_256_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_encryption_test_case_256_2),
+                       test_AES_GCM_auth_encryption_test_case_256_2),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_encryption_test_case_256_3),
+                       test_AES_GCM_auth_encryption_test_case_256_3),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_encryption_test_case_256_4),
+                       test_AES_GCM_auth_encryption_test_case_256_4),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_encryption_test_case_256_5),
+                       test_AES_GCM_auth_encryption_test_case_256_5),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_encryption_test_case_256_6),
+                       test_AES_GCM_auth_encryption_test_case_256_6),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_encryption_test_case_256_7),
+                       test_AES_GCM_auth_encryption_test_case_256_7),
 
                /** AES GCM Authenticated Decryption 256 bits key */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_decryption_test_case_256_1),
+                       test_AES_GCM_auth_decryption_test_case_256_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_decryption_test_case_256_2),
+                       test_AES_GCM_auth_decryption_test_case_256_2),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_decryption_test_case_256_3),
+                       test_AES_GCM_auth_decryption_test_case_256_3),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_decryption_test_case_256_4),
+                       test_AES_GCM_auth_decryption_test_case_256_4),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_decryption_test_case_256_5),
+                       test_AES_GCM_auth_decryption_test_case_256_5),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_decryption_test_case_256_6),
+                       test_AES_GCM_auth_decryption_test_case_256_6),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_decryption_test_case_256_7),
+                       test_AES_GCM_auth_decryption_test_case_256_7),
 
                /** AES GCM Authenticated Encryption big aad size */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_encryption_test_case_aad_1),
+                       test_AES_GCM_auth_encryption_test_case_aad_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_encryption_test_case_aad_2),
+                       test_AES_GCM_auth_encryption_test_case_aad_2),
 
                /** AES GCM Authenticated Decryption big aad size */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_decryption_test_case_aad_1),
+                       test_AES_GCM_auth_decryption_test_case_aad_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_auth_decryption_test_case_aad_2),
+                       test_AES_GCM_auth_decryption_test_case_aad_2),
 
                /** AES GMAC Authentication */
                TEST_CASE_ST(ut_setup, ut_teardown,
@@ -8136,15 +8881,15 @@ static struct unit_test_suite cryptodev_aesni_gcm_testsuite  = {
 
                /** Out of place tests */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_oop),
+                       test_AES_GCM_authenticated_encryption_oop_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_oop),
+                       test_AES_GCM_authenticated_decryption_oop_test_case_1),
 
                /** Session-less tests */
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_encryption_sessionless),
+                       test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                       test_mb_AES_GCM_authenticated_decryption_sessionless),
+                       test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
 
                /** Scatter-Gather */
                TEST_CASE_ST(ut_setup, ut_teardown,
@@ -8334,28 +9079,116 @@ static struct unit_test_suite cryptodev_dpaa2_sec_testsuite  = {
        .teardown = testsuite_teardown,
        .unit_test_cases = {
                TEST_CASE_ST(ut_setup, ut_teardown,
-                            test_device_configure_invalid_dev_id),
+                       test_device_configure_invalid_dev_id),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                            test_multi_session),
+                       test_multi_session),
 
                TEST_CASE_ST(ut_setup, ut_teardown,
-                            test_AES_chain_dpaa2_sec_all),
+                       test_AES_chain_dpaa2_sec_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_3DES_chain_dpaa2_sec_all),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                            test_3DES_chain_dpaa2_sec_all),
+                       test_AES_cipheronly_dpaa2_sec_all),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                            test_AES_cipheronly_dpaa2_sec_all),
+                       test_3DES_cipheronly_dpaa2_sec_all),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                            test_3DES_cipheronly_dpaa2_sec_all),
+                       test_authonly_dpaa2_sec_all),
 
-               /** HMAC_MD5 Authentication */
+               /** AES GCM Authenticated Encryption */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_encryption_test_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_encryption_test_case_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_encryption_test_case_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_encryption_test_case_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_encryption_test_case_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_encryption_test_case_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_encryption_test_case_7),
+
+               /** AES GCM Authenticated Decryption */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_test_case_7),
+
+               /** AES GCM Authenticated Encryption 192 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_192_7),
+
+               /** AES GCM Authenticated Decryption 192 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_192_5),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                            test_MD5_HMAC_generate_case_1),
+                       test_AES_GCM_auth_decryption_test_case_192_6),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                            test_MD5_HMAC_verify_case_1),
+                       test_AES_GCM_auth_decryption_test_case_192_7),
+
+               /** AES GCM Authenticated Encryption 256 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_256_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_256_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_256_3),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                            test_MD5_HMAC_generate_case_2),
+                       test_AES_GCM_auth_encryption_test_case_256_4),
                TEST_CASE_ST(ut_setup, ut_teardown,
-                            test_MD5_HMAC_verify_case_2),
+                       test_AES_GCM_auth_encryption_test_case_256_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_256_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_encryption_test_case_256_7),
+
+               /** AES GCM Authenticated Decryption 256 bits key */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_3),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_4),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_5),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_6),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_auth_decryption_test_case_256_7),
 
                TEST_CASES_END() /**< NULL terminate unit test array */
        }
@@ -8403,14 +9236,31 @@ static struct unit_test_suite cryptodev_armv8_testsuite  = {
 static int
 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
 {
-       gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD;
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_QAT is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_FAILED;
+       }
+
        return unit_test_suite_runner(&cryptodev_qat_testsuite);
 }
 
 static int
 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
 {
-       gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_MB_PMD;
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_FAILED;
+       }
 
        return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
 }
@@ -8418,7 +9268,15 @@ test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
 static int
 test_cryptodev_openssl(void)
 {
-       gbl_cryptodev_type = RTE_CRYPTODEV_OPENSSL_PMD;
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_FAILED;
+       }
 
        return unit_test_suite_runner(&cryptodev_openssl_testsuite);
 }
@@ -8426,7 +9284,15 @@ test_cryptodev_openssl(void)
 static int
 test_cryptodev_aesni_gcm(void)
 {
-       gbl_cryptodev_type = RTE_CRYPTODEV_AESNI_GCM_PMD;
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_FAILED;
+       }
 
        return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
 }
@@ -8434,7 +9300,15 @@ test_cryptodev_aesni_gcm(void)
 static int
 test_cryptodev_null(void)
 {
-       gbl_cryptodev_type = RTE_CRYPTODEV_NULL_PMD;
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_NULL_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "NULL PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_NULL is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_FAILED;
+       }
 
        return unit_test_suite_runner(&cryptodev_null_testsuite);
 }
@@ -8442,7 +9316,15 @@ test_cryptodev_null(void)
 static int
 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
 {
-       gbl_cryptodev_type = RTE_CRYPTODEV_SNOW3G_PMD;
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_FAILED;
+       }
 
        return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
 }
@@ -8450,7 +9332,15 @@ test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
 static int
 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
 {
-       gbl_cryptodev_type = RTE_CRYPTODEV_KASUMI_PMD;
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_KASUMI is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_FAILED;
+       }
 
        return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
 }
@@ -8458,7 +9348,15 @@ test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
 static int
 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
 {
-       gbl_cryptodev_type = RTE_CRYPTODEV_ZUC_PMD;
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_ZUC is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_FAILED;
+       }
 
        return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
 }
@@ -8466,7 +9364,15 @@ test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
 static int
 test_cryptodev_armv8(void)
 {
-       gbl_cryptodev_type = RTE_CRYPTODEV_ARMV8_PMD;
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_FAILED;
+       }
 
        return unit_test_suite_runner(&cryptodev_armv8_testsuite);
 }
@@ -8476,7 +9382,22 @@ test_cryptodev_armv8(void)
 static int
 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
 {
-       gbl_cryptodev_type = RTE_CRYPTODEV_SCHEDULER_PMD;
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_SCHEDULER is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_FAILED;
+       }
+
+       if (rte_cryptodev_driver_id_get(
+                               RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
+               RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
+                       " enabled in config file to run this testsuite.\n");
+               return TEST_FAILED;
+}
        return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
 }
 
@@ -8487,7 +9408,16 @@ REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
 static int
 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
 {
-       gbl_cryptodev_type = RTE_CRYPTODEV_DPAA2_SEC_PMD;
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_FAILED;
+       }
+
        return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
 }