Provided by: dpdk-doc_24.11.2-2_all bug

NAME

       rte_bbdev.h

SYNOPSIS

       #include <stdint.h>
       #include <stdbool.h>
       #include <rte_compat.h>
       #include <rte_cpuflags.h>
       #include 'rte_bbdev_op.h'

   Data Structures
       struct rte_bbdev_queue_conf
       struct rte_bbdev_stats
       struct rte_bbdev_driver_info
       struct rte_bbdev_info
       struct rte_bbdev_queue_info

   Macros
       #define RTE_BBDEV_MAX_DEVS   128
       #define RTE_BBDEV_FOREACH(i)
       #define RTE_BBDEV_END_OF_CAPABILITIES_LIST()      { RTE_BBDEV_OP_NONE }
       #define RTE_BBDEV_NAME_MAX_LEN   64

   Typedefs
       typedef void(* rte_bbdev_cb_fn) (uint16_t dev_id, enum rte_bbdev_event_type event, void *cb_arg, void
           *ret_param)

   Enumerations
       enum rte_bbdev_state
       enum rte_bbdev_enqueue_status { RTE_BBDEV_ENQ_STATUS_NONE, RTE_BBDEV_ENQ_STATUS_QUEUE_FULL,
           RTE_BBDEV_ENQ_STATUS_RING_FULL, RTE_BBDEV_ENQ_STATUS_INVALID_OP }
       enum rte_bbdev_device_status { RTE_BBDEV_DEV_NOSTATUS, RTE_BBDEV_DEV_NOT_SUPPORTED, RTE_BBDEV_DEV_RESET,
           RTE_BBDEV_DEV_CONFIGURED, RTE_BBDEV_DEV_ACTIVE, RTE_BBDEV_DEV_FATAL_ERR, RTE_BBDEV_DEV_RESTART_REQ,
           RTE_BBDEV_DEV_RECONFIG_REQ, RTE_BBDEV_DEV_CORRECT_ERR }
       enum rte_bbdev_event_type { RTE_BBDEV_EVENT_UNKNOWN, RTE_BBDEV_EVENT_ERROR, RTE_BBDEV_EVENT_DEQUEUE,
           RTE_BBDEV_EVENT_MAX }

   Functions
       uint16_t rte_bbdev_count (void)
       bool rte_bbdev_is_valid (uint16_t dev_id)
       uint16_t rte_bbdev_find_next (uint16_t dev_id)
       int rte_bbdev_setup_queues (uint16_t dev_id, uint16_t num_queues, int socket_id)
       int rte_bbdev_intr_enable (uint16_t dev_id)
       int rte_bbdev_queue_configure (uint16_t dev_id, uint16_t queue_id, const struct rte_bbdev_queue_conf
           *conf)
       int rte_bbdev_start (uint16_t dev_id)
       int rte_bbdev_stop (uint16_t dev_id)
       int rte_bbdev_close (uint16_t dev_id)
       int rte_bbdev_queue_start (uint16_t dev_id, uint16_t queue_id)
       int rte_bbdev_queue_stop (uint16_t dev_id, uint16_t queue_id)
       int rte_bbdev_stats_get (uint16_t dev_id, struct rte_bbdev_stats *stats)
       int rte_bbdev_stats_reset (uint16_t dev_id)
       int rte_bbdev_info_get (uint16_t dev_id, struct rte_bbdev_info *dev_info)
       int rte_bbdev_queue_info_get (uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_queue_info
           *queue_info)
       RTE_TAILQ_HEAD (rte_bbdev_cb_list, rte_bbdev_callback)
       static uint16_t rte_bbdev_enqueue_enc_ops (uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_enc_op
           **ops, uint16_t num_ops)
       static uint16_t rte_bbdev_enqueue_dec_ops (uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_dec_op
           **ops, uint16_t num_ops)
       static uint16_t rte_bbdev_enqueue_ldpc_enc_ops (uint16_t dev_id, uint16_t queue_id, struct
           rte_bbdev_enc_op **ops, uint16_t num_ops)
       static uint16_t rte_bbdev_enqueue_ldpc_dec_ops (uint16_t dev_id, uint16_t queue_id, struct
           rte_bbdev_dec_op **ops, uint16_t num_ops)
       static uint16_t rte_bbdev_enqueue_fft_ops (uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_fft_op
           **ops, uint16_t num_ops)
       static uint16_t rte_bbdev_enqueue_mldts_ops (uint16_t dev_id, uint16_t queue_id, struct
           rte_bbdev_mldts_op **ops, uint16_t num_ops)
       static uint16_t rte_bbdev_dequeue_enc_ops (uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_enc_op
           **ops, uint16_t num_ops)
       static uint16_t rte_bbdev_dequeue_dec_ops (uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_dec_op
           **ops, uint16_t num_ops)
       static uint16_t rte_bbdev_dequeue_ldpc_enc_ops (uint16_t dev_id, uint16_t queue_id, struct
           rte_bbdev_enc_op **ops, uint16_t num_ops)
       static uint16_t rte_bbdev_dequeue_ldpc_dec_ops (uint16_t dev_id, uint16_t queue_id, struct
           rte_bbdev_dec_op **ops, uint16_t num_ops)
       static uint16_t rte_bbdev_dequeue_fft_ops (uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_fft_op
           **ops, uint16_t num_ops)
       static uint16_t rte_bbdev_dequeue_mldts_ops (uint16_t dev_id, uint16_t queue_id, struct
           rte_bbdev_mldts_op **ops, uint16_t num_ops)
       int rte_bbdev_callback_register (uint16_t dev_id, enum rte_bbdev_event_type event, rte_bbdev_cb_fn cb_fn,
           void *cb_arg)
       int rte_bbdev_callback_unregister (uint16_t dev_id, enum rte_bbdev_event_type event, rte_bbdev_cb_fn
           cb_fn, void *cb_arg)
       int rte_bbdev_queue_intr_enable (uint16_t dev_id, uint16_t queue_id)
       int rte_bbdev_queue_intr_disable (uint16_t dev_id, uint16_t queue_id)
       int rte_bbdev_queue_intr_ctl (uint16_t dev_id, uint16_t queue_id, int epfd, int op, void *data)
       const char * rte_bbdev_device_status_str (enum rte_bbdev_device_status status)
       const char * rte_bbdev_enqueue_status_str (enum rte_bbdev_enqueue_status status)
       __rte_experimental int rte_bbdev_queue_ops_dump (uint16_t dev_id, uint16_t queue_index, FILE *file)
       __rte_experimental char * rte_bbdev_ops_param_string (void *op, enum rte_bbdev_op_type op_type, char
           *str, uint32_t len)

