crypto/qat: fix session initialization

[dpdk.git] / drivers / crypto / qat / qat_crypto.c

diff --git a/drivers/crypto/qat/qat_crypto.c b/drivers/crypto/qat/qat_crypto.c
index f94a1b0..d92de35 100644 (file)
--- a/drivers/crypto/qat/qat_crypto.c
+++ b/drivers/crypto/qat/qat_crypto.c
@@ -214,7 +214,7 @@ adf_modulo(uint32_t data, uint32_t shift);
 
 static inline int
 qat_write_hw_desc_entry(struct rte_crypto_op *op, uint8_t *out_msg,
-               struct qat_crypto_op_cookie *qat_op_cookie);
+               struct qat_crypto_op_cookie *qat_op_cookie, struct qat_qp *qp);
 
 void
 qat_crypto_sym_clear_session(struct rte_cryptodev *dev,
@@ -295,11 +295,12 @@ qat_get_cipher_xform(struct rte_crypto_sym_xform *xform)
 
        return NULL;
 }
-void *
+
+int
 qat_crypto_sym_configure_session_cipher(struct rte_cryptodev *dev,
-               struct rte_crypto_sym_xform *xform, void *session_private)
+               struct rte_crypto_sym_xform *xform,
+               struct qat_session *session)
 {
-       struct qat_session *session = session_private;
        struct qat_pmd_private *internals = dev->data->dev_private;
        struct rte_crypto_cipher_xform *cipher_xform = NULL;
 
@@ -440,14 +441,14 @@ qat_crypto_sym_configure_session_cipher(struct rte_cryptodev *dev,
                                                cipher_xform->key.length))
                goto error_out;
 
-       return session;
+       return 0;
 
 error_out:
        if (session->bpi_ctx) {
                bpi_cipher_ctx_free(session->bpi_ctx);
                session->bpi_ctx = NULL;
        }
-       return NULL;
+       return -1;
 }
 
 int
