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 struct queue_buffers {
41 void *bufs[SKELETON_QUEUE_MAX_DEPTH];
44 static struct queue_buffers queue_buf[SKELETON_MAX_QUEUES] = {};
45 static void clear_queue_bufs(int queue_id);
47 static void skeleton_rawdev_info_get(struct rte_rawdev *dev,
48 rte_rawdev_obj_t dev_info)
50 struct skeleton_rawdev *skeldev;
51 struct skeleton_rawdev_conf *skeldev_conf;
53 SKELETON_PMD_FUNC_TRACE();
56 SKELETON_PMD_ERR("Invalid request");
60 skeldev = skeleton_rawdev_get_priv(dev);
62 skeldev_conf = dev_info;
64 skeldev_conf->num_queues = skeldev->num_queues;
65 skeldev_conf->capabilities = skeldev->capabilities;
66 skeldev_conf->device_state = skeldev->device_state;
67 skeldev_conf->firmware_state = skeldev->fw.firmware_state;
70 static int skeleton_rawdev_configure(const struct rte_rawdev *dev,
71 rte_rawdev_obj_t config)
73 struct skeleton_rawdev *skeldev;
74 struct skeleton_rawdev_conf *skeldev_conf;
76 SKELETON_PMD_FUNC_TRACE();
78 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
81 SKELETON_PMD_ERR("Invalid configuration");
85 skeldev_conf = config;
86 skeldev = skeleton_rawdev_get_priv(dev);
88 if (skeldev_conf->num_queues <= SKELETON_MAX_QUEUES)
89 skeldev->num_queues = skeldev_conf->num_queues;
93 skeldev->capabilities = skeldev_conf->capabilities;
94 skeldev->num_queues = skeldev_conf->num_queues;
99 static int skeleton_rawdev_start(struct rte_rawdev *dev)
102 struct skeleton_rawdev *skeldev;
103 enum skeleton_firmware_state fw_state;
104 enum skeleton_device_state device_state;
106 SKELETON_PMD_FUNC_TRACE();
108 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
110 skeldev = skeleton_rawdev_get_priv(dev);
112 fw_state = skeldev->fw.firmware_state;
113 device_state = skeldev->device_state;
115 if (fw_state == SKELETON_FW_LOADED &&
116 device_state == SKELETON_DEV_STOPPED) {
117 skeldev->device_state = SKELETON_DEV_RUNNING;
119 SKELETON_PMD_ERR("Device not ready for starting");
126 static void skeleton_rawdev_stop(struct rte_rawdev *dev)
128 struct skeleton_rawdev *skeldev;
130 SKELETON_PMD_FUNC_TRACE();
133 skeldev = skeleton_rawdev_get_priv(dev);
134 skeldev->device_state = SKELETON_DEV_STOPPED;
139 reset_queues(struct skeleton_rawdev *skeldev)
143 for (i = 0; i < SKELETON_MAX_QUEUES; i++) {
144 skeldev->queues[i].depth = SKELETON_QUEUE_DEF_DEPTH;
145 skeldev->queues[i].state = SKELETON_QUEUE_DETACH;
150 reset_attribute_table(struct skeleton_rawdev *skeldev)
154 for (i = 0; i < SKELETON_MAX_ATTRIBUTES; i++) {
155 if (skeldev->attr[i].name) {
156 free(skeldev->attr[i].name);
157 skeldev->attr[i].name = NULL;
162 static int skeleton_rawdev_close(struct rte_rawdev *dev)
165 struct skeleton_rawdev *skeldev;
166 enum skeleton_firmware_state fw_state;
167 enum skeleton_device_state device_state;
169 SKELETON_PMD_FUNC_TRACE();
171 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
173 skeldev = skeleton_rawdev_get_priv(dev);
175 fw_state = skeldev->fw.firmware_state;
176 device_state = skeldev->device_state;
178 reset_queues(skeldev);
179 reset_attribute_table(skeldev);
182 case SKELETON_FW_LOADED:
183 if (device_state == SKELETON_DEV_RUNNING) {
184 SKELETON_PMD_ERR("Cannot close running device");
187 /* Probably call fw reset here */
188 skeldev->fw.firmware_state = SKELETON_FW_READY;
191 case SKELETON_FW_READY:
192 case SKELETON_FW_ERROR:
194 SKELETON_PMD_DEBUG("Device already in stopped state");
199 /* Clear all allocated queues */
200 for (i = 0; i < SKELETON_MAX_QUEUES; i++)
206 static int skeleton_rawdev_reset(struct rte_rawdev *dev)
208 struct skeleton_rawdev *skeldev;
210 SKELETON_PMD_FUNC_TRACE();
212 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
214 skeldev = skeleton_rawdev_get_priv(dev);
216 SKELETON_PMD_DEBUG("Resetting device");
217 skeldev->fw.firmware_state = SKELETON_FW_READY;
222 static void skeleton_rawdev_queue_def_conf(struct rte_rawdev *dev,
224 rte_rawdev_obj_t queue_conf)
226 struct skeleton_rawdev *skeldev;
227 struct skeleton_rawdev_queue *skelq;
229 SKELETON_PMD_FUNC_TRACE();
231 if (!dev || !queue_conf)
234 skeldev = skeleton_rawdev_get_priv(dev);
235 skelq = &skeldev->queues[queue_id];
237 if (queue_id < SKELETON_MAX_QUEUES)
238 rte_memcpy(queue_conf, skelq,
239 sizeof(struct skeleton_rawdev_queue));
243 clear_queue_bufs(int queue_id)
247 /* Clear buffers for queue_id */
248 for (i = 0; i < SKELETON_QUEUE_MAX_DEPTH; i++)
249 queue_buf[queue_id].bufs[i] = NULL;
252 static int skeleton_rawdev_queue_setup(struct rte_rawdev *dev,
254 rte_rawdev_obj_t queue_conf)
257 struct skeleton_rawdev *skeldev;
258 struct skeleton_rawdev_queue *q;
260 SKELETON_PMD_FUNC_TRACE();
262 if (!dev || !queue_conf)
265 skeldev = skeleton_rawdev_get_priv(dev);
266 q = &skeldev->queues[queue_id];
268 if (skeldev->num_queues > queue_id &&
269 q->depth < SKELETON_QUEUE_MAX_DEPTH) {
270 rte_memcpy(q, queue_conf,
271 sizeof(struct skeleton_rawdev_queue));
272 clear_queue_bufs(queue_id);
274 SKELETON_PMD_ERR("Invalid queue configuration");
281 static int skeleton_rawdev_queue_release(struct rte_rawdev *dev,
285 struct skeleton_rawdev *skeldev;
287 SKELETON_PMD_FUNC_TRACE();
289 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
291 skeldev = skeleton_rawdev_get_priv(dev);
293 if (skeldev->num_queues > queue_id) {
294 skeldev->queues[queue_id].state = SKELETON_QUEUE_DETACH;
295 skeldev->queues[queue_id].depth = SKELETON_QUEUE_DEF_DEPTH;
296 clear_queue_bufs(queue_id);
298 SKELETON_PMD_ERR("Invalid queue configuration");
305 static uint16_t skeleton_rawdev_queue_count(struct rte_rawdev *dev)
307 struct skeleton_rawdev *skeldev;
309 SKELETON_PMD_FUNC_TRACE();
311 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
313 skeldev = skeleton_rawdev_get_priv(dev);
314 return skeldev->num_queues;
317 static int skeleton_rawdev_get_attr(struct rte_rawdev *dev,
318 const char *attr_name,
319 uint64_t *attr_value)
323 struct skeleton_rawdev *skeldev;
325 SKELETON_PMD_FUNC_TRACE();
327 if (!dev || !attr_name || !attr_value) {
328 SKELETON_PMD_ERR("Invalid arguments for getting attributes");
332 skeldev = skeleton_rawdev_get_priv(dev);
334 for (i = 0; i < SKELETON_MAX_ATTRIBUTES; i++) {
335 if (!skeldev->attr[i].name)
338 if (!strncmp(skeldev->attr[i].name, attr_name,
339 SKELETON_ATTRIBUTE_NAME_MAX)) {
340 *attr_value = skeldev->attr[i].value;
342 SKELETON_PMD_DEBUG("Attribute (%s) Value (%" PRIu64 ")",
343 attr_name, *attr_value);
351 /* Attribute not found */
355 static int skeleton_rawdev_set_attr(struct rte_rawdev *dev,
356 const char *attr_name,
357 const uint64_t attr_value)
361 struct skeleton_rawdev *skeldev;
363 SKELETON_PMD_FUNC_TRACE();
365 if (!dev || !attr_name) {
366 SKELETON_PMD_ERR("Invalid arguments for setting attributes");
370 skeldev = skeleton_rawdev_get_priv(dev);
372 /* Check if attribute already exists */
373 for (i = 0; i < SKELETON_MAX_ATTRIBUTES; i++) {
374 if (!skeldev->attr[i].name)
377 if (!strncmp(skeldev->attr[i].name, attr_name,
378 SKELETON_ATTRIBUTE_NAME_MAX)) {
380 skeldev->attr[i].value = attr_value;
387 if (i < (SKELETON_MAX_ATTRIBUTES - 1)) {
388 /* There is still space to insert one more */
389 skeldev->attr[i].name = strdup(attr_name);
390 if (!skeldev->attr[i].name)
393 skeldev->attr[i].value = attr_value;
401 static int skeleton_rawdev_enqueue_bufs(struct rte_rawdev *dev,
402 struct rte_rawdev_buf **buffers,
404 rte_rawdev_obj_t context)
410 /* context is essentially the queue_id which is
411 * transferred as opaque object through the library layer. This can
412 * help in complex implementation which require more information than
413 * just an integer - for example, a queue-pair.
415 q_id = *((int *)context);
417 for (i = 0; i < count; i++)
418 queue_buf[q_id].bufs[i] = buffers[i]->buf_addr;
423 static int skeleton_rawdev_dequeue_bufs(struct rte_rawdev *dev,
424 struct rte_rawdev_buf **buffers,
426 rte_rawdev_obj_t context)
432 /* context is essentially the queue_id which is
433 * transferred as opaque object through the library layer. This can
434 * help in complex implementation which require more information than
435 * just an integer - for example, a queue-pair.
437 q_id = *((int *)context);
439 for (i = 0; i < count; i++)
440 buffers[i]->buf_addr = queue_buf[q_id].bufs[i];
445 static int skeleton_rawdev_dump(struct rte_rawdev *dev, FILE *f)
453 static int skeleton_rawdev_firmware_status_get(struct rte_rawdev *dev,
454 rte_rawdev_obj_t status_info)
456 struct skeleton_rawdev *skeldev;
458 SKELETON_PMD_FUNC_TRACE();
460 skeldev = skeleton_rawdev_get_priv(dev);
462 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
465 memcpy(status_info, &skeldev->fw.firmware_state,
466 sizeof(enum skeleton_firmware_state));
472 static int skeleton_rawdev_firmware_version_get(
473 struct rte_rawdev *dev,
474 rte_rawdev_obj_t version_info)
476 struct skeleton_rawdev *skeldev;
477 struct skeleton_firmware_version_info *vi;
479 SKELETON_PMD_FUNC_TRACE();
481 skeldev = skeleton_rawdev_get_priv(dev);
484 vi->major = skeldev->fw.firmware_version.major;
485 vi->minor = skeldev->fw.firmware_version.minor;
486 vi->subrel = skeldev->fw.firmware_version.subrel;
491 static int skeleton_rawdev_firmware_load(struct rte_rawdev *dev,
492 rte_rawdev_obj_t firmware_buf)
494 struct skeleton_rawdev *skeldev;
496 SKELETON_PMD_FUNC_TRACE();
498 skeldev = skeleton_rawdev_get_priv(dev);
500 /* firmware_buf is a mmaped, possibly DMA'able area, buffer. Being
501 * dummy, all this does is check if firmware_buf is not NULL and
502 * sets the state of the firmware.
507 skeldev->fw.firmware_state = SKELETON_FW_LOADED;
512 static int skeleton_rawdev_firmware_unload(struct rte_rawdev *dev)
514 struct skeleton_rawdev *skeldev;
516 SKELETON_PMD_FUNC_TRACE();
518 skeldev = skeleton_rawdev_get_priv(dev);
520 skeldev->fw.firmware_state = SKELETON_FW_READY;
525 static const struct rte_rawdev_ops skeleton_rawdev_ops = {
526 .dev_info_get = skeleton_rawdev_info_get,
527 .dev_configure = skeleton_rawdev_configure,
528 .dev_start = skeleton_rawdev_start,
529 .dev_stop = skeleton_rawdev_stop,
530 .dev_close = skeleton_rawdev_close,
531 .dev_reset = skeleton_rawdev_reset,
533 .queue_def_conf = skeleton_rawdev_queue_def_conf,
534 .queue_setup = skeleton_rawdev_queue_setup,
535 .queue_release = skeleton_rawdev_queue_release,
536 .queue_count = skeleton_rawdev_queue_count,
538 .attr_get = skeleton_rawdev_get_attr,
539 .attr_set = skeleton_rawdev_set_attr,
541 .enqueue_bufs = skeleton_rawdev_enqueue_bufs,
542 .dequeue_bufs = skeleton_rawdev_dequeue_bufs,
544 .dump = skeleton_rawdev_dump,
547 .xstats_get_names = NULL,
548 .xstats_get_by_name = NULL,
549 .xstats_reset = NULL,
551 .firmware_status_get = skeleton_rawdev_firmware_status_get,
552 .firmware_version_get = skeleton_rawdev_firmware_version_get,
553 .firmware_load = skeleton_rawdev_firmware_load,
554 .firmware_unload = skeleton_rawdev_firmware_unload,
556 .dev_selftest = test_rawdev_skeldev,
560 skeleton_rawdev_create(const char *name,
561 struct rte_vdev_device *vdev,
565 struct rte_rawdev *rawdev = NULL;
566 struct skeleton_rawdev *skeldev = NULL;
569 SKELETON_PMD_ERR("Invalid name of the device!");
574 /* Allocate device structure */
575 rawdev = rte_rawdev_pmd_allocate(name, sizeof(struct skeleton_rawdev),
577 if (rawdev == NULL) {
578 SKELETON_PMD_ERR("Unable to allocate rawdevice");
583 ret = rawdev->dev_id; /* return the rawdev id of new device */
585 rawdev->dev_ops = &skeleton_rawdev_ops;
586 rawdev->device = &vdev->device;
588 skeldev = skeleton_rawdev_get_priv(rawdev);
590 skeldev->device_id = SKELETON_DEVICE_ID;
591 skeldev->vendor_id = SKELETON_VENDOR_ID;
592 skeldev->capabilities = SKELETON_DEFAULT_CAPA;
594 memset(&skeldev->fw, 0, sizeof(struct skeleton_firmware));
596 skeldev->fw.firmware_state = SKELETON_FW_READY;
597 skeldev->fw.firmware_version.major = SKELETON_MAJOR_VER;
598 skeldev->fw.firmware_version.minor = SKELETON_MINOR_VER;
599 skeldev->fw.firmware_version.subrel = SKELETON_SUB_VER;
601 skeldev->device_state = SKELETON_DEV_STOPPED;
603 /* Reset/set to default queue configuration for this device */
604 for (i = 0; i < SKELETON_MAX_QUEUES; i++) {
605 skeldev->queues[i].state = SKELETON_QUEUE_DETACH;
606 skeldev->queues[i].depth = SKELETON_QUEUE_DEF_DEPTH;
609 /* Clear all allocated queue buffers */
610 for (i = 0; i < SKELETON_MAX_QUEUES; i++)
617 rte_rawdev_pmd_release(rawdev);
623 skeleton_rawdev_destroy(const char *name)
626 struct rte_rawdev *rdev;
629 SKELETON_PMD_ERR("Invalid device name");
633 rdev = rte_rawdev_pmd_get_named_dev(name);
635 SKELETON_PMD_ERR("Invalid device name (%s)", name);
639 /* rte_rawdev_close is called by pmd_release */
640 ret = rte_rawdev_pmd_release(rdev);
642 SKELETON_PMD_DEBUG("Device cleanup failed");
648 skeldev_get_selftest(const char *key __rte_unused,
658 skeldev_parse_vdev_args(struct rte_vdev_device *vdev)
664 static const char *const args[] = {
665 SKELETON_SELFTEST_ARG,
669 name = rte_vdev_device_name(vdev);
671 params = rte_vdev_device_args(vdev);
672 if (params != NULL && params[0] != '\0') {
673 struct rte_kvargs *kvlist = rte_kvargs_parse(params, args);
677 "Ignoring unsupported params supplied '%s'",
680 int ret = rte_kvargs_process(kvlist,
681 SKELETON_SELFTEST_ARG,
682 skeldev_get_selftest, &selftest);
683 if (ret != 0 || (selftest < 0 || selftest > 1)) {
684 SKELETON_PMD_ERR("%s: Error in parsing args",
686 rte_kvargs_free(kvlist);
687 ret = -1; /* enforce if selftest is invalid */
692 rte_kvargs_free(kvlist);
699 skeleton_rawdev_probe(struct rte_vdev_device *vdev)
702 int selftest = 0, ret = 0;
705 name = rte_vdev_device_name(vdev);
709 /* More than one instance is not supported */
710 if (skeldev_init_once) {
711 SKELETON_PMD_ERR("Multiple instance not supported for %s",
716 SKELETON_PMD_INFO("Init %s on NUMA node %d", name, rte_socket_id());
718 selftest = skeldev_parse_vdev_args(vdev);
719 /* In case of invalid argument, selftest != 1; ignore other values */
721 ret = skeleton_rawdev_create(name, vdev, rte_socket_id());
723 /* In case command line argument for 'selftest' was passed;
724 * if invalid arguments were passed, execution continues but
728 test_rawdev_skeldev(ret);
731 /* Device instance created; Second instance not possible */
732 skeldev_init_once = 1;
734 return ret < 0 ? ret : 0;
738 skeleton_rawdev_remove(struct rte_vdev_device *vdev)
743 name = rte_vdev_device_name(vdev);
747 SKELETON_PMD_INFO("Closing %s on NUMA node %d", name, rte_socket_id());
749 ret = skeleton_rawdev_destroy(name);
751 skeldev_init_once = 0;
756 static struct rte_vdev_driver skeleton_pmd_drv = {
757 .probe = skeleton_rawdev_probe,
758 .remove = skeleton_rawdev_remove
761 RTE_PMD_REGISTER_VDEV(SKELETON_PMD_RAWDEV_NAME, skeleton_pmd_drv);
763 RTE_INIT(skeleton_pmd_init_log)
765 skeleton_pmd_logtype = rte_log_register("rawdev.skeleton");
766 if (skeleton_pmd_logtype >= 0)
767 rte_log_set_level(skeleton_pmd_logtype, RTE_LOG_INFO);