Detailed Description

       Wireless base band device abstraction APIs.

       This API allows an application to discover, configure and use a device to process operations. An
       asynchronous API (enqueue, followed by later dequeue) is used for processing operations.

       The functions in this API are not thread-safe when called on the same target object (a device, or a queue
       on a device), with the exception that one thread can enqueue operations to a queue while another thread
       dequeues from the same queue.

       Definition in file rte_bbdev.h.

Macro Definition Documentation

   #define RTE_BBDEV_MAX_DEVS   128
       Max number of devices

       Definition at line 36 of file rte_bbdev.h.

   #define RTE_BBDEV_FOREACH(i)
       Value:.PP
               for (i = rte_bbdev_find_next(-1); \
               i < RTE_BBDEV_MAX_DEVS; \
               i = rte_bbdev_find_next(i))
       Iterate through all enabled devices

       Definition at line 87 of file rte_bbdev.h.

   #define RTE_BBDEV_END_OF_CAPABILITIES_LIST()      { RTE_BBDEV_OP_NONE }
       Macro used at end of bbdev PMD list

       Definition at line 362 of file rte_bbdev.h.

   #define RTE_BBDEV_NAME_MAX_LEN   64
       Max length of device name

       Definition at line 477 of file rte_bbdev.h.

Typedef Documentation

   typedef void(* rte_bbdev_cb_fn) (uint16_t dev_id, enum rte_bbdev_event_type event, void *cb_arg, void
       *ret_param)
       Typedef for application callback function registered by application software for notification of device
       events

       Parameters
           dev_id Device identifier
           event Device event to register for notification of.
           cb_arg User specified parameter to be passed to user's callback function.
           ret_param To pass data back to user application.

       Definition at line 930 of file rte_bbdev.h.

