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