[v10,4/4] test/crypto: add unit-test for cryptodev raw API test
diff mbox series

Message ID 20200924163417.49983-5-roy.fan.zhang@intel.com
State Changes Requested
Delegated to: akhil goyal
Headers show
Series
  • cryptodev: add raw data-path APIs
Related show

Checks

Context Check Description
ci/iol-mellanox-Performance success Performance Testing PASS
ci/iol-testing success Testing PASS
ci/iol-intel-Performance success Performance Testing PASS
ci/iol-intel-Functional success Functional Testing PASS
ci/Intel-compilation success Compilation OK
ci/iol-broadcom-Performance success Performance Testing PASS
ci/iol-broadcom-Functional success Functional Testing PASS
ci/checkpatch warning coding style issues

Commit Message

Zhang, Roy Fan Sept. 24, 2020, 4:34 p.m. UTC
This patch adds the cryptodev raw API test support to unit test.
In addtion a new test-case for QAT PMD for the test type is
enabled.

Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com>
---
 app/test/test_cryptodev.c             | 759 ++++++++++++++++++++++++--
 app/test/test_cryptodev.h             |  12 +
 app/test/test_cryptodev_blockcipher.c |  58 +-
 3 files changed, 775 insertions(+), 54 deletions(-)

Comments

Adam Dybkowski Sept. 25, 2020, 8:05 a.m. UTC | #1
> -----Original Message-----
> From: Zhang, Roy Fan <roy.fan.zhang@intel.com>
> Sent: Thursday, 24 September, 2020 18:34
> To: dev@dpdk.org
> Cc: akhil.goyal@nxp.com; Trahe, Fiona <fiona.trahe@intel.com>; Kusztal,
> ArkadiuszX <arkadiuszx.kusztal@intel.com>; Dybkowski, AdamX
> <adamx.dybkowski@intel.com>; anoobj@marvell.com; Ananyev, Konstantin
> <konstantin.ananyev@intel.com>; Zhang, Roy Fan
> <roy.fan.zhang@intel.com>
> Subject: [dpdk-dev v10 4/4] test/crypto: add unit-test for cryptodev raw API
> test
> 
> This patch adds the cryptodev raw API test support to unit test.
> In addtion a new test-case for QAT PMD for the test type is
> enabled.
> 
> Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com>

Acked-by: Adam Dybkowski <adamx.dybkowski@intel.com>
Akhil Goyal Oct. 8, 2020, 3:01 p.m. UTC | #2
> This patch adds the cryptodev raw API test support to unit test.
> In addtion a new test-case for QAT PMD for the test type is
> enabled.
> 
> Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com>
> ---
>  app/test/test_cryptodev.c             | 759 ++++++++++++++++++++++++--
>  app/test/test_cryptodev.h             |  12 +
>  app/test/test_cryptodev_blockcipher.c |  58 +-
>  3 files changed, 775 insertions(+), 54 deletions(-)
> 
> diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
> index 99f1eed82..4e7dd1b63 100644
> --- a/app/test/test_cryptodev.c
> +++ b/app/test/test_cryptodev.c
> @@ -49,6 +49,10 @@
>  #define VDEV_ARGS_SIZE 100
>  #define MAX_NB_SESSIONS 4
> 
> +#define MAX_DRV_SERVICE_CTX_SIZE 256
> +
> +#define MAX_RAW_DEQUEUE_COUNT	65535
> +
>  #define IN_PLACE 0
>  #define OUT_OF_PLACE 1
> 
> @@ -57,6 +61,8 @@ static int gbl_driver_id;
>  static enum rte_security_session_action_type gbl_action_type =
>  	RTE_SECURITY_ACTION_TYPE_NONE;
> 
> +enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
> +
>  struct crypto_testsuite_params {
>  	struct rte_mempool *mbuf_pool;
>  	struct rte_mempool *large_mbuf_pool;
> @@ -147,6 +153,187 @@ ceil_byte_length(uint32_t num_bits)
>  		return (num_bits >> 3);
>  }
> 
> +void
> +process_sym_raw_hw_api_op(uint8_t dev_id, uint16_t qp_id,
> +		struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
> +		uint8_t len_in_bits, uint8_t cipher_iv_len)
> +{
> +	int32_t n;
> +	struct rte_crypto_sym_op *sop = op->sym;
> +	struct rte_crypto_op *ret_op = NULL;
> +	struct rte_crypto_vec data_vec[UINT8_MAX];
> +	struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
> +	union rte_crypto_sym_ofs ofs;
> +	struct rte_crypto_sym_vec vec;
> +	struct rte_crypto_sgl sgl;
> +	uint32_t max_len;
> +	union rte_cryptodev_session_ctx sess;
> +	uint32_t count = 0;
> +	struct rte_crypto_raw_dp_ctx *ctx;
> +	uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
> +			auth_len = 0;
> +	int ctx_service_size;
> +	int32_t status = 0;
> +
> +	ctx_service_size = rte_cryptodev_raw_get_dp_context_size(dev_id);
> +	if (ctx_service_size < 0) {
> +		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
> +		return;
> +	}
> +
> +	ctx = malloc(ctx_service_size);
> +	if (!ctx) {
> +		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
> +		return;
> +	}
> +
> +	if (rte_cryptodev_raw_configure_dp_context(dev_id, qp_id, ctx) < 0) {
> +		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
> +		return;
> +	}
> +
> +	sess.crypto_sess = sop->session;
> +	if (rte_cryptodev_raw_attach_session(dev_id, qp_id, ctx,
> +			op->sess_type, sess) < 0) {
> +		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
> +		return;
> +	}
> +
> +	cipher_iv.iova = 0;
> +	cipher_iv.va = NULL;
> +	aad_auth_iv.iova = 0;
> +	aad_auth_iv.va = NULL;
> +	digest.iova = 0;
> +	digest.va = NULL;
> +	sgl.vec = data_vec;
> +	vec.num = 1;
> +	vec.sgl = &sgl;
> +	vec.iv = &cipher_iv;
> +	vec.digest = &digest;
> +	vec.aad = &aad_auth_iv;
> +	vec.status = &status;
> +
> +	ofs.raw = 0;
> +
> +	if (is_cipher && is_auth) {
> +		cipher_offset = sop->cipher.data.offset;
> +		cipher_len = sop->cipher.data.length;
> +		auth_offset = sop->auth.data.offset;
> +		auth_len = sop->auth.data.length;
> +		max_len = RTE_MAX(cipher_offset + cipher_len,
> +				auth_offset + auth_len);
> +		if (len_in_bits) {
> +			max_len = max_len >> 3;
> +			cipher_offset = cipher_offset >> 3;
> +			auth_offset = auth_offset >> 3;
> +			cipher_len = cipher_len >> 3;
> +			auth_len = auth_len >> 3;
> +		}
> +		ofs.ofs.cipher.head = cipher_offset;
> +		ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
> +		ofs.ofs.auth.head = auth_offset;
> +		ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
> +		cipher_iv.va = rte_crypto_op_ctod_offset(op, void *,
> IV_OFFSET);
> +		cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
> +		aad_auth_iv.va = rte_crypto_op_ctod_offset(
> +				op, void *, IV_OFFSET + cipher_iv_len);
> +		aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op,
> IV_OFFSET +
> +				cipher_iv_len);
> +		digest.va = (void *)sop->auth.digest.data;
> +		digest.iova = sop->auth.digest.phys_addr;
> +
> +	} else if (is_cipher) {
> +		cipher_offset = sop->cipher.data.offset;
> +		cipher_len = sop->cipher.data.length;
> +		max_len = cipher_len + cipher_offset;
> +		if (len_in_bits) {
> +			max_len = max_len >> 3;
> +			cipher_offset = cipher_offset >> 3;
> +			cipher_len = cipher_len >> 3;
> +		}
> +		ofs.ofs.cipher.head = cipher_offset;
> +		ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
> +		cipher_iv.va = rte_crypto_op_ctod_offset(op, void *,
> IV_OFFSET);
> +		cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
> +
> +	} else if (is_auth) {
> +		auth_offset = sop->auth.data.offset;
> +		auth_len = sop->auth.data.length;
> +		max_len = auth_len + auth_offset;
> +		if (len_in_bits) {
> +			max_len = max_len >> 3;
> +			auth_offset = auth_offset >> 3;
> +			auth_len = auth_len >> 3;
> +		}
> +		ofs.ofs.auth.head = auth_offset;
> +		ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
> +		aad_auth_iv.va = rte_crypto_op_ctod_offset(
> +				op, void *, IV_OFFSET + cipher_iv_len);
> +		aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op,
> IV_OFFSET +
> +				cipher_iv_len);
> +		digest.va = (void *)sop->auth.digest.data;
> +		digest.iova = sop->auth.digest.phys_addr;
> +
> +	} else { /* aead */
> +		cipher_offset = sop->aead.data.offset;
> +		cipher_len = sop->aead.data.length;
> +		max_len = cipher_len + cipher_offset;
> +		if (len_in_bits) {
> +			max_len = max_len >> 3;
> +			cipher_offset = cipher_offset >> 3;
> +			cipher_len = cipher_len >> 3;
> +		}
> +		ofs.ofs.cipher.head = cipher_offset;
> +		ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
> +		cipher_iv.va = rte_crypto_op_ctod_offset(op, void *,
> IV_OFFSET);
> +		cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
> +		aad_auth_iv.va = (void *)sop->aead.aad.data;
> +		aad_auth_iv.iova = sop->aead.aad.phys_addr;
> +		digest.va = (void *)sop->aead.digest.data;
> +		digest.iova = sop->aead.digest.phys_addr;
> +	}
> +
> +	n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
> +			data_vec, RTE_DIM(data_vec));
> +	if (n < 0 || n > sop->m_src->nb_segs) {
> +		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
> +		return;
> +	}
> +
> +	sgl.num = n;
> +
> +	if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op)
> +			< 1) {
> +		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
> +		return;
> +	}
> +
> +	status = rte_cryptodev_raw_enqueue_done(ctx, 1);
> +	if (status < 0) {
> +		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
> +		return;
> +	}
> +
> +
> +	status = -1;
> +	while (count++ < MAX_RAW_DEQUEUE_COUNT && status == -1) {
> +		status = rte_cryptodev_raw_dequeue(ctx, (void **)&ret_op);
> +		if (status == -1)
> +			rte_pause();
> +	}

