X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=test%2Ftest%2Ftest_cryptodev.c;h=680082f2bf2fbfc335c6054cb65bafb3ced352fe;hb=aed545af1b5ed6b7baa2eb41bad63486d6c95226;hp=df844300edef108b78065c221ca67180a4e02498;hpb=b674d6d0381a752b24df5e7a548459d02ddd1ce4;p=dpdk.git

diff --git a/test/test/test_cryptodev.c b/test/test/test_cryptodev.c
index df844300ed..680082f2bf 100644
--- a/test/test/test_cryptodev.c
+++ b/test/test/test_cryptodev.c
@@ -1,41 +1,16 @@
-/*-
- *   BSD LICENSE
- *
- *   Copyright(c) 2015-2017 Intel Corporation. All rights reserved.
- *
- *   Redistribution and use in source and binary forms, with or without
- *   modification, are permitted provided that the following conditions
- *   are met:
- *
- *	 * Redistributions of source code must retain the above copyright
- *	   notice, this list of conditions and the following disclaimer.
- *	 * Redistributions in binary form must reproduce the above copyright
- *	   notice, this list of conditions and the following disclaimer in
- *	   the documentation and/or other materials provided with the
- *	   distribution.
- *	 * Neither the name of Intel Corporation nor the names of its
- *	   contributors may be used to endorse or promote products derived
- *	   from this software without specific prior written permission.
- *
- *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2015-2017 Intel Corporation
  */
 
+#include <time.h>
+
 #include <rte_common.h>
 #include <rte_hexdump.h>
 #include <rte_mbuf.h>
 #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>
@@ -46,6 +21,8 @@
 #include <rte_cryptodev_scheduler_operations.h>
 #endif
 
+#include <rte_lcore.h>
+
 #include "test.h"
 #include "test_cryptodev.h"
 
@@ -61,6 +38,8 @@
 #include "test_cryptodev_aead_test_vectors.h"
 #include "test_cryptodev_hmac_test_vectors.h"
 
+#define VDEV_ARGS_SIZE 100
+
 static int gbl_driver_id;
 
 struct crypto_testsuite_params {
@@ -341,18 +320,81 @@ testsuite_setup(void)
 		}
 	}
 
+	/* Create a MVSAM device if required */
+	if (gbl_driver_id == rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_MVSAM_PMD))) {
+		nb_devs = rte_cryptodev_device_count_by_driver(
+				rte_cryptodev_driver_id_get(
+				RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)));
+		if (nb_devs < 1) {
+			ret = rte_vdev_init(
+				RTE_STR(CRYPTODEV_NAME_MVSAM_PMD),
+				NULL);
+
+			TEST_ASSERT(ret == 0, "Failed to create "
+				"instance of pmd : %s",
+				RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
+		}
+	}
+
+	/* Create an CCP device if required */
+	if (gbl_driver_id == rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_CCP_PMD))) {
+		nb_devs = rte_cryptodev_device_count_by_driver(
+				rte_cryptodev_driver_id_get(
+				RTE_STR(CRYPTODEV_NAME_CCP_PMD)));
+		if (nb_devs < 1) {
+			ret = rte_vdev_init(
+				RTE_STR(CRYPTODEV_NAME_CCP_PMD),
+				NULL);
+
+			TEST_ASSERT(ret == 0, "Failed to create "
+				"instance of pmd : %s",
+				RTE_STR(CRYPTODEV_NAME_CCP_PMD));
+		}
+	}
+
 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
