lib/librte_eventdev/rte_eventdev_pmd.h

   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 #ifdef __cplusplus
  17 extern "C" {
  18 #endif
  19
  20 #include <string.h>
  21
  22 #include <rte_common.h>
  23 #include <rte_config.h>
  24 #include <rte_dev.h>
  25 #include <rte_log.h>
  26 #include <rte_malloc.h>
  27
  28 #include "rte_eventdev.h"
  29 #include "rte_event_timer_adapter_pmd.h"
  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
  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
  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
  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))
  72
  73 /**< Ethernet Rx adapter cap to return If the packet transfers from
  74  * the ethdev to eventdev use a SW service function
  75  */
  76
  77 #define RTE_EVENTDEV_DETACHED  (0)
  78 #define RTE_EVENTDEV_ATTACHED  (1)
  79
  80 struct rte_eth_dev;
  81
  82 /** Global structure used for maintaining state of allocated event devices */
  83 struct rte_eventdev_global {
  84         uint8_t nb_devs;        /**< Number of devices found */
  85 };
  86
  87 extern struct rte_eventdev_global *rte_eventdev_globals;
  88 /** Pointer to global event devices data structure. */
  89 extern struct rte_eventdev *rte_eventdevs;
  90 /** The pool of rte_eventdev structures. */
  91
  92 /**
  93  * Get the rte_eventdev structure device pointer for the named device.
  94  *
  95  * @param name
  96  *   device name to select the device structure.
  97  *
  98  * @return
  99  *   - The rte_eventdev structure pointer for the given device ID.
 100  */
 101 static inline struct rte_eventdev *
 102 rte_event_pmd_get_named_dev(const char *name)
 103 {
 104         struct rte_eventdev *dev;
 105         unsigned int i;
 106
 107         if (name == NULL)
 108                 return NULL;
 109
 110         for (i = 0; i < RTE_EVENT_MAX_DEVS; i++) {
 111                 dev = &rte_eventdevs[i];
 112                 if ((dev->attached == RTE_EVENTDEV_ATTACHED) &&
 113                                 (strcmp(dev->data->name, name) == 0))
 114                         return dev;
 115         }
 116
 117         return NULL;
 118 }
 119
 120 /**
 121  * Validate if the event device index is valid attached event device.
 122  *
 123  * @param dev_id
 124  *   Event device index.
 125  *
 126  * @return
 127  *   - If the device index is valid (1) or not (0).
 128  */
 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  * @return
 159  *   Returns 0 on success
 160  */
 161 typedef void (*eventdev_info_get_t)(struct rte_eventdev *dev,
 162                 struct rte_event_dev_info *dev_info);
 163
 164 /**
 165  * Configure a device.
 166  *
 167  * @param dev
 168  *   Event device pointer
 169  *
 170  * @return
 171  *   Returns 0 on success
 172  */
 173 typedef int (*eventdev_configure_t)(const struct rte_eventdev *dev);
 174
 175 /**
 176  * Start a configured device.
 177  *
 178  * @param dev
 179  *   Event device pointer
 180  *
 181  * @return
 182  *   Returns 0 on success
 183  */
 184 typedef int (*eventdev_start_t)(struct rte_eventdev *dev);
 185
 186 /**
 187  * Stop a configured device.
 188  *
 189  * @param dev
 190  *   Event device pointer
 191  */
 192 typedef void (*eventdev_stop_t)(struct rte_eventdev *dev);
 193
 194 /**
 195  * Close a configured device.
 196  *
 197  * @param dev
 198  *   Event device pointer
 199  *
 200  * @return
 201  * - 0 on success
 202  * - (-EAGAIN) if can't close as device is busy
 203  */
 204 typedef int (*eventdev_close_t)(struct rte_eventdev *dev);
 205
 206 /**
 207  * Retrieve the default event queue configuration.
 208  *
 209  * @param dev
 210  *   Event device pointer
 211  * @param queue_id
 212  *   Event queue index
 213  * @param[out] queue_conf
 214  *   Event queue configuration structure
 215  *
 216  */
 217 typedef void (*eventdev_queue_default_conf_get_t)(struct rte_eventdev *dev,
 218                 uint8_t queue_id, struct rte_event_queue_conf *queue_conf);
 219
 220 /**
 221  * Setup an event queue.
 222  *
 223  * @param dev
 224  *   Event device pointer
 225  * @param queue_id
 226  *   Event queue index
 227  * @param queue_conf
 228  *   Event queue configuration structure
 229  *
 230  * @return
 231  *   Returns 0 on success.
 232  */
 233 typedef int (*eventdev_queue_setup_t)(struct rte_eventdev *dev,
 234                 uint8_t queue_id,
 235                 const struct rte_event_queue_conf *queue_conf);
 236
 237 /**
 238  * Release resources allocated by given event queue.
 239  *
 240  * @param dev
 241  *   Event device pointer
 242  * @param queue_id
 243  *   Event queue index
 244  *
 245  */
 246 typedef void (*eventdev_queue_release_t)(struct rte_eventdev *dev,
 247                 uint8_t queue_id);
 248
 249 /**
 250  * Retrieve the default event port configuration.
 251  *
 252  * @param dev
 253  *   Event device pointer
 254  * @param port_id
 255  *   Event port index
 256  * @param[out] port_conf
 257  *   Event port configuration structure
 258  *
 259  */
 260 typedef void (*eventdev_port_default_conf_get_t)(struct rte_eventdev *dev,
 261                 uint8_t port_id, struct rte_event_port_conf *port_conf);
 262
 263 /**
 264  * Setup an event port.
 265  *
 266  * @param dev
 267  *   Event device pointer
 268  * @param port_id
 269  *   Event port index
 270  * @param port_conf
 271  *   Event port configuration structure
 272  *
 273  * @return
 274  *   Returns 0 on success.
 275  */
 276 typedef int (*eventdev_port_setup_t)(struct rte_eventdev *dev,
 277                 uint8_t port_id,
 278                 const struct rte_event_port_conf *port_conf);
 279
 280 /**
 281  * Release memory resources allocated by given event port.
 282  *
 283  * @param port
 284  *   Event port pointer
 285  *
 286  */
 287 typedef void (*eventdev_port_release_t)(void *port);
 288
 289 /**
 290  * Link multiple source event queues to destination event port.
 291  *
 292  * @param dev
 293  *   Event device pointer
 294  * @param port
 295  *   Event port pointer
 296  * @param link
 297  *   Points to an array of *nb_links* event queues to be linked
 298  *   to the event port.
 299  * @param priorities
 300  *   Points to an array of *nb_links* service priorities associated with each
 301  *   event queue link to event port.
 302  * @param nb_links
 303  *   The number of links to establish
 304  *
 305  * @return
 306  *   Returns 0 on success.
 307  *
 308  */
 309 typedef int (*eventdev_port_link_t)(struct rte_eventdev *dev, void *port,
 310                 const uint8_t queues[], const uint8_t priorities[],
 311                 uint16_t nb_links);
 312
 313 /**
 314  * Unlink multiple source event queues from destination event port.
 315  *
 316  * @param dev
 317  *   Event device pointer
 318  * @param port
 319  *   Event port pointer
 320  * @param queues
 321  *   An array of *nb_unlinks* event queues to be unlinked from the event port.
 322  * @param nb_unlinks
 323  *   The number of unlinks to establish
 324  *
 325  * @return
 326  *   Returns 0 on success.
 327  *
 328  */
 329 typedef int (*eventdev_port_unlink_t)(struct rte_eventdev *dev, void *port,
 330                 uint8_t queues[], uint16_t nb_unlinks);
 331
 332 /**
 333  * Converts nanoseconds to *timeout_ticks* value for rte_event_dequeue()
 334  *
 335  * @param dev
 336  *   Event device pointer
 337  * @param ns
 338  *   Wait time in nanosecond
 339  * @param[out] timeout_ticks
 340  *   Value for the *timeout_ticks* parameter in rte_event_dequeue() function
 341  *
 342  * @return
 343  *   Returns 0 on success.
 344  *
 345  */
 346 typedef int (*eventdev_dequeue_timeout_ticks_t)(struct rte_eventdev *dev,
 347                 uint64_t ns, uint64_t *timeout_ticks);
 348
 349 /**
 350  * Dump internal information
 351  *
 352  * @param dev
 353  *   Event device pointer
 354  * @param f
 355  *   A pointer to a file for output
 356  *
 357  */
 358 typedef void (*eventdev_dump_t)(struct rte_eventdev *dev, FILE *f);
 359
 360 /**
 361  * Retrieve a set of statistics from device
 362  *
 363  * @param dev
 364  *   Event device pointer
 365  * @param ids
 366  *   The stat ids to retrieve
 367  * @param values
 368  *   The returned stat values
 369  * @param n
 370  *   The number of id values and entries in the values array
 371  * @return
 372  *   The number of stat values successfully filled into the values array
 373  */
 374 typedef int (*eventdev_xstats_get_t)(const struct rte_eventdev *dev,
 375                 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
 376                 const unsigned int ids[], uint64_t values[], unsigned int n);
 377
 378 /**
 379  * Resets the statistic values in xstats for the device, based on mode.
 380  */
 381 typedef int (*eventdev_xstats_reset_t)(struct rte_eventdev *dev,
 382                 enum rte_event_dev_xstats_mode mode,
 383                 int16_t queue_port_id,
 384                 const uint32_t ids[],
 385                 uint32_t nb_ids);
 386
 387 /**
 388  * Get names of extended stats of an event device
 389  *
 390  * @param dev
 391  *   Event device pointer
 392  * @param xstats_names
 393  *   Array of name values to be filled in
 394  * @param size
 395  *   Number of values in the xstats_names array
 396  * @return
 397  *   When size >= the number of stats, return the number of stat values filled
 398  *   into the array.
 399  *   When size < the number of available stats, return the number of stats
 400  *   values, and do not fill in any data into xstats_names.
 401  */
 402 typedef int (*eventdev_xstats_get_names_t)(const struct rte_eventdev *dev,
 403                 enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
 404                 struct rte_event_dev_xstats_name *xstats_names,
 405                 unsigned int *ids, unsigned int size);
 406
 407 /**
 408  * Get value of one stats and optionally return its id
 409  *
 410  * @param dev
 411  *   Event device pointer
 412  * @param name
 413  *   The name of the stat to retrieve
 414  * @param id
 415  *   Pointer to an unsigned int where we store the stat-id for future reference.
 416  *   This pointer may be null if the id is not required.
 417  * @return
 418  *   The value of the stat, or (uint64_t)-1 if the stat is not found.
 419  *   If the stat is not found, the id value will be returned as (unsigned)-1,
 420  *   if id pointer is non-NULL
 421  */
 422 typedef uint64_t (*eventdev_xstats_get_by_name)(const struct rte_eventdev *dev,
 423                 const char *name, unsigned int *id);
 424
 425
 426 /**
 427  * Retrieve the event device's ethdev Rx adapter capabilities for the
 428  * specified ethernet port
 429  *
 430  * @param dev
 431  *   Event device pointer
 432  *
 433  * @param eth_dev
 434  *   Ethernet device pointer
 435  *
 436  * @param[out] caps
 437  *   A pointer to memory filled with Rx event adapter capabilities.
 438  *
 439  * @return
 440  *   - 0: Success, driver provides Rx event adapter capabilities for the
 441  *      ethernet device.
 442  *   - <0: Error code returned by the driver function.
 443  *
 444  */
 445 typedef int (*eventdev_eth_rx_adapter_caps_get_t)
 446                                         (const struct rte_eventdev *dev,
 447                                         const struct rte_eth_dev *eth_dev,
 448                                         uint32_t *caps);
 449
 450 struct rte_event_eth_rx_adapter_queue_conf *queue_conf;
 451
 452 /**
 453  * Retrieve the event device's timer adapter capabilities, as well as the ops
 454  * structure that an event timer adapter should call through to enter the
 455  * driver
 456  *
 457  * @param dev
 458  *   Event device pointer
 459  *
 460  * @param flags
 461  *   Flags that can be used to determine how to select an event timer
 462  *   adapter ops structure
 463  *
 464  * @param[out] caps
 465  *   A pointer to memory filled with Rx event adapter capabilities.
 466  *
 467  * @param[out] ops
 468  *   A pointer to the ops pointer to set with the address of the desired ops
 469  *   structure
 470  *
 471  * @return
 472  *   - 0: Success, driver provides Rx event adapter capabilities for the
 473  *      ethernet device.
 474  *   - <0: Error code returned by the driver function.
 475  *
 476  */
 477 typedef int (*eventdev_timer_adapter_caps_get_t)(
 478                                 const struct rte_eventdev *dev,
 479                                 uint64_t flags,
 480                                 uint32_t *caps,
 481                                 const struct rte_event_timer_adapter_ops **ops);
 482
 483 /**
 484  * Add ethernet Rx queues to event device. This callback is invoked if
 485  * the caps returned from rte_eventdev_eth_rx_adapter_caps_get(, eth_port_id)
 486  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set.
 487  *
 488  * @param dev
 489  *   Event device pointer
 490  *
 491  * @param eth_dev
 492  *   Ethernet device pointer
 493  *
 494  * @param rx_queue_id
 495  *   Ethernet device receive queue index
 496  *
 497  * @param queue_conf
 498  *  Additional configuration structure
 499
 500  * @return
 501  *   - 0: Success, ethernet receive queue added successfully.
 502  *   - <0: Error code returned by the driver function.
 503  *
 504  */
 505 typedef int (*eventdev_eth_rx_adapter_queue_add_t)(
 506                 const struct rte_eventdev *dev,
 507                 const struct rte_eth_dev *eth_dev,
 508                 int32_t rx_queue_id,
 509                 const struct rte_event_eth_rx_adapter_queue_conf *queue_conf);
 510
 511 /**
 512  * Delete ethernet Rx queues from event device. This callback is invoked if
 513  * the caps returned from eventdev_eth_rx_adapter_caps_get(, eth_port_id)
 514  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set.
 515  *
 516  * @param dev
 517  *   Event device pointer
 518  *
 519  * @param eth_dev
 520  *   Ethernet device pointer
 521  *
 522  * @param rx_queue_id
 523  *   Ethernet device receive queue index
 524  *
 525  * @return
 526  *   - 0: Success, ethernet receive queue deleted successfully.
 527  *   - <0: Error code returned by the driver function.
 528  *
 529  */
 530 typedef int (*eventdev_eth_rx_adapter_queue_del_t)
 531                                         (const struct rte_eventdev *dev,
 532                                         const struct rte_eth_dev *eth_dev,
 533                                         int32_t rx_queue_id);
 534
 535 /**
 536  * Start ethernet Rx adapter. 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 and Rx queues
 539  * from eth_port_id have been added to the event device.
 540  *
 541  * @param dev
 542  *   Event device pointer
 543  *
 544  * @param eth_dev
 545  *   Ethernet device pointer
 546  *
 547  * @return
 548  *   - 0: Success, ethernet Rx adapter started successfully.
 549  *   - <0: Error code returned by the driver function.
 550  */
 551 typedef int (*eventdev_eth_rx_adapter_start_t)
 552                                         (const struct rte_eventdev *dev,
 553                                         const struct rte_eth_dev *eth_dev);
 554
 555 /**
 556  * Stop ethernet Rx adapter. This callback is invoked if
 557  * the caps returned from eventdev_eth_rx_adapter_caps_get(..,eth_port_id)
 558  * has RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT set and Rx queues
 559  * from eth_port_id have been added to the event device.
 560  *
 561  * @param dev
 562  *   Event device pointer
 563  *
 564  * @param eth_dev
 565  *   Ethernet device pointer
 566  *
 567  * @return
 568  *   - 0: Success, ethernet Rx adapter stopped successfully.
 569  *   - <0: Error code returned by the driver function.
 570  */
 571 typedef int (*eventdev_eth_rx_adapter_stop_t)
 572                                         (const struct rte_eventdev *dev,
 573                                         const struct rte_eth_dev *eth_dev);
 574
 575 struct rte_event_eth_rx_adapter_stats *stats;
 576
 577 /**
 578  * Retrieve ethernet Rx adapter statistics.
 579  *
 580  * @param dev
 581  *   Event device pointer
 582  *
 583  * @param eth_dev
 584  *   Ethernet device pointer
 585  *
 586  * @param[out] stats
 587  *   Pointer to stats structure
 588  *
 589  * @return
 590  *   Return 0 on success.
 591  */
 592
 593 typedef int (*eventdev_eth_rx_adapter_stats_get)
 594                         (const struct rte_eventdev *dev,
 595                         const struct rte_eth_dev *eth_dev,
 596                         struct rte_event_eth_rx_adapter_stats *stats);
 597 /**
 598  * Reset ethernet Rx adapter statistics.
 599  *
 600  * @param dev
 601  *   Event device pointer
 602  *
 603  * @param eth_dev
 604  *   Ethernet device pointer
 605  *
 606  * @return
 607  *   Return 0 on success.
 608  */
 609 typedef int (*eventdev_eth_rx_adapter_stats_reset)
 610                         (const struct rte_eventdev *dev,
 611                         const struct rte_eth_dev *eth_dev);
 612 /**
 613  * Start eventdev selftest.
 614  *
 615  * @return
 616  *   Return 0 on success.
 617  */
 618 typedef int (*eventdev_selftest)(void);
 619
 620 /** Event device operations function pointer table */
 621 struct rte_eventdev_ops {
 622         eventdev_info_get_t dev_infos_get;      /**< Get device info. */
 623         eventdev_configure_t dev_configure;     /**< Configure device. */
 624         eventdev_start_t dev_start;             /**< Start device. */
 625         eventdev_stop_t dev_stop;               /**< Stop device. */
 626         eventdev_close_t dev_close;             /**< Close device. */
 627
 628         eventdev_queue_default_conf_get_t queue_def_conf;
 629         /**< Get default queue configuration. */
 630         eventdev_queue_setup_t queue_setup;
 631         /**< Set up an event queue. */
 632         eventdev_queue_release_t queue_release;
 633         /**< Release an event queue. */
 634
 635         eventdev_port_default_conf_get_t port_def_conf;
 636         /**< Get default port configuration. */
 637         eventdev_port_setup_t port_setup;
 638         /**< Set up an event port. */
 639         eventdev_port_release_t port_release;
 640         /**< Release an event port. */
 641
 642         eventdev_port_link_t port_link;
 643         /**< Link event queues to an event port. */
 644         eventdev_port_unlink_t port_unlink;
 645         /**< Unlink event queues from an event port. */
 646         eventdev_dequeue_timeout_ticks_t timeout_ticks;
 647         /**< Converts ns to *timeout_ticks* value for rte_event_dequeue() */
 648         eventdev_dump_t dump;
 649         /* Dump internal information */
 650
 651         eventdev_xstats_get_t xstats_get;
 652         /**< Get extended device statistics. */
 653         eventdev_xstats_get_names_t xstats_get_names;
 654         /**< Get names of extended stats. */
 655         eventdev_xstats_get_by_name xstats_get_by_name;
 656         /**< Get one value by name. */
 657         eventdev_xstats_reset_t xstats_reset;
 658         /**< Reset the statistics values in xstats. */
 659
 660         eventdev_eth_rx_adapter_caps_get_t eth_rx_adapter_caps_get;
 661         /**< Get ethernet Rx adapter capabilities */
 662         eventdev_eth_rx_adapter_queue_add_t eth_rx_adapter_queue_add;
 663         /**< Add Rx queues to ethernet Rx adapter */
 664         eventdev_eth_rx_adapter_queue_del_t eth_rx_adapter_queue_del;
 665         /**< Delete Rx queues from ethernet Rx adapter */
 666         eventdev_eth_rx_adapter_start_t eth_rx_adapter_start;
 667         /**< Start ethernet Rx adapter */
 668         eventdev_eth_rx_adapter_stop_t eth_rx_adapter_stop;
 669         /**< Stop ethernet Rx adapter */
 670         eventdev_eth_rx_adapter_stats_get eth_rx_adapter_stats_get;
 671         /**< Get ethernet Rx stats */
 672         eventdev_eth_rx_adapter_stats_reset eth_rx_adapter_stats_reset;
 673         /**< Reset ethernet Rx stats */
 674
 675         eventdev_timer_adapter_caps_get_t timer_adapter_caps_get;
 676         /**< Get timer adapter capabilities */
 677
 678         eventdev_selftest dev_selftest;
 679         /**< Start eventdev Selftest */
 680
 681         eventdev_stop_flush_t dev_stop_flush;
 682         /**< User-provided event flush function */
 683 };
 684
 685 /**
 686  * Allocates a new eventdev slot for an event device and returns the pointer
 687  * to that slot for the driver to use.
 688  *
 689  * @param name
 690  *   Unique identifier name for each device
 691  * @param socket_id
 692  *   Socket to allocate resources on.
 693  * @return
 694  *   - Slot in the rte_dev_devices array for a new device;
 695  */
 696 struct rte_eventdev *
 697 rte_event_pmd_allocate(const char *name, int socket_id);
 698
 699 /**
 700  * Release the specified eventdev device.
 701  *
 702  * @param eventdev
 703  * The *eventdev* pointer is the address of the *rte_eventdev* structure.
 704  * @return
 705  *   - 0 on success, negative on error
 706  */
 707 int
 708 rte_event_pmd_release(struct rte_eventdev *eventdev);
 709
 710 #ifdef __cplusplus
 711 }
 712 #endif
 713
 714 #endif /* _RTE_EVENTDEV_PMD_H_ */