test: rely on dynamic log level to display hexdumps

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

diff --git a/test/test/test_cryptodev.c b/test/test/test_cryptodev.c
index 8be8e57..6662bf3 100644 (file)
--- a/test/test/test_cryptodev.c
+++ b/test/test/test_cryptodev.c
@@ -36,6 +36,7 @@
 #include <rte_malloc.h>
 #include <rte_memcpy.h>
 #include <rte_pause.h>
+#include <rte_bus_vdev.h>
 
 #include <rte_crypto.h>
 #include <rte_cryptodev.h>
@@ -341,6 +342,28 @@ testsuite_setup(void)
                }
        }
 
+       /* Create a MRVL device if required */
+       if (gbl_driver_id == rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_MRVL_PMD))) {
+#ifndef RTE_LIBRTE_PMD_MRVL_CRYPTO
+               RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_MRVL_CRYPTO must be"
+                       " enabled in config file to run this testsuite.\n");
+               return TEST_FAILED;
+#endif
+               nb_devs = rte_cryptodev_device_count_by_driver(
+                               rte_cryptodev_driver_id_get(
+                               RTE_STR(CRYPTODEV_NAME_MRVL_PMD)));
+               if (nb_devs < 1) {
+                       ret = rte_vdev_init(
+                               RTE_STR(CRYPTODEV_NAME_MRVL_PMD),
+                               NULL);
+
+                       TEST_ASSERT(ret == 0, "Failed to create "
+                               "instance of pmd : %s",
+                               RTE_STR(CRYPTODEV_NAME_MRVL_PMD));
+               }
+       }
+
 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
        if (gbl_driver_id == rte_cryptodev_driver_id_get(
                        RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
@@ -1310,7 +1333,7 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
 
        /* Set crypto operation authentication parameters */
        sym_op->auth.digest.data = ut_params->digest;
-       sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+       sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
                        ut_params->ibuf, QUOTE_512_BYTES);
 
        sym_op->auth.data.offset = 0;
@@ -1462,7 +1485,7 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
        sym_op->m_src = ut_params->ibuf;
 
        sym_op->auth.digest.data = ut_params->digest;
-       sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+       sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
                        ut_params->ibuf, QUOTE_512_BYTES);
 
        sym_op->auth.data.offset = 0;
@@ -1767,6 +1790,63 @@ test_AES_cipheronly_qat_all(void)
        return TEST_SUCCESS;
 }
 
+static int
+test_AES_chain_dpaa_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_DPAA_SEC_PMD)),
+               BLKCIPHER_AES_CHAIN_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
+static int
+test_AES_cipheronly_dpaa_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_DPAA_SEC_PMD)),
+               BLKCIPHER_AES_CIPHERONLY_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
+static int
+test_authonly_dpaa_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_DPAA_SEC_PMD)),
+               BLKCIPHER_AUTHONLY_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
 static int
 test_AES_chain_dpaa2_sec_all(void)
 {
@@ -1862,6 +1942,101 @@ test_AES_chain_armv8_all(void)
        return TEST_SUCCESS;
 }
 