Enumeration Type Documentation

   enum rte_bbdev_state
       Flags indicate current state of BBDEV device

       Definition at line 47 of file rte_bbdev.h.

   enum rte_bbdev_enqueue_status
       Flags to indicate the reason why a previous enqueue may not have consumed all requested operations. In
       case of multiple reasons the latter supersedes a previous one. The related macro
       RTE_BBDEV_ENQ_STATUS_SIZE_MAX can be used as an absolute maximum for notably sizing array while allowing
       for future enumeration insertion.

       Enumerator

       RTE_BBDEV_ENQ_STATUS_NONE
              Nothing to report.

       RTE_BBDEV_ENQ_STATUS_QUEUE_FULL
              Not enough room in queue.

       RTE_BBDEV_ENQ_STATUS_RING_FULL
              Not enough room in ring.

       RTE_BBDEV_ENQ_STATUS_INVALID_OP
              Operation was rejected as invalid.

       Definition at line 242 of file rte_bbdev.h.

   enum rte_bbdev_device_status
       Flags to indicate the status of the device.

       Enumerator

       RTE_BBDEV_DEV_NOSTATUS
              Nothing being reported.

       RTE_BBDEV_DEV_NOT_SUPPORTED
              Device status is not supported on the PMD.

       RTE_BBDEV_DEV_RESET
              Device in reset and un-configured state.

       RTE_BBDEV_DEV_CONFIGURED
              Device is configured and ready to use.

       RTE_BBDEV_DEV_ACTIVE
              Device is configured and VF is being used.

       RTE_BBDEV_DEV_FATAL_ERR
              Device has hit a fatal uncorrectable error.

       RTE_BBDEV_DEV_RESTART_REQ
              Device requires application to restart.

       RTE_BBDEV_DEV_RECONFIG_REQ
              Device requires application to reconfigure queues.

       RTE_BBDEV_DEV_CORRECT_ERR
              Warning of a correctable error event happened.

       Definition at line 253 of file rte_bbdev.h.

   enum rte_bbdev_event_type
       Definitions of device event types

       Enumerator

       RTE_BBDEV_EVENT_UNKNOWN
              unknown event type

       RTE_BBDEV_EVENT_ERROR
              error interrupt event

       RTE_BBDEV_EVENT_DEQUEUE
              dequeue event

       RTE_BBDEV_EVENT_MAX
              max value of this enum

       Definition at line 910 of file rte_bbdev.h.

