app/testpmd: enable DDP remove profile feature

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

diff --git a/test/test/test_cryptodev.c b/test/test/test_cryptodev.c
index ca7d6df..8766cad 100644 (file)
--- a/test/test/test_cryptodev.c
+++ b/test/test/test_cryptodev.c
@@ -35,6 +35,7 @@
 #include <rte_mbuf.h>
 #include <rte_malloc.h>
 #include <rte_memcpy.h>
+#include <rte_pause.h>
 
 #include <rte_crypto.h>
 #include <rte_cryptodev.h>
@@ -219,7 +220,7 @@ testsuite_setup(void)
                nb_devs = rte_cryptodev_count_devtype(
                                RTE_CRYPTODEV_AESNI_MB_PMD);
                if (nb_devs < 1) {
-                       ret = rte_eal_vdev_init(
+                       ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
 
                        TEST_ASSERT(ret == 0,
@@ -239,7 +240,7 @@ testsuite_setup(void)
                nb_devs = rte_cryptodev_count_devtype(
                                RTE_CRYPTODEV_AESNI_GCM_PMD);
                if (nb_devs < 1) {
-                       TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
+                       TEST_ASSERT_SUCCESS(rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
                                "Failed to create instance of"
                                " pmd : %s",
@@ -256,7 +257,7 @@ testsuite_setup(void)
 #endif
                nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD);
                if (nb_devs < 1) {
-                       TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
+                       TEST_ASSERT_SUCCESS(rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
                                "Failed to create instance of"
                                " pmd : %s",
@@ -273,7 +274,7 @@ testsuite_setup(void)
 #endif
                nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_KASUMI_PMD);
                if (nb_devs < 1) {
-                       TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
+                       TEST_ASSERT_SUCCESS(rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
                                "Failed to create instance of"
                                " pmd : %s",
@@ -290,7 +291,7 @@ testsuite_setup(void)
 #endif
                nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_ZUC_PMD);
                if (nb_devs < 1) {
-                       TEST_ASSERT_SUCCESS(rte_eal_vdev_init(
+                       TEST_ASSERT_SUCCESS(rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
                                "Failed to create instance of"
                                " pmd : %s",
@@ -308,7 +309,7 @@ testsuite_setup(void)
                nb_devs = rte_cryptodev_count_devtype(
                                RTE_CRYPTODEV_NULL_PMD);
                if (nb_devs < 1) {
-                       ret = rte_eal_vdev_init(
+                       ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
 
                        TEST_ASSERT(ret == 0,
@@ -328,7 +329,7 @@ testsuite_setup(void)
                nb_devs = rte_cryptodev_count_devtype(
                                RTE_CRYPTODEV_OPENSSL_PMD);
                if (nb_devs < 1) {
-                       ret = rte_eal_vdev_init(
+                       ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
                                NULL);
 
@@ -348,7 +349,7 @@ testsuite_setup(void)
                nb_devs = rte_cryptodev_count_devtype(
                                RTE_CRYPTODEV_ARMV8_PMD);
                if (nb_devs < 1) {
-                       ret = rte_eal_vdev_init(
+                       ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
                                NULL);
 
@@ -369,7 +370,7 @@ testsuite_setup(void)
                nb_devs = rte_cryptodev_count_devtype(
                                RTE_CRYPTODEV_SCHEDULER_PMD);
                if (nb_devs < 1) {
-                       ret = rte_eal_vdev_init(
+                       ret = rte_vdev_init(
                                RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
                                NULL);
 
@@ -1710,6 +1711,38 @@ test_AES_cipheronly_qat_all(void)
        return TEST_SUCCESS;
 }
 
+static int
+test_AES_chain_dpaa2_sec_all(void)
+{
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
+       int status;
+
+       status = test_blockcipher_all_tests(ts_params->mbuf_pool,
+               ts_params->op_mpool, ts_params->valid_devs[0],
+               RTE_CRYPTODEV_DPAA2_SEC_PMD,
+               BLKCIPHER_AES_CHAIN_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
+static int
+test_AES_cipheronly_dpaa2_sec_all(void)
+{
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
+       int status;
+
+       status = test_blockcipher_all_tests(ts_params->mbuf_pool,
+               ts_params->op_mpool, ts_params->valid_devs[0],
+               RTE_CRYPTODEV_DPAA2_SEC_PMD,
+               BLKCIPHER_AES_CIPHERONLY_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
 static int
 test_authonly_openssl_all(void)
 {
@@ -2148,10 +2181,9 @@ create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
        const uint8_t *iv = tdata->iv.data;
        const uint8_t iv_len = tdata->iv.len;
        const unsigned int cipher_len = tdata->validCipherLenInBits.len;
-       const unsigned int cipher_offset =
-               tdata->validCipherOffsetLenInBits.len;
+       const unsigned int cipher_offset = tdata->iv.len << 3;
        const unsigned int auth_len = tdata->validAuthLenInBits.len;
-       const unsigned int auth_offset = tdata->validAuthOffsetLenInBits.len;
+       const unsigned int auth_offset = tdata->aad.len << 3;
 
        unsigned int iv_pad_len = 0;
        unsigned int aad_buffer_len;
@@ -2474,7 +2506,7 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
                        plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
                        RTE_CRYPTO_AUTH_SNOW3G_UIA2,
                        tdata->validAuthLenInBits.len,
-                       tdata->validAuthOffsetLenInBits.len);
+                       (tdata->aad.len << 3));
        if (retval < 0)
                return retval;
 
@@ -2536,7 +2568,7 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
                        RTE_CRYPTO_AUTH_OP_VERIFY,
                        RTE_CRYPTO_AUTH_SNOW3G_UIA2,
                        tdata->validAuthLenInBits.len,
-                       tdata->validAuthOffsetLenInBits.len);
+                       (tdata->aad.len << 3));
        if (retval < 0)
                return retval;
 
@@ -2596,7 +2628,7 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
                        plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
                        RTE_CRYPTO_AUTH_KASUMI_F9,
                        tdata->validAuthLenInBits.len,
-                       tdata->validAuthOffsetLenInBits.len);
+                       (tdata->aad.len << 3));
        if (retval < 0)
                return retval;
 
@@ -2658,7 +2690,7 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
                        RTE_CRYPTO_AUTH_OP_VERIFY,
                        RTE_CRYPTO_AUTH_KASUMI_F9,
                        tdata->validAuthLenInBits.len,
-                       tdata->validAuthOffsetLenInBits.len);
+                       (tdata->aad.len << 3));
        if (retval < 0)
                return retval;
 
@@ -2855,7 +2887,7 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
        /* Create KASUMI operation */
        retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
                                        tdata->plaintext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
+                                       (tdata->iv.len << 3),
                                        RTE_CRYPTO_CIPHER_KASUMI_F8);
        if (retval < 0)
                return retval;
@@ -2929,7 +2961,7 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_operation(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->plaintext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
+                                       (tdata->iv.len << 3),
                                        RTE_CRYPTO_CIPHER_KASUMI_F8);
        if (retval < 0)
                return retval;
@@ -3000,7 +3032,7 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->plaintext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
+                                       (tdata->iv.len << 3),
                                        RTE_CRYPTO_CIPHER_KASUMI_F8);
        if (retval < 0)
                return retval;
@@ -3075,7 +3107,7 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->plaintext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
+                                       (tdata->iv.len << 3),
                                        RTE_CRYPTO_CIPHER_KASUMI_F8);
        if (retval < 0)
                return retval;
@@ -3143,7 +3175,7 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->ciphertext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
+                                       (tdata->iv.len << 3),
                                        RTE_CRYPTO_CIPHER_KASUMI_F8);
        if (retval < 0)
                return retval;
@@ -3209,7 +3241,7 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
        retval = create_wireless_algo_cipher_operation(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->ciphertext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
+                                       (tdata->iv.len << 3),
                                        RTE_CRYPTO_CIPHER_KASUMI_F8);
        if (retval < 0)
                return retval;
@@ -3274,7 +3306,7 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata)
        /* Create SNOW 3G operation */
        retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
                                        tdata->validCipherLenInBits.len,
-                                       tdata->validCipherOffsetLenInBits.len,
+                                       (tdata->iv.len << 3),
                                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
        if (retval < 0)
                return retval;
@@ -3348,7 +3380,7 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->validCipherLenInBits.len,
-                                       tdata->validCipherOffsetLenInBits.len,
+                                       (tdata->iv.len << 3),
                                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
        if (retval < 0)
                return retval;
@@ -3425,7 +3457,7 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->validCipherLenInBits.len,
-                                       tdata->validCipherOffsetLenInBits.len,
+                                       (tdata->iv.len << 3),
                                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
        if (retval < 0)
                return retval;
@@ -3528,7 +3560,7 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->validCipherLenInBits.len,
-                                       tdata->validCipherOffsetLenInBits.len +
+                                       (tdata->iv.len << 3) +
                                        extra_offset,
                                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
        if (retval < 0)
@@ -3549,8 +3581,7 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
        rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
 #endif
 
-       expected_ciphertext_shifted = rte_malloc(NULL,
-                       ceil_byte_length(plaintext_len + extra_offset), 0);
+       expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
 
        TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
                        "failed to reserve memory for ciphertext shifted\n");
@@ -3607,7 +3638,7 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
        /* Create SNOW 3G operation */
        retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
                                        tdata->validCipherLenInBits.len,
-                                       tdata->validCipherOffsetLenInBits.len,
+                                       (tdata->iv.len << 3),
                                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
        if (retval < 0)
                return retval;
@@ -3681,7 +3712,7 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
        retval = create_wireless_algo_cipher_operation_oop(tdata->iv.data,
                                        tdata->iv.len,
                                        tdata->validCipherLenInBits.len,
-                                       tdata->validCipherOffsetLenInBits.len,
+                                       (tdata->iv.len << 3),
                                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2);
        if (retval < 0)
                return retval;
@@ -3840,9 +3871,9 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
                        RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
                        tdata->iv.data, tdata->iv.len,
                        tdata->validCipherLenInBits.len,
-                       tdata->validCipherOffsetLenInBits.len,
+                       (tdata->iv.len << 3),
                        tdata->validAuthLenInBits.len,
-                       tdata->validAuthOffsetLenInBits.len
+                       (tdata->aad.len << 3)
                        );
        if (retval < 0)
                return retval;
@@ -3922,9 +3953,9 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata)
                tdata->aad.data, tdata->aad.len,
                plaintext_pad_len,
                tdata->validCipherLenInBits.len,
-               tdata->validCipherOffsetLenInBits.len,
+               (tdata->iv.len << 3),
                tdata->validAuthLenInBits.len,
-               tdata->validAuthOffsetLenInBits.len,
+               (tdata->aad.len << 3),
                RTE_CRYPTO_AUTH_SNOW3G_UIA2,
                RTE_CRYPTO_CIPHER_SNOW3G_UEA2
        );
@@ -4007,9 +4038,9 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata)
                                tdata->aad.data, tdata->aad.len,
                                plaintext_pad_len,
                                tdata->validCipherLenInBits.len,
-                               tdata->validCipherOffsetLenInBits.len,
+                               (tdata->iv.len << 3),
                                tdata->validAuthLenInBits.len,
-                               tdata->validAuthOffsetLenInBits.len,
+                               (tdata->aad.len << 3),
                                RTE_CRYPTO_AUTH_KASUMI_F9,
                                RTE_CRYPTO_CIPHER_KASUMI_F8
                                );
@@ -4094,9 +4125,9 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
                                RTE_CRYPTO_CIPHER_KASUMI_F8,
                                tdata->iv.data, tdata->iv.len,
                                tdata->validCipherLenInBits.len,
-                               tdata->validCipherOffsetLenInBits.len,
+                               (tdata->iv.len << 3),
                                tdata->validAuthLenInBits.len,
-                               tdata->validAuthOffsetLenInBits.len
+                               (tdata->aad.len << 3)
                                );
        if (retval < 0)
                return retval;
@@ -4178,7 +4209,7 @@ test_zuc_encryption(const struct wireless_test_data *tdata)
        /* Create ZUC operation */
        retval = create_wireless_algo_cipher_operation(tdata->iv.data, tdata->iv.len,
                                        tdata->plaintext.len,
-                                       tdata->validCipherOffsetLenInBits.len,
+                                       (tdata->iv.len << 3),
                                        RTE_CRYPTO_CIPHER_ZUC_EEA3);
        if (retval < 0)
                return retval;
@@ -4263,7 +4294,7 @@ test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
        /* Create ZUC operation */
        retval = create_wireless_algo_cipher_operation(tdata->iv.data,
                        tdata->iv.len, tdata->plaintext.len,
-                       tdata->validCipherOffsetLenInBits.len,
+                       (tdata->iv.len << 3),
                        RTE_CRYPTO_CIPHER_ZUC_EEA3);
        if (retval < 0)
                return retval;
@@ -4343,7 +4374,7 @@ test_zuc_authentication(const struct wireless_test_data *tdata)
                        plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
                        RTE_CRYPTO_AUTH_ZUC_EIA3,
                        tdata->validAuthLenInBits.len,
-                       tdata->validAuthOffsetLenInBits.len);
+                       (tdata->aad.len << 3));
        if (retval < 0)
                return retval;
 
