1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright 2017 NXP
3 */
4
5 #include <assert.h>
6 #include <stdio.h>
7 #include <stdbool.h>
8 #include <stdlib.h>
9 #include <errno.h>
10 #include <stdint.h>
11 #include <inttypes.h>
12 #include <string.h>
13
14 #include <rte_byteorder.h>
15 #include <rte_common.h>
16 #include <rte_debug.h>
17 #include <dev_driver.h>
18 #include <rte_eal.h>
19 #include <rte_kvargs.h>
20 #include <rte_log.h>
21 #include <rte_malloc.h>
22 #include <rte_memory.h>
23 #include <rte_memcpy.h>
24 #include <rte_lcore.h>
25 #include <bus_vdev_driver.h>
26
27 #include <rte_rawdev.h>
28 #include <rte_rawdev_pmd.h>
29
30 #include "skeleton_rawdev.h"
31
32 /* Count of instances */
33 static uint16_t skeldev_init_once;
34
35 /**< Rawdev Skeleton dummy driver name */
36 #define SKELETON_PMD_RAWDEV_NAME rawdev_skeleton
37
38 struct queue_buffers {
39 void *bufs[SKELETON_QUEUE_MAX_DEPTH];
40 };
41
42 static struct queue_buffers queue_buf[SKELETON_MAX_QUEUES] = {};
43 static void clear_queue_bufs(int queue_id);
44
skeleton_rawdev_info_get(struct rte_rawdev * dev,rte_rawdev_obj_t dev_info,size_t dev_info_size)45 static int skeleton_rawdev_info_get(struct rte_rawdev *dev,
46 rte_rawdev_obj_t dev_info,
47 size_t dev_info_size)
48 {
49 struct skeleton_rawdev *skeldev;
50 struct skeleton_rawdev_conf *skeldev_conf;
51
52 SKELETON_PMD_FUNC_TRACE();
53
54 if (!dev_info || dev_info_size != sizeof(*skeldev_conf)) {
55 SKELETON_PMD_ERR("Invalid request");
56 return -EINVAL;
57 }
58
59 skeldev = skeleton_rawdev_get_priv(dev);
60
61 skeldev_conf = dev_info;
62
63 skeldev_conf->num_queues = skeldev->num_queues;
64 skeldev_conf->capabilities = skeldev->capabilities;
65 skeldev_conf->device_state = skeldev->device_state;
66 skeldev_conf->firmware_state = skeldev->fw.firmware_state;
67
68 return 0;
69 }
70
skeleton_rawdev_configure(const struct rte_rawdev * dev,rte_rawdev_obj_t config,size_t config_size)71 static int skeleton_rawdev_configure(const struct rte_rawdev *dev,
72 rte_rawdev_obj_t config,
73 size_t config_size)
74 {
75 struct skeleton_rawdev *skeldev;
76 struct skeleton_rawdev_conf *skeldev_conf;
77
78 SKELETON_PMD_FUNC_TRACE();
79
80 if (dev == NULL)
81 return -EINVAL;
82
83 if (config == NULL || config_size != sizeof(*skeldev_conf)) {
84 SKELETON_PMD_ERR("Invalid configuration");
85 return -EINVAL;
86 }
87
88 skeldev_conf = config;
89 skeldev = skeleton_rawdev_get_priv(dev);
90
91 if (skeldev_conf->num_queues <= SKELETON_MAX_QUEUES)
92 skeldev->num_queues = skeldev_conf->num_queues;
93 else
94 return -EINVAL;
95
96 skeldev->capabilities = skeldev_conf->capabilities;
97 skeldev->num_queues = skeldev_conf->num_queues;
98
99 return 0;
100 }
101
skeleton_rawdev_start(struct rte_rawdev * dev)102 static int skeleton_rawdev_start(struct rte_rawdev *dev)
103 {
104 int ret = 0;
105 struct skeleton_rawdev *skeldev;
106 enum skeleton_firmware_state fw_state;
107 enum skeleton_device_state device_state;
108
109 SKELETON_PMD_FUNC_TRACE();
110
111 if (dev == NULL)
112 return -EINVAL;
113
114 skeldev = skeleton_rawdev_get_priv(dev);
115
116 fw_state = skeldev->fw.firmware_state;
117 device_state = skeldev->device_state;
118
119 if (fw_state == SKELETON_FW_LOADED &&
120 device_state == SKELETON_DEV_STOPPED) {
121 skeldev->device_state = SKELETON_DEV_RUNNING;
122 } else {
123 SKELETON_PMD_ERR("Device not ready for starting");
124 ret = -EINVAL;
125 }
126
127 return ret;
128 }
129
skeleton_rawdev_stop(struct rte_rawdev * dev)130 static void skeleton_rawdev_stop(struct rte_rawdev *dev)
131 {
132 struct skeleton_rawdev *skeldev;
133
134 SKELETON_PMD_FUNC_TRACE();
135
136 if (dev) {
137 skeldev = skeleton_rawdev_get_priv(dev);
138 skeldev->device_state = SKELETON_DEV_STOPPED;
139 }
140 }
141
142 static void
reset_queues(struct skeleton_rawdev * skeldev)143 reset_queues(struct skeleton_rawdev *skeldev)
144 {
145 int i;
146
147 for (i = 0; i < SKELETON_MAX_QUEUES; i++) {
148 skeldev->queues[i].depth = SKELETON_QUEUE_DEF_DEPTH;
149 skeldev->queues[i].state = SKELETON_QUEUE_DETACH;
150 }
151 }
152
153 static void
reset_attribute_table(struct skeleton_rawdev * skeldev)154 reset_attribute_table(struct skeleton_rawdev *skeldev)
155 {
156 int i;
157
158 for (i = 0; i < SKELETON_MAX_ATTRIBUTES; i++) {
159 if (skeldev->attr[i].name) {
160 free(skeldev->attr[i].name);
161 skeldev->attr[i].name = NULL;
162 }
163 }
164 }
165
skeleton_rawdev_close(struct rte_rawdev * dev)166 static int skeleton_rawdev_close(struct rte_rawdev *dev)
167 {
168 int ret = 0, i;
169 struct skeleton_rawdev *skeldev;
170 enum skeleton_firmware_state fw_state;
171 enum skeleton_device_state device_state;
172
173 SKELETON_PMD_FUNC_TRACE();
174
175 if (dev == NULL)
176 return -EINVAL;
177
178 skeldev = skeleton_rawdev_get_priv(dev);
179
180 fw_state = skeldev->fw.firmware_state;
181 device_state = skeldev->device_state;
182
183 reset_queues(skeldev);
184 reset_attribute_table(skeldev);
185
186 switch (fw_state) {
187 case SKELETON_FW_LOADED:
188 if (device_state == SKELETON_DEV_RUNNING) {
189 SKELETON_PMD_ERR("Cannot close running device");
190 ret = -EINVAL;
191 } else {
192 /* Probably call fw reset here */
193 skeldev->fw.firmware_state = SKELETON_FW_READY;
194 }
195 break;
196 case SKELETON_FW_READY:
197 SKELETON_PMD_DEBUG("Device already in stopped state");
198 break;
199 case SKELETON_FW_ERROR:
200 default:
201 SKELETON_PMD_DEBUG("Device in impossible state");
202 ret = -EINVAL;
203 break;
204 }
205
206 /* Clear all allocated queues */
207 for (i = 0; i < SKELETON_MAX_QUEUES; i++)
208 clear_queue_bufs(i);
209
210 return ret;
211 }
212
skeleton_rawdev_reset(struct rte_rawdev * dev)213 static int skeleton_rawdev_reset(struct rte_rawdev *dev)
214 {
215 struct skeleton_rawdev *skeldev;
216
217 SKELETON_PMD_FUNC_TRACE();
218
219 if (dev == NULL)
220 return -EINVAL;
221
222 skeldev = skeleton_rawdev_get_priv(dev);
223
224 SKELETON_PMD_DEBUG("Resetting device");
225 skeldev->fw.firmware_state = SKELETON_FW_READY;
226
227 return 0;
228 }
229
skeleton_rawdev_queue_def_conf(struct rte_rawdev * dev,uint16_t queue_id,rte_rawdev_obj_t queue_conf,size_t conf_size)230 static int skeleton_rawdev_queue_def_conf(struct rte_rawdev *dev,
231 uint16_t queue_id,
232 rte_rawdev_obj_t queue_conf,
233 size_t conf_size)
234 {
235 struct skeleton_rawdev *skeldev;
236 struct skeleton_rawdev_queue *skelq;
237
238 SKELETON_PMD_FUNC_TRACE();
239
240 if (!dev || !queue_conf ||
241 conf_size != sizeof(struct skeleton_rawdev_queue))
242 return -EINVAL;
243
244 skeldev = skeleton_rawdev_get_priv(dev);
245 skelq = &skeldev->queues[queue_id];
246
247 if (queue_id < SKELETON_MAX_QUEUES)
248 rte_memcpy(queue_conf, skelq,
249 sizeof(struct skeleton_rawdev_queue));
250
251 return 0;
252 }
253
254 static void
clear_queue_bufs(int queue_id)255 clear_queue_bufs(int queue_id)
256 {
257 int i;
258
259 /* Clear buffers for queue_id */
260 for (i = 0; i < SKELETON_QUEUE_MAX_DEPTH; i++)
261 queue_buf[queue_id].bufs[i] = NULL;
262 }
263
skeleton_rawdev_queue_setup(struct rte_rawdev * dev,uint16_t queue_id,rte_rawdev_obj_t queue_conf,size_t conf_size)264 static int skeleton_rawdev_queue_setup(struct rte_rawdev *dev,
265 uint16_t queue_id,
266 rte_rawdev_obj_t queue_conf,
267 size_t conf_size)
268 {
269 int ret = 0;
270 struct skeleton_rawdev *skeldev;
271 struct skeleton_rawdev_queue *q;
272
273 SKELETON_PMD_FUNC_TRACE();
274
275 if (!dev || !queue_conf ||
276 conf_size != sizeof(struct skeleton_rawdev_queue))
277 return -EINVAL;
278
279 skeldev = skeleton_rawdev_get_priv(dev);
280 q = &skeldev->queues[queue_id];
281
282 if (skeldev->num_queues > queue_id &&
283 q->depth < SKELETON_QUEUE_MAX_DEPTH) {
284 rte_memcpy(q, queue_conf,
285 sizeof(struct skeleton_rawdev_queue));
286 clear_queue_bufs(queue_id);
287 } else {
288 SKELETON_PMD_ERR("Invalid queue configuration");
289 ret = -EINVAL;
290 }
291
292 return ret;
293 }
294
skeleton_rawdev_queue_release(struct rte_rawdev * dev,uint16_t queue_id)295 static int skeleton_rawdev_queue_release(struct rte_rawdev *dev,
296 uint16_t queue_id)
297 {
298 int ret = 0;
299 struct skeleton_rawdev *skeldev;
300
301 SKELETON_PMD_FUNC_TRACE();
302
303 if (dev == NULL)
304 return -EINVAL;
305
306 skeldev = skeleton_rawdev_get_priv(dev);
307
308 if (skeldev->num_queues > queue_id) {
309 skeldev->queues[queue_id].state = SKELETON_QUEUE_DETACH;
310 skeldev->queues[queue_id].depth = SKELETON_QUEUE_DEF_DEPTH;
311 clear_queue_bufs(queue_id);
312 } else {
313 SKELETON_PMD_ERR("Invalid queue configuration");
314 ret = -EINVAL;
315 }
316
317 return ret;
318 }
319
skeleton_rawdev_queue_count(struct rte_rawdev * dev)320 static uint16_t skeleton_rawdev_queue_count(struct rte_rawdev *dev)
321 {
322 struct skeleton_rawdev *skeldev;
323
324 SKELETON_PMD_FUNC_TRACE();
325
326 if (dev == NULL)
327 return -EINVAL;
328
329 skeldev = skeleton_rawdev_get_priv(dev);
330 return skeldev->num_queues;
331 }
332
skeleton_rawdev_get_attr(struct rte_rawdev * dev,const char * attr_name,uint64_t * attr_value)333 static int skeleton_rawdev_get_attr(struct rte_rawdev *dev,
334 const char *attr_name,
335 uint64_t *attr_value)
336 {
337 int i;
338 uint8_t done = 0;
339 struct skeleton_rawdev *skeldev;
340
341 SKELETON_PMD_FUNC_TRACE();
342
343 if (!dev || !attr_name || !attr_value) {
344 SKELETON_PMD_ERR("Invalid arguments for getting attributes");
345 return -EINVAL;
346 }
347
348 skeldev = skeleton_rawdev_get_priv(dev);
349
350 for (i = 0; i < SKELETON_MAX_ATTRIBUTES; i++) {
351 if (!skeldev->attr[i].name)
352 continue;
353
354 if (!strncmp(skeldev->attr[i].name, attr_name,
355 SKELETON_ATTRIBUTE_NAME_MAX)) {
356 *attr_value = skeldev->attr[i].value;
357 done = 1;
358 SKELETON_PMD_DEBUG("Attribute (%s) Value (%" PRIu64 ")",
359 attr_name, *attr_value);
360 break;
361 }
362 }
363
364 if (done)
365 return 0;
366
367 /* Attribute not found */
368 return -EINVAL;
369 }
370
skeleton_rawdev_set_attr(struct rte_rawdev * dev,const char * attr_name,const uint64_t attr_value)371 static int skeleton_rawdev_set_attr(struct rte_rawdev *dev,
372 const char *attr_name,
373 const uint64_t attr_value)
374 {
375 int i;
376 uint8_t done = 0;
377 struct skeleton_rawdev *skeldev;
378
379 SKELETON_PMD_FUNC_TRACE();
380
381 if (!dev || !attr_name) {
382 SKELETON_PMD_ERR("Invalid arguments for setting attributes");
383 return -EINVAL;
384 }
385
386 skeldev = skeleton_rawdev_get_priv(dev);
387
388 /* Check if attribute already exists */
389 for (i = 0; i < SKELETON_MAX_ATTRIBUTES; i++) {
390 if (!skeldev->attr[i].name)
391 break;
392
393 if (!strncmp(skeldev->attr[i].name, attr_name,
394 SKELETON_ATTRIBUTE_NAME_MAX)) {
395 /* Update value */
396 skeldev->attr[i].value = attr_value;
397 done = 1;
398 break;
399 }
400 }
401
402 if (!done) {
403 if (i < (SKELETON_MAX_ATTRIBUTES - 1)) {
404 /* There is still space to insert one more */
405 skeldev->attr[i].name = strdup(attr_name);
406 if (!skeldev->attr[i].name)
407 return -ENOMEM;
408
409 skeldev->attr[i].value = attr_value;
410 return 0;
411 }
412 }
413
414 return -EINVAL;
415 }
416
skeleton_rawdev_enqueue_bufs(struct rte_rawdev * dev,struct rte_rawdev_buf ** buffers,unsigned int count,rte_rawdev_obj_t context)417 static int skeleton_rawdev_enqueue_bufs(struct rte_rawdev *dev,
418 struct rte_rawdev_buf **buffers,
419 unsigned int count,
420 rte_rawdev_obj_t context)
421 {
422 unsigned int i;
423 uint16_t q_id;
424 RTE_SET_USED(dev);
425
426 /* context is essentially the queue_id which is
427 * transferred as opaque object through the library layer. This can
428 * help in complex implementation which require more information than
429 * just an integer - for example, a queue-pair.
430 */
431 q_id = *((uint16_t *)context);
432
433 for (i = 0; i < count; i++)
434 queue_buf[q_id].bufs[i] = buffers[i]->buf_addr;
435
436 return i;
437 }
438
skeleton_rawdev_dequeue_bufs(struct rte_rawdev * dev,struct rte_rawdev_buf ** buffers,unsigned int count,rte_rawdev_obj_t context)439 static int skeleton_rawdev_dequeue_bufs(struct rte_rawdev *dev,
440 struct rte_rawdev_buf **buffers,
441 unsigned int count,
442 rte_rawdev_obj_t context)
443 {
444 unsigned int i;
445 uint16_t q_id;
446 RTE_SET_USED(dev);
447
448 /* context is essentially the queue_id which is
449 * transferred as opaque object through the library layer. This can
450 * help in complex implementation which require more information than
451 * just an integer - for example, a queue-pair.
452 */
453 q_id = *((uint16_t *)context);
454
455 for (i = 0; i < count; i++)
456 buffers[i]->buf_addr = queue_buf[q_id].bufs[i];
457
458 return i;
459 }
460
skeleton_rawdev_dump(struct rte_rawdev * dev,FILE * f)461 static int skeleton_rawdev_dump(struct rte_rawdev *dev, FILE *f)
462 {
463 RTE_SET_USED(dev);
464 RTE_SET_USED(f);
465
466 return 0;
467 }
468
skeleton_rawdev_firmware_status_get(struct rte_rawdev * dev,rte_rawdev_obj_t status_info)469 static int skeleton_rawdev_firmware_status_get(struct rte_rawdev *dev,
470 rte_rawdev_obj_t status_info)
471 {
472 struct skeleton_rawdev *skeldev;
473
474 SKELETON_PMD_FUNC_TRACE();
475
476 skeldev = skeleton_rawdev_get_priv(dev);
477
478 if (status_info)
479 memcpy(status_info, &skeldev->fw.firmware_state,
480 sizeof(enum skeleton_firmware_state));
481
482 return 0;
483 }
484
485
skeleton_rawdev_firmware_version_get(struct rte_rawdev * dev,rte_rawdev_obj_t version_info)486 static int skeleton_rawdev_firmware_version_get(
487 struct rte_rawdev *dev,
488 rte_rawdev_obj_t version_info)
489 {
490 struct skeleton_rawdev *skeldev;
491 struct skeleton_firmware_version_info *vi;
492
493 SKELETON_PMD_FUNC_TRACE();
494
495 skeldev = skeleton_rawdev_get_priv(dev);
496 vi = version_info;
497
498 vi->major = skeldev->fw.firmware_version.major;
499 vi->minor = skeldev->fw.firmware_version.minor;
500 vi->subrel = skeldev->fw.firmware_version.subrel;
501
502 return 0;
503 }
504
skeleton_rawdev_firmware_load(struct rte_rawdev * dev,rte_rawdev_obj_t firmware_buf)505 static int skeleton_rawdev_firmware_load(struct rte_rawdev *dev,
506 rte_rawdev_obj_t firmware_buf)
507 {
508 struct skeleton_rawdev *skeldev;
509
510 SKELETON_PMD_FUNC_TRACE();
511
512 skeldev = skeleton_rawdev_get_priv(dev);
513
514 /* firmware_buf is a mmaped, possibly DMA'able area, buffer. Being
515 * dummy, all this does is check if firmware_buf is not NULL and
516 * sets the state of the firmware.
517 */
518 if (!firmware_buf)
519 return -EINVAL;
520
521 skeldev->fw.firmware_state = SKELETON_FW_LOADED;
522
523 return 0;
524 }
525
skeleton_rawdev_firmware_unload(struct rte_rawdev * dev)526 static int skeleton_rawdev_firmware_unload(struct rte_rawdev *dev)
527 {
528 struct skeleton_rawdev *skeldev;
529
530 SKELETON_PMD_FUNC_TRACE();
531
532 skeldev = skeleton_rawdev_get_priv(dev);
533
534 skeldev->fw.firmware_state = SKELETON_FW_READY;
535
536 return 0;
537 }
538
539 static const struct rte_rawdev_ops skeleton_rawdev_ops = {
540 .dev_info_get = skeleton_rawdev_info_get,
541 .dev_configure = skeleton_rawdev_configure,
542 .dev_start = skeleton_rawdev_start,
543 .dev_stop = skeleton_rawdev_stop,
544 .dev_close = skeleton_rawdev_close,
545 .dev_reset = skeleton_rawdev_reset,
546
547 .queue_def_conf = skeleton_rawdev_queue_def_conf,
548 .queue_setup = skeleton_rawdev_queue_setup,
549 .queue_release = skeleton_rawdev_queue_release,
550 .queue_count = skeleton_rawdev_queue_count,
551
552 .attr_get = skeleton_rawdev_get_attr,
553 .attr_set = skeleton_rawdev_set_attr,
554
555 .enqueue_bufs = skeleton_rawdev_enqueue_bufs,
556 .dequeue_bufs = skeleton_rawdev_dequeue_bufs,
557
558 .dump = skeleton_rawdev_dump,
559
560 .xstats_get = NULL,
561 .xstats_get_names = NULL,
562 .xstats_get_by_name = NULL,
563 .xstats_reset = NULL,
564
565 .firmware_status_get = skeleton_rawdev_firmware_status_get,
566 .firmware_version_get = skeleton_rawdev_firmware_version_get,
567 .firmware_load = skeleton_rawdev_firmware_load,
568 .firmware_unload = skeleton_rawdev_firmware_unload,
569
570 .dev_selftest = test_rawdev_skeldev,
571 };
572
573 static int
skeleton_rawdev_create(const char * name,struct rte_vdev_device * vdev,int socket_id)574 skeleton_rawdev_create(const char *name,
575 struct rte_vdev_device *vdev,
576 int socket_id)
577 {
578 int ret = 0, i;
579 struct rte_rawdev *rawdev = NULL;
580 struct skeleton_rawdev *skeldev = NULL;
581
582 if (!name) {
583 SKELETON_PMD_ERR("Invalid name of the device!");
584 ret = -EINVAL;
585 goto cleanup;
586 }
587
588 /* Allocate device structure */
589 rawdev = rte_rawdev_pmd_allocate(name, sizeof(struct skeleton_rawdev),
590 socket_id);
591 if (rawdev == NULL) {
592 SKELETON_PMD_ERR("Unable to allocate rawdevice");
593 ret = -EINVAL;
594 goto cleanup;
595 }
596
597 ret = rawdev->dev_id; /* return the rawdev id of new device */
598
599 rawdev->dev_ops = &skeleton_rawdev_ops;
600 rawdev->device = &vdev->device;
601
602 skeldev = skeleton_rawdev_get_priv(rawdev);
603
604 skeldev->device_id = SKELETON_DEVICE_ID;
605 skeldev->vendor_id = SKELETON_VENDOR_ID;
606 skeldev->capabilities = SKELETON_DEFAULT_CAPA;
607
608 memset(&skeldev->fw, 0, sizeof(struct skeleton_firmware));
609
610 skeldev->fw.firmware_state = SKELETON_FW_READY;
611 skeldev->fw.firmware_version.major = SKELETON_MAJOR_VER;
612 skeldev->fw.firmware_version.minor = SKELETON_MINOR_VER;
613 skeldev->fw.firmware_version.subrel = SKELETON_SUB_VER;
614
615 skeldev->device_state = SKELETON_DEV_STOPPED;
616
617 /* Reset/set to default queue configuration for this device */
618 for (i = 0; i < SKELETON_MAX_QUEUES; i++) {
619 skeldev->queues[i].state = SKELETON_QUEUE_DETACH;
620 skeldev->queues[i].depth = SKELETON_QUEUE_DEF_DEPTH;
621 }
622
623 /* Clear all allocated queue buffers */
624 for (i = 0; i < SKELETON_MAX_QUEUES; i++)
625 clear_queue_bufs(i);
626
627 return ret;
628
629 cleanup:
630 if (rawdev)
631 rte_rawdev_pmd_release(rawdev);
632
633 return ret;
634 }
635
636 static int
skeleton_rawdev_destroy(const char * name)637 skeleton_rawdev_destroy(const char *name)
638 {
639 int ret;
640 struct rte_rawdev *rdev;
641
642 if (!name) {
643 SKELETON_PMD_ERR("Invalid device name");
644 return -EINVAL;
645 }
646
647 rdev = rte_rawdev_pmd_get_named_dev(name);
648 if (!rdev) {
649 SKELETON_PMD_ERR("Invalid device name (%s)", name);
650 return -EINVAL;
651 }
652
653 /* rte_rawdev_close is called by pmd_release */
654 ret = rte_rawdev_pmd_release(rdev);
655 if (ret)
656 SKELETON_PMD_DEBUG("Device cleanup failed");
657
658 return 0;
659 }
660
661 static int
skeldev_get_selftest(const char * key __rte_unused,const char * value,void * opaque)662 skeldev_get_selftest(const char *key __rte_unused,
663 const char *value,
664 void *opaque)
665 {
666 int *flag = opaque;
667 if (value == NULL || opaque == NULL)
668 return -EINVAL;
669 *flag = atoi(value);
670 return 0;
671 }
672
673 static int
skeldev_parse_vdev_args(struct rte_vdev_device * vdev)674 skeldev_parse_vdev_args(struct rte_vdev_device *vdev)
675 {
676 int selftest = 0;
677 const char *name;
678 const char *params;
679
680 static const char *const args[] = {
681 SKELETON_SELFTEST_ARG,
682 NULL
683 };
684
685 name = rte_vdev_device_name(vdev);
686
687 params = rte_vdev_device_args(vdev);
688 if (params != NULL && params[0] != '\0') {
689 struct rte_kvargs *kvlist = rte_kvargs_parse(params, args);
690
691 if (!kvlist) {
692 SKELETON_PMD_INFO(
693 "Ignoring unsupported params supplied '%s'",
694 name);
695 } else {
696 int ret = rte_kvargs_process(kvlist,
697 SKELETON_SELFTEST_ARG,
698 skeldev_get_selftest, &selftest);
699 if (ret != 0 || (selftest < 0 || selftest > 1)) {
700 SKELETON_PMD_ERR("%s: Error in parsing args",
701 name);
702 rte_kvargs_free(kvlist);
703 ret = -1; /* enforce if selftest is invalid */
704 return ret;
705 }
706 }
707
708 rte_kvargs_free(kvlist);
709 }
710
711 return selftest;
712 }
713
714 static int
skeleton_rawdev_probe(struct rte_vdev_device * vdev)715 skeleton_rawdev_probe(struct rte_vdev_device *vdev)
716 {
717 const char *name;
718 int selftest = 0, ret = 0;
719
720
721 name = rte_vdev_device_name(vdev);
722 if (name == NULL)
723 return -EINVAL;
724
725 /* More than one instance is not supported */
726 if (skeldev_init_once) {
727 SKELETON_PMD_ERR("Multiple instance not supported for %s",
728 name);
729 return -EINVAL;
730 }
731
732 SKELETON_PMD_INFO("Init %s on NUMA node %d", name, rte_socket_id());
733
734 selftest = skeldev_parse_vdev_args(vdev);
735 /* In case of invalid argument, selftest != 1; ignore other values */
736
737 ret = skeleton_rawdev_create(name, vdev, rte_socket_id());
738 if (ret >= 0) {
739 /* In case command line argument for 'selftest' was passed;
740 * if invalid arguments were passed, execution continues but
741 * without selftest.
742 */
743 if (selftest == 1)
744 test_rawdev_skeldev(ret);
745 }
746
747 /* Device instance created; Second instance not possible */
748 skeldev_init_once = 1;
749
750 return ret < 0 ? ret : 0;
751 }
752
753 static int
skeleton_rawdev_remove(struct rte_vdev_device * vdev)754 skeleton_rawdev_remove(struct rte_vdev_device *vdev)
755 {
756 const char *name;
757 int ret;
758
759 name = rte_vdev_device_name(vdev);
760 if (name == NULL)
761 return -1;
762
763 SKELETON_PMD_INFO("Closing %s on NUMA node %d", name, rte_socket_id());
764
765 ret = skeleton_rawdev_destroy(name);
766 if (!ret)
767 skeldev_init_once = 0;
768
769 return ret;
770 }
771
772 static struct rte_vdev_driver skeleton_pmd_drv = {
773 .probe = skeleton_rawdev_probe,
774 .remove = skeleton_rawdev_remove
775 };
776
777 RTE_PMD_REGISTER_VDEV(SKELETON_PMD_RAWDEV_NAME, skeleton_pmd_drv);
778 RTE_LOG_REGISTER_DEFAULT(skeleton_pmd_logtype, INFO);
779