8259c3ef4e
These header includes have been flagged by the iwyu_tool and removed. Signed-off-by: Sean Morrissey <sean.morrissey@intel.com> Acked-by: Hemant Agrawal <hemant.agrawal@nxp.com>
632 lines
18 KiB
C
632 lines
18 KiB
C
/* SPDX-License-Identifier: BSD-3-Clause
|
|
* Copyright 2017 NXP
|
|
*/
|
|
|
|
#ifndef _RTE_RAWDEV_H_
|
|
#define _RTE_RAWDEV_H_
|
|
|
|
/**
|
|
* @file rte_rawdev.h
|
|
*
|
|
* Generic device abstraction APIs.
|
|
*
|
|
* This API allow applications to configure and use generic devices having
|
|
* no specific type already available in DPDK.
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include <rte_common.h>
|
|
#include <rte_memory.h>
|
|
|
|
/* Rawdevice object - essentially a void to be typecast by implementation */
|
|
typedef void *rte_rawdev_obj_t;
|
|
|
|
/**
|
|
* Get the total number of raw devices that have been successfully
|
|
* initialised.
|
|
*
|
|
* @return
|
|
* The total number of usable raw devices.
|
|
*/
|
|
uint8_t
|
|
rte_rawdev_count(void);
|
|
|
|
/**
|
|
* Get the device identifier for the named raw device.
|
|
*
|
|
* @param name
|
|
* Raw device name to select the raw device identifier.
|
|
*
|
|
* @return
|
|
* Returns raw device identifier on success.
|
|
* - <0: Failure to find named raw device.
|
|
*/
|
|
uint16_t
|
|
rte_rawdev_get_dev_id(const char *name);
|
|
|
|
/**
|
|
* Return the NUMA socket to which a device is connected.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device.
|
|
* @return
|
|
* The NUMA socket id to which the device is connected or
|
|
* a default of zero if the socket could not be determined.
|
|
* -(-EINVAL) dev_id value is out of range.
|
|
*/
|
|
int
|
|
rte_rawdev_socket_id(uint16_t dev_id);
|
|
|
|
/**
|
|
* Raw device information forward declaration
|
|
*/
|
|
struct rte_rawdev_info;
|
|
|
|
/**
|
|
* Retrieve the contextual information of a raw device.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device.
|
|
*
|
|
* @param[out] dev_info
|
|
* A pointer to a structure of type *rte_rawdev_info* to be filled with the
|
|
* contextual information of the device. The dev_info->dev_private field
|
|
* should point to an appropriate buffer space for holding the device-
|
|
* specific info for that hardware.
|
|
* If the dev_private field is set to NULL, then the device-specific info
|
|
* function will not be called and only basic information about the device
|
|
* will be returned. This can be used to safely query the type of a rawdev
|
|
* instance without needing to know the size of the private data to return.
|
|
*
|
|
* @param dev_private_size
|
|
* The length of the memory space pointed to by dev_private in dev_info.
|
|
* This should be set to the size of the expected private structure to be
|
|
* returned, and may be checked by drivers to ensure the expected struct
|
|
* type is provided.
|
|
*
|
|
* @return
|
|
* - 0: Success, driver updates the contextual information of the raw device
|
|
* - <0: Error code returned by the driver info get function.
|
|
*
|
|
*/
|
|
int
|
|
rte_rawdev_info_get(uint16_t dev_id, struct rte_rawdev_info *dev_info,
|
|
size_t dev_private_size);
|
|
|
|
/**
|
|
* Configure a raw device.
|
|
*
|
|
* This function must be invoked first before any other function in the
|
|
* API. This function can also be re-invoked when a device is in the
|
|
* stopped state.
|
|
*
|
|
* The caller may use rte_rawdev_info_get() to get the capability of each
|
|
* resources available for this raw device.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device to configure.
|
|
* @param dev_conf
|
|
* The raw device configuration structure encapsulated into rte_rawdev_info
|
|
* object.
|
|
* It is assumed that the opaque object has enough information which the
|
|
* driver/implementation can use to configure the device. It is also assumed
|
|
* that once the configuration is done, a `queue_id` type field can be used
|
|
* to refer to some arbitrary internal representation of a queue.
|
|
* @param dev_private_size
|
|
* The length of the memory space pointed to by dev_private in dev_info.
|
|
* This should be set to the size of the expected private structure to be
|
|
* used by the driver, and may be checked by drivers to ensure the expected
|
|
* struct type is provided.
|
|
*
|
|
* @return
|
|
* - 0: Success, device configured.
|
|
* - <0: Error code returned by the driver configuration function.
|
|
*/
|
|
int
|
|
rte_rawdev_configure(uint16_t dev_id, struct rte_rawdev_info *dev_conf,
|
|
size_t dev_private_size);
|
|
|
|
|
|
/**
|
|
* Retrieve the current configuration information of a raw queue designated
|
|
* by its *queue_id* from the raw driver for a raw device.
|
|
*
|
|
* This function intended to be used in conjunction with rte_raw_queue_setup()
|
|
* where caller needs to set up the queue by overriding few default values.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device.
|
|
* @param queue_id
|
|
* The index of the raw queue to get the configuration information.
|
|
* The value must be in the range [0, nb_raw_queues - 1]
|
|
* previously supplied to rte_rawdev_configure().
|
|
* @param[out] queue_conf
|
|
* The pointer to the default raw queue configuration data.
|
|
* @param queue_conf_size
|
|
* The size of the structure pointed to by queue_conf
|
|
* @return
|
|
* - 0: Success, driver updates the default raw queue configuration data.
|
|
* - <0: Error code returned by the driver info get function.
|
|
*
|
|
* @see rte_raw_queue_setup()
|
|
*
|
|
*/
|
|
int
|
|
rte_rawdev_queue_conf_get(uint16_t dev_id,
|
|
uint16_t queue_id,
|
|
rte_rawdev_obj_t queue_conf,
|
|
size_t queue_conf_size);
|
|
|
|
/**
|
|
* Allocate and set up a raw queue for a raw device.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device.
|
|
* @param queue_id
|
|
* The index of the raw queue to setup. The value must be in the range
|
|
* [0, nb_raw_queues - 1] previously supplied to rte_rawdev_configure().
|
|
* @param queue_conf
|
|
* The pointer to the configuration data to be used for the raw queue.
|
|
* NULL value is allowed, in which case default configuration used.
|
|
* @param queue_conf_size
|
|
* The size of the structure pointed to by queue_conf
|
|
*
|
|
* @see rte_rawdev_queue_conf_get()
|
|
*
|
|
* @return
|
|
* - 0: Success, raw queue correctly set up.
|
|
* - <0: raw queue configuration failed
|
|
*/
|
|
int
|
|
rte_rawdev_queue_setup(uint16_t dev_id,
|
|
uint16_t queue_id,
|
|
rte_rawdev_obj_t queue_conf,
|
|
size_t queue_conf_size);
|
|
|
|
/**
|
|
* Release and deallocate a raw queue from a raw device.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device.
|
|
* @param queue_id
|
|
* The index of the raw queue to release. The value must be in the range
|
|
* [0, nb_raw_queues - 1] previously supplied to rte_rawdev_configure().
|
|
*
|
|
* @see rte_rawdev_queue_conf_get()
|
|
*
|
|
* @return
|
|
* - 0: Success, raw queue released.
|
|
* - <0: raw queue configuration failed
|
|
*/
|
|
int
|
|
rte_rawdev_queue_release(uint16_t dev_id, uint16_t queue_id);
|
|
|
|
/**
|
|
* Get the number of raw queues on a specific raw device
|
|
*
|
|
* @param dev_id
|
|
* Raw device identifier.
|
|
* @return
|
|
* - The number of configured raw queues
|
|
*/
|
|
uint16_t
|
|
rte_rawdev_queue_count(uint16_t dev_id);
|
|
|
|
/**
|
|
* Start a raw device.
|
|
*
|
|
* The device start step is the last one and consists of setting the raw
|
|
* queues to start accepting the raws and schedules to raw ports.
|
|
*
|
|
* On success, all basic functions exported by the API (raw enqueue,
|
|
* raw dequeue and so on) can be invoked.
|
|
*
|
|
* @param dev_id
|
|
* Raw device identifier
|
|
* @return
|
|
* - 0: Success, device started.
|
|
* < 0: Failure
|
|
*/
|
|
int
|
|
rte_rawdev_start(uint16_t dev_id);
|
|
|
|
/**
|
|
* Stop a raw device. The device can be restarted with a call to
|
|
* rte_rawdev_start()
|
|
*
|
|
* @param dev_id
|
|
* Raw device identifier.
|
|
*/
|
|
void
|
|
rte_rawdev_stop(uint16_t dev_id);
|
|
|
|
/**
|
|
* Close a raw device. The device cannot be restarted after this call.
|
|
*
|
|
* @param dev_id
|
|
* Raw device identifier
|
|
*
|
|
* @return
|
|
* - 0 on successfully closing device
|
|
* - <0 on failure to close device
|
|
* - (-EAGAIN) if device is busy
|
|
*/
|
|
int
|
|
rte_rawdev_close(uint16_t dev_id);
|
|
|
|
/**
|
|
* Reset a raw device.
|
|
* This is different from cycle of rte_rawdev_start->rte_rawdev_stop in the
|
|
* sense similar to hard or soft reset.
|
|
*
|
|
* @param dev_id
|
|
* Raw device identifiers
|
|
* @return
|
|
* 0 for successful reset,
|
|
* !0 for failure in resetting
|
|
*/
|
|
int
|
|
rte_rawdev_reset(uint16_t dev_id);
|
|
|
|
#define RTE_RAWDEV_NAME_MAX_LEN (64)
|
|
/**< @internal Max length of name of raw PMD */
|
|
|
|
|
|
|
|
/** @internal
|
|
* The data structure associated with each raw device.
|
|
* It is a placeholder for PMD specific data, encapsulating only information
|
|
* related to framework.
|
|
*/
|
|
struct rte_rawdev {
|
|
/**< Socket ID where memory is allocated */
|
|
int socket_id;
|
|
/**< Device ID for this instance */
|
|
uint16_t dev_id;
|
|
/**< Functions exported by PMD */
|
|
const struct rte_rawdev_ops *dev_ops;
|
|
/**< Device info. supplied during device initialization */
|
|
struct rte_device *device;
|
|
/**< Driver info. supplied by probing */
|
|
const char *driver_name;
|
|
|
|
RTE_STD_C11
|
|
/**< Flag indicating the device is attached */
|
|
uint8_t attached : 1;
|
|
/**< Device state: STARTED(1)/STOPPED(0) */
|
|
uint8_t started : 1;
|
|
|
|
/**< PMD-specific private data */
|
|
rte_rawdev_obj_t dev_private;
|
|
/**< Device name */
|
|
char name[RTE_RAWDEV_NAME_MAX_LEN];
|
|
} __rte_cache_aligned;
|
|
|
|
/** @internal The pool of rte_rawdev structures. */
|
|
extern struct rte_rawdev *rte_rawdevs;
|
|
|
|
|
|
struct rte_rawdev_info {
|
|
/**< Name of driver handling this device */
|
|
const char *driver_name;
|
|
/**< Device encapsulation */
|
|
struct rte_device *device;
|
|
/**< Socket ID where memory is allocated */
|
|
int socket_id;
|
|
/**< PMD-specific private data */
|
|
rte_rawdev_obj_t dev_private;
|
|
};
|
|
|
|
struct rte_rawdev_buf {
|
|
/**< Opaque buffer reference */
|
|
void *buf_addr;
|
|
};
|
|
|
|
/**
|
|
* Dump internal information about *dev_id* to the FILE* provided in *f*.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device.
|
|
*
|
|
* @param f
|
|
* A pointer to a file for output
|
|
*
|
|
* @return
|
|
* - 0: on success
|
|
* - <0: on failure.
|
|
*/
|
|
int
|
|
rte_rawdev_dump(uint16_t dev_id, FILE *f);
|
|
|
|
/**
|
|
* Get an attribute value from implementation.
|
|
* Attribute is an opaque handle agreed upon between application and PMD.
|
|
*
|
|
* Implementations are expected to maintain an array of attribute-value pairs
|
|
* based on application calls. Memory management for this structure is
|
|
* shared responsibility of implementation and application.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device to configure.
|
|
* @param attr_name
|
|
* Opaque object representing an attribute in implementation.
|
|
* @param attr_value [out]
|
|
* Opaque response to the attribute value. In case of error, this remains
|
|
* untouched. This is double pointer of void type.
|
|
* @return
|
|
* 0 for success
|
|
* !0 Error; attr_value remains untouched in case of error.
|
|
*/
|
|
int
|
|
rte_rawdev_get_attr(uint16_t dev_id,
|
|
const char *attr_name,
|
|
uint64_t *attr_value);
|
|
|
|
/**
|
|
* Set an attribute value.
|
|
* Attribute is an opaque handle agreed upon between application and PMD.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device to configure.
|
|
* @param attr_name
|
|
* Opaque object representing an attribute in implementation.
|
|
* @param attr_value
|
|
* Value of the attribute represented by attr_name
|
|
* @return
|
|
* 0 for success
|
|
* !0 Error
|
|
*/
|
|
int
|
|
rte_rawdev_set_attr(uint16_t dev_id,
|
|
const char *attr_name,
|
|
const uint64_t attr_value);
|
|
|
|
/**
|
|
* Enqueue a stream of buffers to the device.
|
|
*
|
|
* Rather than specifying a queue, this API passes along an opaque object
|
|
* to the driver implementation. That object can be a queue or any other
|
|
* contextual information necessary for the device to enqueue buffers.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device to configure.
|
|
* @param buffers
|
|
* Collection of buffers for enqueuing
|
|
* @param count
|
|
* Count of buffers to enqueue
|
|
* @param context
|
|
* Opaque context information.
|
|
* @return
|
|
* >=0 for buffers enqueued
|
|
* !0 for failure.
|
|
* Whether partial enqueue is failure or success is defined between app
|
|
* and driver implementation.
|
|
*/
|
|
int
|
|
rte_rawdev_enqueue_buffers(uint16_t dev_id,
|
|
struct rte_rawdev_buf **buffers,
|
|
unsigned int count,
|
|
rte_rawdev_obj_t context);
|
|
|
|
/**
|
|
* Dequeue a stream of buffers from the device.
|
|
*
|
|
* Rather than specifying a queue, this API passes along an opaque object
|
|
* to the driver implementation. That object can be a queue or any other
|
|
* contextual information necessary for the device to dequeue buffers.
|
|
*
|
|
* Application should have allocated enough space to store `count` response
|
|
* buffers.
|
|
* Releasing buffers dequeued is responsibility of the application.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device to configure.
|
|
* @param buffers
|
|
* Collection of buffers dequeued
|
|
* @param count
|
|
* Max buffers expected to be dequeued
|
|
* @param context
|
|
* Opaque context information.
|
|
* @return
|
|
* >=0 for buffers dequeued
|
|
* !0 for failure.
|
|
* Whether partial enqueue is failure or success is defined between app
|
|
* and driver implementation.
|
|
*/
|
|
int
|
|
rte_rawdev_dequeue_buffers(uint16_t dev_id,
|
|
struct rte_rawdev_buf **buffers,
|
|
unsigned int count,
|
|
rte_rawdev_obj_t context);
|
|
|
|
/** Maximum name length for extended statistics counters */
|
|
#define RTE_RAW_DEV_XSTATS_NAME_SIZE 64
|
|
|
|
/**
|
|
* A name-key lookup element for extended statistics.
|
|
*
|
|
* This structure is used to map between names and ID numbers
|
|
* for extended ethdev statistics.
|
|
*/
|
|
struct rte_rawdev_xstats_name {
|
|
char name[RTE_RAW_DEV_XSTATS_NAME_SIZE];
|
|
};
|
|
|
|
/**
|
|
* Retrieve names of extended statistics of a raw device.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the raw device.
|
|
* @param[out] xstats_names
|
|
* Block of memory to insert names into. Must be at least size in capacity.
|
|
* If set to NULL, function returns required capacity.
|
|
* @param size
|
|
* Capacity of xstats_names (number of names).
|
|
* @return
|
|
* - positive value lower or equal to size: success. The return value
|
|
* is the number of entries filled in the stats table.
|
|
* - positive value higher than size: error, the given statistics table
|
|
* is too small. The return value corresponds to the size that should
|
|
* be given to succeed. The entries in the table are not valid and
|
|
* shall not be used by the caller.
|
|
* - negative value on error:
|
|
* -ENODEV for invalid *dev_id*
|
|
* -ENOTSUP if the device doesn't support this function.
|
|
*/
|
|
int
|
|
rte_rawdev_xstats_names_get(uint16_t dev_id,
|
|
struct rte_rawdev_xstats_name *xstats_names,
|
|
unsigned int size);
|
|
|
|
/**
|
|
* Retrieve extended statistics of a raw device.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device.
|
|
* @param ids
|
|
* The id numbers of the stats to get. The ids can be got from the stat
|
|
* position in the stat list from rte_rawdev_get_xstats_names(), or
|
|
* by using rte_rawdev_get_xstats_by_name()
|
|
* @param[out] values
|
|
* The values for each stats request by ID.
|
|
* @param n
|
|
* The number of stats requested
|
|
* @return
|
|
* - positive value: number of stat entries filled into the values array
|
|
* - negative value on error:
|
|
* -ENODEV for invalid *dev_id*
|
|
* -ENOTSUP if the device doesn't support this function.
|
|
*/
|
|
int
|
|
rte_rawdev_xstats_get(uint16_t dev_id,
|
|
const unsigned int ids[],
|
|
uint64_t values[],
|
|
unsigned int n);
|
|
|
|
/**
|
|
* Retrieve the value of a single stat by requesting it by name.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device
|
|
* @param name
|
|
* The stat name to retrieve
|
|
* @param[out] id
|
|
* If non-NULL, the numerical id of the stat will be returned, so that further
|
|
* requests for the stat can be got using rte_rawdev_xstats_get, which will
|
|
* be faster as it doesn't need to scan a list of names for the stat.
|
|
* If the stat cannot be found, the id returned will be (unsigned)-1.
|
|
* @return
|
|
* - positive value or zero: the stat value
|
|
* - negative value: -EINVAL if stat not found, -ENOTSUP if not supported.
|
|
*/
|
|
uint64_t
|
|
rte_rawdev_xstats_by_name_get(uint16_t dev_id,
|
|
const char *name,
|
|
unsigned int *id);
|
|
|
|
/**
|
|
* Reset the values of the xstats of the selected component in the device.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device
|
|
* @param ids
|
|
* Selects specific statistics to be reset. When NULL, all statistics
|
|
* will be reset. If non-NULL, must point to array of at least
|
|
* *nb_ids* size.
|
|
* @param nb_ids
|
|
* The number of ids available from the *ids* array. Ignored when ids is NULL.
|
|
* @return
|
|
* - zero: successfully reset the statistics to zero
|
|
* - negative value: -EINVAL invalid parameters, -ENOTSUP if not supported.
|
|
*/
|
|
int
|
|
rte_rawdev_xstats_reset(uint16_t dev_id,
|
|
const uint32_t ids[],
|
|
uint32_t nb_ids);
|
|
|
|
/**
|
|
* Get Firmware status of the device..
|
|
* Returns a memory allocated by driver/implementation containing status
|
|
* information block. It is responsibility of caller to release the buffer.
|
|
*
|
|
* @param dev_id
|
|
* Raw device identifier
|
|
* @param status_info
|
|
* Pointer to status information area. Caller is responsible for releasing
|
|
* the memory associated.
|
|
* @return
|
|
* 0 for success,
|
|
* !0 for failure, `status_info` argument state is undefined
|
|
*/
|
|
int
|
|
rte_rawdev_firmware_status_get(uint16_t dev_id,
|
|
rte_rawdev_obj_t status_info);
|
|
|
|
/**
|
|
* Get Firmware version of the device.
|
|
* Returns a memory allocated by driver/implementation containing version
|
|
* information block. It is responsibility of caller to release the buffer.
|
|
*
|
|
* @param dev_id
|
|
* Raw device identifier
|
|
* @param version_info
|
|
* Pointer to version information area. Caller is responsible for releasing
|
|
* the memory associated.
|
|
* @return
|
|
* 0 for success,
|
|
* !0 for failure, `version_info` argument state is undefined
|
|
*/
|
|
int
|
|
rte_rawdev_firmware_version_get(uint16_t dev_id,
|
|
rte_rawdev_obj_t version_info);
|
|
|
|
/**
|
|
* Load firmware on the device.
|
|
* TODO: In future, methods like directly flashing from file too can be
|
|
* supported.
|
|
*
|
|
* @param dev_id
|
|
* Raw device identifier
|
|
* @param firmware_image
|
|
* Pointer to buffer containing image binary data
|
|
* @return
|
|
* 0 for successful load
|
|
* !0 for failure to load the provided image, or image incorrect.
|
|
*/
|
|
int
|
|
rte_rawdev_firmware_load(uint16_t dev_id, rte_rawdev_obj_t firmware_image);
|
|
|
|
/**
|
|
* Unload firmware from the device.
|
|
*
|
|
* @param dev_id
|
|
* Raw device identifiers
|
|
* @return
|
|
* 0 for successful Unload
|
|
* !0 for failure in unloading
|
|
*/
|
|
int
|
|
rte_rawdev_firmware_unload(uint16_t dev_id);
|
|
|
|
/**
|
|
* Trigger the rawdev self test.
|
|
*
|
|
* @param dev_id
|
|
* The identifier of the device
|
|
* @return
|
|
* - 0: Selftest successful
|
|
* - -ENOTSUP if the device doesn't support selftest
|
|
* - other values < 0 on failure.
|
|
*/
|
|
int
|
|
rte_rawdev_selftest(uint16_t dev_id);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* _RTE_RAWDEV_H_ */
|