@@ -4699,6 +4730,38 @@ test_DES_docsis_openssl_all(void)
        return TEST_SUCCESS;
 }
 
+static int
+test_3DES_chain_dpaa2_sec_all(void)
+{
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
+       int status;
+
+       status = test_blockcipher_all_tests(ts_params->mbuf_pool,
+               ts_params->op_mpool, ts_params->valid_devs[0],
+               RTE_CRYPTODEV_DPAA2_SEC_PMD,
+               BLKCIPHER_3DES_CHAIN_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
+static int
+test_3DES_cipheronly_dpaa2_sec_all(void)
+{
+       struct crypto_testsuite_params *ts_params = &testsuite_params;
+       int status;
+
+       status = test_blockcipher_all_tests(ts_params->mbuf_pool,
+               ts_params->op_mpool, ts_params->valid_devs[0],
+               RTE_CRYPTODEV_DPAA2_SEC_PMD,
+               BLKCIPHER_3DES_CIPHERONLY_TYPE);
+
+       TEST_ASSERT_EQUAL(status, 0, "Test failed");
+
+       return TEST_SUCCESS;
+}
+
 static int
 test_3DES_cipheronly_qat_all(void)
 {
@@ -7751,14 +7814,17 @@ test_scheduler_attach_slave_op(void)
        uint8_t sched_id = ts_params->valid_devs[0];
        uint32_t nb_devs, i, nb_devs_attached = 0;
        int ret;
+       char vdev_name[32];
 
        /* create 2 AESNI_MB if necessary */
        nb_devs = rte_cryptodev_count_devtype(
                        RTE_CRYPTODEV_AESNI_MB_PMD);
        if (nb_devs < 2) {
                for (i = nb_devs; i < 2; i++) {
-                       ret = rte_eal_vdev_init(
-                               RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
+                       snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
+                                       RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
+                                       i);
+                       ret = rte_vdev_init(vdev_name, NULL);
 
                        TEST_ASSERT(ret == 0,
                                "Failed to create instance %u of"
@@ -8465,6 +8531,39 @@ static struct unit_test_suite cryptodev_sw_zuc_testsuite  = {
        }
 };
 
+static struct unit_test_suite cryptodev_dpaa2_sec_testsuite  = {
+       .suite_name = "Crypto DPAA2_SEC Unit Test Suite",
+       .setup = testsuite_setup,
+       .teardown = testsuite_teardown,
+       .unit_test_cases = {
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_device_configure_invalid_dev_id),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_multi_session),
+
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_AES_chain_dpaa2_sec_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_3DES_chain_dpaa2_sec_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_AES_cipheronly_dpaa2_sec_all),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_3DES_cipheronly_dpaa2_sec_all),
+
+               /** HMAC_MD5 Authentication */
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_MD5_HMAC_generate_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_MD5_HMAC_verify_case_1),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_MD5_HMAC_generate_case_2),
+               TEST_CASE_ST(ut_setup, ut_teardown,
+                            test_MD5_HMAC_verify_case_2),
+
+               TEST_CASES_END() /**< NULL terminate unit test array */
+       }
+};
+
 static struct unit_test_suite cryptodev_null_testsuite  = {
        .suite_name = "Crypto Device NULL Unit Test Suite",
        .setup = testsuite_setup,
@@ -8588,6 +8687,13 @@ REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
 
 #endif
 
+static int
+test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
+{
+       gbl_cryptodev_type = RTE_CRYPTODEV_DPAA2_SEC_PMD;
+       return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
+}
+
 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
@@ -8597,3 +8703,4 @@ REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
+REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);