1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2016 Cavium, Inc
3 */
4
5 #ifndef _RTE_EVENTDEV_PMD_H_
6 #define _RTE_EVENTDEV_PMD_H_
7
8 #ifdef __cplusplus
9 extern "C" {
10 #endif
11
12 /** @file
13 * RTE Event PMD APIs
14 *
15 * @note
16 * These API are from event PMD only and user applications should not call
17 * them directly.
18 */
19
20 #include <string.h>
21
22 #include <rte_common.h>
23 #include <rte_compat.h>
24 #include <rte_config.h>
25 #include <rte_dev.h>
26 #include <rte_log.h>
27 #include <rte_malloc.h>
28 #include <rte_mbuf.h>
29 #include <rte_mbuf_dyn.h>
30
31 #include "event_timer_adapter_pmd.h"
32 #include "rte_eventdev.h"
33
34 /* Logging Macros */
35 #define RTE_EDEV_LOG_ERR(...) \
36 RTE_LOG(ERR, EVENTDEV, \
37 RTE_FMT("%s() line %u: " RTE_FMT_HEAD(__VA_ARGS__,) "\n", \
38 __func__, __LINE__, RTE_FMT_TAIL(__VA_ARGS__,)))
39
40 #ifdef RTE_LIBRTE_EVENTDEV_DEBUG
41 #define RTE_EDEV_LOG_DEBUG(...) \
42 RTE_LOG(DEBUG, EVENTDEV, \
43 RTE_FMT("%s() line %u: " RTE_FMT_HEAD(__VA_ARGS__,) "\n", \
44 __func__, __LINE__, RTE_FMT_TAIL(__VA_ARGS__,)))
45 #else
46 #define RTE_EDEV_LOG_DEBUG(...) (void)0
47 #endif
48
49 /* Macros to check for valid device */
50 #define RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(dev_id, retval) do { \
51 if (!rte_event_pmd_is_valid_dev((dev_id))) { \
52 RTE_EDEV_LOG_ERR("Invalid dev_id=%d\n", dev_id); \
53 return retval; \
54 } \
55 } while (0)
56
57 #define RTE_EVENTDEV_VALID_DEVID_OR_ERRNO_RET(dev_id, errno, retval) do { \
58 if (!rte_event_pmd_is_valid_dev((dev_id))) { \
59 RTE_EDEV_LOG_ERR("Invalid dev_id=%d\n", dev_id); \
60 rte_errno = errno; \
61 return retval; \
62 } \
63 } while (0)
64
65 #define RTE_EVENTDEV_VALID_DEVID_OR_RET(dev_id) do { \
66 if (!rte_event_pmd_is_valid_dev((dev_id))) { \
67 RTE_EDEV_LOG_ERR("Invalid dev_id=%d\n", dev_id); \
68 return; \
69 } \
70 } while (0)
71
72 #define RTE_EVENT_ETH_RX_ADAPTER_SW_CAP \
73 ((RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) | \
74 (RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) | \
75 (RTE_EVENT_ETH_RX_ADAPTER_CAP_EVENT_VECTOR))
76
77 #define RTE_EVENT_CRYPTO_ADAPTER_SW_CAP \
78 RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA
79
80 /**< Ethernet Rx adapter cap to return If the packet transfers from
81 * the ethdev to eventdev use a SW service function
82 */
83
84 #define RTE_EVENTDEV_DETACHED (0)
85 #define RTE_EVENTDEV_ATTACHED (1)
86
87 #define RTE_EVENTDEV_NAME_MAX_LEN (64)
88 /**< @internal Max length of name of event PMD */
89
90 struct rte_eth_dev;
91
92 /** Global structure used for maintaining state of allocated event devices */
93 struct rte_eventdev_global {
94 uint8_t nb_devs; /**< Number of devices found */
95 };
96
97 /**
98 * @internal
99 * The data part, with no function pointers, associated with each device.
100 *
101 * This structure is safe to place in shared memory to be common among
102 * different processes in a multi-process configuration.
103 */
104 struct rte_eventdev_data {
105 int socket_id;
106 /**< Socket ID where memory is allocated */
107 uint8_t dev_id;
108 /**< Device ID for this instance */
109 uint8_t nb_queues;
110 /**< Number of event queues. */
111 uint8_t nb_ports;
112 /**< Number of event ports. */
113 void *ports[RTE_EVENT_MAX_PORTS_PER_DEV];
114 /**< Array of pointers to ports. */
115 struct rte_event_port_conf ports_cfg[RTE_EVENT_MAX_PORTS_PER_DEV];
116 /**< Array of port configuration structures. */
117 struct rte_event_queue_conf queues_cfg[RTE_EVENT_MAX_QUEUES_PER_DEV];
118 /**< Array of queue configuration structures. */
119 uint16_t links_map[RTE_EVENT_MAX_PORTS_PER_DEV *
120 RTE_EVENT_MAX_QUEUES_PER_DEV];
121 /**< Memory to store queues to port connections. */
122 void *dev_private;
123 /**< PMD-specific private data */
124 uint32_t event_dev_cap;
125 /**< Event device capabilities(RTE_EVENT_DEV_CAP_)*/
126 struct rte_event_dev_config dev_conf;
127 /**< Configuration applied to device. */
128 uint8_t service_inited;
129 /* Service initialization state */
130 uint32_t service_id;
131 /* Service ID*/
132 void *dev_stop_flush_arg;
133 /**< User-provided argument for event flush function */
134
135 RTE_STD_C11
136 uint8_t dev_started : 1;
137 /**< Device state: STARTED(1)/STOPPED(0) */
138
139 char name[RTE_EVENTDEV_NAME_MAX_LEN];
140 /**< Unique identifier name */
141
142 uint64_t reserved_64s[4]; /**< Reserved for future fields */
143 void *reserved_ptrs[4]; /**< Reserved for future fields */
144 } __rte_cache_aligned;
145
146 /** @internal The data structure associated with each event device. */
147 struct rte_eventdev {
148 struct rte_eventdev_data *data;
149 /**< Pointer to device data */
150 struct eventdev_ops *dev_ops;
151 /**< Functions exported by PMD */
152 struct rte_device *dev;
153 /**< Device info. supplied by probing */
154
155 RTE_STD_C11
156 uint8_t attached : 1;
157 /**< Flag indicating the device is attached */
158
159 event_enqueue_t enqueue;
160 /**< Pointer to PMD enqueue function. */
161 event_enqueue_burst_t enqueue_burst;
162 /**< Pointer to PMD enqueue burst function. */
163 event_enqueue_burst_t enqueue_new_burst;
164 /**< Pointer to PMD enqueue burst function(op new variant) */
165 event_enqueue_burst_t enqueue_forward_burst;
166 /**< Pointer to PMD enqueue burst function(op forward variant) */
167 event_dequeue_t dequeue;
168 /**< Pointer to PMD dequeue function. */
169 event_dequeue_burst_t dequeue_burst;
170 /**< Pointer to PMD dequeue burst function. */
171 event_maintain_t maintain;
172 /**< Pointer to PMD port maintenance function. */
173 event_tx_adapter_enqueue_t txa_enqueue_same_dest;
174 /**< Pointer to PMD eth Tx adapter burst enqueue function with
175 * events destined to same Eth port & Tx queue.
176 */
177 event_tx_adapter_enqueue_t txa_enqueue;
178 /**< Pointer to PMD eth Tx adapter enqueue function. */
179 event_crypto_adapter_enqueue_t ca_enqueue;
180
181 uint64_t reserved_64s[4]; /**< Reserved for future fields */
182 void *reserved_ptrs[3]; /**< Reserved for future fields */
183 } __rte_cache_aligned;
184
185 extern struct rte_eventdev *rte_eventdevs;
186 /** @internal The pool of rte_eventdev structures. */
187
188 /**
189 * Get the rte_eventdev structure device pointer for the named device.
190 *
191 * @param name
192 * device name to select the device structure.
193 *
194 * @return
195 * - The rte_eventdev structure pointer for the given device ID.
196 */
197 __rte_internal
198 static inline struct rte_eventdev *
rte_event_pmd_get_named_dev(const char * name)199 rte_event_pmd_get_named_dev(const char *name)
200 {
201 struct rte_eventdev *dev;
202 unsigned int i;
203
204 if (name == NULL)
205 return NULL;
206
207 for (i = 0; i < RTE_EVENT_MAX_DEVS; i++) {
208 dev = &rte_eventdevs[i];
209 if ((dev->attached == RTE_EVENTDEV_ATTACHED) &&
210 (strcmp(dev->data->name, name) == 0))
211 return dev;
212 }
213
214 return NULL;
215 }
216
217 /**
218 * Validate if the event device index is valid attached event device.
219 *
220 * @param dev_id
221 * Event device index.
222 *
223 * @return
224 * - If the device index is valid (1) or not (0).
225 */
226 __rte_internal
227 static inline unsigned
rte_event_pmd_is_valid_dev(uint8_t dev_id)228 rte_event_pmd_is_valid_dev(uint8_t dev_id)
229 {
230 struct rte_eventdev *dev;
231
232 if (dev_id >= RTE_EVENT_MAX_DEVS)
233 return 0;
234
235 dev = &rte_eventdevs[dev_id];
236 if (dev->attached != RTE_EVENTDEV_ATTACHED)
237 return 0;
238 else
239 return 1;
240 }
241
242 /**
243 * Definitions of all functions exported by a driver through the
244 * generic structure of type *event_dev_ops* supplied in the
245 * *rte_eventdev* structure associated with a device.
246 */
247
248 /**
249 * Get device information of a device.
250 *
251 * @param dev
252 * Event device pointer
253 * @param dev_info
254 * Event device information structure
255 */
256 typedef void (*eventdev_info_get_t)(struct rte_eventdev *dev,
257 struct rte_event_dev_info *dev_info);
258
259 /**
260 * Configure a device.
261 *
262 * @param dev
263 * Event device pointer
264 *
265 * @return
266 * Returns 0 on success
267 */
268 typedef int (*eventdev_configure_t)(const struct rte_eventdev *dev);
269
270 /**
271 * Start a configured device.
272 *
273 * @param dev
274 * Event device pointer
275 *
276 * @return
277 * Returns 0 on success
278 */
279 typedef int (*eventdev_start_t)(struct rte_eventdev *dev);
280
281 /**
282 * Stop a configured device.
283 *
284 * @param dev
285 * Event device pointer
286 */
287 typedef void (*eventdev_stop_t)(struct rte_eventdev *dev);
288
289 /**
290 * Close a configured device.
291 *
292 * @param dev
293 * Event device pointer
294 *
295 * @return
296 * - 0 on success
297 * - (-EAGAIN) if can't close as device is busy
298 */
299 typedef int (*eventdev_close_t)(struct rte_eventdev *dev);
300
301 /**
302 * Retrieve the default event queue configuration.
303 *
304 * @param dev
305 * Event device pointer
306 * @param queue_id
307 * Event queue index
308 * @param[out] queue_conf
309 * Event queue configuration structure
310 *
311 */
312 typedef void (*eventdev_queue_default_conf_get_t)(struct rte_eventdev *dev,
313 uint8_t queue_id, struct rte_event_queue_conf *queue_conf);
314
315 /**
316 * Setup an event queue.
317 *
318 * @param dev
319 * Event device pointer
320 * @param queue_id
321 * Event queue index
322 * @param queue_conf
323 * Event queue configuration structure
324 *
325 * @return
326 * Returns 0 on success.
327 */
328 typedef int (*eventdev_queue_setup_t)(struct rte_eventdev *dev,
329 uint8_t queue_id,
330 const struct rte_event_queue_conf *queue_conf);
331
332 /**
333 * Release resources allocated by given event queue.
334 *
335 * @param dev
336 * Event device pointer
337 * @param queue_id
338 * Event queue index
339 *
340 */
341 typedef void (*eventdev_queue_release_t)(struct rte_eventdev *dev,
342 uint8_t queue_id);
343
344 /**
345 * Get an event queue attribute at runtime.
346 *
347 * @param dev
348 * Event device pointer
349 * @param queue_id
350 * Event queue index
351 * @param attr_id
352 * Event queue attribute id
353 * @param[out] attr_value
354 * Event queue attribute value
355 *
356 * @return
357 * - 0: Success.
358 * - <0: Error code on failure.
359 */
360 typedef int (*eventdev_queue_attr_get_t)(struct rte_eventdev *dev,
361 uint8_t queue_id, uint32_t attr_id,
362 uint32_t *attr_value);
363
364 /**
365 * Set an event queue attribute at runtime.
366 *
367 * @param dev
368 * Event device pointer
369 * @param queue_id
370 * Event queue index
371 * @param attr_id
372 * Event queue attribute id
373 * @param attr_value
374 * Event queue attribute value
375 *
376 * @return
377 * - 0: Success.
378 * - <0: Error code on failure.
379 */
380 typedef int (*eventdev_queue_attr_set_t)(struct rte_eventdev *dev,
381 uint8_t queue_id, uint32_t attr_id,
382 uint64_t attr_value);
383
384 /**
385 * Retrieve the default event port configuration.
386 *
387 * @param dev
388 * Event device pointer
389 * @param port_id
390 * Event port index
391 * @param[out] port_conf
392 * Event port configuration structure
393 *
394 */
395 typedef void (*eventdev_port_default_conf_get_t)(struct rte_eventdev *dev,
396 uint8_t port_id, struct rte_event_port_conf *port_conf);
397
398 /**
399 * Setup an event port.
400 *
401 * @param dev
402 * Event device pointer
403 * @param port_id
404 * Event port index
405 * @param port_conf
406 * Event port configuration structure
407 *
408 * @return
409 * Returns 0 on success.
410 */
411 typedef int (*eventdev_port_setup_t)(struct rte_eventdev *dev,
412 uint8_t port_id,
413 const struct rte_event_port_conf *port_conf);
414
415 /**
416 * Release memory resources allocated by given event port.
417 *
418 * @param port
419 * Event port pointer
420 *
421 */
422 typedef void (*eventdev_port_release_t)(void *port);
423
424 /**
425 * Quiesce any core specific resources consumed by the event port
426 *
427 * @param dev
428 * Event device pointer.
429 * @param port
430 * Event port pointer.
431 * @param flush_cb
432 * User-provided event flush function.
433 * @param args
434 * Arguments to be passed to the user-provided event flush function.
435 *
436 */
437 typedef void (*eventdev_port_quiesce_t)(struct rte_eventdev *dev, void *port,
438 rte_eventdev_port_flush_t flush_cb,
439 void *args);
440
441 /**
442 * Link multiple source event queues to destination event port.
443 *
444 * @param dev
445 * Event device pointer
446 * @param port
447 * Event port pointer
448 * @param queues
449 * Points to an array of *nb_links* event queues to be linked
450 * to the event port.
451 * @param priorities
452 * Points to an array of *nb_links* service priorities associated with each
453 * event queue link to event port.
454 * @param nb_links
455 * The number of links to establish
456 *
457 * @return
458 * Returns 0 on success.
459 *
460 */
461 typedef int (*eventdev_port_link_t)(struct rte_eventdev *dev, void *port,
462 const uint8_t queues[], const uint8_t priorities[],
463 uint16_t nb_links);
464
465 /**
466 * Unlink multiple source event queues from destination event port.
467 *
468 * @param dev
469 * Event device pointer
470 * @param port
471 * Event port pointer
472 * @param queues
473 * An array of *nb_unlinks* event queues to be unlinked from the event port.
474 * @param nb_unlinks
475 * The number of unlinks to establish
476 *
477 * @return
478 * Returns 0 on success.
479 *
480 */
481 typedef int (*eventdev_port_unlink_t)(struct rte_eventdev *dev, void *port,
482 uint8_t queues[], uint16_t nb_unlinks);
483
484 /**
485 * Unlinks in progress. Returns number of unlinks that the PMD is currently
486 * performing, but have not yet been completed.
487 *
488 * @param dev
489 * Event device pointer
490 *
491 * @param port
492 * Event port pointer
493 *
494 * @return
495 * Returns the number of in-progress unlinks. Zero is returned if none are
496 * in progress.
497 */
498 typedef int (*eventdev_port_unlinks_in_progress_t)(struct rte_eventdev *dev,
499 void *port);
500
501 /**
502 * Converts nanoseconds to *timeout_ticks* value for rte_event_dequeue()
503 *
504 * @param dev
505 * Event device pointer
506 * @param ns
507 * Wait time in nanosecond
508 * @param[out] timeout_ticks
509 * Value for the *timeout_ticks* parameter in rte_event_dequeue() function
510 *
511 * @return
512 * Returns 0 on success.
513 *
514 */
515 typedef int (*eventdev_dequeue_timeout_ticks_t)(struct rte_eventdev *dev,
516 uint64_t ns, uint64_t *timeout_ticks);
517
518 /**
519 * Dump internal information
520 *
521 * @param dev
522 * Event device pointer
523 * @param f
524 * A pointer to a file for output
525 *
526 */
527 typedef void (*eventdev_dump_t)(struct rte_eventdev *dev, FILE *f);
528
529 /**
530 * Retrieve a set of statistics from device
531 *
532 * @param dev
533 * Event device pointer
534 * @param mode
535 * Level (device, port or queue)
536 * @param queue_port_id
537 * Queue or port number depending on mode
538 * @param ids
539 * The stat ids to retrieve
540 * @param values
541 * The returned stat values
542 * @param n
543 * The number of id values and entries in the values array
544 * @return
545 * The number of stat values successfully filled into the values array
546 */
547 typedef int (*eventdev_xstats_get_t)(const struct rte_eventdev *dev,
548 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
549 const unsigned int ids[], uint64_t values[], unsigned int n);
550
551 /**
552 * Resets the statistic values in xstats for the device, based on mode.
553 */
554 typedef int (*eventdev_xstats_reset_t)(struct rte_eventdev *dev,
555 enum rte_event_dev_xstats_mode mode,
556 int16_t queue_port_id,
557 const uint32_t ids[],
558 uint32_t nb_ids);
559
560 /**
561 * Get names of extended stats of an event device
562 *
563 * @param dev
564 * Event device pointer
565 * @param mode
566 * Level (device, port or queue)
567 * @param queue_port_id
568 * Queue or port number depending on mode
569 * @param xstats_names
570 * Array of name values to be filled in
571 * @param ids
572 * The stat ids to retrieve
573 * @param size
574 * Number of values in the xstats_names array
575 * @return
576 * When size >= the number of stats, return the number of stat values filled
577 * into the array.
578 * When size < the number of available stats, return the number of stats
579 * values, and do not fill in any data into xstats_names.
580 */
581 typedef int (*eventdev_xstats_get_names_t)(const struct rte_eventdev *dev,
582 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
583 struct rte_event_dev_xstats_name *xstats_names,
584 unsigned int *ids, unsigned int size);
585
586 /**
587 * Get value of one stats and optionally return its id
588 *
589 * @param dev
590 * Event device pointer
591 * @param name
592 * The name of the stat to retrieve
593 * @param id
594 * Pointer to an unsigned int where we store the stat-id for future reference.
595 * This pointer may be null if the id is not required.
596 * @return
597 * The value of the stat, or (uint64_t)-1 if the stat is not found.
598 * If the stat is not found, the id value will be returned as (unsigned)-1,
599 * if id pointer is non-NULL
600 */
601 typedef uint64_t (*eventdev_xstats_get_by_name)(const struct rte_eventdev *dev,
602 const char *name, unsigned int *id);
603
604
605 /**
606 * Retrieve the event device's ethdev Rx adapter capabilities for the
607 * specified ethernet port
608 *
609 * @param dev
610 * Event device pointer
611 *
612 * @param eth_dev
613 * Ethernet device pointer
614 *
615 * @param[out] caps
616 * A pointer to memory filled with Rx event adapter capabilities.
617 *
618 * @return
619 * - 0: Success, driver provides Rx event adapter capabilities for the
620 * ethernet device.
621 * - <0: Error code returned by the driver function.
622 *
623 */
624 typedef int (*eventdev_eth_rx_adapter_caps_get_t)
625 (const struct rte_eventdev *dev,
626 const struct rte_eth_dev *eth_dev,
627 uint32_t *caps);
628
629 struct rte_event_eth_rx_adapter_queue_conf;
630
631 /**
632 * Retrieve the event device's timer adapter capabilities, as well as the ops
633 * structure that an event timer adapter should call through to enter the
634 * driver
635 *
636 * @param dev
637 * Event device pointer
638 *
639 * @param flags
640 * Flags that can be used to determine how to select an event timer
641 * adapter ops structure
642 *
643 * @param[out] caps
644 * A pointer to memory filled with Rx event adapter capabilities.
645 *
646 * @param[out] ops
647 * A pointer to the ops pointer to set with the address of the desired ops
648 * structure
649 *
650 * @return
651 * - 0: Success, driver provides Rx event adapter capabilities for the
652 * ethernet device.
653 * - <0: Error code returned by the driver function.
654 *
655 */
656 typedef int (*eventdev_timer_adapter_caps_get_t)(
657 const struct rte_eventdev *dev, uint64_t flags, uint32_t *caps,
658 const struct event_timer_adapter_ops **ops);
659
660 /**
661 * Add ethernet Rx queues to event device. This callback is invoked if
662 * the caps returned from rte_eventdev_eth_rx_adapter_caps_get(, eth_port_id)
663 * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set.
664 *
665 * @param dev
666 * Event device pointer
667 *
668 * @param eth_dev
669 * Ethernet device pointer
670 *
671 * @param rx_queue_id
672 * Ethernet device receive queue index
673 *
674 * @param queue_conf
675 * Additional configuration structure
676
677 * @return
678 * - 0: Success, ethernet receive queue added successfully.
679 * - <0: Error code returned by the driver function.
680 *
681 */
682 typedef int (*eventdev_eth_rx_adapter_queue_add_t)(
683 const struct rte_eventdev *dev,
684 const struct rte_eth_dev *eth_dev,
685 int32_t rx_queue_id,
686 const struct rte_event_eth_rx_adapter_queue_conf *queue_conf);
687
688 /**
689 * Delete ethernet Rx queues from event device. This callback is invoked if
690 * the caps returned from eventdev_eth_rx_adapter_caps_get(, eth_port_id)
691 * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set.
692 *
693 * @param dev
694 * Event device pointer
695 *
696 * @param eth_dev
697 * Ethernet device pointer
698 *
699 * @param rx_queue_id
700 * Ethernet device receive queue index
701 *
702 * @return
703 * - 0: Success, ethernet receive queue deleted successfully.
704 * - <0: Error code returned by the driver function.
705 *
706 */
707 typedef int (*eventdev_eth_rx_adapter_queue_del_t)
708 (const struct rte_eventdev *dev,
709 const struct rte_eth_dev *eth_dev,
710 int32_t rx_queue_id);
711
712 /**
713 * Retrieve Rx adapter queue config information for the specified
714 * rx queue ID.
715 *
716 * @param dev
717 * Event device pointer
718 *
719 * @param eth_dev
720 * Ethernet device pointer
721 *
722 * @param rx_queue_id
723 * Ethernet device receive queue index.
724 *
725 * @param[out] queue_conf
726 * Pointer to rte_event_eth_rx_adapter_queue_conf structure
727 *
728 * @return
729 * - 0: Success
730 * - <0: Error code on failure.
731 */
732 typedef int (*eventdev_eth_rx_adapter_queue_conf_get_t)
733 (const struct rte_eventdev *dev,
734 const struct rte_eth_dev *eth_dev,
735 uint16_t rx_queue_id,
736 struct rte_event_eth_rx_adapter_queue_conf *queue_conf);
737
738 /**
739 * Start ethernet Rx adapter. This callback is invoked if
740 * the caps returned from eventdev_eth_rx_adapter_caps_get(.., eth_port_id)
741 * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues
742 * from eth_port_id have been added to the event device.
743 *
744 * @param dev
745 * Event device pointer
746 *
747 * @param eth_dev
748 * Ethernet device pointer
749 *
750 * @return
751 * - 0: Success, ethernet Rx adapter started successfully.
752 * - <0: Error code returned by the driver function.
753 */
754 typedef int (*eventdev_eth_rx_adapter_start_t)
755 (const struct rte_eventdev *dev,
756 const struct rte_eth_dev *eth_dev);
757
758 /**
759 * Stop ethernet Rx adapter. This callback is invoked if
760 * the caps returned from eventdev_eth_rx_adapter_caps_get(..,eth_port_id)
761 * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues
762 * from eth_port_id have been added to the event device.
763 *
764 * @param dev
765 * Event device pointer
766 *
767 * @param eth_dev
768 * Ethernet device pointer
769 *
770 * @return
771 * - 0: Success, ethernet Rx adapter stopped successfully.
772 * - <0: Error code returned by the driver function.
773 */
774 typedef int (*eventdev_eth_rx_adapter_stop_t)
775 (const struct rte_eventdev *dev,
776 const struct rte_eth_dev *eth_dev);
777
778 struct rte_event_eth_rx_adapter_stats;
779
780 /**
781 * Retrieve ethernet Rx adapter statistics.
782 *
783 * @param dev
784 * Event device pointer
785 *
786 * @param eth_dev
787 * Ethernet device pointer
788 *
789 * @param[out] stats
790 * Pointer to stats structure
791 *
792 * @return
793 * Return 0 on success.
794 */
795
796 typedef int (*eventdev_eth_rx_adapter_stats_get)
797 (const struct rte_eventdev *dev,
798 const struct rte_eth_dev *eth_dev,
799 struct rte_event_eth_rx_adapter_stats *stats);
800 /**
801 * Reset ethernet Rx adapter statistics.
802 *
803 * @param dev
804 * Event device pointer
805 *
806 * @param eth_dev
807 * Ethernet device pointer
808 *
809 * @return
810 * Return 0 on success.
811 */
812 typedef int (*eventdev_eth_rx_adapter_stats_reset)
813 (const struct rte_eventdev *dev,
814 const struct rte_eth_dev *eth_dev);
815
816 struct rte_event_eth_rx_adapter_queue_stats;
817
818 /**
819 * Retrieve ethernet Rx adapter queue statistics.
820 *
821 * @param dev
822 * Event device pointer
823 *
824 * @param eth_dev
825 * Ethernet device pointer
826 *
827 * @param rx_queue_id
828 * Ethernet device receive queue index.
829 *
830 * @param[out] q_stats
831 * Pointer to queue stats structure
832 *
833 * @return
834 * Return 0 on success.
835 */
836 typedef int (*eventdev_eth_rx_adapter_q_stats_get)
837 (const struct rte_eventdev *dev,
838 const struct rte_eth_dev *eth_dev,
839 uint16_t rx_queue_id,
840 struct rte_event_eth_rx_adapter_queue_stats *q_stats);
841
842 /**
843 * Reset ethernet Rx adapter queue statistics.
844 *
845 * @param dev
846 * Event device pointer
847 *
848 * @param eth_dev
849 * Ethernet device pointer
850 *
851 * @param rx_queue_id
852 * Ethernet device receive queue index.
853 *
854 * @return
855 * Return 0 on success.
856 */
857 typedef int (*eventdev_eth_rx_adapter_q_stats_reset)
858 (const struct rte_eventdev *dev,
859 const struct rte_eth_dev *eth_dev,
860 uint16_t rx_queue_id);
861
862 /**
863 * Start eventdev selftest.
864 *
865 * @return
866 * Return 0 on success.
867 */
868 typedef int (*eventdev_selftest)(void);
869
870 struct rte_event_eth_rx_adapter_vector_limits;
871 /**
872 * Get event vector limits for a given event, ethernet device pair.
873 *
874 * @param dev
875 * Event device pointer
876 *
877 * @param eth_dev
878 * Ethernet device pointer
879 *
880 * @param[out] limits
881 * Pointer to the limits structure to be filled.
882 *
883 * @return
884 * - 0: Success.
885 * - <0: Error code returned by the driver function.
886 */
887 typedef int (*eventdev_eth_rx_adapter_vector_limits_get_t)(
888 const struct rte_eventdev *dev, const struct rte_eth_dev *eth_dev,
889 struct rte_event_eth_rx_adapter_vector_limits *limits);
890
891 typedef uint32_t rte_event_pmd_selftest_seqn_t;
892 extern int rte_event_pmd_selftest_seqn_dynfield_offset;
893
894 /**
895 * Read test sequence number from mbuf.
896 *
897 * @param mbuf Structure to read from.
898 * @return pointer to test sequence number.
899 */
900 __rte_internal
901 static inline rte_event_pmd_selftest_seqn_t *
rte_event_pmd_selftest_seqn(struct rte_mbuf * mbuf)902 rte_event_pmd_selftest_seqn(struct rte_mbuf *mbuf)
903 {
904 return RTE_MBUF_DYNFIELD(mbuf,
905 rte_event_pmd_selftest_seqn_dynfield_offset,
906 rte_event_pmd_selftest_seqn_t *);
907 }
908
909 struct rte_cryptodev;
910
911 /**
912 * This API may change without prior notice
913 *
914 * Retrieve the event device's crypto adapter capabilities for the
915 * specified cryptodev
916 *
917 * @param dev
918 * Event device pointer
919 *
920 * @param cdev
921 * cryptodev pointer
922 *
923 * @param[out] caps
924 * A pointer to memory filled with event adapter capabilities.
925 * It is expected to be pre-allocated & initialized by caller.
926 *
927 * @return
928 * - 0: Success, driver provides event adapter capabilities for the
929 * cryptodev.
930 * - <0: Error code returned by the driver function.
931 *
932 */
933 typedef int (*eventdev_crypto_adapter_caps_get_t)
934 (const struct rte_eventdev *dev,
935 const struct rte_cryptodev *cdev,
936 uint32_t *caps);
937
938 /**
939 * This API may change without prior notice
940 *
941 * Add crypto queue pair to event device. This callback is invoked if
942 * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id)
943 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set.
944 *
945 * @param dev
946 * Event device pointer
947 *
948 * @param cdev
949 * cryptodev pointer
950 *
951 * @param queue_pair_id
952 * cryptodev queue pair identifier.
953 *
954 * @param event
955 * Event information required for binding cryptodev queue pair to event queue.
956 * This structure will have a valid value for only those HW PMDs supporting
957 * @see RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_QP_EV_BIND capability.
958 *
959 * @return
960 * - 0: Success, cryptodev queue pair added successfully.
961 * - <0: Error code returned by the driver function.
962 *
963 */
964 typedef int (*eventdev_crypto_adapter_queue_pair_add_t)
965 (const struct rte_eventdev *dev,
966 const struct rte_cryptodev *cdev,
967 int32_t queue_pair_id,
968 const struct rte_event *event);
969
970
971 /**
972 * This API may change without prior notice
973 *
974 * Delete crypto queue pair to event device. This callback is invoked if
975 * the caps returned from rte_event_crypto_adapter_caps_get(, cdev_id)
976 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set.
977 *
978 * @param dev
979 * Event device pointer
980 *
981 * @param cdev
982 * cryptodev pointer
983 *
984 * @param queue_pair_id
985 * cryptodev queue pair identifier.
986 *
987 * @return
988 * - 0: Success, cryptodev queue pair deleted successfully.
989 * - <0: Error code returned by the driver function.
990 *
991 */
992 typedef int (*eventdev_crypto_adapter_queue_pair_del_t)
993 (const struct rte_eventdev *dev,
994 const struct rte_cryptodev *cdev,
995 int32_t queue_pair_id);
996
997 /**
998 * Start crypto adapter. This callback is invoked if
999 * the caps returned from rte_event_crypto_adapter_caps_get(.., cdev_id)
1000 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set and queue pairs
1001 * from cdev_id have been added to the event device.
1002 *
1003 * @param dev
1004 * Event device pointer
1005 *
1006 * @param cdev
1007 * Crypto device pointer
1008 *
1009 * @return
1010 * - 0: Success, crypto adapter started successfully.
1011 * - <0: Error code returned by the driver function.
1012 */
1013 typedef int (*eventdev_crypto_adapter_start_t)
1014 (const struct rte_eventdev *dev,
1015 const struct rte_cryptodev *cdev);
1016
1017 /**
1018 * Stop crypto adapter. This callback is invoked if
1019 * the caps returned from rte_event_crypto_adapter_caps_get(.., cdev_id)
1020 * has RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_* set and queue pairs
1021 * from cdev_id have been added to the event device.
1022 *
1023 * @param dev
1024 * Event device pointer
1025 *
1026 * @param cdev
1027 * Crypto device pointer
1028 *
1029 * @return
1030 * - 0: Success, crypto adapter stopped successfully.
1031 * - <0: Error code returned by the driver function.
1032 */
1033 typedef int (*eventdev_crypto_adapter_stop_t)
1034 (const struct rte_eventdev *dev,
1035 const struct rte_cryptodev *cdev);
1036
1037 struct rte_event_crypto_adapter_stats;
1038
1039 /**
1040 * Retrieve crypto adapter statistics.
1041 *
1042 * @param dev
1043 * Event device pointer
1044 *
1045 * @param cdev
1046 * Crypto device pointer
1047 *
1048 * @param[out] stats
1049 * Pointer to stats structure
1050 *
1051 * @return
1052 * Return 0 on success.
1053 */
1054
1055 typedef int (*eventdev_crypto_adapter_stats_get)
1056 (const struct rte_eventdev *dev,
1057 const struct rte_cryptodev *cdev,
1058 struct rte_event_crypto_adapter_stats *stats);
1059
1060 /**
1061 * Reset crypto adapter statistics.
1062 *
1063 * @param dev
1064 * Event device pointer
1065 *
1066 * @param cdev
1067 * Crypto device pointer
1068 *
1069 * @return
1070 * Return 0 on success.
1071 */
1072
1073 typedef int (*eventdev_crypto_adapter_stats_reset)
1074 (const struct rte_eventdev *dev,
1075 const struct rte_cryptodev *cdev);
1076
1077 /**
1078 * Retrieve the event device's eth Tx adapter capabilities.
1079 *
1080 * @param dev
1081 * Event device pointer
1082 *
1083 * @param eth_dev
1084 * Ethernet device pointer
1085 *
1086 * @param[out] caps
1087 * A pointer to memory filled with eth Tx adapter capabilities.
1088 *
1089 * @return
1090 * - 0: Success, driver provides eth Tx adapter capabilities
1091 * - <0: Error code returned by the driver function.
1092 *
1093 */
1094 typedef int (*eventdev_eth_tx_adapter_caps_get_t)
1095 (const struct rte_eventdev *dev,
1096 const struct rte_eth_dev *eth_dev,
1097 uint32_t *caps);
1098
1099 /**
1100 * Create adapter callback.
1101 *
1102 * @param id
1103 * Adapter identifier
1104 *
1105 * @param dev
1106 * Event device pointer
1107 *
1108 * @return
1109 * - 0: Success.
1110 * - <0: Error code on failure.
1111 */
1112 typedef int (*eventdev_eth_tx_adapter_create_t)(uint8_t id,
1113 const struct rte_eventdev *dev);
1114
1115 /**
1116 * Free adapter callback.
1117 *
1118 * @param id
1119 * Adapter identifier
1120 *
1121 * @param dev
1122 * Event device pointer
1123 *
1124 * @return
1125 * - 0: Success.
1126 * - <0: Error code on failure.
1127 */
1128 typedef int (*eventdev_eth_tx_adapter_free_t)(uint8_t id,
1129 const struct rte_eventdev *dev);
1130
1131 /**
1132 * Add a Tx queue to the adapter.
1133 * A queue value of -1 is used to indicate all
1134 * queues within the device.
1135 *
1136 * @param id
1137 * Adapter identifier
1138 *
1139 * @param dev
1140 * Event device pointer
1141 *
1142 * @param eth_dev
1143 * Ethernet device pointer
1144 *
1145 * @param tx_queue_id
1146 * Transmit queue index
1147 *
1148 * @return
1149 * - 0: Success.
1150 * - <0: Error code on failure.
1151 */
1152 typedef int (*eventdev_eth_tx_adapter_queue_add_t)(
1153 uint8_t id,
1154 const struct rte_eventdev *dev,
1155 const struct rte_eth_dev *eth_dev,
1156 int32_t tx_queue_id);
1157
1158 /**
1159 * Delete a Tx queue from the adapter.
1160 * A queue value of -1 is used to indicate all
1161 * queues within the device, that have been added to this
1162 * adapter.
1163 *
1164 * @param id
1165 * Adapter identifier
1166 *
1167 * @param dev
1168 * Event device pointer
1169 *
1170 * @param eth_dev
1171 * Ethernet device pointer
1172 *
1173 * @param tx_queue_id
1174 * Transmit queue index
1175 *
1176 * @return
1177 * - 0: Success, Queues deleted successfully.
1178 * - <0: Error code on failure.
1179 */
1180 typedef int (*eventdev_eth_tx_adapter_queue_del_t)(
1181 uint8_t id,
1182 const struct rte_eventdev *dev,
1183 const struct rte_eth_dev *eth_dev,
1184 int32_t tx_queue_id);
1185
1186 /**
1187 * Start the adapter.
1188 *
1189 * @param id
1190 * Adapter identifier
1191 *
1192 * @param dev
1193 * Event device pointer
1194 *
1195 * @return
1196 * - 0: Success, Adapter started correctly.
1197 * - <0: Error code on failure.
1198 */
1199 typedef int (*eventdev_eth_tx_adapter_start_t)(uint8_t id,
1200 const struct rte_eventdev *dev);
1201
1202 /**
1203 * Stop the adapter.
1204 *
1205 * @param id
1206 * Adapter identifier
1207 *
1208 * @param dev
1209 * Event device pointer
1210 *
1211 * @return
1212 * - 0: Success.
1213 * - <0: Error code on failure.
1214 */
1215 typedef int (*eventdev_eth_tx_adapter_stop_t)(uint8_t id,
1216 const struct rte_eventdev *dev);
1217
1218 struct rte_event_eth_tx_adapter_stats;
1219
1220 /**
1221 * Retrieve statistics for an adapter
1222 *
1223 * @param id
1224 * Adapter identifier
1225 *
1226 * @param dev
1227 * Event device pointer
1228 *
1229 * @param [out] stats
1230 * A pointer to structure used to retrieve statistics for an adapter
1231 *
1232 * @return
1233 * - 0: Success, statistics retrieved successfully.
1234 * - <0: Error code on failure.
1235 */
1236 typedef int (*eventdev_eth_tx_adapter_stats_get_t)(
1237 uint8_t id,
1238 const struct rte_eventdev *dev,
1239 struct rte_event_eth_tx_adapter_stats *stats);
1240
1241 /**
1242 * Reset statistics for an adapter
1243 *
1244 * @param id
1245 * Adapter identifier
1246 *
1247 * @param dev
1248 * Event device pointer
1249 *
1250 * @return
1251 * - 0: Success, statistics retrieved successfully.
1252 * - <0: Error code on failure.
1253 */
1254 typedef int (*eventdev_eth_tx_adapter_stats_reset_t)(uint8_t id,
1255 const struct rte_eventdev *dev);
1256
1257 /** Event device operations function pointer table */
1258 struct eventdev_ops {
1259 eventdev_info_get_t dev_infos_get; /**< Get device info. */
1260 eventdev_configure_t dev_configure; /**< Configure device. */
1261 eventdev_start_t dev_start; /**< Start device. */
1262 eventdev_stop_t dev_stop; /**< Stop device. */
1263 eventdev_close_t dev_close; /**< Close device. */
1264
1265 eventdev_queue_default_conf_get_t queue_def_conf;
1266 /**< Get default queue configuration. */
1267 eventdev_queue_setup_t queue_setup;
1268 /**< Set up an event queue. */
1269 eventdev_queue_release_t queue_release;
1270 /**< Release an event queue. */
1271 eventdev_queue_attr_get_t queue_attr_get;
1272 /**< Get an event queue attribute. */
1273 eventdev_queue_attr_set_t queue_attr_set;
1274 /**< Set an event queue attribute. */
1275
1276 eventdev_port_default_conf_get_t port_def_conf;
1277 /**< Get default port configuration. */
1278 eventdev_port_setup_t port_setup;
1279 /**< Set up an event port. */
1280 eventdev_port_release_t port_release;
1281 /**< Release an event port. */
1282 eventdev_port_quiesce_t port_quiesce;
1283 /**< Quiesce an event port. */
1284
1285 eventdev_port_link_t port_link;
1286 /**< Link event queues to an event port. */
1287 eventdev_port_unlink_t port_unlink;
1288 /**< Unlink event queues from an event port. */
1289 eventdev_port_unlinks_in_progress_t port_unlinks_in_progress;
1290 /**< Unlinks in progress on an event port. */
1291 eventdev_dequeue_timeout_ticks_t timeout_ticks;
1292 /**< Converts ns to *timeout_ticks* value for rte_event_dequeue() */
1293 eventdev_dump_t dump;
1294 /* Dump internal information */
1295
1296 eventdev_xstats_get_t xstats_get;
1297 /**< Get extended device statistics. */
1298 eventdev_xstats_get_names_t xstats_get_names;
1299 /**< Get names of extended stats. */
1300 eventdev_xstats_get_by_name xstats_get_by_name;
1301 /**< Get one value by name. */
1302 eventdev_xstats_reset_t xstats_reset;
1303 /**< Reset the statistics values in xstats. */
1304
1305 eventdev_eth_rx_adapter_caps_get_t eth_rx_adapter_caps_get;
1306 /**< Get ethernet Rx adapter capabilities */
1307 eventdev_eth_rx_adapter_queue_add_t eth_rx_adapter_queue_add;
1308 /**< Add Rx queues to ethernet Rx adapter */
1309 eventdev_eth_rx_adapter_queue_del_t eth_rx_adapter_queue_del;
1310 /**< Delete Rx queues from ethernet Rx adapter */
1311 eventdev_eth_rx_adapter_queue_conf_get_t eth_rx_adapter_queue_conf_get;
1312 /**< Get Rx adapter queue info */
1313 eventdev_eth_rx_adapter_start_t eth_rx_adapter_start;
1314 /**< Start ethernet Rx adapter */
1315 eventdev_eth_rx_adapter_stop_t eth_rx_adapter_stop;
1316 /**< Stop ethernet Rx adapter */
1317 eventdev_eth_rx_adapter_stats_get eth_rx_adapter_stats_get;
1318 /**< Get ethernet Rx stats */
1319 eventdev_eth_rx_adapter_stats_reset eth_rx_adapter_stats_reset;
1320 /**< Reset ethernet Rx stats */
1321 eventdev_eth_rx_adapter_vector_limits_get_t
1322 eth_rx_adapter_vector_limits_get;
1323 /**< Get event vector limits for the Rx adapter */
1324
1325 eventdev_timer_adapter_caps_get_t timer_adapter_caps_get;
1326 /**< Get timer adapter capabilities */
1327
1328 eventdev_crypto_adapter_caps_get_t crypto_adapter_caps_get;
1329 /**< Get crypto adapter capabilities */
1330 eventdev_crypto_adapter_queue_pair_add_t crypto_adapter_queue_pair_add;
1331 /**< Add queue pair to crypto adapter */
1332 eventdev_crypto_adapter_queue_pair_del_t crypto_adapter_queue_pair_del;
1333 /**< Delete queue pair from crypto adapter */
1334 eventdev_crypto_adapter_start_t crypto_adapter_start;
1335 /**< Start crypto adapter */
1336 eventdev_crypto_adapter_stop_t crypto_adapter_stop;
1337 /**< Stop crypto adapter */
1338 eventdev_crypto_adapter_stats_get crypto_adapter_stats_get;
1339 /**< Get crypto stats */
1340 eventdev_crypto_adapter_stats_reset crypto_adapter_stats_reset;
1341 /**< Reset crypto stats */
1342
1343 eventdev_eth_rx_adapter_q_stats_get eth_rx_adapter_queue_stats_get;
1344 /**< Get ethernet Rx queue stats */
1345 eventdev_eth_rx_adapter_q_stats_reset eth_rx_adapter_queue_stats_reset;
1346 /**< Reset ethernet Rx queue stats */
1347
1348 eventdev_eth_tx_adapter_caps_get_t eth_tx_adapter_caps_get;
1349 /**< Get ethernet Tx adapter capabilities */
1350
1351 eventdev_eth_tx_adapter_create_t eth_tx_adapter_create;
1352 /**< Create adapter callback */
1353 eventdev_eth_tx_adapter_free_t eth_tx_adapter_free;
1354 /**< Free adapter callback */
1355 eventdev_eth_tx_adapter_queue_add_t eth_tx_adapter_queue_add;
1356 /**< Add Tx queues to the eth Tx adapter */
1357 eventdev_eth_tx_adapter_queue_del_t eth_tx_adapter_queue_del;
1358 /**< Delete Tx queues from the eth Tx adapter */
1359 eventdev_eth_tx_adapter_start_t eth_tx_adapter_start;
1360 /**< Start eth Tx adapter */
1361 eventdev_eth_tx_adapter_stop_t eth_tx_adapter_stop;
1362 /**< Stop eth Tx adapter */
1363 eventdev_eth_tx_adapter_stats_get_t eth_tx_adapter_stats_get;
1364 /**< Get eth Tx adapter statistics */
1365 eventdev_eth_tx_adapter_stats_reset_t eth_tx_adapter_stats_reset;
1366 /**< Reset eth Tx adapter statistics */
1367
1368 eventdev_selftest dev_selftest;
1369 /**< Start eventdev Selftest */
1370
1371 eventdev_stop_flush_t dev_stop_flush;
1372 /**< User-provided event flush function */
1373 };
1374
1375 /**
1376 * Allocates a new eventdev slot for an event device and returns the pointer
1377 * to that slot for the driver to use.
1378 *
1379 * @param name
1380 * Unique identifier name for each device
1381 * @param socket_id
1382 * Socket to allocate resources on.
1383 * @return
1384 * - Slot in the rte_dev_devices array for a new device;
1385 */
1386 __rte_internal
1387 struct rte_eventdev *
1388 rte_event_pmd_allocate(const char *name, int socket_id);
1389
1390 /**
1391 * Release the specified eventdev device.
1392 *
1393 * @param eventdev
1394 * The *eventdev* pointer is the address of the *rte_eventdev* structure.
1395 * @return
1396 * - 0 on success, negative on error
1397 */
1398 __rte_internal
1399 int
1400 rte_event_pmd_release(struct rte_eventdev *eventdev);
1401
1402 /**
1403 *
1404 * @internal
1405 * This is the last step of device probing.
1406 * It must be called after a port is allocated and initialized successfully.
1407 *
1408 * @param eventdev
1409 * New event device.
1410 */
1411 __rte_internal
1412 void
1413 event_dev_probing_finish(struct rte_eventdev *eventdev);
1414
1415 /**
1416 * Reset eventdevice fastpath APIs to dummy values.
1417 *
1418 * @param fp_ops
1419 * The *fp_ops* pointer to reset.
1420 */
1421 __rte_internal
1422 void
1423 event_dev_fp_ops_reset(struct rte_event_fp_ops *fp_op);
1424
1425 /**
1426 * Set eventdevice fastpath APIs to event device values.
1427 *
1428 * @param fp_ops
1429 * The *fp_ops* pointer to set.
1430 */
1431 __rte_internal
1432 void
1433 event_dev_fp_ops_set(struct rte_event_fp_ops *fp_ops,
1434 const struct rte_eventdev *dev);
1435
1436 #ifdef __cplusplus
1437 }
1438 #endif
1439
1440 #endif /* _RTE_EVENTDEV_PMD_H_ */
1441