crypto/aesni_mb: support DES

[dpdk.git] / test / test / test_cryptodev.c

diff --git a/test/test/test_cryptodev.c b/test/test/test_cryptodev.c
index e5d6c07..aa0ca51 100644 (file)
--- a/test/test/test_cryptodev.c
+++ b/test/test/test_cryptodev.c
@@ -68,7 +68,6 @@ struct crypto_testsuite_params {
        struct rte_mempool *large_mbuf_pool;
        struct rte_mempool *op_mpool;
        struct rte_mempool *session_mpool;
-       struct rte_mempool *slave_session_mpool;
        struct rte_cryptodev_config conf;
        struct rte_cryptodev_qp_conf qp_conf;
 
@@ -387,12 +386,15 @@ testsuite_setup(void)
        ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
        ts_params->conf.socket_id = SOCKET_ID_ANY;
 
-       unsigned int session_size = sizeof(struct rte_cryptodev_sym_session) +
-               rte_cryptodev_get_private_session_size(dev_id);
+       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,
+                               info.sym.max_nb_sessions * 2,
                                session_size,
                                0, 0, NULL, NULL, NULL,
                                NULL, SOCKET_ID_ANY,
@@ -402,7 +404,7 @@ testsuite_setup(void)
                        "session mempool allocation failed");
 
        TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
-                       &ts_params->conf, ts_params->session_mpool),
+                       &ts_params->conf),
                        "Failed to configure cryptodev %u with %u qps",
                        dev_id, ts_params->conf.nb_queue_pairs);
 
@@ -411,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);
        }
@@ -439,11 +442,6 @@ testsuite_teardown(void)
                rte_mempool_free(ts_params->session_mpool);
                ts_params->session_mpool = NULL;
        }
-
-       if (ts_params->slave_session_mpool != NULL) {
-               rte_mempool_free(ts_params->slave_session_mpool);
-               ts_params->slave_session_mpool = NULL;
-       }
 }
 
 static int
@@ -461,7 +459,7 @@ ut_setup(void)
        ts_params->conf.socket_id = SOCKET_ID_ANY;
 
        TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
-                       &ts_params->conf, ts_params->session_mpool),
+                       &ts_params->conf),
                        "Failed to configure cryptodev %u",
                        ts_params->valid_devs[0]);
 
@@ -469,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]);
        }
@@ -494,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;
        }
 
@@ -544,23 +544,20 @@ test_device_configure_invalid_dev_id(void)
        /* Stop the device in case it's started so it can be configured */
        rte_cryptodev_stop(ts_params->valid_devs[dev_id]);
 
-       TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf,
-                               ts_params->session_mpool),
+       TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
                        "Failed test for rte_cryptodev_configure: "
                        "invalid dev_num %u", dev_id);
 
        /* invalid dev_id values */
        dev_id = num_devs;
 
-       TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf,
-                               ts_params->session_mpool),
+       TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
                        "Failed test for rte_cryptodev_configure: "
                        "invalid dev_num %u", dev_id);
 
        dev_id = 0xff;
 
-       TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf,
-                               ts_params->session_mpool),
+       TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
                        "Failed test for rte_cryptodev_configure:"
                        "invalid dev_num %u", dev_id);
 
@@ -580,7 +577,7 @@ test_device_configure_invalid_queue_pair_ids(void)
        ts_params->conf.nb_queue_pairs = 1;
 
        TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
-                       &ts_params->conf, ts_params->session_mpool),
+                       &ts_params->conf),
                        "Failed to configure cryptodev: dev_id %u, qp_id %u",
                        ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
 
@@ -589,7 +586,7 @@ test_device_configure_invalid_queue_pair_ids(void)
        ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE;
 
        TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
-                       &ts_params->conf, ts_params->session_mpool),
+                       &ts_params->conf),
                        "Failed to configure cryptodev: dev_id %u, qp_id %u",
                        ts_params->valid_devs[0],
                        ts_params->conf.nb_queue_pairs);
@@ -599,7 +596,7 @@ test_device_configure_invalid_queue_pair_ids(void)
        ts_params->conf.nb_queue_pairs = 0;
 
        TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
-                       &ts_params->conf, ts_params->session_mpool),
+                       &ts_params->conf),
                        "Failed test for rte_cryptodev_configure, dev_id %u,"
                        " invalid qps: %u",
                        ts_params->valid_devs[0],
@@ -610,7 +607,7 @@ test_device_configure_invalid_queue_pair_ids(void)
        ts_params->conf.nb_queue_pairs = UINT16_MAX;
 
        TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