+	char vdev_args[VDEV_ARGS_SIZE] = {""};
+	char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
+		"ordering=enable,name=cryptodev_test_scheduler,corelist="};
+	uint16_t slave_core_count = 0;
+	uint16_t socket_id = 0;
+
 	if (gbl_driver_id == rte_cryptodev_driver_id_get(
 			RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
 
+		/* Identify the Slave Cores
+		 * Use 2 slave cores for the device args
+		 */
+		RTE_LCORE_FOREACH_SLAVE(i) {
+			if (slave_core_count > 1)
+				break;
+			snprintf(vdev_args, sizeof(vdev_args),
+					"%s%d", temp_str, i);
+			strcpy(temp_str, vdev_args);
+			strcat(temp_str, ";");
+			slave_core_count++;
+			socket_id = lcore_config[i].socket_id;
+		}
+		if (slave_core_count != 2) {
+			RTE_LOG(ERR, USER1,
+				"Cryptodev scheduler test require at least "
+				"two slave cores to run. "
+				"Please use the correct coremask.\n");
+			return TEST_FAILED;
+		}
+		strcpy(temp_str, vdev_args);
+		snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
+				temp_str, socket_id);
+		RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
 		nb_devs = rte_cryptodev_device_count_by_driver(
 				rte_cryptodev_driver_id_get(
 				RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
 		if (nb_devs < 1) {
 			ret = rte_vdev_init(
 				RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
-				NULL);
-
+					vdev_args);
 			TEST_ASSERT(ret == 0,
 				"Failed to create instance %u of"
 				" pmd : %s",
@@ -1310,7 +1352,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 +1504,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;
@@ -1729,6 +1771,44 @@ test_AES_cipheronly_openssl_all(void)
 	return TEST_SUCCESS;
 }
 
+static int
+test_AES_chain_ccp_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_CCP_PMD)),
+		BLKCIPHER_AES_CHAIN_TYPE);
+
+	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+	return TEST_SUCCESS;
+}
+
+static int
+test_AES_cipheronly_ccp_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_CCP_PMD)),
+		BLKCIPHER_AES_CIPHERONLY_TYPE);
+
+	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+	return TEST_SUCCESS;
+}
+
 static int
 test_AES_chain_qat_all(void)
 {
@@ -1767,6 +1847,25 @@ test_AES_cipheronly_qat_all(void)
 	return TEST_SUCCESS;
 }
 
+static int
+test_AES_cipheronly_virtio_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_VIRTIO_PMD)),
+		BLKCIPHER_AES_CIPHERONLY_TYPE);
+
+	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+	return TEST_SUCCESS;
+}
+
 static int
 test_AES_chain_dpaa_sec_all(void)
 {
@@ -1900,6 +1999,25 @@ test_authonly_openssl_all(void)
 	return TEST_SUCCESS;
 }
 
+static int
+test_authonly_ccp_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_CCP_PMD)),
+		BLKCIPHER_AUTHONLY_TYPE);
+
+	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+	return TEST_SUCCESS;
+}
+
 static int
 test_AES_chain_armv8_all(void)
 {
@@ -1919,6 +2037,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_MVSAM_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_MVSAM_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_MVSAM_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_MVSAM_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_MVSAM_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,
@@ -1934,7 +2147,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;
@@ -1981,7 +2194,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(
@@ -2097,7 +2310,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(
@@ -2156,7 +2369,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(
@@ -2218,7 +2431,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(
@@ -2268,14 +2481,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);
 
@@ -2324,14 +2537,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);
 
@@ -2391,14 +2604,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);
 
@@ -2449,12 +2662,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);
 
@@ -2887,7 +3100,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,
@@ -2907,7 +3120,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);
@@ -2987,7 +3200,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);
@@ -3036,7 +3249,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,
@@ -3056,7 +3269,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);
@@ -3183,7 +3396,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,
@@ -3203,7 +3416,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);
@@ -3250,7 +3463,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,
@@ -3270,7 +3483,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);
@@ -3317,7 +3530,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,
@@ -3337,7 +3550,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(
@@ -3390,7 +3603,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,
@@ -3410,7 +3623,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(
@@ -3488,7 +3701,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(
@@ -3646,7 +3859,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,
@@ -3665,7 +3878,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,
@@ -3719,7 +3932,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,
@@ -3738,7 +3951,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,
@@ -3798,7 +4011,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);
@@ -3814,7 +4027,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,
@@ -3871,7 +4084,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,
@@ -3896,7 +4109,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,
@@ -3953,7 +4166,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(
@@ -3980,7 +4193,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(
@@ -4036,7 +4249,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,
@@ -4122,7 +4335,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,
@@ -4214,7 +4427,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,
@@ -4234,7 +4447,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(
@@ -4321,7 +4534,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(
@@ -4880,6 +5093,44 @@ test_3DES_cipheronly_dpaa2_sec_all(void)
 	return TEST_SUCCESS;
 }
 
+static int
+test_3DES_chain_ccp_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_CCP_PMD)),
+		BLKCIPHER_3DES_CHAIN_TYPE);
+
+	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+	return TEST_SUCCESS;
+}
+
+static int
+test_3DES_cipheronly_ccp_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_CCP_PMD)),
+		BLKCIPHER_3DES_CIPHERONLY_TYPE);
+
+	TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+	return TEST_SUCCESS;
+}
+
 static int
 test_3DES_cipheronly_qat_all(void)
 {
@@ -4965,7 +5216,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(
@@ -5004,7 +5255,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;
 }
@@ -5036,10 +5287,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*/
@@ -5048,7 +5299,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);
@@ -5058,9 +5309,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*/
@@ -5068,7 +5319,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);
 	}
 
