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