-                       &ts_params->conf, ts_params->session_mpool),
+                       &ts_params->conf),
                        "Failed test for rte_cryptodev_configure, dev_id %u,"
                        " invalid qps: %u",
                        ts_params->valid_devs[0],
@@ -621,7 +618,7 @@ test_device_configure_invalid_queue_pair_ids(void)
        ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1;
 
        TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
-                       &ts_params->conf, ts_params->session_mpool),
+                       &ts_params->conf),
                        "Failed test for rte_cryptodev_configure, dev_id %u,"
                        " invalid qps: %u",
                        ts_params->valid_devs[0],
@@ -651,7 +648,7 @@ test_queue_pair_descriptor_setup(void)
        rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
        TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
-                       &ts_params->conf, ts_params->session_mpool),
+                       &ts_params->conf),
                        "Failed to configure cryptodev %u",
                        ts_params->valid_devs[0]);
 
@@ -665,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",
@@ -679,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",
@@ -693,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",
@@ -708,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",
@@ -723,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",
@@ -737,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",
@@ -752,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",
@@ -768,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]);
@@ -778,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]);
@@ -1280,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 */
@@ -1496,7 +1505,9 @@ 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],
+               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);
@@ -1513,7 +1524,9 @@ 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],
+               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);
@@ -1530,7 +1543,9 @@ 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],
+               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);
@@ -1547,7 +1562,9 @@ 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],
+               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);
@@ -1564,7 +1581,9 @@ 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],
+               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);
@@ -1574,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)
 {
@@ -1581,7 +1618,9 @@ 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],
+               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);
@@ -1600,7 +1639,9 @@ 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],
+               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);
@@ -1617,7 +1658,9 @@ 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],
+               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);
@@ -1634,7 +1677,9 @@ 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],
+               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);
@@ -1653,7 +1698,9 @@ 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],
+               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);
@@ -1670,7 +1717,9 @@ 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],
+               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);
@@ -1687,7 +1736,9 @@ 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],
+               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);
@@ -1704,7 +1755,9 @@ 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],
+               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);
@@ -1721,7 +1774,9 @@ 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],
+               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);
@@ -1738,7 +1793,9 @@ 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],
+               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);
@@ -1755,9 +1812,11 @@ test_authonly_dpaa2_sec_all(void)
        int status;
 
        status = test_blockcipher_all_tests(ts_params->mbuf_pool,
-               ts_params->op_mpool, ts_params->valid_devs[0],
+               ts_params->op_mpool,
+               ts_params->session_mpool,
+               ts_params->valid_devs[0],
                rte_cryptodev_driver_id_get(
-               RTE_STR(RTE_CRYPTODEV_DPAA2_SEC_PMD)),
+               RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)),
                BLKCIPHER_AUTHONLY_TYPE);
 
        TEST_ASSERT_EQUAL(status, 0, "Test failed");
@@ -1772,7 +1831,9 @@ 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],
+               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);
@@ -1789,7 +1850,9 @@ 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],
+               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);
@@ -1809,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);
@@ -1826,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;
 }
@@ -1841,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);
@@ -1859,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;
 }
@@ -1940,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);
@@ -1972,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;
@@ -1990,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;
@@ -2027,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;
@@ -2056,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);
@@ -2085,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");
 
@@ -2271,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;
 }
@@ -2327,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;
 }
@@ -2469,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)
@@ -2491,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;
@@ -2529,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)
@@ -2551,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;
@@ -2752,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;
 
@@ -2766,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;
@@ -2825,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;
 
@@ -2841,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
@@ -2896,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;
 
@@ -2910,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;
@@ -2970,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;
 
@@ -2985,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;
@@ -3038,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;
 
@@ -3052,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;
@@ -3105,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;
 
@@ -3117,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;
@@ -3865,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;
@@ -3888,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
                                );
@@ -3902,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 */
@@ -3946,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;
@@ -3969,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
                                );
@@ -3984,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");
 
@@ -4536,7 +4640,9 @@ 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],
+               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);
@@ -4553,7 +4659,9 @@ 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],
+               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);
@@ -4570,7 +4678,9 @@ 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],
+               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);
@@ -4580,6 +4690,44 @@ test_DES_docsis_openssl_all(void)
        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");
