Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : *
3 : : * Copyright (c) 2016 Freescale Semiconductor, Inc. All rights reserved.
4 : : * Copyright 2017-2024 NXP
5 : : *
6 : : */
7 : :
8 : : #include <fcntl.h>
9 : : #include <unistd.h>
10 : : #include <sched.h>
11 : : #include <net/if.h>
12 : :
13 : : #include <rte_byteorder.h>
14 : : #include <rte_common.h>
15 : : #include <cryptodev_pmd.h>
16 : : #include <rte_crypto.h>
17 : : #include <rte_cryptodev.h>
18 : : #include <rte_security_driver.h>
19 : : #include <rte_cycles.h>
20 : : #include <dev_driver.h>
21 : : #include <rte_io.h>
22 : : #include <rte_ip.h>
23 : : #include <rte_udp.h>
24 : : #include <rte_kvargs.h>
25 : : #include <rte_malloc.h>
26 : : #include <rte_mbuf.h>
27 : : #include <rte_memcpy.h>
28 : : #include <rte_string_fns.h>
29 : : #include <rte_spinlock.h>
30 : : #include <rte_hexdump.h>
31 : :
32 : : #include <fsl_usd.h>
33 : : #include <fsl_qman.h>
34 : : #include <dpaa_of.h>
35 : :
36 : : /* RTA header files */
37 : : #include <desc/common.h>
38 : : #include <desc/algo.h>
39 : : #include <desc/ipsec.h>
40 : : #include <desc/pdcp.h>
41 : : #include <desc/sdap.h>
42 : :
43 : : #include <bus_dpaa_driver.h>
44 : : #include <dpaa_sec.h>
45 : : #include <dpaa_sec_event.h>
46 : : #include <dpaa_sec_log.h>
47 : : #include <dpaax_iova_table.h>
48 : :
49 : : #define DRIVER_DUMP_MODE "drv_dump_mode"
50 : : #define DPAA_DEFAULT_NAT_T_PORT 4500
51 : :
52 : : /* DPAA_SEC_DP_DUMP levels */
53 : : enum dpaa_sec_dump_levels {
54 : : DPAA_SEC_DP_NO_DUMP,
55 : : DPAA_SEC_DP_ERR_DUMP,
56 : : DPAA_SEC_DP_FULL_DUMP
57 : : };
58 : :
59 : : uint8_t dpaa_sec_dp_dump = DPAA_SEC_DP_ERR_DUMP;
60 : :
61 : : uint8_t dpaa_cryptodev_driver_id;
62 : :
63 : : static inline void
64 : 0 : dpaa_sec_op_ending(struct dpaa_sec_op_ctx *ctx)
65 : : {
66 [ # # ]: 0 : if (!ctx->fd_status) {
67 : 0 : ctx->op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
68 : : } else {
69 : 0 : DPAA_SEC_DP_WARN("SEC return err: 0x%x", ctx->fd_status);
70 : 0 : ctx->op->status = RTE_CRYPTO_OP_STATUS_ERROR;
71 : : }
72 : 0 : }
73 : :
74 : : static inline struct dpaa_sec_op_ctx *
75 [ # # ]: 0 : dpaa_sec_alloc_ctx(dpaa_sec_session *ses, int sg_count)
76 : : {
77 : : struct dpaa_sec_op_ctx *ctx;
78 : : int i, retval;
79 : :
80 : 0 : retval = rte_mempool_get(
81 [ # # ]: 0 : ses->qp[rte_lcore_id() % MAX_DPAA_CORES]->ctx_pool,
82 : : (void **)(&ctx));
83 [ # # # # ]: 0 : if (!ctx || retval) {
84 : 0 : DPAA_SEC_DP_WARN("Alloc sec descriptor failed!");
85 : 0 : return NULL;
86 : : }
87 : : /*
88 : : * Clear SG memory. There are 16 SG entries of 16 Bytes each.
89 : : * one call to dcbz_64() clear 64 bytes, hence calling it 4 times
90 : : * to clear all the SG entries. dpaa_sec_alloc_ctx() is called for
91 : : * each packet, memset is costlier than dcbz_64().
92 : : */
93 : : for (i = 0; i < sg_count && i < MAX_JOB_SG_ENTRIES; i += 4)
94 : : dcbz_64(&ctx->job.sg[i]);
95 : :
96 : 0 : ctx->ctx_pool = ses->qp[rte_lcore_id() % MAX_DPAA_CORES]->ctx_pool;
97 : 0 : ctx->vtop_offset = (size_t) ctx - rte_mempool_virt2iova(ctx);
98 : :
99 : 0 : return ctx;
100 : : }
101 : :
102 : : static void
103 : 0 : ern_sec_fq_handler(struct qman_portal *qm __rte_unused,
104 : : struct qman_fq *fq,
105 : : const struct qm_mr_entry *msg)
106 : : {
107 : 0 : DPAA_SEC_DP_ERR("sec fq %d error, RC = %x, seqnum = %x",
108 : : fq->fqid, msg->ern.rc, msg->ern.seqnum);
109 : 0 : }
110 : :
111 : : /* initialize the queue with dest chan as caam chan so that
112 : : * all the packets in this queue could be dispatched into caam
113 : : */
114 : : static int
115 : 0 : dpaa_sec_init_rx(struct qman_fq *fq_in, rte_iova_t hwdesc,
116 : : uint32_t fqid_out)
117 : : {
118 : : struct qm_mcc_initfq fq_opts;
119 : : uint32_t flags;
120 : : int ret = -1;
121 : :
122 : : /* Clear FQ options */
123 : : memset(&fq_opts, 0x00, sizeof(struct qm_mcc_initfq));
124 : :
125 : : flags = QMAN_INITFQ_FLAG_SCHED;
126 : 0 : fq_opts.we_mask = QM_INITFQ_WE_DESTWQ | QM_INITFQ_WE_CONTEXTA |
127 : : QM_INITFQ_WE_CONTEXTB;
128 : :
129 : : qm_fqd_context_a_set64(&fq_opts.fqd, hwdesc);
130 : 0 : fq_opts.fqd.context_b = fqid_out;
131 : 0 : fq_opts.fqd.dest.channel = dpaa_get_qm_channel_caam();
132 : 0 : fq_opts.fqd.dest.wq = 0;
133 : :
134 : 0 : fq_in->cb.ern = ern_sec_fq_handler;
135 : :
136 : 0 : DPAA_SEC_DEBUG("in-%x out-%x", fq_in->fqid, fqid_out);
137 : :
138 : 0 : ret = qman_init_fq(fq_in, flags, &fq_opts);
139 [ # # ]: 0 : if (unlikely(ret != 0))
140 : 0 : DPAA_SEC_ERR("qman_init_fq failed %d", ret);
141 : :
142 : 0 : return ret;
143 : : }
144 : :
145 : : /* something is put into in_fq and caam put the crypto result into out_fq */
146 : : static enum qman_cb_dqrr_result
147 : 0 : dqrr_out_fq_cb_rx(struct qman_portal *qm __always_unused,
148 : : struct qman_fq *fq __always_unused,
149 : : const struct qm_dqrr_entry *dqrr)
150 : : {
151 : : const struct qm_fd *fd;
152 : : struct dpaa_sec_job *job;
153 : : struct dpaa_sec_op_ctx *ctx;
154 : :
155 [ # # ]: 0 : if (!(dqrr->stat & QM_DQRR_STAT_FD_VALID))
156 : : return qman_cb_dqrr_consume;
157 : :
158 : : fd = &dqrr->fd;
159 : : /* sg is embedded in an op ctx,
160 : : * sg[0] is for output
161 : : * sg[1] for input
162 : : */
163 : 0 : job = rte_dpaa_mem_ptov(qm_fd_addr_get64(fd));
164 : :
165 : : ctx = container_of(job, struct dpaa_sec_op_ctx, job);
166 : 0 : ctx->fd_status = fd->status;
167 [ # # ]: 0 : if (ctx->op->sess_type == RTE_CRYPTO_OP_SECURITY_SESSION) {
168 : : struct qm_sg_entry *sg_out;
169 : : uint32_t len;
170 : 0 : struct rte_mbuf *mbuf = (ctx->op->sym->m_dst == NULL) ?
171 [ # # ]: 0 : ctx->op->sym->m_src : ctx->op->sym->m_dst;
172 : :
173 : 0 : sg_out = &job->sg[0];
174 : 0 : hw_sg_to_cpu(sg_out);
175 : 0 : len = sg_out->length;
176 : 0 : mbuf->pkt_len = len;
177 [ # # ]: 0 : while (mbuf->next != NULL) {
178 : 0 : len -= mbuf->data_len;
179 : : mbuf = mbuf->next;
180 : : }
181 : 0 : mbuf->data_len = len;
182 : : }
183 : 0 : dpaa_sec_op_ending(ctx);
184 : :
185 : 0 : return qman_cb_dqrr_consume;
186 : : }
187 : :
188 : : /* caam result is put into this queue */
189 : : static int
190 : 0 : dpaa_sec_init_tx(struct qman_fq *fq)
191 : : {
192 : : int ret;
193 : : struct qm_mcc_initfq opts;
194 : : uint32_t flags;
195 : :
196 : : flags = QMAN_FQ_FLAG_NO_ENQUEUE | QMAN_FQ_FLAG_LOCKED |
197 : : QMAN_FQ_FLAG_DYNAMIC_FQID;
198 : :
199 : 0 : ret = qman_create_fq(0, flags, fq);
200 [ # # ]: 0 : if (unlikely(ret)) {
201 : 0 : DPAA_SEC_ERR("qman_create_fq failed");
202 : 0 : return ret;
203 : : }
204 : :
205 : : memset(&opts, 0, sizeof(opts));
206 : 0 : opts.we_mask = QM_INITFQ_WE_DESTWQ | QM_INITFQ_WE_FQCTRL |
207 : : QM_INITFQ_WE_CONTEXTA | QM_INITFQ_WE_CONTEXTB;
208 : :
209 : : /* opts.fqd.dest.channel = dpaa_sec_pool_chan; */
210 : :
211 : 0 : fq->cb.dqrr = dqrr_out_fq_cb_rx;
212 : 0 : fq->cb.ern = ern_sec_fq_handler;
213 : :
214 : 0 : ret = qman_init_fq(fq, 0, &opts);
215 [ # # ]: 0 : if (unlikely(ret)) {
216 : 0 : DPAA_SEC_ERR("unable to init caam source fq!");
217 : 0 : return ret;
218 : : }
219 : :
220 : : return ret;
221 : : }
222 : :
223 : : static inline int is_aead(dpaa_sec_session *ses)
224 : : {
225 : 0 : return ((ses->cipher_alg == 0) &&
226 [ # # ]: 0 : (ses->auth_alg == 0) &&
227 [ # # ]: 0 : (ses->aead_alg != 0));
228 : : }
229 : :
230 : : static inline int is_encode(dpaa_sec_session *ses)
231 : : {
232 : 0 : return ses->dir == DIR_ENC;
233 : : }
234 : :
235 : : static inline int is_decode(dpaa_sec_session *ses)
236 : : {
237 : 0 : return ses->dir == DIR_DEC;
238 : : }
239 : :
240 : : static int
241 : 0 : dpaa_sec_prep_pdcp_cdb(dpaa_sec_session *ses)
242 : : {
243 : 0 : struct alginfo authdata = {0}, cipherdata = {0};
244 : : struct sec_cdb *cdb = &ses->cdb;
245 : : struct alginfo *p_authdata = NULL;
246 : : int32_t shared_desc_len = 0;
247 : : #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
248 : : int swap = false;
249 : : #else
250 : : int swap = true;
251 : : #endif
252 : :
253 : 0 : cipherdata.key = (size_t)ses->cipher_key.data;
254 : 0 : cipherdata.keylen = ses->cipher_key.length;
255 : : cipherdata.key_enc_flags = 0;
256 : 0 : cipherdata.key_type = RTA_DATA_IMM;
257 : 0 : cipherdata.algtype = ses->cipher_key.alg;
258 : 0 : cipherdata.algmode = ses->cipher_key.algmode;
259 : :
260 [ # # ]: 0 : if (ses->auth_alg) {
261 : 0 : authdata.key = (size_t)ses->auth_key.data;
262 : 0 : authdata.keylen = ses->auth_key.length;
263 : : authdata.key_enc_flags = 0;
264 : 0 : authdata.key_type = RTA_DATA_IMM;
265 : 0 : authdata.algtype = ses->auth_key.alg;
266 : 0 : authdata.algmode = ses->auth_key.algmode;
267 : :
268 : : p_authdata = &authdata;
269 : : }
270 : :
271 [ # # ]: 0 : if (ses->pdcp.sdap_enabled) {
272 : : int nb_keys_to_inline =
273 [ # # ]: 0 : rta_inline_pdcp_sdap_query(authdata.algtype,
274 : : cipherdata.algtype,
275 : : ses->pdcp.sn_size,
276 : : ses->pdcp.hfn_ovd);
277 : : if (nb_keys_to_inline >= 1) {
278 : 0 : cipherdata.key = (size_t)rte_dpaa_mem_vtop((void *)
279 : : (size_t)cipherdata.key);
280 : 0 : cipherdata.key_type = RTA_DATA_PTR;
281 : : }
282 [ # # ]: 0 : if (nb_keys_to_inline >= 2) {
283 : 0 : authdata.key = (size_t)rte_dpaa_mem_vtop((void *)
284 : 0 : (size_t)authdata.key);
285 : 0 : authdata.key_type = RTA_DATA_PTR;
286 : : }
287 : : } else {
288 : 0 : if (rta_inline_pdcp_query(authdata.algtype,
289 : : cipherdata.algtype,
290 : 0 : ses->pdcp.sn_size,
291 [ # # ]: 0 : ses->pdcp.hfn_ovd)) {
292 : 0 : cipherdata.key = (size_t)rte_dpaa_mem_vtop((void *)
293 : : (size_t)cipherdata.key);
294 : 0 : cipherdata.key_type = RTA_DATA_PTR;
295 : : }
296 : : }
297 : :
298 [ # # ]: 0 : if (ses->pdcp.domain == RTE_SECURITY_PDCP_MODE_CONTROL) {
299 [ # # ]: 0 : if (ses->dir == DIR_ENC)
300 : 0 : shared_desc_len = cnstr_shdsc_pdcp_c_plane_encap(
301 : 0 : cdb->sh_desc, 1, swap,
302 : : ses->pdcp.hfn,
303 : 0 : ses->pdcp.sn_size,
304 : 0 : ses->pdcp.bearer,
305 : 0 : ses->pdcp.pkt_dir,
306 : : ses->pdcp.hfn_threshold,
307 : : &cipherdata, &authdata);
308 [ # # ]: 0 : else if (ses->dir == DIR_DEC)
309 : 0 : shared_desc_len = cnstr_shdsc_pdcp_c_plane_decap(
310 : 0 : cdb->sh_desc, 1, swap,
311 : : ses->pdcp.hfn,
312 : 0 : ses->pdcp.sn_size,
313 : 0 : ses->pdcp.bearer,
314 : 0 : ses->pdcp.pkt_dir,
315 : : ses->pdcp.hfn_threshold,
316 : : &cipherdata, &authdata);
317 [ # # ]: 0 : } else if (ses->pdcp.domain == RTE_SECURITY_PDCP_MODE_SHORT_MAC) {
318 : 0 : shared_desc_len = cnstr_shdsc_pdcp_short_mac(cdb->sh_desc,
319 : : 1, swap, &authdata);
320 : : } else {
321 [ # # ]: 0 : if (ses->dir == DIR_ENC) {
322 [ # # ]: 0 : if (ses->pdcp.sdap_enabled)
323 : : shared_desc_len =
324 : 0 : cnstr_shdsc_pdcp_sdap_u_plane_encap(
325 : 0 : cdb->sh_desc, 1, swap,
326 : 0 : ses->pdcp.sn_size,
327 : : ses->pdcp.hfn,
328 : 0 : ses->pdcp.bearer,
329 : 0 : ses->pdcp.pkt_dir,
330 : : ses->pdcp.hfn_threshold,
331 : : &cipherdata, p_authdata);
332 : : else
333 : : shared_desc_len =
334 : 0 : cnstr_shdsc_pdcp_u_plane_encap(
335 : 0 : cdb->sh_desc, 1, swap,
336 : 0 : ses->pdcp.sn_size,
337 : : ses->pdcp.hfn,
338 : 0 : ses->pdcp.bearer,
339 : 0 : ses->pdcp.pkt_dir,
340 : : ses->pdcp.hfn_threshold,
341 : : &cipherdata, p_authdata);
342 [ # # ]: 0 : } else if (ses->dir == DIR_DEC) {
343 [ # # ]: 0 : if (ses->pdcp.sdap_enabled)
344 : : shared_desc_len =
345 : 0 : cnstr_shdsc_pdcp_sdap_u_plane_decap(
346 : 0 : cdb->sh_desc, 1, swap,
347 : 0 : ses->pdcp.sn_size,
348 : : ses->pdcp.hfn,
349 : 0 : ses->pdcp.bearer,
350 : 0 : ses->pdcp.pkt_dir,
351 : : ses->pdcp.hfn_threshold,
352 : : &cipherdata, p_authdata);
353 : : else
354 : : shared_desc_len =
355 : 0 : cnstr_shdsc_pdcp_u_plane_decap(
356 : 0 : cdb->sh_desc, 1, swap,
357 : 0 : ses->pdcp.sn_size,
358 : : ses->pdcp.hfn,
359 : 0 : ses->pdcp.bearer,
360 : 0 : ses->pdcp.pkt_dir,
361 : : ses->pdcp.hfn_threshold,
362 : : &cipherdata, p_authdata);
363 : : }
364 : : }
365 : 0 : return shared_desc_len;
366 : : }
367 : :
368 : : /* prepare ipsec proto command block of the session */
369 : : static int
370 : 0 : dpaa_sec_prep_ipsec_cdb(dpaa_sec_session *ses)
371 : : {
372 : 0 : struct alginfo cipherdata = {0}, authdata = {0};
373 : : struct sec_cdb *cdb = &ses->cdb;
374 : : int32_t shared_desc_len = 0;
375 : : int err;
376 : : #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
377 : : int swap = false;
378 : : #else
379 : : int swap = true;
380 : : #endif
381 : :
382 : 0 : cipherdata.key = (size_t)ses->cipher_key.data;
383 : 0 : cipherdata.keylen = ses->cipher_key.length;
384 : : cipherdata.key_enc_flags = 0;
385 : 0 : cipherdata.key_type = RTA_DATA_IMM;
386 : 0 : cipherdata.algtype = ses->cipher_key.alg;
387 : 0 : cipherdata.algmode = ses->cipher_key.algmode;
388 : :
389 [ # # ]: 0 : if (ses->auth_key.length) {
390 : 0 : authdata.key = (size_t)ses->auth_key.data;
391 : 0 : authdata.keylen = ses->auth_key.length;
392 : : authdata.key_enc_flags = 0;
393 : 0 : authdata.key_type = RTA_DATA_IMM;
394 : 0 : authdata.algtype = ses->auth_key.alg;
395 : 0 : authdata.algmode = ses->auth_key.algmode;
396 : : }
397 : :
398 : 0 : cdb->sh_desc[0] = cipherdata.keylen;
399 : 0 : cdb->sh_desc[1] = authdata.keylen;
400 : 0 : err = rta_inline_ipsec_query(IPSEC_AUTH_VAR_AES_DEC_BASE_DESC_LEN,
401 : : DESC_JOB_IO_LEN,
402 : 0 : (unsigned int *)cdb->sh_desc,
403 : : &cdb->sh_desc[2], 2, authdata.algtype, 1);
404 : :
405 [ # # ]: 0 : if (err < 0) {
406 : 0 : DPAA_SEC_ERR("Crypto: Incorrect key lengths");
407 : 0 : return err;
408 : : }
409 [ # # ]: 0 : if (cdb->sh_desc[2] & 1)
410 : : cipherdata.key_type = RTA_DATA_IMM;
411 : : else {
412 : 0 : cipherdata.key = (size_t)rte_dpaa_mem_vtop(
413 : : (void *)(size_t)cipherdata.key);
414 : 0 : cipherdata.key_type = RTA_DATA_PTR;
415 : : }
416 [ # # ]: 0 : if (cdb->sh_desc[2] & (1<<1))
417 : 0 : authdata.key_type = RTA_DATA_IMM;
418 : : else {
419 : 0 : authdata.key = (size_t)rte_dpaa_mem_vtop(
420 : 0 : (void *)(size_t)authdata.key);
421 : 0 : authdata.key_type = RTA_DATA_PTR;
422 : : }
423 : :
424 : 0 : cdb->sh_desc[0] = 0;
425 : 0 : cdb->sh_desc[1] = 0;
426 : 0 : cdb->sh_desc[2] = 0;
427 [ # # ]: 0 : if (ses->dir == DIR_ENC) {
428 : 0 : shared_desc_len = cnstr_shdsc_ipsec_new_encap(
429 : : cdb->sh_desc,
430 : : true, swap, SHR_SERIAL,
431 : : &ses->encap_pdb,
432 : 0 : (uint8_t *)&ses->ip4_hdr,
433 : : &cipherdata, &authdata);
434 [ # # ]: 0 : } else if (ses->dir == DIR_DEC) {
435 : 0 : shared_desc_len = cnstr_shdsc_ipsec_new_decap(
436 : : cdb->sh_desc,
437 : : true, swap, SHR_SERIAL,
438 : : &ses->decap_pdb,
439 : : &cipherdata, &authdata);
440 : : }
441 : : return shared_desc_len;
442 : : }
443 : :
444 : : /* prepare command block of the session */
445 : : static int
446 : 0 : dpaa_sec_prep_cdb(dpaa_sec_session *ses)
447 : : {
448 : 0 : struct alginfo alginfo_c = {0}, alginfo_a = {0}, alginfo = {0};
449 : : int32_t shared_desc_len = 0;
450 [ # # # # : 0 : struct sec_cdb *cdb = &ses->cdb;
# # # ]
451 : : int err;
452 : : #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
453 : : int swap = false;
454 : : #else
455 : : int swap = true;
456 : : #endif
457 : :
458 : : memset(cdb, 0, sizeof(struct sec_cdb));
459 : :
460 [ # # # # : 0 : switch (ses->ctxt) {
# # # ]
461 : 0 : case DPAA_SEC_IPSEC:
462 : 0 : shared_desc_len = dpaa_sec_prep_ipsec_cdb(ses);
463 : 0 : break;
464 : 0 : case DPAA_SEC_PDCP:
465 : 0 : shared_desc_len = dpaa_sec_prep_pdcp_cdb(ses);
466 : 0 : break;
467 : 0 : case DPAA_SEC_CIPHER:
468 : 0 : alginfo_c.key = (size_t)ses->cipher_key.data;
469 : 0 : alginfo_c.keylen = ses->cipher_key.length;
470 : : alginfo_c.key_enc_flags = 0;
471 : 0 : alginfo_c.key_type = RTA_DATA_IMM;
472 : 0 : alginfo_c.algtype = ses->cipher_key.alg;
473 : 0 : alginfo_c.algmode = ses->cipher_key.algmode;
474 : :
475 [ # # # # ]: 0 : switch (ses->cipher_alg) {
476 : 0 : case RTE_CRYPTO_CIPHER_AES_CBC:
477 : : case RTE_CRYPTO_CIPHER_3DES_CBC:
478 : : case RTE_CRYPTO_CIPHER_DES_CBC:
479 : : case RTE_CRYPTO_CIPHER_AES_CTR:
480 : : case RTE_CRYPTO_CIPHER_3DES_CTR:
481 : 0 : shared_desc_len = cnstr_shdsc_blkcipher(
482 : 0 : cdb->sh_desc, true,
483 : : swap, SHR_NEVER, &alginfo_c,
484 : 0 : ses->iv.length,
485 : 0 : ses->dir);
486 : 0 : break;
487 : 0 : case RTE_CRYPTO_CIPHER_SNOW3G_UEA2:
488 : 0 : shared_desc_len = cnstr_shdsc_snow_f8(
489 : 0 : cdb->sh_desc, true, swap,
490 : : &alginfo_c,
491 : 0 : ses->dir);
492 : 0 : break;
493 : 0 : case RTE_CRYPTO_CIPHER_ZUC_EEA3:
494 : 0 : shared_desc_len = cnstr_shdsc_zuce(
495 : 0 : cdb->sh_desc, true, swap,
496 : : &alginfo_c,
497 : 0 : ses->dir);
498 : 0 : break;
499 : 0 : default:
500 : 0 : DPAA_SEC_ERR("unsupported cipher alg %s (%d)",
501 : : rte_cryptodev_get_cipher_algo_string(ses->cipher_alg),
502 : : ses->cipher_alg);
503 : 0 : return -ENOTSUP;
504 : : }
505 : : break;
506 : 0 : case DPAA_SEC_AUTH:
507 : 0 : alginfo_a.key = (size_t)ses->auth_key.data;
508 : 0 : alginfo_a.keylen = ses->auth_key.length;
509 : : alginfo_a.key_enc_flags = 0;
510 : 0 : alginfo_a.key_type = RTA_DATA_IMM;
511 : 0 : alginfo_a.algtype = ses->auth_key.alg;
512 : 0 : alginfo_a.algmode = ses->auth_key.algmode;
513 [ # # # # : 0 : switch (ses->auth_alg) {
# # ]
514 : 0 : case RTE_CRYPTO_AUTH_MD5:
515 : : case RTE_CRYPTO_AUTH_SHA1:
516 : : case RTE_CRYPTO_AUTH_SHA224:
517 : : case RTE_CRYPTO_AUTH_SHA256:
518 : : case RTE_CRYPTO_AUTH_SHA384:
519 : : case RTE_CRYPTO_AUTH_SHA512:
520 : 0 : shared_desc_len = cnstr_shdsc_hash(
521 : 0 : cdb->sh_desc, true,
522 : : swap, SHR_NEVER, &alginfo_a,
523 : 0 : !ses->dir,
524 : 0 : ses->digest_length);
525 : 0 : break;
526 : 0 : case RTE_CRYPTO_AUTH_MD5_HMAC:
527 : : case RTE_CRYPTO_AUTH_SHA1_HMAC:
528 : : case RTE_CRYPTO_AUTH_SHA224_HMAC:
529 : : case RTE_CRYPTO_AUTH_SHA256_HMAC:
530 : : case RTE_CRYPTO_AUTH_SHA384_HMAC:
531 : : case RTE_CRYPTO_AUTH_SHA512_HMAC:
532 : 0 : shared_desc_len = cnstr_shdsc_hmac(
533 : 0 : cdb->sh_desc, true,
534 : : swap, SHR_NEVER, &alginfo_a,
535 : 0 : !ses->dir,
536 : 0 : ses->digest_length);
537 : 0 : break;
538 : 0 : case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
539 : 0 : shared_desc_len = cnstr_shdsc_snow_f9(
540 : 0 : cdb->sh_desc, true, swap,
541 : : &alginfo_a,
542 : 0 : !ses->dir,
543 : : ses->digest_length);
544 : 0 : break;
545 : 0 : case RTE_CRYPTO_AUTH_ZUC_EIA3:
546 : 0 : shared_desc_len = cnstr_shdsc_zuca(
547 : 0 : cdb->sh_desc, true, swap,
548 : : &alginfo_a,
549 : 0 : !ses->dir,
550 : : ses->digest_length);
551 : 0 : break;
552 : 0 : case RTE_CRYPTO_AUTH_AES_XCBC_MAC:
553 : : case RTE_CRYPTO_AUTH_AES_CMAC:
554 : 0 : shared_desc_len = cnstr_shdsc_aes_mac(
555 : 0 : cdb->sh_desc,
556 : : true, swap, SHR_NEVER,
557 : : &alginfo_a,
558 : 0 : !ses->dir,
559 : 0 : ses->digest_length);
560 : 0 : break;
561 : 0 : default:
562 : 0 : DPAA_SEC_ERR("unsupported auth alg %s (%u)",
563 : : rte_cryptodev_get_auth_algo_string(ses->auth_alg),
564 : : ses->auth_alg);
565 : : }
566 : : break;
567 : : case DPAA_SEC_AEAD:
568 : : if (alginfo.algtype == (unsigned int)DPAA_SEC_ALG_UNSUPPORT) {
569 : : DPAA_SEC_ERR("not supported aead alg");
570 : : return -ENOTSUP;
571 : : }
572 : 0 : alginfo.key = (size_t)ses->aead_key.data;
573 : 0 : alginfo.keylen = ses->aead_key.length;
574 : : alginfo.key_enc_flags = 0;
575 : 0 : alginfo.key_type = RTA_DATA_IMM;
576 : 0 : alginfo.algtype = ses->aead_key.alg;
577 : 0 : alginfo.algmode = ses->aead_key.algmode;
578 : :
579 [ # # ]: 0 : if (ses->dir == DIR_ENC)
580 : 0 : shared_desc_len = cnstr_shdsc_gcm_encap(
581 : 0 : cdb->sh_desc, true, swap, SHR_NEVER,
582 : : &alginfo,
583 : 0 : ses->iv.length,
584 : : ses->digest_length);
585 : : else
586 : 0 : shared_desc_len = cnstr_shdsc_gcm_decap(
587 : 0 : cdb->sh_desc, true, swap, SHR_NEVER,
588 : : &alginfo,
589 : 0 : ses->iv.length,
590 : : ses->digest_length);
591 : : break;
592 : 0 : case DPAA_SEC_CIPHER_HASH:
593 : 0 : alginfo_c.key = (size_t)ses->cipher_key.data;
594 : 0 : alginfo_c.keylen = ses->cipher_key.length;
595 : : alginfo_c.key_enc_flags = 0;
596 : 0 : alginfo_c.key_type = RTA_DATA_IMM;
597 : 0 : alginfo_c.algtype = ses->cipher_key.alg;
598 : 0 : alginfo_c.algmode = ses->cipher_key.algmode;
599 : :
600 : 0 : alginfo_a.key = (size_t)ses->auth_key.data;
601 : 0 : alginfo_a.keylen = ses->auth_key.length;
602 : : alginfo_a.key_enc_flags = 0;
603 : 0 : alginfo_a.key_type = RTA_DATA_IMM;
604 : 0 : alginfo_a.algtype = ses->auth_key.alg;
605 : 0 : alginfo_a.algmode = ses->auth_key.algmode;
606 : :
607 : 0 : cdb->sh_desc[0] = alginfo_c.keylen;
608 : 0 : cdb->sh_desc[1] = alginfo_a.keylen;
609 : 0 : err = rta_inline_query(IPSEC_AUTH_VAR_AES_DEC_BASE_DESC_LEN,
610 : : DESC_JOB_IO_LEN,
611 : 0 : (unsigned int *)cdb->sh_desc,
612 : : &cdb->sh_desc[2], 2);
613 : :
614 [ # # ]: 0 : if (err < 0) {
615 : 0 : DPAA_SEC_ERR("Crypto: Incorrect key lengths");
616 : 0 : return err;
617 : : }
618 [ # # ]: 0 : if (cdb->sh_desc[2] & 1)
619 : : alginfo_c.key_type = RTA_DATA_IMM;
620 : : else {
621 : 0 : alginfo_c.key = (size_t)rte_dpaa_mem_vtop(
622 : : (void *)(size_t)alginfo_c.key);
623 : 0 : alginfo_c.key_type = RTA_DATA_PTR;
624 : : }
625 [ # # ]: 0 : if (cdb->sh_desc[2] & (1<<1))
626 : 0 : alginfo_a.key_type = RTA_DATA_IMM;
627 : : else {
628 : 0 : alginfo_a.key = (size_t)rte_dpaa_mem_vtop(
629 : 0 : (void *)(size_t)alginfo_a.key);
630 : 0 : alginfo_a.key_type = RTA_DATA_PTR;
631 : : }
632 : 0 : cdb->sh_desc[0] = 0;
633 : 0 : cdb->sh_desc[1] = 0;
634 : 0 : cdb->sh_desc[2] = 0;
635 : : /* Auth_only_len is set as 0 here and it will be
636 : : * overwritten in fd for each packet.
637 : : */
638 : 0 : shared_desc_len = cnstr_shdsc_authenc(cdb->sh_desc,
639 : : true, swap, SHR_SERIAL, &alginfo_c, &alginfo_a,
640 : 0 : ses->iv.length,
641 : 0 : ses->digest_length, ses->dir);
642 : 0 : break;
643 : 0 : default:
644 : 0 : DPAA_SEC_ERR("error: Unsupported session %d", ses->ctxt);
645 : 0 : return -ENOTSUP;
646 : : }
647 : :
648 [ # # ]: 0 : if (shared_desc_len < 0) {
649 : 0 : DPAA_SEC_ERR("error in preparing command block");
650 : 0 : return shared_desc_len;
651 : : }
652 : :
653 : 0 : cdb->sh_hdr.hi.field.idlen = shared_desc_len;
654 [ # # ]: 0 : cdb->sh_hdr.hi.word = rte_cpu_to_be_32(cdb->sh_hdr.hi.word);
655 [ # # ]: 0 : cdb->sh_hdr.lo.word = rte_cpu_to_be_32(cdb->sh_hdr.lo.word);
656 : :
657 : 0 : return 0;
658 : : }
659 : :
660 : : static void
661 : 0 : dpaa_sec_dump(struct dpaa_sec_op_ctx *ctx, struct dpaa_sec_qp *qp, FILE *f)
662 : : {
663 : : struct dpaa_sec_job *job = &ctx->job;
664 : 0 : struct rte_crypto_op *op = ctx->op;
665 : : dpaa_sec_session *sess = NULL;
666 : : struct sec_cdb c_cdb, *cdb;
667 : : uint8_t bufsize;
668 : : struct rte_crypto_sym_op *sym_op;
669 : : struct qm_sg_entry sg[2];
670 : :
671 [ # # ]: 0 : if (op->sess_type == RTE_CRYPTO_OP_WITH_SESSION)
672 : 0 : sess = CRYPTODEV_GET_SYM_SESS_PRIV(op->sym->session);
673 : : #ifdef RTE_LIB_SECURITY
674 [ # # ]: 0 : else if (op->sess_type == RTE_CRYPTO_OP_SECURITY_SESSION)
675 : 0 : sess = SECURITY_GET_SESS_PRIV(op->sym->session);
676 : : #endif
677 : : if (sess == NULL) {
678 : : printf("session is NULL\n");
679 : 0 : goto mbuf_dump;
680 : : }
681 : :
682 [ # # ]: 0 : cdb = &sess->cdb;
683 : : rte_memcpy(&c_cdb, cdb, sizeof(struct sec_cdb));
684 : : #ifdef RTE_LIB_SECURITY
685 : 0 : fprintf(f, "\nsession protocol type = %d\n", sess->proto_alg);
686 : : #endif
687 : 0 : fprintf(f, "\n****************************************\n"
688 : : "session params:\n\tContext type:\t%d\n\tDirection:\t%s\n"
689 : : "\tCipher alg:\t%d\n\tAuth alg:\t%d\n\tAead alg:\t%d\n"
690 : : "\tCipher key len:\t%"PRIu64"\n\tCipher alg:\t%d\n"
691 : 0 : "\tCipher algmode:\t%d\n", sess->ctxt,
692 : 0 : (sess->dir == DIR_ENC) ? "DIR_ENC" : "DIR_DEC",
693 : 0 : sess->cipher_alg, sess->auth_alg, sess->aead_alg,
694 [ # # ]: 0 : (uint64_t)sess->cipher_key.length, sess->cipher_key.alg,
695 : : sess->cipher_key.algmode);
696 : 0 : rte_hexdump(f, "cipher key", sess->cipher_key.data,
697 : 0 : sess->cipher_key.length);
698 : 0 : rte_hexdump(f, "auth key", sess->auth_key.data,
699 : 0 : sess->auth_key.length);
700 : 0 : fprintf(f, "\tAuth key len:\t%"PRIu64"\n\tAuth alg:\t%d\n"
701 : : "\tAuth algmode:\t%d\n\tIV len:\t\t%d\n\tIV offset:\t%d\n"
702 : : "\tdigest length:\t%d\n\tauth only len:\t\t%d\n"
703 : : "\taead cipher text:\t%d\n",
704 : 0 : (uint64_t)sess->auth_key.length, sess->auth_key.alg,
705 : : sess->auth_key.algmode,
706 : 0 : sess->iv.length, sess->iv.offset,
707 : 0 : sess->digest_length, sess->auth_only_len,
708 : 0 : sess->auth_cipher_text);
709 : : #ifdef RTE_LIB_SECURITY
710 : 0 : fprintf(f, "PDCP session params:\n"
711 : : "\tDomain:\t\t%d\n\tBearer:\t\t%d\n\tpkt_dir:\t%d\n\thfn_ovd:"
712 : : "\t%d\n\tsn_size:\t%d\n\tsdap_enabled:\t%d\n\thfn_ovd_offset:"
713 : : "\t%d\n\thfn:\t\t%d\n"
714 : 0 : "\thfn_threshold:\t0x%x\n", sess->pdcp.domain,
715 : 0 : sess->pdcp.bearer, sess->pdcp.pkt_dir, sess->pdcp.hfn_ovd,
716 : 0 : sess->pdcp.sn_size, sess->pdcp.sdap_enabled,
717 : 0 : sess->pdcp.hfn_ovd_offset, sess->pdcp.hfn,
718 : : sess->pdcp.hfn_threshold);
719 : : #endif
720 [ # # ]: 0 : c_cdb.sh_hdr.hi.word = rte_be_to_cpu_32(c_cdb.sh_hdr.hi.word);
721 [ # # ]: 0 : c_cdb.sh_hdr.lo.word = rte_be_to_cpu_32(c_cdb.sh_hdr.lo.word);
722 : 0 : bufsize = c_cdb.sh_hdr.hi.field.idlen;
723 : :
724 : : fprintf(f, "cdb = %p\n\n", cdb);
725 : 0 : fprintf(f, "Descriptor size = %d\n", bufsize);
726 : : int m;
727 [ # # ]: 0 : for (m = 0; m < bufsize; m++)
728 [ # # ]: 0 : fprintf(f, "0x%x\n", rte_be_to_cpu_32(c_cdb.sh_desc[m]));
729 : :
730 : : fprintf(f, "\n");
731 : 0 : mbuf_dump:
732 : : sym_op = op->sym;
733 [ # # ]: 0 : if (sym_op->m_src) {
734 : : fprintf(f, "Source mbuf:\n");
735 : 0 : rte_pktmbuf_dump(f, sym_op->m_src,
736 : 0 : sym_op->m_src->data_len);
737 : : }
738 [ # # ]: 0 : if (sym_op->m_dst) {
739 : : fprintf(f, "Destination mbuf:\n");
740 : 0 : rte_pktmbuf_dump(f, sym_op->m_dst,
741 : 0 : sym_op->m_dst->data_len);
742 : : }
743 : :
744 : 0 : fprintf(f, "Session address = %p\ncipher offset: %d, length: %d\n"
745 : : "auth offset: %d, length: %d\n aead offset: %d, length: %d\n",
746 : : sym_op->session, sym_op->cipher.data.offset,
747 : : sym_op->cipher.data.length,
748 : : sym_op->auth.data.offset, sym_op->auth.data.length,
749 : : sym_op->aead.data.offset, sym_op->aead.data.length);
750 : : fprintf(f, "\n");
751 : :
752 : : fprintf(f, "******************************************************\n");
753 : : fprintf(f, "ctx info:\n");
754 : : fprintf(f, "job->sg[0] output info:\n");
755 : : memcpy(&sg[0], &job->sg[0], sizeof(sg[0]));
756 : 0 : fprintf(f, "\taddr = %"PRIx64",\n\tlen = %d,\n\tfinal = %d,\n\textension = %d"
757 : : "\n\tbpid = %d\n\toffset = %d\n",
758 : 0 : (uint64_t)sg[0].addr, sg[0].length, sg[0].final,
759 : 0 : sg[0].extension, sg[0].bpid, sg[0].offset);
760 : : fprintf(f, "\njob->sg[1] input info:\n");
761 : : memcpy(&sg[1], &job->sg[1], sizeof(sg[1]));
762 : 0 : hw_sg_to_cpu(&sg[1]);
763 : 0 : fprintf(f, "\taddr = %"PRIx64",\n\tlen = %d,\n\tfinal = %d,\n\textension = %d"
764 : : "\n\tbpid = %d\n\toffset = %d\n",
765 : 0 : (uint64_t)sg[1].addr, sg[1].length, sg[1].final,
766 : 0 : sg[1].extension, sg[1].bpid, sg[1].offset);
767 : :
768 : 0 : fprintf(f, "\nctx pool addr = %p\n", ctx->ctx_pool);
769 [ # # ]: 0 : if (ctx->ctx_pool)
770 : 0 : fprintf(f, "ctx pool available counts = %d\n",
771 : : rte_mempool_avail_count(ctx->ctx_pool));
772 : :
773 : 0 : fprintf(f, "\nop pool addr = %p\n", op->mempool);
774 [ # # ]: 0 : if (op->mempool)
775 : 0 : fprintf(f, "op pool available counts = %d\n",
776 : : rte_mempool_avail_count(op->mempool));
777 : :
778 : : fprintf(f, "********************************************************\n");
779 : : fprintf(f, "Queue data:\n");
780 : 0 : fprintf(f, "\tFQID = 0x%x\n\tstate = %d\n\tnb_desc = %d\n"
781 : : "\tctx_pool = %p\n\trx_pkts = %d\n\ttx_pkts"
782 : : "= %d\n\trx_errs = %d\n\ttx_errs = %d\n\n",
783 : 0 : qp->outq.fqid, qp->outq.state, qp->outq.nb_desc,
784 : : qp->ctx_pool, qp->rx_pkts, qp->tx_pkts,
785 : : qp->rx_errs, qp->tx_errs);
786 : 0 : }
787 : :
788 : : /* qp is lockless, should be accessed by only one thread */
789 : : static int
790 : 0 : dpaa_sec_deq(struct dpaa_sec_qp *qp, struct rte_crypto_op **ops, int nb_ops)
791 : : {
792 : : struct qman_fq *fq;
793 : : unsigned int pkts = 0;
794 : : int num_rx_bufs, ret;
795 : : struct qm_dqrr_entry *dq;
796 : : uint32_t vdqcr_flags = 0;
797 : :
798 : 0 : fq = &qp->outq;
799 : : /*
800 : : * Until request for four buffers, we provide exact number of buffers.
801 : : * Otherwise we do not set the QM_VDQCR_EXACT flag.
802 : : * Not setting QM_VDQCR_EXACT flag can provide two more buffers than
803 : : * requested, so we request two less in this case.
804 : : */
805 [ # # ]: 0 : if (nb_ops < 4) {
806 : : vdqcr_flags = QM_VDQCR_EXACT;
807 : : num_rx_bufs = nb_ops;
808 : : } else {
809 : 0 : num_rx_bufs = nb_ops > DPAA_MAX_DEQUEUE_NUM_FRAMES ?
810 : 0 : (DPAA_MAX_DEQUEUE_NUM_FRAMES - 2) : (nb_ops - 2);
811 : : }
812 : 0 : ret = qman_set_vdq(fq, num_rx_bufs, vdqcr_flags);
813 [ # # ]: 0 : if (ret)
814 : : return 0;
815 : :
816 : : do {
817 : : const struct qm_fd *fd;
818 : : struct dpaa_sec_job *job;
819 : : struct dpaa_sec_op_ctx *ctx;
820 : : struct rte_crypto_op *op;
821 : :
822 : 0 : dq = qman_dequeue(fq);
823 [ # # ]: 0 : if (!dq)
824 : 0 : continue;
825 : :
826 : : fd = &dq->fd;
827 : : /* sg is embedded in an op ctx,
828 : : * sg[0] is for output
829 : : * sg[1] for input
830 : : */
831 : 0 : job = rte_dpaa_mem_ptov(qm_fd_addr_get64(fd));
832 : :
833 : : ctx = container_of(job, struct dpaa_sec_op_ctx, job);
834 : 0 : ctx->fd_status = fd->status;
835 : 0 : op = ctx->op;
836 [ # # ]: 0 : if (op->sess_type == RTE_CRYPTO_OP_SECURITY_SESSION) {
837 : : struct qm_sg_entry *sg_out;
838 : : uint32_t len;
839 : 0 : struct rte_mbuf *mbuf = (op->sym->m_dst == NULL) ?
840 [ # # ]: 0 : op->sym->m_src : op->sym->m_dst;
841 : :
842 : 0 : sg_out = &job->sg[0];
843 : 0 : hw_sg_to_cpu(sg_out);
844 : 0 : len = sg_out->length;
845 : 0 : mbuf->pkt_len = len;
846 [ # # ]: 0 : while (mbuf->next != NULL) {
847 : 0 : len -= mbuf->data_len;
848 : : mbuf = mbuf->next;
849 : : }
850 : 0 : mbuf->data_len = len;
851 : : }
852 [ # # ]: 0 : if (!ctx->fd_status) {
853 : 0 : op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
854 : : } else {
855 [ # # ]: 0 : if (dpaa_sec_dp_dump > DPAA_SEC_DP_NO_DUMP) {
856 : 0 : DPAA_SEC_DP_WARN("SEC return err:0x%x",
857 : : ctx->fd_status);
858 [ # # ]: 0 : if (dpaa_sec_dp_dump > DPAA_SEC_DP_ERR_DUMP)
859 : 0 : dpaa_sec_dump(ctx, qp, stdout);
860 : : }
861 : 0 : op->status = RTE_CRYPTO_OP_STATUS_ERROR;
862 : : }
863 : 0 : ops[pkts++] = op;
864 : :
865 : : /* report op status to sym->op and then free the ctx memory */
866 [ # # ]: 0 : rte_mempool_put(ctx->ctx_pool, (void *)ctx);
867 : :
868 : 0 : qman_dqrr_consume(fq, dq);
869 [ # # ]: 0 : } while (fq->flags & QMAN_FQ_STATE_VDQCR);
870 : :
871 : 0 : return pkts;
872 : : }
873 : :
874 : : static inline struct dpaa_sec_job *
875 : 0 : build_auth_only_sg(struct rte_crypto_op *op, dpaa_sec_session *ses)
876 : : {
877 : : struct rte_crypto_sym_op *sym = op->sym;
878 : 0 : struct rte_mbuf *mbuf = sym->m_src;
879 : : struct dpaa_sec_job *cf;
880 : : struct dpaa_sec_op_ctx *ctx;
881 : : struct qm_sg_entry *sg, *out_sg, *in_sg;
882 : : phys_addr_t start_addr;
883 : : uint8_t *old_digest, extra_segs;
884 : : int data_len, data_offset;
885 : :
886 : 0 : data_len = sym->auth.data.length;
887 : 0 : data_offset = sym->auth.data.offset;
888 : :
889 [ # # ]: 0 : if (ses->auth_alg == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
890 : : ses->auth_alg == RTE_CRYPTO_AUTH_ZUC_EIA3) {
891 [ # # # # ]: 0 : if ((data_len & 7) || (data_offset & 7)) {
892 : 0 : DPAA_SEC_ERR("AUTH: len/offset must be full bytes");
893 : 0 : return NULL;
894 : : }
895 : :
896 : 0 : data_len = data_len >> 3;
897 : 0 : data_offset = data_offset >> 3;
898 : : }
899 : :
900 [ # # ]: 0 : if (is_decode(ses))
901 : : extra_segs = 3;
902 : : else
903 : : extra_segs = 2;
904 : :
905 [ # # ]: 0 : if (mbuf->nb_segs > MAX_SG_ENTRIES) {
906 : 0 : DPAA_SEC_DP_ERR("Auth: Max sec segs supported is %d",
907 : : MAX_SG_ENTRIES);
908 : 0 : return NULL;
909 : : }
910 : 0 : ctx = dpaa_sec_alloc_ctx(ses, mbuf->nb_segs + extra_segs);
911 [ # # ]: 0 : if (!ctx)
912 : : return NULL;
913 : :
914 : 0 : cf = &ctx->job;
915 : 0 : ctx->op = op;
916 : 0 : old_digest = ctx->digest;
917 : :
918 : : /* output */
919 : 0 : out_sg = &cf->sg[0];
920 : 0 : qm_sg_entry_set64(out_sg, sym->auth.digest.phys_addr);
921 : 0 : out_sg->length = ses->digest_length;
922 : 0 : cpu_to_hw_sg(out_sg);
923 : :
924 : : /* input */
925 : 0 : in_sg = &cf->sg[1];
926 : : /* need to extend the input to a compound frame */
927 : 0 : in_sg->extension = 1;
928 : 0 : in_sg->final = 1;
929 : 0 : in_sg->length = data_len;
930 : 0 : qm_sg_entry_set64(in_sg, rte_dpaa_mem_vtop(&cf->sg[2]));
931 : :
932 : : /* 1st seg */
933 : 0 : sg = in_sg + 1;
934 : :
935 [ # # ]: 0 : if (ses->iv.length) {
936 : : uint8_t *iv_ptr;
937 : :
938 : 0 : iv_ptr = rte_crypto_op_ctod_offset(op, uint8_t *,
939 : : ses->iv.offset);
940 : :
941 [ # # ]: 0 : if (ses->auth_alg == RTE_CRYPTO_AUTH_SNOW3G_UIA2) {
942 : : iv_ptr = conv_to_snow_f9_iv(iv_ptr);
943 : 0 : sg->length = 12;
944 [ # # ]: 0 : } else if (ses->auth_alg == RTE_CRYPTO_AUTH_ZUC_EIA3) {
945 : : iv_ptr = conv_to_zuc_eia_iv(iv_ptr);
946 : 0 : sg->length = 8;
947 : : } else {
948 : 0 : sg->length = ses->iv.length;
949 : : }
950 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(iv_ptr));
951 : 0 : in_sg->length += sg->length;
952 : 0 : cpu_to_hw_sg(sg);
953 : 0 : sg++;
954 : : }
955 : :
956 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
957 : 0 : sg->offset = data_offset;
958 : :
959 [ # # ]: 0 : if (data_len <= (mbuf->data_len - data_offset)) {
960 : 0 : sg->length = data_len;
961 : : } else {
962 : 0 : sg->length = mbuf->data_len - data_offset;
963 : :
964 : : /* remaining i/p segs */
965 [ # # ]: 0 : while ((data_len = data_len - sg->length) &&
966 [ # # ]: 0 : (mbuf = mbuf->next)) {
967 : 0 : cpu_to_hw_sg(sg);
968 [ # # ]: 0 : sg++;
969 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
970 [ # # ]: 0 : if (data_len > mbuf->data_len)
971 : 0 : sg->length = mbuf->data_len;
972 : : else
973 : 0 : sg->length = data_len;
974 : : }
975 : : }
976 : :
977 [ # # ]: 0 : if (is_decode(ses)) {
978 : : /* Digest verification case */
979 : 0 : cpu_to_hw_sg(sg);
980 : 0 : sg++;
981 : 0 : rte_memcpy(old_digest, sym->auth.digest.data,
982 [ # # ]: 0 : ses->digest_length);
983 : : start_addr = rte_dpaa_mem_vtop(old_digest);
984 : 0 : qm_sg_entry_set64(sg, start_addr);
985 : 0 : sg->length = ses->digest_length;
986 : 0 : in_sg->length += ses->digest_length;
987 : : }
988 : 0 : sg->final = 1;
989 : 0 : cpu_to_hw_sg(sg);
990 : 0 : cpu_to_hw_sg(in_sg);
991 : :
992 : 0 : return cf;
993 : : }
994 : :
995 : : /**
996 : : * packet looks like:
997 : : * |<----data_len------->|
998 : : * |ip_header|ah_header|icv|payload|
999 : : * ^
1000 : : * |
1001 : : * mbuf->pkt.data
1002 : : */
1003 : : static inline struct dpaa_sec_job *
1004 : 0 : build_auth_only(struct rte_crypto_op *op, dpaa_sec_session *ses)
1005 : : {
1006 : : struct rte_crypto_sym_op *sym = op->sym;
1007 : 0 : struct rte_mbuf *mbuf = sym->m_src;
1008 : : struct dpaa_sec_job *cf;
1009 : : struct dpaa_sec_op_ctx *ctx;
1010 : : struct qm_sg_entry *sg, *in_sg;
1011 : : rte_iova_t start_addr;
1012 : : uint8_t *old_digest;
1013 : : int data_len, data_offset;
1014 : :
1015 : 0 : data_len = sym->auth.data.length;
1016 : 0 : data_offset = sym->auth.data.offset;
1017 : :
1018 [ # # ]: 0 : if (ses->auth_alg == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
1019 : : ses->auth_alg == RTE_CRYPTO_AUTH_ZUC_EIA3) {
1020 [ # # # # ]: 0 : if ((data_len & 7) || (data_offset & 7)) {
1021 : 0 : DPAA_SEC_ERR("AUTH: len/offset must be full bytes");
1022 : 0 : return NULL;
1023 : : }
1024 : :
1025 : 0 : data_len = data_len >> 3;
1026 : 0 : data_offset = data_offset >> 3;
1027 : : }
1028 : :
1029 : 0 : ctx = dpaa_sec_alloc_ctx(ses, 4);
1030 [ # # ]: 0 : if (!ctx)
1031 : : return NULL;
1032 : :
1033 : 0 : cf = &ctx->job;
1034 : 0 : ctx->op = op;
1035 : 0 : old_digest = ctx->digest;
1036 : :
1037 : : start_addr = rte_pktmbuf_iova(mbuf);
1038 : : /* output */
1039 : 0 : sg = &cf->sg[0];
1040 : 0 : qm_sg_entry_set64(sg, sym->auth.digest.phys_addr);
1041 : 0 : sg->length = ses->digest_length;
1042 : 0 : cpu_to_hw_sg(sg);
1043 : :
1044 : : /* input */
1045 : 0 : in_sg = &cf->sg[1];
1046 : : /* need to extend the input to a compound frame */
1047 : 0 : in_sg->extension = 1;
1048 : 0 : in_sg->final = 1;
1049 : 0 : in_sg->length = data_len;
1050 : 0 : qm_sg_entry_set64(in_sg, rte_dpaa_mem_vtop(&cf->sg[2]));
1051 : : sg = &cf->sg[2];
1052 : :
1053 [ # # ]: 0 : if (ses->iv.length) {
1054 : : uint8_t *iv_ptr;
1055 : :
1056 : 0 : iv_ptr = rte_crypto_op_ctod_offset(op, uint8_t *,
1057 : : ses->iv.offset);
1058 : :
1059 [ # # ]: 0 : if (ses->auth_alg == RTE_CRYPTO_AUTH_SNOW3G_UIA2) {
1060 : : iv_ptr = conv_to_snow_f9_iv(iv_ptr);
1061 : 0 : sg->length = 12;
1062 [ # # ]: 0 : } else if (ses->auth_alg == RTE_CRYPTO_AUTH_ZUC_EIA3) {
1063 : : iv_ptr = conv_to_zuc_eia_iv(iv_ptr);
1064 : 0 : sg->length = 8;
1065 : : } else {
1066 : 0 : sg->length = ses->iv.length;
1067 : : }
1068 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(iv_ptr));
1069 : 0 : in_sg->length += sg->length;
1070 : 0 : cpu_to_hw_sg(sg);
1071 : 0 : sg++;
1072 : : }
1073 : :
1074 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1075 : 0 : sg->offset = data_offset;
1076 : 0 : sg->length = data_len;
1077 : :
1078 [ # # ]: 0 : if (is_decode(ses)) {
1079 : : /* Digest verification case */
1080 : 0 : cpu_to_hw_sg(sg);
1081 : : /* hash result or digest, save digest first */
1082 : 0 : rte_memcpy(old_digest, sym->auth.digest.data,
1083 [ # # ]: 0 : ses->digest_length);
1084 : : /* let's check digest by hw */
1085 : : start_addr = rte_dpaa_mem_vtop(old_digest);
1086 : 0 : sg++;
1087 : 0 : qm_sg_entry_set64(sg, start_addr);
1088 : 0 : sg->length = ses->digest_length;
1089 : 0 : in_sg->length += ses->digest_length;
1090 : : }
1091 : 0 : sg->final = 1;
1092 : 0 : cpu_to_hw_sg(sg);
1093 : 0 : cpu_to_hw_sg(in_sg);
1094 : :
1095 : 0 : return cf;
1096 : : }
1097 : :
1098 : : static inline struct dpaa_sec_job *
1099 : 0 : build_cipher_only_sg(struct rte_crypto_op *op, dpaa_sec_session *ses)
1100 : : {
1101 : : struct rte_crypto_sym_op *sym = op->sym;
1102 : : struct dpaa_sec_job *cf;
1103 : : struct dpaa_sec_op_ctx *ctx;
1104 : : struct qm_sg_entry *sg, *out_sg, *in_sg;
1105 : : struct rte_mbuf *mbuf;
1106 : : uint8_t req_segs;
1107 : 0 : uint8_t *IV_ptr = rte_crypto_op_ctod_offset(op, uint8_t *,
1108 : : ses->iv.offset);
1109 : : int data_len, data_offset;
1110 : :
1111 : 0 : data_len = sym->cipher.data.length;
1112 : 0 : data_offset = sym->cipher.data.offset;
1113 : :
1114 [ # # ]: 0 : if (ses->cipher_alg == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
1115 : : ses->cipher_alg == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
1116 [ # # # # ]: 0 : if ((data_len & 7) || (data_offset & 7)) {
1117 : 0 : DPAA_SEC_ERR("CIPHER: len/offset must be full bytes");
1118 : 0 : return NULL;
1119 : : }
1120 : :
1121 : 0 : data_len = data_len >> 3;
1122 : 0 : data_offset = data_offset >> 3;
1123 : : }
1124 : :
1125 [ # # ]: 0 : if (sym->m_dst) {
1126 : : mbuf = sym->m_dst;
1127 : 0 : req_segs = mbuf->nb_segs + sym->m_src->nb_segs + 3;
1128 : : } else {
1129 : 0 : mbuf = sym->m_src;
1130 : 0 : req_segs = mbuf->nb_segs * 2 + 3;
1131 : : }
1132 [ # # ]: 0 : if (mbuf->nb_segs > MAX_SG_ENTRIES) {
1133 : 0 : DPAA_SEC_DP_ERR("Cipher: Max sec segs supported is %d",
1134 : : MAX_SG_ENTRIES);
1135 : 0 : return NULL;
1136 : : }
1137 : :
1138 : 0 : ctx = dpaa_sec_alloc_ctx(ses, req_segs);
1139 [ # # ]: 0 : if (!ctx)
1140 : : return NULL;
1141 : :
1142 : 0 : cf = &ctx->job;
1143 : 0 : ctx->op = op;
1144 : :
1145 : : /* output */
1146 : 0 : out_sg = &cf->sg[0];
1147 : 0 : out_sg->extension = 1;
1148 : 0 : out_sg->length = data_len;
1149 : 0 : qm_sg_entry_set64(out_sg, rte_dpaa_mem_vtop(&cf->sg[2]));
1150 : 0 : cpu_to_hw_sg(out_sg);
1151 : :
1152 : : /* 1st seg */
1153 : : sg = &cf->sg[2];
1154 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1155 : 0 : sg->length = mbuf->data_len - data_offset;
1156 : 0 : sg->offset = data_offset;
1157 : :
1158 : : /* Successive segs */
1159 : 0 : mbuf = mbuf->next;
1160 [ # # ]: 0 : while (mbuf) {
1161 : 0 : cpu_to_hw_sg(sg);
1162 : 0 : sg++;
1163 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1164 : 0 : sg->length = mbuf->data_len;
1165 : 0 : mbuf = mbuf->next;
1166 : : }
1167 : 0 : sg->final = 1;
1168 : 0 : cpu_to_hw_sg(sg);
1169 : :
1170 : : /* input */
1171 : 0 : mbuf = sym->m_src;
1172 : 0 : in_sg = &cf->sg[1];
1173 : 0 : in_sg->extension = 1;
1174 : 0 : in_sg->final = 1;
1175 : 0 : in_sg->length = data_len + ses->iv.length;
1176 : :
1177 : 0 : sg++;
1178 : 0 : qm_sg_entry_set64(in_sg, rte_dpaa_mem_vtop(sg));
1179 : 0 : cpu_to_hw_sg(in_sg);
1180 : :
1181 : : /* IV */
1182 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(IV_ptr));
1183 : 0 : sg->length = ses->iv.length;
1184 : 0 : cpu_to_hw_sg(sg);
1185 : :
1186 : : /* 1st seg */
1187 : 0 : sg++;
1188 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1189 : 0 : sg->length = mbuf->data_len - data_offset;
1190 : 0 : sg->offset = data_offset;
1191 : :
1192 : : /* Successive segs */
1193 : 0 : mbuf = mbuf->next;
1194 [ # # ]: 0 : while (mbuf) {
1195 : 0 : cpu_to_hw_sg(sg);
1196 : 0 : sg++;
1197 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1198 : 0 : sg->length = mbuf->data_len;
1199 : 0 : mbuf = mbuf->next;
1200 : : }
1201 : 0 : sg->final = 1;
1202 : 0 : cpu_to_hw_sg(sg);
1203 : :
1204 : 0 : return cf;
1205 : : }
1206 : :
1207 : : static inline struct dpaa_sec_job *
1208 : 0 : build_cipher_only(struct rte_crypto_op *op, dpaa_sec_session *ses)
1209 : : {
1210 : : struct rte_crypto_sym_op *sym = op->sym;
1211 : : struct dpaa_sec_job *cf;
1212 : : struct dpaa_sec_op_ctx *ctx;
1213 : : struct qm_sg_entry *sg;
1214 : : rte_iova_t src_start_addr, dst_start_addr;
1215 : 0 : uint8_t *IV_ptr = rte_crypto_op_ctod_offset(op, uint8_t *,
1216 : : ses->iv.offset);
1217 : : int data_len, data_offset;
1218 : :
1219 : 0 : data_len = sym->cipher.data.length;
1220 : 0 : data_offset = sym->cipher.data.offset;
1221 : :
1222 [ # # ]: 0 : if (ses->cipher_alg == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
1223 : : ses->cipher_alg == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
1224 [ # # # # ]: 0 : if ((data_len & 7) || (data_offset & 7)) {
1225 : 0 : DPAA_SEC_ERR("CIPHER: len/offset must be full bytes");
1226 : 0 : return NULL;
1227 : : }
1228 : :
1229 : 0 : data_len = data_len >> 3;
1230 : 0 : data_offset = data_offset >> 3;
1231 : : }
1232 : :
1233 : 0 : ctx = dpaa_sec_alloc_ctx(ses, 4);
1234 [ # # ]: 0 : if (!ctx)
1235 : : return NULL;
1236 : :
1237 : 0 : cf = &ctx->job;
1238 : 0 : ctx->op = op;
1239 : :
1240 [ # # ]: 0 : src_start_addr = rte_pktmbuf_iova(sym->m_src);
1241 : :
1242 [ # # ]: 0 : if (sym->m_dst)
1243 : 0 : dst_start_addr = rte_pktmbuf_iova(sym->m_dst);
1244 : : else
1245 : : dst_start_addr = src_start_addr;
1246 : :
1247 : : /* output */
1248 : 0 : sg = &cf->sg[0];
1249 : 0 : qm_sg_entry_set64(sg, dst_start_addr + data_offset);
1250 : 0 : sg->length = data_len + ses->iv.length;
1251 : 0 : cpu_to_hw_sg(sg);
1252 : :
1253 : : /* input */
1254 : 0 : sg = &cf->sg[1];
1255 : :
1256 : : /* need to extend the input to a compound frame */
1257 : 0 : sg->extension = 1;
1258 : 0 : sg->final = 1;
1259 : 0 : sg->length = data_len + ses->iv.length;
1260 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(&cf->sg[2]));
1261 : 0 : cpu_to_hw_sg(sg);
1262 : :
1263 : : sg = &cf->sg[2];
1264 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(IV_ptr));
1265 : 0 : sg->length = ses->iv.length;
1266 : 0 : cpu_to_hw_sg(sg);
1267 : :
1268 : 0 : sg++;
1269 : 0 : qm_sg_entry_set64(sg, src_start_addr + data_offset);
1270 : 0 : sg->length = data_len;
1271 : 0 : sg->final = 1;
1272 : 0 : cpu_to_hw_sg(sg);
1273 : :
1274 : 0 : return cf;
1275 : : }
1276 : :
1277 : : static inline struct dpaa_sec_job *
1278 : 0 : build_cipher_auth_gcm_sg(struct rte_crypto_op *op, dpaa_sec_session *ses)
1279 : : {
1280 : : struct rte_crypto_sym_op *sym = op->sym;
1281 : : struct dpaa_sec_job *cf;
1282 : : struct dpaa_sec_op_ctx *ctx;
1283 : : struct qm_sg_entry *sg, *out_sg, *in_sg;
1284 : : struct rte_mbuf *mbuf;
1285 : : uint8_t req_segs;
1286 : 0 : uint8_t *IV_ptr = rte_crypto_op_ctod_offset(op, uint8_t *,
1287 : : ses->iv.offset);
1288 : :
1289 [ # # ]: 0 : if (sym->m_dst) {
1290 : : mbuf = sym->m_dst;
1291 : 0 : req_segs = mbuf->nb_segs + sym->m_src->nb_segs + 4;
1292 : : } else {
1293 : 0 : mbuf = sym->m_src;
1294 : 0 : req_segs = mbuf->nb_segs * 2 + 4;
1295 : : }
1296 : :
1297 [ # # ]: 0 : if (ses->auth_only_len)
1298 : 0 : req_segs++;
1299 : :
1300 [ # # ]: 0 : if (mbuf->nb_segs > MAX_SG_ENTRIES) {
1301 : 0 : DPAA_SEC_DP_ERR("AEAD: Max sec segs supported is %d",
1302 : : MAX_SG_ENTRIES);
1303 : 0 : return NULL;
1304 : : }
1305 : :
1306 : 0 : ctx = dpaa_sec_alloc_ctx(ses, req_segs);
1307 [ # # ]: 0 : if (!ctx)
1308 : : return NULL;
1309 : :
1310 : 0 : cf = &ctx->job;
1311 : 0 : ctx->op = op;
1312 : :
1313 : 0 : rte_prefetch0(cf->sg);
1314 : :
1315 : : /* output */
1316 : : out_sg = &cf->sg[0];
1317 : 0 : out_sg->extension = 1;
1318 [ # # ]: 0 : if (is_encode(ses))
1319 : 0 : out_sg->length = sym->aead.data.length + ses->digest_length;
1320 : : else
1321 : 0 : out_sg->length = sym->aead.data.length;
1322 : :
1323 : : /* output sg entries */
1324 : 0 : sg = &cf->sg[2];
1325 : 0 : qm_sg_entry_set64(out_sg, rte_dpaa_mem_vtop(sg));
1326 : 0 : cpu_to_hw_sg(out_sg);
1327 : :
1328 : : /* 1st seg */
1329 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1330 : 0 : sg->length = mbuf->data_len - sym->aead.data.offset;
1331 : 0 : sg->offset = sym->aead.data.offset;
1332 : :
1333 : : /* Successive segs */
1334 : 0 : mbuf = mbuf->next;
1335 [ # # ]: 0 : while (mbuf) {
1336 : 0 : cpu_to_hw_sg(sg);
1337 : 0 : sg++;
1338 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1339 : 0 : sg->length = mbuf->data_len;
1340 : 0 : mbuf = mbuf->next;
1341 : : }
1342 : 0 : sg->length -= ses->digest_length;
1343 : :
1344 [ # # ]: 0 : if (is_encode(ses)) {
1345 : 0 : cpu_to_hw_sg(sg);
1346 : : /* set auth output */
1347 : 0 : sg++;
1348 : 0 : qm_sg_entry_set64(sg, sym->aead.digest.phys_addr);
1349 : 0 : sg->length = ses->digest_length;
1350 : : }
1351 : 0 : sg->final = 1;
1352 : 0 : cpu_to_hw_sg(sg);
1353 : :
1354 : : /* input */
1355 : 0 : mbuf = sym->m_src;
1356 : 0 : in_sg = &cf->sg[1];
1357 : 0 : in_sg->extension = 1;
1358 : 0 : in_sg->final = 1;
1359 [ # # ]: 0 : if (is_encode(ses))
1360 : 0 : in_sg->length = ses->iv.length + sym->aead.data.length
1361 : 0 : + ses->auth_only_len;
1362 : : else
1363 : 0 : in_sg->length = ses->iv.length + sym->aead.data.length
1364 : 0 : + ses->auth_only_len + ses->digest_length;
1365 : :
1366 : : /* input sg entries */
1367 : 0 : sg++;
1368 : 0 : qm_sg_entry_set64(in_sg, rte_dpaa_mem_vtop(sg));
1369 : 0 : cpu_to_hw_sg(in_sg);
1370 : :
1371 : : /* 1st seg IV */
1372 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(IV_ptr));
1373 : 0 : sg->length = ses->iv.length;
1374 : 0 : cpu_to_hw_sg(sg);
1375 : :
1376 : : /* 2nd seg auth only */
1377 [ # # ]: 0 : if (ses->auth_only_len) {
1378 : 0 : sg++;
1379 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(sym->aead.aad.data));
1380 : 0 : sg->length = ses->auth_only_len;
1381 : 0 : cpu_to_hw_sg(sg);
1382 : : }
1383 : :
1384 : : /* 3rd seg */
1385 : 0 : sg++;
1386 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1387 : 0 : sg->length = mbuf->data_len - sym->aead.data.offset;
1388 : 0 : sg->offset = sym->aead.data.offset;
1389 : :
1390 : : /* Successive segs */
1391 : 0 : mbuf = mbuf->next;
1392 [ # # ]: 0 : while (mbuf) {
1393 : 0 : cpu_to_hw_sg(sg);
1394 : 0 : sg++;
1395 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1396 : 0 : sg->length = mbuf->data_len;
1397 : 0 : mbuf = mbuf->next;
1398 : : }
1399 : :
1400 [ # # ]: 0 : if (is_decode(ses)) {
1401 : 0 : cpu_to_hw_sg(sg);
1402 : 0 : sg++;
1403 : 0 : memcpy(ctx->digest, sym->aead.digest.data,
1404 : 0 : ses->digest_length);
1405 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(ctx->digest));
1406 : 0 : sg->length = ses->digest_length;
1407 : : }
1408 : 0 : sg->final = 1;
1409 : 0 : cpu_to_hw_sg(sg);
1410 : :
1411 : 0 : return cf;
1412 : : }
1413 : :
1414 : : static inline struct dpaa_sec_job *
1415 : 0 : build_cipher_auth_gcm(struct rte_crypto_op *op, dpaa_sec_session *ses)
1416 : : {
1417 : : struct rte_crypto_sym_op *sym = op->sym;
1418 : : struct dpaa_sec_job *cf;
1419 : : struct dpaa_sec_op_ctx *ctx;
1420 : : struct qm_sg_entry *sg;
1421 : : uint32_t length = 0;
1422 : : rte_iova_t src_start_addr, dst_start_addr;
1423 : 0 : uint8_t *IV_ptr = rte_crypto_op_ctod_offset(op, uint8_t *,
1424 : : ses->iv.offset);
1425 : :
1426 : 0 : src_start_addr = sym->m_src->buf_iova + sym->m_src->data_off;
1427 : :
1428 [ # # ]: 0 : if (sym->m_dst)
1429 : 0 : dst_start_addr = sym->m_dst->buf_iova + sym->m_dst->data_off;
1430 : : else
1431 : : dst_start_addr = src_start_addr;
1432 : :
1433 : 0 : ctx = dpaa_sec_alloc_ctx(ses, 7);
1434 [ # # ]: 0 : if (!ctx)
1435 : : return NULL;
1436 : :
1437 : 0 : cf = &ctx->job;
1438 : 0 : ctx->op = op;
1439 : :
1440 : : /* input */
1441 : 0 : rte_prefetch0(cf->sg);
1442 : 0 : sg = &cf->sg[2];
1443 : 0 : qm_sg_entry_set64(&cf->sg[1], rte_dpaa_mem_vtop(sg));
1444 [ # # ]: 0 : if (is_encode(ses)) {
1445 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(IV_ptr));
1446 : 0 : sg->length = ses->iv.length;
1447 : 0 : length += sg->length;
1448 : 0 : cpu_to_hw_sg(sg);
1449 : :
1450 : 0 : sg++;
1451 [ # # ]: 0 : if (ses->auth_only_len) {
1452 : 0 : qm_sg_entry_set64(sg,
1453 : : rte_dpaa_mem_vtop(sym->aead.aad.data));
1454 : 0 : sg->length = ses->auth_only_len;
1455 : 0 : length += sg->length;
1456 : 0 : cpu_to_hw_sg(sg);
1457 : 0 : sg++;
1458 : : }
1459 : 0 : qm_sg_entry_set64(sg, src_start_addr + sym->aead.data.offset);
1460 : 0 : sg->length = sym->aead.data.length;
1461 : 0 : length += sg->length;
1462 : 0 : sg->final = 1;
1463 : 0 : cpu_to_hw_sg(sg);
1464 : : } else {
1465 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(IV_ptr));
1466 : 0 : sg->length = ses->iv.length;
1467 : 0 : length += sg->length;
1468 : 0 : cpu_to_hw_sg(sg);
1469 : :
1470 : 0 : sg++;
1471 [ # # ]: 0 : if (ses->auth_only_len) {
1472 : 0 : qm_sg_entry_set64(sg,
1473 : : rte_dpaa_mem_vtop(sym->aead.aad.data));
1474 : 0 : sg->length = ses->auth_only_len;
1475 : 0 : length += sg->length;
1476 : 0 : cpu_to_hw_sg(sg);
1477 : 0 : sg++;
1478 : : }
1479 : 0 : qm_sg_entry_set64(sg, src_start_addr + sym->aead.data.offset);
1480 : 0 : sg->length = sym->aead.data.length;
1481 : 0 : length += sg->length;
1482 : 0 : cpu_to_hw_sg(sg);
1483 : :
1484 : 0 : memcpy(ctx->digest, sym->aead.digest.data,
1485 : 0 : ses->digest_length);
1486 : 0 : sg++;
1487 : :
1488 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(ctx->digest));
1489 : 0 : sg->length = ses->digest_length;
1490 : 0 : length += sg->length;
1491 : 0 : sg->final = 1;
1492 : 0 : cpu_to_hw_sg(sg);
1493 : : }
1494 : : /* input compound frame */
1495 : 0 : cf->sg[1].length = length;
1496 : 0 : cf->sg[1].extension = 1;
1497 : 0 : cf->sg[1].final = 1;
1498 : 0 : cpu_to_hw_sg(&cf->sg[1]);
1499 : :
1500 : : /* output */
1501 : 0 : sg++;
1502 : 0 : qm_sg_entry_set64(&cf->sg[0], rte_dpaa_mem_vtop(sg));
1503 : 0 : qm_sg_entry_set64(sg,
1504 : : dst_start_addr + sym->aead.data.offset);
1505 : 0 : sg->length = sym->aead.data.length;
1506 : 0 : length = sg->length;
1507 [ # # ]: 0 : if (is_encode(ses)) {
1508 : 0 : cpu_to_hw_sg(sg);
1509 : : /* set auth output */
1510 : 0 : sg++;
1511 : 0 : qm_sg_entry_set64(sg, sym->aead.digest.phys_addr);
1512 : 0 : sg->length = ses->digest_length;
1513 : 0 : length += sg->length;
1514 : : }
1515 : 0 : sg->final = 1;
1516 : 0 : cpu_to_hw_sg(sg);
1517 : :
1518 : : /* output compound frame */
1519 : 0 : cf->sg[0].length = length;
1520 : 0 : cf->sg[0].extension = 1;
1521 : 0 : cpu_to_hw_sg(&cf->sg[0]);
1522 : :
1523 : 0 : return cf;
1524 : : }
1525 : :
1526 : : static inline struct dpaa_sec_job *
1527 : 0 : build_cipher_auth_sg(struct rte_crypto_op *op, dpaa_sec_session *ses)
1528 : : {
1529 : : struct rte_crypto_sym_op *sym = op->sym;
1530 : : struct dpaa_sec_job *cf;
1531 : : struct dpaa_sec_op_ctx *ctx;
1532 : : struct qm_sg_entry *sg, *out_sg, *in_sg;
1533 : : struct rte_mbuf *mbuf;
1534 : : uint8_t req_segs;
1535 : 0 : uint8_t *IV_ptr = rte_crypto_op_ctod_offset(op, uint8_t *,
1536 : : ses->iv.offset);
1537 : :
1538 [ # # ]: 0 : if (sym->m_dst) {
1539 : : mbuf = sym->m_dst;
1540 : 0 : req_segs = mbuf->nb_segs + sym->m_src->nb_segs + 4;
1541 : : } else {
1542 : 0 : mbuf = sym->m_src;
1543 : 0 : req_segs = mbuf->nb_segs * 2 + 4;
1544 : : }
1545 : :
1546 [ # # ]: 0 : if (mbuf->nb_segs > MAX_SG_ENTRIES) {
1547 : 0 : DPAA_SEC_DP_ERR("Cipher-Auth: Max sec segs supported is %d",
1548 : : MAX_SG_ENTRIES);
1549 : 0 : return NULL;
1550 : : }
1551 : :
1552 : 0 : ctx = dpaa_sec_alloc_ctx(ses, req_segs);
1553 [ # # ]: 0 : if (!ctx)
1554 : : return NULL;
1555 : :
1556 : 0 : cf = &ctx->job;
1557 : 0 : ctx->op = op;
1558 : :
1559 : 0 : rte_prefetch0(cf->sg);
1560 : :
1561 : : /* output */
1562 : : out_sg = &cf->sg[0];
1563 : 0 : out_sg->extension = 1;
1564 [ # # ]: 0 : if (is_encode(ses))
1565 : 0 : out_sg->length = sym->auth.data.length + ses->digest_length;
1566 : : else
1567 : 0 : out_sg->length = sym->auth.data.length;
1568 : :
1569 : : /* output sg entries */
1570 : 0 : sg = &cf->sg[2];
1571 : 0 : qm_sg_entry_set64(out_sg, rte_dpaa_mem_vtop(sg));
1572 : 0 : cpu_to_hw_sg(out_sg);
1573 : :
1574 : : /* 1st seg */
1575 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1576 : 0 : sg->length = mbuf->data_len - sym->auth.data.offset;
1577 : 0 : sg->offset = sym->auth.data.offset;
1578 : :
1579 : : /* Successive segs */
1580 : 0 : mbuf = mbuf->next;
1581 [ # # ]: 0 : while (mbuf) {
1582 : 0 : cpu_to_hw_sg(sg);
1583 : 0 : sg++;
1584 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1585 : 0 : sg->length = mbuf->data_len;
1586 : 0 : mbuf = mbuf->next;
1587 : : }
1588 : 0 : sg->length -= ses->digest_length;
1589 : :
1590 [ # # ]: 0 : if (is_encode(ses)) {
1591 : 0 : cpu_to_hw_sg(sg);
1592 : : /* set auth output */
1593 : 0 : sg++;
1594 : 0 : qm_sg_entry_set64(sg, sym->auth.digest.phys_addr);
1595 : 0 : sg->length = ses->digest_length;
1596 : : }
1597 : 0 : sg->final = 1;
1598 : 0 : cpu_to_hw_sg(sg);
1599 : :
1600 : : /* input */
1601 : 0 : mbuf = sym->m_src;
1602 : 0 : in_sg = &cf->sg[1];
1603 : 0 : in_sg->extension = 1;
1604 : 0 : in_sg->final = 1;
1605 [ # # ]: 0 : if (is_encode(ses))
1606 : 0 : in_sg->length = ses->iv.length + sym->auth.data.length;
1607 : : else
1608 : 0 : in_sg->length = ses->iv.length + sym->auth.data.length
1609 : 0 : + ses->digest_length;
1610 : :
1611 : : /* input sg entries */
1612 : 0 : sg++;
1613 : 0 : qm_sg_entry_set64(in_sg, rte_dpaa_mem_vtop(sg));
1614 : 0 : cpu_to_hw_sg(in_sg);
1615 : :
1616 : : /* 1st seg IV */
1617 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(IV_ptr));
1618 : 0 : sg->length = ses->iv.length;
1619 : 0 : cpu_to_hw_sg(sg);
1620 : :
1621 : : /* 2nd seg */
1622 : 0 : sg++;
1623 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1624 : 0 : sg->length = mbuf->data_len - sym->auth.data.offset;
1625 : 0 : sg->offset = sym->auth.data.offset;
1626 : :
1627 : : /* Successive segs */
1628 : 0 : mbuf = mbuf->next;
1629 [ # # ]: 0 : while (mbuf) {
1630 : 0 : cpu_to_hw_sg(sg);
1631 : 0 : sg++;
1632 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1633 : 0 : sg->length = mbuf->data_len;
1634 : 0 : mbuf = mbuf->next;
1635 : : }
1636 : :
1637 : 0 : sg->length -= ses->digest_length;
1638 [ # # ]: 0 : if (is_decode(ses)) {
1639 : 0 : cpu_to_hw_sg(sg);
1640 : 0 : sg++;
1641 : 0 : memcpy(ctx->digest, sym->auth.digest.data,
1642 : : ses->digest_length);
1643 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(ctx->digest));
1644 : 0 : sg->length = ses->digest_length;
1645 : : }
1646 : 0 : sg->final = 1;
1647 : 0 : cpu_to_hw_sg(sg);
1648 : :
1649 : 0 : return cf;
1650 : : }
1651 : :
1652 : : static inline struct dpaa_sec_job *
1653 : 0 : build_cipher_auth(struct rte_crypto_op *op, dpaa_sec_session *ses)
1654 : : {
1655 : : struct rte_crypto_sym_op *sym = op->sym;
1656 : : struct dpaa_sec_job *cf;
1657 : : struct dpaa_sec_op_ctx *ctx;
1658 : : struct qm_sg_entry *sg;
1659 : : rte_iova_t src_start_addr, dst_start_addr;
1660 : : uint32_t length = 0;
1661 : 0 : uint8_t *IV_ptr = rte_crypto_op_ctod_offset(op, uint8_t *,
1662 : : ses->iv.offset);
1663 : :
1664 : 0 : src_start_addr = sym->m_src->buf_iova + sym->m_src->data_off;
1665 [ # # ]: 0 : if (sym->m_dst)
1666 : 0 : dst_start_addr = sym->m_dst->buf_iova + sym->m_dst->data_off;
1667 : : else
1668 : : dst_start_addr = src_start_addr;
1669 : :
1670 : 0 : ctx = dpaa_sec_alloc_ctx(ses, 7);
1671 [ # # ]: 0 : if (!ctx)
1672 : : return NULL;
1673 : :
1674 : 0 : cf = &ctx->job;
1675 : 0 : ctx->op = op;
1676 : :
1677 : : /* input */
1678 : 0 : rte_prefetch0(cf->sg);
1679 : 0 : sg = &cf->sg[2];
1680 : 0 : qm_sg_entry_set64(&cf->sg[1], rte_dpaa_mem_vtop(sg));
1681 [ # # ]: 0 : if (is_encode(ses)) {
1682 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(IV_ptr));
1683 : 0 : sg->length = ses->iv.length;
1684 : 0 : length += sg->length;
1685 : 0 : cpu_to_hw_sg(sg);
1686 : :
1687 : 0 : sg++;
1688 : 0 : qm_sg_entry_set64(sg, src_start_addr + sym->auth.data.offset);
1689 : 0 : sg->length = sym->auth.data.length;
1690 : 0 : length += sg->length;
1691 : 0 : sg->final = 1;
1692 : 0 : cpu_to_hw_sg(sg);
1693 : : } else {
1694 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(IV_ptr));
1695 : 0 : sg->length = ses->iv.length;
1696 : 0 : length += sg->length;
1697 : 0 : cpu_to_hw_sg(sg);
1698 : :
1699 : 0 : sg++;
1700 : :
1701 : 0 : qm_sg_entry_set64(sg, src_start_addr + sym->auth.data.offset);
1702 : 0 : sg->length = sym->auth.data.length;
1703 : 0 : length += sg->length;
1704 : 0 : cpu_to_hw_sg(sg);
1705 : :
1706 : 0 : memcpy(ctx->digest, sym->auth.digest.data,
1707 : 0 : ses->digest_length);
1708 : 0 : sg++;
1709 : :
1710 : 0 : qm_sg_entry_set64(sg, rte_dpaa_mem_vtop(ctx->digest));
1711 : 0 : sg->length = ses->digest_length;
1712 : 0 : length += sg->length;
1713 : 0 : sg->final = 1;
1714 : 0 : cpu_to_hw_sg(sg);
1715 : : }
1716 : : /* input compound frame */
1717 : 0 : cf->sg[1].length = length;
1718 : 0 : cf->sg[1].extension = 1;
1719 : 0 : cf->sg[1].final = 1;
1720 : 0 : cpu_to_hw_sg(&cf->sg[1]);
1721 : :
1722 : : /* output */
1723 : 0 : sg++;
1724 : 0 : qm_sg_entry_set64(&cf->sg[0], rte_dpaa_mem_vtop(sg));
1725 : 0 : qm_sg_entry_set64(sg, dst_start_addr + sym->cipher.data.offset);
1726 : 0 : sg->length = sym->cipher.data.length;
1727 : 0 : length = sg->length;
1728 [ # # ]: 0 : if (is_encode(ses)) {
1729 : 0 : cpu_to_hw_sg(sg);
1730 : : /* set auth output */
1731 : 0 : sg++;
1732 : 0 : qm_sg_entry_set64(sg, sym->auth.digest.phys_addr);
1733 : 0 : sg->length = ses->digest_length;
1734 : 0 : length += sg->length;
1735 : : }
1736 : 0 : sg->final = 1;
1737 : 0 : cpu_to_hw_sg(sg);
1738 : :
1739 : : /* output compound frame */
1740 : 0 : cf->sg[0].length = length;
1741 : 0 : cf->sg[0].extension = 1;
1742 : 0 : cpu_to_hw_sg(&cf->sg[0]);
1743 : :
1744 : 0 : return cf;
1745 : : }
1746 : :
1747 : : static inline struct dpaa_sec_job *
1748 : 0 : build_proto(struct rte_crypto_op *op, dpaa_sec_session *ses)
1749 : : {
1750 : : struct rte_crypto_sym_op *sym = op->sym;
1751 : : struct dpaa_sec_job *cf;
1752 : : struct dpaa_sec_op_ctx *ctx;
1753 : : struct qm_sg_entry *sg;
1754 : : phys_addr_t src_start_addr, dst_start_addr;
1755 : :
1756 : 0 : ctx = dpaa_sec_alloc_ctx(ses, 2);
1757 [ # # ]: 0 : if (!ctx)
1758 : : return NULL;
1759 : 0 : cf = &ctx->job;
1760 : 0 : ctx->op = op;
1761 : :
1762 [ # # ]: 0 : src_start_addr = rte_pktmbuf_iova(sym->m_src);
1763 : :
1764 [ # # ]: 0 : if (sym->m_dst)
1765 : 0 : dst_start_addr = rte_pktmbuf_iova(sym->m_dst);
1766 : : else
1767 : : dst_start_addr = src_start_addr;
1768 : :
1769 : : /* input */
1770 : 0 : sg = &cf->sg[1];
1771 : 0 : qm_sg_entry_set64(sg, src_start_addr);
1772 : 0 : sg->length = sym->m_src->pkt_len;
1773 : 0 : sg->final = 1;
1774 : 0 : cpu_to_hw_sg(sg);
1775 : :
1776 : 0 : sym->m_src->packet_type &= ~RTE_PTYPE_L4_MASK;
1777 : : /* output */
1778 : 0 : sg = &cf->sg[0];
1779 : 0 : qm_sg_entry_set64(sg, dst_start_addr);
1780 : 0 : sg->length = sym->m_src->buf_len - sym->m_src->data_off;
1781 : 0 : cpu_to_hw_sg(sg);
1782 : :
1783 : 0 : return cf;
1784 : : }
1785 : :
1786 : : static inline struct dpaa_sec_job *
1787 : 0 : build_proto_sg(struct rte_crypto_op *op, dpaa_sec_session *ses)
1788 : : {
1789 : : struct rte_crypto_sym_op *sym = op->sym;
1790 : : struct dpaa_sec_job *cf;
1791 : : struct dpaa_sec_op_ctx *ctx;
1792 : : struct qm_sg_entry *sg, *out_sg, *in_sg;
1793 : : struct rte_mbuf *mbuf;
1794 : : uint8_t req_segs;
1795 : : uint32_t in_len = 0, out_len = 0;
1796 : :
1797 [ # # ]: 0 : if (sym->m_dst)
1798 : : mbuf = sym->m_dst;
1799 : : else
1800 : 0 : mbuf = sym->m_src;
1801 : :
1802 : 0 : req_segs = mbuf->nb_segs + sym->m_src->nb_segs + 2;
1803 [ # # ]: 0 : if (mbuf->nb_segs > MAX_SG_ENTRIES) {
1804 : 0 : DPAA_SEC_DP_ERR("Proto: Max sec segs supported is %d",
1805 : : MAX_SG_ENTRIES);
1806 : 0 : return NULL;
1807 : : }
1808 : :
1809 : 0 : ctx = dpaa_sec_alloc_ctx(ses, req_segs);
1810 [ # # ]: 0 : if (!ctx)
1811 : : return NULL;
1812 : 0 : cf = &ctx->job;
1813 : 0 : ctx->op = op;
1814 : : /* output */
1815 : 0 : out_sg = &cf->sg[0];
1816 : 0 : out_sg->extension = 1;
1817 : 0 : qm_sg_entry_set64(out_sg, rte_dpaa_mem_vtop(&cf->sg[2]));
1818 : :
1819 : : /* 1st seg */
1820 : : sg = &cf->sg[2];
1821 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1822 : 0 : sg->offset = 0;
1823 : :
1824 : : /* Successive segs */
1825 [ # # ]: 0 : while (mbuf->next) {
1826 : 0 : sg->length = mbuf->data_len;
1827 : 0 : out_len += sg->length;
1828 : : mbuf = mbuf->next;
1829 : 0 : cpu_to_hw_sg(sg);
1830 : 0 : sg++;
1831 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1832 : 0 : sg->offset = 0;
1833 : : }
1834 : 0 : sg->length = mbuf->buf_len - mbuf->data_off;
1835 : 0 : out_len += sg->length;
1836 : 0 : sg->final = 1;
1837 : 0 : cpu_to_hw_sg(sg);
1838 : :
1839 : 0 : out_sg->length = out_len;
1840 : 0 : cpu_to_hw_sg(out_sg);
1841 : :
1842 : : /* input */
1843 : 0 : mbuf = sym->m_src;
1844 : 0 : in_sg = &cf->sg[1];
1845 : 0 : in_sg->extension = 1;
1846 : 0 : in_sg->final = 1;
1847 : 0 : in_len = mbuf->data_len;
1848 : :
1849 : 0 : sg++;
1850 : 0 : qm_sg_entry_set64(in_sg, rte_dpaa_mem_vtop(sg));
1851 : :
1852 : : /* 1st seg */
1853 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1854 : 0 : sg->length = mbuf->data_len;
1855 : 0 : sg->offset = 0;
1856 : :
1857 : : /* Successive segs */
1858 : 0 : mbuf = mbuf->next;
1859 [ # # ]: 0 : while (mbuf) {
1860 : 0 : cpu_to_hw_sg(sg);
1861 : 0 : sg++;
1862 : 0 : qm_sg_entry_set64(sg, rte_pktmbuf_iova(mbuf));
1863 : 0 : sg->length = mbuf->data_len;
1864 : 0 : sg->offset = 0;
1865 : 0 : in_len += sg->length;
1866 : 0 : mbuf = mbuf->next;
1867 : : }
1868 : 0 : sg->final = 1;
1869 : 0 : cpu_to_hw_sg(sg);
1870 : :
1871 : 0 : in_sg->length = in_len;
1872 : 0 : cpu_to_hw_sg(in_sg);
1873 : :
1874 : 0 : sym->m_src->packet_type &= ~RTE_PTYPE_L4_MASK;
1875 : :
1876 : 0 : return cf;
1877 : : }
1878 : :
1879 : : static uint16_t
1880 : 0 : dpaa_sec_enqueue_burst(void *qp, struct rte_crypto_op **ops,
1881 : : uint16_t nb_ops)
1882 : : {
1883 : : /* Function to transmit the frames to given device and queuepair */
1884 : : uint32_t loop;
1885 : : struct dpaa_sec_qp *dpaa_qp = (struct dpaa_sec_qp *)qp;
1886 : : uint16_t num_tx = 0;
1887 : : struct qm_fd fds[DPAA_SEC_BURST], *fd;
1888 : : uint32_t frames_to_send;
1889 : : struct rte_crypto_op *op;
1890 : : struct dpaa_sec_job *cf;
1891 : : dpaa_sec_session *ses;
1892 : : uint16_t auth_hdr_len, auth_tail_len;
1893 : 0 : uint32_t index, flags[DPAA_SEC_BURST] = {0};
1894 : : struct qman_fq *inq[DPAA_SEC_BURST];
1895 : :
1896 [ # # ]: 0 : if (unlikely(!DPAA_PER_LCORE_PORTAL)) {
1897 [ # # ]: 0 : if (rte_dpaa_portal_init((void *)0)) {
1898 : 0 : DPAA_SEC_ERR("Failure in affining portal");
1899 : 0 : return 0;
1900 : : }
1901 : : }
1902 : :
1903 [ # # ]: 0 : while (nb_ops) {
1904 : 0 : frames_to_send = (nb_ops > DPAA_SEC_BURST) ?
1905 : 0 : DPAA_SEC_BURST : nb_ops;
1906 [ # # ]: 0 : for (loop = 0; loop < frames_to_send; loop++) {
1907 : 0 : op = *(ops++);
1908 [ # # ]: 0 : if (*dpaa_seqn(op->sym->m_src) != 0) {
1909 : 0 : index = *dpaa_seqn(op->sym->m_src) - 1;
1910 [ # # ]: 0 : if (DPAA_PER_LCORE_DQRR_HELD & (UINT64_C(1) << index)) {
1911 : : /* QM_EQCR_DCA_IDXMASK = 0x0f */
1912 : 0 : flags[loop] = ((index & 0x0f) << 8);
1913 : 0 : flags[loop] |= QMAN_ENQUEUE_FLAG_DCA;
1914 : 0 : DPAA_PER_LCORE_DQRR_SIZE--;
1915 : 0 : DPAA_PER_LCORE_DQRR_HELD &= ~(UINT64_C(1) << index);
1916 : : }
1917 : : }
1918 : :
1919 [ # # # ]: 0 : switch (op->sess_type) {
1920 : 0 : case RTE_CRYPTO_OP_WITH_SESSION:
1921 : 0 : ses = CRYPTODEV_GET_SYM_SESS_PRIV(op->sym->session);
1922 : 0 : break;
1923 : 0 : case RTE_CRYPTO_OP_SECURITY_SESSION:
1924 : 0 : ses = SECURITY_GET_SESS_PRIV(op->sym->session);
1925 : 0 : break;
1926 : 0 : default:
1927 : 0 : DPAA_SEC_DP_ERR(
1928 : : "sessionless crypto op not supported");
1929 : : frames_to_send = loop;
1930 : 0 : nb_ops = loop;
1931 : 0 : goto send_pkts;
1932 : : }
1933 : :
1934 : : if (!ses) {
1935 : : DPAA_SEC_DP_ERR("session not available");
1936 : : frames_to_send = loop;
1937 : : nb_ops = loop;
1938 : : goto send_pkts;
1939 : : }
1940 : :
1941 [ # # ]: 0 : if (unlikely(!ses->qp[rte_lcore_id() % MAX_DPAA_CORES])) {
1942 [ # # ]: 0 : if (dpaa_sec_attach_sess_q(qp, ses)) {
1943 : : frames_to_send = loop;
1944 : 0 : nb_ops = loop;
1945 : 0 : goto send_pkts;
1946 : : }
1947 [ # # ]: 0 : } else if (unlikely(ses->qp[rte_lcore_id() %
1948 : : MAX_DPAA_CORES] != qp)) {
1949 : 0 : DPAA_SEC_DP_ERR("Old:sess->qp = %p"
1950 : : " New qp = %p",
1951 : : ses->qp[rte_lcore_id() %
1952 : : MAX_DPAA_CORES], qp);
1953 : : frames_to_send = loop;
1954 : 0 : nb_ops = loop;
1955 : 0 : goto send_pkts;
1956 : : }
1957 : :
1958 : 0 : auth_hdr_len = op->sym->auth.data.length -
1959 : 0 : op->sym->cipher.data.length;
1960 : : auth_tail_len = 0;
1961 : :
1962 [ # # ]: 0 : if (rte_pktmbuf_is_contiguous(op->sym->m_src) &&
1963 [ # # # # ]: 0 : ((op->sym->m_dst == NULL) ||
1964 : : rte_pktmbuf_is_contiguous(op->sym->m_dst))) {
1965 [ # # # # : 0 : switch (ses->ctxt) {
# # ]
1966 : 0 : case DPAA_SEC_PDCP:
1967 : : case DPAA_SEC_IPSEC:
1968 : 0 : cf = build_proto(op, ses);
1969 : 0 : break;
1970 : 0 : case DPAA_SEC_AUTH:
1971 : 0 : cf = build_auth_only(op, ses);
1972 : 0 : break;
1973 : 0 : case DPAA_SEC_CIPHER:
1974 : 0 : cf = build_cipher_only(op, ses);
1975 : 0 : break;
1976 : 0 : case DPAA_SEC_AEAD:
1977 : 0 : cf = build_cipher_auth_gcm(op, ses);
1978 : 0 : auth_hdr_len = ses->auth_only_len;
1979 : 0 : break;
1980 : 0 : case DPAA_SEC_CIPHER_HASH:
1981 : 0 : auth_hdr_len =
1982 : 0 : op->sym->cipher.data.offset
1983 : 0 : - op->sym->auth.data.offset;
1984 : 0 : auth_tail_len =
1985 : : op->sym->auth.data.length
1986 : : - op->sym->cipher.data.length
1987 : : - auth_hdr_len;
1988 : 0 : cf = build_cipher_auth(op, ses);
1989 : 0 : break;
1990 : 0 : default:
1991 : 0 : DPAA_SEC_DP_ERR("not supported ops");
1992 : : frames_to_send = loop;
1993 : 0 : nb_ops = loop;
1994 : 0 : goto send_pkts;
1995 : : }
1996 : : } else {
1997 [ # # # # : 0 : switch (ses->ctxt) {
# # ]
1998 : 0 : case DPAA_SEC_PDCP:
1999 : : case DPAA_SEC_IPSEC:
2000 : 0 : cf = build_proto_sg(op, ses);
2001 : 0 : break;
2002 : 0 : case DPAA_SEC_AUTH:
2003 : 0 : cf = build_auth_only_sg(op, ses);
2004 : 0 : break;
2005 : 0 : case DPAA_SEC_CIPHER:
2006 : 0 : cf = build_cipher_only_sg(op, ses);
2007 : 0 : break;
2008 : 0 : case DPAA_SEC_AEAD:
2009 : 0 : cf = build_cipher_auth_gcm_sg(op, ses);
2010 : 0 : auth_hdr_len = ses->auth_only_len;
2011 : 0 : break;
2012 : 0 : case DPAA_SEC_CIPHER_HASH:
2013 : 0 : auth_hdr_len =
2014 : 0 : op->sym->cipher.data.offset
2015 : 0 : - op->sym->auth.data.offset;
2016 : 0 : auth_tail_len =
2017 : : op->sym->auth.data.length
2018 : : - op->sym->cipher.data.length
2019 : : - auth_hdr_len;
2020 : 0 : cf = build_cipher_auth_sg(op, ses);
2021 : 0 : break;
2022 : 0 : default:
2023 : 0 : DPAA_SEC_DP_ERR("not supported ops");
2024 : : frames_to_send = loop;
2025 : 0 : nb_ops = loop;
2026 : 0 : goto send_pkts;
2027 : : }
2028 : : }
2029 [ # # ]: 0 : if (unlikely(!cf)) {
2030 : : frames_to_send = loop;
2031 : 0 : nb_ops = loop;
2032 : 0 : goto send_pkts;
2033 : : }
2034 : :
2035 : : fd = &fds[loop];
2036 : 0 : inq[loop] = ses->inq[rte_lcore_id() % MAX_DPAA_CORES];
2037 : 0 : fd->opaque_addr = 0;
2038 : 0 : fd->cmd = 0;
2039 : 0 : qm_fd_addr_set64(fd, rte_dpaa_mem_vtop(cf->sg));
2040 : 0 : fd->_format1 = qm_fd_compound;
2041 : 0 : fd->length29 = 2 * sizeof(struct qm_sg_entry);
2042 : :
2043 : : /* Auth_only_len is set as 0 in descriptor and it is
2044 : : * overwritten here in the fd.cmd which will update
2045 : : * the DPOVRD reg.
2046 : : */
2047 [ # # ]: 0 : if (auth_hdr_len || auth_tail_len) {
2048 : : fd->cmd = 0x80000000;
2049 : 0 : fd->cmd |=
2050 : 0 : ((auth_tail_len << 16) | auth_hdr_len);
2051 : : }
2052 : :
2053 : : /* In case of PDCP, per packet HFN is stored in
2054 : : * mbuf priv after sym_op.
2055 : : */
2056 [ # # # # ]: 0 : if ((ses->ctxt == DPAA_SEC_PDCP) && ses->pdcp.hfn_ovd) {
2057 : 0 : fd->cmd = 0x80000000 |
2058 : 0 : *((uint32_t *)((uint8_t *)op +
2059 : 0 : ses->pdcp.hfn_ovd_offset));
2060 : : DPAA_SEC_DP_DEBUG("Per packet HFN: %x, ovd:%u",
2061 : : *((uint32_t *)((uint8_t *)op +
2062 : : ses->pdcp.hfn_ovd_offset)),
2063 : : ses->pdcp.hfn_ovd);
2064 : : }
2065 : : }
2066 : 0 : send_pkts:
2067 : : loop = 0;
2068 [ # # ]: 0 : while (loop < frames_to_send) {
2069 : 0 : loop += qman_enqueue_multi_fq(&inq[loop], &fds[loop],
2070 : 0 : &flags[loop], frames_to_send - loop);
2071 : : }
2072 : 0 : nb_ops -= frames_to_send;
2073 : 0 : num_tx += frames_to_send;
2074 : : }
2075 : :
2076 : 0 : dpaa_qp->tx_pkts += num_tx;
2077 : 0 : dpaa_qp->tx_errs += nb_ops - num_tx;
2078 : :
2079 : 0 : return num_tx;
2080 : : }
2081 : :
2082 : : static uint16_t
2083 : 0 : dpaa_sec_dequeue_burst(void *qp, struct rte_crypto_op **ops,
2084 : : uint16_t nb_ops)
2085 : : {
2086 : : uint16_t num_rx;
2087 : : struct dpaa_sec_qp *dpaa_qp = (struct dpaa_sec_qp *)qp;
2088 : :
2089 [ # # ]: 0 : if (unlikely(!DPAA_PER_LCORE_PORTAL)) {
2090 [ # # ]: 0 : if (rte_dpaa_portal_init((void *)0)) {
2091 : 0 : DPAA_SEC_ERR("Failure in affining portal");
2092 : 0 : return 0;
2093 : : }
2094 : : }
2095 : :
2096 : 0 : num_rx = dpaa_sec_deq(dpaa_qp, ops, nb_ops);
2097 : :
2098 : 0 : dpaa_qp->rx_pkts += num_rx;
2099 : 0 : dpaa_qp->rx_errs += nb_ops - num_rx;
2100 : :
2101 : : DPAA_SEC_DP_DEBUG("SEC Received %d Packets", num_rx);
2102 : :
2103 : 0 : return num_rx;
2104 : : }
2105 : :
2106 : : /** Release queue pair */
2107 : : static int
2108 : 0 : dpaa_sec_queue_pair_release(struct rte_cryptodev *dev,
2109 : : uint16_t qp_id)
2110 : : {
2111 : : struct dpaa_sec_dev_private *internals;
2112 : : struct dpaa_sec_qp *qp = NULL;
2113 : :
2114 : 0 : PMD_INIT_FUNC_TRACE();
2115 : :
2116 : 0 : DPAA_SEC_DEBUG("dev =%p, queue =%d", dev, qp_id);
2117 : :
2118 : 0 : internals = dev->data->dev_private;
2119 [ # # ]: 0 : if (qp_id >= internals->max_nb_queue_pairs) {
2120 : 0 : DPAA_SEC_ERR("Max supported qpid %d",
2121 : : internals->max_nb_queue_pairs);
2122 : 0 : return -EINVAL;
2123 : : }
2124 : :
2125 : : qp = &internals->qps[qp_id];
2126 : 0 : rte_mempool_free(qp->ctx_pool);
2127 : 0 : qp->internals = NULL;
2128 : 0 : dev->data->queue_pairs[qp_id] = NULL;
2129 : :
2130 : 0 : return 0;
2131 : : }
2132 : :
2133 : : /** Setup a queue pair */
2134 : : static int
2135 : 0 : dpaa_sec_queue_pair_setup(struct rte_cryptodev *dev, uint16_t qp_id,
2136 : : __rte_unused const struct rte_cryptodev_qp_conf *qp_conf,
2137 : : __rte_unused int socket_id)
2138 : : {
2139 : : struct dpaa_sec_dev_private *internals;
2140 : : struct dpaa_sec_qp *qp = NULL;
2141 : : char str[20];
2142 : :
2143 : 0 : DPAA_SEC_DEBUG("dev =%p, queue =%d, conf =%p", dev, qp_id, qp_conf);
2144 : :
2145 : 0 : internals = dev->data->dev_private;
2146 [ # # ]: 0 : if (qp_id >= internals->max_nb_queue_pairs) {
2147 : 0 : DPAA_SEC_ERR("Max supported qpid %d",
2148 : : internals->max_nb_queue_pairs);
2149 : 0 : return -EINVAL;
2150 : : }
2151 : :
2152 : 0 : qp = &internals->qps[qp_id];
2153 : 0 : qp->internals = internals;
2154 : 0 : snprintf(str, sizeof(str), "ctx_pool_d%d_qp%d",
2155 [ # # ]: 0 : dev->data->dev_id, qp_id);
2156 [ # # ]: 0 : if (!qp->ctx_pool) {
2157 : 0 : qp->ctx_pool = rte_mempool_create((const char *)str,
2158 : : CTX_POOL_NUM_BUFS,
2159 : : CTX_POOL_BUF_SIZE,
2160 : : CTX_POOL_CACHE_SIZE, 0,
2161 : : NULL, NULL, NULL, NULL,
2162 : : SOCKET_ID_ANY, 0);
2163 [ # # ]: 0 : if (!qp->ctx_pool) {
2164 : 0 : DPAA_SEC_ERR("%s create failed", str);
2165 : 0 : return -ENOMEM;
2166 : : }
2167 : : } else
2168 : 0 : DPAA_SEC_INFO("mempool already created for dev_id : %d, qp: %d",
2169 : : dev->data->dev_id, qp_id);
2170 : 0 : dev->data->queue_pairs[qp_id] = qp;
2171 : :
2172 : 0 : return 0;
2173 : : }
2174 : :
2175 : : /** Returns the size of session structure */
2176 : : static unsigned int
2177 : 0 : dpaa_sec_sym_session_get_size(struct rte_cryptodev *dev __rte_unused)
2178 : : {
2179 : 0 : PMD_INIT_FUNC_TRACE();
2180 : :
2181 : 0 : return sizeof(dpaa_sec_session);
2182 : : }
2183 : :
2184 : : static int
2185 : 0 : dpaa_sec_cipher_init(struct rte_cryptodev *dev __rte_unused,
2186 : : struct rte_crypto_sym_xform *xform,
2187 : : dpaa_sec_session *session)
2188 : : {
2189 : 0 : session->ctxt = DPAA_SEC_CIPHER;
2190 : 0 : session->cipher_alg = xform->cipher.algo;
2191 : 0 : session->iv.length = xform->cipher.iv.length;
2192 : 0 : session->iv.offset = xform->cipher.iv.offset;
2193 : 0 : session->cipher_key.data = rte_zmalloc(NULL, xform->cipher.key.length,
2194 : : RTE_CACHE_LINE_SIZE);
2195 [ # # # # ]: 0 : if (session->cipher_key.data == NULL && xform->cipher.key.length > 0) {
2196 : 0 : DPAA_SEC_ERR("No Memory for cipher key");
2197 : 0 : return -ENOMEM;
2198 : : }
2199 : 0 : session->cipher_key.length = xform->cipher.key.length;
2200 : :
2201 [ # # # # : 0 : memcpy(session->cipher_key.data, xform->cipher.key.data,
# # # ]
2202 : : xform->cipher.key.length);
2203 [ # # # # : 0 : switch (xform->cipher.algo) {
# # # ]
2204 : 0 : case RTE_CRYPTO_CIPHER_AES_CBC:
2205 : 0 : session->cipher_key.alg = OP_ALG_ALGSEL_AES;
2206 : 0 : session->cipher_key.algmode = OP_ALG_AAI_CBC;
2207 : 0 : break;
2208 : 0 : case RTE_CRYPTO_CIPHER_DES_CBC:
2209 : 0 : session->cipher_key.alg = OP_ALG_ALGSEL_DES;
2210 : 0 : session->cipher_key.algmode = OP_ALG_AAI_CBC;
2211 : 0 : break;
2212 : 0 : case RTE_CRYPTO_CIPHER_3DES_CBC:
2213 : 0 : session->cipher_key.alg = OP_ALG_ALGSEL_3DES;
2214 : 0 : session->cipher_key.algmode = OP_ALG_AAI_CBC;
2215 : 0 : break;
2216 : 0 : case RTE_CRYPTO_CIPHER_AES_CTR:
2217 : 0 : session->cipher_key.alg = OP_ALG_ALGSEL_AES;
2218 : 0 : session->cipher_key.algmode = OP_ALG_AAI_CTR;
2219 : 0 : break;
2220 : 0 : case RTE_CRYPTO_CIPHER_SNOW3G_UEA2:
2221 : 0 : session->cipher_key.alg = OP_ALG_ALGSEL_SNOW_F8;
2222 : 0 : break;
2223 : 0 : case RTE_CRYPTO_CIPHER_ZUC_EEA3:
2224 : 0 : session->cipher_key.alg = OP_ALG_ALGSEL_ZUCE;
2225 : 0 : break;
2226 : 0 : default:
2227 : 0 : DPAA_SEC_ERR("Crypto: Unsupported Cipher specified %s (%u)",
2228 : : rte_cryptodev_get_cipher_algo_string(xform->cipher.algo),
2229 : : xform->cipher.algo);
2230 : 0 : return -ENOTSUP;
2231 : : }
2232 : 0 : session->dir = (xform->cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) ?
2233 : 0 : DIR_ENC : DIR_DEC;
2234 : :
2235 : 0 : return 0;
2236 : : }
2237 : :
2238 : : static int
2239 : 0 : dpaa_sec_auth_init(struct rte_cryptodev *dev __rte_unused,
2240 : : struct rte_crypto_sym_xform *xform,
2241 : : dpaa_sec_session *session)
2242 : : {
2243 : 0 : session->ctxt = DPAA_SEC_AUTH;
2244 : 0 : session->auth_alg = xform->auth.algo;
2245 : 0 : session->auth_key.length = xform->auth.key.length;
2246 [ # # ]: 0 : if (xform->auth.key.length) {
2247 : 0 : session->auth_key.data =
2248 : 0 : rte_zmalloc(NULL, xform->auth.key.length,
2249 : : RTE_CACHE_LINE_SIZE);
2250 [ # # ]: 0 : if (session->auth_key.data == NULL) {
2251 : 0 : DPAA_SEC_ERR("No Memory for auth key");
2252 : 0 : return -ENOMEM;
2253 : : }
2254 : 0 : memcpy(session->auth_key.data, xform->auth.key.data,
2255 : 0 : xform->auth.key.length);
2256 : :
2257 : : }
2258 : 0 : session->digest_length = xform->auth.digest_length;
2259 [ # # ]: 0 : if (session->cipher_alg == RTE_CRYPTO_CIPHER_NULL) {
2260 : 0 : session->iv.offset = xform->auth.iv.offset;
2261 : 0 : session->iv.length = xform->auth.iv.length;
2262 : : }
2263 : :
2264 [ # # # # : 0 : switch (xform->auth.algo) {
# # # # #
# # # # #
# # # ]
2265 : 0 : case RTE_CRYPTO_AUTH_SHA1:
2266 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA1;
2267 : 0 : session->auth_key.algmode = OP_ALG_AAI_HASH;
2268 : 0 : break;
2269 : 0 : case RTE_CRYPTO_AUTH_SHA1_HMAC:
2270 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA1;
2271 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2272 : 0 : break;
2273 : 0 : case RTE_CRYPTO_AUTH_MD5:
2274 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_MD5;
2275 : 0 : session->auth_key.algmode = OP_ALG_AAI_HASH;
2276 : 0 : break;
2277 : 0 : case RTE_CRYPTO_AUTH_MD5_HMAC:
2278 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_MD5;
2279 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2280 : 0 : break;
2281 : 0 : case RTE_CRYPTO_AUTH_SHA224:
2282 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA224;
2283 : 0 : session->auth_key.algmode = OP_ALG_AAI_HASH;
2284 : 0 : break;
2285 : 0 : case RTE_CRYPTO_AUTH_SHA224_HMAC:
2286 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA224;
2287 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2288 : 0 : break;
2289 : 0 : case RTE_CRYPTO_AUTH_SHA256:
2290 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA256;
2291 : 0 : session->auth_key.algmode = OP_ALG_AAI_HASH;
2292 : 0 : break;
2293 : 0 : case RTE_CRYPTO_AUTH_SHA256_HMAC:
2294 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA256;
2295 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2296 : 0 : break;
2297 : 0 : case RTE_CRYPTO_AUTH_SHA384:
2298 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA384;
2299 : 0 : session->auth_key.algmode = OP_ALG_AAI_HASH;
2300 : 0 : break;
2301 : 0 : case RTE_CRYPTO_AUTH_SHA384_HMAC:
2302 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA384;
2303 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2304 : 0 : break;
2305 : 0 : case RTE_CRYPTO_AUTH_SHA512:
2306 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA512;
2307 : 0 : session->auth_key.algmode = OP_ALG_AAI_HASH;
2308 : 0 : break;
2309 : 0 : case RTE_CRYPTO_AUTH_SHA512_HMAC:
2310 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA512;
2311 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2312 : 0 : break;
2313 : 0 : case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2314 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SNOW_F9;
2315 : 0 : session->auth_key.algmode = OP_ALG_AAI_F9;
2316 : 0 : break;
2317 : 0 : case RTE_CRYPTO_AUTH_ZUC_EIA3:
2318 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_ZUCA;
2319 : 0 : session->auth_key.algmode = OP_ALG_AAI_F9;
2320 : 0 : break;
2321 : 0 : case RTE_CRYPTO_AUTH_AES_XCBC_MAC:
2322 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_AES;
2323 : 0 : session->auth_key.algmode = OP_ALG_AAI_XCBC_MAC;
2324 : 0 : break;
2325 : 0 : case RTE_CRYPTO_AUTH_AES_CMAC:
2326 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_AES;
2327 : 0 : session->auth_key.algmode = OP_ALG_AAI_CMAC;
2328 : 0 : break;
2329 : 0 : default:
2330 : 0 : DPAA_SEC_ERR("Crypto: Unsupported Auth specified %s (%u)",
2331 : : rte_cryptodev_get_auth_algo_string(xform->auth.algo),
2332 : : xform->auth.algo);
2333 : 0 : return -ENOTSUP;
2334 : : }
2335 : :
2336 : 0 : session->dir = (xform->auth.op == RTE_CRYPTO_AUTH_OP_GENERATE) ?
2337 : 0 : DIR_ENC : DIR_DEC;
2338 : :
2339 : 0 : return 0;
2340 : : }
2341 : :
2342 : : static int
2343 : 0 : dpaa_sec_chain_init(struct rte_cryptodev *dev __rte_unused,
2344 : : struct rte_crypto_sym_xform *xform,
2345 : : dpaa_sec_session *session)
2346 : : {
2347 : :
2348 : : struct rte_crypto_cipher_xform *cipher_xform;
2349 : : struct rte_crypto_auth_xform *auth_xform;
2350 : :
2351 : 0 : session->ctxt = DPAA_SEC_CIPHER_HASH;
2352 [ # # ]: 0 : if (session->auth_cipher_text) {
2353 : 0 : cipher_xform = &xform->cipher;
2354 : 0 : auth_xform = &xform->next->auth;
2355 : : } else {
2356 : 0 : cipher_xform = &xform->next->cipher;
2357 : 0 : auth_xform = &xform->auth;
2358 : : }
2359 : :
2360 : : /* Set IV parameters */
2361 : 0 : session->iv.offset = cipher_xform->iv.offset;
2362 : 0 : session->iv.length = cipher_xform->iv.length;
2363 : :
2364 : 0 : session->cipher_key.data = rte_zmalloc(NULL, cipher_xform->key.length,
2365 : : RTE_CACHE_LINE_SIZE);
2366 [ # # # # ]: 0 : if (session->cipher_key.data == NULL && cipher_xform->key.length > 0) {
2367 : 0 : DPAA_SEC_ERR("No Memory for cipher key");
2368 : 0 : return -ENOMEM;
2369 : : }
2370 : 0 : session->cipher_key.length = cipher_xform->key.length;
2371 : 0 : session->auth_key.data = rte_zmalloc(NULL, auth_xform->key.length,
2372 : : RTE_CACHE_LINE_SIZE);
2373 [ # # # # ]: 0 : if (session->auth_key.data == NULL && auth_xform->key.length > 0) {
2374 : 0 : DPAA_SEC_ERR("No Memory for auth key");
2375 : 0 : return -ENOMEM;
2376 : : }
2377 : 0 : session->auth_key.length = auth_xform->key.length;
2378 : 0 : memcpy(session->cipher_key.data, cipher_xform->key.data,
2379 [ # # # # : 0 : cipher_xform->key.length);
# # # #
# ]
2380 : 0 : memcpy(session->auth_key.data, auth_xform->key.data,
2381 : 0 : auth_xform->key.length);
2382 : :
2383 : 0 : session->digest_length = auth_xform->digest_length;
2384 : 0 : session->auth_alg = auth_xform->algo;
2385 : :
2386 [ # # # # : 0 : switch (auth_xform->algo) {
# # # #
# ]
2387 : 0 : case RTE_CRYPTO_AUTH_SHA1_HMAC:
2388 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA1;
2389 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2390 : 0 : break;
2391 : 0 : case RTE_CRYPTO_AUTH_MD5_HMAC:
2392 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_MD5;
2393 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2394 : 0 : break;
2395 : 0 : case RTE_CRYPTO_AUTH_SHA224_HMAC:
2396 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA224;
2397 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2398 : 0 : break;
2399 : 0 : case RTE_CRYPTO_AUTH_SHA256_HMAC:
2400 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA256;
2401 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2402 : 0 : break;
2403 : 0 : case RTE_CRYPTO_AUTH_SHA384_HMAC:
2404 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA384;
2405 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2406 : 0 : break;
2407 : 0 : case RTE_CRYPTO_AUTH_SHA512_HMAC:
2408 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_SHA512;
2409 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2410 : 0 : break;
2411 : 0 : case RTE_CRYPTO_AUTH_AES_XCBC_MAC:
2412 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_AES;
2413 : 0 : session->auth_key.algmode = OP_ALG_AAI_XCBC_MAC;
2414 : 0 : break;
2415 : 0 : case RTE_CRYPTO_AUTH_AES_CMAC:
2416 : 0 : session->auth_key.alg = OP_ALG_ALGSEL_AES;
2417 : 0 : session->auth_key.algmode = OP_ALG_AAI_CMAC;
2418 : 0 : break;
2419 : 0 : default:
2420 : 0 : DPAA_SEC_ERR("Crypto: Unsupported Auth specified %s (%u)",
2421 : : rte_cryptodev_get_auth_algo_string(auth_xform->algo),
2422 : : auth_xform->algo);
2423 : 0 : return -ENOTSUP;
2424 : : }
2425 : :
2426 : 0 : session->cipher_alg = cipher_xform->algo;
2427 : :
2428 [ # # # # : 0 : switch (cipher_xform->algo) {
# ]
2429 : 0 : case RTE_CRYPTO_CIPHER_AES_CBC:
2430 : 0 : session->cipher_key.alg = OP_ALG_ALGSEL_AES;
2431 : 0 : session->cipher_key.algmode = OP_ALG_AAI_CBC;
2432 : 0 : break;
2433 : 0 : case RTE_CRYPTO_CIPHER_DES_CBC:
2434 : 0 : session->cipher_key.alg = OP_ALG_ALGSEL_DES;
2435 : 0 : session->cipher_key.algmode = OP_ALG_AAI_CBC;
2436 : 0 : break;
2437 : 0 : case RTE_CRYPTO_CIPHER_3DES_CBC:
2438 : 0 : session->cipher_key.alg = OP_ALG_ALGSEL_3DES;
2439 : 0 : session->cipher_key.algmode = OP_ALG_AAI_CBC;
2440 : 0 : break;
2441 : 0 : case RTE_CRYPTO_CIPHER_AES_CTR:
2442 : 0 : session->cipher_key.alg = OP_ALG_ALGSEL_AES;
2443 : 0 : session->cipher_key.algmode = OP_ALG_AAI_CTR;
2444 : 0 : break;
2445 : 0 : default:
2446 : :
2447 : 0 : DPAA_SEC_ERR("Crypto: Undefined Cipher specified %s (%u)",
2448 : : rte_cryptodev_get_cipher_algo_string(cipher_xform->algo),
2449 : : cipher_xform->algo);
2450 : 0 : return -ENOTSUP;
2451 : : }
2452 : 0 : session->dir = (cipher_xform->op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) ?
2453 : 0 : DIR_ENC : DIR_DEC;
2454 : 0 : return 0;
2455 : : }
2456 : :
2457 : : static int
2458 : 0 : dpaa_sec_aead_init(struct rte_cryptodev *dev __rte_unused,
2459 : : struct rte_crypto_sym_xform *xform,
2460 : : dpaa_sec_session *session)
2461 : : {
2462 : 0 : session->aead_alg = xform->aead.algo;
2463 : 0 : session->ctxt = DPAA_SEC_AEAD;
2464 : 0 : session->iv.length = xform->aead.iv.length;
2465 : 0 : session->iv.offset = xform->aead.iv.offset;
2466 : 0 : session->auth_only_len = xform->aead.aad_length;
2467 : 0 : session->aead_key.data = rte_zmalloc(NULL, xform->aead.key.length,
2468 : : RTE_CACHE_LINE_SIZE);
2469 [ # # # # ]: 0 : if (session->aead_key.data == NULL && xform->aead.key.length > 0) {
2470 : 0 : DPAA_SEC_ERR("No Memory for aead key");
2471 : 0 : return -ENOMEM;
2472 : : }
2473 : 0 : session->aead_key.length = xform->aead.key.length;
2474 : 0 : session->digest_length = xform->aead.digest_length;
2475 : :
2476 [ # # ]: 0 : memcpy(session->aead_key.data, xform->aead.key.data,
2477 : : xform->aead.key.length);
2478 : :
2479 [ # # ]: 0 : switch (session->aead_alg) {
2480 : 0 : case RTE_CRYPTO_AEAD_AES_GCM:
2481 : 0 : session->aead_key.alg = OP_ALG_ALGSEL_AES;
2482 : 0 : session->aead_key.algmode = OP_ALG_AAI_GCM;
2483 : : break;
2484 : 0 : default:
2485 : 0 : DPAA_SEC_ERR("unsupported AEAD alg %d", session->aead_alg);
2486 : 0 : return -ENOTSUP;
2487 : : }
2488 : :
2489 : 0 : session->dir = (xform->aead.op == RTE_CRYPTO_AEAD_OP_ENCRYPT) ?
2490 : 0 : DIR_ENC : DIR_DEC;
2491 : :
2492 : 0 : return 0;
2493 : : }
2494 : :
2495 : : static struct qman_fq *
2496 : 0 : dpaa_sec_attach_rxq(struct dpaa_sec_dev_private *qi)
2497 : : {
2498 : : unsigned int i;
2499 : :
2500 [ # # ]: 0 : for (i = 0; i < RTE_DPAA_MAX_RX_QUEUE; i++) {
2501 [ # # ]: 0 : if (qi->inq_attach[i] == 0) {
2502 : 0 : qi->inq_attach[i] = 1;
2503 : 0 : return &qi->inq[i];
2504 : : }
2505 : : }
2506 : 0 : DPAA_SEC_WARN("All session in use %u", qi->max_nb_sessions);
2507 : :
2508 : 0 : return NULL;
2509 : : }
2510 : :
2511 : : static int
2512 : 0 : dpaa_sec_detach_rxq(struct dpaa_sec_dev_private *qi, struct qman_fq *fq)
2513 : : {
2514 : : unsigned int i;
2515 : : int ret;
2516 : :
2517 [ # # ]: 0 : for (i = 0; i < RTE_DPAA_MAX_RX_QUEUE; i++) {
2518 [ # # ]: 0 : if (&qi->inq[i] == fq) {
2519 : 0 : ret = qman_retire_fq(fq, NULL);
2520 [ # # ]: 0 : if (ret != 0)
2521 : 0 : DPAA_SEC_ERR("Queue %d is not retired err: %d",
2522 : : fq->fqid, ret);
2523 : 0 : qman_oos_fq(fq);
2524 : 0 : qi->inq_attach[i] = 0;
2525 : 0 : return 0;
2526 : : }
2527 : : }
2528 : : return -1;
2529 : : }
2530 : :
2531 : : int
2532 [ # # ]: 0 : dpaa_sec_attach_sess_q(struct dpaa_sec_qp *qp, dpaa_sec_session *sess)
2533 : : {
2534 : : int ret;
2535 : :
2536 : 0 : sess->qp[rte_lcore_id() % MAX_DPAA_CORES] = qp;
2537 [ # # ]: 0 : if (unlikely(!DPAA_PER_LCORE_PORTAL)) {
2538 : 0 : ret = rte_dpaa_portal_init((void *)0);
2539 [ # # ]: 0 : if (ret) {
2540 : 0 : DPAA_SEC_ERR("Failure in affining portal");
2541 : 0 : return ret;
2542 : : }
2543 : : }
2544 : 0 : ret = dpaa_sec_init_rx(sess->inq[rte_lcore_id() % MAX_DPAA_CORES],
2545 : 0 : rte_dpaa_mem_vtop(&sess->cdb),
2546 : : qman_fq_fqid(&qp->outq));
2547 [ # # ]: 0 : if (ret)
2548 : 0 : DPAA_SEC_ERR("Unable to init sec queue");
2549 : :
2550 : : return ret;
2551 : : }
2552 : :
2553 : : static inline void
2554 [ # # ]: 0 : free_session_data(dpaa_sec_session *s)
2555 : : {
2556 : : if (is_aead(s))
2557 : 0 : rte_free(s->aead_key.data);
2558 : : else {
2559 : 0 : rte_free(s->auth_key.data);
2560 : 0 : rte_free(s->cipher_key.data);
2561 : : }
2562 : : memset(s, 0, sizeof(dpaa_sec_session));
2563 : 0 : }
2564 : :
2565 : : static int
2566 : 0 : dpaa_sec_set_session_parameters(struct rte_cryptodev *dev,
2567 : : struct rte_crypto_sym_xform *xform, void *sess)
2568 : : {
2569 : 0 : struct dpaa_sec_dev_private *internals = dev->data->dev_private;
2570 : : dpaa_sec_session *session = sess;
2571 : : uint32_t i;
2572 : : int ret;
2573 : :
2574 : 0 : PMD_INIT_FUNC_TRACE();
2575 : :
2576 [ # # ]: 0 : if (unlikely(sess == NULL)) {
2577 : 0 : DPAA_SEC_ERR("invalid session struct");
2578 : 0 : return -EINVAL;
2579 : : }
2580 : : memset(session, 0, sizeof(dpaa_sec_session));
2581 : :
2582 : : /* Default IV length = 0 */
2583 : : session->iv.length = 0;
2584 : :
2585 : : /* Cipher Only */
2586 [ # # # # ]: 0 : if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER && xform->next == NULL) {
2587 : 0 : session->auth_alg = RTE_CRYPTO_AUTH_NULL;
2588 : 0 : ret = dpaa_sec_cipher_init(dev, xform, session);
2589 : :
2590 : : /* Authentication Only */
2591 [ # # ]: 0 : } else if (xform->type == RTE_CRYPTO_SYM_XFORM_AUTH &&
2592 [ # # ]: 0 : xform->next == NULL) {
2593 : 0 : session->cipher_alg = RTE_CRYPTO_CIPHER_NULL;
2594 : 0 : session->ctxt = DPAA_SEC_AUTH;
2595 : 0 : ret = dpaa_sec_auth_init(dev, xform, session);
2596 : :
2597 : : /* Cipher then Authenticate */
2598 [ # # ]: 0 : } else if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER &&
2599 [ # # ]: 0 : xform->next->type == RTE_CRYPTO_SYM_XFORM_AUTH) {
2600 [ # # ]: 0 : if (xform->cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
2601 : 0 : session->auth_cipher_text = 1;
2602 [ # # ]: 0 : if (xform->cipher.algo == RTE_CRYPTO_CIPHER_NULL)
2603 : 0 : ret = dpaa_sec_auth_init(dev, xform, session);
2604 [ # # ]: 0 : else if (xform->next->auth.algo == RTE_CRYPTO_AUTH_NULL)
2605 : 0 : ret = dpaa_sec_cipher_init(dev, xform, session);
2606 : : else
2607 : 0 : ret = dpaa_sec_chain_init(dev, xform, session);
2608 : : } else {
2609 : 0 : DPAA_SEC_ERR("Not supported: Auth then Cipher");
2610 : 0 : return -ENOTSUP;
2611 : : }
2612 : : /* Authenticate then Cipher */
2613 [ # # ]: 0 : } else if (xform->type == RTE_CRYPTO_SYM_XFORM_AUTH &&
2614 [ # # ]: 0 : xform->next->type == RTE_CRYPTO_SYM_XFORM_CIPHER) {
2615 [ # # ]: 0 : if (xform->next->cipher.op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2616 : : session->auth_cipher_text = 0;
2617 [ # # ]: 0 : if (xform->auth.algo == RTE_CRYPTO_AUTH_NULL)
2618 : 0 : ret = dpaa_sec_cipher_init(dev, xform, session);
2619 [ # # ]: 0 : else if (xform->next->cipher.algo
2620 : : == RTE_CRYPTO_CIPHER_NULL)
2621 : 0 : ret = dpaa_sec_auth_init(dev, xform, session);
2622 : : else
2623 : 0 : ret = dpaa_sec_chain_init(dev, xform, session);
2624 : : } else {
2625 : 0 : DPAA_SEC_ERR("Not supported: Auth then Cipher");
2626 : 0 : return -ENOTSUP;
2627 : : }
2628 : :
2629 : : /* AEAD operation for AES-GCM kind of Algorithms */
2630 [ # # ]: 0 : } else if (xform->type == RTE_CRYPTO_SYM_XFORM_AEAD &&
2631 [ # # ]: 0 : xform->next == NULL) {
2632 : 0 : ret = dpaa_sec_aead_init(dev, xform, session);
2633 : :
2634 : : } else {
2635 : 0 : DPAA_SEC_ERR("Invalid crypto type");
2636 : 0 : return -EINVAL;
2637 : : }
2638 [ # # ]: 0 : if (ret) {
2639 : 0 : DPAA_SEC_ERR("unable to init session");
2640 : 0 : goto err1;
2641 : : }
2642 : :
2643 : 0 : rte_spinlock_lock(&internals->lock);
2644 [ # # ]: 0 : for (i = 0; i < MAX_DPAA_CORES; i++) {
2645 : 0 : session->inq[i] = dpaa_sec_attach_rxq(internals);
2646 [ # # ]: 0 : if (session->inq[i] == NULL) {
2647 : 0 : DPAA_SEC_ERR("unable to attach sec queue");
2648 : : rte_spinlock_unlock(&internals->lock);
2649 : : ret = -EBUSY;
2650 : 0 : goto err1;
2651 : : }
2652 : : }
2653 : : rte_spinlock_unlock(&internals->lock);
2654 : :
2655 : 0 : return 0;
2656 : :
2657 : 0 : err1:
2658 : 0 : free_session_data(session);
2659 : 0 : return ret;
2660 : : }
2661 : :
2662 : : static int
2663 : 0 : dpaa_sec_sym_session_configure(struct rte_cryptodev *dev,
2664 : : struct rte_crypto_sym_xform *xform,
2665 : : struct rte_cryptodev_sym_session *sess)
2666 : : {
2667 : 0 : void *sess_private_data = CRYPTODEV_GET_SYM_SESS_PRIV(sess);
2668 : : int ret;
2669 : :
2670 : 0 : PMD_INIT_FUNC_TRACE();
2671 : :
2672 : 0 : ret = dpaa_sec_set_session_parameters(dev, xform, sess_private_data);
2673 [ # # ]: 0 : if (ret != 0) {
2674 : 0 : DPAA_SEC_ERR("failed to configure session parameters");
2675 : 0 : return ret;
2676 : : }
2677 : :
2678 : 0 : ret = dpaa_sec_prep_cdb(sess_private_data);
2679 [ # # ]: 0 : if (ret) {
2680 : 0 : DPAA_SEC_ERR("Unable to prepare sec cdb");
2681 : 0 : return ret;
2682 : : }
2683 : :
2684 : : return 0;
2685 : : }
2686 : :
2687 : : static inline void
2688 : 0 : free_session_memory(struct rte_cryptodev *dev, dpaa_sec_session *s)
2689 : : {
2690 : 0 : struct dpaa_sec_dev_private *qi = dev->data->dev_private;
2691 : : uint8_t i;
2692 : :
2693 [ # # ]: 0 : for (i = 0; i < MAX_DPAA_CORES; i++) {
2694 [ # # ]: 0 : if (s->inq[i])
2695 : 0 : dpaa_sec_detach_rxq(qi, s->inq[i]);
2696 : 0 : s->inq[i] = NULL;
2697 : 0 : s->qp[i] = NULL;
2698 : : }
2699 : 0 : free_session_data(s);
2700 : 0 : }
2701 : :
2702 : : /** Clear the memory of session so it doesn't leave key material behind */
2703 : : static void
2704 : 0 : dpaa_sec_sym_session_clear(struct rte_cryptodev *dev,
2705 : : struct rte_cryptodev_sym_session *sess)
2706 : : {
2707 : 0 : PMD_INIT_FUNC_TRACE();
2708 : 0 : void *sess_priv = CRYPTODEV_GET_SYM_SESS_PRIV(sess);
2709 : : dpaa_sec_session *s = (dpaa_sec_session *)sess_priv;
2710 : :
2711 : 0 : free_session_memory(dev, s);
2712 : 0 : }
2713 : :
2714 : : static int
2715 : 0 : dpaa_sec_ipsec_aead_init(struct rte_crypto_aead_xform *aead_xform,
2716 : : struct rte_security_ipsec_xform *ipsec_xform,
2717 : : dpaa_sec_session *session)
2718 : : {
2719 : 0 : PMD_INIT_FUNC_TRACE();
2720 : :
2721 : 0 : session->aead_key.data = rte_zmalloc(NULL, aead_xform->key.length,
2722 : : RTE_CACHE_LINE_SIZE);
2723 [ # # # # ]: 0 : if (session->aead_key.data == NULL && aead_xform->key.length > 0) {
2724 : 0 : DPAA_SEC_ERR("No Memory for aead key");
2725 : 0 : return -ENOMEM;
2726 : : }
2727 : 0 : memcpy(session->aead_key.data, aead_xform->key.data,
2728 [ # # ]: 0 : aead_xform->key.length);
2729 : :
2730 : 0 : session->digest_length = aead_xform->digest_length;
2731 : 0 : session->aead_key.length = aead_xform->key.length;
2732 : :
2733 [ # # ]: 0 : switch (aead_xform->algo) {
2734 [ # # # # ]: 0 : case RTE_CRYPTO_AEAD_AES_GCM:
2735 : : switch (session->digest_length) {
2736 : 0 : case 8:
2737 : 0 : session->aead_key.alg = OP_PCL_IPSEC_AES_GCM8;
2738 : 0 : break;
2739 : 0 : case 12:
2740 : 0 : session->aead_key.alg = OP_PCL_IPSEC_AES_GCM12;
2741 : 0 : break;
2742 : 0 : case 16:
2743 : 0 : session->aead_key.alg = OP_PCL_IPSEC_AES_GCM16;
2744 : 0 : break;
2745 : 0 : default:
2746 : 0 : DPAA_SEC_ERR("Crypto: Undefined GCM digest %d",
2747 : : session->digest_length);
2748 : 0 : return -EINVAL;
2749 : : }
2750 [ # # ]: 0 : if (session->dir == DIR_ENC) {
2751 : 0 : memcpy(session->encap_pdb.gcm.salt,
2752 : 0 : (uint8_t *)&(ipsec_xform->salt), 4);
2753 : : } else {
2754 : 0 : memcpy(session->decap_pdb.gcm.salt,
2755 : 0 : (uint8_t *)&(ipsec_xform->salt), 4);
2756 : : }
2757 : 0 : session->aead_key.algmode = OP_ALG_AAI_GCM;
2758 : 0 : session->aead_alg = RTE_CRYPTO_AEAD_AES_GCM;
2759 : : break;
2760 : 0 : default:
2761 : 0 : DPAA_SEC_ERR("Crypto: Undefined AEAD specified %u",
2762 : : aead_xform->algo);
2763 : 0 : return -ENOTSUP;
2764 : : }
2765 : 0 : return 0;
2766 : : }
2767 : :
2768 : : static int
2769 : 0 : dpaa_sec_ipsec_proto_init(struct rte_crypto_cipher_xform *cipher_xform,
2770 : : struct rte_crypto_auth_xform *auth_xform,
2771 : : struct rte_security_ipsec_xform *ipsec_xform,
2772 : : dpaa_sec_session *session)
2773 : : {
2774 [ # # ]: 0 : if (cipher_xform) {
2775 : 0 : session->cipher_key.data = rte_zmalloc(NULL,
2776 : 0 : cipher_xform->key.length,
2777 : : RTE_CACHE_LINE_SIZE);
2778 [ # # ]: 0 : if (session->cipher_key.data == NULL &&
2779 [ # # ]: 0 : cipher_xform->key.length > 0) {
2780 : 0 : DPAA_SEC_ERR("No Memory for cipher key");
2781 : 0 : return -ENOMEM;
2782 : : }
2783 : :
2784 : 0 : session->cipher_key.length = cipher_xform->key.length;
2785 : 0 : memcpy(session->cipher_key.data, cipher_xform->key.data,
2786 : : cipher_xform->key.length);
2787 : 0 : session->cipher_alg = cipher_xform->algo;
2788 : : } else {
2789 : 0 : session->cipher_key.data = NULL;
2790 : 0 : session->cipher_key.length = 0;
2791 : 0 : session->cipher_alg = RTE_CRYPTO_CIPHER_NULL;
2792 : : }
2793 : :
2794 [ # # ]: 0 : if (auth_xform) {
2795 : 0 : session->auth_key.data = rte_zmalloc(NULL,
2796 : 0 : auth_xform->key.length,
2797 : : RTE_CACHE_LINE_SIZE);
2798 [ # # ]: 0 : if (session->auth_key.data == NULL &&
2799 [ # # ]: 0 : auth_xform->key.length > 0) {
2800 : 0 : DPAA_SEC_ERR("No Memory for auth key");
2801 : 0 : return -ENOMEM;
2802 : : }
2803 : 0 : session->auth_key.length = auth_xform->key.length;
2804 : 0 : memcpy(session->auth_key.data, auth_xform->key.data,
2805 : : auth_xform->key.length);
2806 : 0 : session->auth_alg = auth_xform->algo;
2807 : 0 : session->digest_length = auth_xform->digest_length;
2808 : : } else {
2809 : 0 : session->auth_key.data = NULL;
2810 : 0 : session->auth_key.length = 0;
2811 : 0 : session->auth_alg = RTE_CRYPTO_AUTH_NULL;
2812 : : }
2813 : :
2814 [ # # # # : 0 : switch (session->auth_alg) {
# # # # #
# ]
2815 : 0 : case RTE_CRYPTO_AUTH_SHA1_HMAC:
2816 : 0 : session->auth_key.alg = OP_PCL_IPSEC_HMAC_SHA1_96;
2817 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2818 : 0 : break;
2819 : 0 : case RTE_CRYPTO_AUTH_MD5_HMAC:
2820 : 0 : session->auth_key.alg = OP_PCL_IPSEC_HMAC_MD5_96;
2821 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2822 : 0 : break;
2823 : 0 : case RTE_CRYPTO_AUTH_SHA256_HMAC:
2824 : 0 : session->auth_key.alg = OP_PCL_IPSEC_HMAC_SHA2_256_128;
2825 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2826 [ # # ]: 0 : if (session->digest_length != 16)
2827 : 0 : DPAA_SEC_WARN(
2828 : : "+++Using sha256-hmac truncated len is non-standard,"
2829 : : "it will not work with lookaside proto");
2830 : : break;
2831 : 0 : case RTE_CRYPTO_AUTH_SHA224_HMAC:
2832 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2833 [ # # ]: 0 : if (session->digest_length == 6)
2834 : 0 : session->auth_key.alg = OP_PCL_IPSEC_HMAC_SHA2_224_96;
2835 [ # # ]: 0 : else if (session->digest_length == 14)
2836 : 0 : session->auth_key.alg = OP_PCL_IPSEC_HMAC_SHA2_224_224;
2837 : : else
2838 : 0 : session->auth_key.alg = OP_PCL_IPSEC_HMAC_SHA2_224_112;
2839 : : break;
2840 : 0 : case RTE_CRYPTO_AUTH_SHA384_HMAC:
2841 : 0 : session->auth_key.alg = OP_PCL_IPSEC_HMAC_SHA2_384_192;
2842 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2843 : 0 : break;
2844 : 0 : case RTE_CRYPTO_AUTH_SHA512_HMAC:
2845 : 0 : session->auth_key.alg = OP_PCL_IPSEC_HMAC_SHA2_512_256;
2846 : 0 : session->auth_key.algmode = OP_ALG_AAI_HMAC;
2847 : 0 : break;
2848 : 0 : case RTE_CRYPTO_AUTH_AES_CMAC:
2849 : 0 : session->auth_key.alg = OP_PCL_IPSEC_AES_CMAC_96;
2850 : 0 : session->auth_key.algmode = OP_ALG_AAI_CMAC;
2851 : 0 : break;
2852 : 0 : case RTE_CRYPTO_AUTH_NULL:
2853 : 0 : session->auth_key.alg = OP_PCL_IPSEC_HMAC_NULL;
2854 : 0 : break;
2855 : 0 : case RTE_CRYPTO_AUTH_AES_XCBC_MAC:
2856 : 0 : session->auth_key.alg = OP_PCL_IPSEC_AES_XCBC_MAC_96;
2857 : 0 : session->auth_key.algmode = OP_ALG_AAI_XCBC_MAC;
2858 : 0 : break;
2859 : 0 : default:
2860 : 0 : DPAA_SEC_ERR("Crypto: Unsupported auth alg %s (%u)",
2861 : : rte_cryptodev_get_auth_algo_string(session->auth_alg),
2862 : : session->auth_alg);
2863 : 0 : return -ENOTSUP;
2864 : : }
2865 : :
2866 [ # # # # : 0 : switch (session->cipher_alg) {
# # ]
2867 : 0 : case RTE_CRYPTO_CIPHER_AES_CBC:
2868 : 0 : session->cipher_key.alg = OP_PCL_IPSEC_AES_CBC;
2869 : 0 : session->cipher_key.algmode = OP_ALG_AAI_CBC;
2870 : 0 : break;
2871 : 0 : case RTE_CRYPTO_CIPHER_DES_CBC:
2872 : 0 : session->cipher_key.alg = OP_PCL_IPSEC_DES;
2873 : 0 : session->cipher_key.algmode = OP_ALG_AAI_CBC;
2874 : 0 : break;
2875 : 0 : case RTE_CRYPTO_CIPHER_3DES_CBC:
2876 : 0 : session->cipher_key.alg = OP_PCL_IPSEC_3DES;
2877 : 0 : session->cipher_key.algmode = OP_ALG_AAI_CBC;
2878 : 0 : break;
2879 : 0 : case RTE_CRYPTO_CIPHER_AES_CTR:
2880 : 0 : session->cipher_key.alg = OP_PCL_IPSEC_AES_CTR;
2881 : 0 : session->cipher_key.algmode = OP_ALG_AAI_CTR;
2882 [ # # ]: 0 : if (session->dir == DIR_ENC) {
2883 : 0 : session->encap_pdb.ctr.ctr_initial = 0x00000001;
2884 : 0 : session->encap_pdb.ctr.ctr_nonce = ipsec_xform->salt;
2885 : : } else {
2886 : 0 : session->decap_pdb.ctr.ctr_initial = 0x00000001;
2887 : 0 : session->decap_pdb.ctr.ctr_nonce = ipsec_xform->salt;
2888 : : }
2889 : : break;
2890 : 0 : case RTE_CRYPTO_CIPHER_NULL:
2891 : 0 : session->cipher_key.alg = OP_PCL_IPSEC_NULL;
2892 : 0 : break;
2893 : 0 : default:
2894 : 0 : DPAA_SEC_ERR("Crypto: Unsupported Cipher alg %s (%u)",
2895 : : rte_cryptodev_get_cipher_algo_string(session->cipher_alg),
2896 : : session->cipher_alg);
2897 : 0 : return -ENOTSUP;
2898 : : }
2899 : :
2900 : : return 0;
2901 : : }
2902 : :
2903 : : static int
2904 : 0 : dpaa_sec_set_ipsec_session(__rte_unused struct rte_cryptodev *dev,
2905 : : struct rte_security_session_conf *conf,
2906 : : void *sess)
2907 : : {
2908 : 0 : struct dpaa_sec_dev_private *internals = dev->data->dev_private;
2909 : 0 : struct rte_security_ipsec_xform *ipsec_xform = &conf->ipsec;
2910 : : struct rte_crypto_auth_xform *auth_xform = NULL;
2911 : : struct rte_crypto_cipher_xform *cipher_xform = NULL;
2912 : : struct rte_crypto_aead_xform *aead_xform = NULL;
2913 : : dpaa_sec_session *session = (dpaa_sec_session *)sess;
2914 : : uint32_t i;
2915 : : int ret;
2916 : :
2917 : 0 : PMD_INIT_FUNC_TRACE();
2918 : :
2919 : : memset(session, 0, sizeof(dpaa_sec_session));
2920 : 0 : session->proto_alg = conf->protocol;
2921 : 0 : session->ctxt = DPAA_SEC_IPSEC;
2922 : :
2923 [ # # ]: 0 : if (ipsec_xform->life.bytes_hard_limit != 0 ||
2924 [ # # ]: 0 : ipsec_xform->life.bytes_soft_limit != 0 ||
2925 [ # # ]: 0 : ipsec_xform->life.packets_hard_limit != 0 ||
2926 [ # # ]: 0 : ipsec_xform->life.packets_soft_limit != 0)
2927 : : return -ENOTSUP;
2928 : :
2929 [ # # ]: 0 : if (ipsec_xform->direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS)
2930 : 0 : session->dir = DIR_ENC;
2931 : : else
2932 : : session->dir = DIR_DEC;
2933 : :
2934 [ # # ]: 0 : if (conf->crypto_xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER) {
2935 : 0 : cipher_xform = &conf->crypto_xform->cipher;
2936 [ # # ]: 0 : if (conf->crypto_xform->next)
2937 : 0 : auth_xform = &conf->crypto_xform->next->auth;
2938 : 0 : ret = dpaa_sec_ipsec_proto_init(cipher_xform, auth_xform,
2939 : : ipsec_xform, session);
2940 [ # # ]: 0 : } else if (conf->crypto_xform->type == RTE_CRYPTO_SYM_XFORM_AUTH) {
2941 : 0 : auth_xform = &conf->crypto_xform->auth;
2942 [ # # ]: 0 : if (conf->crypto_xform->next)
2943 : 0 : cipher_xform = &conf->crypto_xform->next->cipher;
2944 : 0 : ret = dpaa_sec_ipsec_proto_init(cipher_xform, auth_xform,
2945 : : ipsec_xform, session);
2946 [ # # ]: 0 : } else if (conf->crypto_xform->type == RTE_CRYPTO_SYM_XFORM_AEAD) {
2947 : 0 : aead_xform = &conf->crypto_xform->aead;
2948 : 0 : ret = dpaa_sec_ipsec_aead_init(aead_xform,
2949 : : ipsec_xform, session);
2950 : : } else {
2951 : 0 : DPAA_SEC_ERR("XFORM not specified");
2952 : : ret = -EINVAL;
2953 : 0 : goto out;
2954 : : }
2955 [ # # ]: 0 : if (ret) {
2956 : 0 : DPAA_SEC_ERR("Failed to process xform");
2957 : 0 : goto out;
2958 : : }
2959 : :
2960 [ # # ]: 0 : if (ipsec_xform->direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) {
2961 [ # # ]: 0 : if (ipsec_xform->tunnel.type ==
2962 : : RTE_SECURITY_IPSEC_TUNNEL_IPV4) {
2963 : 0 : session->ip4_hdr.ip_v = IPVERSION;
2964 : 0 : session->ip4_hdr.ip_hl = 5;
2965 [ # # ]: 0 : if (ipsec_xform->options.udp_encap)
2966 : 0 : session->ip4_hdr.ip_len = rte_cpu_to_be_16(
2967 : : sizeof(session->ip4_hdr) + sizeof(struct rte_udp_hdr));
2968 : : else
2969 : 0 : session->ip4_hdr.ip_len = rte_cpu_to_be_16(
2970 : : sizeof(session->ip4_hdr));
2971 : 0 : session->ip4_hdr.ip_tos = ipsec_xform->tunnel.ipv4.dscp;
2972 : 0 : session->ip4_hdr.ip_id = 0;
2973 : 0 : session->ip4_hdr.ip_off = 0;
2974 : 0 : session->ip4_hdr.ip_ttl = ipsec_xform->tunnel.ipv4.ttl;
2975 [ # # ]: 0 : if (ipsec_xform->options.udp_encap)
2976 : 0 : session->ip4_hdr.ip_p = IPPROTO_UDP;
2977 : : else
2978 [ # # ]: 0 : session->ip4_hdr.ip_p = (ipsec_xform->proto ==
2979 : : RTE_SECURITY_IPSEC_SA_PROTO_ESP) ?
2980 : : IPPROTO_ESP : IPPROTO_AH;
2981 : 0 : session->ip4_hdr.ip_sum = 0;
2982 : 0 : session->ip4_hdr.ip_src =
2983 : : ipsec_xform->tunnel.ipv4.src_ip;
2984 : 0 : session->ip4_hdr.ip_dst =
2985 : : ipsec_xform->tunnel.ipv4.dst_ip;
2986 : 0 : session->ip4_hdr.ip_sum = calc_chksum((uint16_t *)
2987 : 0 : (void *)&session->ip4_hdr,
2988 : : sizeof(struct ip));
2989 : 0 : session->encap_pdb.ip_hdr_len = sizeof(struct ip);
2990 [ # # ]: 0 : } else if (ipsec_xform->tunnel.type ==
2991 : : RTE_SECURITY_IPSEC_TUNNEL_IPV6) {
2992 [ # # ]: 0 : session->ip6_hdr.vtc_flow = rte_cpu_to_be_32(
2993 : : DPAA_IPv6_DEFAULT_VTC_FLOW |
2994 : : ((ipsec_xform->tunnel.ipv6.dscp <<
2995 : : RTE_IPV6_HDR_TC_SHIFT) &
2996 : : RTE_IPV6_HDR_TC_MASK) |
2997 : : ((ipsec_xform->tunnel.ipv6.flabel <<
2998 : : RTE_IPV6_HDR_FL_SHIFT) &
2999 : : RTE_IPV6_HDR_FL_MASK));
3000 : : /* Payload length will be updated by HW */
3001 : 0 : session->ip6_hdr.payload_len = 0;
3002 : 0 : session->ip6_hdr.hop_limits =
3003 : 0 : ipsec_xform->tunnel.ipv6.hlimit;
3004 [ # # ]: 0 : if (ipsec_xform->options.udp_encap)
3005 : 0 : session->ip6_hdr.proto = IPPROTO_UDP;
3006 : : else
3007 [ # # ]: 0 : session->ip6_hdr.proto = (ipsec_xform->proto ==
3008 : : RTE_SECURITY_IPSEC_SA_PROTO_ESP) ?
3009 : : IPPROTO_ESP : IPPROTO_AH;
3010 : 0 : memcpy(&session->ip6_hdr.src_addr,
3011 : 0 : &ipsec_xform->tunnel.ipv6.src_addr, 16);
3012 : 0 : memcpy(&session->ip6_hdr.dst_addr,
3013 : 0 : &ipsec_xform->tunnel.ipv6.dst_addr, 16);
3014 : 0 : session->encap_pdb.ip_hdr_len =
3015 : : sizeof(struct rte_ipv6_hdr);
3016 : : }
3017 : :
3018 : 0 : session->encap_pdb.options =
3019 : : (IPVERSION << PDBNH_ESP_ENCAP_SHIFT) |
3020 : : PDBOPTS_ESP_OIHI_PDB_INL |
3021 : : PDBOPTS_ESP_IVSRC |
3022 : : PDBHMO_ESP_SNR;
3023 [ # # ]: 0 : if (ipsec_xform->options.dec_ttl)
3024 : 0 : session->encap_pdb.options |= PDBHMO_ESP_ENCAP_DTTL;
3025 : 0 : session->encap_pdb.spi = ipsec_xform->spi;
3026 : : /* Initializing the sequence number to 1, Security
3027 : : * engine will choose this sequence number for first packet
3028 : : * Refer: RFC4303 section: 3.3.3.Sequence Number Generation
3029 : : */
3030 : 0 : session->encap_pdb.seq_num = 1;
3031 [ # # ]: 0 : if (ipsec_xform->options.esn) {
3032 : 0 : session->encap_pdb.options |= PDBOPTS_ESP_ESN;
3033 : 0 : session->encap_pdb.seq_num_ext_hi = conf->ipsec.esn.hi;
3034 : 0 : session->encap_pdb.seq_num = conf->ipsec.esn.low;
3035 : : }
3036 [ # # ]: 0 : if (ipsec_xform->options.udp_encap) {
3037 : : struct rte_udp_hdr *udp_hdr;
3038 : :
3039 [ # # ]: 0 : if (ipsec_xform->tunnel.type == RTE_SECURITY_IPSEC_TUNNEL_IPV4)
3040 : 0 : udp_hdr = (struct rte_udp_hdr *)(&session->udp4.udp_hdr);
3041 : : else
3042 : 0 : udp_hdr = (struct rte_udp_hdr *)(&session->udp6.udp_hdr);
3043 : :
3044 [ # # ]: 0 : if (ipsec_xform->udp.sport)
3045 [ # # ]: 0 : udp_hdr->src_port = rte_cpu_to_be_16(ipsec_xform->udp.sport);
3046 : : else
3047 : 0 : udp_hdr->src_port = rte_cpu_to_be_16(DPAA_DEFAULT_NAT_T_PORT);
3048 : :
3049 [ # # ]: 0 : if (ipsec_xform->udp.dport)
3050 [ # # ]: 0 : udp_hdr->dst_port = rte_cpu_to_be_16(ipsec_xform->udp.dport);
3051 : : else
3052 : 0 : udp_hdr->dst_port = rte_cpu_to_be_16(DPAA_DEFAULT_NAT_T_PORT);
3053 : 0 : udp_hdr->dgram_len = 0;
3054 : 0 : udp_hdr->dgram_cksum = 0;
3055 : :
3056 : 0 : session->encap_pdb.ip_hdr_len += sizeof(struct rte_udp_hdr);
3057 : 0 : session->encap_pdb.options |= PDBOPTS_ESP_NAT | PDBOPTS_ESP_NUC;
3058 : : }
3059 [ # # ]: 0 : if (ipsec_xform->options.ecn)
3060 : 0 : session->encap_pdb.options |= PDBOPTS_ESP_TECN;
3061 [ # # ]: 0 : } else if (ipsec_xform->direction ==
3062 : : RTE_SECURITY_IPSEC_SA_DIR_INGRESS) {
3063 [ # # ]: 0 : if (ipsec_xform->tunnel.type == RTE_SECURITY_IPSEC_TUNNEL_IPV4) {
3064 [ # # ]: 0 : if (ipsec_xform->options.udp_encap)
3065 : 0 : session->decap_pdb.options =
3066 : : (sizeof(struct ip) + sizeof(struct rte_udp_hdr)) << 16;
3067 : : else
3068 : 0 : session->decap_pdb.options = sizeof(struct ip) << 16;
3069 [ # # ]: 0 : if (ipsec_xform->options.copy_df)
3070 : 0 : session->decap_pdb.options |= PDBHMO_ESP_DFV;
3071 : : } else {
3072 [ # # ]: 0 : if (ipsec_xform->options.udp_encap)
3073 : 0 : session->decap_pdb.options =
3074 : : (sizeof(struct rte_ipv6_hdr) + sizeof(struct rte_udp_hdr)) << 16;
3075 : : else
3076 : 0 : session->decap_pdb.options = sizeof(struct rte_ipv6_hdr) << 16;
3077 : : }
3078 [ # # ]: 0 : if (ipsec_xform->options.esn) {
3079 : 0 : session->decap_pdb.options |= PDBOPTS_ESP_ESN;
3080 : 0 : session->decap_pdb.seq_num_ext_hi = conf->ipsec.esn.hi;
3081 : 0 : session->decap_pdb.seq_num = conf->ipsec.esn.low;
3082 : : }
3083 [ # # ]: 0 : if (ipsec_xform->options.copy_dscp)
3084 : 0 : session->decap_pdb.options |= PDBHMO_ESP_DIFFSERV;
3085 [ # # ]: 0 : if (ipsec_xform->options.ecn)
3086 : 0 : session->decap_pdb.options |= PDBOPTS_ESP_TECN;
3087 : :
3088 [ # # ]: 0 : if (ipsec_xform->replay_win_sz) {
3089 : : uint32_t win_sz;
3090 : : win_sz = rte_align32pow2(ipsec_xform->replay_win_sz);
3091 : :
3092 [ # # # ]: 0 : switch (win_sz) {
3093 : 0 : case 1:
3094 : : case 2:
3095 : : case 4:
3096 : : case 8:
3097 : : case 16:
3098 : : case 32:
3099 : 0 : session->decap_pdb.options |= PDBOPTS_ESP_ARS32;
3100 : 0 : break;
3101 : 0 : case 64:
3102 : 0 : session->decap_pdb.options |= PDBOPTS_ESP_ARS64;
3103 : 0 : break;
3104 : 0 : default:
3105 : 0 : session->decap_pdb.options |=
3106 : : PDBOPTS_ESP_ARS128;
3107 : : }
3108 : : }
3109 : : } else
3110 : 0 : goto out;
3111 : 0 : rte_spinlock_lock(&internals->lock);
3112 [ # # ]: 0 : for (i = 0; i < MAX_DPAA_CORES; i++) {
3113 : 0 : session->inq[i] = dpaa_sec_attach_rxq(internals);
3114 [ # # ]: 0 : if (session->inq[i] == NULL) {
3115 : 0 : DPAA_SEC_ERR("unable to attach sec queue");
3116 : : rte_spinlock_unlock(&internals->lock);
3117 : 0 : goto out;
3118 : : }
3119 : : }
3120 : : rte_spinlock_unlock(&internals->lock);
3121 : :
3122 : 0 : return 0;
3123 : 0 : out:
3124 : 0 : free_session_data(session);
3125 : 0 : return -1;
3126 : : }
3127 : :
3128 : : static int
3129 : 0 : dpaa_sec_set_pdcp_session(struct rte_cryptodev *dev,
3130 : : struct rte_security_session_conf *conf,
3131 : : void *sess)
3132 : : {
3133 : : struct rte_security_pdcp_xform *pdcp_xform = &conf->pdcp;
3134 : 0 : struct rte_crypto_sym_xform *xform = conf->crypto_xform;
3135 : : struct rte_crypto_auth_xform *auth_xform = NULL;
3136 : : struct rte_crypto_cipher_xform *cipher_xform = NULL;
3137 : : dpaa_sec_session *session = (dpaa_sec_session *)sess;
3138 : 0 : struct dpaa_sec_dev_private *dev_priv = dev->data->dev_private;
3139 : : uint32_t i;
3140 : : int ret;
3141 : :
3142 : 0 : PMD_INIT_FUNC_TRACE();
3143 : :
3144 : : memset(session, 0, sizeof(dpaa_sec_session));
3145 : :
3146 : : /* find xfrm types */
3147 [ # # ]: 0 : if (xform->type == RTE_CRYPTO_SYM_XFORM_CIPHER) {
3148 : 0 : cipher_xform = &xform->cipher;
3149 [ # # ]: 0 : if (xform->next != NULL &&
3150 [ # # ]: 0 : xform->next->type == RTE_CRYPTO_SYM_XFORM_AUTH)
3151 : 0 : auth_xform = &xform->next->auth;
3152 [ # # ]: 0 : } else if (xform->type == RTE_CRYPTO_SYM_XFORM_AUTH) {
3153 : 0 : auth_xform = &xform->auth;
3154 [ # # ]: 0 : if (xform->next != NULL &&
3155 [ # # ]: 0 : xform->next->type == RTE_CRYPTO_SYM_XFORM_CIPHER)
3156 : 0 : cipher_xform = &xform->next->cipher;
3157 : : } else {
3158 : 0 : DPAA_SEC_ERR("Invalid crypto type");
3159 : 0 : return -EINVAL;
3160 : : }
3161 : :
3162 : 0 : session->proto_alg = conf->protocol;
3163 : 0 : session->ctxt = DPAA_SEC_PDCP;
3164 : :
3165 [ # # ]: 0 : if (cipher_xform) {
3166 [ # # # # : 0 : switch (cipher_xform->algo) {
# ]
3167 : 0 : case RTE_CRYPTO_CIPHER_SNOW3G_UEA2:
3168 : 0 : session->cipher_key.alg = PDCP_CIPHER_TYPE_SNOW;
3169 : 0 : break;
3170 : 0 : case RTE_CRYPTO_CIPHER_ZUC_EEA3:
3171 : 0 : session->cipher_key.alg = PDCP_CIPHER_TYPE_ZUC;
3172 : 0 : break;
3173 : 0 : case RTE_CRYPTO_CIPHER_AES_CTR:
3174 : 0 : session->cipher_key.alg = PDCP_CIPHER_TYPE_AES;
3175 : 0 : break;
3176 : : case RTE_CRYPTO_CIPHER_NULL:
3177 : : session->cipher_key.alg = PDCP_CIPHER_TYPE_NULL;
3178 : : break;
3179 : 0 : default:
3180 : 0 : DPAA_SEC_ERR("Crypto: Undefined Cipher specified %u",
3181 : : session->cipher_alg);
3182 : 0 : return -EINVAL;
3183 : : }
3184 : :
3185 : 0 : session->cipher_key.data = rte_zmalloc(NULL,
3186 : 0 : cipher_xform->key.length,
3187 : : RTE_CACHE_LINE_SIZE);
3188 [ # # ]: 0 : if (session->cipher_key.data == NULL &&
3189 [ # # ]: 0 : cipher_xform->key.length > 0) {
3190 : 0 : DPAA_SEC_ERR("No Memory for cipher key");
3191 : 0 : return -ENOMEM;
3192 : : }
3193 : 0 : session->cipher_key.length = cipher_xform->key.length;
3194 : 0 : memcpy(session->cipher_key.data, cipher_xform->key.data,
3195 : : cipher_xform->key.length);
3196 : 0 : session->dir = (cipher_xform->op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) ?
3197 : 0 : DIR_ENC : DIR_DEC;
3198 : 0 : session->cipher_alg = cipher_xform->algo;
3199 : : } else {
3200 : : session->cipher_key.data = NULL;
3201 : : session->cipher_key.length = 0;
3202 : 0 : session->cipher_alg = RTE_CRYPTO_CIPHER_NULL;
3203 : 0 : session->dir = DIR_ENC;
3204 : : }
3205 : :
3206 [ # # ]: 0 : if (pdcp_xform->domain == RTE_SECURITY_PDCP_MODE_CONTROL) {
3207 [ # # ]: 0 : if (pdcp_xform->sn_size != RTE_SECURITY_PDCP_SN_SIZE_5 &&
3208 : : pdcp_xform->sn_size != RTE_SECURITY_PDCP_SN_SIZE_12) {
3209 : 0 : DPAA_SEC_ERR(
3210 : : "PDCP Seq Num size should be 5/12 bits for cmode");
3211 : : ret = -EINVAL;
3212 : 0 : goto out;
3213 : : }
3214 : : }
3215 : :
3216 [ # # ]: 0 : if (auth_xform) {
3217 [ # # # # : 0 : switch (auth_xform->algo) {
# ]
3218 : 0 : case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
3219 : 0 : session->auth_key.alg = PDCP_AUTH_TYPE_SNOW;
3220 : 0 : break;
3221 : 0 : case RTE_CRYPTO_AUTH_ZUC_EIA3:
3222 : 0 : session->auth_key.alg = PDCP_AUTH_TYPE_ZUC;
3223 : 0 : break;
3224 : 0 : case RTE_CRYPTO_AUTH_AES_CMAC:
3225 : 0 : session->auth_key.alg = PDCP_AUTH_TYPE_AES;
3226 : 0 : break;
3227 : 0 : case RTE_CRYPTO_AUTH_NULL:
3228 : 0 : session->auth_key.alg = PDCP_AUTH_TYPE_NULL;
3229 : 0 : break;
3230 : 0 : default:
3231 : 0 : DPAA_SEC_ERR("Crypto: Unsupported auth alg %s (%u)",
3232 : : rte_cryptodev_get_auth_algo_string(session->auth_alg),
3233 : : session->auth_alg);
3234 : 0 : rte_free(session->cipher_key.data);
3235 : 0 : return -EINVAL;
3236 : : }
3237 : 0 : session->auth_key.data = rte_zmalloc(NULL,
3238 : 0 : auth_xform->key.length,
3239 : : RTE_CACHE_LINE_SIZE);
3240 [ # # ]: 0 : if (!session->auth_key.data &&
3241 [ # # ]: 0 : auth_xform->key.length > 0) {
3242 : 0 : DPAA_SEC_ERR("No Memory for auth key");
3243 : 0 : rte_free(session->cipher_key.data);
3244 : 0 : return -ENOMEM;
3245 : : }
3246 : 0 : session->auth_key.length = auth_xform->key.length;
3247 : 0 : memcpy(session->auth_key.data, auth_xform->key.data,
3248 : : auth_xform->key.length);
3249 : 0 : session->auth_alg = auth_xform->algo;
3250 : : } else {
3251 [ # # ]: 0 : if (pdcp_xform->domain == RTE_SECURITY_PDCP_MODE_CONTROL) {
3252 : 0 : DPAA_SEC_ERR("Crypto: Integrity must for c-plane");
3253 : : ret = -EINVAL;
3254 : 0 : goto out;
3255 : : }
3256 : 0 : session->auth_key.data = NULL;
3257 : 0 : session->auth_key.length = 0;
3258 : 0 : session->auth_alg = 0;
3259 : : }
3260 : 0 : session->pdcp.domain = pdcp_xform->domain;
3261 : 0 : session->pdcp.bearer = pdcp_xform->bearer;
3262 : 0 : session->pdcp.pkt_dir = pdcp_xform->pkt_dir;
3263 : 0 : session->pdcp.sn_size = pdcp_xform->sn_size;
3264 : 0 : session->pdcp.hfn = pdcp_xform->hfn;
3265 : 0 : session->pdcp.hfn_threshold = pdcp_xform->hfn_threshold;
3266 : 0 : session->pdcp.hfn_ovd = pdcp_xform->hfn_ovrd;
3267 : 0 : session->pdcp.sdap_enabled = pdcp_xform->sdap_enabled;
3268 [ # # ]: 0 : if (cipher_xform)
3269 : 0 : session->pdcp.hfn_ovd_offset = cipher_xform->iv.offset;
3270 : :
3271 : 0 : rte_spinlock_lock(&dev_priv->lock);
3272 [ # # ]: 0 : for (i = 0; i < MAX_DPAA_CORES; i++) {
3273 : 0 : session->inq[i] = dpaa_sec_attach_rxq(dev_priv);
3274 [ # # ]: 0 : if (session->inq[i] == NULL) {
3275 : 0 : DPAA_SEC_ERR("unable to attach sec queue");
3276 : : rte_spinlock_unlock(&dev_priv->lock);
3277 : : ret = -EBUSY;
3278 : 0 : goto out;
3279 : : }
3280 : : }
3281 : : rte_spinlock_unlock(&dev_priv->lock);
3282 : 0 : return 0;
3283 : 0 : out:
3284 : 0 : rte_free(session->auth_key.data);
3285 : 0 : rte_free(session->cipher_key.data);
3286 : : memset(session, 0, sizeof(dpaa_sec_session));
3287 : 0 : return ret;
3288 : : }
3289 : :
3290 : : static int
3291 : 0 : dpaa_sec_security_session_create(void *dev,
3292 : : struct rte_security_session_conf *conf,
3293 : : struct rte_security_session *sess)
3294 : : {
3295 : 0 : void *sess_private_data = SECURITY_GET_SESS_PRIV(sess);
3296 : : struct rte_cryptodev *cdev = (struct rte_cryptodev *)dev;
3297 : : int ret;
3298 : :
3299 [ # # # # ]: 0 : switch (conf->protocol) {
3300 : 0 : case RTE_SECURITY_PROTOCOL_IPSEC:
3301 : 0 : ret = dpaa_sec_set_ipsec_session(cdev, conf,
3302 : : sess_private_data);
3303 : 0 : break;
3304 : 0 : case RTE_SECURITY_PROTOCOL_PDCP:
3305 : 0 : ret = dpaa_sec_set_pdcp_session(cdev, conf,
3306 : : sess_private_data);
3307 : 0 : break;
3308 : : case RTE_SECURITY_PROTOCOL_MACSEC:
3309 : : return -ENOTSUP;
3310 : 0 : default:
3311 : 0 : return -EINVAL;
3312 : : }
3313 [ # # ]: 0 : if (ret != 0) {
3314 : 0 : DPAA_SEC_ERR("failed to configure session parameters");
3315 : 0 : return ret;
3316 : : }
3317 : :
3318 : 0 : ret = dpaa_sec_prep_cdb(sess_private_data);
3319 [ # # ]: 0 : if (ret) {
3320 : 0 : DPAA_SEC_ERR("Unable to prepare sec cdb");
3321 : 0 : return ret;
3322 : : }
3323 : :
3324 : : return ret;
3325 : : }
3326 : :
3327 : : /** Clear the memory of session so it doesn't leave key material behind */
3328 : : static int
3329 : 0 : dpaa_sec_security_session_destroy(void *dev __rte_unused,
3330 : : struct rte_security_session *sess)
3331 : : {
3332 : 0 : PMD_INIT_FUNC_TRACE();
3333 : 0 : void *sess_priv = SECURITY_GET_SESS_PRIV(sess);
3334 : : dpaa_sec_session *s = (dpaa_sec_session *)sess_priv;
3335 : :
3336 : : if (sess_priv) {
3337 : 0 : free_session_memory((struct rte_cryptodev *)dev, s);
3338 : : }
3339 : 0 : return 0;
3340 : : }
3341 : :
3342 : : static unsigned int
3343 : 0 : dpaa_sec_security_session_get_size(void *device __rte_unused)
3344 : : {
3345 : 0 : return sizeof(dpaa_sec_session);
3346 : : }
3347 : :
3348 : : static int
3349 : 0 : dpaa_sec_dev_configure(struct rte_cryptodev *dev __rte_unused,
3350 : : struct rte_cryptodev_config *config __rte_unused)
3351 : : {
3352 : 0 : PMD_INIT_FUNC_TRACE();
3353 : :
3354 : 0 : return 0;
3355 : : }
3356 : :
3357 : : static int
3358 : 0 : dpaa_sec_dev_start(struct rte_cryptodev *dev __rte_unused)
3359 : : {
3360 : 0 : PMD_INIT_FUNC_TRACE();
3361 : 0 : return 0;
3362 : : }
3363 : :
3364 : : static void
3365 : 0 : dpaa_sec_dev_stop(struct rte_cryptodev *dev __rte_unused)
3366 : : {
3367 : 0 : PMD_INIT_FUNC_TRACE();
3368 : 0 : }
3369 : :
3370 : : static int
3371 : 0 : dpaa_sec_dev_close(struct rte_cryptodev *dev)
3372 : : {
3373 : 0 : PMD_INIT_FUNC_TRACE();
3374 : :
3375 [ # # ]: 0 : if (dev == NULL)
3376 : 0 : return -ENOMEM;
3377 : :
3378 : : return 0;
3379 : : }
3380 : :
3381 : : static void
3382 : 0 : dpaa_sec_dev_infos_get(struct rte_cryptodev *dev,
3383 : : struct rte_cryptodev_info *info)
3384 : : {
3385 : 0 : struct dpaa_sec_dev_private *internals = dev->data->dev_private;
3386 : :
3387 : 0 : PMD_INIT_FUNC_TRACE();
3388 [ # # ]: 0 : if (info != NULL) {
3389 : 0 : info->max_nb_queue_pairs = internals->max_nb_queue_pairs;
3390 : 0 : info->feature_flags = dev->feature_flags;
3391 : 0 : info->capabilities = dpaa_sec_capabilities;
3392 : 0 : info->sym.max_nb_sessions = internals->max_nb_sessions;
3393 : 0 : info->driver_id = dpaa_cryptodev_driver_id;
3394 : : }
3395 : 0 : }
3396 : :
3397 : : static enum qman_cb_dqrr_result
3398 : 0 : dpaa_sec_process_parallel_event(void *event,
3399 : : struct qman_portal *qm __always_unused,
3400 : : struct qman_fq *outq,
3401 : : const struct qm_dqrr_entry *dqrr,
3402 : : void **bufs)
3403 : : {
3404 : : const struct qm_fd *fd;
3405 : : struct dpaa_sec_job *job;
3406 : : struct dpaa_sec_op_ctx *ctx;
3407 : : struct rte_event *ev = (struct rte_event *)event;
3408 : :
3409 : : fd = &dqrr->fd;
3410 : :
3411 : : /* sg is embedded in an op ctx,
3412 : : * sg[0] is for output
3413 : : * sg[1] for input
3414 : : */
3415 : 0 : job = rte_dpaa_mem_ptov(qm_fd_addr_get64(fd));
3416 : :
3417 : : ctx = container_of(job, struct dpaa_sec_op_ctx, job);
3418 : 0 : ctx->fd_status = fd->status;
3419 [ # # ]: 0 : if (ctx->op->sess_type == RTE_CRYPTO_OP_SECURITY_SESSION) {
3420 : : struct qm_sg_entry *sg_out;
3421 : : uint32_t len;
3422 : :
3423 : 0 : sg_out = &job->sg[0];
3424 : 0 : hw_sg_to_cpu(sg_out);
3425 : 0 : len = sg_out->length;
3426 : 0 : ctx->op->sym->m_src->pkt_len = len;
3427 : 0 : ctx->op->sym->m_src->data_len = len;
3428 : : }
3429 [ # # ]: 0 : if (!ctx->fd_status) {
3430 : 0 : ctx->op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
3431 : : } else {
3432 : 0 : DPAA_SEC_DP_WARN("SEC return err: 0x%x", ctx->fd_status);
3433 : 0 : ctx->op->status = RTE_CRYPTO_OP_STATUS_ERROR;
3434 : : }
3435 : 0 : ev->event_ptr = (void *)ctx->op;
3436 : :
3437 : 0 : ev->flow_id = outq->ev.flow_id;
3438 : 0 : ev->sub_event_type = outq->ev.sub_event_type;
3439 : 0 : ev->event_type = RTE_EVENT_TYPE_CRYPTODEV;
3440 : 0 : ev->op = RTE_EVENT_OP_NEW;
3441 : 0 : ev->sched_type = outq->ev.sched_type;
3442 : 0 : ev->queue_id = outq->ev.queue_id;
3443 : 0 : ev->priority = outq->ev.priority;
3444 : 0 : *bufs = (void *)ctx->op;
3445 : :
3446 [ # # ]: 0 : rte_mempool_put(ctx->ctx_pool, (void *)ctx);
3447 : :
3448 : 0 : return qman_cb_dqrr_consume;
3449 : : }
3450 : :
3451 : : static enum qman_cb_dqrr_result
3452 : 0 : dpaa_sec_process_atomic_event(void *event,
3453 : : struct qman_portal *qm __rte_unused,
3454 : : struct qman_fq *outq,
3455 : : const struct qm_dqrr_entry *dqrr,
3456 : : void **bufs)
3457 : : {
3458 : : u8 index;
3459 : : const struct qm_fd *fd;
3460 : : struct dpaa_sec_job *job;
3461 : : struct dpaa_sec_op_ctx *ctx;
3462 : : struct rte_event *ev = (struct rte_event *)event;
3463 : :
3464 : : fd = &dqrr->fd;
3465 : :
3466 : : /* sg is embedded in an op ctx,
3467 : : * sg[0] is for output
3468 : : * sg[1] for input
3469 : : */
3470 : 0 : job = rte_dpaa_mem_ptov(qm_fd_addr_get64(fd));
3471 : :
3472 : : ctx = container_of(job, struct dpaa_sec_op_ctx, job);
3473 : 0 : ctx->fd_status = fd->status;
3474 [ # # ]: 0 : if (ctx->op->sess_type == RTE_CRYPTO_OP_SECURITY_SESSION) {
3475 : : struct qm_sg_entry *sg_out;
3476 : : uint32_t len;
3477 : :
3478 : 0 : sg_out = &job->sg[0];
3479 : 0 : hw_sg_to_cpu(sg_out);
3480 : 0 : len = sg_out->length;
3481 : 0 : ctx->op->sym->m_src->pkt_len = len;
3482 : 0 : ctx->op->sym->m_src->data_len = len;
3483 : : }
3484 [ # # ]: 0 : if (!ctx->fd_status) {
3485 : 0 : ctx->op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
3486 : : } else {
3487 : 0 : DPAA_SEC_DP_WARN("SEC return err: 0x%x", ctx->fd_status);
3488 : 0 : ctx->op->status = RTE_CRYPTO_OP_STATUS_ERROR;
3489 : : }
3490 : 0 : ev->event_ptr = (void *)ctx->op;
3491 : 0 : ev->flow_id = outq->ev.flow_id;
3492 : 0 : ev->sub_event_type = outq->ev.sub_event_type;
3493 : 0 : ev->event_type = RTE_EVENT_TYPE_CRYPTODEV;
3494 : 0 : ev->op = RTE_EVENT_OP_NEW;
3495 : 0 : ev->sched_type = outq->ev.sched_type;
3496 : 0 : ev->queue_id = outq->ev.queue_id;
3497 : 0 : ev->priority = outq->ev.priority;
3498 : :
3499 : : /* Save active dqrr entries */
3500 : 0 : index = ((uintptr_t)dqrr >> 6) & (16/*QM_DQRR_SIZE*/ - 1);
3501 : 0 : DPAA_PER_LCORE_DQRR_SIZE++;
3502 : 0 : DPAA_PER_LCORE_DQRR_HELD |= UINT64_C(1) << index;
3503 : 0 : DPAA_PER_LCORE_DQRR_MBUF(index) = ctx->op->sym->m_src;
3504 : 0 : ev->impl_opaque = index + 1;
3505 [ # # ]: 0 : *dpaa_seqn(ctx->op->sym->m_src) = (uint32_t)index + 1;
3506 : 0 : *bufs = (void *)ctx->op;
3507 : :
3508 [ # # ]: 0 : rte_mempool_put(ctx->ctx_pool, (void *)ctx);
3509 : :
3510 : 0 : return qman_cb_dqrr_defer;
3511 : : }
3512 : :
3513 : : int
3514 : 0 : dpaa_sec_eventq_attach(const struct rte_cryptodev *dev,
3515 : : int qp_id,
3516 : : uint16_t ch_id,
3517 : : const struct rte_event *event)
3518 : : {
3519 : 0 : struct dpaa_sec_qp *qp = dev->data->queue_pairs[qp_id];
3520 : 0 : struct qm_mcc_initfq opts = {0};
3521 : :
3522 : : int ret;
3523 : :
3524 : 0 : opts.we_mask = QM_INITFQ_WE_DESTWQ | QM_INITFQ_WE_FQCTRL |
3525 : : QM_INITFQ_WE_CONTEXTA | QM_INITFQ_WE_CONTEXTB;
3526 : 0 : opts.fqd.dest.channel = ch_id;
3527 : :
3528 [ # # # ]: 0 : switch (event->sched_type) {
3529 : 0 : case RTE_SCHED_TYPE_ATOMIC:
3530 : 0 : opts.fqd.fq_ctrl |= QM_FQCTRL_HOLDACTIVE;
3531 : : /* Reset FQCTRL_AVOIDBLOCK bit as it is unnecessary
3532 : : * configuration with HOLD_ACTIVE setting
3533 : : */
3534 : : opts.fqd.fq_ctrl &= (~QM_FQCTRL_AVOIDBLOCK);
3535 : 0 : qp->outq.cb.dqrr_dpdk_cb = dpaa_sec_process_atomic_event;
3536 : 0 : break;
3537 : 0 : case RTE_SCHED_TYPE_ORDERED:
3538 : 0 : DPAA_SEC_ERR("Ordered queue schedule type is not supported");
3539 : 0 : return -ENOTSUP;
3540 : 0 : default:
3541 : 0 : opts.fqd.fq_ctrl |= QM_FQCTRL_AVOIDBLOCK;
3542 : 0 : qp->outq.cb.dqrr_dpdk_cb = dpaa_sec_process_parallel_event;
3543 : 0 : break;
3544 : : }
3545 : :
3546 : 0 : ret = qman_init_fq(&qp->outq, QMAN_INITFQ_FLAG_SCHED, &opts);
3547 [ # # ]: 0 : if (unlikely(ret)) {
3548 : 0 : DPAA_SEC_ERR("unable to init caam source fq!");
3549 : 0 : return ret;
3550 : : }
3551 : :
3552 : 0 : memcpy(&qp->outq.ev, event, sizeof(struct rte_event));
3553 : :
3554 : 0 : return 0;
3555 : : }
3556 : :
3557 : : int
3558 : 0 : dpaa_sec_eventq_detach(const struct rte_cryptodev *dev,
3559 : : int qp_id)
3560 : : {
3561 : 0 : struct qm_mcc_initfq opts = {0};
3562 : : int ret;
3563 : 0 : struct dpaa_sec_qp *qp = dev->data->queue_pairs[qp_id];
3564 : :
3565 : 0 : opts.we_mask = QM_INITFQ_WE_DESTWQ | QM_INITFQ_WE_FQCTRL |
3566 : : QM_INITFQ_WE_CONTEXTA | QM_INITFQ_WE_CONTEXTB;
3567 : 0 : qp->outq.cb.dqrr = dqrr_out_fq_cb_rx;
3568 : 0 : qp->outq.cb.ern = ern_sec_fq_handler;
3569 : 0 : qman_retire_fq(&qp->outq, NULL);
3570 : 0 : qman_oos_fq(&qp->outq);
3571 : 0 : ret = qman_init_fq(&qp->outq, 0, &opts);
3572 [ # # ]: 0 : if (ret)
3573 : 0 : DPAA_SEC_ERR("Error in qman_init_fq: ret: %d", ret);
3574 : 0 : qp->outq.cb.dqrr = NULL;
3575 : :
3576 : 0 : return ret;
3577 : : }
3578 : :
3579 : : static struct rte_cryptodev_ops crypto_ops = {
3580 : : .dev_configure = dpaa_sec_dev_configure,
3581 : : .dev_start = dpaa_sec_dev_start,
3582 : : .dev_stop = dpaa_sec_dev_stop,
3583 : : .dev_close = dpaa_sec_dev_close,
3584 : : .dev_infos_get = dpaa_sec_dev_infos_get,
3585 : : .queue_pair_setup = dpaa_sec_queue_pair_setup,
3586 : : .queue_pair_release = dpaa_sec_queue_pair_release,
3587 : : .sym_session_get_size = dpaa_sec_sym_session_get_size,
3588 : : .sym_session_configure = dpaa_sec_sym_session_configure,
3589 : : .sym_session_clear = dpaa_sec_sym_session_clear,
3590 : : /* Raw data-path API related operations */
3591 : : .sym_get_raw_dp_ctx_size = dpaa_sec_get_dp_ctx_size,
3592 : : .sym_configure_raw_dp_ctx = dpaa_sec_configure_raw_dp_ctx,
3593 : : };
3594 : :
3595 : : static const struct rte_security_capability *
3596 : 0 : dpaa_sec_capabilities_get(void *device __rte_unused)
3597 : : {
3598 : 0 : return dpaa_sec_security_cap;
3599 : : }
3600 : :
3601 : : static const struct rte_security_ops dpaa_sec_security_ops = {
3602 : : .session_create = dpaa_sec_security_session_create,
3603 : : .session_update = NULL,
3604 : : .session_get_size = dpaa_sec_security_session_get_size,
3605 : : .session_stats_get = NULL,
3606 : : .session_destroy = dpaa_sec_security_session_destroy,
3607 : : .set_pkt_metadata = NULL,
3608 : : .capabilities_get = dpaa_sec_capabilities_get
3609 : : };
3610 : :
3611 : : static int
3612 : 0 : dpaa_sec_uninit(struct rte_cryptodev *dev)
3613 : : {
3614 : : struct dpaa_sec_dev_private *internals;
3615 : :
3616 [ # # ]: 0 : if (dev == NULL)
3617 : : return -ENODEV;
3618 : :
3619 : 0 : internals = dev->data->dev_private;
3620 : 0 : rte_free(dev->security_ctx);
3621 : :
3622 : 0 : rte_free(internals);
3623 : :
3624 : 0 : DPAA_SEC_INFO("Closing DPAA_SEC device %s on numa socket %u",
3625 : : dev->data->name, rte_socket_id());
3626 : :
3627 : 0 : return 0;
3628 : : }
3629 : :
3630 : : static int
3631 : 0 : check_devargs_handler(__rte_unused const char *key, const char *value,
3632 : : __rte_unused void *opaque)
3633 : : {
3634 : 0 : dpaa_sec_dp_dump = atoi(value);
3635 [ # # ]: 0 : if (dpaa_sec_dp_dump > DPAA_SEC_DP_FULL_DUMP) {
3636 : 0 : DPAA_SEC_WARN("WARN: DPAA_SEC_DP_DUMP_LEVEL is not "
3637 : : "supported, changing to FULL error prints");
3638 : 0 : dpaa_sec_dp_dump = DPAA_SEC_DP_FULL_DUMP;
3639 : : }
3640 : :
3641 : 0 : return 0;
3642 : : }
3643 : :
3644 : : static void
3645 : 0 : dpaa_sec_get_devargs(struct rte_devargs *devargs, const char *key)
3646 : : {
3647 : : struct rte_kvargs *kvlist;
3648 : :
3649 [ # # ]: 0 : if (!devargs)
3650 : : return;
3651 : :
3652 : 0 : kvlist = rte_kvargs_parse(devargs->args, NULL);
3653 [ # # ]: 0 : if (!kvlist)
3654 : : return;
3655 : :
3656 [ # # ]: 0 : if (!rte_kvargs_count(kvlist, key)) {
3657 : 0 : rte_kvargs_free(kvlist);
3658 : 0 : return;
3659 : : }
3660 : :
3661 : 0 : rte_kvargs_process(kvlist, key,
3662 : : check_devargs_handler, NULL);
3663 : 0 : rte_kvargs_free(kvlist);
3664 : : }
3665 : :
3666 : : static int
3667 : 0 : dpaa_sec_dev_init(struct rte_cryptodev *cryptodev)
3668 : : {
3669 : : struct dpaa_sec_dev_private *internals;
3670 : : struct rte_security_ctx *security_instance;
3671 : : struct dpaa_sec_qp *qp;
3672 : : uint32_t i, flags;
3673 : : int ret;
3674 : : void *cmd_map;
3675 : : int map_fd = -1;
3676 : :
3677 : 0 : PMD_INIT_FUNC_TRACE();
3678 : :
3679 : 0 : internals = cryptodev->data->dev_private;
3680 : : map_fd = open("/dev/mem", O_RDWR);
3681 [ # # ]: 0 : if (unlikely(map_fd < 0)) {
3682 : 0 : DPAA_SEC_ERR("Unable to open (/dev/mem)");
3683 : 0 : return map_fd;
3684 : : }
3685 : 0 : internals->sec_hw = mmap(NULL, MAP_SIZE, PROT_READ | PROT_WRITE,
3686 : : MAP_SHARED, map_fd, SEC_BASE_ADDR);
3687 [ # # ]: 0 : if (internals->sec_hw == MAP_FAILED) {
3688 : 0 : DPAA_SEC_ERR("Memory map failed");
3689 : 0 : close(map_fd);
3690 : 0 : return -EINVAL;
3691 : : }
3692 : : cmd_map = (uint8_t *)internals->sec_hw +
3693 : : (BLOCK_OFFSET * QI_BLOCK_NUMBER) + CMD_REG;
3694 [ # # ]: 0 : if (!(be32_to_cpu(rte_read32(cmd_map)) & QICTL_DQEN))
3695 : : /* enable QI interface */
3696 : : rte_write32(cpu_to_be32(QICTL_DQEN), cmd_map);
3697 : :
3698 : 0 : ret = munmap(internals->sec_hw, MAP_SIZE);
3699 [ # # ]: 0 : if (ret)
3700 : 0 : DPAA_SEC_WARN("munmap failed");
3701 : :
3702 : 0 : close(map_fd);
3703 : 0 : cryptodev->driver_id = dpaa_cryptodev_driver_id;
3704 : 0 : cryptodev->dev_ops = &crypto_ops;
3705 : :
3706 : 0 : cryptodev->enqueue_burst = dpaa_sec_enqueue_burst;
3707 : 0 : cryptodev->dequeue_burst = dpaa_sec_dequeue_burst;
3708 : 0 : cryptodev->feature_flags = RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO |
3709 : : RTE_CRYPTODEV_FF_HW_ACCELERATED |
3710 : : RTE_CRYPTODEV_FF_SYM_OPERATION_CHAINING |
3711 : : RTE_CRYPTODEV_FF_SECURITY |
3712 : : RTE_CRYPTODEV_FF_SYM_RAW_DP |
3713 : : RTE_CRYPTODEV_FF_IN_PLACE_SGL |
3714 : : RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT |
3715 : : RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT |
3716 : : RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT |
3717 : : RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT;
3718 : :
3719 : 0 : internals->max_nb_queue_pairs = RTE_DPAA_MAX_NB_SEC_QPS;
3720 : 0 : internals->max_nb_sessions = RTE_DPAA_SEC_PMD_MAX_NB_SESSIONS;
3721 : :
3722 : : /*
3723 : : * For secondary processes, we don't initialise any further as primary
3724 : : * has already done this work. Only check we don't need a different
3725 : : * RX function
3726 : : */
3727 [ # # ]: 0 : if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
3728 : 0 : DPAA_SEC_WARN("Device already init by primary process");
3729 : 0 : return 0;
3730 : : }
3731 : : /* Initialize security_ctx only for primary process*/
3732 : 0 : security_instance = rte_malloc("rte_security_instances_ops",
3733 : : sizeof(struct rte_security_ctx), 0);
3734 [ # # ]: 0 : if (security_instance == NULL)
3735 : : return -ENOMEM;
3736 : 0 : security_instance->device = (void *)cryptodev;
3737 : 0 : security_instance->ops = &dpaa_sec_security_ops;
3738 : 0 : security_instance->sess_cnt = 0;
3739 : 0 : cryptodev->security_ctx = security_instance;
3740 : : rte_spinlock_init(&internals->lock);
3741 [ # # ]: 0 : for (i = 0; i < internals->max_nb_queue_pairs; i++) {
3742 : : /* init qman fq for queue pair */
3743 : : qp = &internals->qps[i];
3744 : 0 : ret = dpaa_sec_init_tx(&qp->outq);
3745 [ # # ]: 0 : if (ret) {
3746 : 0 : DPAA_SEC_ERR("config tx of queue pair %d", i);
3747 : 0 : goto init_error;
3748 : : }
3749 : : }
3750 : :
3751 : : flags = QMAN_FQ_FLAG_LOCKED | QMAN_FQ_FLAG_DYNAMIC_FQID |
3752 : : QMAN_FQ_FLAG_TO_DCPORTAL;
3753 [ # # ]: 0 : for (i = 0; i < RTE_DPAA_MAX_RX_QUEUE; i++) {
3754 : : /* create rx qman fq for sessions*/
3755 : 0 : ret = qman_create_fq(0, flags, &internals->inq[i]);
3756 [ # # ]: 0 : if (unlikely(ret != 0)) {
3757 : 0 : DPAA_SEC_ERR("sec qman_create_fq failed");
3758 : 0 : goto init_error;
3759 : : }
3760 : : }
3761 : :
3762 : 0 : dpaa_sec_get_devargs(cryptodev->device->devargs, DRIVER_DUMP_MODE);
3763 : :
3764 : 0 : DPAA_SEC_INFO("%s cryptodev init", cryptodev->data->name);
3765 : 0 : return 0;
3766 : :
3767 : 0 : init_error:
3768 : 0 : DPAA_SEC_ERR("driver %s: create failed", cryptodev->data->name);
3769 : :
3770 : 0 : rte_free(cryptodev->security_ctx);
3771 : 0 : return -EFAULT;
3772 : : }
3773 : :
3774 : : static int
3775 : 0 : cryptodev_dpaa_sec_probe(struct rte_dpaa_driver *dpaa_drv __rte_unused,
3776 : : struct rte_dpaa_device *dpaa_dev)
3777 : : {
3778 : : struct rte_cryptodev *cryptodev;
3779 : : char cryptodev_name[RTE_CRYPTODEV_NAME_MAX_LEN];
3780 : :
3781 : : int retval;
3782 : :
3783 [ # # ]: 0 : if (rte_eal_process_type() != RTE_PROC_PRIMARY)
3784 : : return 0;
3785 : :
3786 : 0 : snprintf(cryptodev_name, sizeof(cryptodev_name), "%s", dpaa_dev->name);
3787 : :
3788 : 0 : cryptodev = rte_cryptodev_pmd_allocate(cryptodev_name, rte_socket_id());
3789 [ # # ]: 0 : if (cryptodev == NULL)
3790 : : return -ENOMEM;
3791 : :
3792 : 0 : cryptodev->data->dev_private = rte_zmalloc_socket(
3793 : : "cryptodev private structure",
3794 : : sizeof(struct dpaa_sec_dev_private),
3795 : : RTE_CACHE_LINE_SIZE,
3796 : 0 : rte_socket_id());
3797 : :
3798 [ # # ]: 0 : if (cryptodev->data->dev_private == NULL)
3799 : 0 : rte_panic("Cannot allocate memzone for private "
3800 : : "device data");
3801 : :
3802 : 0 : dpaa_dev->crypto_dev = cryptodev;
3803 : 0 : cryptodev->device = &dpaa_dev->device;
3804 : :
3805 : : /* init user callbacks */
3806 [ # # ]: 0 : TAILQ_INIT(&(cryptodev->link_intr_cbs));
3807 : :
3808 : : /* if sec device version is not configured */
3809 [ # # ]: 0 : if (!rta_get_sec_era()) {
3810 : : const struct device_node *caam_node;
3811 : :
3812 [ # # ]: 0 : for_each_compatible_node(caam_node, NULL, "fsl,sec-v4.0") {
3813 : 0 : const uint32_t *prop = of_get_property(caam_node,
3814 : : "fsl,sec-era",
3815 : : NULL);
3816 [ # # ]: 0 : if (prop) {
3817 : 0 : rta_set_sec_era(
3818 [ # # ]: 0 : INTL_SEC_ERA(rte_cpu_to_be_32(*prop)));
3819 : 0 : break;
3820 : : }
3821 : : }
3822 : : }
3823 : :
3824 [ # # ]: 0 : if (unlikely(!DPAA_PER_LCORE_PORTAL)) {
3825 : 0 : retval = rte_dpaa_portal_init((void *)1);
3826 [ # # ]: 0 : if (retval) {
3827 : 0 : DPAA_SEC_ERR("Unable to initialize portal");
3828 : 0 : goto out;
3829 : : }
3830 : : }
3831 : :
3832 : : /* Invoke PMD device initialization function */
3833 : 0 : retval = dpaa_sec_dev_init(cryptodev);
3834 [ # # ]: 0 : if (retval == 0) {
3835 : 0 : rte_cryptodev_pmd_probing_finish(cryptodev);
3836 : 0 : return 0;
3837 : : }
3838 : :
3839 : : retval = -ENXIO;
3840 : 0 : out:
3841 : : /* In case of error, cleanup is done */
3842 : 0 : rte_free(cryptodev->data->dev_private);
3843 : :
3844 : 0 : rte_cryptodev_pmd_release_device(cryptodev);
3845 : :
3846 : 0 : return retval;
3847 : : }
3848 : :
3849 : : static int
3850 : 0 : cryptodev_dpaa_sec_remove(struct rte_dpaa_device *dpaa_dev)
3851 : : {
3852 : : struct rte_cryptodev *cryptodev;
3853 : : int ret;
3854 : :
3855 : 0 : cryptodev = dpaa_dev->crypto_dev;
3856 [ # # ]: 0 : if (cryptodev == NULL)
3857 : : return -ENODEV;
3858 : :
3859 : 0 : ret = dpaa_sec_uninit(cryptodev);
3860 [ # # ]: 0 : if (ret)
3861 : : return ret;
3862 : :
3863 : 0 : return rte_cryptodev_pmd_destroy(cryptodev);
3864 : : }
3865 : :
3866 : : static struct rte_dpaa_driver rte_dpaa_sec_driver = {
3867 : : .drv_type = FSL_DPAA_CRYPTO,
3868 : : .driver = {
3869 : : .name = "DPAA SEC PMD"
3870 : : },
3871 : : .probe = cryptodev_dpaa_sec_probe,
3872 : : .remove = cryptodev_dpaa_sec_remove,
3873 : : };
3874 : :
3875 : : static struct cryptodev_driver dpaa_sec_crypto_drv;
3876 : :
3877 : 252 : RTE_PMD_REGISTER_DPAA(CRYPTODEV_NAME_DPAA_SEC_PMD, rte_dpaa_sec_driver);
3878 : 252 : RTE_PMD_REGISTER_CRYPTO_DRIVER(dpaa_sec_crypto_drv, rte_dpaa_sec_driver.driver,
3879 : : dpaa_cryptodev_driver_id);
3880 : : RTE_PMD_REGISTER_PARAM_STRING(CRYPTODEV_NAME_DPAA_SEC_PMD,
3881 : : DRIVER_DUMP_MODE "=<int>");
3882 [ - + ]: 252 : RTE_LOG_REGISTER(dpaa_logtype_sec, pmd.crypto.dpaa, NOTICE);
|
