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 /* Count of instances */
32 static uint16_t skeldev_init_once;
34 /**< Rawdev Skeleton dummy driver name */
35 #define SKELETON_PMD_RAWDEV_NAME rawdev_skeleton
37 struct queue_buffers {
38 void *bufs[SKELETON_QUEUE_MAX_DEPTH];
41 static struct queue_buffers queue_buf[SKELETON_MAX_QUEUES] = {};
42 static void clear_queue_bufs(int queue_id);
44 static int skeleton_rawdev_info_get(struct rte_rawdev *dev,
45 rte_rawdev_obj_t dev_info,
48 struct skeleton_rawdev *skeldev;
49 struct skeleton_rawdev_conf *skeldev_conf;
51 SKELETON_PMD_FUNC_TRACE();
53 if (!dev_info || dev_info_size != sizeof(*skeldev_conf)) {
54 SKELETON_PMD_ERR("Invalid request");
58 skeldev = skeleton_rawdev_get_priv(dev);
60 skeldev_conf = dev_info;
62 skeldev_conf->num_queues = skeldev->num_queues;
63 skeldev_conf->capabilities = skeldev->capabilities;
64 skeldev_conf->device_state = skeldev->device_state;
65 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,
74 struct skeleton_rawdev *skeldev;
75 struct skeleton_rawdev_conf *skeldev_conf;
77 SKELETON_PMD_FUNC_TRACE();
79 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
81 if (config == NULL || config_size != sizeof(*skeldev_conf)) {
82 SKELETON_PMD_ERR("Invalid configuration");
86 skeldev_conf = config;
87 skeldev = skeleton_rawdev_get_priv(dev);
89 if (skeldev_conf->num_queues <= SKELETON_MAX_QUEUES)
90 skeldev->num_queues = skeldev_conf->num_queues;
94 skeldev->capabilities = skeldev_conf->capabilities;
95 skeldev->num_queues = skeldev_conf->num_queues;
100 static int skeleton_rawdev_start(struct rte_rawdev *dev)
103 struct skeleton_rawdev *skeldev;
104 enum skeleton_firmware_state fw_state;
105 enum skeleton_device_state device_state;
107 SKELETON_PMD_FUNC_TRACE();
109 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
111 skeldev = skeleton_rawdev_get_priv(dev);
113 fw_state = skeldev->fw.firmware_state;
114 device_state = skeldev->device_state;
116 if (fw_state == SKELETON_FW_LOADED &&
117 device_state == SKELETON_DEV_STOPPED) {
118 skeldev->device_state = SKELETON_DEV_RUNNING;
120 SKELETON_PMD_ERR("Device not ready for starting");
127 static void skeleton_rawdev_stop(struct rte_rawdev *dev)
129 struct skeleton_rawdev *skeldev;
131 SKELETON_PMD_FUNC_TRACE();
134 skeldev = skeleton_rawdev_get_priv(dev);
135 skeldev->device_state = SKELETON_DEV_STOPPED;
140 reset_queues(struct skeleton_rawdev *skeldev)
144 for (i = 0; i < SKELETON_MAX_QUEUES; i++) {
145 skeldev->queues[i].depth = SKELETON_QUEUE_DEF_DEPTH;
146 skeldev->queues[i].state = SKELETON_QUEUE_DETACH;
151 reset_attribute_table(struct skeleton_rawdev *skeldev)
155 for (i = 0; i < SKELETON_MAX_ATTRIBUTES; i++) {
156 if (skeldev->attr[i].name) {
157 free(skeldev->attr[i].name);
158 skeldev->attr[i].name = NULL;
163 static int skeleton_rawdev_close(struct rte_rawdev *dev)
166 struct skeleton_rawdev *skeldev;
167 enum skeleton_firmware_state fw_state;
168 enum skeleton_device_state device_state;
170 SKELETON_PMD_FUNC_TRACE();
172 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
174 skeldev = skeleton_rawdev_get_priv(dev);
176 fw_state = skeldev->fw.firmware_state;
177 device_state = skeldev->device_state;
179 reset_queues(skeldev);
180 reset_attribute_table(skeldev);
183 case SKELETON_FW_LOADED:
184 if (device_state == SKELETON_DEV_RUNNING) {
185 SKELETON_PMD_ERR("Cannot close running device");
188 /* Probably call fw reset here */
189 skeldev->fw.firmware_state = SKELETON_FW_READY;
192 case SKELETON_FW_READY:
193 case SKELETON_FW_ERROR:
195 SKELETON_PMD_DEBUG("Device already in stopped state");
200 /* Clear all allocated queues */
201 for (i = 0; i < SKELETON_MAX_QUEUES; i++)
207 static int skeleton_rawdev_reset(struct rte_rawdev *dev)
209 struct skeleton_rawdev *skeldev;
211 SKELETON_PMD_FUNC_TRACE();
213 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
215 skeldev = skeleton_rawdev_get_priv(dev);
217 SKELETON_PMD_DEBUG("Resetting device");
218 skeldev->fw.firmware_state = SKELETON_FW_READY;
223 static int skeleton_rawdev_queue_def_conf(struct rte_rawdev *dev,
225 rte_rawdev_obj_t queue_conf,
228 struct skeleton_rawdev *skeldev;
229 struct skeleton_rawdev_queue *skelq;
231 SKELETON_PMD_FUNC_TRACE();
233 if (!dev || !queue_conf ||
234 conf_size != sizeof(struct skeleton_rawdev_queue))
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));
248 clear_queue_bufs(int queue_id)
252 /* Clear buffers for queue_id */
253 for (i = 0; i < SKELETON_QUEUE_MAX_DEPTH; i++)
254 queue_buf[queue_id].bufs[i] = NULL;
257 static int skeleton_rawdev_queue_setup(struct rte_rawdev *dev,
259 rte_rawdev_obj_t queue_conf,
263 struct skeleton_rawdev *skeldev;
264 struct skeleton_rawdev_queue *q;
266 SKELETON_PMD_FUNC_TRACE();
268 if (!dev || !queue_conf ||
269 conf_size != sizeof(struct skeleton_rawdev_queue))
272 skeldev = skeleton_rawdev_get_priv(dev);
273 q = &skeldev->queues[queue_id];
275 if (skeldev->num_queues > queue_id &&
276 q->depth < SKELETON_QUEUE_MAX_DEPTH) {
277 rte_memcpy(q, queue_conf,
278 sizeof(struct skeleton_rawdev_queue));
279 clear_queue_bufs(queue_id);
281 SKELETON_PMD_ERR("Invalid queue configuration");
288 static int skeleton_rawdev_queue_release(struct rte_rawdev *dev,
292 struct skeleton_rawdev *skeldev;
294 SKELETON_PMD_FUNC_TRACE();
296 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
298 skeldev = skeleton_rawdev_get_priv(dev);
300 if (skeldev->num_queues > queue_id) {
301 skeldev->queues[queue_id].state = SKELETON_QUEUE_DETACH;
302 skeldev->queues[queue_id].depth = SKELETON_QUEUE_DEF_DEPTH;
303 clear_queue_bufs(queue_id);
305 SKELETON_PMD_ERR("Invalid queue configuration");
312 static uint16_t skeleton_rawdev_queue_count(struct rte_rawdev *dev)
314 struct skeleton_rawdev *skeldev;
316 SKELETON_PMD_FUNC_TRACE();
318 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
320 skeldev = skeleton_rawdev_get_priv(dev);
321 return skeldev->num_queues;
324 static int skeleton_rawdev_get_attr(struct rte_rawdev *dev,
325 const char *attr_name,
326 uint64_t *attr_value)
330 struct skeleton_rawdev *skeldev;
332 SKELETON_PMD_FUNC_TRACE();
334 if (!dev || !attr_name || !attr_value) {
335 SKELETON_PMD_ERR("Invalid arguments for getting attributes");
339 skeldev = skeleton_rawdev_get_priv(dev);
341 for (i = 0; i < SKELETON_MAX_ATTRIBUTES; i++) {
342 if (!skeldev->attr[i].name)
345 if (!strncmp(skeldev->attr[i].name, attr_name,
346 SKELETON_ATTRIBUTE_NAME_MAX)) {
347 *attr_value = skeldev->attr[i].value;
349 SKELETON_PMD_DEBUG("Attribute (%s) Value (%" PRIu64 ")",
350 attr_name, *attr_value);
358 /* Attribute not found */
362 static int skeleton_rawdev_set_attr(struct rte_rawdev *dev,
363 const char *attr_name,
364 const uint64_t attr_value)
368 struct skeleton_rawdev *skeldev;
370 SKELETON_PMD_FUNC_TRACE();
372 if (!dev || !attr_name) {
373 SKELETON_PMD_ERR("Invalid arguments for setting attributes");
377 skeldev = skeleton_rawdev_get_priv(dev);
379 /* Check if attribute already exists */
380 for (i = 0; i < SKELETON_MAX_ATTRIBUTES; i++) {
381 if (!skeldev->attr[i].name)
384 if (!strncmp(skeldev->attr[i].name, attr_name,
385 SKELETON_ATTRIBUTE_NAME_MAX)) {
387 skeldev->attr[i].value = attr_value;
394 if (i < (SKELETON_MAX_ATTRIBUTES - 1)) {
395 /* There is still space to insert one more */
396 skeldev->attr[i].name = strdup(attr_name);
397 if (!skeldev->attr[i].name)
400 skeldev->attr[i].value = attr_value;
408 static int skeleton_rawdev_enqueue_bufs(struct rte_rawdev *dev,
409 struct rte_rawdev_buf **buffers,
411 rte_rawdev_obj_t context)
417 /* context is essentially the queue_id which is
418 * transferred as opaque object through the library layer. This can
419 * help in complex implementation which require more information than
420 * just an integer - for example, a queue-pair.
422 q_id = *((int *)context);
424 for (i = 0; i < count; i++)
425 queue_buf[q_id].bufs[i] = buffers[i]->buf_addr;
430 static int skeleton_rawdev_dequeue_bufs(struct rte_rawdev *dev,
431 struct rte_rawdev_buf **buffers,
433 rte_rawdev_obj_t context)
439 /* context is essentially the queue_id which is
440 * transferred as opaque object through the library layer. This can
441 * help in complex implementation which require more information than
442 * just an integer - for example, a queue-pair.
444 q_id = *((int *)context);
446 for (i = 0; i < count; i++)
447 buffers[i]->buf_addr = queue_buf[q_id].bufs[i];
452 static int skeleton_rawdev_dump(struct rte_rawdev *dev, FILE *f)
460 static int skeleton_rawdev_firmware_status_get(struct rte_rawdev *dev,
461 rte_rawdev_obj_t status_info)
463 struct skeleton_rawdev *skeldev;
465 SKELETON_PMD_FUNC_TRACE();
467 skeldev = skeleton_rawdev_get_priv(dev);
469 RTE_FUNC_PTR_OR_ERR_RET(dev, -EINVAL);
472 memcpy(status_info, &skeldev->fw.firmware_state,
473 sizeof(enum skeleton_firmware_state));
479 static int skeleton_rawdev_firmware_version_get(
480 struct rte_rawdev *dev,
481 rte_rawdev_obj_t version_info)
483 struct skeleton_rawdev *skeldev;
484 struct skeleton_firmware_version_info *vi;
486 SKELETON_PMD_FUNC_TRACE();
488 skeldev = skeleton_rawdev_get_priv(dev);
491 vi->major = skeldev->fw.firmware_version.major;
492 vi->minor = skeldev->fw.firmware_version.minor;
493 vi->subrel = skeldev->fw.firmware_version.subrel;
498 static int skeleton_rawdev_firmware_load(struct rte_rawdev *dev,
499 rte_rawdev_obj_t firmware_buf)
501 struct skeleton_rawdev *skeldev;
503 SKELETON_PMD_FUNC_TRACE();
505 skeldev = skeleton_rawdev_get_priv(dev);
507 /* firmware_buf is a mmaped, possibly DMA'able area, buffer. Being
508 * dummy, all this does is check if firmware_buf is not NULL and
509 * sets the state of the firmware.
514 skeldev->fw.firmware_state = SKELETON_FW_LOADED;
519 static int skeleton_rawdev_firmware_unload(struct rte_rawdev *dev)
521 struct skeleton_rawdev *skeldev;
523 SKELETON_PMD_FUNC_TRACE();
525 skeldev = skeleton_rawdev_get_priv(dev);
527 skeldev->fw.firmware_state = SKELETON_FW_READY;
532 static const struct rte_rawdev_ops skeleton_rawdev_ops = {
533 .dev_info_get = skeleton_rawdev_info_get,
534 .dev_configure = skeleton_rawdev_configure,
535 .dev_start = skeleton_rawdev_start,
536 .dev_stop = skeleton_rawdev_stop,
537 .dev_close = skeleton_rawdev_close,
538 .dev_reset = skeleton_rawdev_reset,
540 .queue_def_conf = skeleton_rawdev_queue_def_conf,
541 .queue_setup = skeleton_rawdev_queue_setup,
542 .queue_release = skeleton_rawdev_queue_release,
543 .queue_count = skeleton_rawdev_queue_count,
545 .attr_get = skeleton_rawdev_get_attr,
546 .attr_set = skeleton_rawdev_set_attr,
548 .enqueue_bufs = skeleton_rawdev_enqueue_bufs,
549 .dequeue_bufs = skeleton_rawdev_dequeue_bufs,
551 .dump = skeleton_rawdev_dump,
554 .xstats_get_names = NULL,
555 .xstats_get_by_name = NULL,
556 .xstats_reset = NULL,
558 .firmware_status_get = skeleton_rawdev_firmware_status_get,
559 .firmware_version_get = skeleton_rawdev_firmware_version_get,
560 .firmware_load = skeleton_rawdev_firmware_load,
561 .firmware_unload = skeleton_rawdev_firmware_unload,
563 .dev_selftest = test_rawdev_skeldev,
567 skeleton_rawdev_create(const char *name,
568 struct rte_vdev_device *vdev,
572 struct rte_rawdev *rawdev = NULL;
573 struct skeleton_rawdev *skeldev = NULL;
576 SKELETON_PMD_ERR("Invalid name of the device!");
581 /* Allocate device structure */
582 rawdev = rte_rawdev_pmd_allocate(name, sizeof(struct skeleton_rawdev),
584 if (rawdev == NULL) {
585 SKELETON_PMD_ERR("Unable to allocate rawdevice");
590 ret = rawdev->dev_id; /* return the rawdev id of new device */
592 rawdev->dev_ops = &skeleton_rawdev_ops;
593 rawdev->device = &vdev->device;
595 skeldev = skeleton_rawdev_get_priv(rawdev);
597 skeldev->device_id = SKELETON_DEVICE_ID;
598 skeldev->vendor_id = SKELETON_VENDOR_ID;
599 skeldev->capabilities = SKELETON_DEFAULT_CAPA;
601 memset(&skeldev->fw, 0, sizeof(struct skeleton_firmware));
603 skeldev->fw.firmware_state = SKELETON_FW_READY;
604 skeldev->fw.firmware_version.major = SKELETON_MAJOR_VER;
605 skeldev->fw.firmware_version.minor = SKELETON_MINOR_VER;
606 skeldev->fw.firmware_version.subrel = SKELETON_SUB_VER;
608 skeldev->device_state = SKELETON_DEV_STOPPED;
610 /* Reset/set to default queue configuration for this device */
611 for (i = 0; i < SKELETON_MAX_QUEUES; i++) {
612 skeldev->queues[i].state = SKELETON_QUEUE_DETACH;
613 skeldev->queues[i].depth = SKELETON_QUEUE_DEF_DEPTH;
616 /* Clear all allocated queue buffers */
617 for (i = 0; i < SKELETON_MAX_QUEUES; i++)
624 rte_rawdev_pmd_release(rawdev);
630 skeleton_rawdev_destroy(const char *name)
633 struct rte_rawdev *rdev;
636 SKELETON_PMD_ERR("Invalid device name");
640 rdev = rte_rawdev_pmd_get_named_dev(name);
642 SKELETON_PMD_ERR("Invalid device name (%s)", name);
646 /* rte_rawdev_close is called by pmd_release */
647 ret = rte_rawdev_pmd_release(rdev);
649 SKELETON_PMD_DEBUG("Device cleanup failed");
655 skeldev_get_selftest(const char *key __rte_unused,
665 skeldev_parse_vdev_args(struct rte_vdev_device *vdev)
671 static const char *const args[] = {
672 SKELETON_SELFTEST_ARG,
676 name = rte_vdev_device_name(vdev);
678 params = rte_vdev_device_args(vdev);
679 if (params != NULL && params[0] != '\0') {
680 struct rte_kvargs *kvlist = rte_kvargs_parse(params, args);
684 "Ignoring unsupported params supplied '%s'",
687 int ret = rte_kvargs_process(kvlist,
688 SKELETON_SELFTEST_ARG,
689 skeldev_get_selftest, &selftest);
690 if (ret != 0 || (selftest < 0 || selftest > 1)) {
691 SKELETON_PMD_ERR("%s: Error in parsing args",
693 rte_kvargs_free(kvlist);
694 ret = -1; /* enforce if selftest is invalid */
699 rte_kvargs_free(kvlist);
706 skeleton_rawdev_probe(struct rte_vdev_device *vdev)
709 int selftest = 0, ret = 0;
712 name = rte_vdev_device_name(vdev);
716 /* More than one instance is not supported */
717 if (skeldev_init_once) {
718 SKELETON_PMD_ERR("Multiple instance not supported for %s",
723 SKELETON_PMD_INFO("Init %s on NUMA node %d", name, rte_socket_id());
725 selftest = skeldev_parse_vdev_args(vdev);
726 /* In case of invalid argument, selftest != 1; ignore other values */
728 ret = skeleton_rawdev_create(name, vdev, rte_socket_id());
730 /* In case command line argument for 'selftest' was passed;
731 * if invalid arguments were passed, execution continues but
735 test_rawdev_skeldev(ret);
738 /* Device instance created; Second instance not possible */
739 skeldev_init_once = 1;
741 return ret < 0 ? ret : 0;
745 skeleton_rawdev_remove(struct rte_vdev_device *vdev)
750 name = rte_vdev_device_name(vdev);
754 SKELETON_PMD_INFO("Closing %s on NUMA node %d", name, rte_socket_id());
756 ret = skeleton_rawdev_destroy(name);
758 skeldev_init_once = 0;
763 static struct rte_vdev_driver skeleton_pmd_drv = {
764 .probe = skeleton_rawdev_probe,
765 .remove = skeleton_rawdev_remove
768 RTE_PMD_REGISTER_VDEV(SKELETON_PMD_RAWDEV_NAME, skeleton_pmd_drv);
769 RTE_LOG_REGISTER(skeleton_pmd_logtype, rawdev.skeleton, INFO);