Why don't we do dequeue with the burst API?


> +
> +	if (status != -1) {
> +		if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
> +			op->status = RTE_CRYPTO_OP_STATUS_ERROR;
> +			return;
> +		}
> +	}
> +
> +	op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op !=
> op ||
> +			status != 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
> +					RTE_CRYPTO_OP_STATUS_SUCCESS;
> +}
> +
>  static void
>  process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
>  {
> @@ -1661,6 +1848,9 @@
> test_AES_CBC_HMAC_SHA512_decrypt_perform(struct
> rte_cryptodev_sym_session *sess,
>  	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
>  		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
>  			ut_params->op);
> +	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 1, 0, 0);
>  	else
>  		TEST_ASSERT_NOT_NULL(
>  				process_crypto_request(ts_params-
> >valid_devs[0],
> @@ -1715,12 +1905,18 @@ test_AES_cipheronly_all(void)
>  static int
>  test_AES_docsis_all(void)
>  {
> +	/* Data-path service does not support DOCSIS yet */
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
>  	return test_blockcipher(BLKCIPHER_AES_DOCSIS_TYPE);
>  }
> 
>  static int
>  test_DES_docsis_all(void)
>  {
> +	/* Data-path service does not support DOCSIS yet */
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
>  	return test_blockcipher(BLKCIPHER_DES_DOCSIS_TYPE);
>  }
> 
> @@ -2435,6 +2631,12 @@ test_snow3g_authentication(const struct
> snow3g_hash_test_data *tdata)
>  		return -ENOTSUP;
>  	}
> 
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> +
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
>  	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
> @@ -2475,7 +2677,11 @@ test_snow3g_authentication(const struct
> snow3g_hash_test_data *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 1, 1, 0);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  				ut_params->op);
>  	ut_params->obuf = ut_params->op->sym->m_src;
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> @@ -2513,6 +2719,12 @@ test_snow3g_authentication_verify(const struct
> snow3g_hash_test_data *tdata)
>  		return -ENOTSUP;
>  	}
> 
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> +
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
>  	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
> @@ -2554,7 +2766,11 @@ test_snow3g_authentication_verify(const struct
> snow3g_hash_test_data *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 1, 1, 0);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  				ut_params->op);
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
>  	ut_params->obuf = ut_params->op->sym->m_src;
> @@ -2580,6 +2796,16 @@ test_kasumi_authentication(const struct
> kasumi_hash_test_data *tdata)
>  	unsigned plaintext_pad_len;
>  	unsigned plaintext_len;
>  	uint8_t *plaintext;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {

I believe global_api_test_type is set as CRYPTODEV_RAW_API_TEST after
Checking the feature flag. Hence we don't need to check it again here. Right?

Or else we should check it for every case.


> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -2624,6 +2850,9 @@ test_kasumi_authentication(const struct
> kasumi_hash_test_data *tdata)
>  	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
>  		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
>  			ut_params->op);
> +	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 1, 1, 0);
>  	else
>  		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
> @@ -2653,6 +2882,16 @@ test_kasumi_authentication_verify(const struct
> kasumi_hash_test_data *tdata)
>  	unsigned plaintext_pad_len;
>  	unsigned plaintext_len;
>  	uint8_t *plaintext;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}

Same comment here as well

> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -2695,7 +2934,11 @@ test_kasumi_authentication_verify(const struct
> kasumi_hash_test_data *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 1, 1, 0);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  				ut_params->op);
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
>  	ut_params->obuf = ut_params->op->sym->m_src;
> @@ -2860,6 +3103,16 @@ test_kasumi_encryption(const struct
> kasumi_test_data *tdata)
>  	uint8_t *plaintext, *ciphertext;
>  	unsigned plaintext_pad_len;
>  	unsigned plaintext_len;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -2902,8 +3155,12 @@ test_kasumi_encryption(const struct
> kasumi_test_data *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> -						ut_params->op);
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
> +				ut_params->op);
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> 
>  	ut_params->obuf = ut_params->op->sym->m_dst;
> @@ -2959,6 +3216,12 @@ test_kasumi_encryption_sgl(const struct
> kasumi_test_data *tdata)
>  		return -ENOTSUP;
>  	}
> 
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> +
>  	/* Create KASUMI session */
>  	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
>  					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
> @@ -2988,7 +3251,11 @@ test_kasumi_encryption_sgl(const struct
> kasumi_test_data *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  						ut_params->op);
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> 
> @@ -3031,10 +3298,14 @@ test_kasumi_encryption_oop(const struct
> kasumi_test_data *tdata)
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
>  	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
>  	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
> +	/* Data-path service does not support OOP */
>  	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
>  			&cap_idx) == NULL)
>  		return -ENOTSUP;
> 
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
> +
>  	/* Create KASUMI session */
>  	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
>  					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
> @@ -3116,6 +3387,9 @@ test_kasumi_encryption_oop_sgl(const struct
> kasumi_test_data *tdata)
>  			&cap_idx) == NULL)
>  		return -ENOTSUP;
> 
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
> +
>  	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> 
>  	uint64_t feat_flags = dev_info.feature_flags;
> @@ -3201,6 +3475,9 @@ test_kasumi_decryption_oop(const struct
> kasumi_test_data *tdata)
>  			&cap_idx) == NULL)
>  		return -ENOTSUP;
> 
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
> +
>  	/* Create KASUMI session */
>  	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
>  					RTE_CRYPTO_CIPHER_OP_DECRYPT,
> @@ -3269,6 +3546,16 @@ test_kasumi_decryption(const struct
> kasumi_test_data *tdata)
>  	uint8_t *ciphertext, *plaintext;
>  	unsigned ciphertext_pad_len;
>  	unsigned ciphertext_len;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
You are checking the feature flags randomly. Please check if it is really needed as suggested above.
Please be consistent.

> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -3311,7 +3598,11 @@ test_kasumi_decryption(const struct
> kasumi_test_data *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 0, 1, 0);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  						ut_params->op);
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> 
> @@ -3344,6 +3635,16 @@ test_snow3g_encryption(const struct
> snow3g_test_data *tdata)
>  	uint8_t *plaintext, *ciphertext;
>  	unsigned plaintext_pad_len;
>  	unsigned plaintext_len;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -3386,7 +3687,11 @@ test_snow3g_encryption(const struct
> snow3g_test_data *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  						ut_params->op);
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> 
> @@ -3427,6 +3732,9 @@ test_snow3g_encryption_oop(const struct
> snow3g_test_data *tdata)
>  			&cap_idx) == NULL)
>  		return -ENOTSUP;
> 
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
> +
>  	/* Create SNOW 3G session */
>  	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
>  					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
> @@ -3510,6 +3818,9 @@ test_snow3g_encryption_oop_sgl(const struct
> snow3g_test_data *tdata)
>  			&cap_idx) == NULL)
>  		return -ENOTSUP;
> 
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
> +
>  	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> 
>  	uint64_t feat_flags = dev_info.feature_flags;
> @@ -3629,6 +3940,9 @@ test_snow3g_encryption_offset_oop(const struct
> snow3g_test_data *tdata)
>  			&cap_idx) == NULL)
>  		return -ENOTSUP;
> 
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
> +
>  	/* Create SNOW 3G session */
>  	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
>  					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
> @@ -3719,6 +4033,16 @@ static int test_snow3g_decryption(const struct
> snow3g_test_data *tdata)
>  	uint8_t *plaintext, *ciphertext;
>  	unsigned ciphertext_pad_len;
>  	unsigned ciphertext_len;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -3761,7 +4085,11 @@ static int test_snow3g_decryption(const struct
> snow3g_test_data *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  						ut_params->op);
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
>  	ut_params->obuf = ut_params->op->sym->m_dst;
> @@ -3799,6 +4127,9 @@ static int test_snow3g_decryption_oop(const struct
> snow3g_test_data *tdata)
>  			&cap_idx) == NULL)
>  		return -ENOTSUP;
> 
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
> +
>  	/* Create SNOW 3G session */
>  	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
>  					RTE_CRYPTO_CIPHER_OP_DECRYPT,
> @@ -3886,6 +4217,12 @@ test_zuc_cipher_auth(const struct
> wireless_test_data *tdata)
>  		return -ENOTSUP;
>  	}
> 
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> +
>  	/* Check if device supports ZUC EEA3 */
>  	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
>  	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
> @@ -3929,7 +4266,11 @@ test_zuc_cipher_auth(const struct
> wireless_test_data *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
>  	ut_params->obuf = ut_params->op->sym->m_src;
> @@ -3969,6 +4310,16 @@ test_snow3g_cipher_auth(const struct
> snow3g_test_data *tdata)
>  	uint8_t *plaintext, *ciphertext;
>  	unsigned plaintext_pad_len;
>  	unsigned plaintext_len;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -4024,7 +4375,11 @@ test_snow3g_cipher_auth(const struct
> snow3g_test_data *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
>  	ut_params->obuf = ut_params->op->sym->m_src;
> @@ -4092,6 +4447,14 @@ test_snow3g_auth_cipher(const struct
> snow3g_test_data *tdata,
>  			printf("Device doesn't support digest encrypted.\n");
>  			return -ENOTSUP;
>  		}
> +		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +			return -ENOTSUP;
> +	}
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
>  	}
> 
>  	/* Create SNOW 3G session */
> @@ -4160,7 +4523,11 @@ test_snow3g_auth_cipher(const struct
> snow3g_test_data *tdata,
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
> 
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> @@ -4270,7 +4637,14 @@ test_snow3g_auth_cipher_sgl(const struct
> snow3g_test_data *tdata,
>  					"in both input and output mbufs.\n");
>  			return -ENOTSUP;
>  		}
> +		if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +			printf("Device doesn't support RAW data-path APIs.\n");
> +			return -ENOTSUP;
> +		}
>  	} else {
> +		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +			return -ENOTSUP;
>  		if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
> {
>  			printf("Device doesn't support out-of-place scatter-
> gather "
>  					"in both input and output mbufs.\n");
> @@ -4349,7 +4723,11 @@ test_snow3g_auth_cipher_sgl(const struct
> snow3g_test_data *tdata,
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
> 
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> @@ -4457,7 +4835,15 @@ test_kasumi_auth_cipher(const struct
> kasumi_test_data *tdata,
> 
>  	uint64_t feat_flags = dev_info.feature_flags;
> 
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> +
>  	if (op_mode == OUT_OF_PLACE) {
> +		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +			return -ENOTSUP;
>  		if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
>  			printf("Device doesn't support digest encrypted.\n");
>  			return -ENOTSUP;
> @@ -4531,7 +4917,11 @@ test_kasumi_auth_cipher(const struct
> kasumi_test_data *tdata,
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
> 
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> @@ -4642,7 +5032,14 @@ test_kasumi_auth_cipher_sgl(const struct
> kasumi_test_data *tdata,
>  					"in both input and output mbufs.\n");
>  			return -ENOTSUP;
>  		}
> +		if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +			printf("Device doesn't support RAW data-path APIs.\n");
> +			return -ENOTSUP;
> +		}
>  	} else {
> +		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +			return -ENOTSUP;
>  		if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
> {
>  			printf("Device doesn't support out-of-place scatter-
> gather "
>  					"in both input and output mbufs.\n");
> @@ -4721,7 +5118,11 @@ test_kasumi_auth_cipher_sgl(const struct
> kasumi_test_data *tdata,
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
> 
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> @@ -4806,6 +5207,16 @@ test_kasumi_cipher_auth(const struct
> kasumi_test_data *tdata)
>  	uint8_t *plaintext, *ciphertext;
>  	unsigned plaintext_pad_len;
>  	unsigned plaintext_len;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -4862,7 +5273,11 @@ test_kasumi_cipher_auth(const struct
> kasumi_test_data *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> 
> @@ -4905,6 +5320,16 @@ test_zuc_encryption(const struct wireless_test_data
> *tdata)
>  	uint8_t *plaintext, *ciphertext;
>  	unsigned plaintext_pad_len;
>  	unsigned plaintext_len;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> 
> @@ -4949,7 +5374,11 @@ test_zuc_encryption(const struct wireless_test_data
> *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  						ut_params->op);
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> 
> @@ -5004,6 +5433,12 @@ test_zuc_encryption_sgl(const struct
> wireless_test_data *tdata)
>  		return -ENOTSUP;
>  	}
> 
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> +
>  	plaintext_len = ceil_byte_length(tdata->plaintext.len);
> 
>  	/* Append data which is padded to a multiple */
> @@ -5036,7 +5471,11 @@ test_zuc_encryption_sgl(const struct
> wireless_test_data *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  						ut_params->op);
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> 
> @@ -5084,6 +5523,12 @@ test_zuc_authentication(const struct
> wireless_test_data *tdata)
>  		return -ENOTSUP;
>  	}
> 
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> +
>  	/* Check if device supports ZUC EIA3 */
>  	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
>  	cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
> @@ -5124,7 +5569,11 @@ test_zuc_authentication(const struct
> wireless_test_data *tdata)
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 1, 1, 0);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  				ut_params->op);
>  	ut_params->obuf = ut_params->op->sym->m_src;
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> @@ -5181,7 +5630,15 @@ test_zuc_auth_cipher(const struct
> wireless_test_data *tdata,
>  					"in both input and output mbufs.\n");
>  			return -ENOTSUP;
>  		}
> +
> +		if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +			printf("Device doesn't support RAW data-path APIs.\n");
> +			return -ENOTSUP;
> +		}
>  	} else {
> +		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +			return -ENOTSUP;
>  		if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
> {
>  			printf("Device doesn't support out-of-place scatter-
> gather "
>  					"in both input and output mbufs.\n");
> @@ -5256,7 +5713,11 @@ test_zuc_auth_cipher(const struct
> wireless_test_data *tdata,
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
> 
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> @@ -5363,7 +5824,15 @@ test_zuc_auth_cipher_sgl(const struct
> wireless_test_data *tdata,
>  					"in both input and output mbufs.\n");
>  			return -ENOTSUP;
>  		}
> +
> +		if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +			printf("Device doesn't support RAW data-path APIs.\n");
> +			return -ENOTSUP;
> +		}
>  	} else {
> +		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +			return -ENOTSUP;
>  		if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
> {
>  			printf("Device doesn't support out-of-place scatter-
> gather "
>  					"in both input and output mbufs.\n");
> @@ -5442,7 +5911,11 @@ test_zuc_auth_cipher_sgl(const struct
> wireless_test_data *tdata,
>  	if (retval < 0)
>  		return retval;
> 
> -	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
> +	else
> +		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
> 
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> @@ -5585,6 +6058,9 @@ test_kasumi_decryption_test_case_2(void)
>  static int
>  test_kasumi_decryption_test_case_3(void)
>  {
> +	/* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
>  	return test_kasumi_decryption(&kasumi_test_case_3);
>  }
> 
> @@ -5784,6 +6260,9 @@ test_snow3g_auth_cipher_part_digest_enc_oop(void)
>  static int
>  test_snow3g_auth_cipher_test_case_3_sgl(void)
>  {
> +	/* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
>  	return test_snow3g_auth_cipher_sgl(
>  		&snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
>  }
> @@ -5798,6 +6277,9 @@ test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
>  static int
>  test_snow3g_auth_cipher_part_digest_enc_sgl(void)
>  {
> +	/* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
>  	return test_snow3g_auth_cipher_sgl(
>  		&snow3g_auth_cipher_partial_digest_encryption,
>  			IN_PLACE, 0);
> @@ -6151,11 +6633,12 @@ test_mixed_auth_cipher(const struct
> mixed_cipher_auth_test_data *tdata,
>  	unsigned int ciphertext_len;
> 
>  	struct rte_cryptodev_info dev_info;
> -	struct rte_crypto_op *op;
> 
>  	/* Check if device supports particular algorithms separately */
>  	if (test_mixed_check_if_unsupported(tdata))
>  		return -ENOTSUP;
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
> 
>  	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> 
> @@ -6166,6 +6649,9 @@ test_mixed_auth_cipher(const struct
> mixed_cipher_auth_test_data *tdata,
>  		return -ENOTSUP;
>  	}
> 
> +	if (op_mode == OUT_OF_PLACE)
> +		return -ENOTSUP;
> +
>  	/* Create the session */
>  	if (verify)
>  		retval = create_wireless_algo_cipher_auth_session(
> @@ -6197,9 +6683,11 @@ test_mixed_auth_cipher(const struct
> mixed_cipher_auth_test_data *tdata,
>  	/* clear mbuf payload */
>  	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
>  		rte_pktmbuf_tailroom(ut_params->ibuf));
> -	if (op_mode == OUT_OF_PLACE)
> +	if (op_mode == OUT_OF_PLACE) {
> +
>  		memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
>  				rte_pktmbuf_tailroom(ut_params->obuf));
> +	}

Unnecessary change.

> 
>  	ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
>  	plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
> @@ -6240,18 +6728,17 @@ test_mixed_auth_cipher(const struct
> mixed_cipher_auth_test_data *tdata,
>  	if (retval < 0)
>  		return retval;
> 
> -	op = process_crypto_request(ts_params->valid_devs[0],
> +	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
>  			ut_params->op);
> 
>  	/* Check if the op failed because the device doesn't */
>  	/* support this particular combination of algorithms */
> -	if (op == NULL && ut_params->op->status ==
> +	if (ut_params->op == NULL && ut_params->op->status ==
>  			RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
>  		printf("Device doesn't support this mixed combination. "
>  				"Test Skipped.\n");
>  		return -ENOTSUP;
>  	}
> -	ut_params->op = op;
> 
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> 
> @@ -6342,11 +6829,12 @@ test_mixed_auth_cipher_sgl(const struct
> mixed_cipher_auth_test_data *tdata,
>  	uint8_t digest_buffer[10000];
> 
>  	struct rte_cryptodev_info dev_info;
> -	struct rte_crypto_op *op;
> 
>  	/* Check if device supports particular algorithms */
>  	if (test_mixed_check_if_unsupported(tdata))
>  		return -ENOTSUP;
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
> 
>  	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> 
> @@ -6445,20 +6933,18 @@ test_mixed_auth_cipher_sgl(const struct
> mixed_cipher_auth_test_data *tdata,
>  	if (retval < 0)
>  		return retval;
> 
> -	op = process_crypto_request(ts_params->valid_devs[0],
> +	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
>  			ut_params->op);
> 
>  	/* Check if the op failed because the device doesn't */
>  	/* support this particular combination of algorithms */
> -	if (op == NULL && ut_params->op->status ==
> +	if (ut_params->op == NULL && ut_params->op->status ==
>  			RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
>  		printf("Device doesn't support this mixed combination. "
>  				"Test Skipped.\n");
>  		return -ENOTSUP;
>  	}
> 
> -	ut_params->op = op;
> -
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
> 
>  	ut_params->obuf = (op_mode == IN_PLACE ?
> @@ -6999,6 +7485,16 @@ test_authenticated_encryption(const struct
> aead_test_data *tdata)
>  	uint8_t *ciphertext, *auth_tag;
>  	uint16_t plaintext_pad_len;
>  	uint32_t i;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -7048,6 +7544,9 @@ test_authenticated_encryption(const struct
> aead_test_data *tdata)
>  	/* Process crypto operation */
>  	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
>  		process_cpu_aead_op(ts_params->valid_devs[0], ut_params-
> >op);
> +	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 0, 0, 0);
>  	else
>  		TEST_ASSERT_NOT_NULL(
>  			process_crypto_request(ts_params->valid_devs[0],
> @@ -8496,6 +8995,16 @@ test_authenticated_decryption(const struct
> aead_test_data *tdata)
>  	int retval;
>  	uint8_t *plaintext;
>  	uint32_t i;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -8545,6 +9054,9 @@ test_authenticated_decryption(const struct
> aead_test_data *tdata)
>  	/* Process crypto operation */
>  	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
>  		process_cpu_aead_op(ts_params->valid_devs[0], ut_params-
> >op);
> +	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 0, 0, 0);
>  	else
>  		TEST_ASSERT_NOT_NULL(
>  			process_crypto_request(ts_params->valid_devs[0],
> @@ -8839,6 +9351,9 @@ test_authenticated_encryption_oop(const struct
> aead_test_data *tdata)
>  			&cap_idx) == NULL)
>  		return -ENOTSUP;
> 
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		return -ENOTSUP;
> +
>  	/* not supported with CPU crypto */
>  	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
>  		return -ENOTSUP;
> @@ -8928,8 +9443,9 @@ test_authenticated_decryption_oop(const struct
> aead_test_data *tdata)
>  			&cap_idx) == NULL)
>  		return -ENOTSUP;
> 
> -	/* not supported with CPU crypto */
> -	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
> +	/* not supported with CPU crypto and raw data-path APIs*/
> +	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
> +			global_api_test_type == CRYPTODEV_RAW_API_TEST)
>  		return -ENOTSUP;
> 
>  	/* Create AEAD session */
> @@ -9115,6 +9631,12 @@ test_authenticated_decryption_sessionless(
>  		return -ENOTSUP;
>  	}
> 
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> +
>  	/* not supported with CPU crypto */
>  	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
>  		return -ENOTSUP;
> @@ -9156,8 +9678,13 @@ test_authenticated_decryption_sessionless(
>  			"crypto op session type not sessionless");
> 
>  	/* Process crypto operation */
> -	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params-
> >valid_devs[0],
> -			ut_params->op), "failed to process sym crypto op");
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 0, 0, 0);
> +	else
> +		TEST_ASSERT_NOT_NULL(process_crypto_request(
> +			ts_params->valid_devs[0], ut_params->op),
> +				"failed to process sym crypto op");
> 
>  	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
> 
> @@ -9449,6 +9976,16 @@ test_MD5_HMAC_generate(const struct
> HMAC_MD5_vector *test_case)
> 
>  	struct crypto_testsuite_params *ts_params = &testsuite_params;
>  	struct crypto_unittest_params *ut_params = &unittest_params;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -9477,6 +10014,9 @@ test_MD5_HMAC_generate(const struct
> HMAC_MD5_vector *test_case)
>  	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
>  		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
>  			ut_params->op);
> +	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 1, 0, 0);
>  	else
>  		TEST_ASSERT_NOT_NULL(
>  			process_crypto_request(ts_params->valid_devs[0],
> @@ -9509,6 +10049,16 @@ test_MD5_HMAC_verify(const struct
> HMAC_MD5_vector *test_case)
> 
>  	struct crypto_testsuite_params *ts_params = &testsuite_params;
>  	struct crypto_unittest_params *ut_params = &unittest_params;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -9535,6 +10085,9 @@ test_MD5_HMAC_verify(const struct
> HMAC_MD5_vector *test_case)
>  	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
>  		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
>  			ut_params->op);
> +	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 1, 0, 0);
>  	else
>  		TEST_ASSERT_NOT_NULL(
>  			process_crypto_request(ts_params->valid_devs[0],
> @@ -10040,6 +10593,16 @@ test_AES_GMAC_authentication(const struct
> gmac_test_data *tdata)
>  {
>  	struct crypto_testsuite_params *ts_params = &testsuite_params;
>  	struct crypto_unittest_params *ut_params = &unittest_params;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	int retval;
> 
> @@ -10103,6 +10666,9 @@ test_AES_GMAC_authentication(const struct
> gmac_test_data *tdata)
>  	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
>  		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
>  			ut_params->op);
> +	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 1, 0, 0);
>  	else
>  		TEST_ASSERT_NOT_NULL(
>  			process_crypto_request(ts_params->valid_devs[0],
> @@ -10161,6 +10727,16 @@ test_AES_GMAC_authentication_verify(const
> struct gmac_test_data *tdata)
>  	int retval;
>  	uint32_t plaintext_pad_len;
>  	uint8_t *plaintext;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
>  			      "No GMAC length in the source data");
> @@ -10220,6 +10796,9 @@ test_AES_GMAC_authentication_verify(const
> struct gmac_test_data *tdata)
>  	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
>  		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
>  			ut_params->op);
> +	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 1, 0, 0);
>  	else
>  		TEST_ASSERT_NOT_NULL(
>  			process_crypto_request(ts_params->valid_devs[0],
> @@ -10735,6 +11314,16 @@
> test_authentication_verify_fail_when_data_corruption(
>  	int retval;
> 
>  	uint8_t *plaintext;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -10744,6 +11333,7 @@
> test_authentication_verify_fail_when_data_corruption(
>  			&cap_idx) == NULL)
>  		return -ENOTSUP;
> 
> +
>  	/* Create session */
>  	retval = create_auth_session(ut_params,
>  			ts_params->valid_devs[0],
> @@ -10785,7 +11375,10 @@
> test_authentication_verify_fail_when_data_corruption(
>  		TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
>  			RTE_CRYPTO_OP_STATUS_SUCCESS,
>  			"authentication not failed");
> -	} else {
> +	} else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 1, 0, 0);
> +	else {
>  		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
>  		TEST_ASSERT_NULL(ut_params->op, "authentication not
> failed");
> @@ -10803,6 +11396,16 @@
> test_authentication_verify_GMAC_fail_when_corruption(
>  {
>  	int retval;
>  	uint8_t *plaintext;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -10856,7 +11459,10 @@
> test_authentication_verify_GMAC_fail_when_corruption(
>  		TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
>  			RTE_CRYPTO_OP_STATUS_SUCCESS,
>  			"authentication not failed");
> -	} else {
> +	} else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 1, 0, 0);
> +	else {
>  		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
>  		TEST_ASSERT_NULL(ut_params->op, "authentication not
> failed");
> @@ -10875,6 +11481,16 @@
> test_authenticated_decryption_fail_when_corruption(
>  	int retval;
> 
>  	uint8_t *ciphertext;
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -10931,7 +11547,10 @@
> test_authenticated_decryption_fail_when_corruption(
>  		TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
>  			RTE_CRYPTO_OP_STATUS_SUCCESS,
>  			"authentication not failed");
> -	} else {
> +	} else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 1, 0, 0);
> +	else {
>  		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
>  		TEST_ASSERT_NULL(ut_params->op, "authentication not
> failed");
> @@ -10952,6 +11571,16 @@ test_authenticated_encryt_with_esn(
>  	uint16_t plaintext_pad_len;
>  	uint8_t cipher_key[reference->cipher_key.len + 1];
>  	uint8_t auth_key[reference->auth_key.len + 1];
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -11026,6 +11655,9 @@ test_authenticated_encryt_with_esn(
>  	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
>  		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
>  			ut_params->op);
> +	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 1, 0, 0);
>  	else
>  		ut_params->op = process_crypto_request(
>  			ts_params->valid_devs[0], ut_params->op);
> @@ -11072,6 +11704,16 @@ test_authenticated_decrypt_with_esn(
>  	uint8_t *ciphertext;
>  	uint8_t cipher_key[reference->cipher_key.len + 1];
>  	uint8_t auth_key[reference->auth_key.len + 1];
> +	struct rte_cryptodev_info dev_info;
> +
> +	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
> +	uint64_t feat_flags = dev_info.feature_flags;
> +
> +	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +		printf("Device doesn't support RAW data-path APIs.\n");
> +		return -ENOTSUP;
> +	}
> 
>  	/* Verify the capabilities */
>  	struct rte_cryptodev_sym_capability_idx cap_idx;
> @@ -11146,6 +11788,9 @@ test_authenticated_decrypt_with_esn(
>  	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
>  		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
>  			ut_params->op);
> +	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 1, 1, 0, 0);
>  	else
>  		ut_params->op = process_crypto_request(ts_params-
> >valid_devs[0],
>  			ut_params->op);
> @@ -11286,10 +11931,21 @@ test_authenticated_encryption_SGL(const struct
> aead_test_data *tdata,
>  		if (sgl_in && (!(dev_info.feature_flags &
>  				RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
>  			return -ENOTSUP;
> +
> +		uint64_t feat_flags = dev_info.feature_flags;
> +
> +		if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
> +			(!(feat_flags &
> RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
> +			printf("Device doesn't support RAW data-path APIs.\n");
> +			return -ENOTSUP;
> +		}
>  	} else {
>  		unsigned int sgl_in = fragsz < tdata->plaintext.len;
>  		unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
>  				tdata->plaintext.len;
> +		/* Raw data path API does not support OOP */
> +		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +			return -ENOTSUP;
>  		if (sgl_in && !sgl_out) {
>  			if (!(dev_info.feature_flags &
> 
> 	RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
> @@ -11485,6 +12141,9 @@ test_authenticated_encryption_SGL(const struct
> aead_test_data *tdata,
>  	if (oop == IN_PLACE &&
>  			gbl_action_type ==
> RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
>  		process_cpu_aead_op(ts_params->valid_devs[0], ut_params-
> >op);
> +	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
> +		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
> +				ut_params->op, 0, 0, 0, 0);
>  	else
>  		TEST_ASSERT_NOT_NULL(
>  			process_crypto_request(ts_params->valid_devs[0],
> @@ -13046,6 +13705,30 @@ test_cryptodev_nitrox(void)
>  	return unit_test_suite_runner(&cryptodev_nitrox_testsuite);
>  }
> 
> +static int
> +test_cryptodev_qat_raw_api(void /*argv __rte_unused, int argc
> __rte_unused*/)
> +{
> +	int ret;
> +
> +	gbl_driver_id =	rte_cryptodev_driver_id_get(
> +			RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
> +
> +	if (gbl_driver_id == -1) {
> +		RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check that
> both "
> +		"CONFIG_RTE_LIBRTE_PMD_QAT and
> CONFIG_RTE_LIBRTE_PMD_QAT_SYM "
> +		"are enabled in config file to run this testsuite.\n");
> +		return TEST_SKIPPED;
> +	}
> +
> +	global_api_test_type = CRYPTODEV_RAW_API_TEST;
> +	ret = unit_test_suite_runner(&cryptodev_testsuite);
> +	global_api_test_type = CRYPTODEV_API_TEST;

OK I got your point of checking feature flag in each test.
Please disregard my previous comment above. However, double check that
None of the test is left without checking the feature flag.


> +
> +	return ret;
> +}
> +
> +REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
> +		test_cryptodev_qat_raw_api);
>  REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
>  REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest,
> test_cryptodev_aesni_mb);
>  REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
> diff --git a/app/test/test_cryptodev.h b/app/test/test_cryptodev.h
> index 41542e055..d8fc0db53 100644
> --- a/app/test/test_cryptodev.h
> +++ b/app/test/test_cryptodev.h
> @@ -71,6 +71,13 @@
>  #define CRYPTODEV_NAME_CAAM_JR_PMD	crypto_caam_jr
>  #define CRYPTODEV_NAME_NITROX_PMD	crypto_nitrox_sym
> 
> +enum cryptodev_api_test_type {
> +	CRYPTODEV_API_TEST = 0,
> +	CRYPTODEV_RAW_API_TEST
> +};
> +
> +extern enum cryptodev_api_test_type global_api_test_type;
> +
>  /**
>   * Write (spread) data from buffer to mbuf data
>   *
> @@ -209,4 +216,9 @@ create_segmented_mbuf(struct rte_mempool
> *mbuf_pool, int pkt_len,
>  	return NULL;
>  }
> 
> +void
> +process_sym_raw_hw_api_op(uint8_t dev_id, uint16_t qp_id,
> +		struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
> +		uint8_t len_in_bits, uint8_t cipher_iv_len);
> +
>  #endif /* TEST_CRYPTODEV_H_ */
> diff --git a/app/test/test_cryptodev_blockcipher.c
> b/app/test/test_cryptodev_blockcipher.c
> index 221262341..f675a2c92 100644
> --- a/app/test/test_cryptodev_blockcipher.c
> +++ b/app/test/test_cryptodev_blockcipher.c
> @@ -136,6 +136,14 @@ test_blockcipher_one_case(const struct
> blockcipher_test_case *t,
>  		nb_segs = 3;
>  	}
> 
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST &&
> +		!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP)) {
> +		printf("Device doesn't support raw data-path APIs. "
> +			"Test Skipped.\n");
> +		snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "SKIPPED");
> +		return TEST_SKIPPED;
> +	}
> +
>  	if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) {
>  		uint64_t oop_flags =
> RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT |
>  			RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT |
> @@ -148,6 +156,13 @@ test_blockcipher_one_case(const struct
> blockcipher_test_case *t,
>  				"SKIPPED");
>  			return TEST_SKIPPED;
>  		}
> +		if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
> +			printf("Raw Data Path APIs do not support OOP, "
> +				"Test Skipped.\n");
> +			snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
> "SKIPPED");
> +			status = TEST_SUCCESS;
> +			goto error_exit;
> +		}
>  	}
> 
>  	if (tdata->cipher_key.len)
> @@ -462,25 +477,36 @@ test_blockcipher_one_case(const struct
> blockcipher_test_case *t,
>  	}
> 
>  	/* Process crypto operation */
> -	if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
> -		snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
> -			"line %u FAILED: %s",
> -			__LINE__, "Error sending packet for encryption");
> -		status = TEST_FAILED;
> -		goto error_exit;
> -	}
> +	if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
> +		uint8_t is_cipher = 0, is_auth = 0;
> +		if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER)
> +			is_cipher = 1;
> +		if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH)
> +			is_auth = 1;
> 
> -	op = NULL;
> +		process_sym_raw_hw_api_op(dev_id, 0, op, is_cipher, is_auth,
> 0,
> +				tdata->iv.len);
> +	} else {
> +		if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
> +			snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
> +				"line %u FAILED: %s",
> +				__LINE__, "Error sending packet for
> encryption");
> +			status = TEST_FAILED;
> +			goto error_exit;
> +		}
> 
> -	while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
> -		rte_pause();
> +		op = NULL;
> 
> -	if (!op) {
> -		snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
> -			"line %u FAILED: %s",
> -			__LINE__, "Failed to process sym crypto op");
> -		status = TEST_FAILED;
> -		goto error_exit;
> +		while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
> +			rte_pause();
> +
> +		if (!op) {
> +			snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
> +				"line %u FAILED: %s",
> +				__LINE__, "Failed to process sym crypto op");
> +			status = TEST_FAILED;
> +			goto error_exit;
> +		}
>  	}
> 
>  	debug_hexdump(stdout, "m_src(after):",
> --
> 2.20.1

Patch
diff mbox series

diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
index 99f1eed82..4e7dd1b63 100644
--- a/app/test/test_cryptodev.c
+++ b/app/test/test_cryptodev.c
@@ -49,6 +49,10 @@ 
 #define VDEV_ARGS_SIZE 100
 #define MAX_NB_SESSIONS 4
 
+#define MAX_DRV_SERVICE_CTX_SIZE 256
+
+#define MAX_RAW_DEQUEUE_COUNT	65535
+
 #define IN_PLACE 0
 #define OUT_OF_PLACE 1
 
@@ -57,6 +61,8 @@  static int gbl_driver_id;
 static enum rte_security_session_action_type gbl_action_type =
 	RTE_SECURITY_ACTION_TYPE_NONE;
 
+enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
+
 struct crypto_testsuite_params {
 	struct rte_mempool *mbuf_pool;
 	struct rte_mempool *large_mbuf_pool;
@@ -147,6 +153,187 @@  ceil_byte_length(uint32_t num_bits)
 		return (num_bits >> 3);
 }
 
+void
+process_sym_raw_hw_api_op(uint8_t dev_id, uint16_t qp_id,
+		struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
+		uint8_t len_in_bits, uint8_t cipher_iv_len)
+{
+	int32_t n;
+	struct rte_crypto_sym_op *sop = op->sym;
+	struct rte_crypto_op *ret_op = NULL;
+	struct rte_crypto_vec data_vec[UINT8_MAX];
+	struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
+	union rte_crypto_sym_ofs ofs;
+	struct rte_crypto_sym_vec vec;
+	struct rte_crypto_sgl sgl;
+	uint32_t max_len;
+	union rte_cryptodev_session_ctx sess;
+	uint32_t count = 0;
+	struct rte_crypto_raw_dp_ctx *ctx;
+	uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
+			auth_len = 0;
+	int ctx_service_size;
+	int32_t status = 0;
+
+	ctx_service_size = rte_cryptodev_raw_get_dp_context_size(dev_id);
+	if (ctx_service_size < 0) {
+		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return;
+	}
+
+	ctx = malloc(ctx_service_size);
+	if (!ctx) {
+		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return;
+	}
+
+	if (rte_cryptodev_raw_configure_dp_context(dev_id, qp_id, ctx) < 0) {
+		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return;
+	}
+
+	sess.crypto_sess = sop->session;
+	if (rte_cryptodev_raw_attach_session(dev_id, qp_id, ctx,
+			op->sess_type, sess) < 0) {
+		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return;
+	}
+
+	cipher_iv.iova = 0;
+	cipher_iv.va = NULL;
+	aad_auth_iv.iova = 0;
+	aad_auth_iv.va = NULL;
+	digest.iova = 0;
+	digest.va = NULL;
+	sgl.vec = data_vec;
+	vec.num = 1;
+	vec.sgl = &sgl;
+	vec.iv = &cipher_iv;
+	vec.digest = &digest;
+	vec.aad = &aad_auth_iv;
+	vec.status = &status;
+
+	ofs.raw = 0;
+
+	if (is_cipher && is_auth) {
+		cipher_offset = sop->cipher.data.offset;
+		cipher_len = sop->cipher.data.length;
+		auth_offset = sop->auth.data.offset;
+		auth_len = sop->auth.data.length;
+		max_len = RTE_MAX(cipher_offset + cipher_len,
+				auth_offset + auth_len);
+		if (len_in_bits) {
+			max_len = max_len >> 3;
+			cipher_offset = cipher_offset >> 3;
+			auth_offset = auth_offset >> 3;
+			cipher_len = cipher_len >> 3;
+			auth_len = auth_len >> 3;
+		}
+		ofs.ofs.cipher.head = cipher_offset;
+		ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
+		ofs.ofs.auth.head = auth_offset;
+		ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
+		cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
+		cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
+		aad_auth_iv.va = rte_crypto_op_ctod_offset(
+				op, void *, IV_OFFSET + cipher_iv_len);
+		aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
+				cipher_iv_len);
+		digest.va = (void *)sop->auth.digest.data;
+		digest.iova = sop->auth.digest.phys_addr;
+
+	} else if (is_cipher) {
+		cipher_offset = sop->cipher.data.offset;
+		cipher_len = sop->cipher.data.length;
+		max_len = cipher_len + cipher_offset;
+		if (len_in_bits) {
+			max_len = max_len >> 3;
+			cipher_offset = cipher_offset >> 3;
+			cipher_len = cipher_len >> 3;
+		}
+		ofs.ofs.cipher.head = cipher_offset;
+		ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
+		cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
+		cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
+
+	} else if (is_auth) {
+		auth_offset = sop->auth.data.offset;
+		auth_len = sop->auth.data.length;
+		max_len = auth_len + auth_offset;
+		if (len_in_bits) {
+			max_len = max_len >> 3;
+			auth_offset = auth_offset >> 3;
+			auth_len = auth_len >> 3;
+		}
+		ofs.ofs.auth.head = auth_offset;
+		ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
+		aad_auth_iv.va = rte_crypto_op_ctod_offset(
+				op, void *, IV_OFFSET + cipher_iv_len);
+		aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
+				cipher_iv_len);
+		digest.va = (void *)sop->auth.digest.data;
+		digest.iova = sop->auth.digest.phys_addr;
+
+	} else { /* aead */
+		cipher_offset = sop->aead.data.offset;
+		cipher_len = sop->aead.data.length;
+		max_len = cipher_len + cipher_offset;
+		if (len_in_bits) {
+			max_len = max_len >> 3;
+			cipher_offset = cipher_offset >> 3;
+			cipher_len = cipher_len >> 3;
+		}
+		ofs.ofs.cipher.head = cipher_offset;
+		ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
+		cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
+		cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
+		aad_auth_iv.va = (void *)sop->aead.aad.data;
+		aad_auth_iv.iova = sop->aead.aad.phys_addr;
+		digest.va = (void *)sop->aead.digest.data;
+		digest.iova = sop->aead.digest.phys_addr;
+	}
+
+	n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
+			data_vec, RTE_DIM(data_vec));
+	if (n < 0 || n > sop->m_src->nb_segs) {
+		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return;
+	}
+
+	sgl.num = n;
+
+	if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op)
+			< 1) {
+		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return;
+	}
+
+	status = rte_cryptodev_raw_enqueue_done(ctx, 1);
+	if (status < 0) {
+		op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+		return;
+	}
+
+
+	status = -1;
+	while (count++ < MAX_RAW_DEQUEUE_COUNT && status == -1) {
+		status = rte_cryptodev_raw_dequeue(ctx, (void **)&ret_op);
+		if (status == -1)
+			rte_pause();
+	}
+
+	if (status != -1) {
+		if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
+			op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+			return;
+		}
+	}
+
+	op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
+			status != 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
+					RTE_CRYPTO_OP_STATUS_SUCCESS;
+}
+
 static void
 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
 {
@@ -1661,6 +1848,9 @@  test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
 		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
 			ut_params->op);
