1/* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright 2017 NXP 3 */ 4 5#ifndef _RTE_RAWDEV_H_ 6#define _RTE_RAWDEV_H_ 7 8/** 9 * @file rte_rawdev.h 10 * 11 * Generic device abstraction APIs. 12 * 13 * This API allow applications to configure and use generic devices having 14 * no specific type already available in DPDK. 15 */ 16 17#ifdef __cplusplus 18extern "C" { 19#endif 20 21#include <rte_common.h> 22#include <rte_memory.h> 23#include <rte_errno.h> 24 25/* Rawdevice object - essentially a void to be typecast by implementation */ 26typedef void *rte_rawdev_obj_t; 27 28/** 29 * Get the total number of raw devices that have been successfully 30 * initialised. 31 * 32 * @return 33 * The total number of usable raw devices. 34 */ 35uint8_t 36rte_rawdev_count(void); 37 38/** 39 * Get the device identifier for the named raw device. 40 * 41 * @param name 42 * Raw device name to select the raw device identifier. 43 * 44 * @return 45 * Returns raw device identifier on success. 46 * - <0: Failure to find named raw device. 47 */ 48uint16_t 49rte_rawdev_get_dev_id(const char *name); 50 51/** 52 * Return the NUMA socket to which a device is connected. 53 * 54 * @param dev_id 55 * The identifier of the device. 56 * @return 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. 60 */ 61int 62rte_rawdev_socket_id(uint16_t dev_id); 63 64/** 65 * Raw device information forward declaration 66 */ 67struct rte_rawdev_info; 68 69/** 70 * Retrieve the contextual information of a raw device. 71 * 72 * @param dev_id 73 * The identifier of the device. 74 * 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. 84 * 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 89 * type is provided. 90 * 91 * @return 92 * - 0: Success, driver updates the contextual information of the raw device 93 * - <0: Error code returned by the driver info get function. 94 * 95 */ 96int 97rte_rawdev_info_get(uint16_t dev_id, struct rte_rawdev_info *dev_info, 98 size_t dev_private_size); 99 100/** 101 * Configure a raw device. 102 * 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 105 * stopped state. 106 * 107 * The caller may use rte_rawdev_info_get() to get the capability of each 108 * resources available for this raw device. 109 * 110 * @param dev_id 111 * The identifier of the device to configure. 112 * @param dev_conf 113 * The raw device configuration structure encapsulated into rte_rawdev_info 114 * object. 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. 124 * 125 * @return 126 * - 0: Success, device configured. 127 * - <0: Error code returned by the driver configuration function. 128 */ 129int 130rte_rawdev_configure(uint16_t dev_id, struct rte_rawdev_info *dev_conf, 131 size_t dev_private_size); 132 133 134/** 135 * Retrieve the current configuration information of a raw queue designated 136 * by its *queue_id* from the raw driver for a raw device. 137 * 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. 140 * 141 * @param dev_id 142 * The identifier of the device. 143 * @param queue_id 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. 149 * @param queue_conf_size 150 * The size of the structure pointed to by queue_conf 151 * @return 152 * - 0: Success, driver updates the default raw queue configuration data. 153 * - <0: Error code returned by the driver info get function. 154 * 155 * @see rte_raw_queue_setup() 156 * 157 */ 158int 159rte_rawdev_queue_conf_get(uint16_t dev_id, 160 uint16_t queue_id, 161 rte_rawdev_obj_t queue_conf, 162 size_t queue_conf_size); 163 164/** 165 * Allocate and set up a raw queue for a raw device. 166 * 167 * @param dev_id 168 * The identifier of the device. 169 * @param queue_id 170 * The index of the raw queue to setup. The value must be in the range 171 * [0, nb_raw_queues - 1] previously supplied to rte_rawdev_configure(). 172 * @param queue_conf 173 * The pointer to the configuration data to be used for the raw queue. 174 * NULL value is allowed, in which case default configuration used. 175 * @param queue_conf_size 176 * The size of the structure pointed to by queue_conf 177 * 178 * @see rte_rawdev_queue_conf_get() 179 * 180 * @return 181 * - 0: Success, raw queue correctly set up. 182 * - <0: raw queue configuration failed 183 */ 184int 185rte_rawdev_queue_setup(uint16_t dev_id, 186 uint16_t queue_id, 187 rte_rawdev_obj_t queue_conf, 188 size_t queue_conf_size); 189 190/** 191 * Release and deallocate a raw queue from a raw device. 192 * 193 * @param dev_id 194 * The identifier of the device. 195 * @param queue_id 196 * The index of the raw queue to release. The value must be in the range 197 * [0, nb_raw_queues - 1] previously supplied to rte_rawdev_configure(). 198 * 199 * @see rte_rawdev_queue_conf_get() 200 * 201 * @return 202 * - 0: Success, raw queue released. 203 * - <0: raw queue configuration failed 204 */ 205int 206rte_rawdev_queue_release(uint16_t dev_id, uint16_t queue_id); 207 208/** 209 * Get the number of raw queues on a specific raw device 210 * 211 * @param dev_id 212 * Raw device identifier. 213 * @return 214 * - The number of configured raw queues 215 */ 216uint16_t 217rte_rawdev_queue_count(uint16_t dev_id); 218 219/** 220 * Start a raw device. 221 * 222 * The device start step is the last one and consists of setting the raw 223 * queues to start accepting the raws and schedules to raw ports. 224 * 225 * On success, all basic functions exported by the API (raw enqueue, 226 * raw dequeue and so on) can be invoked. 227 * 228 * @param dev_id 229 * Raw device identifier 230 * @return 231 * - 0: Success, device started. 232 * < 0: Failure 233 */ 234int 235rte_rawdev_start(uint16_t dev_id); 236 237/** 238 * Stop a raw device. The device can be restarted with a call to 239 * rte_rawdev_start() 240 * 241 * @param dev_id 242 * Raw device identifier. 243 */ 244void 245rte_rawdev_stop(uint16_t dev_id); 246 247/** 248 * Close a raw device. The device cannot be restarted after this call. 249 * 250 * @param dev_id 251 * Raw device identifier 252 * 253 * @return 254 * - 0 on successfully closing device 255 * - <0 on failure to close device 256 * - (-EAGAIN) if device is busy 257 */ 258int 259rte_rawdev_close(uint16_t dev_id); 260 261/** 262 * Reset a raw device. 263 * This is different from cycle of rte_rawdev_start->rte_rawdev_stop in the 264 * sense similar to hard or soft reset. 265 * 266 * @param dev_id 267 * Raw device identifiers 268 * @return 269 * 0 for successful reset, 270 * !0 for failure in resetting 271 */ 272int 273rte_rawdev_reset(uint16_t dev_id); 274 275#define RTE_RAWDEV_NAME_MAX_LEN (64) 276/**< @internal Max length of name of raw PMD */ 277 278 279 280/** @internal 281 * The data structure associated with each raw device. 282 * It is a placeholder for PMD specific data, encapsulating only information 283 * related to framework. 284 */ 285struct rte_rawdev { 286 /**< Socket ID where memory is allocated */ 287 int socket_id; 288 /**< Device ID for this instance */ 289 uint16_t dev_id; 290 /**< Functions exported by PMD */ 291 const struct rte_rawdev_ops *dev_ops; 292 /**< Device info. supplied during device initialization */ 293 struct rte_device *device; 294 /**< Driver info. supplied by probing */ 295 const char *driver_name; 296 297 RTE_STD_C11 298 /**< Flag indicating the device is attached */ 299 uint8_t attached : 1; 300 /**< Device state: STARTED(1)/STOPPED(0) */ 301 uint8_t started : 1; 302 303 /**< PMD-specific private data */ 304 rte_rawdev_obj_t dev_private; 305 /**< Device name */ 306 char name[RTE_RAWDEV_NAME_MAX_LEN]; 307} __rte_cache_aligned; 308 309/** @internal The pool of rte_rawdev structures. */ 310extern struct rte_rawdev *rte_rawdevs; 311 312 313struct rte_rawdev_info { 314 /**< Name of driver handling this device */ 315 const char *driver_name; 316 /**< Device encapsulation */ 317 struct rte_device *device; 318 /**< Socket ID where memory is allocated */ 319 int socket_id; 320 /**< PMD-specific private data */ 321 rte_rawdev_obj_t dev_private; 322}; 323 324struct rte_rawdev_buf { 325 /**< Opaque buffer reference */ 326 void *buf_addr; 327}; 328 329/** 330 * Dump internal information about *dev_id* to the FILE* provided in *f*. 331 * 332 * @param dev_id 333 * The identifier of the device. 334 * 335 * @param f 336 * A pointer to a file for output 337 * 338 * @return 339 * - 0: on success 340 * - <0: on failure. 341 */ 342int 343rte_rawdev_dump(uint16_t dev_id, FILE *f); 344 345/** 346 * Get an attribute value from implementation. 347 * Attribute is an opaque handle agreed upon between application and PMD. 348 * 349 * Implementations are expected to maintain an array of attribute-value pairs 350 * based on application calls. Memory management for this structure is 351 * shared responsibility of implementation and application. 352 * 353 * @param dev_id 354 * The identifier of the device to configure. 355 * @param attr_name 356 * Opaque object representing an attribute in implementation. 357 * @param attr_value [out] 358 * Opaque response to the attribute value. In case of error, this remains 359 * untouched. This is double pointer of void type. 360 * @return 361 * 0 for success 362 * !0 Error; attr_value remains untouched in case of error. 363 */ 364int 365rte_rawdev_get_attr(uint16_t dev_id, 366 const char *attr_name, 367 uint64_t *attr_value); 368 369/** 370 * Set an attribute value. 371 * Attribute is an opaque handle agreed upon between application and PMD. 372 * 373 * @param dev_id 374 * The identifier of the device to configure. 375 * @param attr_name 376 * Opaque object representing an attribute in implementation. 377 * @param attr_value 378 * Value of the attribute represented by attr_name 379 * @return 380 * 0 for success 381 * !0 Error 382 */ 383int 384rte_rawdev_set_attr(uint16_t dev_id, 385 const char *attr_name, 386 const uint64_t attr_value); 387 388/** 389 * Enqueue a stream of buffers to the device. 390 * 391 * Rather than specifying a queue, this API passes along an opaque object 392 * to the driver implementation. That object can be a queue or any other 393 * contextual information necessary for the device to enqueue buffers. 394 * 395 * @param dev_id 396 * The identifier of the device to configure. 397 * @param buffers 398 * Collection of buffers for enqueuing 399 * @param count 400 * Count of buffers to enqueue 401 * @param context 402 * Opaque context information. 403 * @return 404 * >=0 for buffers enqueued 405 * !0 for failure. 406 * Whether partial enqueue is failure or success is defined between app 407 * and driver implementation. 408 */ 409int 410rte_rawdev_enqueue_buffers(uint16_t dev_id, 411 struct rte_rawdev_buf **buffers, 412 unsigned int count, 413 rte_rawdev_obj_t context); 414 415/** 416 * Dequeue a stream of buffers from the device. 417 * 418 * Rather than specifying a queue, this API passes along an opaque object 419 * to the driver implementation. That object can be a queue or any other 420 * contextual information necessary for the device to dequeue buffers. 421 * 422 * Application should have allocated enough space to store `count` response 423 * buffers. 424 * Releasing buffers dequeued is responsibility of the application. 425 * 426 * @param dev_id 427 * The identifier of the device to configure. 428 * @param buffers 429 * Collection of buffers dequeued 430 * @param count 431 * Max buffers expected to be dequeued 432 * @param context 433 * Opaque context information. 434 * @return 435 * >=0 for buffers dequeued 436 * !0 for failure. 437 * Whether partial enqueue is failure or success is defined between app 438 * and driver implementation. 439 */ 440int 441rte_rawdev_dequeue_buffers(uint16_t dev_id, 442 struct rte_rawdev_buf **buffers, 443 unsigned int count, 444 rte_rawdev_obj_t context); 445 446/** Maximum name length for extended statistics counters */ 447#define RTE_RAW_DEV_XSTATS_NAME_SIZE 64 448 449/** 450 * A name-key lookup element for extended statistics. 451 * 452 * This structure is used to map between names and ID numbers 453 * for extended ethdev statistics. 454 */ 455struct rte_rawdev_xstats_name { 456 char name[RTE_RAW_DEV_XSTATS_NAME_SIZE]; 457}; 458 459/** 460 * Retrieve names of extended statistics of a raw device. 461 * 462 * @param dev_id 463 * The identifier of the raw device. 464 * @param[out] xstats_names 465 * Block of memory to insert names into. Must be at least size in capacity. 466 * If set to NULL, function returns required capacity. 467 * @param size 468 * Capacity of xstats_names (number of names). 469 * @return 470 * - positive value lower or equal to size: success. The return value 471 * is the number of entries filled in the stats table. 472 * - positive value higher than size: error, the given statistics table 473 * is too small. The return value corresponds to the size that should 474 * be given to succeed. The entries in the table are not valid and 475 * shall not be used by the caller. 476 * - negative value on error: 477 * -ENODEV for invalid *dev_id* 478 * -ENOTSUP if the device doesn't support this function. 479 */ 480int 481rte_rawdev_xstats_names_get(uint16_t dev_id, 482 struct rte_rawdev_xstats_name *xstats_names, 483 unsigned int size); 484 485/** 486 * Retrieve extended statistics of a raw device. 487 * 488 * @param dev_id 489 * The identifier of the device. 490 * @param ids 491 * The id numbers of the stats to get. The ids can be got from the stat 492 * position in the stat list from rte_rawdev_get_xstats_names(), or 493 * by using rte_rawdev_get_xstats_by_name() 494 * @param[out] values 495 * The values for each stats request by ID. 496 * @param n 497 * The number of stats requested 498 * @return 499 * - positive value: number of stat entries filled into the values array 500 * - negative value on error: 501 * -ENODEV for invalid *dev_id* 502 * -ENOTSUP if the device doesn't support this function. 503 */ 504int 505rte_rawdev_xstats_get(uint16_t dev_id, 506 const unsigned int ids[], 507 uint64_t values[], 508 unsigned int n); 509 510/** 511 * Retrieve the value of a single stat by requesting it by name. 512 * 513 * @param dev_id 514 * The identifier of the device 515 * @param name 516 * The stat name to retrieve 517 * @param[out] id 518 * If non-NULL, the numerical id of the stat will be returned, so that further 519 * requests for the stat can be got using rte_rawdev_xstats_get, which will 520 * be faster as it doesn't need to scan a list of names for the stat. 521 * If the stat cannot be found, the id returned will be (unsigned)-1. 522 * @return 523 * - positive value or zero: the stat value 524 * - negative value: -EINVAL if stat not found, -ENOTSUP if not supported. 525 */ 526uint64_t 527rte_rawdev_xstats_by_name_get(uint16_t dev_id, 528 const char *name, 529 unsigned int *id); 530 531/** 532 * Reset the values of the xstats of the selected component in the device. 533 * 534 * @param dev_id 535 * The identifier of the device 536 * @param ids 537 * Selects specific statistics to be reset. When NULL, all statistics 538 * will be reset. If non-NULL, must point to array of at least 539 * *nb_ids* size. 540 * @param nb_ids 541 * The number of ids available from the *ids* array. Ignored when ids is NULL. 542 * @return 543 * - zero: successfully reset the statistics to zero 544 * - negative value: -EINVAL invalid parameters, -ENOTSUP if not supported. 545 */ 546int 547rte_rawdev_xstats_reset(uint16_t dev_id, 548 const uint32_t ids[], 549 uint32_t nb_ids); 550 551/** 552 * Get Firmware status of the device.. 553 * Returns a memory allocated by driver/implementation containing status 554 * information block. It is responsibility of caller to release the buffer. 555 * 556 * @param dev_id 557 * Raw device identifier 558 * @param status_info 559 * Pointer to status information area. Caller is responsible for releasing 560 * the memory associated. 561 * @return 562 * 0 for success, 563 * !0 for failure, `status_info` argument state is undefined 564 */ 565int 566rte_rawdev_firmware_status_get(uint16_t dev_id, 567 rte_rawdev_obj_t status_info); 568 569/** 570 * Get Firmware version of the device. 571 * Returns a memory allocated by driver/implementation containing version 572 * information block. It is responsibility of caller to release the buffer. 573 * 574 * @param dev_id 575 * Raw device identifier 576 * @param version_info 577 * Pointer to version information area. Caller is responsible for releasing 578 * the memory associated. 579 * @return 580 * 0 for success, 581 * !0 for failure, `version_info` argument state is undefined 582 */ 583int 584rte_rawdev_firmware_version_get(uint16_t dev_id, 585 rte_rawdev_obj_t version_info); 586 587/** 588 * Load firmware on the device. 589 * TODO: In future, methods like directly flashing from file too can be 590 * supported. 591 * 592 * @param dev_id 593 * Raw device identifier 594 * @param firmware_image 595 * Pointer to buffer containing image binary data 596 * @return 597 * 0 for successful load 598 * !0 for failure to load the provided image, or image incorrect. 599 */ 600int 601rte_rawdev_firmware_load(uint16_t dev_id, rte_rawdev_obj_t firmware_image); 602 603/** 604 * Unload firmware from the device. 605 * 606 * @param dev_id 607 * Raw device identifiers 608 * @return 609 * 0 for successful Unload 610 * !0 for failure in unloading 611 */ 612int 613rte_rawdev_firmware_unload(uint16_t dev_id); 614 615/** 616 * Trigger the rawdev self test. 617 * 618 * @param dev_id 619 * The identifier of the device 620 * @return 621 * - 0: Selftest successful 622 * - -ENOTSUP if the device doesn't support selftest 623 * - other values < 0 on failure. 624 */ 625int 626rte_rawdev_selftest(uint16_t dev_id); 627 628#ifdef __cplusplus 629} 630#endif 631 632#endif /* _RTE_RAWDEV_H_ */ 633