+static int
+test_AES_chain_mrvl_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_MRVL_PMD)),
+               BLKCIPHER_AES_CHAIN_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
+static int
+test_AES_cipheronly_mrvl_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_MRVL_PMD)),
+               BLKCIPHER_AES_CIPHERONLY_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
+static int
+test_authonly_mrvl_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_MRVL_PMD)),
+               BLKCIPHER_AUTHONLY_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
+static int
+test_3DES_chain_mrvl_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_MRVL_PMD)),
+               BLKCIPHER_3DES_CHAIN_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
+static int
+test_3DES_cipheronly_mrvl_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_MRVL_PMD)),
+               BLKCIPHER_3DES_CIPHERONLY_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
 /* ***** SNOW 3G Tests ***** */
 static int
 create_wireless_algo_hash_session(uint8_t dev_id,
@@ -1877,7 +2052,7 @@ create_wireless_algo_hash_session(uint8_t dev_id,
 
        memcpy(hash_key, key, key_len);
 
-       TEST_HEXDUMP(stdout, "key:", key, key_len);
+       debug_hexdump(stdout, "key:", key, key_len);
 
        /* Setup Authentication Parameters */
        ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
@@ -1924,7 +2099,7 @@ create_wireless_algo_cipher_session(uint8_t dev_id,
        ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
        ut_params->cipher_xform.cipher.iv.length = iv_len;
 
-       TEST_HEXDUMP(stdout, "key:", key, key_len);
+       debug_hexdump(stdout, "key:", key, key_len);
 
        /* Create Crypto session */
        ut_params->sess = rte_cryptodev_sym_session_create(
@@ -2040,7 +2215,7 @@ create_wireless_algo_cipher_auth_session(uint8_t dev_id,
        ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
        ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
 
-       TEST_HEXDUMP(stdout, "key:", key, key_len);
+       debug_hexdump(stdout, "key:", key, key_len);
 
        /* Create Crypto session*/
        ut_params->sess = rte_cryptodev_sym_session_create(
@@ -2099,7 +2274,7 @@ create_wireless_cipher_auth_session(uint8_t dev_id,
        ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
 
 
-       TEST_HEXDUMP(stdout, "key:", key, key_len);
+       debug_hexdump(stdout, "key:", key, key_len);
 
        /* Create Crypto session*/
        ut_params->sess = rte_cryptodev_sym_session_create(
@@ -2161,7 +2336,7 @@ create_wireless_algo_auth_cipher_session(uint8_t dev_id,
        ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
        ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
 
-       TEST_HEXDUMP(stdout, "key:", key, key_len);
+       debug_hexdump(stdout, "key:", key, key_len);
 
        /* Create Crypto session*/
        ut_params->sess = rte_cryptodev_sym_session_create(
@@ -2211,14 +2386,14 @@ create_wireless_algo_hash_operation(const uint8_t *auth_tag,
        TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
                                "no room to append auth tag");
        ut_params->digest = sym_op->auth.digest.data;
-       sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+       sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
                        ut_params->ibuf, data_pad_len);
        if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
                memset(sym_op->auth.digest.data, 0, auth_tag_len);
        else
                rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
 
-       TEST_HEXDUMP(stdout, "digest:",
+       debug_hexdump(stdout, "digest:",
                sym_op->auth.digest.data,
                auth_tag_len);
 
@@ -2267,14 +2442,14 @@ create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
        TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
                        "no room to append auth tag");
        ut_params->digest = sym_op->auth.digest.data;
-       sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+       sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
                        ut_params->ibuf, data_pad_len);
        if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
                memset(sym_op->auth.digest.data, 0, auth_tag_len);
        else
                rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
 
-       TEST_HEXDUMP(stdout, "digest:",
+       debug_hexdump(stdout, "digest:",
                sym_op->auth.digest.data,
                auth_tag_len);
 
@@ -2334,14 +2509,14 @@ create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
        TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
                        "no room to append auth tag");
        ut_params->digest = sym_op->auth.digest.data;
-       sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+       sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
                        ut_params->ibuf, data_pad_len);
        if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
                memset(sym_op->auth.digest.data, 0, auth_tag_len);
        else
                rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
 
-       TEST_HEXDUMP(stdout, "digest:",
+       debug_hexdump(stdout, "digest:",
                sym_op->auth.digest.data,
                auth_tag_len);
 
@@ -2392,12 +2567,12 @@ create_wireless_algo_auth_cipher_operation(unsigned int auth_tag_len,
        TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
                        "no room to append auth tag");
 
-       sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+       sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
                        ut_params->ibuf, data_pad_len);
 
        memset(sym_op->auth.digest.data, 0, auth_tag_len);
 
-       TEST_HEXDUMP(stdout, "digest:",
+       debug_hexdump(stdout, "digest:",
                        sym_op->auth.digest.data,
                        auth_tag_len);
 
@@ -2830,7 +3005,7 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
                                plaintext_pad_len);
        memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
        /* Create KASUMI operation */
        retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
@@ -2850,7 +3025,7 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
        else
                ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 
        const uint8_t *reference_ciphertext = tdata->ciphertext.data +
                                (tdata->validCipherOffsetInBits.len >> 3);
@@ -2930,7 +3105,7 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
                                plaintext_len, buffer);
 
        /* Validate obuf */
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 
        const uint8_t *reference_ciphertext = tdata->ciphertext.data +
                                (tdata->validCipherOffsetInBits.len >> 3);
@@ -2979,7 +3154,7 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
        rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
        memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
        /* Create KASUMI operation */
        retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
@@ -2999,7 +3174,7 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
        else
                ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 
        const uint8_t *reference_ciphertext = tdata->ciphertext.data +
                                (tdata->validCipherOffsetInBits.len >> 3);
@@ -3126,7 +3301,7 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
        rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
        memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
 
        /* Create KASUMI operation */
        retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
@@ -3146,7 +3321,7 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
        else
                plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
 
        const uint8_t *reference_plaintext = tdata->plaintext.data +
                                (tdata->validCipherOffsetInBits.len >> 3);
@@ -3193,7 +3368,7 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
                                ciphertext_pad_len);
        memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
 
        /* Create KASUMI operation */
        retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
@@ -3213,7 +3388,7 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
        else
                plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
 
        const uint8_t *reference_plaintext = tdata->plaintext.data +
                                (tdata->validCipherOffsetInBits.len >> 3);
@@ -3260,7 +3435,7 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata)
                                plaintext_pad_len);
        memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
        /* Create SNOW 3G operation */
        retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
@@ -3280,7 +3455,7 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata)
        else
                ciphertext = plaintext;
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
@@ -3333,7 +3508,7 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
        rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
        memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
        /* Create SNOW 3G operation */
        retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
@@ -3353,7 +3528,7 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
        else
                ciphertext = plaintext;
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
@@ -3431,7 +3606,7 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
                ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
                                plaintext_len, buffer);
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
@@ -3589,7 +3764,7 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
                                ciphertext_pad_len);
        memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
 
        /* Create SNOW 3G operation */
        retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