@@ -5080,7 +5331,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) {
@@ -5102,7 +5353,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) {
@@ -5126,7 +5377,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 +
@@ -5136,13 +5387,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);
 	}
@@ -5216,8 +5467,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(
@@ -5430,7 +5681,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(
@@ -5635,8 +5886,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(
@@ -5709,7 +5960,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(
@@ -5785,8 +6036,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(
@@ -5863,7 +6114,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(
@@ -6109,7 +6360,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) {
@@ -6491,17 +6742,29 @@ test_null_cipher_only_operation(void)
 
 	return TEST_SUCCESS;
 }
-
+uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
+			0xab, 0xab, 0xab, 0xab,
+			0xab, 0xab, 0xab, 0xab,
+			0xab, 0xab, 0xab, 0xab};
 static int
 test_null_auth_only_operation(void)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+	uint8_t *digest;
 
 	/* Generate test mbuf data and space for digest */
 	ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
 			catch_22_quote, QUOTE_512_BYTES, 0);
 
+	/* create a pointer for digest, but don't expect anything to be written
+	 * here in a NULL auth algo so no mbuf append done.
+	 */
+	digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
+			QUOTE_512_BYTES);
+	/* prefill the memory pointed to by digest */
+	memcpy(digest, orig_data, sizeof(orig_data));
+
 	/* Setup HMAC Parameters */
 	ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
 	ut_params->auth_xform.next = NULL;
@@ -6533,6 +6796,9 @@ test_null_auth_only_operation(void)
 
 	sym_op->auth.data.offset = 0;
 	sym_op->auth.data.length = QUOTE_512_BYTES;
+	sym_op->auth.digest.data = digest;
+	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
+			QUOTE_512_BYTES);
 
 	/* Process crypto operation */
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
@@ -6541,20 +6807,36 @@ test_null_auth_only_operation(void)
 
 	TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
 			"crypto operation processing failed");
+	/* Make sure memory pointed to by digest hasn't been overwritten */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			orig_data,
+			digest,
+			sizeof(orig_data),
+			"Memory at digest ptr overwritten unexpectedly");
 
 	return TEST_SUCCESS;
 }
 
+
 static int
 test_null_cipher_auth_operation(void)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+	uint8_t *digest;
 
 	/* Generate test mbuf data and space for digest */
 	ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
 			catch_22_quote, QUOTE_512_BYTES, 0);
 
+	/* create a pointer for digest, but don't expect anything to be written
+	 * here in a NULL auth algo so no mbuf append done.
+	 */
+	digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
+			QUOTE_512_BYTES);
+	/* prefill the memory pointed to by digest */
+	memcpy(digest, orig_data, sizeof(orig_data));
+
 	/* Setup Cipher Parameters */
 	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
 	ut_params->cipher_xform.next = &ut_params->auth_xform;
@@ -6596,6 +6878,9 @@ test_null_cipher_auth_operation(void)
 
 	sym_op->auth.data.offset = 0;
 	sym_op->auth.data.length = QUOTE_512_BYTES;
+	sym_op->auth.digest.data = digest;
+	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
+			QUOTE_512_BYTES);
 
 	/* Process crypto operation */
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
@@ -6611,6 +6896,12 @@ test_null_cipher_auth_operation(void)
 			catch_22_quote,
 			QUOTE_512_BYTES,
 			"Ciphertext data not as expected");
+	/* Make sure memory pointed to by digest hasn't been overwritten */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			orig_data,
+			digest,
+			sizeof(orig_data),
+			"Memory at digest ptr overwritten unexpectedly");
 
 	return TEST_SUCCESS;
 }
@@ -6620,11 +6911,20 @@ test_null_auth_cipher_operation(void)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+	uint8_t *digest;
 
-	/* Generate test mbuf data and space for digest */
+	/* Generate test mbuf data */
 	ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
 			catch_22_quote, QUOTE_512_BYTES, 0);
 
+	/* create a pointer for digest, but don't expect anything to be written
+	 * here in a NULL auth algo so no mbuf append done.
+	 */
+	digest = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
+				QUOTE_512_BYTES);
+	/* prefill the memory pointed to by digest */
+	memcpy(digest, orig_data, sizeof(orig_data));
+
 	/* Setup Cipher Parameters */
 	ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
 	ut_params->cipher_xform.next = NULL;
