git.droids-corp.org / dpdk.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
drivers/crypto: invoke probing finish function
[dpdk.git] / drivers / crypto / dpaa_sec / dpaa_sec.c
diff --git a/drivers/crypto/dpaa_sec/dpaa_sec.c b/drivers/crypto/dpaa_sec/dpaa_sec.c
index d1c0ea9..454b9c4 100644 (file)
--- a/drivers/crypto/dpaa_sec/dpaa_sec.c
+++ b/drivers/crypto/dpaa_sec/dpaa_sec.c
@@ -1,7 +1,7 @@
 /* SPDX-License-Identifier: BSD-3-Clause
  *
  *   Copyright (c) 2016 Freescale Semiconductor, Inc. All rights reserved.
- *   Copyright 2017-2019 NXP
+ *   Copyright 2017-2021 NXP
  *
  */
 
@@ -45,10 +45,7 @@
 #include <dpaa_sec_log.h>
 #include <dpaax_iova_table.h>
 
-static uint8_t cryptodev_driver_id;
-
-static int
-dpaa_sec_attach_sess_q(struct dpaa_sec_qp *qp, dpaa_sec_session *sess);
+uint8_t dpaa_cryptodev_driver_id;
 
 static inline void
 dpaa_sec_op_ending(struct dpaa_sec_op_ctx *ctx)
@@ -263,14 +260,31 @@ dpaa_sec_prep_pdcp_cdb(dpaa_sec_session *ses)
                p_authdata = &authdata;
        }
 
-       if (rta_inline_pdcp_query(authdata.algtype,
-                               cipherdata.algtype,
-                               ses->pdcp.sn_size,
-                               ses->pdcp.hfn_ovd)) {
-               cipherdata.key =
-                       (size_t)rte_dpaa_mem_vtop((void *)
-                                       (size_t)cipherdata.key);
-               cipherdata.key_type = RTA_DATA_PTR;
+       if (ses->pdcp.sdap_enabled) {
+               int nb_keys_to_inline =
+                               rta_inline_pdcp_sdap_query(authdata.algtype,
+                                       cipherdata.algtype,
+                                       ses->pdcp.sn_size,
+                                       ses->pdcp.hfn_ovd);
+               if (nb_keys_to_inline >= 1) {
+                       cipherdata.key = (size_t)rte_dpaa_mem_vtop((void *)
+                                               (size_t)cipherdata.key);
+                       cipherdata.key_type = RTA_DATA_PTR;
+               }
+               if (nb_keys_to_inline >= 2) {
+                       authdata.key = (size_t)rte_dpaa_mem_vtop((void *)
+                                               (size_t)authdata.key);
+                       authdata.key_type = RTA_DATA_PTR;
+               }
+       } else {
+               if (rta_inline_pdcp_query(authdata.algtype,
+                                       cipherdata.algtype,
+                                       ses->pdcp.sn_size,
+                                       ses->pdcp.hfn_ovd)) {
+                       cipherdata.key = (size_t)rte_dpaa_mem_vtop((void *)
+                                               (size_t)cipherdata.key);
+                       cipherdata.key_type = RTA_DATA_PTR;
+               }
        }
 
        if (ses->pdcp.domain == RTE_SECURITY_PDCP_MODE_CONTROL) {
@@ -294,6 +308,9 @@ dpaa_sec_prep_pdcp_cdb(dpaa_sec_session *ses)
                                        ses->pdcp.hfn_threshold,
                                        &cipherdata, &authdata,
                                        0);
+       } else if (ses->pdcp.domain == RTE_SECURITY_PDCP_MODE_SHORT_MAC) {
+               shared_desc_len = cnstr_shdsc_pdcp_short_mac(cdb->sh_desc,
+                                                    1, swap, &authdata);
        } else {
                if (ses->dir == DIR_ENC) {
                        if (ses->pdcp.sdap_enabled)
@@ -527,6 +544,15 @@ dpaa_sec_prep_cdb(dpaa_sec_session *ses)
                                                !ses->dir,
                                                ses->digest_length);
                        break;
+               case RTE_CRYPTO_AUTH_AES_XCBC_MAC:
+               case RTE_CRYPTO_AUTH_AES_CMAC:
+                       shared_desc_len = cnstr_shdsc_aes_mac(
+                                               cdb->sh_desc,
+                                               true, swap, SHR_NEVER,
+                                               &alginfo_a,
+                                               !ses->dir,
+                                               ses->digest_length);
+                       break;
                default:
                        DPAA_SEC_ERR("unsupported auth alg %u", ses->auth_alg);
                }