@@ -3608,7 +3783,7 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
        else
                plaintext = ciphertext;
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
@@ -3662,7 +3837,7 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
        rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
        memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, ciphertext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
 
        /* Create SNOW 3G operation */
        retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
@@ -3681,7 +3856,7 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
        else
                plaintext = ciphertext;
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, ciphertext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
@@ -3741,7 +3916,7 @@ test_zuc_cipher_auth(const struct wireless_test_data *tdata)
                                plaintext_pad_len);
        memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
        /* Create ZUC operation */
        retval = create_zuc_cipher_hash_generate_operation(tdata);
@@ -3757,7 +3932,7 @@ test_zuc_cipher_auth(const struct wireless_test_data *tdata)
        else
                ciphertext = plaintext;
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
                        ciphertext,
@@ -3814,7 +3989,7 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
                                plaintext_pad_len);
        memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
        /* Create SNOW 3G operation */
        retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
@@ -3839,7 +4014,7 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
        else
                ciphertext = plaintext;
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
                        ciphertext,
@@ -3896,7 +4071,7 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
                                plaintext_pad_len);
        memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
        /* Create SNOW 3G operation */
        retval = create_wireless_algo_auth_cipher_operation(
@@ -3923,7 +4098,7 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
 
        ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
                        + plaintext_pad_len;
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
@@ -3979,7 +4154,7 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
                                plaintext_pad_len);
        memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
        /* Create KASUMI operation */
        retval = create_wireless_algo_auth_cipher_operation(tdata->digest.len,
@@ -4065,7 +4240,7 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
                                plaintext_pad_len);
        memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
        /* Create KASUMI operation */
        retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
@@ -4157,7 +4332,7 @@ test_zuc_encryption(const struct wireless_test_data *tdata)
                                plaintext_pad_len);
        memcpy(plaintext, tdata->plaintext.data, plaintext_len);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, plaintext_len);