@@ -6666,6 +6966,9 @@ test_null_auth_cipher_operation(void)
 
 	sym_op->auth.data.offset = 0;
 	sym_op->auth.data.length = QUOTE_512_BYTES;
+	sym_op->auth.digest.data = digest;
+	sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(ut_params->ibuf,
+					QUOTE_512_BYTES);
 
 	/* Process crypto operation */
 	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
@@ -6681,6 +6984,12 @@ test_null_auth_cipher_operation(void)
 			catch_22_quote,
 			QUOTE_512_BYTES,
 			"Ciphertext data not as expected");
+	/* Make sure memory pointed to by digest hasn't been overwritten */
+	TEST_ASSERT_BUFFERS_ARE_EQUAL(
+			orig_data,
+			digest,
+			sizeof(orig_data),
+			"Memory at digest ptr overwritten unexpectedly");
 
 	return TEST_SUCCESS;
 }
@@ -6845,13 +7154,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);
 	}
@@ -6861,7 +7170,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;
@@ -6951,7 +7260,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,
@@ -6977,7 +7286,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,
@@ -7055,7 +7364,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,
@@ -7367,7 +7676,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)
@@ -7377,7 +7686,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);
 
@@ -7414,7 +7723,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)
@@ -7424,7 +7733,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);
 
@@ -7467,7 +7776,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)
@@ -7477,7 +7786,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);
 
@@ -7550,7 +7859,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);
@@ -7608,7 +7918,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,
@@ -7727,7 +8038,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);
 	}
@@ -7746,15 +8057,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,
@@ -7766,14 +8077,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);
 	}
 
@@ -7913,7 +8224,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);
 		}
@@ -7951,14 +8262,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);
 	}
 
@@ -8276,33 +8587,47 @@ test_scheduler_detach_slave_op(void)
 }
 
 static int
-test_scheduler_mode_op(void)
+test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	uint8_t sched_id = ts_params->valid_devs[0];
-	struct rte_cryptodev_scheduler_ops op = {0};
-	struct rte_cryptodev_scheduler dummy_scheduler = {
-		.description = "dummy scheduler to test mode",
-		.name = "dummy scheduler",
-		.mode = CDEV_SCHED_MODE_USERDEFINED,
-		.ops = &op
-	};
-	int ret;
+	/* set mode */
+	return rte_cryptodev_scheduler_mode_set(sched_id,
+		scheduler_mode);
+}
 
-	/* set user defined mode */
-	ret = rte_cryptodev_scheduler_load_user_scheduler(sched_id,
-			&dummy_scheduler);
-	TEST_ASSERT(ret == 0,
-		"Failed to set cdev %u to user defined mode", sched_id);
-
-	/* set round robin mode */
-	ret = rte_cryptodev_scheduler_mode_set(sched_id,
-			CDEV_SCHED_MODE_ROUNDROBIN);
-	TEST_ASSERT(ret == 0,
-		"Failed to set cdev %u to round-robin mode", sched_id);
-	TEST_ASSERT(rte_cryptodev_scheduler_mode_get(sched_id) ==
-			CDEV_SCHED_MODE_ROUNDROBIN, "Scheduling Mode "
-					"not match");
+static int
+test_scheduler_mode_roundrobin_op(void)
+{
+	TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
+			0, "Failed to set roundrobin mode");
+	return 0;
+
+}
+
+static int
+test_scheduler_mode_multicore_op(void)
+{
+	TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
+			0, "Failed to set multicore mode");
+
+	return 0;
+}
+
+static int
+test_scheduler_mode_failover_op(void)
+{
+	TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
+			0, "Failed to set failover mode");
+
+	return 0;
+}
+
+static int
+test_scheduler_mode_pkt_size_distr_op(void)
+{
+	TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
+			0, "Failed to set pktsize mode");
 
 	return 0;
 }
