Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2018 Intel Corporation.
3 : : * All rights reserved.
4 : : */
5 : :
6 : : #include <string.h>
7 : : #include <stdbool.h>
8 : : #include <eal_export.h>
9 : : #include <rte_common.h>
10 : : #include <dev_driver.h>
11 : : #include <rte_errno.h>
12 : : #include <rte_cryptodev.h>
13 : : #include <cryptodev_pmd.h>
14 : : #include <rte_log.h>
15 : : #include <rte_malloc.h>
16 : : #include <rte_service_component.h>
17 : :
18 : : #include "rte_eventdev.h"
19 : : #include "eventdev_pmd.h"
20 : : #include "eventdev_trace.h"
21 : : #include "rte_event_crypto_adapter.h"
22 : :
23 : : #define BATCH_SIZE 32
24 : : #define DEFAULT_MAX_NB 128
25 : : #define CRYPTO_ADAPTER_NAME_LEN 32
26 : : #define CRYPTO_ADAPTER_MEM_NAME_LEN 32
27 : : #define CRYPTO_ADAPTER_MAX_EV_ENQ_RETRIES 100
28 : :
29 : : /* MAX_OPS_IN_BUFFER contains size for batch of dequeued events */
30 : : #define MAX_OPS_IN_BUFFER BATCH_SIZE
31 : :
32 : : /* CRYPTO_ADAPTER_OPS_BUFFER_SZ to accommodate MAX_OPS_IN_BUFFER +
33 : : * additional space for one batch
34 : : */
35 : : #define CRYPTO_ADAPTER_OPS_BUFFER_SZ (MAX_OPS_IN_BUFFER + BATCH_SIZE)
36 : :
37 : : #define CRYPTO_ADAPTER_BUFFER_SZ 1024
38 : :
39 : : /* Flush an instance's enqueue buffers every CRYPTO_ENQ_FLUSH_THRESHOLD
40 : : * iterations of eca_crypto_adapter_enq_run()
41 : : */
42 : : #define CRYPTO_ENQ_FLUSH_THRESHOLD 1024
43 : :
44 : : #define ECA_ADAPTER_ARRAY "crypto_adapter_array"
45 : :
46 : : struct __rte_cache_aligned crypto_ops_circular_buffer {
47 : : /* index of head element in circular buffer */
48 : : uint16_t head;
49 : : /* index of tail element in circular buffer */
50 : : uint16_t tail;
51 : : /* number of elements in buffer */
52 : : uint16_t count;
53 : : /* size of circular buffer */
54 : : uint16_t size;
55 : : /* Pointer to hold rte_crypto_ops for batching */
56 : : struct rte_crypto_op **op_buffer;
57 : : };
58 : :
59 : : struct __rte_cache_aligned event_crypto_adapter {
60 : : /* Event device identifier */
61 : : uint8_t eventdev_id;
62 : : /* Event port identifier */
63 : : uint8_t event_port_id;
64 : : /* Store event port's implicit release capability */
65 : : uint8_t implicit_release_disabled;
66 : : /* Flag to indicate backpressure at cryptodev
67 : : * Stop further dequeuing events from eventdev
68 : : */
69 : : bool stop_enq_to_cryptodev;
70 : : /* Max crypto ops processed in any service function invocation */
71 : : uint32_t max_nb;
72 : : /* Lock to serialize config updates with service function */
73 : : rte_spinlock_t lock;
74 : : /* Next crypto device to be processed */
75 : : uint16_t next_cdev_id;
76 : : /* Per crypto device structure */
77 : : struct crypto_device_info *cdevs;
78 : : /* Loop counter to flush crypto ops */
79 : : uint16_t transmit_loop_count;
80 : : /* Circular buffer for batching crypto ops to eventdev */
81 : : struct crypto_ops_circular_buffer ebuf;
82 : : /* Per instance stats structure */
83 : : struct rte_event_crypto_adapter_stats crypto_stats;
84 : : /* Configuration callback for rte_service configuration */
85 : : rte_event_crypto_adapter_conf_cb conf_cb;
86 : : /* Configuration callback argument */
87 : : void *conf_arg;
88 : : /* Set if default_cb is being used */
89 : : int default_cb_arg;
90 : : /* Service initialization state */
91 : : uint8_t service_inited;
92 : : /* Memory allocation name */
93 : : char mem_name[CRYPTO_ADAPTER_MEM_NAME_LEN];
94 : : /* Socket identifier cached from eventdev */
95 : : int socket_id;
96 : : /* Per adapter EAL service */
97 : : uint32_t service_id;
98 : : /* No. of queue pairs configured */
99 : : uint16_t nb_qps;
100 : : /* Adapter mode */
101 : : enum rte_event_crypto_adapter_mode mode;
102 : : };
103 : :
104 : : /* Per crypto device information */
105 : : struct __rte_cache_aligned crypto_device_info {
106 : : /* Pointer to cryptodev */
107 : : struct rte_cryptodev *dev;
108 : : /* Pointer to queue pair info */
109 : : struct crypto_queue_pair_info *qpairs;
110 : : /* Next queue pair to be processed */
111 : : uint16_t next_queue_pair_id;
112 : : /* Set to indicate cryptodev->eventdev packet
113 : : * transfer uses a hardware mechanism
114 : : */
115 : : uint8_t internal_event_port;
116 : : /* Set to indicate processing has been started */
117 : : uint8_t dev_started;
118 : : /* If num_qpairs > 0, the start callback will
119 : : * be invoked if not already invoked
120 : : */
121 : : uint16_t num_qpairs;
122 : : };
123 : :
124 : : /* Per queue pair information */
125 : : struct __rte_cache_aligned crypto_queue_pair_info {
126 : : /* Set to indicate queue pair is enabled */
127 : : bool qp_enabled;
128 : : /* Circular buffer for batching crypto ops to cdev */
129 : : struct crypto_ops_circular_buffer cbuf;
130 : : };
131 : :
132 : : static struct event_crypto_adapter **event_crypto_adapter;
133 : :
134 : : /* Macros to check for valid adapter */
135 : : #define EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, retval) do { \
136 : : if (!eca_valid_id(id)) { \
137 : : RTE_EDEV_LOG_ERR("Invalid crypto adapter id = %d", id); \
138 : : return retval; \
139 : : } \
140 : : } while (0)
141 : :
142 : : #define ECA_DYNFIELD_NAME "eca_ev_opaque_data"
143 : : /* Device-specific metadata field type */
144 : : typedef uint8_t eca_dynfield_t;
145 : :
146 : : /* mbuf dynamic field offset for device-specific metadata */
147 : : int eca_dynfield_offset = -1;
148 : :
149 : : static int
150 : : eca_dynfield_register(void)
151 : : {
152 : : static const struct rte_mbuf_dynfield eca_dynfield_desc = {
153 : : .name = ECA_DYNFIELD_NAME,
154 : : .size = sizeof(eca_dynfield_t),
155 : : .align = alignof(eca_dynfield_t),
156 : : .flags = 0,
157 : : };
158 : :
159 : 0 : eca_dynfield_offset =
160 : 0 : rte_mbuf_dynfield_register(&eca_dynfield_desc);
161 : : return eca_dynfield_offset;
162 : : }
163 : :
164 : : static inline int
165 : : eca_valid_id(uint8_t id)
166 : : {
167 : : return id < RTE_EVENT_CRYPTO_ADAPTER_MAX_INSTANCE;
168 : : }
169 : :
170 : : static int
171 : 0 : eca_init(void)
172 : : {
173 : : const struct rte_memzone *mz;
174 : : unsigned int sz;
175 : :
176 : : sz = sizeof(*event_crypto_adapter) *
177 : : RTE_EVENT_CRYPTO_ADAPTER_MAX_INSTANCE;
178 : : sz = RTE_ALIGN(sz, RTE_CACHE_LINE_SIZE);
179 : :
180 : 0 : mz = rte_memzone_lookup(ECA_ADAPTER_ARRAY);
181 [ # # ]: 0 : if (mz == NULL) {
182 : 0 : mz = rte_memzone_reserve_aligned(ECA_ADAPTER_ARRAY, sz,
183 : 0 : rte_socket_id(), 0,
184 : : RTE_CACHE_LINE_SIZE);
185 [ # # ]: 0 : if (mz == NULL) {
186 : 0 : RTE_EDEV_LOG_ERR("failed to reserve memzone err = %"
187 : : PRId32, rte_errno);
188 : 0 : return -rte_errno;
189 : : }
190 : : }
191 : :
192 : 0 : event_crypto_adapter = mz->addr;
193 : 0 : return 0;
194 : : }
195 : :
196 : : static int
197 : 0 : eca_memzone_lookup(void)
198 : : {
199 : : const struct rte_memzone *mz;
200 : :
201 [ # # ]: 0 : if (event_crypto_adapter == NULL) {
202 : 0 : mz = rte_memzone_lookup(ECA_ADAPTER_ARRAY);
203 [ # # ]: 0 : if (mz == NULL)
204 : : return -ENOMEM;
205 : :
206 : 0 : event_crypto_adapter = mz->addr;
207 : : }
208 : :
209 : : return 0;
210 : : }
211 : :
212 : : static inline bool
213 : : eca_circular_buffer_batch_ready(struct crypto_ops_circular_buffer *bufp)
214 : : {
215 : : return bufp->count >= BATCH_SIZE;
216 : : }
217 : :
218 : : static inline bool
219 : : eca_circular_buffer_space_for_batch(struct crypto_ops_circular_buffer *bufp)
220 : : {
221 : : /* circular buffer can have atmost MAX_OPS_IN_BUFFER */
222 : 0 : return (bufp->size - bufp->count) >= MAX_OPS_IN_BUFFER;
223 : : }
224 : :
225 : : static inline void
226 : : eca_circular_buffer_free(struct crypto_ops_circular_buffer *bufp)
227 : : {
228 : 0 : rte_free(bufp->op_buffer);
229 : : }
230 : :
231 : : static inline int
232 : : eca_circular_buffer_init(const char *name,
233 : : struct crypto_ops_circular_buffer *bufp,
234 : : uint16_t sz)
235 : : {
236 : 0 : bufp->op_buffer = rte_zmalloc(name,
237 : : sizeof(struct rte_crypto_op *) * sz,
238 : : 0);
239 [ # # # # ]: 0 : if (bufp->op_buffer == NULL)
240 : : return -ENOMEM;
241 : :
242 : 0 : bufp->size = sz;
243 : : return 0;
244 : : }
245 : :
246 : : static inline int
247 : : eca_circular_buffer_add(struct crypto_ops_circular_buffer *bufp,
248 : : struct rte_crypto_op *op)
249 : : {
250 : : uint16_t *tailp = &bufp->tail;
251 : :
252 : 0 : bufp->op_buffer[*tailp] = op;
253 : : /* circular buffer, go round */
254 : 0 : *tailp = (*tailp + 1) % bufp->size;
255 : 0 : bufp->count++;
256 : :
257 : : return 0;
258 : : }
259 : :
260 : : static inline int
261 : 0 : eca_circular_buffer_flush_to_cdev(struct crypto_ops_circular_buffer *bufp,
262 : : uint8_t cdev_id, uint16_t qp_id,
263 : : uint16_t *nb_ops_flushed)
264 : : {
265 : : uint16_t n = 0;
266 : : uint16_t *headp = &bufp->head;
267 : : uint16_t *tailp = &bufp->tail;
268 : 0 : struct rte_crypto_op **ops = bufp->op_buffer;
269 : :
270 [ # # ]: 0 : if (*tailp > *headp)
271 : : /* Flush ops from head pointer to (tail - head) OPs */
272 : 0 : n = *tailp - *headp;
273 [ # # ]: 0 : else if (*tailp < *headp)
274 : : /* Circ buffer - Rollover.
275 : : * Flush OPs from head to max size of buffer.
276 : : * Rest of the OPs will be flushed in next iteration.
277 : : */
278 : 0 : n = bufp->size - *headp;
279 : : else { /* head == tail case */
280 : : /* when head == tail,
281 : : * circ buff is either full(tail pointer roll over) or empty
282 : : */
283 [ # # ]: 0 : if (bufp->count != 0) {
284 : : /* Circ buffer - FULL.
285 : : * Flush OPs from head to max size of buffer.
286 : : * Rest of the OPS will be flushed in next iteration.
287 : : */
288 : 0 : n = bufp->size - *headp;
289 : : } else {
290 : : /* Circ buffer - Empty */
291 : 0 : *nb_ops_flushed = 0;
292 : 0 : return 0;
293 : : }
294 : : }
295 : :
296 : 0 : *nb_ops_flushed = rte_cryptodev_enqueue_burst(cdev_id, qp_id,
297 : 0 : &ops[*headp], n);
298 : 0 : bufp->count -= *nb_ops_flushed;
299 [ # # ]: 0 : if (!bufp->count) {
300 : 0 : *headp = 0;
301 : 0 : *tailp = 0;
302 : : } else
303 : 0 : *headp = (*headp + *nb_ops_flushed) % bufp->size;
304 : :
305 [ # # ]: 0 : return *nb_ops_flushed == n ? 0 : -1;
306 : : }
307 : :
308 : : static inline struct event_crypto_adapter *
309 : : eca_id_to_adapter(uint8_t id)
310 : : {
311 : 0 : return event_crypto_adapter ?
312 [ # # # # : 0 : event_crypto_adapter[id] : NULL;
# # # # #
# # # # #
# # # # #
# # # #
# ]
313 : : }
314 : :
315 : : static int
316 [ # # ]: 0 : eca_default_config_cb(uint8_t id, uint8_t dev_id,
317 : : struct rte_event_crypto_adapter_conf *conf, void *arg)
318 : : {
319 : : struct rte_event_dev_config dev_conf;
320 : : struct rte_eventdev *dev;
321 : : uint8_t port_id;
322 : : int started;
323 : : int ret;
324 : : struct rte_event_port_conf *port_conf = arg;
325 : : struct event_crypto_adapter *adapter = eca_id_to_adapter(id);
326 : :
327 [ # # ]: 0 : if (adapter == NULL)
328 : : return -EINVAL;
329 : :
330 : 0 : dev = &rte_eventdevs[adapter->eventdev_id];
331 : 0 : dev_conf = dev->data->dev_conf;
332 : :
333 : 0 : started = dev->data->dev_started;
334 [ # # ]: 0 : if (started)
335 : 0 : rte_event_dev_stop(dev_id);
336 : 0 : port_id = dev_conf.nb_event_ports;
337 : 0 : dev_conf.nb_event_ports += 1;
338 [ # # ]: 0 : if (port_conf->event_port_cfg & RTE_EVENT_PORT_CFG_SINGLE_LINK)
339 : 0 : dev_conf.nb_single_link_event_port_queues += 1;
340 : :
341 : 0 : ret = rte_event_dev_configure(dev_id, &dev_conf);
342 [ # # ]: 0 : if (ret) {
343 : 0 : RTE_EDEV_LOG_ERR("failed to configure event dev %u", dev_id);
344 [ # # ]: 0 : if (started) {
345 [ # # ]: 0 : if (rte_event_dev_start(dev_id))
346 : : return -EIO;
347 : : }
348 : 0 : return ret;
349 : : }
350 : :
351 : 0 : ret = rte_event_port_setup(dev_id, port_id, port_conf);
352 [ # # ]: 0 : if (ret) {
353 : 0 : RTE_EDEV_LOG_ERR("failed to setup event port %u", port_id);
354 : 0 : return ret;
355 : : }
356 : :
357 : 0 : conf->event_port_id = port_id;
358 : 0 : conf->max_nb = DEFAULT_MAX_NB;
359 [ # # ]: 0 : if (started)
360 : 0 : ret = rte_event_dev_start(dev_id);
361 : :
362 : 0 : adapter->default_cb_arg = 1;
363 : 0 : return ret;
364 : : }
365 : :
366 : : RTE_EXPORT_SYMBOL(rte_event_crypto_adapter_create_ext)
367 : : int
368 : 0 : rte_event_crypto_adapter_create_ext(uint8_t id, uint8_t dev_id,
369 : : rte_event_crypto_adapter_conf_cb conf_cb,
370 : : enum rte_event_crypto_adapter_mode mode,
371 : : void *conf_arg)
372 : : {
373 : : struct event_crypto_adapter *adapter;
374 : : char mem_name[CRYPTO_ADAPTER_NAME_LEN];
375 : : int socket_id;
376 : : uint8_t i;
377 : : int ret;
378 : :
379 [ # # ]: 0 : EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
380 [ # # ]: 0 : RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
381 [ # # ]: 0 : if (conf_cb == NULL)
382 : : return -EINVAL;
383 : :
384 [ # # ]: 0 : if (event_crypto_adapter == NULL) {
385 : 0 : ret = eca_init();
386 [ # # ]: 0 : if (ret)
387 : : return ret;
388 : : }
389 : :
390 : : adapter = eca_id_to_adapter(id);
391 [ # # ]: 0 : if (adapter != NULL) {
392 : 0 : RTE_EDEV_LOG_ERR("Crypto adapter id %u already exists!", id);
393 : 0 : return -EEXIST;
394 : : }
395 : :
396 : 0 : socket_id = rte_event_dev_socket_id(dev_id);
397 : : snprintf(mem_name, CRYPTO_ADAPTER_MEM_NAME_LEN,
398 : : "rte_event_crypto_adapter_%d", id);
399 : :
400 : 0 : adapter = rte_zmalloc_socket(mem_name, sizeof(*adapter),
401 : : RTE_CACHE_LINE_SIZE, socket_id);
402 [ # # ]: 0 : if (adapter == NULL) {
403 : 0 : RTE_EDEV_LOG_ERR("Failed to get mem for event crypto adapter!");
404 : 0 : return -ENOMEM;
405 : : }
406 : :
407 : : if (eca_circular_buffer_init("eca_edev_circular_buffer",
408 : : &adapter->ebuf,
409 : : CRYPTO_ADAPTER_BUFFER_SZ)) {
410 : 0 : RTE_EDEV_LOG_ERR("Failed to get memory for eventdev buffer");
411 : 0 : rte_free(adapter);
412 : 0 : return -ENOMEM;
413 : : }
414 : :
415 : 0 : adapter->eventdev_id = dev_id;
416 : 0 : adapter->socket_id = socket_id;
417 : 0 : adapter->conf_cb = conf_cb;
418 : 0 : adapter->conf_arg = conf_arg;
419 : 0 : adapter->mode = mode;
420 : 0 : strcpy(adapter->mem_name, mem_name);
421 : 0 : adapter->cdevs = rte_zmalloc_socket(adapter->mem_name,
422 : 0 : rte_cryptodev_count() *
423 : : sizeof(struct crypto_device_info), 0,
424 : : socket_id);
425 [ # # ]: 0 : if (adapter->cdevs == NULL) {
426 : 0 : RTE_EDEV_LOG_ERR("Failed to get mem for crypto devices");
427 : : eca_circular_buffer_free(&adapter->ebuf);
428 : 0 : rte_free(adapter);
429 : 0 : return -ENOMEM;
430 : : }
431 : :
432 : : rte_spinlock_init(&adapter->lock);
433 [ # # ]: 0 : for (i = 0; i < rte_cryptodev_count(); i++)
434 : 0 : adapter->cdevs[i].dev = rte_cryptodev_pmd_get_dev(i);
435 : :
436 : 0 : event_crypto_adapter[id] = adapter;
437 : :
438 : 0 : return 0;
439 : : }
440 : :
441 : :
442 : : RTE_EXPORT_SYMBOL(rte_event_crypto_adapter_create)
443 : : int
444 : 0 : rte_event_crypto_adapter_create(uint8_t id, uint8_t dev_id,
445 : : struct rte_event_port_conf *port_config,
446 : : enum rte_event_crypto_adapter_mode mode)
447 : : {
448 : : struct rte_event_port_conf *pc;
449 : : int ret;
450 : :
451 [ # # ]: 0 : if (port_config == NULL)
452 : : return -EINVAL;
453 [ # # ]: 0 : EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
454 : :
455 : 0 : pc = rte_malloc(NULL, sizeof(*pc), 0);
456 [ # # ]: 0 : if (pc == NULL)
457 : : return -ENOMEM;
458 : 0 : *pc = *port_config;
459 : 0 : ret = rte_event_crypto_adapter_create_ext(id, dev_id,
460 : : eca_default_config_cb,
461 : : mode,
462 : : pc);
463 [ # # ]: 0 : if (ret)
464 : 0 : rte_free(pc);
465 : :
466 [ # # ]: 0 : rte_eventdev_trace_crypto_adapter_create(id, dev_id, port_config, mode, ret);
467 : :
468 : 0 : return ret;
469 : : }
470 : :
471 : : RTE_EXPORT_SYMBOL(rte_event_crypto_adapter_free)
472 : : int
473 : 0 : rte_event_crypto_adapter_free(uint8_t id)
474 : : {
475 : : struct event_crypto_adapter *adapter;
476 : :
477 [ # # ]: 0 : EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
478 : :
479 : : adapter = eca_id_to_adapter(id);
480 [ # # ]: 0 : if (adapter == NULL)
481 : : return -EINVAL;
482 : :
483 [ # # ]: 0 : if (adapter->nb_qps) {
484 : 0 : RTE_EDEV_LOG_ERR("%" PRIu16 "Queue pairs not deleted",
485 : : adapter->nb_qps);
486 : 0 : return -EBUSY;
487 : : }
488 : :
489 : 0 : rte_eventdev_trace_crypto_adapter_free(id, adapter);
490 [ # # ]: 0 : if (adapter->default_cb_arg)
491 : 0 : rte_free(adapter->conf_arg);
492 : 0 : rte_free(adapter->cdevs);
493 : 0 : rte_free(adapter);
494 : 0 : event_crypto_adapter[id] = NULL;
495 : :
496 : 0 : return 0;
497 : : }
498 : :
499 : : static inline unsigned int
500 : 0 : eca_enq_to_cryptodev(struct event_crypto_adapter *adapter, struct rte_event *ev,
501 : : unsigned int cnt)
502 : : {
503 : : struct rte_event_crypto_adapter_stats *stats = &adapter->crypto_stats;
504 : : union rte_event_crypto_metadata *m_data = NULL;
505 : : struct crypto_queue_pair_info *qp_info = NULL;
506 : : struct rte_crypto_op *crypto_op;
507 : : unsigned int i, n;
508 : 0 : uint16_t qp_id, nb_enqueued = 0;
509 : : uint8_t cdev_id;
510 : : int ret;
511 : :
512 : : ret = 0;
513 : : n = 0;
514 : 0 : stats->event_deq_count += cnt;
515 : :
516 [ # # ]: 0 : for (i = 0; i < cnt; i++) {
517 : 0 : crypto_op = ev[i].event_ptr;
518 [ # # ]: 0 : if (crypto_op == NULL)
519 : 0 : continue;
520 : :
521 : : /** "struct rte_event::impl_opaque" field passed on from
522 : : * eventdev PMD could have different value per event.
523 : : * For session-based crypto operations retain
524 : : * "struct rte_event::impl_opaque" into mbuf dynamic field and
525 : : * restore it back after copying event information from
526 : : * session event metadata.
527 : : * For session-less, each crypto operation carries event
528 : : * metadata and retains "struct rte_event:impl_opaque"
529 : : * information to be passed back to eventdev PMD.
530 : : */
531 [ # # ]: 0 : if (crypto_op->sess_type == RTE_CRYPTO_OP_WITH_SESSION) {
532 : 0 : struct rte_mbuf *mbuf = crypto_op->sym->m_src;
533 : :
534 : 0 : *RTE_MBUF_DYNFIELD(mbuf,
535 : : eca_dynfield_offset,
536 : 0 : eca_dynfield_t *) = ev[i].impl_opaque;
537 : : }
538 : :
539 : 0 : m_data = rte_cryptodev_session_event_mdata_get(crypto_op);
540 [ # # ]: 0 : if (m_data == NULL) {
541 : 0 : rte_pktmbuf_free(crypto_op->sym->m_src);
542 : 0 : rte_crypto_op_free(crypto_op);
543 : 0 : continue;
544 : : }
545 : :
546 : 0 : cdev_id = m_data->request_info.cdev_id;
547 : 0 : qp_id = m_data->request_info.queue_pair_id;
548 : 0 : qp_info = &adapter->cdevs[cdev_id].qpairs[qp_id];
549 [ # # ]: 0 : if (!qp_info->qp_enabled) {
550 : 0 : rte_pktmbuf_free(crypto_op->sym->m_src);
551 : 0 : rte_crypto_op_free(crypto_op);
552 : 0 : continue;
553 : : }
554 : 0 : eca_circular_buffer_add(&qp_info->cbuf, crypto_op);
555 : :
556 [ # # ]: 0 : if (eca_circular_buffer_batch_ready(&qp_info->cbuf)) {
557 : 0 : ret = eca_circular_buffer_flush_to_cdev(&qp_info->cbuf,
558 : : cdev_id,
559 : : qp_id,
560 : : &nb_enqueued);
561 : 0 : stats->crypto_enq_count += nb_enqueued;
562 : 0 : n += nb_enqueued;
563 : :
564 : : /**
565 : : * If some crypto ops failed to flush to cdev and
566 : : * space for another batch is not available, stop
567 : : * dequeue from eventdev momentarily
568 : : */
569 [ # # # # ]: 0 : if (unlikely(ret < 0 &&
570 : : !eca_circular_buffer_space_for_batch(
571 : : &qp_info->cbuf)))
572 : 0 : adapter->stop_enq_to_cryptodev = true;
573 : : }
574 : : }
575 : :
576 : 0 : return n;
577 : : }
578 : :
579 : : static unsigned int
580 : 0 : eca_crypto_cdev_flush(struct event_crypto_adapter *adapter,
581 : : uint8_t cdev_id, uint16_t *nb_ops_flushed)
582 : : {
583 : : struct crypto_device_info *curr_dev;
584 : : struct crypto_queue_pair_info *curr_queue;
585 : : struct rte_cryptodev *dev;
586 : 0 : uint16_t nb = 0, nb_enqueued = 0;
587 : : uint16_t qp;
588 : :
589 : 0 : curr_dev = &adapter->cdevs[cdev_id];
590 : 0 : dev = rte_cryptodev_pmd_get_dev(cdev_id);
591 : :
592 [ # # ]: 0 : for (qp = 0; qp < dev->data->nb_queue_pairs; qp++) {
593 : :
594 : 0 : curr_queue = &curr_dev->qpairs[qp];
595 [ # # # # ]: 0 : if (unlikely(curr_queue == NULL || !curr_queue->qp_enabled))
596 : 0 : continue;
597 : :
598 : 0 : eca_circular_buffer_flush_to_cdev(&curr_queue->cbuf,
599 : : cdev_id,
600 : : qp,
601 : : &nb_enqueued);
602 : 0 : *nb_ops_flushed += curr_queue->cbuf.count;
603 : 0 : nb += nb_enqueued;
604 : : }
605 : :
606 : 0 : return nb;
607 : : }
608 : :
609 : : static unsigned int
610 : 0 : eca_crypto_enq_flush(struct event_crypto_adapter *adapter)
611 : : {
612 : : struct rte_event_crypto_adapter_stats *stats = &adapter->crypto_stats;
613 : : uint8_t cdev_id;
614 : : uint16_t nb_enqueued = 0;
615 : 0 : uint16_t nb_ops_flushed = 0;
616 : 0 : uint16_t num_cdev = rte_cryptodev_count();
617 : :
618 [ # # ]: 0 : for (cdev_id = 0; cdev_id < num_cdev; cdev_id++)
619 : 0 : nb_enqueued += eca_crypto_cdev_flush(adapter,
620 : : cdev_id,
621 : : &nb_ops_flushed);
622 : : /**
623 : : * Enable dequeue from eventdev if all ops from circular
624 : : * buffer flushed to cdev
625 : : */
626 [ # # ]: 0 : if (!nb_ops_flushed)
627 : 0 : adapter->stop_enq_to_cryptodev = false;
628 : :
629 : 0 : stats->crypto_enq_count += nb_enqueued;
630 : :
631 : 0 : return nb_enqueued;
632 : : }
633 : :
634 : : static int
635 : 0 : eca_crypto_adapter_enq_run(struct event_crypto_adapter *adapter,
636 : : unsigned int max_enq)
637 : : {
638 : : struct rte_event_crypto_adapter_stats *stats = &adapter->crypto_stats;
639 : : struct rte_event ev[BATCH_SIZE];
640 : : unsigned int nb_enq, nb_enqueued;
641 : : uint16_t n;
642 : 0 : uint8_t event_dev_id = adapter->eventdev_id;
643 : 0 : uint8_t event_port_id = adapter->event_port_id;
644 : :
645 : : nb_enqueued = 0;
646 [ # # ]: 0 : if (adapter->mode == RTE_EVENT_CRYPTO_ADAPTER_OP_NEW)
647 : : return 0;
648 : :
649 [ # # ]: 0 : for (nb_enq = 0; nb_enq < max_enq; nb_enq += n) {
650 : :
651 [ # # ]: 0 : if (unlikely(adapter->stop_enq_to_cryptodev)) {
652 : 0 : nb_enqueued += eca_crypto_enq_flush(adapter);
653 : :
654 [ # # ]: 0 : if (unlikely(adapter->stop_enq_to_cryptodev))
655 : : break;
656 : : }
657 : :
658 : 0 : stats->event_poll_count++;
659 : 0 : n = rte_event_dequeue_burst(event_dev_id,
660 : : event_port_id, ev, BATCH_SIZE, 0);
661 : :
662 [ # # ]: 0 : if (!n)
663 : : break;
664 : :
665 : 0 : nb_enqueued += eca_enq_to_cryptodev(adapter, ev, n);
666 : : }
667 : :
668 [ # # ]: 0 : if ((++adapter->transmit_loop_count &
669 : : (CRYPTO_ENQ_FLUSH_THRESHOLD - 1)) == 0) {
670 : 0 : nb_enqueued += eca_crypto_enq_flush(adapter);
671 : : }
672 : :
673 : 0 : return nb_enqueued;
674 : : }
675 : :
676 : : static inline uint16_t
677 : 0 : eca_ops_enqueue_burst(struct event_crypto_adapter *adapter,
678 : : struct rte_crypto_op **ops, uint16_t num)
679 : : {
680 : : struct rte_event_crypto_adapter_stats *stats = &adapter->crypto_stats;
681 : : union rte_event_crypto_metadata *m_data = NULL;
682 : 0 : uint8_t event_dev_id = adapter->eventdev_id;
683 : 0 : uint8_t event_port_id = adapter->event_port_id;
684 : : struct rte_event events[BATCH_SIZE];
685 : : uint16_t nb_enqueued, nb_ev;
686 : : uint8_t retry;
687 : : uint8_t i;
688 : :
689 : : nb_ev = 0;
690 : : retry = 0;
691 : : nb_enqueued = 0;
692 : 0 : num = RTE_MIN(num, BATCH_SIZE);
693 [ # # ]: 0 : for (i = 0; i < num; i++) {
694 : 0 : struct rte_event *ev = &events[nb_ev++];
695 : :
696 : 0 : m_data = rte_cryptodev_session_event_mdata_get(ops[i]);
697 [ # # ]: 0 : if (unlikely(m_data == NULL)) {
698 : 0 : rte_pktmbuf_free(ops[i]->sym->m_src);
699 : 0 : rte_crypto_op_free(ops[i]);
700 : 0 : continue;
701 : : }
702 : :
703 [ # # ]: 0 : rte_memcpy(ev, &m_data->response_info, sizeof(*ev));
704 : 0 : ev->event_ptr = ops[i];
705 : :
706 : : /** Restore "struct rte_event::impl_opaque" from mbuf
707 : : * dynamic field for session based crypto operation.
708 : : * For session-less, each crypto operations carries event
709 : : * metadata and retains "struct rte_event::impl_opaque"
710 : : * information to be passed back to eventdev PMD.
711 : : */
712 [ # # ]: 0 : if (ops[i]->sess_type == RTE_CRYPTO_OP_WITH_SESSION) {
713 : 0 : struct rte_mbuf *mbuf = ops[i]->sym->m_src;
714 : :
715 : 0 : ev->impl_opaque = *RTE_MBUF_DYNFIELD(mbuf,
716 : : eca_dynfield_offset,
717 : : eca_dynfield_t *);
718 : : }
719 : :
720 : 0 : ev->event_type = RTE_EVENT_TYPE_CRYPTODEV;
721 [ # # ]: 0 : if (adapter->implicit_release_disabled)
722 : 0 : ev->op = RTE_EVENT_OP_FORWARD;
723 : : else
724 : 0 : ev->op = RTE_EVENT_OP_NEW;
725 : : }
726 : :
727 : : do {
728 : 0 : nb_enqueued += rte_event_enqueue_burst(event_dev_id,
729 : : event_port_id,
730 : 0 : &events[nb_enqueued],
731 : 0 : nb_ev - nb_enqueued);
732 : :
733 [ # # # # ]: 0 : } while (retry++ < CRYPTO_ADAPTER_MAX_EV_ENQ_RETRIES &&
734 : : nb_enqueued < nb_ev);
735 : :
736 : 0 : stats->event_enq_fail_count += nb_ev - nb_enqueued;
737 : 0 : stats->event_enq_count += nb_enqueued;
738 : 0 : stats->event_enq_retry_count += retry - 1;
739 : :
740 : 0 : return nb_enqueued;
741 : : }
742 : :
743 : : static int
744 : 0 : eca_circular_buffer_flush_to_evdev(struct event_crypto_adapter *adapter,
745 : : struct crypto_ops_circular_buffer *bufp)
746 : : {
747 : : uint16_t n = 0, nb_ops_flushed;
748 : : uint16_t *headp = &bufp->head;
749 : : uint16_t *tailp = &bufp->tail;
750 : 0 : struct rte_crypto_op **ops = bufp->op_buffer;
751 : :
752 [ # # ]: 0 : if (*tailp > *headp)
753 : 0 : n = *tailp - *headp;
754 [ # # ]: 0 : else if (*tailp < *headp)
755 : 0 : n = bufp->size - *headp;
756 : : else
757 : : return 0; /* buffer empty */
758 : :
759 : 0 : nb_ops_flushed = eca_ops_enqueue_burst(adapter, &ops[*headp], n);
760 : 0 : bufp->count -= nb_ops_flushed;
761 [ # # ]: 0 : if (!bufp->count) {
762 : 0 : *headp = 0;
763 : 0 : *tailp = 0;
764 : 0 : return 0; /* buffer empty */
765 : : }
766 : :
767 : 0 : *headp = (*headp + nb_ops_flushed) % bufp->size;
768 : 0 : return 1;
769 : : }
770 : :
771 : :
772 : : static void
773 : : eca_ops_buffer_flush(struct event_crypto_adapter *adapter)
774 : : {
775 [ # # ]: 0 : if (likely(adapter->ebuf.count == 0))
776 : : return;
777 : :
778 [ # # ]: 0 : while (eca_circular_buffer_flush_to_evdev(adapter,
779 : : &adapter->ebuf))
780 : : ;
781 : : }
782 : : static inline unsigned int
783 : 0 : eca_crypto_adapter_deq_run(struct event_crypto_adapter *adapter,
784 : : unsigned int max_deq)
785 : : {
786 : : struct rte_event_crypto_adapter_stats *stats = &adapter->crypto_stats;
787 : : struct crypto_device_info *curr_dev;
788 : : struct crypto_queue_pair_info *curr_queue;
789 : : struct rte_crypto_op *ops[BATCH_SIZE];
790 : : uint16_t n, nb_deq, nb_enqueued, i;
791 : : struct rte_cryptodev *dev;
792 : : uint8_t cdev_id;
793 : : uint16_t qp, dev_qps;
794 : : bool done;
795 : 0 : uint16_t num_cdev = rte_cryptodev_count();
796 : :
797 : : nb_deq = 0;
798 : : eca_ops_buffer_flush(adapter);
799 : :
800 : : do {
801 : : done = true;
802 : :
803 : 0 : for (cdev_id = adapter->next_cdev_id;
804 [ # # ]: 0 : cdev_id < num_cdev; cdev_id++) {
805 : : uint16_t queues = 0;
806 : :
807 : 0 : curr_dev = &adapter->cdevs[cdev_id];
808 : 0 : dev = curr_dev->dev;
809 [ # # ]: 0 : if (unlikely(dev == NULL))
810 : 0 : continue;
811 : :
812 : 0 : dev_qps = dev->data->nb_queue_pairs;
813 : :
814 : 0 : for (qp = curr_dev->next_queue_pair_id;
815 [ # # ]: 0 : queues < dev_qps; qp = (qp + 1) % dev_qps,
816 : 0 : queues++) {
817 : :
818 : 0 : curr_queue = &curr_dev->qpairs[qp];
819 [ # # # # ]: 0 : if (unlikely(curr_queue == NULL ||
820 : : !curr_queue->qp_enabled))
821 : 0 : continue;
822 : :
823 : 0 : n = rte_cryptodev_dequeue_burst(cdev_id, qp,
824 : : ops, BATCH_SIZE);
825 [ # # ]: 0 : if (!n)
826 : 0 : continue;
827 : :
828 : : done = false;
829 : : nb_enqueued = 0;
830 : :
831 : 0 : stats->crypto_deq_count += n;
832 : :
833 [ # # ]: 0 : if (unlikely(!adapter->ebuf.count))
834 : 0 : nb_enqueued = eca_ops_enqueue_burst(
835 : : adapter, ops, n);
836 : :
837 [ # # ]: 0 : if (likely(nb_enqueued == n))
838 : 0 : goto check;
839 : :
840 : : /* Failed to enqueue events case */
841 [ # # ]: 0 : for (i = nb_enqueued; i < n; i++)
842 : 0 : eca_circular_buffer_add(
843 : : &adapter->ebuf,
844 : : ops[i]);
845 : :
846 : 0 : check:
847 : 0 : nb_deq += n;
848 : :
849 [ # # ]: 0 : if (nb_deq >= max_deq) {
850 [ # # ]: 0 : if ((qp + 1) == dev_qps) {
851 : 0 : adapter->next_cdev_id =
852 : 0 : (cdev_id + 1)
853 : 0 : % num_cdev;
854 : : }
855 : 0 : curr_dev->next_queue_pair_id = (qp + 1)
856 : 0 : % dev->data->nb_queue_pairs;
857 : :
858 : 0 : return nb_deq;
859 : : }
860 : : }
861 : : }
862 : 0 : adapter->next_cdev_id = 0;
863 [ # # ]: 0 : } while (done == false);
864 : 0 : return nb_deq;
865 : : }
866 : :
867 : : static int
868 : 0 : eca_crypto_adapter_run(struct event_crypto_adapter *adapter,
869 : : unsigned int max_ops)
870 : : {
871 : : unsigned int ops_left = max_ops;
872 : :
873 [ # # ]: 0 : while (ops_left > 0) {
874 : : unsigned int e_cnt, d_cnt;
875 : :
876 : 0 : e_cnt = eca_crypto_adapter_deq_run(adapter, ops_left);
877 : 0 : ops_left -= RTE_MIN(ops_left, e_cnt);
878 : :
879 : 0 : d_cnt = eca_crypto_adapter_enq_run(adapter, ops_left);
880 : 0 : ops_left -= RTE_MIN(ops_left, d_cnt);
881 : :
882 [ # # ]: 0 : if (e_cnt == 0 && d_cnt == 0)
883 : : break;
884 : :
885 : : }
886 : :
887 [ # # ]: 0 : if (ops_left == max_ops) {
888 : 0 : rte_event_maintain(adapter->eventdev_id,
889 [ # # ]: 0 : adapter->event_port_id, 0);
890 : 0 : return -EAGAIN;
891 : : } else
892 : : return 0;
893 : : }
894 : :
895 : : static int
896 : 0 : eca_service_func(void *args)
897 : : {
898 : : struct event_crypto_adapter *adapter = args;
899 : : int ret;
900 : :
901 [ # # ]: 0 : if (rte_spinlock_trylock(&adapter->lock) == 0)
902 : : return 0;
903 : 0 : ret = eca_crypto_adapter_run(adapter, adapter->max_nb);
904 : : rte_spinlock_unlock(&adapter->lock);
905 : :
906 : 0 : return ret;
907 : : }
908 : :
909 : : static int
910 : 0 : eca_init_service(struct event_crypto_adapter *adapter, uint8_t id)
911 : : {
912 : : struct rte_event_crypto_adapter_conf adapter_conf;
913 : : struct rte_service_spec service;
914 : : int ret;
915 : : uint32_t impl_rel;
916 : :
917 [ # # ]: 0 : if (adapter->service_inited)
918 : : return 0;
919 : :
920 : : memset(&service, 0, sizeof(service));
921 : 0 : snprintf(service.name, CRYPTO_ADAPTER_NAME_LEN,
922 : : "rte_event_crypto_adapter_%d", id);
923 : 0 : service.socket_id = adapter->socket_id;
924 : 0 : service.callback = eca_service_func;
925 : 0 : service.callback_userdata = adapter;
926 : : /* Service function handles locking for queue add/del updates */
927 : 0 : service.capabilities = RTE_SERVICE_CAP_MT_SAFE;
928 : 0 : ret = rte_service_component_register(&service, &adapter->service_id);
929 [ # # ]: 0 : if (ret) {
930 : 0 : RTE_EDEV_LOG_ERR("failed to register service %s err = %" PRId32,
931 : : service.name, ret);
932 : 0 : return ret;
933 : : }
934 : :
935 : 0 : ret = adapter->conf_cb(id, adapter->eventdev_id,
936 : : &adapter_conf, adapter->conf_arg);
937 [ # # ]: 0 : if (ret) {
938 : 0 : RTE_EDEV_LOG_ERR("configuration callback failed err = %" PRId32,
939 : : ret);
940 : 0 : return ret;
941 : : }
942 : :
943 : 0 : adapter->max_nb = adapter_conf.max_nb;
944 : 0 : adapter->event_port_id = adapter_conf.event_port_id;
945 : :
946 [ # # ]: 0 : if (rte_event_port_attr_get(adapter->eventdev_id,
947 : : adapter->event_port_id,
948 : : RTE_EVENT_PORT_ATTR_IMPLICIT_RELEASE_DISABLE,
949 : : &impl_rel)) {
950 : 0 : RTE_EDEV_LOG_ERR("Failed to get port info for eventdev %" PRId32,
951 : : adapter->eventdev_id);
952 : : eca_circular_buffer_free(&adapter->ebuf);
953 : 0 : rte_free(adapter);
954 : 0 : return -EINVAL;
955 : : }
956 : :
957 : 0 : adapter->implicit_release_disabled = (uint8_t)impl_rel;
958 : :
959 : : /** Register for mbuf dyn field to store/restore
960 : : * "struct rte_event::impl_opaque"
961 : : */
962 : : eca_dynfield_offset = eca_dynfield_register();
963 [ # # ]: 0 : if (eca_dynfield_offset < 0) {
964 : 0 : RTE_EDEV_LOG_ERR("Failed to register eca mbuf dyn field");
965 : : eca_circular_buffer_free(&adapter->ebuf);
966 : 0 : rte_free(adapter);
967 : 0 : return -EINVAL;
968 : : }
969 : :
970 : 0 : adapter->service_inited = 1;
971 : :
972 : 0 : return ret;
973 : : }
974 : :
975 : : static void
976 : 0 : eca_update_qp_info(struct event_crypto_adapter *adapter,
977 : : struct crypto_device_info *dev_info, int32_t queue_pair_id,
978 : : uint8_t add)
979 : : {
980 : : struct crypto_queue_pair_info *qp_info;
981 : : int enabled;
982 : : uint16_t i;
983 : :
984 [ # # ]: 0 : if (dev_info->qpairs == NULL)
985 : : return;
986 : :
987 [ # # ]: 0 : if (queue_pair_id == -1) {
988 [ # # ]: 0 : for (i = 0; i < dev_info->dev->data->nb_queue_pairs; i++)
989 : 0 : eca_update_qp_info(adapter, dev_info, i, add);
990 : : } else {
991 : 0 : qp_info = &dev_info->qpairs[queue_pair_id];
992 : 0 : enabled = qp_info->qp_enabled;
993 [ # # ]: 0 : if (add) {
994 : 0 : adapter->nb_qps += !enabled;
995 : 0 : dev_info->num_qpairs += !enabled;
996 : : } else {
997 : 0 : adapter->nb_qps -= enabled;
998 : 0 : dev_info->num_qpairs -= enabled;
999 : : }
1000 : 0 : qp_info->qp_enabled = !!add;
1001 : : }
1002 : : }
1003 : :
1004 : : static int
1005 : 0 : eca_add_queue_pair(struct event_crypto_adapter *adapter, uint8_t cdev_id,
1006 : : int queue_pair_id)
1007 : : {
1008 : 0 : struct crypto_device_info *dev_info = &adapter->cdevs[cdev_id];
1009 : : struct crypto_queue_pair_info *qpairs;
1010 : : uint32_t i;
1011 : :
1012 [ # # ]: 0 : if (dev_info->qpairs == NULL) {
1013 : 0 : dev_info->qpairs =
1014 : 0 : rte_zmalloc_socket(adapter->mem_name,
1015 : 0 : dev_info->dev->data->nb_queue_pairs *
1016 : : sizeof(struct crypto_queue_pair_info),
1017 : : 0, adapter->socket_id);
1018 [ # # ]: 0 : if (dev_info->qpairs == NULL)
1019 : : return -ENOMEM;
1020 : :
1021 : : qpairs = dev_info->qpairs;
1022 : :
1023 : : if (eca_circular_buffer_init("eca_cdev_circular_buffer",
1024 : : &qpairs->cbuf,
1025 : : CRYPTO_ADAPTER_OPS_BUFFER_SZ)) {
1026 : 0 : RTE_EDEV_LOG_ERR("Failed to get memory for cryptodev "
1027 : : "buffer");
1028 : 0 : rte_free(qpairs);
1029 : 0 : return -ENOMEM;
1030 : : }
1031 : : }
1032 : :
1033 [ # # ]: 0 : if (queue_pair_id == -1) {
1034 [ # # ]: 0 : for (i = 0; i < dev_info->dev->data->nb_queue_pairs; i++)
1035 : 0 : eca_update_qp_info(adapter, dev_info, i, 1);
1036 : : } else
1037 : 0 : eca_update_qp_info(adapter, dev_info,
1038 : : (uint16_t)queue_pair_id, 1);
1039 : :
1040 : : return 0;
1041 : : }
1042 : :
1043 : : RTE_EXPORT_SYMBOL(rte_event_crypto_adapter_queue_pair_add)
1044 : : int
1045 : 0 : rte_event_crypto_adapter_queue_pair_add(uint8_t id,
1046 : : uint8_t cdev_id,
1047 : : int32_t queue_pair_id,
1048 : : const struct rte_event_crypto_adapter_queue_conf *conf)
1049 : : {
1050 : : struct rte_event_crypto_adapter_vector_limits limits;
1051 : : struct event_crypto_adapter *adapter;
1052 : : struct crypto_device_info *dev_info;
1053 : : struct rte_eventdev *dev;
1054 : : uint32_t cap;
1055 : : int ret;
1056 : :
1057 [ # # ]: 0 : EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1058 : :
1059 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(cdev_id)) {
1060 : 0 : RTE_EDEV_LOG_ERR("Invalid dev_id=%" PRIu8, cdev_id);
1061 : 0 : return -EINVAL;
1062 : : }
1063 : :
1064 : : adapter = eca_id_to_adapter(id);
1065 [ # # ]: 0 : if (adapter == NULL)
1066 : : return -EINVAL;
1067 : :
1068 : 0 : dev = &rte_eventdevs[adapter->eventdev_id];
1069 : 0 : ret = rte_event_crypto_adapter_caps_get(adapter->eventdev_id,
1070 : : cdev_id,
1071 : : &cap);
1072 [ # # ]: 0 : if (ret) {
1073 : 0 : RTE_EDEV_LOG_ERR("Failed to get adapter caps dev %" PRIu8
1074 : : " cdev %" PRIu8, id, cdev_id);
1075 : 0 : return ret;
1076 : : }
1077 : :
1078 [ # # ]: 0 : if (conf == NULL) {
1079 [ # # ]: 0 : if (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) {
1080 : 0 : RTE_EDEV_LOG_ERR("Conf value can not be NULL for dev_id=%u",
1081 : : cdev_id);
1082 : 0 : return -EINVAL;
1083 : : }
1084 : : } else {
1085 [ # # ]: 0 : if (conf->flags & RTE_EVENT_CRYPTO_ADAPTER_EVENT_VECTOR) {
1086 [ # # ]: 0 : if ((cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_EVENT_VECTOR) == 0) {
1087 : 0 : RTE_EDEV_LOG_ERR("Event vectorization is not supported,"
1088 : : "dev %" PRIu8 " cdev %" PRIu8, id,
1089 : : cdev_id);
1090 : 0 : return -ENOTSUP;
1091 : : }
1092 : :
1093 : 0 : ret = rte_event_crypto_adapter_vector_limits_get(
1094 : 0 : adapter->eventdev_id, cdev_id, &limits);
1095 [ # # ]: 0 : if (ret < 0) {
1096 : 0 : RTE_EDEV_LOG_ERR("Failed to get event device vector "
1097 : : "limits, dev %" PRIu8 " cdev %" PRIu8,
1098 : : id, cdev_id);
1099 : 0 : return -EINVAL;
1100 : : }
1101 : :
1102 [ # # ]: 0 : if (conf->vector_sz < limits.min_sz ||
1103 [ # # ]: 0 : conf->vector_sz > limits.max_sz ||
1104 [ # # ]: 0 : conf->vector_timeout_ns < limits.min_timeout_ns ||
1105 [ # # ]: 0 : conf->vector_timeout_ns > limits.max_timeout_ns ||
1106 [ # # ]: 0 : conf->vector_mp == NULL) {
1107 : 0 : RTE_EDEV_LOG_ERR("Invalid event vector configuration,"
1108 : : " dev %" PRIu8 " cdev %" PRIu8,
1109 : : id, cdev_id);
1110 : 0 : return -EINVAL;
1111 : : }
1112 : :
1113 : 0 : if (conf->vector_mp->elt_size < (sizeof(struct rte_event_vector) +
1114 [ # # ]: 0 : (sizeof(uintptr_t) * conf->vector_sz))) {
1115 : 0 : RTE_EDEV_LOG_ERR("Invalid event vector configuration,"
1116 : : " dev %" PRIu8 " cdev %" PRIu8,
1117 : : id, cdev_id);
1118 : 0 : return -EINVAL;
1119 : : }
1120 : : }
1121 : : }
1122 : :
1123 : 0 : dev_info = &adapter->cdevs[cdev_id];
1124 : :
1125 [ # # ]: 0 : if (queue_pair_id != -1 &&
1126 [ # # ]: 0 : (uint16_t)queue_pair_id >= dev_info->dev->data->nb_queue_pairs) {
1127 : 0 : RTE_EDEV_LOG_ERR("Invalid queue_pair_id %" PRIu16,
1128 : : (uint16_t)queue_pair_id);
1129 : 0 : return -EINVAL;
1130 : : }
1131 : :
1132 : : /* In case HW cap is RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD,
1133 : : * no need of service core as HW supports event forward capability.
1134 : : */
1135 [ # # ]: 0 : if ((cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) ||
1136 [ # # ]: 0 : (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND &&
1137 [ # # ]: 0 : adapter->mode == RTE_EVENT_CRYPTO_ADAPTER_OP_NEW) ||
1138 [ # # ]: 0 : (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW &&
1139 [ # # ]: 0 : adapter->mode == RTE_EVENT_CRYPTO_ADAPTER_OP_NEW)) {
1140 [ # # ]: 0 : if (dev->dev_ops->crypto_adapter_queue_pair_add == NULL)
1141 : : return -ENOTSUP;
1142 [ # # ]: 0 : if (dev_info->qpairs == NULL) {
1143 : 0 : dev_info->qpairs =
1144 : 0 : rte_zmalloc_socket(adapter->mem_name,
1145 : 0 : dev_info->dev->data->nb_queue_pairs *
1146 : : sizeof(struct crypto_queue_pair_info),
1147 : : 0, adapter->socket_id);
1148 [ # # ]: 0 : if (dev_info->qpairs == NULL)
1149 : : return -ENOMEM;
1150 : : }
1151 : :
1152 : 0 : ret = dev->dev_ops->crypto_adapter_queue_pair_add(dev, dev_info->dev,
1153 : : queue_pair_id, conf);
1154 [ # # ]: 0 : if (ret)
1155 : : return ret;
1156 : :
1157 : : else
1158 : 0 : eca_update_qp_info(adapter, &adapter->cdevs[cdev_id],
1159 : : queue_pair_id, 1);
1160 : : }
1161 : :
1162 : : /* In case HW cap is RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW,
1163 : : * or SW adapter, initiate services so the application can choose
1164 : : * which ever way it wants to use the adapter.
1165 : : * Case 1: RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW
1166 : : * Application may wants to use one of below two mode
1167 : : * a. OP_FORWARD mode -> HW Dequeue + SW enqueue
1168 : : * b. OP_NEW mode -> HW Dequeue
1169 : : * Case 2: No HW caps, use SW adapter
1170 : : * a. OP_FORWARD mode -> SW enqueue & dequeue
1171 : : * b. OP_NEW mode -> SW Dequeue
1172 : : */
1173 [ # # ]: 0 : if ((cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW &&
1174 : 0 : !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) &&
1175 [ # # ]: 0 : adapter->mode == RTE_EVENT_CRYPTO_ADAPTER_OP_FORWARD) ||
1176 : : (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW) &&
1177 : : !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) &&
1178 [ # # ]: 0 : !(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND) &&
1179 : : (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA))) {
1180 : 0 : rte_spinlock_lock(&adapter->lock);
1181 : 0 : ret = eca_init_service(adapter, id);
1182 [ # # ]: 0 : if (ret == 0)
1183 : 0 : ret = eca_add_queue_pair(adapter, cdev_id,
1184 : : queue_pair_id);
1185 : : rte_spinlock_unlock(&adapter->lock);
1186 : :
1187 [ # # ]: 0 : if (ret)
1188 : : return ret;
1189 : :
1190 : 0 : rte_service_component_runstate_set(adapter->service_id, 1);
1191 : : }
1192 : :
1193 : 0 : rte_eventdev_trace_crypto_adapter_queue_pair_add(id, cdev_id,
1194 : : queue_pair_id, conf);
1195 : 0 : return 0;
1196 : : }
1197 : :
1198 : : RTE_EXPORT_SYMBOL(rte_event_crypto_adapter_queue_pair_del)
1199 : : int
1200 : 0 : rte_event_crypto_adapter_queue_pair_del(uint8_t id, uint8_t cdev_id,
1201 : : int32_t queue_pair_id)
1202 : : {
1203 : : struct event_crypto_adapter *adapter;
1204 : : struct crypto_device_info *dev_info;
1205 : : struct rte_eventdev *dev;
1206 : : int ret;
1207 : : uint32_t cap;
1208 : : uint16_t i;
1209 : :
1210 [ # # ]: 0 : EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1211 : :
1212 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(cdev_id)) {
1213 : 0 : RTE_EDEV_LOG_ERR("Invalid dev_id=%" PRIu8, cdev_id);
1214 : 0 : return -EINVAL;
1215 : : }
1216 : :
1217 : : adapter = eca_id_to_adapter(id);
1218 [ # # ]: 0 : if (adapter == NULL)
1219 : : return -EINVAL;
1220 : :
1221 : 0 : dev = &rte_eventdevs[adapter->eventdev_id];
1222 : 0 : ret = rte_event_crypto_adapter_caps_get(adapter->eventdev_id,
1223 : : cdev_id,
1224 : : &cap);
1225 [ # # ]: 0 : if (ret)
1226 : : return ret;
1227 : :
1228 : 0 : dev_info = &adapter->cdevs[cdev_id];
1229 : :
1230 [ # # ]: 0 : if (queue_pair_id != -1 &&
1231 [ # # ]: 0 : (uint16_t)queue_pair_id >= dev_info->dev->data->nb_queue_pairs) {
1232 : 0 : RTE_EDEV_LOG_ERR("Invalid queue_pair_id %" PRIu16,
1233 : : (uint16_t)queue_pair_id);
1234 : 0 : return -EINVAL;
1235 : : }
1236 : :
1237 [ # # ]: 0 : if ((cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) ||
1238 [ # # ]: 0 : (cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW &&
1239 [ # # ]: 0 : adapter->mode == RTE_EVENT_CRYPTO_ADAPTER_OP_NEW)) {
1240 [ # # ]: 0 : if (dev->dev_ops->crypto_adapter_queue_pair_del == NULL)
1241 : : return -ENOTSUP;
1242 : 0 : ret = dev->dev_ops->crypto_adapter_queue_pair_del(dev,
1243 : 0 : dev_info->dev, queue_pair_id);
1244 [ # # ]: 0 : if (ret == 0) {
1245 : 0 : eca_update_qp_info(adapter,
1246 : 0 : &adapter->cdevs[cdev_id],
1247 : : queue_pair_id,
1248 : : 0);
1249 [ # # ]: 0 : if (dev_info->num_qpairs == 0) {
1250 : 0 : rte_free(dev_info->qpairs);
1251 : 0 : dev_info->qpairs = NULL;
1252 : : }
1253 : : }
1254 : : } else {
1255 [ # # ]: 0 : if (adapter->nb_qps == 0)
1256 : : return 0;
1257 : :
1258 : 0 : rte_spinlock_lock(&adapter->lock);
1259 [ # # ]: 0 : if (queue_pair_id == -1) {
1260 [ # # ]: 0 : for (i = 0; i < dev_info->dev->data->nb_queue_pairs;
1261 : 0 : i++)
1262 : 0 : eca_update_qp_info(adapter, dev_info,
1263 : : queue_pair_id, 0);
1264 : : } else {
1265 : 0 : eca_update_qp_info(adapter, dev_info,
1266 : : (uint16_t)queue_pair_id, 0);
1267 : : }
1268 : :
1269 [ # # ]: 0 : if (dev_info->num_qpairs == 0) {
1270 : 0 : rte_free(dev_info->qpairs);
1271 : 0 : dev_info->qpairs = NULL;
1272 : : }
1273 : :
1274 : : rte_spinlock_unlock(&adapter->lock);
1275 : 0 : rte_service_component_runstate_set(adapter->service_id,
1276 : 0 : adapter->nb_qps);
1277 : : }
1278 : :
1279 : 0 : rte_eventdev_trace_crypto_adapter_queue_pair_del(id, cdev_id,
1280 : : queue_pair_id, ret);
1281 : 0 : return ret;
1282 : : }
1283 : :
1284 : : static int
1285 : 0 : eca_adapter_ctrl(uint8_t id, int start)
1286 : : {
1287 : : struct event_crypto_adapter *adapter;
1288 : : struct crypto_device_info *dev_info;
1289 : : struct rte_eventdev *dev;
1290 : : uint32_t i;
1291 : : int use_service;
1292 : : int stop = !start;
1293 : :
1294 : : use_service = 0;
1295 [ # # ]: 0 : EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1296 : : adapter = eca_id_to_adapter(id);
1297 [ # # ]: 0 : if (adapter == NULL)
1298 : : return -EINVAL;
1299 : :
1300 : 0 : dev = &rte_eventdevs[adapter->eventdev_id];
1301 : :
1302 [ # # ]: 0 : for (i = 0; i < rte_cryptodev_count(); i++) {
1303 : 0 : dev_info = &adapter->cdevs[i];
1304 : : /* if start check for num queue pairs */
1305 [ # # # # ]: 0 : if (start && !dev_info->num_qpairs)
1306 : 0 : continue;
1307 : : /* if stop check if dev has been started */
1308 [ # # # # ]: 0 : if (stop && !dev_info->dev_started)
1309 : 0 : continue;
1310 : 0 : use_service |= !dev_info->internal_event_port;
1311 : 0 : dev_info->dev_started = start;
1312 [ # # ]: 0 : if (dev_info->internal_event_port == 0)
1313 : 0 : continue;
1314 [ # # ]: 0 : start ? dev->dev_ops->crypto_adapter_start(dev, &dev_info->dev[i]) :
1315 : 0 : dev->dev_ops->crypto_adapter_stop(dev, &dev_info->dev[i]);
1316 : : }
1317 : :
1318 [ # # ]: 0 : if (use_service)
1319 : 0 : rte_service_runstate_set(adapter->service_id, start);
1320 : :
1321 : : return 0;
1322 : : }
1323 : :
1324 : : RTE_EXPORT_SYMBOL(rte_event_crypto_adapter_start)
1325 : : int
1326 : 0 : rte_event_crypto_adapter_start(uint8_t id)
1327 : : {
1328 : : struct event_crypto_adapter *adapter;
1329 : :
1330 [ # # ]: 0 : EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1331 : : adapter = eca_id_to_adapter(id);
1332 [ # # ]: 0 : if (adapter == NULL)
1333 : : return -EINVAL;
1334 : :
1335 : 0 : rte_eventdev_trace_crypto_adapter_start(id, adapter);
1336 : 0 : return eca_adapter_ctrl(id, 1);
1337 : : }
1338 : :
1339 : : RTE_EXPORT_SYMBOL(rte_event_crypto_adapter_stop)
1340 : : int
1341 : 0 : rte_event_crypto_adapter_stop(uint8_t id)
1342 : : {
1343 [ # # ]: 0 : rte_eventdev_trace_crypto_adapter_stop(id);
1344 : 0 : return eca_adapter_ctrl(id, 0);
1345 : : }
1346 : :
1347 : : RTE_EXPORT_SYMBOL(rte_event_crypto_adapter_stats_get)
1348 : : int
1349 : 0 : rte_event_crypto_adapter_stats_get(uint8_t id,
1350 : : struct rte_event_crypto_adapter_stats *stats)
1351 : : {
1352 : : struct event_crypto_adapter *adapter;
1353 : : struct rte_event_crypto_adapter_stats dev_stats_sum = { 0 };
1354 : : struct rte_event_crypto_adapter_stats dev_stats;
1355 : : struct rte_eventdev *dev;
1356 : : struct crypto_device_info *dev_info;
1357 : : uint32_t i;
1358 : : int ret;
1359 : :
1360 [ # # ]: 0 : if (eca_memzone_lookup())
1361 : : return -ENOMEM;
1362 : :
1363 [ # # ]: 0 : EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1364 : :
1365 : : adapter = eca_id_to_adapter(id);
1366 [ # # ]: 0 : if (adapter == NULL || stats == NULL)
1367 : : return -EINVAL;
1368 : :
1369 : 0 : dev = &rte_eventdevs[adapter->eventdev_id];
1370 : : memset(stats, 0, sizeof(*stats));
1371 [ # # ]: 0 : for (i = 0; i < rte_cryptodev_count(); i++) {
1372 : 0 : dev_info = &adapter->cdevs[i];
1373 [ # # ]: 0 : if (dev_info->internal_event_port == 0 ||
1374 [ # # ]: 0 : dev->dev_ops->crypto_adapter_stats_get == NULL)
1375 : 0 : continue;
1376 : 0 : ret = dev->dev_ops->crypto_adapter_stats_get(dev, dev_info->dev, &dev_stats);
1377 [ # # ]: 0 : if (ret)
1378 : 0 : continue;
1379 : :
1380 : 0 : dev_stats_sum.crypto_deq_count += dev_stats.crypto_deq_count;
1381 : 0 : dev_stats_sum.event_enq_count +=
1382 : 0 : dev_stats.event_enq_count;
1383 : : }
1384 : :
1385 [ # # ]: 0 : if (adapter->service_inited)
1386 : 0 : *stats = adapter->crypto_stats;
1387 : :
1388 : 0 : stats->crypto_deq_count += dev_stats_sum.crypto_deq_count;
1389 : 0 : stats->event_enq_count += dev_stats_sum.event_enq_count;
1390 : :
1391 [ # # ]: 0 : rte_eventdev_trace_crypto_adapter_stats_get(id, stats,
1392 : : stats->event_poll_count, stats->event_deq_count,
1393 : : stats->crypto_enq_count, stats->crypto_enq_fail,
1394 : : stats->crypto_deq_count, stats->event_enq_count,
1395 : : stats->event_enq_retry_count, stats->event_enq_fail_count);
1396 : :
1397 : 0 : return 0;
1398 : : }
1399 : :
1400 : : RTE_EXPORT_SYMBOL(rte_event_crypto_adapter_stats_reset)
1401 : : int
1402 : 0 : rte_event_crypto_adapter_stats_reset(uint8_t id)
1403 : : {
1404 : : struct event_crypto_adapter *adapter;
1405 : : struct crypto_device_info *dev_info;
1406 : : struct rte_eventdev *dev;
1407 : : uint32_t i;
1408 : :
1409 [ # # ]: 0 : rte_eventdev_trace_crypto_adapter_stats_reset(id);
1410 : :
1411 [ # # ]: 0 : if (eca_memzone_lookup())
1412 : : return -ENOMEM;
1413 : :
1414 [ # # ]: 0 : EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1415 : :
1416 : : adapter = eca_id_to_adapter(id);
1417 [ # # ]: 0 : if (adapter == NULL)
1418 : : return -EINVAL;
1419 : :
1420 : 0 : dev = &rte_eventdevs[adapter->eventdev_id];
1421 [ # # ]: 0 : for (i = 0; i < rte_cryptodev_count(); i++) {
1422 : 0 : dev_info = &adapter->cdevs[i];
1423 [ # # ]: 0 : if (dev_info->internal_event_port == 0 ||
1424 [ # # ]: 0 : dev->dev_ops->crypto_adapter_stats_reset == NULL)
1425 : 0 : continue;
1426 : 0 : dev->dev_ops->crypto_adapter_stats_reset(dev, dev_info->dev);
1427 : : }
1428 : :
1429 : 0 : memset(&adapter->crypto_stats, 0, sizeof(adapter->crypto_stats));
1430 : 0 : return 0;
1431 : : }
1432 : :
1433 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_event_crypto_adapter_runtime_params_init, 23.03)
1434 : : int
1435 : 0 : rte_event_crypto_adapter_runtime_params_init(
1436 : : struct rte_event_crypto_adapter_runtime_params *params)
1437 : : {
1438 [ # # ]: 0 : if (params == NULL)
1439 : : return -EINVAL;
1440 : :
1441 : : memset(params, 0, sizeof(*params));
1442 : 0 : params->max_nb = DEFAULT_MAX_NB;
1443 : :
1444 : 0 : return 0;
1445 : : }
1446 : :
1447 : : static int
1448 : 0 : crypto_adapter_cap_check(struct event_crypto_adapter *adapter)
1449 : : {
1450 : : int ret;
1451 : : uint32_t caps;
1452 : :
1453 [ # # ]: 0 : if (!adapter->nb_qps)
1454 : : return -EINVAL;
1455 : 0 : ret = rte_event_crypto_adapter_caps_get(adapter->eventdev_id,
1456 : 0 : adapter->next_cdev_id,
1457 : : &caps);
1458 [ # # ]: 0 : if (ret) {
1459 : 0 : RTE_EDEV_LOG_ERR("Failed to get adapter caps dev %" PRIu8
1460 : : " cdev %" PRIu8, adapter->eventdev_id,
1461 : : adapter->next_cdev_id);
1462 : 0 : return ret;
1463 : : }
1464 : :
1465 [ # # ]: 0 : if ((caps & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) ||
1466 : : (caps & RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_NEW))
1467 : 0 : return -ENOTSUP;
1468 : :
1469 : : return 0;
1470 : : }
1471 : :
1472 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_event_crypto_adapter_runtime_params_set, 23.03)
1473 : : int
1474 : 0 : rte_event_crypto_adapter_runtime_params_set(uint8_t id,
1475 : : struct rte_event_crypto_adapter_runtime_params *params)
1476 : : {
1477 : : struct event_crypto_adapter *adapter;
1478 : : int ret;
1479 : :
1480 [ # # ]: 0 : if (eca_memzone_lookup())
1481 : : return -ENOMEM;
1482 : :
1483 [ # # ]: 0 : EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1484 : :
1485 [ # # ]: 0 : if (params == NULL) {
1486 : 0 : RTE_EDEV_LOG_ERR("params pointer is NULL");
1487 : 0 : return -EINVAL;
1488 : : }
1489 : :
1490 : : adapter = eca_id_to_adapter(id);
1491 [ # # ]: 0 : if (adapter == NULL)
1492 : : return -EINVAL;
1493 : :
1494 : 0 : ret = crypto_adapter_cap_check(adapter);
1495 [ # # ]: 0 : if (ret)
1496 : : return ret;
1497 : :
1498 : 0 : rte_spinlock_lock(&adapter->lock);
1499 : 0 : adapter->max_nb = params->max_nb;
1500 : : rte_spinlock_unlock(&adapter->lock);
1501 : :
1502 : 0 : return 0;
1503 : : }
1504 : :
1505 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_event_crypto_adapter_runtime_params_get, 23.03)
1506 : : int
1507 : 0 : rte_event_crypto_adapter_runtime_params_get(uint8_t id,
1508 : : struct rte_event_crypto_adapter_runtime_params *params)
1509 : : {
1510 : : struct event_crypto_adapter *adapter;
1511 : : int ret;
1512 : :
1513 [ # # ]: 0 : if (eca_memzone_lookup())
1514 : : return -ENOMEM;
1515 : :
1516 : :
1517 [ # # ]: 0 : EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1518 : :
1519 [ # # ]: 0 : if (params == NULL) {
1520 : 0 : RTE_EDEV_LOG_ERR("params pointer is NULL");
1521 : 0 : return -EINVAL;
1522 : : }
1523 : :
1524 : : adapter = eca_id_to_adapter(id);
1525 [ # # ]: 0 : if (adapter == NULL)
1526 : : return -EINVAL;
1527 : :
1528 : 0 : ret = crypto_adapter_cap_check(adapter);
1529 [ # # ]: 0 : if (ret)
1530 : : return ret;
1531 : :
1532 : 0 : params->max_nb = adapter->max_nb;
1533 : :
1534 : 0 : return 0;
1535 : : }
1536 : :
1537 : : RTE_EXPORT_SYMBOL(rte_event_crypto_adapter_service_id_get)
1538 : : int
1539 : 0 : rte_event_crypto_adapter_service_id_get(uint8_t id, uint32_t *service_id)
1540 : : {
1541 : : struct event_crypto_adapter *adapter;
1542 : :
1543 [ # # ]: 0 : EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1544 : :
1545 : : adapter = eca_id_to_adapter(id);
1546 [ # # ]: 0 : if (adapter == NULL || service_id == NULL)
1547 : : return -EINVAL;
1548 : :
1549 [ # # ]: 0 : if (adapter->service_inited)
1550 : 0 : *service_id = adapter->service_id;
1551 : :
1552 [ # # ]: 0 : rte_eventdev_trace_crypto_adapter_service_id_get(id, *service_id);
1553 : :
1554 [ # # ]: 0 : return adapter->service_inited ? 0 : -ESRCH;
1555 : : }
1556 : :
1557 : : RTE_EXPORT_SYMBOL(rte_event_crypto_adapter_event_port_get)
1558 : : int
1559 : 0 : rte_event_crypto_adapter_event_port_get(uint8_t id, uint8_t *event_port_id)
1560 : : {
1561 : : struct event_crypto_adapter *adapter;
1562 : :
1563 [ # # ]: 0 : EVENT_CRYPTO_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1564 : :
1565 : : adapter = eca_id_to_adapter(id);
1566 [ # # ]: 0 : if (adapter == NULL || event_port_id == NULL)
1567 : : return -EINVAL;
1568 : :
1569 [ # # ]: 0 : *event_port_id = adapter->event_port_id;
1570 : :
1571 : 0 : rte_eventdev_trace_crypto_adapter_event_port_get(id, *event_port_id);
1572 : :
1573 : 0 : return 0;
1574 : : }
1575 : :
1576 : : RTE_EXPORT_SYMBOL(rte_event_crypto_adapter_vector_limits_get)
1577 : : int
1578 : 0 : rte_event_crypto_adapter_vector_limits_get(
1579 : : uint8_t dev_id, uint16_t cdev_id,
1580 : : struct rte_event_crypto_adapter_vector_limits *limits)
1581 : : {
1582 : : struct rte_cryptodev *cdev;
1583 : : struct rte_eventdev *dev;
1584 : : uint32_t cap;
1585 : : int ret;
1586 : :
1587 [ # # # # ]: 0 : rte_eventdev_trace_crypto_adapter_vector_limits_get(dev_id, cdev_id, limits);
1588 : :
1589 : 0 : RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, -EINVAL);
1590 : :
1591 [ # # ]: 0 : if (!rte_cryptodev_is_valid_dev(cdev_id)) {
1592 : 0 : RTE_EDEV_LOG_ERR("Invalid dev_id=%" PRIu8, cdev_id);
1593 : 0 : return -EINVAL;
1594 : : }
1595 : :
1596 [ # # ]: 0 : if (limits == NULL) {
1597 : 0 : RTE_EDEV_LOG_ERR("Invalid limits storage provided");
1598 : 0 : return -EINVAL;
1599 : : }
1600 : :
1601 : 0 : dev = &rte_eventdevs[dev_id];
1602 : 0 : cdev = rte_cryptodev_pmd_get_dev(cdev_id);
1603 : :
1604 : 0 : ret = rte_event_crypto_adapter_caps_get(dev_id, cdev_id, &cap);
1605 [ # # ]: 0 : if (ret) {
1606 : 0 : RTE_EDEV_LOG_ERR("Failed to get adapter caps edev %" PRIu8
1607 : : "cdev %" PRIu16, dev_id, cdev_id);
1608 : 0 : return ret;
1609 : : }
1610 : :
1611 [ # # ]: 0 : if (!(cap & RTE_EVENT_CRYPTO_ADAPTER_CAP_EVENT_VECTOR)) {
1612 : 0 : RTE_EDEV_LOG_ERR("Event vectorization is not supported,"
1613 : : "dev %" PRIu8 " cdev %" PRIu8, dev_id, cdev_id);
1614 : 0 : return -ENOTSUP;
1615 : : }
1616 : :
1617 [ # # ]: 0 : if (dev->dev_ops->crypto_adapter_vector_limits_get == NULL)
1618 : : return -ENOTSUP;
1619 : :
1620 : 0 : return dev->dev_ops->crypto_adapter_vector_limits_get(dev, cdev, limits);
1621 : : }
|