@@ -492,40 +493,50 @@ qat_crypto_set_session_parameters(struct rte_cryptodev *dev,
        session->cd_paddr = rte_mempool_virt2phy(NULL, session) +
                        offsetof(struct qat_session, cd);
 
+       session->min_qat_dev_gen = QAT_GEN1;
+
        /* Get requested QAT command id */
        qat_cmd_id = qat_get_cmd_id(xform);
        if (qat_cmd_id < 0 || qat_cmd_id >= ICP_QAT_FW_LA_CMD_DELIMITER) {
                PMD_DRV_LOG(ERR, "Unsupported xform chain requested");
-               goto error_out;
+               return -1;
        }
        session->qat_cmd = (enum icp_qat_fw_la_cmd_id)qat_cmd_id;
        switch (session->qat_cmd) {
        case ICP_QAT_FW_LA_CMD_CIPHER:
-       session = qat_crypto_sym_configure_session_cipher(dev, xform, session);
+               if (qat_crypto_sym_configure_session_cipher(dev, xform, session) < 0)
+                       return -1;
                break;
        case ICP_QAT_FW_LA_CMD_AUTH:
-       session = qat_crypto_sym_configure_session_auth(dev, xform, session);
+               if (qat_crypto_sym_configure_session_auth(dev, xform, session) < 0)
+                       return -1;
                break;
        case ICP_QAT_FW_LA_CMD_CIPHER_HASH:
-               if (xform->type == RTE_CRYPTO_SYM_XFORM_AEAD)
-                       session = qat_crypto_sym_configure_session_aead(xform,
-                                       session);
-               else {
-                       session = qat_crypto_sym_configure_session_cipher(dev,
-                                       xform, session);
-                       session = qat_crypto_sym_configure_session_auth(dev,
-                                       xform, session);
+               if (xform->type == RTE_CRYPTO_SYM_XFORM_AEAD) {
+                       if (qat_crypto_sym_configure_session_aead(xform,
+                                       session) < 0)
+                               return -1;
+               } else {
+                       if (qat_crypto_sym_configure_session_cipher(dev,
+                                       xform, session) < 0)
+                               return -1;
+                       if (qat_crypto_sym_configure_session_auth(dev,
+                                       xform, session) < 0)
+                               return -1;
                }
                break;
        case ICP_QAT_FW_LA_CMD_HASH_CIPHER:
-               if (xform->type == RTE_CRYPTO_SYM_XFORM_AEAD)
-                       session = qat_crypto_sym_configure_session_aead(xform,
-                                       session);
-               else {
-                       session = qat_crypto_sym_configure_session_auth(dev,
-                                       xform, session);
-                       session = qat_crypto_sym_configure_session_cipher(dev,
-                                       xform, session);
+               if (xform->type == RTE_CRYPTO_SYM_XFORM_AEAD) {
+                       if (qat_crypto_sym_configure_session_aead(xform,
+                                       session) < 0)
+                               return -1;
+               } else {
+                       if (qat_crypto_sym_configure_session_auth(dev,
+                                       xform, session) < 0)
+                               return -1;
+                       if (qat_crypto_sym_configure_session_cipher(dev,
+                                       xform, session) < 0)
+                               return -1;
                }
                break;
        case ICP_QAT_FW_LA_CMD_TRNG_GET_RANDOM:
@@ -539,26 +550,21 @@ qat_crypto_set_session_parameters(struct rte_cryptodev *dev,
        case ICP_QAT_FW_LA_CMD_DELIMITER:
        PMD_DRV_LOG(ERR, "Unsupported Service %u",
                session->qat_cmd);
-               goto error_out;
+               return -1;
        default:
        PMD_DRV_LOG(ERR, "Unsupported Service %u",
                session->qat_cmd);
-               goto error_out;
+               return -1;
        }
 
        return 0;
-
-error_out:
-       return -1;
 }
 
-struct qat_session *
+int
 qat_crypto_sym_configure_session_auth(struct rte_cryptodev *dev,
                                struct rte_crypto_sym_xform *xform,
-                               struct qat_session *session_private)
+                               struct qat_session *session)
 {
-
-       struct qat_session *session = session_private;
        struct rte_crypto_auth_xform *auth_xform = NULL;
        struct qat_pmd_private *internals = dev->data->dev_private;
        auth_xform = qat_get_auth_xform(xform);
@@ -688,17 +694,16 @@ qat_crypto_sym_configure_session_auth(struct rte_cryptodev *dev,
        }
 
        session->digest_length = auth_xform->digest_length;
-       return session;
+       return 0;
 
 error_out:
-       return NULL;
+       return -1;
 }
 
-struct qat_session *
+int
 qat_crypto_sym_configure_session_aead(struct rte_crypto_sym_xform *xform,
-                               struct qat_session *session_private)
+                               struct qat_session *session)
 {
-       struct qat_session *session = session_private;
        struct rte_crypto_aead_xform *aead_xform = &xform->aead;
 
        /*
@@ -742,7 +747,7 @@ qat_crypto_sym_configure_session_aead(struct rte_crypto_sym_xform *xform,
                if (qat_alg_aead_session_create_content_desc_auth(session,
                                        aead_xform->key.data,
                                        aead_xform->key.length,
-                                       aead_xform->add_auth_data_length,
+                                       aead_xform->aad_length,
                                        aead_xform->digest_length,
                                        RTE_CRYPTO_AUTH_OP_GENERATE))
                        goto error_out;
@@ -755,7 +760,7 @@ qat_crypto_sym_configure_session_aead(struct rte_crypto_sym_xform *xform,
                if (qat_alg_aead_session_create_content_desc_auth(session,
                                        aead_xform->key.data,
                                        aead_xform->key.length,
-                                       aead_xform->add_auth_data_length,
+                                       aead_xform->aad_length,
                                        aead_xform->digest_length,
                                        RTE_CRYPTO_AUTH_OP_VERIFY))
                        goto error_out;
@@ -767,10 +772,10 @@ qat_crypto_sym_configure_session_aead(struct rte_crypto_sym_xform *xform,
        }
 
        session->digest_length = aead_xform->digest_length;
-       return session;
+       return 0;
 
 error_out:
-       return NULL;
+       return -1;
 }
 
 unsigned qat_crypto_sym_get_session_private_size(
@@ -924,7 +929,7 @@ qat_pmd_enqueue_op_burst(void *qp, struct rte_crypto_op **ops,
 
        while (nb_ops_sent != nb_ops_possible) {
                ret = qat_write_hw_desc_entry(*cur_op, base_addr + tail,
-                               tmp_qp->op_cookies[tail / queue->msg_size]);
+                       tmp_qp->op_cookies[tail / queue->msg_size], tmp_qp);
                if (ret != 0) {
                        tmp_qp->stats.enqueue_err_count++;
                        /*
@@ -1081,7 +1086,7 @@ set_cipher_iv(uint16_t iv_length, uint16_t iv_offset,
 
 static inline int
 qat_write_hw_desc_entry(struct rte_crypto_op *op, uint8_t *out_msg,
-               struct qat_crypto_op_cookie *qat_op_cookie)
+               struct qat_crypto_op_cookie *qat_op_cookie, struct qat_qp *qp)
 {
        int ret = 0;
        struct qat_session *ctx;
@@ -1117,6 +1122,12 @@ qat_write_hw_desc_entry(struct rte_crypto_op *op, uint8_t *out_msg,
                return -EINVAL;
        }
 
+       if (unlikely(ctx->min_qat_dev_gen > qp->qat_dev_gen)) {
+               PMD_DRV_LOG(ERR, "Session alg not supported on this device gen");
+               op->status = RTE_CRYPTO_OP_STATUS_INVALID_SESSION;
+               return -EINVAL;
+       }
+
        qat_req = (struct icp_qat_fw_la_bulk_req *)out_msg;
        rte_mov128((uint8_t *)qat_req, (const uint8_t *)&(ctx->fw_req));
        qat_req->comn_mid.opaque_data = (uint64_t)(uintptr_t)op;
@@ -1195,18 +1206,7 @@ qat_write_hw_desc_entry(struct rte_crypto_op *op, uint8_t *out_msg,
                        auth_ofs = op->sym->auth.data.offset >> 3;
                        auth_len = op->sym->auth.data.length >> 3;
 
-                       if (ctx->qat_hash_alg ==
-                                       ICP_QAT_HW_AUTH_ALGO_KASUMI_F9) {
-                               if (do_cipher) {
-                                       auth_len = auth_len + auth_ofs + 1 -
-                                               ICP_QAT_HW_KASUMI_BLK_SZ;
-                                       auth_ofs = ICP_QAT_HW_KASUMI_BLK_SZ;
-                               } else {
-                                       auth_len = auth_len + auth_ofs + 1;
-                                       auth_ofs = 0;
-                               }
-                       } else
-                               auth_param->u1.aad_adr =
+                       auth_param->u1.aad_adr =
                                        rte_crypto_op_ctophys_offset(op,
                                                        ctx->auth_iv.offset);