1 /* SPDX-License-Identifier: BSD-3-Clause
11 * Generic device abstraction APIs.
13 * This API allow applications to configure and use generic devices having
14 * no specific type already available in DPDK.
21 #include <rte_common.h>
22 #include <rte_memory.h>
23 #include <rte_errno.h>
25 /* Rawdevice object - essentially a void to be typecast by implementation */
26 typedef void *rte_rawdev_obj_t;
29 * Get the total number of raw devices that have been successfully
33 * The total number of usable raw devices.
36 rte_rawdev_count(void);
39 * Get the device identifier for the named raw device.
42 * Raw device name to select the raw device identifier.
45 * Returns raw device identifier on success.
46 * - <0: Failure to find named raw device.
49 rte_rawdev_get_dev_id(const char *name);
52 * Return the NUMA socket to which a device is connected.
55 * The identifier of the device.
57 * The NUMA socket id to which the device is connected or
58 * a default of zero if the socket could not be determined.
59 * -(-EINVAL) dev_id value is out of range.
62 rte_rawdev_socket_id(uint16_t dev_id);
65 * Raw device information forward declaration
67 struct rte_rawdev_info;
70 * Retrieve the contextual information of a raw device.
73 * The identifier of the device.
75 * @param[out] dev_info
76 * A pointer to a structure of type *rte_rawdev_info* to be filled with the
77 * contextual information of the device. The dev_info->dev_private field
78 * should point to an appropriate buffer space for holding the device-
79 * specific info for that hardware.
80 * If the dev_private field is set to NULL, then the device-specific info
81 * function will not be called and only basic information about the device
82 * will be returned. This can be used to safely query the type of a rawdev
83 * instance without needing to know the size of the private data to return.
85 * @param dev_private_size
86 * The length of the memory space pointed to by dev_private in dev_info.
87 * This should be set to the size of the expected private structure to be
88 * returned, and may be checked by drivers to ensure the expected struct
92 * - 0: Success, driver updates the contextual information of the raw device
93 * - <0: Error code returned by the driver info get function.
97 rte_rawdev_info_get(uint16_t dev_id, struct rte_rawdev_info *dev_info,
98 size_t dev_private_size);
101 * Configure a raw device.
103 * This function must be invoked first before any other function in the
104 * API. This function can also be re-invoked when a device is in the
107 * The caller may use rte_rawdev_info_get() to get the capability of each
108 * resources available for this raw device.
111 * The identifier of the device to configure.
113 * The raw device configuration structure encapsulated into rte_rawdev_info
115 * It is assumed that the opaque object has enough information which the
116 * driver/implementation can use to configure the device. It is also assumed
117 * that once the configuration is done, a `queue_id` type field can be used
118 * to refer to some arbitrary internal representation of a queue.
119 * @param dev_private_size
120 * The length of the memory space pointed to by dev_private in dev_info.
121 * This should be set to the size of the expected private structure to be
122 * used by the driver, and may be checked by drivers to ensure the expected
123 * struct type is provided.
126 * - 0: Success, device configured.
127 * - <0: Error code returned by the driver configuration function.
130 rte_rawdev_configure(uint16_t dev_id, struct rte_rawdev_info *dev_conf,
131 size_t dev_private_size);
135 * Retrieve the current configuration information of a raw queue designated
136 * by its *queue_id* from the raw driver for a raw device.
138 * This function intended to be used in conjunction with rte_raw_queue_setup()
139 * where caller needs to set up the queue by overriding few default values.
142 * The identifier of the device.
144 * The index of the raw queue to get the configuration information.
145 * The value must be in the range [0, nb_raw_queues - 1]
146 * previously supplied to rte_rawdev_configure().
147 * @param[out] queue_conf
148 * The pointer to the default raw queue configuration data.
150 * - 0: Success, driver updates the default raw queue configuration data.
151 * - <0: Error code returned by the driver info get function.
153 * @see rte_raw_queue_setup()
157 rte_rawdev_queue_conf_get(uint16_t dev_id,
159 rte_rawdev_obj_t queue_conf);
162 * Allocate and set up a raw queue for a raw device.
165 * The identifier of the device.
167 * The index of the raw queue to setup. The value must be in the range
168 * [0, nb_raw_queues - 1] previously supplied to rte_rawdev_configure().
170 * The pointer to the configuration data to be used for the raw queue.
171 * NULL value is allowed, in which case default configuration used.
173 * @see rte_rawdev_queue_conf_get()
176 * - 0: Success, raw queue correctly set up.
177 * - <0: raw queue configuration failed
180 rte_rawdev_queue_setup(uint16_t dev_id,
182 rte_rawdev_obj_t queue_conf);
185 * Release and deallocate a raw queue from a raw device.
188 * The identifier of the device.
190 * The index of the raw queue to release. The value must be in the range
191 * [0, nb_raw_queues - 1] previously supplied to rte_rawdev_configure().
193 * @see rte_rawdev_queue_conf_get()
196 * - 0: Success, raw queue released.
197 * - <0: raw queue configuration failed
200 rte_rawdev_queue_release(uint16_t dev_id, uint16_t queue_id);
203 * Get the number of raw queues on a specific raw device
206 * Raw device identifier.
208 * - The number of configured raw queues
211 rte_rawdev_queue_count(uint16_t dev_id);
214 * Start a raw device.
216 * The device start step is the last one and consists of setting the raw
217 * queues to start accepting the raws and schedules to raw ports.
219 * On success, all basic functions exported by the API (raw enqueue,
220 * raw dequeue and so on) can be invoked.
223 * Raw device identifier
225 * - 0: Success, device started.
229 rte_rawdev_start(uint16_t dev_id);
232 * Stop a raw device. The device can be restarted with a call to
236 * Raw device identifier.
239 rte_rawdev_stop(uint16_t dev_id);
242 * Close a raw device. The device cannot be restarted after this call.
245 * Raw device identifier
248 * - 0 on successfully closing device
249 * - <0 on failure to close device
250 * - (-EAGAIN) if device is busy
253 rte_rawdev_close(uint16_t dev_id);
256 * Reset a raw device.
257 * This is different from cycle of rte_rawdev_start->rte_rawdev_stop in the
258 * sense similar to hard or soft reset.
261 * Raw device identifiers
263 * 0 for successful reset,
264 * !0 for failure in resetting
267 rte_rawdev_reset(uint16_t dev_id);
269 #define RTE_RAWDEV_NAME_MAX_LEN (64)
270 /**< @internal Max length of name of raw PMD */
275 * The data structure associated with each raw device.
276 * It is a placeholder for PMD specific data, encapsulating only information
277 * related to framework.
280 /**< Socket ID where memory is allocated */
282 /**< Device ID for this instance */
284 /**< Functions exported by PMD */
285 const struct rte_rawdev_ops *dev_ops;
286 /**< Device info. supplied during device initialization */
287 struct rte_device *device;
288 /**< Driver info. supplied by probing */
289 const char *driver_name;
292 /**< Flag indicating the device is attached */
293 uint8_t attached : 1;
294 /**< Device state: STARTED(1)/STOPPED(0) */
297 /**< PMD-specific private data */
298 rte_rawdev_obj_t dev_private;
300 char name[RTE_RAWDEV_NAME_MAX_LEN];
301 } __rte_cache_aligned;
303 /** @internal The pool of rte_rawdev structures. */
304 extern struct rte_rawdev *rte_rawdevs;
307 struct rte_rawdev_info {
308 /**< Name of driver handling this device */
309 const char *driver_name;
310 /**< Device encapsulation */
311 struct rte_device *device;
312 /**< Socket ID where memory is allocated */
314 /**< PMD-specific private data */
315 rte_rawdev_obj_t dev_private;
318 struct rte_rawdev_buf {
319 /**< Opaque buffer reference */
324 * Dump internal information about *dev_id* to the FILE* provided in *f*.
327 * The identifier of the device.
330 * A pointer to a file for output
337 rte_rawdev_dump(uint16_t dev_id, FILE *f);
340 * Get an attribute value from implementation.
341 * Attribute is an opaque handle agreed upon between application and PMD.
343 * Implementations are expected to maintain an array of attribute-value pairs
344 * based on application calls. Memory management for this structure is
345 * shared responsibility of implementation and application.
348 * The identifier of the device to configure.
350 * Opaque object representing an attribute in implementation.
351 * @param attr_value [out]
352 * Opaque response to the attribute value. In case of error, this remains
353 * untouched. This is double pointer of void type.
356 * !0 Error; attr_value remains untouched in case of error.
359 rte_rawdev_get_attr(uint16_t dev_id,
360 const char *attr_name,
361 uint64_t *attr_value);
364 * Set an attribute value.
365 * Attribute is an opaque handle agreed upon between application and PMD.
368 * The identifier of the device to configure.
370 * Opaque object representing an attribute in implementation.
372 * Value of the attribute represented by attr_name
378 rte_rawdev_set_attr(uint16_t dev_id,
379 const char *attr_name,
380 const uint64_t attr_value);
383 * Enqueue a stream of buffers to the device.
385 * Rather than specifying a queue, this API passes along an opaque object
386 * to the driver implementation. That object can be a queue or any other
387 * contextual information necessary for the device to enqueue buffers.
390 * The identifier of the device to configure.
392 * Collection of buffers for enqueuing
394 * Count of buffers to enqueue
396 * Opaque context information.
398 * >=0 for buffers enqueued
400 * Whether partial enqueue is failure or success is defined between app
401 * and driver implementation.
404 rte_rawdev_enqueue_buffers(uint16_t dev_id,
405 struct rte_rawdev_buf **buffers,
407 rte_rawdev_obj_t context);
410 * Dequeue a stream of buffers from the device.
412 * Rather than specifying a queue, this API passes along an opaque object
413 * to the driver implementation. That object can be a queue or any other
414 * contextual information necessary for the device to dequeue buffers.
416 * Application should have allocated enough space to store `count` response
418 * Releasing buffers dequeued is responsibility of the application.
421 * The identifier of the device to configure.
423 * Collection of buffers dequeued
425 * Max buffers expected to be dequeued
427 * Opaque context information.
429 * >=0 for buffers dequeued
431 * Whether partial enqueue is failure or success is defined between app
432 * and driver implementation.
435 rte_rawdev_dequeue_buffers(uint16_t dev_id,
436 struct rte_rawdev_buf **buffers,
438 rte_rawdev_obj_t context);
440 /** Maximum name length for extended statistics counters */
441 #define RTE_RAW_DEV_XSTATS_NAME_SIZE 64
444 * A name-key lookup element for extended statistics.
446 * This structure is used to map between names and ID numbers
447 * for extended ethdev statistics.
449 struct rte_rawdev_xstats_name {
450 char name[RTE_RAW_DEV_XSTATS_NAME_SIZE];
454 * Retrieve names of extended statistics of a raw device.
457 * The identifier of the raw device.
458 * @param[out] xstats_names
459 * Block of memory to insert names into. Must be at least size in capacity.
460 * If set to NULL, function returns required capacity.
462 * Capacity of xstats_names (number of names).
464 * - positive value lower or equal to size: success. The return value
465 * is the number of entries filled in the stats table.
466 * - positive value higher than size: error, the given statistics table
467 * is too small. The return value corresponds to the size that should
468 * be given to succeed. The entries in the table are not valid and
469 * shall not be used by the caller.
470 * - negative value on error:
471 * -ENODEV for invalid *dev_id*
472 * -ENOTSUP if the device doesn't support this function.
475 rte_rawdev_xstats_names_get(uint16_t dev_id,
476 struct rte_rawdev_xstats_name *xstats_names,
480 * Retrieve extended statistics of a raw device.
483 * The identifier of the device.
485 * The id numbers of the stats to get. The ids can be got from the stat
486 * position in the stat list from rte_rawdev_get_xstats_names(), or
487 * by using rte_rawdev_get_xstats_by_name()
489 * The values for each stats request by ID.
491 * The number of stats requested
493 * - positive value: number of stat entries filled into the values array
494 * - negative value on error:
495 * -ENODEV for invalid *dev_id*
496 * -ENOTSUP if the device doesn't support this function.
499 rte_rawdev_xstats_get(uint16_t dev_id,
500 const unsigned int ids[],
505 * Retrieve the value of a single stat by requesting it by name.
508 * The identifier of the device
510 * The stat name to retrieve
512 * If non-NULL, the numerical id of the stat will be returned, so that further
513 * requests for the stat can be got using rte_rawdev_xstats_get, which will
514 * be faster as it doesn't need to scan a list of names for the stat.
515 * If the stat cannot be found, the id returned will be (unsigned)-1.
517 * - positive value or zero: the stat value
518 * - negative value: -EINVAL if stat not found, -ENOTSUP if not supported.
521 rte_rawdev_xstats_by_name_get(uint16_t dev_id,
526 * Reset the values of the xstats of the selected component in the device.
529 * The identifier of the device
531 * Selects specific statistics to be reset. When NULL, all statistics
532 * will be reset. If non-NULL, must point to array of at least
535 * The number of ids available from the *ids* array. Ignored when ids is NULL.
537 * - zero: successfully reset the statistics to zero
538 * - negative value: -EINVAL invalid parameters, -ENOTSUP if not supported.
541 rte_rawdev_xstats_reset(uint16_t dev_id,
542 const uint32_t ids[],
546 * Get Firmware status of the device..
547 * Returns a memory allocated by driver/implementation containing status
548 * information block. It is responsibility of caller to release the buffer.
551 * Raw device identifier
553 * Pointer to status information area. Caller is responsible for releasing
554 * the memory associated.
557 * !0 for failure, `status_info` argument state is undefined
560 rte_rawdev_firmware_status_get(uint16_t dev_id,
561 rte_rawdev_obj_t status_info);
564 * Get Firmware version of the device.
565 * Returns a memory allocated by driver/implementation containing version
566 * information block. It is responsibility of caller to release the buffer.
569 * Raw device identifier
570 * @param version_info
571 * Pointer to version information area. Caller is responsible for releasing
572 * the memory associated.
575 * !0 for failure, `version_info` argument state is undefined
578 rte_rawdev_firmware_version_get(uint16_t dev_id,
579 rte_rawdev_obj_t version_info);
582 * Load firmware on the device.
583 * TODO: In future, methods like directly flashing from file too can be
587 * Raw device identifier
588 * @param firmware_image
589 * Pointer to buffer containing image binary data
591 * 0 for successful load
592 * !0 for failure to load the provided image, or image incorrect.
595 rte_rawdev_firmware_load(uint16_t dev_id, rte_rawdev_obj_t firmware_image);
598 * Unload firmware from the device.
601 * Raw device identifiers
603 * 0 for successful Unload
604 * !0 for failure in unloading
607 rte_rawdev_firmware_unload(uint16_t dev_id);
610 * Trigger the rawdev self test.
613 * The identifier of the device
615 * - 0: Selftest successful
616 * - -ENOTSUP if the device doesn't support selftest
617 * - other values < 0 on failure.
620 rte_rawdev_selftest(uint16_t dev_id);
626 #endif /* _RTE_RAWDEV_H_ */