+       debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
 
        /* Create ZUC operation */
        retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
@@ -4177,7 +4352,7 @@ test_zuc_encryption(const struct wireless_test_data *tdata)
        else
                ciphertext = plaintext;
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
@@ -4264,7 +4439,7 @@ test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
                        0, plaintext_len, ciphertext_buffer);
 
        /* Validate obuf */
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, plaintext_len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
@@ -4747,6 +4922,44 @@ test_DES_docsis_mb_all(void)
        return TEST_SUCCESS;
 }
 
+static int
+test_3DES_chain_dpaa_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_DPAA_SEC_PMD)),
+               BLKCIPHER_3DES_CHAIN_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
+static int
+test_3DES_cipheronly_dpaa_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_DPAA_SEC_PMD)),
+               BLKCIPHER_3DES_CIPHERONLY_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
 static int
 test_3DES_chain_dpaa2_sec_all(void)
 {
@@ -4870,7 +5083,7 @@ create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
        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);
+       debug_hexdump(stdout, "key:", key, key_len);
 
        /* Create Crypto session*/
        ut_params->sess = rte_cryptodev_sym_session_create(
@@ -4909,7 +5122,7 @@ create_aead_xform(struct rte_crypto_op *op,
        sym_op->xform->aead.digest_length = auth_len;
        sym_op->xform->aead.aad_length = aad_len;
 
-       TEST_HEXDUMP(stdout, "key:", key, key_len);
+       debug_hexdump(stdout, "key:", key, key_len);
 
        return 0;
 }
@@ -4941,10 +5154,10 @@ create_aead_operation(enum rte_crypto_aead_operation op,
                                "no room to append aad");
 
                sym_op->aead.aad.phys_addr =
-                               rte_pktmbuf_mtophys(ut_params->ibuf);
+                               rte_pktmbuf_iova(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,
+               debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
                        tdata->aad.len);
 
                /* Append IV at the end of the crypto operation*/
@@ -4953,7 +5166,7 @@ create_aead_operation(enum rte_crypto_aead_operation op,
 
                /* 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,
+               debug_hexdump(stdout, "iv:", iv_ptr,
                        tdata->iv.len);
        } else {
                aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
@@ -4963,9 +5176,9 @@ create_aead_operation(enum rte_crypto_aead_operation op,
                                "no room to append aad");
 
                sym_op->aead.aad.phys_addr =
-                               rte_pktmbuf_mtophys(ut_params->ibuf);
+                               rte_pktmbuf_iova(ut_params->ibuf);
                memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
-               TEST_HEXDUMP(stdout, "aad:", sym_op->aead.aad.data,
+               debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
                        tdata->aad.len);
 
                /* Append IV at the end of the crypto operation*/
@@ -4973,7 +5186,7 @@ create_aead_operation(enum rte_crypto_aead_operation op,
                                uint8_t *, IV_OFFSET);
 
                rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
-               TEST_HEXDUMP(stdout, "iv:", iv_ptr,
+               debug_hexdump(stdout, "iv:", iv_ptr,
                        tdata->iv.len);
        }
 
@@ -4985,7 +5198,7 @@ create_aead_operation(enum rte_crypto_aead_operation op,
                TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
 
                memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
-               TEST_HEXDUMP(stdout, "plaintext:", plaintext,
+               debug_hexdump(stdout, "plaintext:", plaintext,
                                tdata->plaintext.len);
 
                if (ut_params->obuf) {
@@ -5007,7 +5220,7 @@ create_aead_operation(enum rte_crypto_aead_operation op,
 
                memcpy(ciphertext, tdata->ciphertext.data,
                                tdata->ciphertext.len);
-               TEST_HEXDUMP(stdout, "ciphertext:", ciphertext,
+               debug_hexdump(stdout, "ciphertext:", ciphertext,
                                tdata->ciphertext.len);
 
                if (ut_params->obuf) {
@@ -5031,7 +5244,7 @@ create_aead_operation(enum rte_crypto_aead_operation op,
                TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
                                "no room to append digest");
                memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
-               sym_op->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+               sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
                                ut_params->obuf ? ut_params->obuf :
                                                ut_params->ibuf,
                                                plaintext_pad_len +
@@ -5041,13 +5254,13 @@ create_aead_operation(enum rte_crypto_aead_operation op,
                                ut_params->ibuf, tdata->auth_tag.len);
                TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
                                "no room to append digest");
-               sym_op->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+               sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
                                ut_params->ibuf,
                                plaintext_pad_len + aad_pad_len);
 
                rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
                        tdata->auth_tag.len);
-               TEST_HEXDUMP(stdout, "digest:",
+               debug_hexdump(stdout, "digest:",
                        sym_op->aead.digest.data,
                        tdata->auth_tag.len);
        }
@@ -5121,8 +5334,8 @@ test_authenticated_encryption(const struct aead_test_data *tdata)
                auth_tag = ciphertext + plaintext_pad_len;
        }
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
-       TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
+       debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
@@ -5335,7 +5548,7 @@ test_authenticated_decryption(const struct aead_test_data *tdata)
                                uint8_t *,
                                ut_params->op->sym->cipher.data.offset);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
+       debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
@@ -5540,8 +5753,8 @@ test_authenticated_encryption_oop(const struct aead_test_data *tdata)
                        ut_params->op->sym->cipher.data.offset);
        auth_tag = ciphertext + plaintext_pad_len;
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
-       TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
+       debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
@@ -5614,7 +5827,7 @@ test_authenticated_decryption_oop(const struct aead_test_data *tdata)
        plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
                        ut_params->op->sym->cipher.data.offset);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
+       debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
@@ -5690,8 +5903,8 @@ test_authenticated_encryption_sessionless(
                        ut_params->op->sym->cipher.data.offset);
        auth_tag = ciphertext + plaintext_pad_len;
 
-       TEST_HEXDUMP(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
-       TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
+       debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
+       debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
@@ -5768,7 +5981,7 @@ test_authenticated_decryption_sessionless(
        plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
                        ut_params->op->sym->cipher.data.offset);
 
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
+       debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
 
        /* Validate obuf */
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
@@ -6014,7 +6227,7 @@ static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
                        ut_params->ibuf, MD5_DIGEST_LEN);
        TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
                        "no room to append digest");