+
+       return TEST_SUCCESS;
+}
+
 static int
 test_3DES_chain_dpaa2_sec_all(void)
 {
@@ -4587,7 +4735,9 @@ 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],
+               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);
@@ -4604,7 +4754,9 @@ 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],
+               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);
@@ -4621,7 +4773,9 @@ 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],
+               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);
@@ -4638,7 +4792,9 @@ 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],
+               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);
@@ -4655,7 +4811,9 @@ 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],
+               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);
@@ -4675,6 +4833,7 @@ create_gcm_session(uint8_t dev_id, enum rte_crypto_aead_operation op,
 {
        uint8_t aead_key[key_len];
 
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
 
        memcpy(aead_key, key, key_len);
@@ -4689,13 +4848,16 @@ create_gcm_session(uint8_t dev_id, enum rte_crypto_aead_operation op,
        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.add_auth_data_length = aad_len;
+       ut_params->aead_xform.aead.aad_length = aad_len;
 
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
        /* Create Crypto session*/
-       ut_params->sess = rte_cryptodev_sym_session_create(dev_id,
-                       &ut_params->aead_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->aead_xform, ts_params->session_mpool);
 
        TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
 
@@ -4724,7 +4886,7 @@ create_gcm_xforms(struct rte_crypto_op *op,
        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.add_auth_data_length = aad_len;
+       sym_op->xform->aead.aad_length = aad_len;
 
        TEST_HEXDUMP(stdout, "key:", key, key_len);
 
@@ -5656,7 +5818,11 @@ static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
        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;
@@ -5831,9 +5997,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);
@@ -5869,14 +6039,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);
 
@@ -5934,6 +6107,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));
 
@@ -5942,9 +6118,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",
@@ -5987,9 +6165,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);
 
@@ -6013,9 +6193,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 */
@@ -6070,9 +6255,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 */
@@ -6126,9 +6315,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 */
@@ -6192,9 +6385,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 */
@@ -6240,6 +6437,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;
@@ -6248,10 +6446,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");
 
 
@@ -6262,10 +6464,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;
@@ -6299,9 +6505,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,
@@ -6414,6 +6624,7 @@ static int create_gmac_session(uint8_t dev_id,
 {
        uint8_t auth_key[tdata->key.len];
 
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
        struct crypto_unittest_params *ut_params = &unittest_params;
 
        memcpy(auth_key, tdata->key.data, tdata->key.len);
@@ -6430,8 +6641,12 @@ static int create_gmac_session(uint8_t dev_id,
        ut_params->auth_xform.auth.iv.length = tdata->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");
 
@@ -6791,6 +7006,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);
@@ -6805,8 +7021,12 @@ create_auth_session(struct crypto_unittest_params *ut_params,
        ut_params->auth_xform.auth.digest_length = reference->digest.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");
 
@@ -6820,6 +7040,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];
 
@@ -6853,8 +7074,12 @@ create_auth_cipher_session(struct crypto_unittest_params *ut_params,
        }
 
        /* 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");
 
@@ -7710,30 +7935,32 @@ test_scheduler_attach_slave_op(void)
                        continue;
 
                /*
-                * Create a separate mempool for the slaves, as they need different
-                * session size and then configure them to store the pointer
-                * to this mempool
+                * Create the session mempool again, since now there are new devices
+                * to use the mempool.
                 */
-               unsigned int session_size = sizeof(struct rte_cryptodev_sym_session) +
-                       rte_cryptodev_get_private_session_size(i);
+               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);
 
-               if (ts_params->slave_session_mpool == NULL) {
-                       ts_params->slave_session_mpool = rte_mempool_create(
-                               "test_slave_sess_mp",
-                               info.sym.max_nb_sessions,
-                               session_size,
-                               0, 0, NULL, NULL, NULL, NULL,
-                               SOCKET_ID_ANY, 0);
+               /*
+                * 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->slave_session_mpool,
+                       TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
                                        "session mempool allocation failed");
                }
 
-               TEST_ASSERT_SUCCESS(rte_cryptodev_configure(i,
-                               &ts_params->conf, ts_params->slave_session_mpool),
-                               "Failed to configure cryptodev %u with %u qps",
-                               i, ts_params->conf.nb_queue_pairs);
-
                ret = rte_cryptodev_scheduler_slave_attach(sched_id,
                                (uint8_t)i);
 
@@ -7845,6 +8072,7 @@ 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 GCM Authenticated Encryption */
@@ -8038,10 +8266,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,
@@ -8078,6 +8327,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 */
        }
@@ -8767,8 +9020,8 @@ test_cryptodev_openssl(void)
                        RTE_STR(CRYPTODEV_NAME_OPENSSL_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 "
+               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;
        }