DPDK patches and discussions
 help / color / mirror / Atom feed
From: Akhil Goyal <akhil.goyal@nxp.com>
To: Fan Zhang <roy.fan.zhang@intel.com>, "dev@dpdk.org" <dev@dpdk.org>
Cc: "fiona.trahe@intel.com" <fiona.trahe@intel.com>,
	"arkadiuszx.kusztal@intel.com" <arkadiuszx.kusztal@intel.com>,
	"adamx.dybkowski@intel.com" <adamx.dybkowski@intel.com>,
	"anoobj@marvell.com" <anoobj@marvell.com>,
	"konstantin.ananyev@intel.com" <konstantin.ananyev@intel.com>
Subject: Re: [dpdk-dev] [dpdk-dev v10 4/4] test/crypto: add unit-test for cryptodev raw API test
Date: Thu, 8 Oct 2020 15:01:21 +0000
Message-ID: <VI1PR04MB316801FAA21F8EF1169C90A0E60B0@VI1PR04MB3168.eurprd04.prod.outlook.com> (raw)
In-Reply-To: <20200924163417.49983-5-roy.fan.zhang@intel.com>

> 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


  parent reply	other threads:[~2020-10-08 15:01 UTC|newest]

Thread overview: 84+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2020-08-18 16:28 [dpdk-dev] [dpdk-dev v6 0/4] cryptodev: add data-path service APIs Fan Zhang
2020-08-18 16:28 ` [dpdk-dev] [dpdk-dev v6 1/4] cryptodev: add crypto " Fan Zhang
2020-08-18 16:28 ` [dpdk-dev] [dpdk-dev v6 2/4] crypto/qat: add crypto data-path service API support Fan Zhang
2020-08-18 16:28 ` [dpdk-dev] [dpdk-dev v6 3/4] test/crypto: add unit-test for cryptodev direct APIs Fan Zhang
2020-08-18 16:28 ` [dpdk-dev] [dpdk-dev v6 4/4] doc: add cryptodev service APIs guide Fan Zhang
2020-08-28 12:58 ` [dpdk-dev] [dpdk-dev v7 0/4] cryptodev: add data-path service APIs Fan Zhang
2020-08-28 12:58   ` [dpdk-dev] [dpdk-dev v7 1/4] cryptodev: add crypto " Fan Zhang
2020-08-31  6:23     ` Kusztal, ArkadiuszX
2020-08-31 12:21       ` Zhang, Roy Fan
2020-08-31 15:15       ` Zhang, Roy Fan
2020-08-28 12:58   ` [dpdk-dev] [dpdk-dev v7 2/4] crypto/qat: add crypto data-path service API support Fan Zhang
2020-08-28 12:58   ` [dpdk-dev] [dpdk-dev v7 3/4] test/crypto: add unit-test for cryptodev direct APIs Fan Zhang
2020-08-28 12:58   ` [dpdk-dev] [dpdk-dev v7 4/4] doc: add cryptodev service APIs guide Fan Zhang
2020-09-04 15:25   ` [dpdk-dev] [dpdk-dev v8 0/4] cryptodev: add data-path service APIs Fan Zhang
2020-09-04 15:25     ` [dpdk-dev] [dpdk-dev v8 1/4] cryptodev: add crypto " Fan Zhang
2020-09-07 12:36       ` Dybkowski, AdamX
2020-09-04 15:25     ` [dpdk-dev] [dpdk-dev v8 2/4] crypto/qat: add crypto data-path service API support Fan Zhang
2020-09-04 15:25     ` [dpdk-dev] [dpdk-dev v8 3/4] test/crypto: add unit-test for cryptodev direct APIs Fan Zhang
2020-09-04 15:25     ` [dpdk-dev] [dpdk-dev v8 4/4] doc: add cryptodev service APIs guide Fan Zhang
2020-09-08  8:42     ` [dpdk-dev] [dpdk-dev v9 0/4] cryptodev: add data-path service APIs Fan Zhang
2020-09-08  8:42       ` [dpdk-dev] [dpdk-dev v9 1/4] cryptodev: add crypto " Fan Zhang
2020-09-18 21:50         ` Akhil Goyal
2020-09-21 10:40           ` Zhang, Roy Fan
2020-09-21 11:59             ` Akhil Goyal
2020-09-21 15:26               ` Zhang, Roy Fan
2020-09-21 15:41               ` Zhang, Roy Fan
2020-09-21 15:49                 ` Akhil Goyal
2020-09-22  8:08                   ` Zhang, Roy Fan
2020-09-22  8:21                   ` Zhang, Roy Fan
2020-09-22  8:48                     ` Ananyev, Konstantin
2020-09-22  9:05                       ` Akhil Goyal
2020-09-22  9:28                         ` Zhang, Roy Fan
2020-09-22 10:18                           ` Ananyev, Konstantin
2020-09-22 12:15                             ` Zhang, Roy Fan
2020-09-22 12:50                             ` Zhang, Roy Fan
2020-09-22 12:52                               ` Akhil Goyal
2020-09-08  8:42       ` [dpdk-dev] [dpdk-dev v9 2/4] crypto/qat: add crypto data-path service API support Fan Zhang
2020-09-08  8:42       ` [dpdk-dev] [dpdk-dev v9 3/4] test/crypto: add unit-test for cryptodev direct APIs Fan Zhang
2020-09-18 20:03         ` Akhil Goyal
2020-09-21 12:41           ` Zhang, Roy Fan
2020-09-08  8:42       ` [dpdk-dev] [dpdk-dev v9 4/4] doc: add cryptodev service APIs guide Fan Zhang
2020-09-18 20:39         ` Akhil Goyal
2020-09-21 12:28           ` Zhang, Roy Fan
2020-09-23 13:37           ` Zhang, Roy Fan
2020-09-24 16:34       ` [dpdk-dev] [dpdk-dev v10 0/4] cryptodev: add raw data-path APIs Fan Zhang
2020-09-24 16:34         ` [dpdk-dev] [dpdk-dev v10 1/4] cryptodev: change crypto symmetric vector structure Fan Zhang
2020-09-25  8:03           ` Dybkowski, AdamX
2020-09-28 17:01           ` Ananyev, Konstantin
2020-09-24 16:34         ` [dpdk-dev] [dpdk-dev v10 2/4] cryptodev: add raw crypto data-path APIs Fan Zhang
2020-09-25  8:04           ` Dybkowski, AdamX
2020-10-08 14:26           ` Akhil Goyal
2020-10-08 15:29             ` Zhang, Roy Fan
2020-10-08 16:07               ` Akhil Goyal
2020-10-08 16:24                 ` Zhang, Roy Fan
2020-10-09  8:32                 ` Zhang, Roy Fan
2020-10-08 14:37           ` Akhil Goyal
2020-09-24 16:34         ` [dpdk-dev] [dpdk-dev v10 3/4] crypto/qat: add raw crypto data-path API support Fan Zhang
2020-09-25  8:04           ` Dybkowski, AdamX
2020-09-24 16:34         ` [dpdk-dev] [dpdk-dev v10 4/4] test/crypto: add unit-test for cryptodev raw API test Fan Zhang
2020-09-25  8:05           ` Dybkowski, AdamX
2020-10-08 15:01           ` Akhil Goyal [this message]
2020-10-08 15:04         ` [dpdk-dev] [dpdk-dev v10 0/4] cryptodev: add raw data-path APIs Akhil Goyal
2020-10-08 15:30           ` Zhang, Roy Fan
2020-10-09 21:11         ` [dpdk-dev] [dpdk-dev v11 " Fan Zhang
2020-10-09 21:11           ` [dpdk-dev] [dpdk-dev v11 1/4] cryptodev: change crypto symmetric vector structure Fan Zhang
2020-10-09 21:11           ` [dpdk-dev] [dpdk-dev v11 2/4] cryptodev: add raw crypto data-path APIs Fan Zhang
2020-10-10 19:38             ` Akhil Goyal
2020-10-10 20:40               ` Zhang, Roy Fan
2020-10-09 21:11           ` [dpdk-dev] [dpdk-dev v11 3/4] crypto/qat: add raw crypto data-path API support Fan Zhang
2020-10-09 21:11           ` [dpdk-dev] [dpdk-dev v11 4/4] test/crypto: add unit-test for cryptodev raw API test Fan Zhang
2020-10-10 19:55             ` Akhil Goyal
2020-10-10 20:50               ` Zhang, Roy Fan
2020-10-10 21:03                 ` Akhil Goyal
2020-10-11  0:32           ` [dpdk-dev] [dpdk-dev v12 0/4] cryptodev: add raw data-path APIs Fan Zhang
2020-10-11  0:32             ` [dpdk-dev] [dpdk-dev v12 1/4] cryptodev: change crypto symmetric vector structure Fan Zhang
2020-10-11  0:32             ` [dpdk-dev] [dpdk-dev v12 2/4] cryptodev: add raw crypto data-path APIs Fan Zhang
2020-10-11  0:32             ` [dpdk-dev] [dpdk-dev v12 3/4] crypto/qat: add raw crypto data-path API support Fan Zhang
2020-10-11  0:32             ` [dpdk-dev] [dpdk-dev v12 4/4] test/crypto: add unit-test for cryptodev raw API test Fan Zhang
2020-10-11  0:38             ` [dpdk-dev] [dpdk-dev v13 0/4] cryptodev: add raw data-path APIs Fan Zhang
2020-10-11  0:38               ` [dpdk-dev] [dpdk-dev v13 1/4] cryptodev: change crypto symmetric vector structure Fan Zhang
2020-10-11  0:38               ` [dpdk-dev] [dpdk-dev v13 2/4] cryptodev: add raw crypto data-path APIs Fan Zhang
2020-10-11  0:38               ` [dpdk-dev] [dpdk-dev v13 3/4] crypto/qat: add raw crypto data-path API support Fan Zhang
2020-10-11  0:38               ` [dpdk-dev] [dpdk-dev v13 4/4] test/crypto: add unit-test for cryptodev raw API test Fan Zhang
2020-10-12 16:15               ` [dpdk-dev] [dpdk-dev v13 0/4] cryptodev: add raw data-path APIs Akhil Goyal

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=VI1PR04MB316801FAA21F8EF1169C90A0E60B0@VI1PR04MB3168.eurprd04.prod.outlook.com \
    --to=akhil.goyal@nxp.com \
    --cc=adamx.dybkowski@intel.com \
    --cc=anoobj@marvell.com \
    --cc=arkadiuszx.kusztal@intel.com \
    --cc=dev@dpdk.org \
    --cc=fiona.trahe@intel.com \
    --cc=konstantin.ananyev@intel.com \
    --cc=roy.fan.zhang@intel.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

DPDK patches and discussions

This inbox may be cloned and mirrored by anyone:

	git clone --mirror https://inbox.dpdk.org/dev/0 dev/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 dev dev/ https://inbox.dpdk.org/dev \
		dev@dpdk.org
	public-inbox-index dev

Example config snippet for mirrors.
Newsgroup available over NNTP:
	nntp://inbox.dpdk.org/inbox.dpdk.dev


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git