+	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 1, 0, 0);
 	else
 		TEST_ASSERT_NOT_NULL(
 				process_crypto_request(ts_params->valid_devs[0],
@@ -1715,12 +1905,18 @@  test_AES_cipheronly_all(void)
 static int
 test_AES_docsis_all(void)
 {
+	/* Data-path service does not support DOCSIS yet */
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
 	return test_blockcipher(BLKCIPHER_AES_DOCSIS_TYPE);
 }
 
 static int
 test_DES_docsis_all(void)
 {
+	/* Data-path service does not support DOCSIS yet */
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
 	return test_blockcipher(BLKCIPHER_DES_DOCSIS_TYPE);
 }
 
@@ -2435,6 +2631,12 @@  test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
 		return -ENOTSUP;
 	}
 
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
+
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
 	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
@@ -2475,7 +2677,11 @@  test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 1, 1, 0);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 				ut_params->op);
 	ut_params->obuf = ut_params->op->sym->m_src;
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
@@ -2513,6 +2719,12 @@  test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
 		return -ENOTSUP;
 	}
 
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
+
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
 	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
@@ -2554,7 +2766,11 @@  test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 1, 1, 0);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 				ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 	ut_params->obuf = ut_params->op->sym->m_src;
@@ -2580,6 +2796,16 @@  test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
 	unsigned plaintext_pad_len;
 	unsigned plaintext_len;
 	uint8_t *plaintext;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -2624,6 +2850,9 @@  test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
 	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
 		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
 			ut_params->op);