Function Documentation

   uint16_t rte_bbdev_count (void)
       Get the total number of devices that have been successfully initialised.

       Returns
           The total number of usable devices.

   bool rte_bbdev_is_valid (uint16_t dev_id)
       Check if a device is valid.

       Parameters
           dev_id The identifier of the device.

       Returns
           true if device ID is valid and device is attached, false otherwise.

   uint16_t rte_bbdev_find_next (uint16_t dev_id)
       Get the next enabled device.

       Parameters
           dev_id The current device

       Returns

           • The next device, or

           • RTE_BBDEV_MAX_DEVS if none found

   int rte_bbdev_setup_queues (uint16_t dev_id, uint16_t num_queues, int socket_id)
       Setup  up  device  queues.  This  function  must  be  called on a device before setting up the queues and
       starting the device. It can also be called when a device is in the stopped state. If  any  device  queues
       have been configured their configuration will be cleared by a call to this function.

       Parameters
           dev_id The identifier of the device.
           num_queues Number of queues to configure on device.
           socket_id ID of a socket which will be used to allocate memory.

       Returns

           • 0 on success

           • -ENODEV if dev_id is invalid or the device is corrupted

           • -EINVAL if num_queues is invalid, 0 or greater than maximum

           • -EBUSY if the identified device has already started

           • -ENOMEM if unable to allocate memory

   int rte_bbdev_intr_enable (uint16_t dev_id)
       Enable  interrupts.  This  function  may be called before starting the device to enable the interrupts if
       they are available.

       Parameters
           dev_id The identifier of the device.

       Returns

           • 0 on success

           • -ENODEV if dev_id is invalid or the device is corrupted

           • -EBUSY if the identified device has already started

           • -ENOTSUP if the interrupts are not supported by the device

   int rte_bbdev_queue_configure (uint16_t dev_id, uint16_t queue_id, const struct rte_bbdev_queue_conf * conf)
       Configure a queue on a device. This function  can  be  called  after  device  configuration,  and  before
       starting. It can also be called when the device or the queue is in the stopped state.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           conf The queue configuration. If NULL, a default configuration will be used.

       Returns

           • 0 on success

           • EINVAL if the identified queue size or priority are invalid

           • EBUSY if the identified queue or its device have already started

   int rte_bbdev_start (uint16_t dev_id)
       Start a device. This is the last step needed before enqueueing operations is possible.

       Parameters
           dev_id The identifier of the device.

       Returns

           • 0 on success

           • negative value on failure - as returned from PMD

   int rte_bbdev_stop (uint16_t dev_id)
       Stop a device. The device can be reconfigured, and restarted after being stopped.

       Parameters
           dev_id The identifier of the device.

       Returns

           • 0 on success

   int rte_bbdev_close (uint16_t dev_id)
       Close a device. The device cannot be restarted without reconfiguration!

       Parameters
           dev_id The identifier of the device.

       Returns

           • 0 on success

   int rte_bbdev_queue_start (uint16_t dev_id, uint16_t queue_id)
       Start  a  specified  queue  on  a  device.  This  is only needed if the queue has been stopped, or if the
       deferred_start flag has been set when configuring the queue.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.

       Returns

           • 0 on success

           • negative value on failure - as returned from PMD

   int rte_bbdev_queue_stop (uint16_t dev_id, uint16_t queue_id)
       Stop a specified queue on a device, to allow re configuration.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.

       Returns

           • 0 on success

           • negative value on failure - as returned from PMD

   int rte_bbdev_stats_get (uint16_t dev_id, struct rte_bbdev_stats * stats)
       Retrieve the general I/O statistics of a device.

       Parameters
           dev_id The identifier of the device.
           stats Pointer to structure to where statistics will be copied. On error, this location may or may not
           have been modified.

       Returns

           • 0 on success

           • EINVAL if invalid parameter pointer is provided

   int rte_bbdev_stats_reset (uint16_t dev_id)
       Reset the statistics of a device.

       Parameters
           dev_id The identifier of the device.

       Returns

           • 0 on success

   int rte_bbdev_info_get (uint16_t dev_id, struct rte_bbdev_info * dev_info)
       Retrieve information about a device.

       Parameters
           dev_id The identifier of the device.
           dev_info Pointer to structure to where information will be copied. On error, this location may or may
           not have been modified.

       Returns

           • 0 on success

           • EINVAL if invalid parameter pointer is provided

   int rte_bbdev_queue_info_get (uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_queue_info * queue_info)
       Retrieve information about a specific queue on a device.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           queue_info Pointer to structure to where information will be copied. On error, this location  may  or
           may not have been modified.

       Returns

           • 0 on success

           • EINVAL if invalid parameter pointer is provided

   RTE_TAILQ_HEAD (rte_bbdev_cb_list, rte_bbdev_callback)
       Structure to keep track of registered callbacks

   static  uint16_t  rte_bbdev_enqueue_enc_ops  (uint16_t  dev_id, uint16_t queue_id, struct rte_bbdev_enc_op **
       ops, uint16_t num_ops) [inline],  [static]
       Enqueue a burst of processed encode operations to a queue of the device. This functions only enqueues  as
       many  operations  as  currently  possible  and  does  not  block  until  num_ops entries in the queue are
       available. This function does not provide any error notification to avoid the corresponding overhead.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           ops Pointer array containing operations to be enqueued Must have at least num_ops entries
           num_ops The maximum number of operations to enqueue.

       Returns
           The number of operations actually enqueued (this is the  number  of  processed  entries  in  the  ops
           array).

       Definition at line 567 of file rte_bbdev.h.

   static  uint16_t  rte_bbdev_enqueue_dec_ops  (uint16_t  dev_id, uint16_t queue_id, struct rte_bbdev_dec_op **
       ops, uint16_t num_ops) [inline],  [static]
       Enqueue a burst of processed decode operations to a queue of the device. This functions only enqueues  as
       many  operations  as  currently  possible  and  does  not  block  until  num_ops entries in the queue are
       available. This function does not provide any error notification to avoid the corresponding overhead.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           ops Pointer array containing operations to be enqueued Must have at least num_ops entries
           num_ops The maximum number of operations to enqueue.

       Returns
           The number of operations actually enqueued (this is the  number  of  processed  entries  in  the  ops
           array).

       Definition at line 597 of file rte_bbdev.h.

   static  uint16_t  rte_bbdev_enqueue_ldpc_enc_ops (uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_enc_op
       ** ops, uint16_t num_ops) [inline],  [static]
       Enqueue a burst of processed encode operations to a queue of the device. This functions only enqueues  as
       many  operations  as  currently  possible  and  does  not  block  until  num_ops entries in the queue are
       available. This function does not provide any error notification to avoid the corresponding overhead.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           ops Pointer array containing operations to be enqueued Must have at least num_ops entries
           num_ops The maximum number of operations to enqueue.

       Returns
           The number of operations actually enqueued (this is the  number  of  processed  entries  in  the  ops
           array).

       Definition at line 627 of file rte_bbdev.h.

   static  uint16_t  rte_bbdev_enqueue_ldpc_dec_ops (uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_dec_op
       ** ops, uint16_t num_ops) [inline],  [static]
       Enqueue a burst of processed decode operations to a queue of the device. This functions only enqueues  as
       many  operations  as  currently  possible  and  does  not  block  until  num_ops entries in the queue are
       available. This function does not provide any error notification to avoid the corresponding overhead.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           ops Pointer array containing operations to be enqueued Must have at least num_ops entries
           num_ops The maximum number of operations to enqueue.

       Returns
           The number of operations actually enqueued (this is the  number  of  processed  entries  in  the  ops
           array).

       Definition at line 657 of file rte_bbdev.h.

   static  uint16_t  rte_bbdev_enqueue_fft_ops  (uint16_t  dev_id, uint16_t queue_id, struct rte_bbdev_fft_op **
       ops, uint16_t num_ops) [inline],  [static]
       Enqueue a burst of FFT operations to a queue  of  the  device.  This  functions  only  enqueues  as  many
       operations  as  currently  possible  and does not block until num_ops entries in the queue are available.
       This function does not provide any error notification to avoid the corresponding overhead.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           ops Pointer array containing operations to be enqueued. Must have at least num_ops entries.
           num_ops The maximum number of operations to enqueue.

       Returns
           The number of operations actually enqueued. (This is the number  of  processed  entries  in  the  ops
           array.)

       Definition at line 687 of file rte_bbdev.h.

   static uint16_t rte_bbdev_enqueue_mldts_ops (uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_mldts_op **
       ops, uint16_t num_ops) [inline],  [static]
       Enqueue  a  burst  of  MLDTS  operations  to  a queue of the device. This functions only enqueues as many
       operations as currently possible and does not block until num_ops entries in  the  queue  are  available.
       This function does not provide any error notification to avoid the corresponding overhead.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           ops Pointer array containing operations to be enqueued Must have at least num_ops entries
           num_ops The maximum number of operations to enqueue.

       Returns
           The  number  of  operations  actually  enqueued  (this  is the number of processed entries in the ops
           array).

       Definition at line 717 of file rte_bbdev.h.

   static uint16_t rte_bbdev_dequeue_enc_ops (uint16_t dev_id, uint16_t  queue_id,  struct  rte_bbdev_enc_op  **
       ops, uint16_t num_ops) [inline],  [static]
       Dequeue  a  burst  of processed encode operations from a queue of the device. This functions returns only
       the current contents of the queue, and does not block until @ num_ops is available.  This  function  does
       not provide any error notification to avoid the corresponding overhead.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           ops  Pointer  array  where operations will be dequeued to. Must have at least num_ops entries, i.e. a
           pointer to a table of void * pointers (ops) that will be filled.
           num_ops The maximum number of operations to dequeue.

       Returns
           The number of operations actually dequeued. (This is the  number  of  entries  copied  into  the  ops
           array.)

       Definition at line 748 of file rte_bbdev.h.

   static  uint16_t  rte_bbdev_dequeue_dec_ops  (uint16_t  dev_id, uint16_t queue_id, struct rte_bbdev_dec_op **
       ops, uint16_t num_ops) [inline],  [static]
       Dequeue a burst of processed decode operations from a queue of the device. This  functions  returns  only
       the  current  contents  of the queue, and does not block until @ num_ops is available. This function does
       not provide any error notification to avoid the corresponding overhead.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           ops Pointer array where operations will be dequeued to. Must have at  least  num_ops  entries  ie.  A
           pointer to a table of void * pointers (ops) that will be filled.
           num_ops The maximum number of operations to dequeue.

       Returns
           The number of operations actually dequeued (this is the number of entries copied into the ops array).

       Definition at line 780 of file rte_bbdev.h.

   static  uint16_t  rte_bbdev_dequeue_ldpc_enc_ops (uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_enc_op
       ** ops, uint16_t num_ops) [inline],  [static]
       Dequeue a burst of processed encode operations from a queue of the device. This  functions  returns  only
       the  current  contents  of the queue, and does not block until @ num_ops is available. This function does
       not provide any error notification to avoid the corresponding overhead.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           ops Pointer array where operations will be dequeued to. Must have at least num_ops entries
           num_ops The maximum number of operations to dequeue.

       Returns
           The number of operations actually dequeued (this is the number of entries copied into the ops array).

       Definition at line 811 of file rte_bbdev.h.

   static uint16_t rte_bbdev_dequeue_ldpc_dec_ops (uint16_t dev_id, uint16_t queue_id,  struct  rte_bbdev_dec_op
       ** ops, uint16_t num_ops) [inline],  [static]
       Dequeue  a  burst  of processed decode operations from a queue of the device. This functions returns only
       the current contents of the queue, and does not block until @ num_ops is available.  This  function  does
       not provide any error notification to avoid the corresponding overhead.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           ops Pointer array where operations will be dequeued to. Must have at least num_ops entries
           num_ops The maximum number of operations to dequeue.

       Returns
           The number of operations actually dequeued (this is the number of entries copied into the ops array).

       Definition at line 841 of file rte_bbdev.h.

   static  uint16_t  rte_bbdev_dequeue_fft_ops  (uint16_t  dev_id, uint16_t queue_id, struct rte_bbdev_fft_op **
       ops, uint16_t num_ops) [inline],  [static]
       Dequeue a burst of FFT operations from a queue of the device. This functions  returns  only  the  current
       contents  of  the  queue, and does not block until @ num_ops is available. This function does not provide
       any error notification to avoid the corresponding overhead.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           ops Pointer array where operations will be dequeued to. Must have at least num_ops entries
           num_ops The maximum number of operations to dequeue.

       Returns
           The number of operations actually dequeued (this is the number of entries copied into the ops array).

       Definition at line 871 of file rte_bbdev.h.

   static uint16_t rte_bbdev_dequeue_mldts_ops (uint16_t dev_id, uint16_t queue_id, struct rte_bbdev_mldts_op **
       ops, uint16_t num_ops) [inline],  [static]
       Dequeue a burst of MLDTS operations from a queue of the device. This functions returns only  the  current
       contents  of the queue, and does not block until num_ops is available. This function does not provide any
       error notification to avoid the corresponding overhead.

       Parameters
           dev_id The identifier of the device.
           queue_id The index of the queue.
           ops Pointer array where operations will be dequeued to. Must have at least num_ops entries
           num_ops The maximum number of operations to dequeue.

       Returns
           The number of operations actually dequeued (this is the number of entries copied into the ops array).

       Definition at line 901 of file rte_bbdev.h.

   int rte_bbdev_callback_register (uint16_t dev_id, enum  rte_bbdev_event_type  event,  rte_bbdev_cb_fn  cb_fn,
       void * cb_arg)
       Register  a  callback function for specific device id. Multiple callbacks can be added and will be called
       in the order they are added when an event is triggered. Callbacks are called in a separate thread created
       by the DPDK EAL.

       Parameters
           dev_id Device id.
           event The event that the callback will be registered for.
           cb_fn User supplied callback function to be called.
           cb_arg Pointer to parameter that will be passed to the callback.

       Returns
           Zero on success, negative value on failure.

   int rte_bbdev_callback_unregister (uint16_t dev_id, enum rte_bbdev_event_type event,  rte_bbdev_cb_fn  cb_fn,
       void * cb_arg)
       Unregister a callback function for specific device id.

       Parameters
           dev_id The device identifier.
           event The event that the callback will be unregistered for.
           cb_fn User supplied callback function to be unregistered.
           cb_arg  Pointer  to  the parameter supplied when registering the callback. (void *)-1 means to remove
           all registered callbacks with the specified function address.

       Returns

           • 0 on success

           • EINVAL if invalid parameter pointer is provided

           • EAGAIN if the provided callback pointer does not exist

   int rte_bbdev_queue_intr_enable (uint16_t dev_id, uint16_t queue_id)
       Enable a one-shot interrupt on the next operation enqueued to a particular queue. The interrupt  will  be
       triggered  when  the operation is ready to be dequeued. To handle the interrupt, an epoll file descriptor
       must be registered using rte_bbdev_queue_intr_ctl(), and then an application thread/lcore  can  wait  for
       the interrupt using rte_epoll_wait().

       Parameters
           dev_id The device identifier.
           queue_id The index of the queue.

       Returns

           • 0 on success

           • negative value on failure - as returned from PMD

   int rte_bbdev_queue_intr_disable (uint16_t dev_id, uint16_t queue_id)
       Disable  a  one-shot  interrupt  on  the  next  operation  enqueued to a particular queue (if it has been
       enabled).

       Parameters
           dev_id The device identifier.
           queue_id The index of the queue.

       Returns

           • 0 on success

           • negative value on failure - as returned from PMD

   int rte_bbdev_queue_intr_ctl (uint16_t dev_id, uint16_t queue_id, int epfd, int op, void * data)
       Control interface for per-queue interrupts.

       Parameters
           dev_id The device identifier.
           queue_id The index of the queue.
           epfd Epoll file descriptor that will be associated with the interrupt source. If  the  special  value
           RTE_EPOLL_PER_THREAD  is  provided,  a  per  thread  epoll file descriptor created by the EAL is used
           (RTE_EPOLL_PER_THREAD can also be used when calling rte_epoll_wait()).
           op The operation be performed for the vector.RTE_INTR_EVENT_ADD or RTE_INTR_EVENT_DEL.
           data User context, that will be returned in the epdata.data field of  the  rte_epoll_event  structure
           filled in by rte_epoll_wait().

       Returns

           • 0 on success

           • ENOTSUP if interrupts are not supported by the identified device

           • negative value on failure - as returned from PMD

   const char * rte_bbdev_device_status_str (enum rte_bbdev_device_status status)
       Convert device status from enum to string.

       Parameters
           status Device status as enum.

       Returns
           Device status as string or NULL if invalid.

   const char * rte_bbdev_enqueue_status_str (enum rte_bbdev_enqueue_status status)
       Convert queue status from enum to string.

       Parameters
           status Queue status as enum.

       Returns
           Queue status as string or NULL if op_type is invalid.

   __rte_experimental int rte_bbdev_queue_ops_dump (uint16_t dev_id, uint16_t queue_index, FILE * file)
       Dump operations info from device to a file. This API is used for debugging provided input operations, not
       a dataplane API.

       Parameters
           dev_id The device identifier.
           queue_index Index of queue.
           file A pointer to a file for output.

       Returns

           • 0 on success

           • ENOTSUP if interrupts are not supported by the identified device

           • negative value on failure - as returned from PMD

   __rte_experimental  char * rte_bbdev_ops_param_string (void * op, enum rte_bbdev_op_type op_type, char * str,
       uint32_t len)
       String of parameters related to the parameters of an operation of a given type.

       Parameters
           op Pointer to an operation.
           op_type Operation type enum.
           str String being describing the operations.
           len Size of the string buffer.

       Returns
           String describing the provided operation.

Author

       Generated automatically by Doxygen for DPDK from the source code.

DPDK                                             Version 24.11.2                                  rte_bbdev.h(3)