-       sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+       sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
                        ut_params->ibuf, plaintext_pad_len);
 
        if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
@@ -6750,13 +6963,13 @@ create_gmac_operation(enum rte_crypto_auth_operation op,
        TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
                        "no room to append digest");
 
-       sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+       sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
                        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:",
+               debug_hexdump(stdout, "digest:",
                                sym_op->auth.digest.data,
                                tdata->gmac_tag.len);
        }
@@ -6766,7 +6979,7 @@ create_gmac_operation(enum rte_crypto_auth_operation op,
 
        rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
 
-       TEST_HEXDUMP(stdout, "iv:", iv_ptr, tdata->iv.len);
+       debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
 
        sym_op->cipher.data.length = 0;
        sym_op->cipher.data.offset = 0;
@@ -6856,7 +7069,7 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
        TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
 
        memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext,
+       debug_hexdump(stdout, "plaintext:", plaintext,
                        tdata->plaintext.len);
 
        retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
@@ -6882,7 +7095,7 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
                auth_tag = plaintext + plaintext_pad_len;
        }
 
-       TEST_HEXDUMP(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
+       debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
 
        TEST_ASSERT_BUFFERS_ARE_EQUAL(
                        auth_tag,
@@ -6960,7 +7173,7 @@ test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
        TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
 
        memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
-       TEST_HEXDUMP(stdout, "plaintext:", plaintext,
+       debug_hexdump(stdout, "plaintext:", plaintext,
                        tdata->plaintext.len);
 
        retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
@@ -7272,7 +7485,7 @@ create_auth_operation(struct crypto_testsuite_params *ts_params,
        TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
                        "no room to append auth tag");
 
-       sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+       sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
                        ut_params->ibuf, reference->plaintext.len);
 
        if (auth_generate)
@@ -7282,7 +7495,7 @@ create_auth_operation(struct crypto_testsuite_params *ts_params,
                                reference->digest.data,
                                reference->digest.len);
 
-       TEST_HEXDUMP(stdout, "digest:",
+       debug_hexdump(stdout, "digest:",
                        sym_op->auth.digest.data,
                        reference->digest.len);
 
@@ -7319,7 +7532,7 @@ create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
        TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
                        "no room to append auth tag");
 
-       sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+       sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
                        ut_params->ibuf, reference->ciphertext.len);
 
        if (auth_generate)
@@ -7329,7 +7542,7 @@ create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
                                reference->digest.data,
                                reference->digest.len);
 
