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