@@ -1758,8 +1784,8 @@ dpaa_sec_enqueue_burst(void *qp, struct rte_crypto_op **ops,
                        case RTE_CRYPTO_OP_WITH_SESSION:
                                ses = (dpaa_sec_session *)
                                        get_sym_session_private_data(
-                                                       op->sym->session,
-                                                       cryptodev_driver_id);
+                                               op->sym->session,
+                                               dpaa_cryptodev_driver_id);
                                break;
 #ifdef RTE_LIB_SECURITY
                        case RTE_CRYPTO_OP_SECURITY_SESSION:
@@ -2168,6 +2194,14 @@ dpaa_sec_auth_init(struct rte_cryptodev *dev __rte_unused,
                session->auth_key.alg = OP_ALG_ALGSEL_ZUCA;
                session->auth_key.algmode = OP_ALG_AAI_F9;
                break;
+       case RTE_CRYPTO_AUTH_AES_XCBC_MAC:
+               session->auth_key.alg = OP_ALG_ALGSEL_AES;
+               session->auth_key.algmode = OP_ALG_AAI_XCBC_MAC;
+               break;
+       case RTE_CRYPTO_AUTH_AES_CMAC:
+               session->auth_key.alg = OP_ALG_ALGSEL_AES;
+               session->auth_key.algmode = OP_ALG_AAI_CMAC;
+               break;
        default:
                DPAA_SEC_ERR("Crypto: Unsupported Auth specified %u",
                              xform->auth.algo);
@@ -2249,6 +2283,14 @@ dpaa_sec_chain_init(struct rte_cryptodev *dev __rte_unused,
                session->auth_key.alg = OP_ALG_ALGSEL_SHA512;
                session->auth_key.algmode = OP_ALG_AAI_HMAC;
                break;
+       case RTE_CRYPTO_AUTH_AES_XCBC_MAC:
+               session->auth_key.alg = OP_ALG_ALGSEL_AES;
+               session->auth_key.algmode = OP_ALG_AAI_XCBC_MAC;
+               break;
+       case RTE_CRYPTO_AUTH_AES_CMAC:
+               session->auth_key.alg = OP_ALG_ALGSEL_AES;
+               session->auth_key.algmode = OP_ALG_AAI_CMAC;
+               break;
        default:
                DPAA_SEC_ERR("Crypto: Unsupported Auth specified %u",
                              auth_xform->algo);
@@ -2355,7 +2397,7 @@ dpaa_sec_detach_rxq(struct dpaa_sec_dev_private *qi, struct qman_fq *fq)
        return -1;
 }
 
-static int
+int
 dpaa_sec_attach_sess_q(struct dpaa_sec_qp *qp, dpaa_sec_session *sess)
 {
        int ret;
@@ -2684,12 +2726,16 @@ dpaa_sec_ipsec_proto_init(struct rte_crypto_cipher_xform *cipher_xform,
                break;
        case RTE_CRYPTO_AUTH_AES_CMAC:
                session->auth_key.alg = OP_PCL_IPSEC_AES_CMAC_96;
+               session->auth_key.algmode = OP_ALG_AAI_CMAC;
                break;
        case RTE_CRYPTO_AUTH_NULL:
                session->auth_key.alg = OP_PCL_IPSEC_HMAC_NULL;
                break;
-       case RTE_CRYPTO_AUTH_SHA224_HMAC:
        case RTE_CRYPTO_AUTH_AES_XCBC_MAC:
+               session->auth_key.alg = OP_PCL_IPSEC_AES_XCBC_MAC_96;
+               session->auth_key.algmode = OP_ALG_AAI_XCBC_MAC;
+               break;
+       case RTE_CRYPTO_AUTH_SHA224_HMAC:
        case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
        case RTE_CRYPTO_AUTH_SHA1:
        case RTE_CRYPTO_AUTH_SHA256:
@@ -3167,7 +3213,7 @@ dpaa_sec_dev_infos_get(struct rte_cryptodev *dev,
                info->feature_flags = dev->feature_flags;
                info->capabilities = dpaa_sec_capabilities;
                info->sym.max_nb_sessions = internals->max_nb_sessions;
-               info->driver_id = cryptodev_driver_id;
+               info->driver_id = dpaa_cryptodev_driver_id;
        }
 }
 
@@ -3363,7 +3409,10 @@ static struct rte_cryptodev_ops crypto_ops = {
        .queue_pair_release   = dpaa_sec_queue_pair_release,
        .sym_session_get_size     = dpaa_sec_sym_session_get_size,
        .sym_session_configure    = dpaa_sec_sym_session_configure,
-       .sym_session_clear        = dpaa_sec_sym_session_clear
+       .sym_session_clear        = dpaa_sec_sym_session_clear,
+       /* Raw data-path API related operations */
+       .sym_get_raw_dp_ctx_size = dpaa_sec_get_dp_ctx_size,
+       .sym_configure_raw_dp_ctx = dpaa_sec_configure_raw_dp_ctx,
 };
 
 #ifdef RTE_LIB_SECURITY
@@ -3414,7 +3463,7 @@ dpaa_sec_dev_init(struct rte_cryptodev *cryptodev)
 
        PMD_INIT_FUNC_TRACE();
 
-       cryptodev->driver_id = cryptodev_driver_id;
+       cryptodev->driver_id = dpaa_cryptodev_driver_id;
        cryptodev->dev_ops = &crypto_ops;
 
        cryptodev->enqueue_burst = dpaa_sec_enqueue_burst;
@@ -3423,6 +3472,7 @@ dpaa_sec_dev_init(struct rte_cryptodev *cryptodev)
                        RTE_CRYPTODEV_FF_HW_ACCELERATED |
                        RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING |
                        RTE_CRYPTODEV_FF_SECURITY |
+                       RTE_CRYPTODEV_FF_SYM_RAW_DP |
                        RTE_CRYPTODEV_FF_IN_PLACE_SGL |
                        RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT |
                        RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT |
@@ -3544,8 +3594,10 @@ cryptodev_dpaa_sec_probe(struct rte_dpaa_driver *dpaa_drv __rte_unused,
 
        /* Invoke PMD device initialization function */
        retval = dpaa_sec_dev_init(cryptodev);
-       if (retval == 0)
+       if (retval == 0) {
+               rte_cryptodev_pmd_probing_finish(cryptodev);
                return 0;
+       }
 
        retval = -ENXIO;
 out:
@@ -3588,5 +3640,5 @@ static struct cryptodev_driver dpaa_sec_crypto_drv;
 
 RTE_PMD_REGISTER_DPAA(CRYPTODEV_NAME_DPAA_SEC_PMD, rte_dpaa_sec_driver);
 RTE_PMD_REGISTER_CRYPTO_DRIVER(dpaa_sec_crypto_drv, rte_dpaa_sec_driver.driver,
-               cryptodev_driver_id);
+               dpaa_cryptodev_driver_id);
 RTE_LOG_REGISTER(dpaa_logtype_sec, pmd.crypto.dpaa, NOTICE);
DPDK repo used for reviews