-       TEST_HEXDUMP(stdout, "digest:",
+       debug_hexdump(stdout, "digest:",
                        sym_op->auth.digest.data,
                        reference->digest.len);
 
@@ -7372,7 +7585,7 @@ create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
        TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
                        "no room to append auth tag");
 
-       sym_op->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
+       sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
                        ut_params->ibuf, reference->ciphertext.len);
 
        if (auth_generate)
@@ -7382,7 +7595,7 @@ create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
                                reference->digest.data,
                                reference->digest.len);
 
-       TEST_HEXDUMP(stdout, "digest:",
+       debug_hexdump(stdout, "digest:",
                        sym_op->auth.digest.data,
                        reference->digest.len);
 
@@ -7455,7 +7668,8 @@ test_authentication_verify_fail_when_data_corruption(
        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);
+       debug_hexdump(stdout, "plaintext:", plaintext,
+               reference->plaintext.len);
 
        /* Create operation */
        retval = create_auth_verify_operation(ts_params, ut_params, reference);
@@ -7513,7 +7727,8 @@ test_authentication_verify_GMAC_fail_when_corruption(
        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);
+       debug_hexdump(stdout, "plaintext:", plaintext,
+               reference->plaintext.len);
 
        /* Create operation */
        retval = create_auth_verify_GMAC_operation(ts_params,
@@ -7632,7 +7847,7 @@ create_aead_operation_SGL(enum rte_crypto_aead_operation op,
        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:",
+               debug_hexdump(stdout, "digest:",
                                sym_op->aead.digest.data,
                                auth_tag_len);
        }
@@ -7651,15 +7866,15 @@ create_aead_operation_SGL(enum rte_crypto_aead_operation op,
                                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(
+               sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
                                ut_params->ibuf);
 
                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);
 
-               TEST_HEXDUMP(stdout, "iv:", iv_ptr, iv_len);
-               TEST_HEXDUMP(stdout, "aad:",
+               debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
+               debug_hexdump(stdout, "aad:",
                                sym_op->aead.aad.data, aad_len);
        } else {
                uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
@@ -7671,14 +7886,14 @@ create_aead_operation_SGL(enum rte_crypto_aead_operation op,
                                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(
+               sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
                                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:",
+               debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
+               debug_hexdump(stdout, "aad:",
                                sym_op->aead.aad.data, aad_len);
        }
 
@@ -7818,7 +8033,7 @@ test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
                        digest_mem = rte_pktmbuf_append(ut_params->obuf,
                                tdata->auth_tag.len);
 
-                       digest_phys = rte_pktmbuf_mtophys_offset(
+                       digest_phys = rte_pktmbuf_iova_offset(
                                        ut_params->obuf,
                                        tdata->plaintext.len + prepend_len);
                }
@@ -7856,14 +8071,14 @@ test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
         * Place digest at the end of the last buffer
         */
        if (!digest_phys)
-               digest_phys = rte_pktmbuf_mtophys(buf) + to_trn;
+               digest_phys = rte_pktmbuf_iova(buf) + to_trn;
        if (oop && buf_last_oop)
-               digest_phys = rte_pktmbuf_mtophys(buf_last_oop) + to_trn;
+               digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
 
        if (!digest_mem && !oop) {
                digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
                                + tdata->auth_tag.len);
-               digest_phys = rte_pktmbuf_mtophys_offset(ut_params->ibuf,
+               digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
                                tdata->plaintext.len);
        }
 
@@ -9073,6 +9288,101 @@ static struct unit_test_suite cryptodev_sw_zuc_testsuite  = {
        }
 };
 
+static struct unit_test_suite cryptodev_dpaa_sec_testsuite  = {
+       .suite_name = "Crypto DPAA_SEC Unit Test Suite",
+       .setup = testsuite_setup,
+       .teardown = testsuite_teardown,
+       .unit_test_cases = {
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_device_configure_invalid_dev_id),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_multi_session),
+
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_AES_chain_dpaa_sec_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_3DES_chain_dpaa_sec_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_AES_cipheronly_dpaa_sec_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_3DES_cipheronly_dpaa_sec_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_authonly_dpaa_sec_all),
+
+               /** 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 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 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),
+
+               /** Out of place tests */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_encryption_oop_test_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_oop_test_case_1),
+
+               TEST_CASES_END() /**< NULL terminate unit test array */
+       }
+};
+
 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite  = {
        .suite_name = "Crypto DPAA2_SEC Unit Test Suite",
        .setup = testsuite_setup,
@@ -9190,6 +9500,12 @@ static struct unit_test_suite cryptodev_dpaa2_sec_testsuite  = {
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_AES_GCM_auth_decryption_test_case_256_7),
 
+               /** Out of place tests */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_encryption_oop_test_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       test_AES_GCM_authenticated_decryption_oop_test_case_1),
+
                TEST_CASES_END() /**< NULL terminate unit test array */
        }
 };
