Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2025 ZTE Corporation
3 : : */
4 : :
5 : : #include "zsda_crypto.h"
6 : :
7 : : #define choose_dst_mbuf(mbuf_src, mbuf_dst) ((mbuf_dst) == NULL ? (mbuf_src) : (mbuf_dst))
8 : : #define LBADS_MAX_REMAINDER (16 - 1)
9 : :
10 : : int
11 : 0 : zsda_encry_match(const void *op_in)
12 : : {
13 : : const struct rte_crypto_op *op = op_in;
14 : 0 : struct rte_cryptodev_sym_session *session = op->sym->session;
15 : : struct zsda_sym_session *sess =
16 : : (struct zsda_sym_session *)session->driver_priv_data;
17 : :
18 [ # # ]: 0 : if (sess->chain_order == ZSDA_SYM_CHAIN_ONLY_CIPHER &&
19 [ # # ]: 0 : sess->cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT)
20 : : return 1;
21 : : else
22 : 0 : return 0;
23 : : }
24 : :
25 : : int
26 : 0 : zsda_decry_match(const void *op_in)
27 : : {
28 : : const struct rte_crypto_op *op = op_in;
29 : 0 : struct rte_cryptodev_sym_session *session = op->sym->session;
30 : : struct zsda_sym_session *sess =
31 : : (struct zsda_sym_session *)session->driver_priv_data;
32 : :
33 [ # # ]: 0 : if (sess->chain_order == ZSDA_SYM_CHAIN_ONLY_CIPHER &&
34 [ # # ]: 0 : sess->cipher.op == RTE_CRYPTO_CIPHER_OP_DECRYPT)
35 : : return 1;
36 : : else
37 : 0 : return 0;
38 : : }
39 : :
40 : : int
41 : 0 : zsda_hash_match(const void *op_in)
42 : : {
43 : : const struct rte_crypto_op *op = op_in;
44 : 0 : struct rte_cryptodev_sym_session *session = op->sym->session;
45 : : struct zsda_sym_session *sess =
46 : : (struct zsda_sym_session *)session->driver_priv_data;
47 : :
48 [ # # ]: 0 : if (sess->chain_order == ZSDA_SYM_CHAIN_ONLY_AUTH)
49 : : return 1;
50 : : else
51 : 0 : return 0;
52 : : }
53 : :
54 : : static uint8_t
55 : : zsda_opcode_hash_get(struct zsda_sym_session *sess)
56 : : {
57 : 0 : switch (sess->auth.algo) {
58 : : case RTE_CRYPTO_AUTH_SHA1:
59 : : return ZSDA_OPC_HASH_SHA1;
60 : :
61 : : case RTE_CRYPTO_AUTH_SHA224:
62 : : return ZSDA_OPC_HASH_SHA2_224;
63 : :
64 : : case RTE_CRYPTO_AUTH_SHA256:
65 : : return ZSDA_OPC_HASH_SHA2_256;
66 : :
67 : : case RTE_CRYPTO_AUTH_SHA384:
68 : : return ZSDA_OPC_HASH_SHA2_384;
69 : :
70 : : case RTE_CRYPTO_AUTH_SHA512:
71 : : return ZSDA_OPC_HASH_SHA2_512;
72 : :
73 : : case RTE_CRYPTO_AUTH_SM3:
74 : : return ZSDA_OPC_HASH_SM3;
75 : : default:
76 : : break;
77 : : }
78 : :
79 : : return ZSDA_OPC_INVALID;
80 : : }
81 : :
82 : : static uint8_t
83 : 0 : zsda_opcode_crypto_get(struct zsda_sym_session *sess)
84 : : {
85 [ # # ]: 0 : if (sess->cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
86 [ # # ]: 0 : if (sess->cipher.algo == RTE_CRYPTO_CIPHER_AES_XTS &&
87 [ # # ]: 0 : sess->cipher.key_encry.length == 32)
88 : : return ZSDA_OPC_EC_AES_XTS_256;
89 [ # # ]: 0 : else if (sess->cipher.algo == RTE_CRYPTO_CIPHER_AES_XTS &&
90 [ # # ]: 0 : sess->cipher.key_encry.length == 64)
91 : : return ZSDA_OPC_EC_AES_XTS_512;
92 [ # # ]: 0 : else if (sess->cipher.algo == RTE_CRYPTO_CIPHER_SM4_XTS)
93 : 0 : return ZSDA_OPC_EC_SM4_XTS_256;
94 [ # # ]: 0 : } else if (sess->cipher.op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
95 [ # # ]: 0 : if (sess->cipher.algo == RTE_CRYPTO_CIPHER_AES_XTS &&
96 [ # # ]: 0 : sess->cipher.key_decry.length == 32)
97 : : return ZSDA_OPC_DC_AES_XTS_256;
98 [ # # ]: 0 : else if (sess->cipher.algo == RTE_CRYPTO_CIPHER_AES_XTS &&
99 [ # # ]: 0 : sess->cipher.key_decry.length == 64)
100 : : return ZSDA_OPC_DC_AES_XTS_512;
101 [ # # ]: 0 : else if (sess->cipher.algo == RTE_CRYPTO_CIPHER_SM4_XTS)
102 : 0 : return ZSDA_OPC_DC_SM4_XTS_256;
103 : : }
104 : : return ZSDA_OPC_INVALID;
105 : : }
106 : :
107 : : static int
108 : 0 : zsda_len_lbads_chk(uint32_t data_len, uint32_t lbads_size)
109 : : {
110 [ # # ]: 0 : if (data_len < 16) {
111 : 0 : ZSDA_LOG(ERR, "data_len wrong data_len 0x%x!", data_len);
112 : 0 : return ZSDA_FAILED;
113 : : }
114 [ # # ]: 0 : if (lbads_size != 0) {
115 [ # # ]: 0 : if (!(((data_len % lbads_size) == 0) ||
116 : : ((data_len % lbads_size) > LBADS_MAX_REMAINDER))) {
117 : 0 : ZSDA_LOG(ERR, "data_len wrong! data_len 0x%x - %d",
118 : : data_len, data_len % lbads_size);
119 : 0 : return ZSDA_FAILED;
120 : : }
121 : : }
122 : :
123 : : return ZSDA_SUCCESS;
124 : : }
125 : :
126 : : int
127 : 0 : zsda_crypto_wqe_build(void *op_in, const struct zsda_queue *queue,
128 : : void **op_cookies, const uint16_t new_tail)
129 : : {
130 : : struct rte_crypto_op *op = op_in;
131 : :
132 : 0 : struct rte_cryptodev_sym_session *session = op->sym->session;
133 : 0 : struct zsda_sym_session *sess =
134 : : (struct zsda_sym_session *)session->driver_priv_data;
135 : :
136 : 0 : struct zsda_wqe_crpt *wqe =
137 : 0 : (struct zsda_wqe_crpt *)(queue->base_addr +
138 : 0 : (new_tail * queue->msg_size));
139 : 0 : struct zsda_op_cookie *cookie = op_cookies[new_tail];
140 : 0 : struct zsda_sgl *sgl_src = (struct zsda_sgl *)&cookie->sgl_src;
141 : 0 : struct zsda_sgl *sgl_dst = (struct zsda_sgl *)&cookie->sgl_dst;
142 : : struct rte_mbuf *mbuf;
143 : :
144 : : int ret;
145 : : uint32_t op_offset;
146 : : uint32_t op_src_len;
147 : : uint32_t op_dst_len;
148 : : const uint8_t *iv_addr = NULL;
149 : : uint8_t iv_len = 0;
150 : :
151 : 0 : ret = zsda_len_lbads_chk(op->sym->cipher.data.length,
152 : : sess->cipher.dataunit_len);
153 [ # # ]: 0 : if (ret) {
154 : 0 : ZSDA_LOG(ERR, "data_len 0x%x", op->sym->cipher.data.length);
155 : 0 : return ZSDA_FAILED;
156 : : }
157 : :
158 : 0 : op_offset = op->sym->cipher.data.offset;
159 : 0 : op_src_len = op->sym->cipher.data.length;
160 : 0 : mbuf = op->sym->m_src;
161 : 0 : ret = zsda_sgl_fill(mbuf, op_offset, sgl_src, cookie->sgl_src_phys_addr,
162 : : op_src_len, NULL);
163 : :
164 [ # # ]: 0 : mbuf = choose_dst_mbuf(op->sym->m_src, op->sym->m_dst);
165 : 0 : op_dst_len = mbuf->pkt_len - op_offset;
166 : 0 : ret |= zsda_sgl_fill(mbuf, op_offset, sgl_dst,
167 : : cookie->sgl_dst_phys_addr, op_dst_len, NULL);
168 : :
169 [ # # ]: 0 : if (ret) {
170 : 0 : ZSDA_LOG(ERR, "Failed! zsda_sgl_fill");
171 : 0 : return ret;
172 : : }
173 : :
174 : 0 : cookie->used = true;
175 : 0 : cookie->sid = new_tail;
176 [ # # ]: 0 : cookie->op = op;
177 : :
178 : : memset(wqe, 0, sizeof(struct zsda_wqe_crpt));
179 : 0 : wqe->rx_length = op_src_len;
180 : 0 : wqe->tx_length = op_dst_len;
181 : 0 : wqe->valid = queue->valid;
182 : 0 : wqe->op_code = zsda_opcode_crypto_get(sess);
183 : 0 : wqe->sid = cookie->sid;
184 : 0 : wqe->rx_sgl_type = WQE_ELM_TYPE_LIST;
185 : 0 : wqe->tx_sgl_type = WQE_ELM_TYPE_LIST;
186 : 0 : wqe->rx_addr = cookie->sgl_src_phys_addr;
187 : 0 : wqe->tx_addr = cookie->sgl_dst_phys_addr;
188 : 0 : wqe->cfg.lbads = sess->cipher.lbads;
189 : :
190 [ # # ]: 0 : if (sess->cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT)
191 : 0 : memcpy((uint8_t *)wqe->cfg.key, sess->cipher.key_encry.data,
192 : : ZSDA_CIPHER_KEY_MAX_LEN);
193 : : else
194 : 0 : memcpy((uint8_t *)wqe->cfg.key, sess->cipher.key_decry.data,
195 : : ZSDA_CIPHER_KEY_MAX_LEN);
196 : :
197 : 0 : iv_addr = (const uint8_t *)rte_crypto_op_ctod_offset(
198 : : op, char *, sess->cipher.iv.offset);
199 : 0 : iv_len = sess->cipher.iv.length;
200 : 0 : zsda_reverse_memcpy((uint8_t *)wqe->cfg.slba_H, iv_addr, iv_len / 2);
201 : 0 : zsda_reverse_memcpy((uint8_t *)wqe->cfg.slba_L, iv_addr + 8, iv_len / 2);
202 : :
203 : 0 : return ret;
204 : : }
205 : :
206 : : int
207 : 0 : zsda_hash_wqe_build(void *op_in, const struct zsda_queue *queue,
208 : : void **op_cookies, const uint16_t new_tail)
209 : : {
210 : : struct rte_crypto_op *op = op_in;
211 : :
212 : 0 : struct rte_cryptodev_sym_session *session = op->sym->session;
213 : : struct zsda_sym_session *sess =
214 : : (struct zsda_sym_session *)session->driver_priv_data;
215 : :
216 : 0 : struct zsda_wqe_crpt *wqe =
217 : 0 : (struct zsda_wqe_crpt *)(queue->base_addr +
218 : 0 : (new_tail * queue->msg_size));
219 : 0 : struct zsda_op_cookie *cookie = op_cookies[new_tail];
220 [ # # ]: 0 : struct zsda_sgl *sgl_src = &cookie->sgl_src;
221 : : uint8_t opcode;
222 : : uint32_t op_offset;
223 : : uint32_t op_src_len;
224 : : int ret;
225 : :
226 : : opcode = zsda_opcode_hash_get(sess);
227 [ # # ]: 0 : if (opcode == ZSDA_OPC_INVALID) {
228 : 0 : ZSDA_LOG(ERR, "Failed! zsda_opcode_hash_get");
229 : 0 : return ZSDA_FAILED;
230 : : }
231 : :
232 : 0 : op_offset = op->sym->auth.data.offset;
233 : 0 : op_src_len = op->sym->auth.data.length;
234 : 0 : ret = zsda_sgl_fill(op->sym->m_src, op_offset, sgl_src,
235 : : cookie->sgl_src_phys_addr, op_src_len, NULL);
236 [ # # ]: 0 : if (ret) {
237 : 0 : ZSDA_LOG(ERR, "Failed! zsda_sgl_fill");
238 : 0 : return ret;
239 : : }
240 : :
241 : : memset(wqe, 0, sizeof(struct zsda_wqe_crpt));
242 : 0 : cookie->used = true;
243 : 0 : cookie->sid = new_tail;
244 : 0 : cookie->op = op;
245 : 0 : wqe->valid = queue->valid;
246 : 0 : wqe->op_code = opcode;
247 : 0 : wqe->sid = cookie->sid;
248 : 0 : wqe->rx_sgl_type = WQE_ELM_TYPE_LIST;
249 : 0 : wqe->tx_sgl_type = WQE_ELM_TYPE_PHYS_ADDR;
250 : 0 : wqe->rx_addr = cookie->sgl_src_phys_addr;
251 : 0 : wqe->tx_addr = op->sym->auth.digest.phys_addr;
252 : 0 : wqe->rx_length = op->sym->auth.data.length;
253 : 0 : wqe->tx_length = sess->auth.digest_length;
254 : :
255 : 0 : return ret;
256 : : }
257 : :
258 : : int
259 : 0 : zsda_crypto_callback(void *cookie_in, struct zsda_cqe *cqe)
260 : : {
261 : : struct zsda_op_cookie *tmp_cookie = cookie_in;
262 : 0 : struct rte_crypto_op *op = tmp_cookie->op;
263 : :
264 [ # # # # ]: 0 : if (!(CQE_ERR0(cqe->err0) || CQE_ERR1(cqe->err1)))
265 : 0 : op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
266 : : else {
267 : 0 : op->status = RTE_CRYPTO_OP_STATUS_ERROR;
268 : 0 : return ZSDA_FAILED;
269 : : }
270 : :
271 : 0 : return ZSDA_SUCCESS;
272 : : }
|
