crypto/cnxk: support inner checksum

[dpdk.git] / drivers / crypto / cnxk / cnxk_se.h

diff --git a/drivers/crypto/cnxk/cnxk_se.h b/drivers/crypto/cnxk/cnxk_se.h
index 9d1ce09..7959c4c 100644 (file)
--- a/drivers/crypto/cnxk/cnxk_se.h
+++ b/drivers/crypto/cnxk/cnxk_se.h
@@ -36,6 +36,29 @@ struct cnxk_se_sess {
        struct roc_se_ctx roc_se_ctx;
 } __rte_cache_aligned;
 
+static inline void
+pdcp_iv_copy(uint8_t *iv_d, uint8_t *iv_s, const uint8_t pdcp_alg_type)
+{
+       uint32_t *iv_s_temp, iv_temp[4];
+       int j;
+
+       if (pdcp_alg_type == ROC_SE_PDCP_ALG_TYPE_SNOW3G) {
+               /*
+                * DPDK seems to provide it in form of IV3 IV2 IV1 IV0
+                * and BigEndian, MC needs it as IV0 IV1 IV2 IV3
+                */
+
+               iv_s_temp = (uint32_t *)iv_s;
+
+               for (j = 0; j < 4; j++)
+                       iv_temp[j] = iv_s_temp[3 - j];
+               memcpy(iv_d, iv_temp, 16);
+       } else {
+               /* ZUC doesn't need a swap */
+               memcpy(iv_d, iv_s, 16);
+       }
+}
+
 static __rte_always_inline int
 cpt_mac_len_verify(struct rte_crypto_auth_xform *auth)
 {
@@ -954,13 +977,13 @@ cpt_zuc_snow3g_prep(uint32_t req_flags, uint64_t d_offs, uint64_t d_lens,
        int32_t inputlen, outputlen;
        struct roc_se_ctx *se_ctx;
        uint32_t mac_len = 0;
-       uint8_t pdcp_alg_type, j;
+       uint8_t pdcp_alg_type;
        uint32_t encr_offset, auth_offset;
        uint32_t encr_data_len, auth_data_len;
-       int flags, iv_len = 16;
+       int flags, iv_len;
        uint64_t offset_ctrl;
        uint64_t *offset_vaddr;
-       uint32_t *iv_s, iv[4];
+       uint8_t *iv_s;
        union cpt_inst_w4 cpt_inst_w4;
 
        se_ctx = params->ctx_buf.vaddr;
@@ -970,12 +993,12 @@ cpt_zuc_snow3g_prep(uint32_t req_flags, uint64_t d_offs, uint64_t d_lens,
 
        cpt_inst_w4.s.opcode_major = ROC_SE_MAJOR_OP_ZUC_SNOW3G;
 
-       /* indicates CPTR ctx, operation type, KEY & IV mode from DPTR */
-
-       cpt_inst_w4.s.opcode_minor = ((1 << 7) | (pdcp_alg_type << 5) |
-                                     (0 << 4) | (0 << 3) | (flags & 0x7));
+       cpt_inst_w4.s.opcode_minor = se_ctx->template_w4.s.opcode_minor;
 
        if (flags == 0x1) {
+               iv_s = params->auth_iv_buf;
+               iv_len = params->auth_iv_len;
+
                /*
                 * Microcode expects offsets in bytes
                 * TODO: Rounding off
@@ -996,9 +1019,10 @@ cpt_zuc_snow3g_prep(uint32_t req_flags, uint64_t d_offs, uint64_t d_lens,
 
                encr_data_len = 0;
                encr_offset = 0;
-
-               iv_s = params->auth_iv_buf;
        } else {
+               iv_s = params->iv_buf;
+               iv_len = params->cipher_iv_len;
+
                /* EEA3 or UEA2 */
                /*
                 * Microcode expects offsets in bytes
@@ -1019,8 +1043,6 @@ cpt_zuc_snow3g_prep(uint32_t req_flags, uint64_t d_offs, uint64_t d_lens,
 
                auth_data_len = 0;
                auth_offset = 0;
-
-               iv_s = params->iv_buf;
        }
 
        if (unlikely((encr_offset >> 16) || (auth_offset >> 8))) {
@@ -1030,20 +1052,6 @@ cpt_zuc_snow3g_prep(uint32_t req_flags, uint64_t d_offs, uint64_t d_lens,
                return -1;
        }
 
-       if (pdcp_alg_type == ROC_SE_PDCP_ALG_TYPE_SNOW3G) {
-               /*
-                * DPDK seems to provide it in form of IV3 IV2 IV1 IV0
-                * and BigEndian, MC needs it as IV0 IV1 IV2 IV3
-                */
-
-               for (j = 0; j < 4; j++)
-                       iv[j] = iv_s[3 - j];
-       } else {
-               /* ZUC doesn't need a swap */
-               for (j = 0; j < 4; j++)
-                       iv[j] = iv_s[j];
-       }
-
        /*
         * GP op header, lengths are expected in bits.
         */
@@ -1072,11 +1080,8 @@ cpt_zuc_snow3g_prep(uint32_t req_flags, uint64_t d_offs, uint64_t d_lens,
 
                cpt_inst_w4.s.dlen = inputlen + ROC_SE_OFF_CTRL_LEN;
 
-               if (likely(iv_len)) {
-                       uint32_t *iv_d = (uint32_t *)((uint8_t *)offset_vaddr +
-                                                     ROC_SE_OFF_CTRL_LEN);
-                       memcpy(iv_d, iv, 16);
-               }
+               uint8_t *iv_d = ((uint8_t *)offset_vaddr + ROC_SE_OFF_CTRL_LEN);
+               pdcp_iv_copy(iv_d, iv_s, pdcp_alg_type);
 
                *offset_vaddr = offset_ctrl;
        } else {
@@ -1085,7 +1090,7 @@ cpt_zuc_snow3g_prep(uint32_t req_flags, uint64_t d_offs, uint64_t d_lens,
                struct roc_se_sglist_comp *gather_comp;
                struct roc_se_sglist_comp *scatter_comp;
                uint8_t *in_buffer;
-               uint32_t *iv_d;
+               uint8_t *iv_d;
 
                /* save space for iv */
                offset_vaddr = m_vaddr;
@@ -1117,9 +1122,8 @@ cpt_zuc_snow3g_prep(uint32_t req_flags, uint64_t d_offs, uint64_t d_lens,
                /* iv offset is 0 */
                *offset_vaddr = offset_ctrl;
 
-               iv_d = (uint32_t *)((uint8_t *)offset_vaddr +
-                                   ROC_SE_OFF_CTRL_LEN);
-               memcpy(iv_d, iv, 16);
+               iv_d = ((uint8_t *)offset_vaddr + ROC_SE_OFF_CTRL_LEN);
+               pdcp_iv_copy(iv_d, iv_s, pdcp_alg_type);
 
                /* input data */
                size = inputlen - iv_len;
@@ -1717,7 +1721,7 @@ fill_sess_cipher(struct rte_crypto_sym_xform *xform, struct cnxk_se_sess *sess)
                break;
        case RTE_CRYPTO_CIPHER_ZUC_EEA3:
                enc_type = ROC_SE_ZUC_EEA3;
-               cipher_key_len = 16;
+               cipher_key_len = c_form->key.length;
                zsk_flag = ROC_SE_ZS_EA;
                break;
        case RTE_CRYPTO_CIPHER_AES_XTS:
@@ -1761,6 +1765,8 @@ fill_sess_cipher(struct rte_crypto_sym_xform *xform, struct cnxk_se_sess *sess)
                                         NULL)))
                return -1;
 
+       if ((enc_type >= ROC_SE_ZUC_EEA3) && (enc_type <= ROC_SE_AES_CTR_EEA2))
+               roc_se_ctx_swap(&sess->roc_se_ctx);
        return 0;
 }
 
@@ -1864,6 +1870,10 @@ fill_sess_auth(struct rte_crypto_sym_xform *xform, struct cnxk_se_sess *sess)
                                         a_form->digest_length)))
                return -1;
 
+       if ((auth_type >= ROC_SE_ZUC_EIA3) &&
+           (auth_type <= ROC_SE_AES_CMAC_EIA2))
+               roc_se_ctx_swap(&sess->roc_se_ctx);
+
        return 0;
 }
 
@@ -2061,6 +2071,9 @@ fill_fc_params(struct rte_crypto_op *cop, struct cnxk_se_sess *sess,
        uint32_t iv_buf[4];
        int ret;
 
+       fc_params.cipher_iv_len = sess->iv_length;
+       fc_params.auth_iv_len = sess->auth_iv_length;
+
        if (likely(sess->iv_length)) {
                flags |= ROC_SE_VALID_IV_BUF;
                fc_params.iv_buf = rte_crypto_op_ctod_offset(cop, uint8_t *,
@@ -2371,6 +2384,7 @@ fill_digest_params(struct rte_crypto_op *cop, struct cnxk_se_sess *sess,
                 */
                d_offs = auth_range_off;
                auth_range_off = 0;
+               params.auth_iv_len = sess->auth_iv_length;
                params.auth_iv_buf = rte_crypto_op_ctod_offset(
                        cop, uint8_t *, sess->auth_iv_offset);
                if (sess->zsk_flag == ROC_SE_K_F9) {