+	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 1, 1, 0);
 	else
 		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
@@ -2653,6 +2882,16 @@  test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
 	unsigned plaintext_pad_len;
 	unsigned plaintext_len;
 	uint8_t *plaintext;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -2695,7 +2934,11 @@  test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 1, 1, 0);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 				ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 	ut_params->obuf = ut_params->op->sym->m_src;
@@ -2860,6 +3103,16 @@  test_kasumi_encryption(const struct kasumi_test_data *tdata)
 	uint8_t *plaintext, *ciphertext;
 	unsigned plaintext_pad_len;
 	unsigned plaintext_len;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -2902,8 +3155,12 @@  test_kasumi_encryption(const struct kasumi_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-						ut_params->op);
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+				ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
 	ut_params->obuf = ut_params->op->sym->m_dst;
@@ -2959,6 +3216,12 @@  test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
 		return -ENOTSUP;
 	}
 
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
+
 	/* Create KASUMI session */
 	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
 					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -2988,7 +3251,11 @@  test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 						ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
@@ -3031,10 +3298,14 @@  test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
 	struct rte_cryptodev_sym_capability_idx cap_idx;
 	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
 	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
+	/* Data-path service does not support OOP */
 	if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
 			&cap_idx) == NULL)
 		return -ENOTSUP;
 
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
+
 	/* Create KASUMI session */
 	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
 					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -3116,6 +3387,9 @@  test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
 			&cap_idx) == NULL)
 		return -ENOTSUP;
 
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
+
 	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
 	uint64_t feat_flags = dev_info.feature_flags;
