1 /* SPDX-License-Identifier: BSD-3-Clause
13 #include <rte_byteorder.h>
14 #include <rte_common.h>
15 #include <rte_debug.h>
18 #include <rte_kvargs.h>
20 #include <rte_malloc.h>
21 #include <rte_memory.h>
22 #include <rte_memcpy.h>
23 #include <rte_lcore.h>
24 #include <rte_bus_vdev.h>
26 #include <rte_rawdev.h>
27 #include <rte_rawdev_pmd.h>
29 #include "skeleton_rawdev.h"
31 /* Dynamic log type identifier */
32 int skeleton_pmd_logtype;
34 /* Count of instances */
35 static uint16_t skeldev_init_once;
37 /**< Rawdev Skeleton dummy driver name */
38 #define SKELETON_PMD_RAWDEV_NAME rawdev_skeleton
40 /**< Skeleton rawdev driver object */
41 static struct rte_vdev_driver skeleton_pmd_drv;
43 struct queue_buffers {
44 void *bufs[SKELETON_QUEUE_MAX_DEPTH];
47 static struct queue_buffers queue_buf[SKELETON_MAX_QUEUES] = {};
48 static void clear_queue_bufs(int queue_id);
50 static void skeleton_rawdev_info_get(struct rte_rawdev *dev,
51 rte_rawdev_obj_t dev_info)
53 struct skeleton_rawdev *skeldev;
54 struct skeleton_rawdev_conf *skeldev_conf;
56 SKELETON_PMD_FUNC_TRACE();
59 SKELETON_PMD_ERR("Invalid request");
63 skeldev = skeleton_rawdev_get_priv(dev);
65 skeldev_conf = dev_info;
67 skeldev_conf->num_queues = skeldev->num_queues;
68 skeldev_conf->capabilities = skeldev->capabilities;
69 skeldev_conf->device_state = skeldev->device_state;
70 skeldev_conf->firmware_state = skeldev->fw.firmware_state;
73 static int skeleton_rawdev_configure(const struct rte_rawdev *dev,
74 rte_rawdev_obj_t config)
76 struct skeleton_rawdev *skeldev;
77 struct skeleton_rawdev_conf *skeldev_conf;
79 SKELETON_PMD_FUNC_TRACE();
81 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
84 SKELETON_PMD_ERR("Invalid configuration");
88 skeldev_conf = config;
89 skeldev = skeleton_rawdev_get_priv(dev);
91 if (skeldev_conf->num_queues <= SKELETON_MAX_QUEUES)
92 skeldev->num_queues = skeldev_conf->num_queues;
96 skeldev->capabilities = skeldev_conf->capabilities;
97 skeldev->num_queues = skeldev_conf->num_queues;
102 static int skeleton_rawdev_start(struct rte_rawdev *dev)
105 struct skeleton_rawdev *skeldev;
106 enum skeleton_firmware_state fw_state;
107 enum skeleton_device_state device_state;
109 SKELETON_PMD_FUNC_TRACE();
111 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
113 skeldev = skeleton_rawdev_get_priv(dev);
115 fw_state = skeldev->fw.firmware_state;
116 device_state = skeldev->device_state;
118 if (fw_state == SKELETON_FW_LOADED &&
119 device_state == SKELETON_DEV_STOPPED) {
120 skeldev->device_state = SKELETON_DEV_RUNNING;
122 SKELETON_PMD_ERR("Device not ready for starting");
129 static void skeleton_rawdev_stop(struct rte_rawdev *dev)
131 struct skeleton_rawdev *skeldev;
133 SKELETON_PMD_FUNC_TRACE();
136 skeldev = skeleton_rawdev_get_priv(dev);
137 skeldev->device_state = SKELETON_DEV_STOPPED;
142 reset_queues(struct skeleton_rawdev *skeldev)
146 for (i = 0; i < SKELETON_MAX_QUEUES; i++) {
147 skeldev->queues[i].depth = SKELETON_QUEUE_DEF_DEPTH;
148 skeldev->queues[i].state = SKELETON_QUEUE_DETACH;
153 reset_attribute_table(struct skeleton_rawdev *skeldev)
157 for (i = 0; i < SKELETON_MAX_ATTRIBUTES; i++) {
158 if (skeldev->attr[i].name) {
159 free(skeldev->attr[i].name);
160 skeldev->attr[i].name = NULL;
165 static int skeleton_rawdev_close(struct rte_rawdev *dev)
168 struct skeleton_rawdev *skeldev;
169 enum skeleton_firmware_state fw_state;
170 enum skeleton_device_state device_state;
172 SKELETON_PMD_FUNC_TRACE();
174 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
176 skeldev = skeleton_rawdev_get_priv(dev);
178 fw_state = skeldev->fw.firmware_state;
179 device_state = skeldev->device_state;
181 reset_queues(skeldev);
182 reset_attribute_table(skeldev);
185 case SKELETON_FW_LOADED:
186 if (device_state == SKELETON_DEV_RUNNING) {
187 SKELETON_PMD_ERR("Cannot close running device");
190 /* Probably call fw reset here */
191 skeldev->fw.firmware_state = SKELETON_FW_READY;
194 case SKELETON_FW_READY:
195 case SKELETON_FW_ERROR:
197 SKELETON_PMD_DEBUG("Device already in stopped state");
202 /* Clear all allocated queues */
203 for (i = 0; i < SKELETON_MAX_QUEUES; i++)
209 static int skeleton_rawdev_reset(struct rte_rawdev *dev)
211 struct skeleton_rawdev *skeldev;
213 SKELETON_PMD_FUNC_TRACE();
215 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
217 skeldev = skeleton_rawdev_get_priv(dev);
219 SKELETON_PMD_DEBUG("Resetting device");
220 skeldev->fw.firmware_state = SKELETON_FW_READY;
225 static void skeleton_rawdev_queue_def_conf(struct rte_rawdev *dev,
227 rte_rawdev_obj_t queue_conf)
229 struct skeleton_rawdev *skeldev;
230 struct skeleton_rawdev_queue *skelq;
232 SKELETON_PMD_FUNC_TRACE();
234 if (!dev || !queue_conf)
237 skeldev = skeleton_rawdev_get_priv(dev);
238 skelq = &skeldev->queues[queue_id];
240 if (queue_id < SKELETON_MAX_QUEUES)
241 rte_memcpy(queue_conf, skelq,
242 sizeof(struct skeleton_rawdev_queue));
246 clear_queue_bufs(int queue_id)
250 /* Clear buffers for queue_id */
251 for (i = 0; i < SKELETON_QUEUE_MAX_DEPTH; i++)
252 queue_buf[queue_id].bufs[i] = NULL;
255 static int skeleton_rawdev_queue_setup(struct rte_rawdev *dev,
257 rte_rawdev_obj_t queue_conf)
260 struct skeleton_rawdev *skeldev;
261 struct skeleton_rawdev_queue *q;
263 SKELETON_PMD_FUNC_TRACE();
265 if (!dev || !queue_conf)
268 skeldev = skeleton_rawdev_get_priv(dev);
269 q = &skeldev->queues[queue_id];
271 if (skeldev->num_queues > queue_id &&
272 q->depth < SKELETON_QUEUE_MAX_DEPTH) {
273 rte_memcpy(q, queue_conf,
274 sizeof(struct skeleton_rawdev_queue));
275 clear_queue_bufs(queue_id);
277 SKELETON_PMD_ERR("Invalid queue configuration");
284 static int skeleton_rawdev_queue_release(struct rte_rawdev *dev,
288 struct skeleton_rawdev *skeldev;
290 SKELETON_PMD_FUNC_TRACE();
292 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
294 skeldev = skeleton_rawdev_get_priv(dev);
296 if (skeldev->num_queues > queue_id) {
297 skeldev->queues[queue_id].state = SKELETON_QUEUE_DETACH;
298 skeldev->queues[queue_id].depth = SKELETON_QUEUE_DEF_DEPTH;
299 clear_queue_bufs(queue_id);
301 SKELETON_PMD_ERR("Invalid queue configuration");
308 static uint16_t skeleton_rawdev_queue_count(struct rte_rawdev *dev)
310 struct skeleton_rawdev *skeldev;
312 SKELETON_PMD_FUNC_TRACE();
314 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
316 skeldev = skeleton_rawdev_get_priv(dev);
317 return skeldev->num_queues;
320 static int skeleton_rawdev_get_attr(struct rte_rawdev *dev,
321 const char *attr_name,
322 uint64_t *attr_value)
326 struct skeleton_rawdev *skeldev;
328 SKELETON_PMD_FUNC_TRACE();
330 if (!dev || !attr_name || !attr_value) {
331 SKELETON_PMD_ERR("Invalid arguments for getting attributes");
335 skeldev = skeleton_rawdev_get_priv(dev);
337 for (i = 0; i < SKELETON_MAX_ATTRIBUTES; i++) {
338 if (!skeldev->attr[i].name)
341 if (!strncmp(skeldev->attr[i].name, attr_name,
342 SKELETON_ATTRIBUTE_NAME_MAX)) {
343 *attr_value = skeldev->attr[i].value;
345 SKELETON_PMD_DEBUG("Attribute (%s) Value (%" PRIu64 ")",
346 attr_name, *attr_value);
354 /* Attribute not found */
358 static int skeleton_rawdev_set_attr(struct rte_rawdev *dev,
359 const char *attr_name,
360 const uint64_t attr_value)
364 struct skeleton_rawdev *skeldev;
366 SKELETON_PMD_FUNC_TRACE();
368 if (!dev || !attr_name) {
369 SKELETON_PMD_ERR("Invalid arguments for setting attributes");
373 skeldev = skeleton_rawdev_get_priv(dev);
375 /* Check if attribute already exists */
376 for (i = 0; i < SKELETON_MAX_ATTRIBUTES; i++) {
377 if (!skeldev->attr[i].name)
380 if (!strncmp(skeldev->attr[i].name, attr_name,
381 SKELETON_ATTRIBUTE_NAME_MAX)) {
383 skeldev->attr[i].value = attr_value;
390 if (i < (SKELETON_MAX_ATTRIBUTES - 1)) {
391 /* There is still space to insert one more */
392 skeldev->attr[i].name = strdup(attr_name);
393 if (!skeldev->attr[i].name)
396 skeldev->attr[i].value = attr_value;
404 static int skeleton_rawdev_enqueue_bufs(struct rte_rawdev *dev,
405 struct rte_rawdev_buf **buffers,
407 rte_rawdev_obj_t context)
413 /* context is essentially the queue_id which is
414 * transferred as opaque object through the library layer. This can
415 * help in complex implementation which require more information than
416 * just an integer - for example, a queue-pair.
418 q_id = *((int *)context);
420 for (i = 0; i < count; i++)
421 queue_buf[q_id].bufs[i] = buffers[i]->buf_addr;
426 static int skeleton_rawdev_dequeue_bufs(struct rte_rawdev *dev,
427 struct rte_rawdev_buf **buffers,
429 rte_rawdev_obj_t context)
435 /* context is essentially the queue_id which is
436 * transferred as opaque object through the library layer. This can
437 * help in complex implementation which require more information than
438 * just an integer - for example, a queue-pair.
440 q_id = *((int *)context);
442 for (i = 0; i < count; i++)
443 buffers[i]->buf_addr = queue_buf[q_id].bufs[i];
448 static int skeleton_rawdev_dump(struct rte_rawdev *dev, FILE *f)
456 static int skeleton_rawdev_firmware_status_get(struct rte_rawdev *dev,
457 rte_rawdev_obj_t status_info)
459 struct skeleton_rawdev *skeldev;
461 SKELETON_PMD_FUNC_TRACE();
463 skeldev = skeleton_rawdev_get_priv(dev);
465 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
468 memcpy(status_info, &skeldev->fw.firmware_state,
469 sizeof(enum skeleton_firmware_state));
475 static int skeleton_rawdev_firmware_version_get(
476 struct rte_rawdev *dev,
477 rte_rawdev_obj_t version_info)
479 struct skeleton_rawdev *skeldev;
480 struct skeleton_firmware_version_info *vi;
482 SKELETON_PMD_FUNC_TRACE();
484 skeldev = skeleton_rawdev_get_priv(dev);
487 vi->major = skeldev->fw.firmware_version.major;
488 vi->minor = skeldev->fw.firmware_version.minor;
489 vi->subrel = skeldev->fw.firmware_version.subrel;
494 static int skeleton_rawdev_firmware_load(struct rte_rawdev *dev,
495 rte_rawdev_obj_t firmware_buf)
497 struct skeleton_rawdev *skeldev;
499 SKELETON_PMD_FUNC_TRACE();
501 skeldev = skeleton_rawdev_get_priv(dev);
503 /* firmware_buf is a mmaped, possibly DMA'able area, buffer. Being
504 * dummy, all this does is check if firmware_buf is not NULL and
505 * sets the state of the firmware.
510 skeldev->fw.firmware_state = SKELETON_FW_LOADED;
515 static int skeleton_rawdev_firmware_unload(struct rte_rawdev *dev)
517 struct skeleton_rawdev *skeldev;
519 SKELETON_PMD_FUNC_TRACE();
521 skeldev = skeleton_rawdev_get_priv(dev);
523 skeldev->fw.firmware_state = SKELETON_FW_READY;
528 static const struct rte_rawdev_ops skeleton_rawdev_ops = {
529 .dev_info_get = skeleton_rawdev_info_get,
530 .dev_configure = skeleton_rawdev_configure,
531 .dev_start = skeleton_rawdev_start,
532 .dev_stop = skeleton_rawdev_stop,
533 .dev_close = skeleton_rawdev_close,
534 .dev_reset = skeleton_rawdev_reset,
536 .queue_def_conf = skeleton_rawdev_queue_def_conf,
537 .queue_setup = skeleton_rawdev_queue_setup,
538 .queue_release = skeleton_rawdev_queue_release,
539 .queue_count = skeleton_rawdev_queue_count,
541 .attr_get = skeleton_rawdev_get_attr,
542 .attr_set = skeleton_rawdev_set_attr,
544 .enqueue_bufs = skeleton_rawdev_enqueue_bufs,
545 .dequeue_bufs = skeleton_rawdev_dequeue_bufs,
547 .dump = skeleton_rawdev_dump,
550 .xstats_get_names = NULL,
551 .xstats_get_by_name = NULL,
552 .xstats_reset = NULL,
554 .firmware_status_get = skeleton_rawdev_firmware_status_get,
555 .firmware_version_get = skeleton_rawdev_firmware_version_get,
556 .firmware_load = skeleton_rawdev_firmware_load,
557 .firmware_unload = skeleton_rawdev_firmware_unload,
559 .dev_selftest = test_rawdev_skeldev,
563 skeleton_rawdev_create(const char *name,
564 struct rte_vdev_device *vdev,
568 struct rte_rawdev *rawdev = NULL;
569 struct skeleton_rawdev *skeldev = NULL;
572 SKELETON_PMD_ERR("Invalid name of the device!");
577 /* Allocate device structure */
578 rawdev = rte_rawdev_pmd_allocate(name, sizeof(struct skeleton_rawdev),
580 if (rawdev == NULL) {
581 SKELETON_PMD_ERR("Unable to allocate rawdevice");
586 ret = rawdev->dev_id; /* return the rawdev id of new device */
588 rawdev->dev_ops = &skeleton_rawdev_ops;
589 rawdev->device = &vdev->device;
591 skeldev = skeleton_rawdev_get_priv(rawdev);
593 skeldev->device_id = SKELETON_DEVICE_ID;
594 skeldev->vendor_id = SKELETON_VENDOR_ID;
595 skeldev->capabilities = SKELETON_DEFAULT_CAPA;
597 memset(&skeldev->fw, 0, sizeof(struct skeleton_firmware));
599 skeldev->fw.firmware_state = SKELETON_FW_READY;
600 skeldev->fw.firmware_version.major = SKELETON_MAJOR_VER;
601 skeldev->fw.firmware_version.minor = SKELETON_MINOR_VER;
602 skeldev->fw.firmware_version.subrel = SKELETON_SUB_VER;
604 skeldev->device_state = SKELETON_DEV_STOPPED;
606 /* Reset/set to default queue configuration for this device */
607 for (i = 0; i < SKELETON_MAX_QUEUES; i++) {
608 skeldev->queues[i].state = SKELETON_QUEUE_DETACH;
609 skeldev->queues[i].depth = SKELETON_QUEUE_DEF_DEPTH;
612 /* Clear all allocated queue buffers */
613 for (i = 0; i < SKELETON_MAX_QUEUES; i++)
620 rte_rawdev_pmd_release(rawdev);
626 skeleton_rawdev_destroy(const char *name)
629 struct rte_rawdev *rdev;
632 SKELETON_PMD_ERR("Invalid device name");
636 rdev = rte_rawdev_pmd_get_named_dev(name);
638 SKELETON_PMD_ERR("Invalid device name (%s)", name);
642 /* rte_rawdev_close is called by pmd_release */
643 ret = rte_rawdev_pmd_release(rdev);
645 SKELETON_PMD_DEBUG("Device cleanup failed");
651 skeldev_get_selftest(const char *key __rte_unused,
661 skeldev_parse_vdev_args(struct rte_vdev_device *vdev)
667 static const char *const args[] = {
668 SKELETON_SELFTEST_ARG,
672 name = rte_vdev_device_name(vdev);
674 params = rte_vdev_device_args(vdev);
675 if (params != NULL && params[0] != '\0') {
676 struct rte_kvargs *kvlist = rte_kvargs_parse(params, args);
680 "Ignoring unsupported params supplied '%s'",
683 int ret = rte_kvargs_process(kvlist,
684 SKELETON_SELFTEST_ARG,
685 skeldev_get_selftest, &selftest);
686 if (ret != 0 || (selftest < 0 || selftest > 1)) {
687 SKELETON_PMD_ERR("%s: Error in parsing args",
689 rte_kvargs_free(kvlist);
690 ret = -1; /* enforce if selftest is invalid */
695 rte_kvargs_free(kvlist);
702 skeleton_rawdev_probe(struct rte_vdev_device *vdev)
705 int selftest = 0, ret = 0;
708 name = rte_vdev_device_name(vdev);
712 /* More than one instance is not supported */
713 if (skeldev_init_once) {
714 SKELETON_PMD_ERR("Multiple instance not supported for %s",
719 SKELETON_PMD_INFO("Init %s on NUMA node %d", name, rte_socket_id());
721 selftest = skeldev_parse_vdev_args(vdev);
722 /* In case of invalid argument, selftest != 1; ignore other values */
724 ret = skeleton_rawdev_create(name, vdev, rte_socket_id());
726 /* In case command line argument for 'selftest' was passed;
727 * if invalid arguments were passed, execution continues but
731 test_rawdev_skeldev(ret);
734 /* Device instance created; Second instance not possible */
735 skeldev_init_once = 1;
737 return ret < 0 ? ret : 0;
741 skeleton_rawdev_remove(struct rte_vdev_device *vdev)
746 name = rte_vdev_device_name(vdev);
750 SKELETON_PMD_INFO("Closing %s on NUMA node %d", name, rte_socket_id());
752 ret = skeleton_rawdev_destroy(name);
754 skeldev_init_once = 0;
759 static struct rte_vdev_driver skeleton_pmd_drv = {
760 .probe = skeleton_rawdev_probe,
761 .remove = skeleton_rawdev_remove
764 RTE_PMD_REGISTER_VDEV(SKELETON_PMD_RAWDEV_NAME, skeleton_pmd_drv);
766 RTE_INIT(skeleton_pmd_init_log)
768 skeleton_pmd_logtype = rte_log_register("rawdev.skeleton");
769 if (skeleton_pmd_logtype >= 0)
770 rte_log_set_level(skeleton_pmd_logtype, RTE_LOG_INFO);