uint16_t auth_iv_offset;
uint32_t salt;
uint64_t cpt_inst_w7;
+ uint64_t cpt_inst_w2;
+ struct cnxk_cpt_qp *qp;
struct roc_se_ctx roc_se_ctx;
} __rte_cache_aligned;
+static __rte_always_inline int
+fill_sess_gmac(struct rte_crypto_sym_xform *xform, struct cnxk_se_sess *sess);
+
+static inline void
+cpt_pack_iv(uint8_t *iv_src, uint8_t *iv_dst)
+{
+ iv_dst[16] = iv_src[16];
+ /* pack the last 8 bytes of IV to 6 bytes.
+ * discard the 2 MSB bits of each byte
+ */
+ iv_dst[17] = (((iv_src[17] & 0x3f) << 2) | ((iv_src[18] >> 4) & 0x3));
+ iv_dst[18] = (((iv_src[18] & 0xf) << 4) | ((iv_src[19] >> 2) & 0xf));
+ iv_dst[19] = (((iv_src[19] & 0x3) << 6) | (iv_src[20] & 0x3f));
+
+ iv_dst[20] = (((iv_src[21] & 0x3f) << 2) | ((iv_src[22] >> 4) & 0x3));
+ iv_dst[21] = (((iv_src[22] & 0xf) << 4) | ((iv_src[23] >> 2) & 0xf));
+ iv_dst[22] = (((iv_src[23] & 0x3) << 6) | (iv_src[24] & 0x3f));
+}
+
static inline void
-pdcp_iv_copy(uint8_t *iv_d, uint8_t *iv_s, const uint8_t pdcp_alg_type)
+pdcp_iv_copy(uint8_t *iv_d, uint8_t *iv_s, const uint8_t pdcp_alg_type,
+ uint8_t pack_iv)
{
uint32_t *iv_s_temp, iv_temp[4];
int j;
for (j = 0; j < 4; j++)
iv_temp[j] = iv_s_temp[3 - j];
memcpy(iv_d, iv_temp, 16);
- } else {
+ } else if (pdcp_alg_type == ROC_SE_PDCP_ALG_TYPE_ZUC) {
/* ZUC doesn't need a swap */
memcpy(iv_d, iv_s, 16);
+ if (pack_iv)
+ cpt_pack_iv(iv_s, iv_d);
+ } else {
+ /* AES-CMAC EIA2, microcode expects 16B zeroized IV */
+ for (j = 0; j < 4; j++)
+ iv_d[j] = 0;
}
}
}
static __rte_always_inline int
-cpt_zuc_snow3g_prep(uint32_t req_flags, uint64_t d_offs, uint64_t d_lens,
- struct roc_se_fc_params *params, struct cpt_inst_s *inst)
+cpt_pdcp_alg_prep(uint32_t req_flags, uint64_t d_offs, uint64_t d_lens,
+ struct roc_se_fc_params *params, struct cpt_inst_s *inst)
{
uint32_t size;
int32_t inputlen, outputlen;
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;
uint8_t *iv_s;
+ uint8_t pack_iv = 0;
union cpt_inst_w4 cpt_inst_w4;
se_ctx = params->ctx_buf.vaddr;
mac_len = se_ctx->mac_len;
pdcp_alg_type = se_ctx->pdcp_alg_type;
- cpt_inst_w4.s.opcode_major = ROC_SE_MAJOR_OP_ZUC_SNOW3G;
-
+ cpt_inst_w4.s.opcode_major = ROC_SE_MAJOR_OP_PDCP;
cpt_inst_w4.s.opcode_minor = se_ctx->template_w4.s.opcode_minor;
if (flags == 0x1) {
+ iv_s = params->auth_iv_buf;
+
/*
* Microcode expects offsets in bytes
* TODO: Rounding off
*/
auth_data_len = ROC_SE_AUTH_DLEN(d_lens);
-
- /* EIA3 or UIA2 */
auth_offset = ROC_SE_AUTH_OFFSET(d_offs);
- auth_offset = auth_offset / 8;
- /* consider iv len */
- auth_offset += iv_len;
+ if (se_ctx->pdcp_alg_type != ROC_SE_PDCP_ALG_TYPE_AES_CTR) {
+ iv_len = params->auth_iv_len;
+
+ if (iv_len == 25) {
+ iv_len -= 2;
+ pack_iv = 1;
+ }
+
+ auth_offset = auth_offset / 8;
+
+ /* consider iv len */
+ auth_offset += iv_len;
+
+ inputlen =
+ auth_offset + (RTE_ALIGN(auth_data_len, 8) / 8);
+ } else {
+ iv_len = 16;
+
+ /* consider iv len */
+ auth_offset += iv_len;
+
+ inputlen = auth_offset + auth_data_len;
+ }
- inputlen = auth_offset + (RTE_ALIGN(auth_data_len, 8) / 8);
outputlen = mac_len;
offset_ctrl = rte_cpu_to_be_64((uint64_t)auth_offset);
encr_data_len = 0;
encr_offset = 0;
-
- iv_s = params->auth_iv_buf;
} else {
- /* EEA3 or UEA2 */
+ iv_s = params->iv_buf;
+ iv_len = params->cipher_iv_len;
+
+ if (iv_len == 25) {
+ iv_len -= 2;
+ pack_iv = 1;
+ }
+
/*
* Microcode expects offsets in bytes
* TODO: Rounding off
auth_data_len = 0;
auth_offset = 0;
-
- iv_s = params->iv_buf;
}
if (unlikely((encr_offset >> 16) || (auth_offset >> 8))) {
cpt_inst_w4.s.dlen = inputlen + ROC_SE_OFF_CTRL_LEN;
uint8_t *iv_d = ((uint8_t *)offset_vaddr + ROC_SE_OFF_CTRL_LEN);
- pdcp_iv_copy(iv_d, iv_s, pdcp_alg_type);
+ pdcp_iv_copy(iv_d, iv_s, pdcp_alg_type, pack_iv);
*offset_vaddr = offset_ctrl;
} else {
/* save space for iv */
offset_vaddr = m_vaddr;
- m_vaddr = (uint8_t *)m_vaddr + ROC_SE_OFF_CTRL_LEN + iv_len;
+ m_vaddr = (uint8_t *)m_vaddr + ROC_SE_OFF_CTRL_LEN +
+ RTE_ALIGN_CEIL(iv_len, 8);
cpt_inst_w4.s.opcode_major |= (uint64_t)ROC_SE_DMA_MODE;
*offset_vaddr = offset_ctrl;
iv_d = ((uint8_t *)offset_vaddr + ROC_SE_OFF_CTRL_LEN);
- pdcp_iv_copy(iv_d, iv_s, pdcp_alg_type);
+ pdcp_iv_copy(iv_d, iv_s, pdcp_alg_type, pack_iv);
/* input data */
size = inputlen - iv_len;
/* consider iv len */
encr_offset += iv_len;
- inputlen = iv_len + (RTE_ALIGN(encr_data_len, 8) / 8);
+ inputlen = encr_offset + (RTE_ALIGN(encr_data_len, 8) / 8);
outputlen = inputlen;
/* save space for offset ctrl & iv */
if (likely(fc_type == ROC_SE_FC_GEN)) {
ret = cpt_dec_hmac_prep(flags, d_offs, d_lens, fc_params, inst);
} else if (fc_type == ROC_SE_PDCP) {
- ret = cpt_zuc_snow3g_prep(flags, d_offs, d_lens, fc_params,
- inst);
+ ret = cpt_pdcp_alg_prep(flags, d_offs, d_lens, fc_params, inst);
} else if (fc_type == ROC_SE_KASUMI) {
ret = cpt_kasumi_dec_prep(d_offs, d_lens, fc_params, inst);
}
if (likely(fc_type == ROC_SE_FC_GEN)) {
ret = cpt_enc_hmac_prep(flags, d_offs, d_lens, fc_params, inst);
} else if (fc_type == ROC_SE_PDCP) {
- ret = cpt_zuc_snow3g_prep(flags, d_offs, d_lens, fc_params,
- inst);
+ ret = cpt_pdcp_alg_prep(flags, d_offs, d_lens, fc_params, inst);
} else if (fc_type == ROC_SE_KASUMI) {
ret = cpt_kasumi_enc_prep(flags, d_offs, d_lens, fc_params,
inst);
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:
roc_se_auth_type auth_type = 0; /* NULL Auth type */
uint8_t zsk_flag = 0, aes_gcm = 0, is_null = 0;
+ if (xform->auth.algo == RTE_CRYPTO_AUTH_AES_GMAC)
+ return fill_sess_gmac(xform, sess);
+
if (xform->next != NULL &&
xform->next->type == RTE_CRYPTO_SYM_XFORM_CIPHER &&
xform->next->cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
auth_type = 0;
is_null = 1;
break;
- case RTE_CRYPTO_AUTH_AES_XCBC_MAC:
case RTE_CRYPTO_AUTH_AES_CMAC:
+ auth_type = ROC_SE_AES_CMAC_EIA2;
+ zsk_flag = ROC_SE_ZS_IA;
+ break;
+ case RTE_CRYPTO_AUTH_AES_XCBC_MAC:
case RTE_CRYPTO_AUTH_AES_CBC_MAC:
plt_dp_err("Crypto: Unsupported hash algo %u", a_form->algo);
return -1;
return 0;
}
-static __rte_always_inline uint32_t
+static __rte_always_inline void
prepare_iov_from_pkt_inplace(struct rte_mbuf *pkt,
struct roc_se_fc_params *param, uint32_t *flags)
{
param->bufs[0].vaddr = seg_data;
param->bufs[0].size = seg_size;
- return 0;
+ return;
}
iovec = param->src_iov;
iovec->bufs[index].vaddr = seg_data;
}
iovec->buf_cnt = index;
- return 0;
+ return;
}
static __rte_always_inline int
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 *,
*/
fc_params.dst_iov = fc_params.src_iov = (void *)src;
- if (unlikely(prepare_iov_from_pkt_inplace(m_src, &fc_params,
- &flags))) {
- plt_dp_err("Prepare inplace src iov failed");
- ret = -EINVAL;
- goto err_exit;
- }
+ prepare_iov_from_pkt_inplace(m_src, &fc_params, &flags);
} else {
/* Out of place processing */
*/
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) {
git.droids-corp.org / dpdk.git / blobdiff