@@ -3201,6 +3475,9 @@  test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
 			&cap_idx) == NULL)
 		return -ENOTSUP;
 
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
+
 	/* Create KASUMI session */
 	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
 					RTE_CRYPTO_CIPHER_OP_DECRYPT,
@@ -3269,6 +3546,16 @@  test_kasumi_decryption(const struct kasumi_test_data *tdata)
 	uint8_t *ciphertext, *plaintext;
 	unsigned ciphertext_pad_len;
 	unsigned ciphertext_len;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -3311,7 +3598,11 @@  test_kasumi_decryption(const struct kasumi_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 0, 1, 0);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 						ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
@@ -3344,6 +3635,16 @@  test_snow3g_encryption(const struct snow3g_test_data *tdata)
 	uint8_t *plaintext, *ciphertext;
 	unsigned plaintext_pad_len;
 	unsigned plaintext_len;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -3386,7 +3687,11 @@  test_snow3g_encryption(const struct snow3g_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 						ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
@@ -3427,6 +3732,9 @@  test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
 			&cap_idx) == NULL)
 		return -ENOTSUP;
 
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
+
 	/* Create SNOW 3G session */
 	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
 					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -3510,6 +3818,9 @@  test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
 			&cap_idx) == NULL)
 		return -ENOTSUP;
 
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
+
 	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
 	uint64_t feat_flags = dev_info.feature_flags;
@@ -3629,6 +3940,9 @@  test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
 			&cap_idx) == NULL)
 		return -ENOTSUP;
 
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
+
 	/* Create SNOW 3G session */
 	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
 					RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -3719,6 +4033,16 @@  static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
 	uint8_t *plaintext, *ciphertext;
 	unsigned ciphertext_pad_len;
 	unsigned ciphertext_len;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -3761,7 +4085,11 @@  static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 						ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 	ut_params->obuf = ut_params->op->sym->m_dst;
@@ -3799,6 +4127,9 @@  static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
 			&cap_idx) == NULL)
 		return -ENOTSUP;
 
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
+
 	/* Create SNOW 3G session */
 	retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
 					RTE_CRYPTO_CIPHER_OP_DECRYPT,
@@ -3886,6 +4217,12 @@  test_zuc_cipher_auth(const struct wireless_test_data *tdata)
 		return -ENOTSUP;
 	}
 
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
+
 	/* Check if device supports ZUC EEA3 */
 	cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
 	cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
@@ -3929,7 +4266,11 @@  test_zuc_cipher_auth(const struct wireless_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 	ut_params->obuf = ut_params->op->sym->m_src;
@@ -3969,6 +4310,16 @@  test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
 	uint8_t *plaintext, *ciphertext;
 	unsigned plaintext_pad_len;
 	unsigned plaintext_len;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -4024,7 +4375,11 @@  test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 	ut_params->obuf = ut_params->op->sym->m_src;
@@ -4092,6 +4447,14 @@  test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
 			printf("Device doesn't support digest encrypted.\n");
 			return -ENOTSUP;
 		}
+		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+			return -ENOTSUP;
+	}
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
 	}
 
 	/* Create SNOW 3G session */
@@ -4160,7 +4523,11 @@  test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
@@ -4270,7 +4637,14 @@  test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
 					"in both input and output mbufs.\n");
 			return -ENOTSUP;
 		}
+		if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+			printf("Device doesn't support RAW data-path APIs.\n");
+			return -ENOTSUP;
+		}
 	} else {
+		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+			return -ENOTSUP;
 		if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
 			printf("Device doesn't support out-of-place scatter-gather "
 					"in both input and output mbufs.\n");
@@ -4349,7 +4723,11 @@  test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
@@ -4457,7 +4835,15 @@  test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
 
 	uint64_t feat_flags = dev_info.feature_flags;
 
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
+
 	if (op_mode == OUT_OF_PLACE) {
+		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+			return -ENOTSUP;
 		if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
 			printf("Device doesn't support digest encrypted.\n");
 			return -ENOTSUP;
@@ -4531,7 +4917,11 @@  test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
@@ -4642,7 +5032,14 @@  test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
 					"in both input and output mbufs.\n");
 			return -ENOTSUP;
 		}
