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