@@ -8312,8 +8637,20 @@ static struct unit_test_suite cryptodev_scheduler_testsuite  = {
 	.setup = testsuite_setup,
 	.teardown = testsuite_teardown,
 	.unit_test_cases = {
+		/* Multi Core */
 		TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
-		TEST_CASE_ST(NULL, NULL, test_scheduler_mode_op),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+					test_AES_chain_scheduler_all),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+					test_AES_cipheronly_scheduler_all),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+					test_authonly_scheduler_all),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
+
+		/* Round Robin */
+		TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
 		TEST_CASE_ST(ut_setup, ut_teardown,
 				test_AES_chain_scheduler_all),
 		TEST_CASE_ST(ut_setup, ut_teardown,
@@ -8321,6 +8658,29 @@ static struct unit_test_suite cryptodev_scheduler_testsuite  = {
 		TEST_CASE_ST(ut_setup, ut_teardown,
 				test_authonly_scheduler_all),
 		TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
+
+		/* Fail over */
+		TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+					test_AES_chain_scheduler_all),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+					test_AES_cipheronly_scheduler_all),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+					test_authonly_scheduler_all),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
+
+		/* PKT SIZE */
+		TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+					test_AES_chain_scheduler_all),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+					test_AES_cipheronly_scheduler_all),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+					test_authonly_scheduler_all),
+		TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
+
 		TEST_CASES_END() /**< NULL terminate unit test array */
 	}
 };
@@ -8615,6 +8975,18 @@ static struct unit_test_suite cryptodev_qat_testsuite  = {
 	}
 };
 
+static struct unit_test_suite cryptodev_virtio_testsuite = {
+	.suite_name = "Crypto VIRTIO Unit Test Suite",
+	.setup = testsuite_setup,
+	.teardown = testsuite_teardown,
+	.unit_test_cases = {
+		TEST_CASE_ST(ut_setup, ut_teardown,
+				test_AES_cipheronly_virtio_all),
+
+		TEST_CASES_END() /**< NULL terminate unit test array */
+	}
+};
+
 static struct unit_test_suite cryptodev_aesni_mb_testsuite  = {
 	.suite_name = "Crypto Device AESNI MB Unit Test Suite",
 	.setup = testsuite_setup,
@@ -8628,6 +9000,18 @@ static struct unit_test_suite cryptodev_aesni_mb_testsuite  = {
 						test_DES_cipheronly_mb_all),
 		TEST_CASE_ST(ut_setup, ut_teardown,
 						test_DES_docsis_mb_all),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_CCM_authenticated_encryption_test_case_128_1),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_CCM_authenticated_decryption_test_case_128_1),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_CCM_authenticated_encryption_test_case_128_2),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_CCM_authenticated_decryption_test_case_128_2),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_CCM_authenticated_encryption_test_case_128_3),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_CCM_authenticated_decryption_test_case_128_3),
 
 		TEST_CASES_END() /**< NULL terminate unit test array */
 	}
@@ -9253,6 +9637,22 @@ static struct unit_test_suite cryptodev_dpaa_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),
+
+		/** Scatter-Gather */
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
+
 		TEST_CASES_END() /**< NULL terminate unit test array */
 	}
 };
@@ -9374,6 +9774,22 @@ 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),
+
+		/** Scatter-Gather */
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+			test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
+
 		TEST_CASES_END() /**< NULL terminate unit test array */
 	}
 };
@@ -9417,6 +9833,72 @@ 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 struct unit_test_suite cryptodev_ccp_testsuite  = {
+	.suite_name = "Crypto Device CCP Unit 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_ccp_all),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+				test_AES_cipheronly_ccp_all),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+				test_3DES_chain_ccp_all),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+				test_3DES_cipheronly_ccp_all),
+		TEST_CASE_ST(ut_setup, ut_teardown,
+				test_authonly_ccp_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*/)
 {
@@ -9427,12 +9909,28 @@ test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
 		RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if "
 				"CONFIG_RTE_LIBRTE_PMD_QAT is enabled "
 				"in config file to run this testsuite.\n");
-		return TEST_FAILED;
+		return TEST_SKIPPED;
 	}
 
 	return unit_test_suite_runner(&cryptodev_qat_testsuite);
 }
 
+static int
+test_cryptodev_virtio(void /*argv __rte_unused, int argc __rte_unused*/)
+{
+	gbl_driver_id =	rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
+
+	if (gbl_driver_id == -1) {
+		RTE_LOG(ERR, USER1, "VIRTIO PMD must be loaded. Check if "
+				"CONFIG_RTE_LIBRTE_PMD_VIRTIO_CRYPTO is enabled "
+				"in config file to run this testsuite.\n");
+		return TEST_FAILED;
+	}
+
+	return unit_test_suite_runner(&cryptodev_virtio_testsuite);
+}
+
 static int
 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
 {
@@ -9443,7 +9941,7 @@ test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
 		RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
 				"CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
 				"in config file to run this testsuite.\n");