+		if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+			printf("Device doesn't support RAW data-path APIs.\n");
+			return -ENOTSUP;
+		}
 	} else {
+		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+			return -ENOTSUP;
 		if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
 			printf("Device doesn't support out-of-place scatter-gather "
 					"in both input and output mbufs.\n");
@@ -4721,7 +5118,11 @@  test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
@@ -4806,6 +5207,16 @@  test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
 	uint8_t *plaintext, *ciphertext;
 	unsigned plaintext_pad_len;
 	unsigned plaintext_len;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -4862,7 +5273,11 @@  test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
@@ -4905,6 +5320,16 @@  test_zuc_encryption(const struct wireless_test_data *tdata)
 	uint8_t *plaintext, *ciphertext;
 	unsigned plaintext_pad_len;
 	unsigned plaintext_len;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	struct rte_cryptodev_sym_capability_idx cap_idx;
 
@@ -4949,7 +5374,11 @@  test_zuc_encryption(const struct wireless_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 						ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
@@ -5004,6 +5433,12 @@  test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
 		return -ENOTSUP;
 	}
 
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
+
 	plaintext_len = ceil_byte_length(tdata->plaintext.len);
 
 	/* Append data which is padded to a multiple */
@@ -5036,7 +5471,11 @@  test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 						ut_params->op);
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
@@ -5084,6 +5523,12 @@  test_zuc_authentication(const struct wireless_test_data *tdata)
 		return -ENOTSUP;
 	}
 
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
+
 	/* Check if device supports ZUC EIA3 */
 	cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
 	cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
@@ -5124,7 +5569,11 @@  test_zuc_authentication(const struct wireless_test_data *tdata)
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 1, 1, 0);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 				ut_params->op);
 	ut_params->obuf = ut_params->op->sym->m_src;
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
@@ -5181,7 +5630,15 @@  test_zuc_auth_cipher(const struct wireless_test_data *tdata,
 					"in both input and output mbufs.\n");
 			return -ENOTSUP;
 		}
+
+		if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+			printf("Device doesn't support RAW data-path APIs.\n");
+			return -ENOTSUP;
+		}
 	} else {
+		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+			return -ENOTSUP;
 		if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
 			printf("Device doesn't support out-of-place scatter-gather "
 					"in both input and output mbufs.\n");
@@ -5256,7 +5713,11 @@  test_zuc_auth_cipher(const struct wireless_test_data *tdata,
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
@@ -5363,7 +5824,15 @@  test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
 					"in both input and output mbufs.\n");
 			return -ENOTSUP;
 		}
+
+		if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+			printf("Device doesn't support RAW data-path APIs.\n");
+			return -ENOTSUP;
+		}
 	} else {
+		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+			return -ENOTSUP;
 		if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
 			printf("Device doesn't support out-of-place scatter-gather "
 					"in both input and output mbufs.\n");
@@ -5442,7 +5911,11 @@  test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
 	if (retval < 0)
 		return retval;
 
-	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
+	else
+		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
@@ -5585,6 +6058,9 @@  test_kasumi_decryption_test_case_2(void)
 static int
 test_kasumi_decryption_test_case_3(void)
 {
+	/* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
 	return test_kasumi_decryption(&kasumi_test_case_3);
 }
 
@@ -5784,6 +6260,9 @@  test_snow3g_auth_cipher_part_digest_enc_oop(void)
 static int
 test_snow3g_auth_cipher_test_case_3_sgl(void)
 {
+	/* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
 	return test_snow3g_auth_cipher_sgl(
 		&snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
 }
@@ -5798,6 +6277,9 @@  test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
 static int
 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
 {
+	/* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
 	return test_snow3g_auth_cipher_sgl(
 		&snow3g_auth_cipher_partial_digest_encryption,
 			IN_PLACE, 0);
@@ -6151,11 +6633,12 @@  test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
 	unsigned int ciphertext_len;
 
 	struct rte_cryptodev_info dev_info;
-	struct rte_crypto_op *op;
 
 	/* Check if device supports particular algorithms separately */
 	if (test_mixed_check_if_unsupported(tdata))
 		return -ENOTSUP;
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
 
 	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
@@ -6166,6 +6649,9 @@  test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
 		return -ENOTSUP;
 	}
 
+	if (op_mode == OUT_OF_PLACE)
+		return -ENOTSUP;
+
 	/* Create the session */
 	if (verify)
 		retval = create_wireless_algo_cipher_auth_session(
@@ -6197,9 +6683,11 @@  test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
 	/* clear mbuf payload */
 	memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
 		rte_pktmbuf_tailroom(ut_params->ibuf));
-	if (op_mode == OUT_OF_PLACE)
+	if (op_mode == OUT_OF_PLACE) {
+
 		memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
 				rte_pktmbuf_tailroom(ut_params->obuf));
+	}
 
 	ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
 	plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
@@ -6240,18 +6728,17 @@  test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
 	if (retval < 0)
 		return retval;
 
-	op = process_crypto_request(ts_params->valid_devs[0],
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 
 	/* Check if the op failed because the device doesn't */
 	/* support this particular combination of algorithms */
-	if (op == NULL && ut_params->op->status ==
+	if (ut_params->op == NULL && ut_params->op->status ==
 			RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
 		printf("Device doesn't support this mixed combination. "
 				"Test Skipped.\n");
 		return -ENOTSUP;
 	}
-	ut_params->op = op;
 
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
@@ -6342,11 +6829,12 @@  test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
 	uint8_t digest_buffer[10000];
 
 	struct rte_cryptodev_info dev_info;
-	struct rte_crypto_op *op;
 
 	/* Check if device supports particular algorithms */
 	if (test_mixed_check_if_unsupported(tdata))
 		return -ENOTSUP;
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
 
 	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
@@ -6445,20 +6933,18 @@  test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
 	if (retval < 0)
 		return retval;
 
-	op = process_crypto_request(ts_params->valid_devs[0],
+	ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 
 	/* Check if the op failed because the device doesn't */
 	/* support this particular combination of algorithms */
-	if (op == NULL && ut_params->op->status ==
+	if (ut_params->op == NULL && ut_params->op->status ==
 			RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
 		printf("Device doesn't support this mixed combination. "
 				"Test Skipped.\n");
 		return -ENOTSUP;
 	}
 
-	ut_params->op = op;
-
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
 	ut_params->obuf = (op_mode == IN_PLACE ?
@@ -6999,6 +7485,16 @@  test_authenticated_encryption(const struct aead_test_data *tdata)
 	uint8_t *ciphertext, *auth_tag;
 	uint16_t plaintext_pad_len;
 	uint32_t i;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -7048,6 +7544,9 @@  test_authenticated_encryption(const struct aead_test_data *tdata)
 	/* Process crypto operation */
 	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
 		process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
+	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 0, 0, 0);
 	else
 		TEST_ASSERT_NOT_NULL(
 			process_crypto_request(ts_params->valid_devs[0],
@@ -8496,6 +8995,16 @@  test_authenticated_decryption(const struct aead_test_data *tdata)
 	int retval;
 	uint8_t *plaintext;
 	uint32_t i;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -8545,6 +9054,9 @@  test_authenticated_decryption(const struct aead_test_data *tdata)
 	/* Process crypto operation */
 	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
 		process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
+	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 0, 0, 0);
 	else
 		TEST_ASSERT_NOT_NULL(
 			process_crypto_request(ts_params->valid_devs[0],
@@ -8839,6 +9351,9 @@  test_authenticated_encryption_oop(const struct aead_test_data *tdata)
 			&cap_idx) == NULL)
 		return -ENOTSUP;
 
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		return -ENOTSUP;
+
 	/* not supported with CPU crypto */
 	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
 		return -ENOTSUP;
@@ -8928,8 +9443,9 @@  test_authenticated_decryption_oop(const struct aead_test_data *tdata)
 			&cap_idx) == NULL)
 		return -ENOTSUP;
 
-	/* not supported with CPU crypto */
-	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+	/* not supported with CPU crypto and raw data-path APIs*/
+	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
+			global_api_test_type == CRYPTODEV_RAW_API_TEST)
 		return -ENOTSUP;
 
 	/* Create AEAD session */
@@ -9115,6 +9631,12 @@  test_authenticated_decryption_sessionless(
 		return -ENOTSUP;
 	}
 
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
+
 	/* not supported with CPU crypto */
 	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
 		return -ENOTSUP;
@@ -9156,8 +9678,13 @@  test_authenticated_decryption_sessionless(
 			"crypto op session type not sessionless");
 
 	/* Process crypto operation */
-	TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
-			ut_params->op), "failed to process sym crypto op");
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 0, 0, 0);
+	else
+		TEST_ASSERT_NOT_NULL(process_crypto_request(
+			ts_params->valid_devs[0], ut_params->op),
+				"failed to process sym crypto op");
 
 	TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
 
@@ -9449,6 +9976,16 @@  test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
 
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -9477,6 +10014,9 @@  test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
 	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
 		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
 			ut_params->op);
