lib/librte_bbdev/rte_bbdev.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Intel Corporation
   3  */
   4
   5 #ifndef _RTE_BBDEV_H_
   6 #define _RTE_BBDEV_H_
   7
   8 /**
   9  * @file rte_bbdev.h
  10  *
  11  * Wireless base band device abstraction APIs.
  12  *
  13  * @warning
  14  * @b EXPERIMENTAL: this API may change without prior notice
  15  *
  16  * This API allows an application to discover, configure and use a device to
  17  * process operations. An asynchronous API (enqueue, followed by later dequeue)
  18  * is used for processing operations.
  19  *
  20  * The functions in this API are not thread-safe when called on the same
  21  * target object (a device, or a queue on a device), with the exception that
  22  * one thread can enqueue operations to a queue while another thread dequeues
  23  * from the same queue.
  24  */
  25
  26 #ifdef __cplusplus
  27 extern "C" {
  28 #endif
  29
  30 #include <stdint.h>
  31 #include <stdbool.h>
  32 #include <string.h>
  33
  34 #include <rte_compat.h>
  35 #include <rte_atomic.h>
  36 #include <rte_bus.h>
  37 #include <rte_cpuflags.h>
  38 #include <rte_memory.h>
  39
  40 #include "rte_bbdev_op.h"
  41
  42 #ifndef RTE_BBDEV_MAX_DEVS
  43 #define RTE_BBDEV_MAX_DEVS 128  /**< Max number of devices */
  44 #endif
  45
  46 /** Flags indiciate current state of BBDEV device */
  47 enum rte_bbdev_state {
  48         RTE_BBDEV_UNUSED,
  49         RTE_BBDEV_INITIALIZED
  50 };
  51
  52 /**
  53  * Get the total number of devices that have been successfully initialised.
  54  *
  55  * @return
  56  *   The total number of usable devices.
  57  */
  58 uint16_t __rte_experimental
  59 rte_bbdev_count(void);
  60
  61 /**
  62  * Check if a device is valid.
  63  *
  64  * @param dev_id
  65  *   The identifier of the device.
  66  *
  67  * @return
  68  *   true if device ID is valid and device is attached, false otherwise.
  69  */
  70 bool __rte_experimental
  71 rte_bbdev_is_valid(uint16_t dev_id);
  72
  73 /**
  74  * Get the next enabled device.
  75  *
  76  * @param dev_id
  77  *   The current device
  78  *
  79  * @return
  80  *   - The next device, or
  81  *   - RTE_BBDEV_MAX_DEVS if none found
  82  */
  83 uint16_t __rte_experimental
  84 rte_bbdev_find_next(uint16_t dev_id);
  85
  86 /** Iterate through all enabled devices */
  87 #define RTE_BBDEV_FOREACH(i) for (i = rte_bbdev_find_next(-1); \
  88                 i < RTE_BBDEV_MAX_DEVS; \
  89                 i = rte_bbdev_find_next(i))
  90
  91 /**
  92  * Setup up device queues.
  93  * This function must be called on a device before setting up the queues and
  94  * starting the device. It can also be called when a device is in the stopped
  95  * state. If any device queues have been configured their configuration will be
  96  * cleared by a call to this function.
  97  *
  98  * @param dev_id
  99  *   The identifier of the device.
 100  * @param num_queues
 101  *   Number of queues to configure on device.
 102  * @param socket_id
 103  *   ID of a socket which will be used to allocate memory.
 104  *
 105  * @return
 106  *   - 0 on success
 107  *   - -ENODEV if dev_id is invalid or the device is corrupted
 108  *   - -EINVAL if num_queues is invalid, 0 or greater than maximum
 109  *   - -EBUSY if the identified device has already started
 110  *   - -ENOMEM if unable to allocate memory
 111  */
 112 int __rte_experimental
 113 rte_bbdev_setup_queues(uint16_t dev_id, uint16_t num_queues, int socket_id);
 114
 115 /**
 116  * Enable interrupts.
 117  * This function may be called before starting the device to enable the
 118  * interrupts if they are available.
 119  *
 120  * @param dev_id
 121  *   The identifier of the device.
 122  *
 123  * @return
 124  *   - 0 on success
 125  *   - -ENODEV if dev_id is invalid or the device is corrupted
 126  *   - -EBUSY if the identified device has already started
 127  *   - -ENOTSUP if the interrupts are not supported by the device
 128  */
 129 int __rte_experimental
 130 rte_bbdev_intr_enable(uint16_t dev_id);
 131
 132 /** Device queue configuration structure */
 133 struct rte_bbdev_queue_conf {
 134         int socket;  /**< NUMA socket used for memory allocation */
 135         uint32_t queue_size;  /**< Size of queue */
 136         uint8_t priority;  /**< Queue priority */
 137         bool deferred_start; /**< Do not start queue when device is started. */
 138         enum rte_bbdev_op_type op_type; /**< Operation type */
 139 };
 140
 141 /**
 142  * Configure a queue on a device.
 143  * This function can be called after device configuration, and before starting.
 144  * It can also be called when the device or the queue is in the stopped state.
 145  *
 146  * @param dev_id
 147  *   The identifier of the device.
 148  * @param queue_id
 149  *   The index of the queue.
 150  * @param conf
 151  *   The queue configuration. If NULL, a default configuration will be used.
 152  *
 153  * @return
 154  *   - 0 on success
 155  *   - EINVAL if the identified queue size or priority are invalid
 156  *   - EBUSY if the identified queue or its device have already started
 157  */
 158 int __rte_experimental
 159 rte_bbdev_queue_configure(uint16_t dev_id, uint16_t queue_id,
 160                 const struct rte_bbdev_queue_conf *conf);
 161
 162 /**
 163  * Start a device.
 164  * This is the last step needed before enqueueing operations is possible.
 165  *
 166  * @param dev_id
 167  *   The identifier of the device.
 168  *
 169  * @return
 170  *   - 0 on success
 171  *   - negative value on failure - as returned from PMD driver
 172  */
 173 int __rte_experimental
 174 rte_bbdev_start(uint16_t dev_id);
 175
 176 /**
 177  * Stop a device.
 178  * The device can be reconfigured, and restarted after being stopped.
 179  *
 180  * @param dev_id
 181  *   The identifier of the device.
 182  *
 183  * @return
 184  *   - 0 on success
 185  */
 186 int __rte_experimental
 187 rte_bbdev_stop(uint16_t dev_id);
 188
 189 /**
 190  * Close a device.
 191  * The device cannot be restarted without reconfiguration!
 192  *
 193  * @param dev_id
 194  *   The identifier of the device.
 195  *
 196  * @return
 197  *   - 0 on success
 198  */
 199 int __rte_experimental
 200 rte_bbdev_close(uint16_t dev_id);
 201
 202 /**
 203  * Start a specified queue on a device.
 204  * This is only needed if the queue has been stopped, or if the deferred_start
 205  * flag has been set when configuring the queue.
 206  *
 207  * @param dev_id
 208  *   The identifier of the device.
 209  * @param queue_id
 210  *   The index of the queue.
 211  *
 212  * @return
 213  *   - 0 on success
 214  *   - negative value on failure - as returned from PMD driver
 215  */
 216 int __rte_experimental
 217 rte_bbdev_queue_start(uint16_t dev_id, uint16_t queue_id);
 218
 219 /**
 220  * Stop a specified queue on a device, to allow re configuration.
 221  *
 222  * @param dev_id
 223  *   The identifier of the device.
 224  * @param queue_id
 225  *   The index of the queue.
 226  *
 227  * @return
 228  *   - 0 on success
 229  *   - negative value on failure - as returned from PMD driver
 230  */
 231 int __rte_experimental
 232 rte_bbdev_queue_stop(uint16_t dev_id, uint16_t queue_id);
 233
 234 /** Device statistics. */
 235 struct rte_bbdev_stats {
 236         uint64_t enqueued_count;  /**< Count of all operations enqueued */
 237         uint64_t dequeued_count;  /**< Count of all operations dequeued */
 238         /** Total error count on operations enqueued */
 239         uint64_t enqueue_err_count;
 240         /** Total error count on operations dequeued */
 241         uint64_t dequeue_err_count;
 242 };
 243
 244 /**
 245  * Retrieve the general I/O statistics of a device.
 246  *
 247  * @param dev_id
 248  *   The identifier of the device.
 249  * @param stats
 250  *   Pointer to structure to where statistics will be copied. On error, this
 251  *   location may or may not have been modified.
 252  *
 253  * @return
 254  *   - 0 on success
 255  *   - EINVAL if invalid parameter pointer is provided
 256  */
 257 int __rte_experimental
 258 rte_bbdev_stats_get(uint16_t dev_id, struct rte_bbdev_stats *stats);
 259
 260 /**
 261  * Reset the statistics of a device.
 262  *
 263  * @param dev_id
 264  *   The identifier of the device.
 265  * @return
 266  *   - 0 on success
 267  */
 268 int __rte_experimental
 269 rte_bbdev_stats_reset(uint16_t dev_id);
 270
 271 /** Device information supplied by the device's driver */
 272 struct rte_bbdev_driver_info {
 273         /** Driver name */
 274         const char *driver_name;
 275
 276         /** Maximum number of queues supported by the device */
 277         unsigned int max_num_queues;
 278         /** Queue size limit (queue size must also be power of 2) */
 279         uint32_t queue_size_lim;
 280         /** Set if device off-loads operation to hardware  */
 281         bool hardware_accelerated;
 282         /** Max value supported by queue priority */
 283         uint8_t max_queue_priority;
 284         /** Set if device supports per-queue interrupts */
 285         bool queue_intr_supported;
 286         /** Minimum alignment of buffers, in bytes */
 287         uint16_t min_alignment;
 288         /** Default queue configuration used if none is supplied  */
 289         struct rte_bbdev_queue_conf default_queue_conf;
 290         /** Device operation capabilities */
 291         const struct rte_bbdev_op_cap *capabilities;
 292         /** Device cpu_flag requirements */
 293         const enum rte_cpu_flag_t *cpu_flag_reqs;
 294 };
 295
 296 /** Macro used at end of bbdev PMD list */
 297 #define RTE_BBDEV_END_OF_CAPABILITIES_LIST() \
 298         { RTE_BBDEV_OP_NONE }
 299
 300 /**
 301  * Device information structure used by an application to discover a devices
 302  * capabilities and current configuration
 303  */
 304 struct rte_bbdev_info {
 305         int socket_id;  /**< NUMA socket that device is on */
 306         const char *dev_name;  /**< Unique device name */
 307         const struct rte_bus *bus;  /**< Bus information */
 308         uint16_t num_queues;  /**< Number of queues currently configured */
 309         bool started;  /**< Set if device is currently started */
 310         struct rte_bbdev_driver_info drv;  /**< Info from device driver */
 311 };
 312
 313 /**
 314  * Retrieve information about a device.
 315  *
 316  * @param dev_id
 317  *   The identifier of the device.
 318  * @param dev_info
 319  *   Pointer to structure to where information will be copied. On error, this
 320  *   location may or may not have been modified.
 321  *
 322  * @return
 323  *   - 0 on success
 324  *   - EINVAL if invalid parameter pointer is provided
 325  */
 326 int __rte_experimental
 327 rte_bbdev_info_get(uint16_t dev_id, struct rte_bbdev_info *dev_info);
 328
 329 /** Queue information */
 330 struct rte_bbdev_queue_info {
 331         /** Current device configuration */
 332         struct rte_bbdev_queue_conf conf;
 333         /** Set if queue is currently started */
 334         bool started;
 335 };
 336
 337 /**
 338  * Retrieve information about a specific queue on a device.
 339  *
 340  * @param dev_id
 341  *   The identifier of the device.
 342  * @param queue_id
 343  *   The index of the queue.
 344  * @param queue_info
 345  *   Pointer to structure to where information will be copied. On error, this
 346  *   location may or may not have been modified.
 347  *
 348  * @return
 349  *   - 0 on success
 350  *   - EINVAL if invalid parameter pointer is provided
 351  */
 352 int __rte_experimental
 353 rte_bbdev_queue_info_get(uint16_t dev_id, uint16_t queue_id,
 354                 struct rte_bbdev_queue_info *queue_info);
 355
 356 /** @internal The data structure associated with each queue of a device. */
 357 struct rte_bbdev_queue_data {
 358         void *queue_private;  /**< Driver-specific per-queue data */
 359         struct rte_bbdev_queue_conf conf;  /**< Current configuration */
 360         struct rte_bbdev_stats queue_stats;  /**< Queue statistics */
 361         bool started;  /**< Queue state */
 362 };
 363
 364 /** @internal Enqueue encode operations for processing on queue of a device. */
 365 typedef uint16_t (*rte_bbdev_enqueue_enc_ops_t)(
 366                 struct rte_bbdev_queue_data *q_data,
 367                 struct rte_bbdev_enc_op **ops,
 368                 uint16_t num);
 369
 370 /** @internal Enqueue decode operations for processing on queue of a device. */
 371 typedef uint16_t (*rte_bbdev_enqueue_dec_ops_t)(
 372                 struct rte_bbdev_queue_data *q_data,
 373                 struct rte_bbdev_dec_op **ops,
 374                 uint16_t num);
 375
 376 /** @internal Dequeue encode operations from a queue of a device. */
 377 typedef uint16_t (*rte_bbdev_dequeue_enc_ops_t)(
 378                 struct rte_bbdev_queue_data *q_data,
 379                 struct rte_bbdev_enc_op **ops, uint16_t num);
 380
 381 /** @internal Dequeue decode operations from a queue of a device. */
 382 typedef uint16_t (*rte_bbdev_dequeue_dec_ops_t)(
 383                 struct rte_bbdev_queue_data *q_data,
 384                 struct rte_bbdev_dec_op **ops, uint16_t num);
 385
 386 #define RTE_BBDEV_NAME_MAX_LEN  64  /**< Max length of device name */
 387
 388 /**
 389  * @internal The data associated with a device, with no function pointers.
 390  * This structure is safe to place in shared memory to be common among
 391  * different processes in a multi-process configuration. Drivers can access
 392  * these fields, but should never write to them!
 393  */
 394 struct rte_bbdev_data {
 395         char name[RTE_BBDEV_NAME_MAX_LEN]; /**< Unique identifier name */
 396         void *dev_private;  /**< Driver-specific private data */
 397         uint16_t num_queues;  /**< Number of currently configured queues */
 398         struct rte_bbdev_queue_data *queues;  /**< Queue structures */
 399         uint16_t dev_id;  /**< Device ID */
 400         int socket_id;  /**< NUMA socket that device is on */
 401         bool started;  /**< Device run-time state */
 402         /** Counter of processes using the device */
 403         rte_atomic16_t process_cnt;
 404 };
 405
 406 /* Forward declarations */
 407 struct rte_bbdev_ops;
 408 struct rte_bbdev_callback;
 409 struct rte_intr_handle;
 410
 411 /** Structure to keep track of registered callbacks */
 412 TAILQ_HEAD(rte_bbdev_cb_list, rte_bbdev_callback);
 413
 414 /**
 415  * @internal The data structure associated with a device. Drivers can access
 416  * these fields, but should only write to the *_ops fields.
 417  */
 418 struct __rte_cache_aligned rte_bbdev {
 419         /**< Enqueue encode function */
 420         rte_bbdev_enqueue_enc_ops_t enqueue_enc_ops;
 421         /**< Enqueue decode function */
 422         rte_bbdev_enqueue_dec_ops_t enqueue_dec_ops;
 423         /**< Dequeue encode function */
 424         rte_bbdev_dequeue_enc_ops_t dequeue_enc_ops;
 425         /**< Dequeue decode function */
 426         rte_bbdev_dequeue_dec_ops_t dequeue_dec_ops;
 427         const struct rte_bbdev_ops *dev_ops;  /**< Functions exported by PMD */
 428         struct rte_bbdev_data *data;  /**< Pointer to device data */
 429         enum rte_bbdev_state state;  /**< If device is currently used or not */
 430         struct rte_device *device; /**< Backing device */
 431         /** User application callback for interrupts if present */
 432         struct rte_bbdev_cb_list list_cbs;
 433         struct rte_intr_handle *intr_handle; /**< Device interrupt handle */
 434 };
 435
 436 /** @internal array of all devices */
 437 extern struct rte_bbdev rte_bbdev_devices[];
 438
 439 /**
 440  * Enqueue a burst of processed encode operations to a queue of the device.
 441  * This functions only enqueues as many operations as currently possible and
 442  * does not block until @p num_ops entries in the queue are available.
 443  * This function does not provide any error notification to avoid the
 444  * corresponding overhead.
 445  *
 446  * @param dev_id
 447  *   The identifier of the device.
 448  * @param queue_id
 449  *   The index of the queue.
 450  * @param ops
 451  *   Pointer array containing operations to be enqueued Must have at least
 452  *   @p num_ops entries
 453  * @param num_ops
 454  *   The maximum number of operations to enqueue.
 455  *
 456  * @return
 457  *   The number of operations actually enqueued (this is the number of processed
 458  *   entries in the @p ops array).
 459  */
 460 static inline uint16_t
 461 rte_bbdev_enqueue_enc_ops(uint16_t dev_id, uint16_t queue_id,
 462                 struct rte_bbdev_enc_op **ops, uint16_t num_ops)
 463 {
 464         struct rte_bbdev *dev = &rte_bbdev_devices[dev_id];
 465         struct rte_bbdev_queue_data *q_data = &dev->data->queues[queue_id];
 466         uint16_t n = dev->enqueue_enc_ops(q_data, ops, num_ops);
 467
 468         rte_bbdev_log_verbose("%u encode ops enqueued to dev%u,q%u.\n",
 469                         num_ops, dev_id, queue_id);
 470
 471         return n;
 472 }
 473
 474 /**
 475  * Enqueue a burst of processed decode operations to a queue of the device.
 476  * This functions only enqueues as many operations as currently possible and
 477  * does not block until @p num_ops entries in the queue are available.
 478  * This function does not provide any error notification to avoid the
 479  * corresponding overhead.
 480  *
 481  * @param dev_id
 482  *   The identifier of the device.
 483  * @param queue_id
 484  *   The index of the queue.
 485  * @param ops
 486  *   Pointer array containing operations to be enqueued Must have at least
 487  *   @p num_ops entries
 488  * @param num_ops
 489  *   The maximum number of operations to enqueue.
 490  *
 491  * @return
 492  *   The number of operations actually enqueued (this is the number of processed
 493  *   entries in the @p ops array).
 494  */
 495 static inline uint16_t
 496 rte_bbdev_enqueue_dec_ops(uint16_t dev_id, uint16_t queue_id,
 497                 struct rte_bbdev_dec_op **ops, uint16_t num_ops)
 498 {
 499         struct rte_bbdev *dev = &rte_bbdev_devices[dev_id];
 500         struct rte_bbdev_queue_data *q_data = &dev->data->queues[queue_id];
 501         uint16_t n = dev->enqueue_dec_ops(q_data, ops, num_ops);
 502
 503         rte_bbdev_log_verbose("%u decode ops enqueued to dev%u,q%u.\n",
 504                         num_ops, dev_id, queue_id);
 505
 506         return n;
 507 }
 508
 509 /**
 510  * Dequeue a burst of processed encode operations from a queue of the device.
 511  * This functions returns only the current contents of the queue, and does not
 512  * block until @ num_ops is available.
 513  * This function does not provide any error notification to avoid the
 514  * corresponding overhead.
 515  *
 516  * @param dev_id
 517  *   The identifier of the device.
 518  * @param queue_id
 519  *   The index of the queue.
 520  * @param ops
 521  *   Pointer array where operations will be dequeued to. Must have at least
 522  *   @p num_ops entries
 523  * @param num_ops
 524  *   The maximum number of operations to dequeue.
 525  *
 526  * @return
 527  *   The number of operations actually dequeued (this is the number of entries
 528  *   copied into the @p ops array).
 529  */
 530 static inline uint16_t
 531 rte_bbdev_dequeue_enc_ops(uint16_t dev_id, uint16_t queue_id,
 532                 struct rte_bbdev_enc_op **ops, uint16_t num_ops)
 533 {
 534         struct rte_bbdev *dev = &rte_bbdev_devices[dev_id];
 535         struct rte_bbdev_queue_data *q_data = &dev->data->queues[queue_id];
 536         uint16_t n = dev->dequeue_enc_ops(q_data, ops, num_ops);
 537
 538         rte_bbdev_log_verbose("%u encode ops dequeued to dev%u,q%u\n",
 539                         n, dev_id, queue_id);
 540
 541         return n;
 542 }
 543
 544 /**
 545  * Dequeue a burst of processed decode operations from a queue of the device.
 546  * This functions returns only the current contents of the queue, and does not
 547  * block until @ num_ops is available.
 548  * This function does not provide any error notification to avoid the
 549  * corresponding overhead.
 550  *
 551  * @param dev_id
 552  *   The identifier of the device.
 553  * @param queue_id
 554  *   The index of the queue.
 555  * @param ops
 556  *   Pointer array where operations will be dequeued to. Must have at least
 557  *   @p num_ops entries
 558  * @param num_ops
 559  *   The maximum number of operations to dequeue.
 560  *
 561  * @return
 562  *   The number of operations actually dequeued (this is the number of entries
 563  *   copied into the @p ops array).
 564  */
 565
 566 static inline uint16_t
 567 rte_bbdev_dequeue_dec_ops(uint16_t dev_id, uint16_t queue_id,
 568                 struct rte_bbdev_dec_op **ops, uint16_t num_ops)
 569 {
 570         struct rte_bbdev *dev = &rte_bbdev_devices[dev_id];
 571         struct rte_bbdev_queue_data *q_data = &dev->data->queues[queue_id];
 572         uint16_t n = dev->dequeue_dec_ops(q_data, ops, num_ops);
 573
 574         rte_bbdev_log_verbose("%u decode ops dequeued to dev%u,q%u\n",
 575                         n, dev_id, queue_id);
 576
 577         return n;
 578 }
 579
 580 /** Definitions of device event types */
 581 enum rte_bbdev_event_type {
 582         RTE_BBDEV_EVENT_UNKNOWN,  /**< unknown event type */
 583         RTE_BBDEV_EVENT_ERROR,  /**< error interrupt event */
 584         RTE_BBDEV_EVENT_DEQUEUE,  /**< dequeue event */
 585         RTE_BBDEV_EVENT_MAX  /**< max value of this enum */
 586 };
 587
 588 /**
 589  * Typedef for application callback function registered by application
 590  * software for notification of device events
 591  *
 592  * @param dev_id
 593  *   Device identifier
 594  * @param event
 595  *   Device event to register for notification of.
 596  * @param cb_arg
 597  *   User specified parameter to be passed to user's callback function.
 598  * @param ret_param
 599  *   To pass data back to user application.
 600  */
 601 typedef void (*rte_bbdev_cb_fn)(uint16_t dev_id,
 602                 enum rte_bbdev_event_type event, void *cb_arg,
 603                 void *ret_param);
 604
 605 /**
 606  * Register a callback function for specific device id. Multiple callbacks can
 607  * be added and will be called in the order they are added when an event is
 608  * triggered. Callbacks are called in a separate thread created by the DPDK EAL.
 609  *
 610  * @param dev_id
 611  *   Device id.
 612  * @param event
 613  *   The event that the callback will be registered for.
 614  * @param cb_fn
 615  *   User supplied callback function to be called.
 616  * @param cb_arg
 617  *   Pointer to parameter that will be passed to the callback.
 618  *
 619  * @return
 620  *   Zero on success, negative value on failure.
 621  */
 622 int __rte_experimental
 623 rte_bbdev_callback_register(uint16_t dev_id, enum rte_bbdev_event_type event,
 624                 rte_bbdev_cb_fn cb_fn, void *cb_arg);
 625
 626 /**
 627  * Unregister a callback function for specific device id.
 628  *
 629  * @param dev_id
 630  *   The device identifier.
 631  * @param event
 632  *   The event that the callback will be unregistered for.
 633  * @param cb_fn
 634  *   User supplied callback function to be unregistered.
 635  * @param cb_arg
 636  *   Pointer to the parameter supplied when registering the callback.
 637  *   (void *)-1 means to remove all registered callbacks with the specified
 638  *   function address.
 639  *
 640  * @return
 641  *   - 0 on success
 642  *   - EINVAL if invalid parameter pointer is provided
 643  *   - EAGAIN if the provided callback pointer does not exist
 644  */
 645 int __rte_experimental
 646 rte_bbdev_callback_unregister(uint16_t dev_id, enum rte_bbdev_event_type event,
 647                 rte_bbdev_cb_fn cb_fn, void *cb_arg);
 648
 649 /**
 650  * Enable a one-shot interrupt on the next operation enqueued to a particular
 651  * queue. The interrupt will be triggered when the operation is ready to be
 652  * dequeued. To handle the interrupt, an epoll file descriptor must be
 653  * registered using rte_bbdev_queue_intr_ctl(), and then an application
 654  * thread/lcore can wait for the interrupt using rte_epoll_wait().
 655  *
 656  * @param dev_id
 657  *   The device identifier.
 658  * @param queue_id
 659  *   The index of the queue.
 660  *
 661  * @return
 662  *   - 0 on success
 663  *   - negative value on failure - as returned from PMD driver
 664  */
 665 int __rte_experimental
 666 rte_bbdev_queue_intr_enable(uint16_t dev_id, uint16_t queue_id);
 667
 668 /**
 669  * Disable a one-shot interrupt on the next operation enqueued to a particular
 670  * queue (if it has been enabled).
 671  *
 672  * @param dev_id
 673  *   The device identifier.
 674  * @param queue_id
 675  *   The index of the queue.
 676  *
 677  * @return
 678  *   - 0 on success
 679  *   - negative value on failure - as returned from PMD driver
 680  */
 681 int __rte_experimental
 682 rte_bbdev_queue_intr_disable(uint16_t dev_id, uint16_t queue_id);
 683
 684 /**
 685  * Control interface for per-queue interrupts.
 686  *
 687  * @param dev_id
 688  *   The device identifier.
 689  * @param queue_id
 690  *   The index of the queue.
 691  * @param epfd
 692  *   Epoll file descriptor that will be associated with the interrupt source.
 693  *   If the special value RTE_EPOLL_PER_THREAD is provided, a per thread epoll
 694  *   file descriptor created by the EAL is used (RTE_EPOLL_PER_THREAD can also
 695  *   be used when calling rte_epoll_wait()).
 696  * @param op
 697  *   The operation be performed for the vector.RTE_INTR_EVENT_ADD or
 698  *   RTE_INTR_EVENT_DEL.
 699  * @param data
 700  *   User context, that will be returned in the epdata.data field of the
 701  *   rte_epoll_event structure filled in by rte_epoll_wait().
 702  *
 703  * @return
 704  *   - 0 on success
 705  *   - ENOTSUP if interrupts are not supported by the identified device
 706  *   - negative value on failure - as returned from PMD driver
 707  */
 708 int __rte_experimental
 709 rte_bbdev_queue_intr_ctl(uint16_t dev_id, uint16_t queue_id, int epfd, int op,
 710                 void *data);
 711
 712 #ifdef __cplusplus
 713 }
 714 #endif
 715
 716 #endif /* _RTE_BBDEV_H_ */