-		return TEST_FAILED;
+		return TEST_SKIPPED;
 	}
 
 	return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
@@ -9459,7 +9957,7 @@ test_cryptodev_openssl(void)
 		RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded. Check if "
 				"CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
 				"in config file to run this testsuite.\n");
-		return TEST_FAILED;
+		return TEST_SKIPPED;
 	}
 
 	return unit_test_suite_runner(&cryptodev_openssl_testsuite);
@@ -9475,7 +9973,7 @@ test_cryptodev_aesni_gcm(void)
 		RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
 				"CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
 				"in config file to run this testsuite.\n");
-		return TEST_FAILED;
+		return TEST_SKIPPED;
 	}
 
 	return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
@@ -9491,7 +9989,7 @@ test_cryptodev_null(void)
 		RTE_LOG(ERR, USER1, "NULL PMD must be loaded. Check if "
 				"CONFIG_RTE_LIBRTE_PMD_NULL is enabled "
 				"in config file to run this testsuite.\n");
-		return TEST_FAILED;
+		return TEST_SKIPPED;
 	}
 
 	return unit_test_suite_runner(&cryptodev_null_testsuite);
@@ -9507,7 +10005,7 @@ test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
 		RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if "
 				"CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled "
 				"in config file to run this testsuite.\n");
-		return TEST_FAILED;
+		return TEST_SKIPPED;
 	}
 
 	return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
@@ -9523,7 +10021,7 @@ test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
 		RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
 				"CONFIG_RTE_LIBRTE_PMD_KASUMI is enabled "
 				"in config file to run this testsuite.\n");
-		return TEST_FAILED;
+		return TEST_SKIPPED;
 	}
 
 	return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
@@ -9539,7 +10037,7 @@ test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
 		RTE_LOG(ERR, USER1, "ZUC PMD must be loaded. Check if "
 				"CONFIG_RTE_LIBRTE_PMD_ZUC is enabled "
 				"in config file to run this testsuite.\n");
-		return TEST_FAILED;
+		return TEST_SKIPPED;
 	}
 
 	return unit_test_suite_runner(&cryptodev_sw_zuc_testsuite);
@@ -9555,12 +10053,28 @@ test_cryptodev_armv8(void)
 		RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if "
 				"CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled "
 				"in config file to run this testsuite.\n");
-		return TEST_FAILED;
+		return TEST_SKIPPED;
 	}
 
 	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_MVSAM_PMD));
+
+	if (gbl_driver_id == -1) {
+		RTE_LOG(ERR, USER1, "MVSAM PMD must be loaded. Check if "
+				"CONFIG_RTE_LIBRTE_PMD_MVSAM_CRYPTO is enabled "
+				"in config file to run this testsuite.\n");
+		return TEST_SKIPPED;
+	}
+
+	return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
+}
+
 #ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
 
 static int
@@ -9573,14 +10087,14 @@ test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
 		RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded. Check if "
 				"CONFIG_RTE_LIBRTE_PMD_SCHEDULER is enabled "
 				"in config file to run this testsuite.\n");
-		return TEST_FAILED;
+		return TEST_SKIPPED;
 	}
 
 	if (rte_cryptodev_driver_id_get(
 				RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
 		RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
 			" enabled in config file to run this testsuite.\n");
-		return TEST_FAILED;
+		return TEST_SKIPPED;
 }
 	return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
 }
@@ -9599,7 +10113,7 @@ test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
 		RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if "
 				"CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled "
 				"in config file to run this testsuite.\n");
-		return TEST_FAILED;
+		return TEST_SKIPPED;
 	}
 
 	return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
@@ -9615,12 +10129,28 @@ test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
 		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 TEST_SKIPPED;
 	}
 
 	return unit_test_suite_runner(&cryptodev_dpaa_sec_testsuite);
 }
 
+static int
+test_cryptodev_ccp(void)
+{
+	gbl_driver_id = rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_CCP_PMD));
+
+	if (gbl_driver_id == -1) {
+		RTE_LOG(ERR, USER1, "CCP PMD must be loaded. Check if "
+				"CONFIG_RTE_LIBRTE_PMD_CCP is enabled "
+				"in config file to run this testsuite.\n");
+		return TEST_FAILED;
+	}
+
+	return unit_test_suite_runner(&cryptodev_ccp_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);
@@ -9630,5 +10160,8 @@ 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_mvsam_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);
+REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
+REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);