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