@@ -9233,6 +9549,40 @@ static struct unit_test_suite cryptodev_armv8_testsuite  = {
        }
 };
 
+static struct unit_test_suite cryptodev_mrvl_testsuite  = {
+       .suite_name = "Crypto Device Marvell Component Test Suite",
+       .setup = testsuite_setup,
+       .teardown = testsuite_teardown,
+       .unit_test_cases = {
+               TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                               test_multi_session_random_usage),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                               test_AES_chain_mrvl_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                               test_AES_cipheronly_mrvl_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                               test_authonly_mrvl_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                               test_3DES_chain_mrvl_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                               test_3DES_cipheronly_mrvl_all),
+
+               /** Negative tests */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       authentication_verify_HMAC_SHA1_fail_data_corrupt),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       authentication_verify_HMAC_SHA1_fail_tag_corrupt),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                       auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
+
+               TEST_CASES_END() /**< NULL terminate unit test array */
+       }
+};
+
+
 static int
 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
 {
@@ -9377,6 +9727,22 @@ test_cryptodev_armv8(void)
        return unit_test_suite_runner(&cryptodev_armv8_testsuite);
 }
 
+static int
+test_cryptodev_mrvl(void)
+{
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_MRVL_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "MRVL PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_MRVL_CRYPTO is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_FAILED;
+       }
+
+       return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
+}
+
 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
 
 static int
@@ -9421,6 +9787,22 @@ test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
        return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
 }
 
+static int
+test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
+{
+       gbl_driver_id = rte_cryptodev_driver_id_get(
+                       RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
+
+       if (gbl_driver_id == -1) {
+               RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded. Check if "
+                               "CONFIG_RTE_LIBRTE_PMD_DPAA_SEC is enabled "
+                               "in config file to run this testsuite.\n");
+               return TEST_FAILED;
+       }
+
+       return unit_test_suite_runner(&cryptodev_dpaa_sec_testsuite);
+}
+
 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
@@ -9430,4 +9812,6 @@ REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
+REGISTER_TEST_COMMAND(cryptodev_sw_mrvl_autotest, test_cryptodev_mrvl);
 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
+REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);