+	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 1, 0, 0);
 	else
 		TEST_ASSERT_NOT_NULL(
 			process_crypto_request(ts_params->valid_devs[0],
@@ -9509,6 +10049,16 @@  test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
 
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -9535,6 +10085,9 @@  test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
 	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
 		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
 			ut_params->op);
+	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 1, 0, 0);
 	else
 		TEST_ASSERT_NOT_NULL(
 			process_crypto_request(ts_params->valid_devs[0],
@@ -10040,6 +10593,16 @@  test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
 {
 	struct crypto_testsuite_params *ts_params = &testsuite_params;
 	struct crypto_unittest_params *ut_params = &unittest_params;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	int retval;
 
@@ -10103,6 +10666,9 @@  test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
 	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
 		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
 			ut_params->op);
+	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 1, 0, 0);
 	else
 		TEST_ASSERT_NOT_NULL(
 			process_crypto_request(ts_params->valid_devs[0],
@@ -10161,6 +10727,16 @@  test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
 	int retval;
 	uint32_t plaintext_pad_len;
 	uint8_t *plaintext;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
 			      "No GMAC length in the source data");
@@ -10220,6 +10796,9 @@  test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
 	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
 		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
 			ut_params->op);
+	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 1, 0, 0);
 	else
 		TEST_ASSERT_NOT_NULL(
 			process_crypto_request(ts_params->valid_devs[0],
@@ -10735,6 +11314,16 @@  test_authentication_verify_fail_when_data_corruption(
 	int retval;
 
 	uint8_t *plaintext;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -10744,6 +11333,7 @@  test_authentication_verify_fail_when_data_corruption(
 			&cap_idx) == NULL)
 		return -ENOTSUP;
 
+
 	/* Create session */
 	retval = create_auth_session(ut_params,
 			ts_params->valid_devs[0],
@@ -10785,7 +11375,10 @@  test_authentication_verify_fail_when_data_corruption(
 		TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
 			RTE_CRYPTO_OP_STATUS_SUCCESS,
 			"authentication not failed");
-	} else {
+	} else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 1, 0, 0);
+	else {
 		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 		TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
@@ -10803,6 +11396,16 @@  test_authentication_verify_GMAC_fail_when_corruption(
 {
 	int retval;
 	uint8_t *plaintext;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -10856,7 +11459,10 @@  test_authentication_verify_GMAC_fail_when_corruption(
 		TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
 			RTE_CRYPTO_OP_STATUS_SUCCESS,
 			"authentication not failed");
-	} else {
+	} else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 1, 0, 0);
+	else {
 		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 		TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
@@ -10875,6 +11481,16 @@  test_authenticated_decryption_fail_when_corruption(
 	int retval;
 
 	uint8_t *ciphertext;
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -10931,7 +11547,10 @@  test_authenticated_decryption_fail_when_corruption(
 		TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
 			RTE_CRYPTO_OP_STATUS_SUCCESS,
 			"authentication not failed");
-	} else {
+	} else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 1, 0, 0);
+	else {
 		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
 		TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
@@ -10952,6 +11571,16 @@  test_authenticated_encryt_with_esn(
 	uint16_t plaintext_pad_len;
 	uint8_t cipher_key[reference->cipher_key.len + 1];
 	uint8_t auth_key[reference->auth_key.len + 1];
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -11026,6 +11655,9 @@  test_authenticated_encryt_with_esn(
 	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
 		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
 			ut_params->op);
+	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 1, 0, 0);
 	else
 		ut_params->op = process_crypto_request(
 			ts_params->valid_devs[0], ut_params->op);
@@ -11072,6 +11704,16 @@  test_authenticated_decrypt_with_esn(
 	uint8_t *ciphertext;
 	uint8_t cipher_key[reference->cipher_key.len + 1];
 	uint8_t auth_key[reference->auth_key.len + 1];
+	struct rte_cryptodev_info dev_info;
+
+	rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+	uint64_t feat_flags = dev_info.feature_flags;
+
+	if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+		printf("Device doesn't support RAW data-path APIs.\n");
+		return -ENOTSUP;
+	}
 
 	/* Verify the capabilities */
 	struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -11146,6 +11788,9 @@  test_authenticated_decrypt_with_esn(
 	if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
 		process_cpu_crypt_auth_op(ts_params->valid_devs[0],
 			ut_params->op);
+	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 1, 1, 0, 0);
 	else
 		ut_params->op = process_crypto_request(ts_params->valid_devs[0],
 			ut_params->op);
@@ -11286,10 +11931,21 @@  test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
 		if (sgl_in && (!(dev_info.feature_flags &
 				RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
 			return -ENOTSUP;
+
+		uint64_t feat_flags = dev_info.feature_flags;
+
+		if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+			(!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+			printf("Device doesn't support RAW data-path APIs.\n");
+			return -ENOTSUP;
+		}
 	} else {
 		unsigned int sgl_in = fragsz < tdata->plaintext.len;
 		unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
 				tdata->plaintext.len;
+		/* Raw data path API does not support OOP */
+		if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+			return -ENOTSUP;
 		if (sgl_in && !sgl_out) {
 			if (!(dev_info.feature_flags &
 					RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
@@ -11485,6 +12141,9 @@  test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
 	if (oop == IN_PLACE &&
 			gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
 		process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
+	else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+		process_sym_raw_hw_api_op(ts_params->valid_devs[0], 0,
+				ut_params->op, 0, 0, 0, 0);
 	else
 		TEST_ASSERT_NOT_NULL(
 			process_crypto_request(ts_params->valid_devs[0],
@@ -13046,6 +13705,30 @@  test_cryptodev_nitrox(void)
 	return unit_test_suite_runner(&cryptodev_nitrox_testsuite);
 }
 
+static int
+test_cryptodev_qat_raw_api(void /*argv __rte_unused, int argc __rte_unused*/)
+{
+	int ret;
+
+	gbl_driver_id =	rte_cryptodev_driver_id_get(
+			RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
+
+	if (gbl_driver_id == -1) {
+		RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check that both "
+		"CONFIG_RTE_LIBRTE_PMD_QAT and CONFIG_RTE_LIBRTE_PMD_QAT_SYM "
+		"are enabled in config file to run this testsuite.\n");
+		return TEST_SKIPPED;
+	}
+
+	global_api_test_type = CRYPTODEV_RAW_API_TEST;
+	ret = unit_test_suite_runner(&cryptodev_testsuite);
+	global_api_test_type = CRYPTODEV_API_TEST;
+
+	return ret;
+}
+
+REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
+		test_cryptodev_qat_raw_api);
 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
diff --git a/app/test/test_cryptodev.h b/app/test/test_cryptodev.h
index 41542e055..d8fc0db53 100644
--- a/app/test/test_cryptodev.h
+++ b/app/test/test_cryptodev.h
@@ -71,6 +71,13 @@ 
 #define CRYPTODEV_NAME_CAAM_JR_PMD	crypto_caam_jr
 #define CRYPTODEV_NAME_NITROX_PMD	crypto_nitrox_sym
 
+enum cryptodev_api_test_type {
+	CRYPTODEV_API_TEST = 0,
+	CRYPTODEV_RAW_API_TEST
+};
+
+extern enum cryptodev_api_test_type global_api_test_type;
+
 /**
  * Write (spread) data from buffer to mbuf data
  *
@@ -209,4 +216,9 @@  create_segmented_mbuf(struct rte_mempool *mbuf_pool, int pkt_len,
 	return NULL;
 }
 
+void
+process_sym_raw_hw_api_op(uint8_t dev_id, uint16_t qp_id,
+		struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
+		uint8_t len_in_bits, uint8_t cipher_iv_len);
+
 #endif /* TEST_CRYPTODEV_H_ */
diff --git a/app/test/test_cryptodev_blockcipher.c b/app/test/test_cryptodev_blockcipher.c
index 221262341..f675a2c92 100644
--- a/app/test/test_cryptodev_blockcipher.c
+++ b/app/test/test_cryptodev_blockcipher.c
@@ -136,6 +136,14 @@  test_blockcipher_one_case(const struct blockcipher_test_case *t,
 		nb_segs = 3;
 	}
 
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST &&
+		!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP)) {
+		printf("Device doesn't support raw data-path APIs. "
+			"Test Skipped.\n");
+		snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "SKIPPED");
+		return TEST_SKIPPED;
+	}
+
 	if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) {
 		uint64_t oop_flags = RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT |
 			RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT |
@@ -148,6 +156,13 @@  test_blockcipher_one_case(const struct blockcipher_test_case *t,
 				"SKIPPED");
 			return TEST_SKIPPED;
 		}
+		if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
+			printf("Raw Data Path APIs do not support OOP, "
+				"Test Skipped.\n");
+			snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "SKIPPED");
+			status = TEST_SUCCESS;
+			goto error_exit;
+		}
 	}
 
 	if (tdata->cipher_key.len)
@@ -462,25 +477,36 @@  test_blockcipher_one_case(const struct blockcipher_test_case *t,
 	}
 
 	/* Process crypto operation */
-	if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
-		snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
-			"line %u FAILED: %s",
-			__LINE__, "Error sending packet for encryption");
-		status = TEST_FAILED;
-		goto error_exit;
-	}
+	if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
+		uint8_t is_cipher = 0, is_auth = 0;
+		if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER)
+			is_cipher = 1;
+		if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH)
+			is_auth = 1;
 
-	op = NULL;
+		process_sym_raw_hw_api_op(dev_id, 0, op, is_cipher, is_auth, 0,
+				tdata->iv.len);
+	} else {
+		if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
+			snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
+				"line %u FAILED: %s",
+				__LINE__, "Error sending packet for encryption");
+			status = TEST_FAILED;
+			goto error_exit;
+		}
 
-	while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
-		rte_pause();
+		op = NULL;
 
-	if (!op) {
-		snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
-			"line %u FAILED: %s",
-			__LINE__, "Failed to process sym crypto op");
-		status = TEST_FAILED;
-		goto error_exit;
+		while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
+			rte_pause();
+
+		if (!op) {
+			snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
+				"line %u FAILED: %s",
+				__LINE__, "Failed to process sym crypto op");
+			status = TEST_FAILED;
+			goto error_exit;
+		}
 	}
 
 	debug_hexdump(stdout, "m_src(after):",