1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Intel Corporation
5 #include <rte_common.h>
6 #include <rte_hexdump.h>
8 #include <rte_malloc.h>
9 #include <rte_memcpy.h>
10 #include <rte_cycles.h>
12 #include <rte_bus_vdev.h>
14 #include <rte_bbdev.h>
15 #include <rte_bbdev_op.h>
16 #include <rte_bbdev_pmd.h>
21 #define BBDEV_NAME_NULL ("bbdev_null")
23 struct bbdev_testsuite_params {
24 struct rte_bbdev_queue_conf qconf;
27 static struct bbdev_testsuite_params testsuite_params;
29 static uint8_t null_dev_id;
36 char buf[RTE_BBDEV_NAME_MAX_LEN];
38 /* Create test device */
39 snprintf(buf, sizeof(buf), "%s_unittest", BBDEV_NAME_NULL);
40 ret = rte_vdev_init(buf, NULL);
41 TEST_ASSERT(ret == 0, "Failed to create instance of pmd: %s", buf);
43 nb_devs = rte_bbdev_count();
44 TEST_ASSERT(nb_devs != 0, "No devices found");
46 /* Most recently created device is our device */
47 null_dev_id = nb_devs - 1;
53 testsuite_teardown(void)
55 char buf[RTE_BBDEV_NAME_MAX_LEN];
57 snprintf(buf, sizeof(buf), "%s_unittest", BBDEV_NAME_NULL);
64 struct bbdev_testsuite_params *ts_params = &testsuite_params;
67 /* Valid queue configuration */
68 ts_params->qconf.priority = 0;
69 ts_params->qconf.socket = SOCKET_ID_ANY;
70 ts_params->qconf.deferred_start = 1;
73 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(null_dev_id, num_queues,
74 SOCKET_ID_ANY), "Failed to setup queues for bbdev %u",
77 /* Start the device */
78 TEST_ASSERT_SUCCESS(rte_bbdev_start(null_dev_id),
79 "Failed to start bbdev %u", 0);
87 rte_bbdev_close(null_dev_id);
91 test_bbdev_configure_invalid_dev_id(void)
97 for (dev_id = 0; dev_id < RTE_BBDEV_MAX_DEVS; dev_id++) {
98 if (!rte_bbdev_is_valid(dev_id)) {
99 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id,
100 num_queues, SOCKET_ID_ANY),
101 "Failed test for rte_bbdev_setup_queues: "
102 "invalid dev_num %u", dev_id);
103 TEST_ASSERT(rte_bbdev_intr_enable(dev_id) == -ENODEV,
104 "Failed test for rte_bbdev_intr_enable: "
105 "invalid dev_num %u", dev_id);
114 test_bbdev_configure_invalid_num_queues(void)
116 struct rte_bbdev_info info;
117 uint8_t dev_id, num_devs;
121 TEST_ASSERT((num_devs = rte_bbdev_count()) >= 1,
122 "Need at least %d devices for test", 1);
124 /* valid num_queues values */
127 /* valid dev_id values */
128 dev_id = null_dev_id;
130 /* Stop the device in case it's started so it can be configured */
131 rte_bbdev_stop(dev_id);
133 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 0, SOCKET_ID_ANY),
134 "Failed test for rte_bbdev_setup_queues: "
135 "invalid num_queues %d", 0);
137 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, num_queues,
139 "Failed test for rte_bbdev_setup_queues: "
140 "invalid dev_num %u", dev_id);
142 TEST_ASSERT_FAIL(return_value = rte_bbdev_info_get(dev_id, NULL),
143 "Failed test for rte_bbdev_info_get: "
144 "returned value:%i", return_value);
146 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
147 "Failed test for rte_bbdev_info_get: "
148 "invalid return value:%i", return_value);
150 TEST_ASSERT(info.num_queues == num_queues,
151 "Failed test for rte_bbdev_info_get: "
152 "invalid num_queues:%u", info.num_queues);
154 num_queues = info.drv.max_num_queues;
155 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, num_queues,
157 "Failed test for rte_bbdev_setup_queues: "
158 "invalid num_queues: %u", num_queues);
161 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, num_queues,
163 "Failed test for rte_bbdev_setup_queues: "
164 "invalid num_queues: %u", num_queues);
170 test_bbdev_configure_stop_device(void)
172 struct rte_bbdev_info info;
176 /* valid dev_id values */
177 dev_id = null_dev_id;
179 /* Stop the device so it can be configured */
180 rte_bbdev_stop(dev_id);
182 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
183 "Failed test for rte_bbdev_info_get: "
184 "invalid return value from "
185 "rte_bbdev_info_get function: %i", return_value);
187 TEST_ASSERT_SUCCESS(info.started, "Failed test for rte_bbdev_info_get: "
188 "started value: %u", info.started);
190 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id,
191 info.drv.max_num_queues, SOCKET_ID_ANY),
192 "Failed test for rte_bbdev_setup_queues: "
193 "device should be stopped, dev_id: %u", dev_id);
195 return_value = rte_bbdev_intr_enable(dev_id);
196 TEST_ASSERT(return_value != -EBUSY,
197 "Failed test for rte_bbdev_intr_enable: device should be stopped, dev_id: %u",
200 /* Start the device so it cannot be configured */
201 TEST_ASSERT_FAIL(rte_bbdev_start(RTE_BBDEV_MAX_DEVS),
202 "Failed to start bbdev %u", dev_id);
204 TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
205 "Failed to start bbdev %u", dev_id);
207 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
208 "Failed test for rte_bbdev_info_get: "
209 "invalid return value from "
210 "rte_bbdev_info_get function: %i", return_value);
212 TEST_ASSERT_FAIL(info.started, "Failed test for rte_bbdev_info_get: "
213 "started value: %u", info.started);
215 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id,
216 info.drv.max_num_queues, SOCKET_ID_ANY),
217 "Failed test for rte_bbdev_setup_queues: "
218 "device should be started, dev_id: %u", dev_id);
220 return_value = rte_bbdev_intr_enable(dev_id);
221 TEST_ASSERT(return_value == -EBUSY,
222 "Failed test for rte_bbdev_intr_enable: device should be started, dev_id: %u",
225 /* Stop again the device so it can be once again configured */
226 TEST_ASSERT_FAIL(rte_bbdev_stop(RTE_BBDEV_MAX_DEVS),
227 "Failed to start bbdev %u", dev_id);
229 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u",
232 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
233 "Failed test for rte_bbdev_info_get: "
234 "invalid return value from "
235 "rte_bbdev_info_get function: %i", return_value);
237 TEST_ASSERT_SUCCESS(info.started, "Failed test for rte_bbdev_info_get: "
238 "started value: %u", info.started);
240 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id,
241 info.drv.max_num_queues, SOCKET_ID_ANY),
242 "Failed test for rte_bbdev_setup_queues: "
243 "device should be stopped, dev_id: %u", dev_id);
245 return_value = rte_bbdev_intr_enable(dev_id);
246 TEST_ASSERT(return_value != -EBUSY,
247 "Failed test for rte_bbdev_intr_enable: device should be stopped, dev_id: %u",
254 test_bbdev_configure_stop_queue(void)
256 struct bbdev_testsuite_params *ts_params = &testsuite_params;
257 struct rte_bbdev_info info;
258 struct rte_bbdev_queue_info qinfo;
263 /* Valid dev_id values */
264 dev_id = null_dev_id;
266 /* Valid queue_id values */
269 rte_bbdev_stop(dev_id);
270 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
271 "Failed test for rte_bbdev_info_get: "
272 "invalid return value:%i", return_value);
274 /* Valid queue configuration */
275 ts_params->qconf.queue_size = info.drv.queue_size_lim;
276 ts_params->qconf.priority = info.drv.max_queue_priority;
278 /* Device - started; queue - started */
279 rte_bbdev_start(dev_id);
281 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
283 "Failed test for rte_bbdev_queue_configure: "
284 "queue:%u on device:%u should be stopped",
287 /* Device - stopped; queue - started */
288 rte_bbdev_stop(dev_id);
290 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
292 "Failed test for rte_bbdev_queue_configure: "
293 "queue:%u on device:%u should be stopped",
296 TEST_ASSERT_FAIL(rte_bbdev_queue_stop(RTE_BBDEV_MAX_DEVS, queue_id),
297 "Failed test for rte_bbdev_queue_stop "
300 TEST_ASSERT_FAIL(rte_bbdev_queue_stop(dev_id, RTE_MAX_QUEUES_PER_PORT),
301 "Failed test for rte_bbdev_queue_stop "
302 "invalid queue_id ");
304 /* Device - stopped; queue - stopped */
305 rte_bbdev_queue_stop(dev_id, queue_id);
307 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
309 "Failed test for rte_bbdev_queue_configure: "
310 "queue:%u on device:%u should be stopped", queue_id,
313 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
315 "Failed test for rte_bbdev_info_get: "
316 "invalid return value from "
317 "rte_bbdev_queue_info_get function: %i", return_value);
319 TEST_ASSERT(qinfo.conf.socket == ts_params->qconf.socket,
320 "Failed test for rte_bbdev_queue_info_get: "
321 "invalid queue_size:%u", qinfo.conf.socket);
323 TEST_ASSERT(qinfo.conf.queue_size == ts_params->qconf.queue_size,
324 "Failed test for rte_bbdev_queue_info_get: "
325 "invalid queue_size:%u", qinfo.conf.queue_size);
327 TEST_ASSERT(qinfo.conf.priority == ts_params->qconf.priority,
328 "Failed test for rte_bbdev_queue_info_get: "
329 "invalid queue_size:%u", qinfo.conf.priority);
331 TEST_ASSERT(qinfo.conf.deferred_start ==
332 ts_params->qconf.deferred_start,
333 "Failed test for rte_bbdev_queue_info_get: "
334 "invalid queue_size:%u", qinfo.conf.deferred_start);
336 /* Device - started; queue - stopped */
337 rte_bbdev_start(dev_id);
338 rte_bbdev_queue_stop(dev_id, queue_id);
340 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
342 "Failed test for rte_bbdev_queue_configure: "
343 "queue:%u on device:%u should be stopped", queue_id,
346 rte_bbdev_stop(dev_id);
348 /* After rte_bbdev_start(dev_id):
349 * - queue should be still stopped if deferred_start ==
351 rte_bbdev_start(dev_id);
353 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
355 "Failed test for rte_bbdev_info_get: "
356 "invalid return value from "
357 "rte_bbdev_queue_info_get function: %i", return_value);
359 TEST_ASSERT(qinfo.started == 0,
360 "Failed test for rte_bbdev_queue_info_get: "
361 "invalid value for qinfo.started:%u", qinfo.started);
363 rte_bbdev_stop(dev_id);
365 /* After rte_bbdev_start(dev_id):
366 * - queue should be started if deferred_start ==
368 ts_params->qconf.deferred_start = 0;
369 rte_bbdev_queue_configure(dev_id, queue_id, &ts_params->qconf);
370 rte_bbdev_start(dev_id);
372 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
374 "Failed test for rte_bbdev_info_get: "
375 "invalid return value from "
376 "rte_bbdev_queue_info_get function: %i", return_value);
378 TEST_ASSERT(qinfo.started == 1,
379 "Failed test for rte_bbdev_queue_info_get: "
380 "invalid value for qinfo.started:%u", qinfo.started);
386 test_bbdev_configure_invalid_queue_configure(void)
388 struct bbdev_testsuite_params *ts_params = &testsuite_params;
390 struct rte_bbdev_info info;
394 /* Valid dev_id values */
395 dev_id = null_dev_id;
397 /* Valid queue_id values */
400 rte_bbdev_stop(dev_id);
402 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
403 "Failed test for rte_bbdev_info_get: "
404 "invalid return value:%i", return_value);
406 rte_bbdev_queue_stop(dev_id, queue_id);
408 ts_params->qconf.queue_size = info.drv.queue_size_lim + 1;
409 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
411 "Failed test for rte_bbdev_queue_configure: "
412 "invalid value qconf.queue_size: %u",
413 ts_params->qconf.queue_size);
415 ts_params->qconf.queue_size = info.drv.queue_size_lim;
416 ts_params->qconf.priority = info.drv.max_queue_priority + 1;
417 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
419 "Failed test for rte_bbdev_queue_configure: "
420 "invalid value qconf.queue_size: %u",
421 ts_params->qconf.queue_size);
423 ts_params->qconf.priority = info.drv.max_queue_priority;
424 queue_id = info.num_queues;
425 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
427 "Failed test for rte_bbdev_queue_configure: "
428 "invalid value queue_id: %u", queue_id);
431 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
432 "Failed test for rte_bbdev_queue_configure: "
433 "NULL qconf structure ");
435 ts_params->qconf.socket = RTE_MAX_NUMA_NODES;
436 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
438 "Failed test for rte_bbdev_queue_configure: "
439 "invalid socket number ");
441 ts_params->qconf.socket = SOCKET_ID_ANY;
442 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
444 "Failed test for rte_bbdev_queue_configure: "
445 "invalid value qconf.queue_size: %u",
446 ts_params->qconf.queue_size);
448 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS, queue_id,
450 "Failed test for rte_bbdev_queue_configure: "
453 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
454 "Failed test for rte_bbdev_queue_configure: "
455 "invalid value qconf.queue_size: %u",
456 ts_params->qconf.queue_size);
462 test_bbdev_op_pool(void)
464 struct rte_mempool *mp;
466 unsigned int dec_size = sizeof(struct rte_bbdev_dec_op);
467 unsigned int enc_size = sizeof(struct rte_bbdev_enc_op);
469 const char *pool_dec = "Test_DEC";
470 const char *pool_enc = "Test_ENC";
472 /* Valid pool configuration */
474 uint32_t cache_size = 128;
476 TEST_ASSERT(rte_bbdev_op_pool_create(NULL,
477 RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0) == NULL,
478 "Failed test for rte_bbdev_op_pool_create: "
479 "NULL name parameter");
481 TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_dec,
482 RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0)) != NULL,
483 "Failed test for rte_bbdev_op_pool_create: "
484 "returned value is empty");
486 TEST_ASSERT(mp->size == size,
487 "Failed test for rte_bbdev_op_pool_create: "
488 "invalid size of the mempool, mp->size: %u", mp->size);
490 TEST_ASSERT(mp->cache_size == cache_size,
491 "Failed test for rte_bbdev_op_pool_create: "
492 "invalid size of the mempool, mp->size: %u",
495 TEST_ASSERT_SUCCESS(strcmp(mp->name, pool_dec),
496 "Failed test for rte_bbdev_op_pool_create: "
497 "invalid name of mempool, mp->name: %s", mp->name);
499 TEST_ASSERT(mp->elt_size == dec_size,
500 "Failed test for rte_bbdev_op_pool_create: "
501 "invalid element size for RTE_BBDEV_OP_TURBO_DEC, "
502 "mp->elt_size: %u", mp->elt_size);
504 rte_mempool_free(mp);
506 TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_enc,
507 RTE_BBDEV_OP_TURBO_ENC, size, cache_size, 0)) != NULL,
508 "Failed test for rte_bbdev_op_pool_create: "
509 "returned value is empty");
511 TEST_ASSERT(mp->elt_size == enc_size,
512 "Failed test for rte_bbdev_op_pool_create: "
513 "invalid element size for RTE_BBDEV_OP_TURBO_ENC, "
514 "mp->elt_size: %u", mp->elt_size);
516 rte_mempool_free(mp);
518 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_NONE",
519 RTE_BBDEV_OP_NONE, size, cache_size, 0)) != NULL,
520 "Failed test for rte_bbdev_op_pool_create: "
521 "returned value is empty for RTE_BBDEV_OP_NONE");
523 TEST_ASSERT(mp->elt_size == (enc_size > dec_size ? enc_size : dec_size),
524 "Failed test for rte_bbdev_op_pool_create: "
525 "invalid size for RTE_BBDEV_OP_NONE, mp->elt_size: %u",
528 rte_mempool_free(mp);
530 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_INV",
531 RTE_BBDEV_OP_TYPE_COUNT, size, cache_size, 0)) == NULL,
532 "Failed test for rte_bbdev_op_pool_create: "
533 "returned value is not NULL for invalid type");
535 /* Invalid pool configuration */
539 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_InvSize",
540 RTE_BBDEV_OP_NONE, size, cache_size, 0)) == NULL,
541 "Failed test for rte_bbdev_op_pool_create: "
542 "returned value should be empty "
543 "because size of per-lcore local cache "
544 "is greater than size of the mempool.");
550 * Create pool of OP types RTE_BBDEV_OP_NONE, RTE_BBDEV_OP_TURBO_DEC and
551 * RTE_BBDEV_OP_TURBO_ENC and check that only ops of that type can be
555 test_bbdev_op_type(void)
557 struct rte_mempool *mp_dec;
559 const unsigned int OPS_COUNT = 32;
560 struct rte_bbdev_dec_op *dec_ops_arr[OPS_COUNT];
561 struct rte_bbdev_enc_op *enc_ops_arr[OPS_COUNT];
563 const char *pool_dec = "Test_op_dec";
565 /* Valid pool configuration */
566 uint32_t num_elements = 256;
567 uint32_t cache_size = 128;
569 /* mempool type : RTE_BBDEV_OP_TURBO_DEC */
570 mp_dec = rte_bbdev_op_pool_create(pool_dec,
571 RTE_BBDEV_OP_TURBO_DEC, num_elements, cache_size, 0);
572 TEST_ASSERT(mp_dec != NULL, "Failed to create %s mempool", pool_dec);
574 TEST_ASSERT(rte_bbdev_dec_op_alloc_bulk(mp_dec, dec_ops_arr, 1) == 0,
575 "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
576 "OPs type: RTE_BBDEV_OP_TURBO_DEC");
578 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_dec, enc_ops_arr, 1) != 0,
579 "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
580 "OPs type: RTE_BBDEV_OP_TURBO_ENC");
582 rte_mempool_free(mp_dec);
588 test_bbdev_op_pool_size(void)
590 struct rte_mempool *mp_none;
592 const unsigned int OPS_COUNT = 128;
593 struct rte_bbdev_enc_op *ops_enc_arr[OPS_COUNT];
594 struct rte_bbdev_enc_op *ops_ext_arr[OPS_COUNT];
595 struct rte_bbdev_enc_op *ops_ext2_arr[OPS_COUNT];
597 const char *pool_none = "Test_pool_size";
599 /* Valid pool configuration */
600 uint32_t num_elements = 256;
601 uint32_t cache_size = 0;
603 /* Create mempool type : RTE_BBDEV_OP_TURBO_ENC, size : 256 */
604 mp_none = rte_bbdev_op_pool_create(pool_none, RTE_BBDEV_OP_TURBO_ENC,
605 num_elements, cache_size, 0);
606 TEST_ASSERT(mp_none != NULL, "Failed to create %s mempool", pool_none);
608 /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
609 rte_bbdev_enc_op_alloc_bulk(mp_none, ops_enc_arr, OPS_COUNT);
611 /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
612 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext_arr,
614 "Failed test for allocating bbdev ops: "
615 "Mempool size: 256, Free : 128, Attempted to add: 128");
617 /* Try adding 128 more RTE_BBDEV_OP_TURBO_ENC ops, this should fail */
618 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
620 "Failed test for allocating bbdev ops: "
621 "Mempool size: 256, Free : 0, Attempted to add: 128");
623 /* Free-up 128 RTE_BBDEV_OP_TURBO_ENC ops */
624 rte_bbdev_enc_op_free_bulk(ops_enc_arr, OPS_COUNT);
626 /* Try adding 128 RTE_BBDEV_OP_TURBO_DEC ops, this should succeed */
627 /* Cache size > 0 causes reallocation of ops size > 127 fail */
628 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
630 "Failed test for allocating ops after mempool freed: "
631 "Mempool size: 256, Free : 128, Attempted to add: 128");
633 rte_mempool_free(mp_none);
639 test_bbdev_count(void)
641 uint8_t num_devs, num_valid_devs = 0;
643 for (num_devs = 0; num_devs < RTE_BBDEV_MAX_DEVS; num_devs++) {
644 if (rte_bbdev_is_valid(num_devs))
648 num_devs = rte_bbdev_count();
649 TEST_ASSERT(num_valid_devs == num_devs,
650 "Failed test for rte_bbdev_is_valid: "
651 "invalid num_devs %u ", num_devs);
657 test_bbdev_stats(void)
659 uint8_t dev_id = null_dev_id;
660 uint16_t queue_id = 0;
661 struct rte_bbdev_dec_op *dec_ops[4096] = { 0 };
662 struct rte_bbdev_dec_op *dec_proc_ops[4096] = { 0 };
663 struct rte_bbdev_enc_op *enc_ops[4096] = { 0 };
664 struct rte_bbdev_enc_op *enc_proc_ops[4096] = { 0 };
665 uint16_t num_ops = 236;
666 struct rte_bbdev_stats stats;
667 struct bbdev_testsuite_params *ts_params = &testsuite_params;
669 TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
670 "Failed to stop queue %u on device %u ", queue_id,
672 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
673 "Failed to stop bbdev %u ", dev_id);
675 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
677 "Failed to configure queue %u on device %u ",
680 TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
681 "Failed to start bbdev %u ", dev_id);
683 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
684 "Failed to start queue %u on device %u ", queue_id,
687 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
688 "Failed to start queue %u on device %u ", queue_id,
691 /* Tests after enqueue operation */
692 rte_bbdev_enqueue_enc_ops(dev_id, queue_id, enc_ops, num_ops);
693 rte_bbdev_enqueue_dec_ops(dev_id, queue_id, dec_ops, num_ops);
695 TEST_ASSERT_FAIL(rte_bbdev_stats_get(RTE_BBDEV_MAX_DEVS, &stats),
696 "Failed test for rte_bbdev_stats_get on device %u ",
699 TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, NULL),
700 "Failed test for rte_bbdev_stats_get on device %u ",
703 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
704 "Failed test for rte_bbdev_stats_get on device %u ",
707 TEST_ASSERT(stats.enqueued_count == 2 * num_ops,
708 "Failed test for rte_bbdev_enqueue_ops: "
709 "invalid enqueued_count %" PRIu64 " ",
710 stats.enqueued_count);
712 TEST_ASSERT(stats.dequeued_count == 0,
713 "Failed test for rte_bbdev_stats_reset: "
714 "invalid dequeued_count %" PRIu64 " ",
715 stats.dequeued_count);
717 /* Tests after dequeue operation */
718 rte_bbdev_dequeue_enc_ops(dev_id, queue_id, enc_proc_ops, num_ops);
719 rte_bbdev_dequeue_dec_ops(dev_id, queue_id, dec_proc_ops, num_ops);
721 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
722 "Failed test for rte_bbdev_stats_get on device %u ",
725 TEST_ASSERT(stats.dequeued_count == 2 * num_ops,
726 "Failed test for rte_bbdev_dequeue_ops: "
727 "invalid enqueued_count %" PRIu64 " ",
728 stats.dequeued_count);
730 TEST_ASSERT(stats.enqueue_err_count == 0,
731 "Failed test for rte_bbdev_stats_reset: "
732 "invalid enqueue_err_count %" PRIu64 " ",
733 stats.enqueue_err_count);
735 TEST_ASSERT(stats.dequeue_err_count == 0,
736 "Failed test for rte_bbdev_stats_reset: "
737 "invalid dequeue_err_count %" PRIu64 " ",
738 stats.dequeue_err_count);
740 /* Tests after reset operation */
741 TEST_ASSERT_FAIL(rte_bbdev_stats_reset(RTE_BBDEV_MAX_DEVS),
742 "Failed to reset statistic for device %u ", dev_id);
744 TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
745 "Failed to reset statistic for device %u ", dev_id);
746 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
747 "Failed test for rte_bbdev_stats_get on device %u ",
750 TEST_ASSERT(stats.enqueued_count == 0,
751 "Failed test for rte_bbdev_stats_reset: "
752 "invalid enqueued_count %" PRIu64 " ",
753 stats.enqueued_count);
755 TEST_ASSERT(stats.dequeued_count == 0,
756 "Failed test for rte_bbdev_stats_reset: "
757 "invalid dequeued_count %" PRIu64 " ",
758 stats.dequeued_count);
760 TEST_ASSERT(stats.enqueue_err_count == 0,
761 "Failed test for rte_bbdev_stats_reset: "
762 "invalid enqueue_err_count %" PRIu64 " ",
763 stats.enqueue_err_count);
765 TEST_ASSERT(stats.dequeue_err_count == 0,
766 "Failed test for rte_bbdev_stats_reset: "
767 "invalid dequeue_err_count %" PRIu64 " ",
768 stats.dequeue_err_count);
774 test_bbdev_driver_init(void)
776 struct rte_bbdev *dev1, *dev2;
777 const char *name = "dev_name";
779 int num_devs, num_devs_tmp;
781 dev1 = rte_bbdev_allocate(NULL);
782 TEST_ASSERT(dev1 == NULL,
783 "Failed initialize bbdev driver with NULL name");
785 dev1 = rte_bbdev_allocate(name);
786 TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
788 dev2 = rte_bbdev_allocate(name);
789 TEST_ASSERT(dev2 == NULL,
790 "Failed to initialize bbdev driver: "
791 "driver with the same name has been initialized before");
793 num_devs = rte_bbdev_count() - 1;
794 num_devs_tmp = num_devs;
796 /* Initialize the maximum amount of devices */
798 sprintf(name_tmp, "%s%i", "name_", num_devs);
799 dev2 = rte_bbdev_allocate(name_tmp);
800 TEST_ASSERT(dev2 != NULL,
801 "Failed to initialize bbdev driver");
803 } while (num_devs < (RTE_BBDEV_MAX_DEVS - 1));
805 sprintf(name_tmp, "%s%i", "name_", num_devs);
806 dev2 = rte_bbdev_allocate(name_tmp);
807 TEST_ASSERT(dev2 == NULL, "Failed to initialize bbdev driver number %d "
808 "more drivers than RTE_BBDEV_MAX_DEVS: %d ", num_devs,
813 while (num_devs >= num_devs_tmp) {
814 sprintf(name_tmp, "%s%i", "name_", num_devs);
815 dev2 = rte_bbdev_get_named_dev(name_tmp);
816 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
817 "Failed to uninitialize bbdev driver %s ",
822 TEST_ASSERT(dev1->data->dev_id < RTE_BBDEV_MAX_DEVS,
823 "Failed test rte_bbdev_allocate: "
824 "invalid dev_id %" PRIu8 ", max number of devices %d ",
825 dev1->data->dev_id, RTE_BBDEV_MAX_DEVS);
827 TEST_ASSERT(dev1->state == RTE_BBDEV_INITIALIZED,
828 "Failed test rte_bbdev_allocate: "
829 "invalid state %d (0 - RTE_BBDEV_UNUSED, 1 - RTE_BBDEV_INITIALIZED",
832 TEST_ASSERT_FAIL(rte_bbdev_release(NULL),
833 "Failed to uninitialize bbdev driver with NULL bbdev");
835 sprintf(name_tmp, "%s", "invalid_name");
836 dev2 = rte_bbdev_get_named_dev(name_tmp);
837 TEST_ASSERT_FAIL(rte_bbdev_release(dev2),
838 "Failed to uninitialize bbdev driver with invalid name");
840 dev2 = rte_bbdev_get_named_dev(name);
841 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
842 "Failed to uninitialize bbdev driver: %s ", name);
848 event_callback(uint16_t dev_id, enum rte_bbdev_event_type type, void *param,
851 RTE_SET_USED(dev_id);
852 RTE_SET_USED(ret_param);
857 if (type == RTE_BBDEV_EVENT_UNKNOWN ||
858 type == RTE_BBDEV_EVENT_ERROR ||
859 type == RTE_BBDEV_EVENT_MAX)
860 *(int *)param = type;
864 test_bbdev_callback(void)
866 struct rte_bbdev *dev1, *dev2;
867 const char *name = "dev_name1";
868 const char *name2 = "dev_name2";
870 uint8_t invalid_dev_id = RTE_BBDEV_MAX_DEVS;
871 enum rte_bbdev_event_type invalid_event_type = RTE_BBDEV_EVENT_MAX;
874 dev1 = rte_bbdev_allocate(name);
875 TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
878 * RTE_BBDEV_EVENT_UNKNOWN - unregistered
879 * RTE_BBDEV_EVENT_ERROR - unregistered
882 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
883 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
884 TEST_ASSERT(event_status == -1,
885 "Failed test for rte_bbdev_pmd_callback_process: "
886 "events were not registered ");
888 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
889 RTE_BBDEV_EVENT_MAX, event_callback, NULL),
890 "Failed to callback register for RTE_BBDEV_EVENT_MAX ");
892 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
893 RTE_BBDEV_EVENT_MAX, event_callback, NULL),
894 "Failed to unregister RTE_BBDEV_EVENT_MAX ");
897 * RTE_BBDEV_EVENT_UNKNOWN - registered
898 * RTE_BBDEV_EVENT_ERROR - unregistered
900 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
901 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
902 "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
904 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
905 TEST_ASSERT(event_status == 0,
906 "Failed test for rte_bbdev_pmd_callback_process "
907 "for RTE_BBDEV_EVENT_UNKNOWN ");
909 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
910 TEST_ASSERT(event_status == 0,
911 "Failed test for rte_bbdev_pmd_callback_process: "
912 "event RTE_BBDEV_EVENT_ERROR was not registered ");
915 * RTE_BBDEV_EVENT_UNKNOWN - registered
916 * RTE_BBDEV_EVENT_ERROR - registered
918 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
919 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
920 "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR ");
922 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
923 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
924 "Failed to callback register for RTE_BBDEV_EVENT_ERROR"
925 "(re-registration) ");
928 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
929 TEST_ASSERT(event_status == 0,
930 "Failed test for rte_bbdev_pmd_callback_process "
931 "for RTE_BBDEV_EVENT_UNKNOWN ");
933 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
934 TEST_ASSERT(event_status == 1,
935 "Failed test for rte_bbdev_pmd_callback_process "
936 "for RTE_BBDEV_EVENT_ERROR ");
939 * RTE_BBDEV_EVENT_UNKNOWN - registered
940 * RTE_BBDEV_EVENT_ERROR - unregistered
942 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev1->data->dev_id,
943 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
944 "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
947 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
948 TEST_ASSERT(event_status == 0,
949 "Failed test for rte_bbdev_pmd_callback_process "
950 "for RTE_BBDEV_EVENT_UNKNOWN ");
952 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
953 TEST_ASSERT(event_status == 0,
954 "Failed test for rte_bbdev_pmd_callback_process: "
955 "event RTE_BBDEV_EVENT_ERROR was unregistered ");
957 /* rte_bbdev_callback_register with invalid inputs */
958 TEST_ASSERT_FAIL(rte_bbdev_callback_register(invalid_dev_id,
959 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
960 "Failed test for rte_bbdev_callback_register "
961 "for invalid_dev_id ");
963 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
964 invalid_event_type, event_callback, &event_status),
965 "Failed to callback register for invalid event type ");
967 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
968 RTE_BBDEV_EVENT_ERROR, NULL, &event_status),
969 "Failed to callback register - no callback function ");
971 /* The impact of devices on each other */
972 dev2 = rte_bbdev_allocate(name2);
973 TEST_ASSERT(dev2 != NULL,
974 "Failed to initialize bbdev driver");
978 * RTE_BBDEV_EVENT_UNKNOWN - unregistered
979 * RTE_BBDEV_EVENT_ERROR - unregistered
982 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
983 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
984 TEST_ASSERT(event_status == -1,
985 "Failed test for rte_bbdev_pmd_callback_process: "
986 "events were not registered ");
989 * dev1: RTE_BBDEV_EVENT_ERROR - unregistered
990 * dev2: RTE_BBDEV_EVENT_ERROR - registered
992 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
993 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
994 "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR");
996 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
997 TEST_ASSERT(event_status == -1,
998 "Failed test for rte_bbdev_pmd_callback_process in dev1 "
999 "for RTE_BBDEV_EVENT_ERROR ");
1001 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
1002 TEST_ASSERT(event_status == 1,
1003 "Failed test for rte_bbdev_pmd_callback_process in dev2 "
1004 "for RTE_BBDEV_EVENT_ERROR ");
1007 * dev1: RTE_BBDEV_EVENT_UNKNOWN - registered
1008 * dev2: RTE_BBDEV_EVENT_UNKNOWN - unregistered
1010 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
1011 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1012 "Failed to callback register for RTE_BBDEV_EVENT_UNKNOWN "
1015 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1016 TEST_ASSERT(event_status == 0,
1017 "Failed test for rte_bbdev_pmd_callback_process in dev2"
1018 " for RTE_BBDEV_EVENT_UNKNOWN ");
1020 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1021 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1022 "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN ");
1024 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1025 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1026 "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN : "
1027 "unregister function called once again ");
1030 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1031 TEST_ASSERT(event_status == -1,
1032 "Failed test for rte_bbdev_pmd_callback_process in dev2"
1033 " for RTE_BBDEV_EVENT_UNKNOWN ");
1035 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1036 TEST_ASSERT(event_status == 0,
1037 "Failed test for rte_bbdev_pmd_callback_process in dev2 "
1038 "for RTE_BBDEV_EVENT_UNKNOWN ");
1040 /* rte_bbdev_pmd_callback_process with invalid inputs */
1041 rte_bbdev_pmd_callback_process(NULL, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1044 rte_bbdev_pmd_callback_process(dev1, invalid_event_type, NULL);
1045 TEST_ASSERT(event_status == -1,
1046 "Failed test for rte_bbdev_pmd_callback_process: "
1047 "for invalid event type ");
1049 /* rte_dev_callback_unregister with invalid inputs */
1050 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(invalid_dev_id,
1051 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1052 "Failed test for rte_dev_callback_unregister "
1053 "for invalid_dev_id ");
1055 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1056 invalid_event_type, event_callback, &event_status),
1057 "Failed rte_dev_callback_unregister "
1058 "for invalid event type ");
1060 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1061 invalid_event_type, NULL, &event_status),
1062 "Failed rte_dev_callback_unregister "
1063 "when no callback function ");
1065 dev_id = dev1->data->dev_id;
1067 rte_bbdev_release(dev1);
1068 rte_bbdev_release(dev2);
1070 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev_id,
1071 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1072 "Failed test for rte_bbdev_callback_register: "
1073 "function called after rte_bbdev_driver_uninit .");
1075 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev_id,
1076 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1077 "Failed test for rte_dev_callback_unregister: "
1078 "function called after rte_bbdev_driver_uninit. ");
1081 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1082 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
1083 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1084 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
1085 TEST_ASSERT(event_status == -1,
1086 "Failed test for rte_bbdev_pmd_callback_process: "
1087 "callback function was called after rte_bbdev_driver_uninit");
1089 return TEST_SUCCESS;
1093 test_bbdev_invalid_driver(void)
1095 struct rte_bbdev dev1, *dev2;
1096 uint8_t dev_id = null_dev_id;
1097 uint16_t queue_id = 0;
1098 struct rte_bbdev_stats stats;
1099 struct bbdev_testsuite_params *ts_params = &testsuite_params;
1100 struct rte_bbdev_queue_info qinfo;
1101 struct rte_bbdev_ops dev_ops_tmp;
1103 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u ",
1106 dev1 = rte_bbdev_devices[dev_id];
1107 dev2 = &rte_bbdev_devices[dev_id];
1109 /* Tests for rte_bbdev_setup_queues */
1110 dev2->dev_ops = NULL;
1111 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1112 "Failed test for rte_bbdev_setup_queues: "
1113 "NULL dev_ops structure ");
1114 dev2->dev_ops = dev1.dev_ops;
1116 dev_ops_tmp = *dev2->dev_ops;
1117 dev_ops_tmp.info_get = NULL;
1118 dev2->dev_ops = &dev_ops_tmp;
1119 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1120 "Failed test for rte_bbdev_setup_queues: "
1122 dev2->dev_ops = dev1.dev_ops;
1124 dev_ops_tmp = *dev2->dev_ops;
1125 dev_ops_tmp.queue_release = NULL;
1126 dev2->dev_ops = &dev_ops_tmp;
1127 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1128 "Failed test for rte_bbdev_setup_queues: "
1129 "NULL queue_release ");
1130 dev2->dev_ops = dev1.dev_ops;
1132 dev2->data->socket_id = SOCKET_ID_ANY;
1133 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, 1,
1134 SOCKET_ID_ANY), "Failed to configure bbdev %u", dev_id);
1136 /* Test for rte_bbdev_queue_configure */
1137 dev2->dev_ops = NULL;
1138 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1140 "Failed to configure queue %u on device %u "
1141 "with NULL dev_ops structure ", queue_id, dev_id);
1142 dev2->dev_ops = dev1.dev_ops;
1144 dev_ops_tmp = *dev2->dev_ops;
1145 dev_ops_tmp.queue_setup = NULL;
1146 dev2->dev_ops = &dev_ops_tmp;
1147 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1149 "Failed to configure queue %u on device %u "
1150 "with NULL queue_setup ", queue_id, dev_id);
1151 dev2->dev_ops = dev1.dev_ops;
1153 dev_ops_tmp = *dev2->dev_ops;
1154 dev_ops_tmp.info_get = NULL;
1155 dev2->dev_ops = &dev_ops_tmp;
1156 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1158 "Failed to configure queue %u on device %u "
1159 "with NULL info_get ", queue_id, dev_id);
1160 dev2->dev_ops = dev1.dev_ops;
1162 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS,
1163 queue_id, &ts_params->qconf),
1164 "Failed to configure queue %u on device %u ",
1167 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
1169 "Failed to configure queue %u on device %u ",
1172 /* Test for rte_bbdev_queue_info_get */
1173 dev2->dev_ops = NULL;
1174 TEST_ASSERT_SUCCESS(rte_bbdev_queue_info_get(dev_id, queue_id, &qinfo),
1175 "Failed test for rte_bbdev_info_get: "
1176 "NULL dev_ops structure ");
1177 dev2->dev_ops = dev1.dev_ops;
1179 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(RTE_BBDEV_MAX_DEVS,
1181 "Failed test for rte_bbdev_info_get: "
1184 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id,
1185 RTE_MAX_QUEUES_PER_PORT, &qinfo),
1186 "Failed test for rte_bbdev_info_get: "
1187 "invalid queue_id ");
1189 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id, queue_id, NULL),
1190 "Failed test for rte_bbdev_info_get: "
1191 "invalid dev_info ");
1193 /* Test for rte_bbdev_start */
1194 dev2->dev_ops = NULL;
1195 TEST_ASSERT_FAIL(rte_bbdev_start(dev_id),
1196 "Failed to start bbdev %u "
1197 "with NULL dev_ops structure ", dev_id);
1198 dev2->dev_ops = dev1.dev_ops;
1200 TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
1201 "Failed to start bbdev %u ", dev_id);
1203 /* Test for rte_bbdev_queue_start */
1204 dev2->dev_ops = NULL;
1205 TEST_ASSERT_FAIL(rte_bbdev_queue_start(dev_id, queue_id),
1206 "Failed to start queue %u on device %u: "
1207 "NULL dev_ops structure", queue_id, dev_id);
1208 dev2->dev_ops = dev1.dev_ops;
1210 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
1211 "Failed to start queue %u on device %u ", queue_id,
1214 /* Tests for rte_bbdev_stats_get */
1215 dev2->dev_ops = NULL;
1216 TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, &stats),
1217 "Failed test for rte_bbdev_stats_get on device %u ",
1219 dev2->dev_ops = dev1.dev_ops;
1221 dev_ops_tmp = *dev2->dev_ops;
1222 dev_ops_tmp.stats_reset = NULL;
1223 dev2->dev_ops = &dev_ops_tmp;
1224 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1225 "Failed test for rte_bbdev_stats_get: "
1227 dev2->dev_ops = dev1.dev_ops;
1229 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1230 "Failed test for rte_bbdev_stats_get on device %u ",
1235 * rte_bbdev_callback_register,
1236 * rte_bbdev_pmd_callback_process,
1237 * rte_dev_callback_unregister
1239 dev2->dev_ops = NULL;
1240 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev_id,
1241 RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1242 "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
1243 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1245 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev_id,
1246 RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1247 "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
1248 dev2->dev_ops = dev1.dev_ops;
1250 /* Tests for rte_bbdev_stats_reset */
1251 dev2->dev_ops = NULL;
1252 TEST_ASSERT_FAIL(rte_bbdev_stats_reset(dev_id),
1253 "Failed to reset statistic for device %u ", dev_id);
1254 dev2->dev_ops = dev1.dev_ops;
1256 dev_ops_tmp = *dev2->dev_ops;
1257 dev_ops_tmp.stats_reset = NULL;
1258 dev2->dev_ops = &dev_ops_tmp;
1259 TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1260 "Failed test for rte_bbdev_stats_reset: "
1261 "NULL stats_reset ");
1262 dev2->dev_ops = dev1.dev_ops;
1264 TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1265 "Failed to reset statistic for device %u ", dev_id);
1267 /* Tests for rte_bbdev_queue_stop */
1268 dev2->dev_ops = NULL;
1269 TEST_ASSERT_FAIL(rte_bbdev_queue_stop(dev_id, queue_id),
1270 "Failed to stop queue %u on device %u: "
1271 "NULL dev_ops structure", queue_id, dev_id);
1272 dev2->dev_ops = dev1.dev_ops;
1274 TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
1275 "Failed to stop queue %u on device %u ", queue_id,
1278 /* Tests for rte_bbdev_stop */
1279 dev2->dev_ops = NULL;
1280 TEST_ASSERT_FAIL(rte_bbdev_stop(dev_id),
1281 "Failed to stop bbdev %u with NULL dev_ops structure ",
1283 dev2->dev_ops = dev1.dev_ops;
1285 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
1286 "Failed to stop bbdev %u ", dev_id);
1288 /* Tests for rte_bbdev_close */
1289 TEST_ASSERT_FAIL(rte_bbdev_close(RTE_BBDEV_MAX_DEVS),
1290 "Failed to close bbdev with invalid dev_id");
1292 dev2->dev_ops = NULL;
1293 TEST_ASSERT_FAIL(rte_bbdev_close(dev_id),
1294 "Failed to close bbdev %u with NULL dev_ops structure ",
1296 dev2->dev_ops = dev1.dev_ops;
1298 TEST_ASSERT_SUCCESS(rte_bbdev_close(dev_id),
1299 "Failed to close bbdev %u ", dev_id);
1301 return TEST_SUCCESS;
1305 test_bbdev_get_named_dev(void)
1307 struct rte_bbdev *dev, *dev_tmp;
1308 const char *name = "name";
1310 dev = rte_bbdev_allocate(name);
1311 TEST_ASSERT(dev != NULL, "Failed to initialize bbdev driver");
1313 dev_tmp = rte_bbdev_get_named_dev(NULL);
1314 TEST_ASSERT(dev_tmp == NULL, "Failed test for rte_bbdev_get_named_dev: "
1315 "function called with NULL parameter");
1317 dev_tmp = rte_bbdev_get_named_dev(name);
1319 TEST_ASSERT(dev == dev_tmp, "Failed test for rte_bbdev_get_named_dev: "
1320 "wrong device was returned ");
1322 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev),
1323 "Failed to uninitialize bbdev driver %s ", name);
1325 return TEST_SUCCESS;
1328 static struct unit_test_suite bbdev_null_testsuite = {
1329 .suite_name = "BBDEV NULL Unit Test Suite",
1330 .setup = testsuite_setup,
1331 .teardown = testsuite_teardown,
1332 .unit_test_cases = {
1334 TEST_CASE(test_bbdev_configure_invalid_dev_id),
1336 TEST_CASE_ST(ut_setup, ut_teardown,
1337 test_bbdev_configure_invalid_num_queues),
1339 TEST_CASE_ST(ut_setup, ut_teardown,
1340 test_bbdev_configure_stop_device),
1342 TEST_CASE_ST(ut_setup, ut_teardown,
1343 test_bbdev_configure_stop_queue),
1345 TEST_CASE_ST(ut_setup, ut_teardown,
1346 test_bbdev_configure_invalid_queue_configure),
1348 TEST_CASE_ST(ut_setup, ut_teardown,
1349 test_bbdev_op_pool),
1351 TEST_CASE_ST(ut_setup, ut_teardown,
1352 test_bbdev_op_type),
1354 TEST_CASE_ST(ut_setup, ut_teardown,
1355 test_bbdev_op_pool_size),
1357 TEST_CASE_ST(ut_setup, ut_teardown,
1360 TEST_CASE_ST(ut_setup, ut_teardown,
1361 test_bbdev_driver_init),
1363 TEST_CASE_ST(ut_setup, ut_teardown,
1364 test_bbdev_callback),
1366 TEST_CASE_ST(ut_setup, ut_teardown,
1367 test_bbdev_invalid_driver),
1369 TEST_CASE_ST(ut_setup, ut_teardown,
1370 test_bbdev_get_named_dev),
1372 TEST_CASE(test_bbdev_count),
1374 TEST_CASES_END() /**< NULL terminate unit test array */
1378 REGISTER_TEST_COMMAND(unittest, bbdev_null_testsuite);