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>
18 #include <rte_string_fns.h>
23 #define BBDEV_NAME_NULL ("bbdev_null")
25 struct bbdev_testsuite_params {
26 struct rte_bbdev_queue_conf qconf;
29 static struct bbdev_testsuite_params testsuite_params;
31 static uint8_t null_dev_id;
38 char buf[RTE_BBDEV_NAME_MAX_LEN];
40 /* Create test device */
41 snprintf(buf, sizeof(buf), "%s_unittest", BBDEV_NAME_NULL);
42 ret = rte_vdev_init(buf, NULL);
43 TEST_ASSERT(ret == 0, "Failed to create instance of pmd: %s", buf);
45 nb_devs = rte_bbdev_count();
46 TEST_ASSERT(nb_devs != 0, "No devices found");
48 /* Most recently created device is our device */
49 null_dev_id = nb_devs - 1;
55 testsuite_teardown(void)
57 char buf[RTE_BBDEV_NAME_MAX_LEN];
59 snprintf(buf, sizeof(buf), "%s_unittest", BBDEV_NAME_NULL);
66 struct bbdev_testsuite_params *ts_params = &testsuite_params;
69 /* Valid queue configuration */
70 ts_params->qconf.priority = 0;
71 ts_params->qconf.socket = SOCKET_ID_ANY;
72 ts_params->qconf.deferred_start = 1;
75 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(null_dev_id, num_queues,
76 SOCKET_ID_ANY), "Failed to setup queues for bbdev %u",
79 /* Start the device */
80 TEST_ASSERT_SUCCESS(rte_bbdev_start(null_dev_id),
81 "Failed to start bbdev %u", 0);
89 rte_bbdev_close(null_dev_id);
93 test_bbdev_configure_invalid_dev_id(void)
99 for (dev_id = 0; dev_id < RTE_BBDEV_MAX_DEVS; dev_id++) {
100 if (!rte_bbdev_is_valid(dev_id)) {
101 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id,
102 num_queues, SOCKET_ID_ANY),
103 "Failed test for rte_bbdev_setup_queues: "
104 "invalid dev_num %u", dev_id);
105 TEST_ASSERT(rte_bbdev_intr_enable(dev_id) == -ENODEV,
106 "Failed test for rte_bbdev_intr_enable: "
107 "invalid dev_num %u", dev_id);
116 test_bbdev_configure_invalid_num_queues(void)
118 struct rte_bbdev_info info;
119 uint8_t dev_id, num_devs;
123 TEST_ASSERT((num_devs = rte_bbdev_count()) >= 1,
124 "Need at least %d devices for test", 1);
126 /* valid num_queues values */
129 /* valid dev_id values */
130 dev_id = null_dev_id;
132 /* Stop the device in case it's started so it can be configured */
133 rte_bbdev_stop(dev_id);
135 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 0, SOCKET_ID_ANY),
136 "Failed test for rte_bbdev_setup_queues: "
137 "invalid num_queues %d", 0);
139 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, num_queues,
141 "Failed test for rte_bbdev_setup_queues: "
142 "invalid dev_num %u", dev_id);
144 TEST_ASSERT_FAIL(return_value = rte_bbdev_info_get(dev_id, NULL),
145 "Failed test for rte_bbdev_info_get: "
146 "returned value:%i", return_value);
148 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
149 "Failed test for rte_bbdev_info_get: "
150 "invalid return value:%i", return_value);
152 TEST_ASSERT(info.num_queues == num_queues,
153 "Failed test for rte_bbdev_info_get: "
154 "invalid num_queues:%u", info.num_queues);
156 num_queues = info.drv.max_num_queues;
157 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, num_queues,
159 "Failed test for rte_bbdev_setup_queues: "
160 "invalid num_queues: %u", num_queues);
163 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, num_queues,
165 "Failed test for rte_bbdev_setup_queues: "
166 "invalid num_queues: %u", num_queues);
172 test_bbdev_configure_stop_device(void)
174 struct rte_bbdev_info info;
178 /* valid dev_id values */
179 dev_id = null_dev_id;
181 /* Stop the device so it can be configured */
182 rte_bbdev_stop(dev_id);
184 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
185 "Failed test for rte_bbdev_info_get: "
186 "invalid return value from "
187 "rte_bbdev_info_get function: %i", return_value);
189 TEST_ASSERT_SUCCESS(info.started, "Failed test for rte_bbdev_info_get: "
190 "started value: %u", info.started);
192 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id,
193 info.drv.max_num_queues, SOCKET_ID_ANY),
194 "Failed test for rte_bbdev_setup_queues: "
195 "device should be stopped, dev_id: %u", dev_id);
197 return_value = rte_bbdev_intr_enable(dev_id);
198 TEST_ASSERT(return_value != -EBUSY,
199 "Failed test for rte_bbdev_intr_enable: device should be stopped, dev_id: %u",
202 /* Start the device so it cannot be configured */
203 TEST_ASSERT_FAIL(rte_bbdev_start(RTE_BBDEV_MAX_DEVS),
204 "Failed to start bbdev %u", dev_id);
206 TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
207 "Failed to start bbdev %u", dev_id);
209 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
210 "Failed test for rte_bbdev_info_get: "
211 "invalid return value from "
212 "rte_bbdev_info_get function: %i", return_value);
214 TEST_ASSERT_FAIL(info.started, "Failed test for rte_bbdev_info_get: "
215 "started value: %u", info.started);
217 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id,
218 info.drv.max_num_queues, SOCKET_ID_ANY),
219 "Failed test for rte_bbdev_setup_queues: "
220 "device should be started, dev_id: %u", dev_id);
222 return_value = rte_bbdev_intr_enable(dev_id);
223 TEST_ASSERT(return_value == -EBUSY,
224 "Failed test for rte_bbdev_intr_enable: device should be started, dev_id: %u",
227 /* Stop again the device so it can be once again configured */
228 TEST_ASSERT_FAIL(rte_bbdev_stop(RTE_BBDEV_MAX_DEVS),
229 "Failed to start bbdev %u", dev_id);
231 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u",
234 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
235 "Failed test for rte_bbdev_info_get: "
236 "invalid return value from "
237 "rte_bbdev_info_get function: %i", return_value);
239 TEST_ASSERT_SUCCESS(info.started, "Failed test for rte_bbdev_info_get: "
240 "started value: %u", info.started);
242 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id,
243 info.drv.max_num_queues, SOCKET_ID_ANY),
244 "Failed test for rte_bbdev_setup_queues: "
245 "device should be stopped, dev_id: %u", dev_id);
247 return_value = rte_bbdev_intr_enable(dev_id);
248 TEST_ASSERT(return_value != -EBUSY,
249 "Failed test for rte_bbdev_intr_enable: device should be stopped, dev_id: %u",
256 test_bbdev_configure_stop_queue(void)
258 struct bbdev_testsuite_params *ts_params = &testsuite_params;
259 struct rte_bbdev_info info;
260 struct rte_bbdev_queue_info qinfo;
265 /* Valid dev_id values */
266 dev_id = null_dev_id;
268 /* Valid queue_id values */
271 rte_bbdev_stop(dev_id);
272 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
273 "Failed test for rte_bbdev_info_get: "
274 "invalid return value:%i", return_value);
276 /* Valid queue configuration */
277 ts_params->qconf.queue_size = info.drv.queue_size_lim;
278 ts_params->qconf.priority = info.drv.max_ul_queue_priority;
280 /* Device - started; queue - started */
281 rte_bbdev_start(dev_id);
283 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
285 "Failed test for rte_bbdev_queue_configure: "
286 "queue:%u on device:%u should be stopped",
289 /* Device - stopped; queue - started */
290 rte_bbdev_stop(dev_id);
292 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
294 "Failed test for rte_bbdev_queue_configure: "
295 "queue:%u on device:%u should be stopped",
298 TEST_ASSERT_FAIL(rte_bbdev_queue_stop(RTE_BBDEV_MAX_DEVS, queue_id),
299 "Failed test for rte_bbdev_queue_stop "
302 TEST_ASSERT_FAIL(rte_bbdev_queue_stop(dev_id, RTE_MAX_QUEUES_PER_PORT),
303 "Failed test for rte_bbdev_queue_stop "
304 "invalid queue_id ");
306 /* Device - stopped; queue - stopped */
307 rte_bbdev_queue_stop(dev_id, queue_id);
309 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
311 "Failed test for rte_bbdev_queue_configure: "
312 "queue:%u on device:%u should be stopped", queue_id,
315 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
317 "Failed test for rte_bbdev_info_get: "
318 "invalid return value from "
319 "rte_bbdev_queue_info_get function: %i", return_value);
321 TEST_ASSERT(qinfo.conf.socket == ts_params->qconf.socket,
322 "Failed test for rte_bbdev_queue_info_get: "
323 "invalid queue_size:%u", qinfo.conf.socket);
325 TEST_ASSERT(qinfo.conf.queue_size == ts_params->qconf.queue_size,
326 "Failed test for rte_bbdev_queue_info_get: "
327 "invalid queue_size:%u", qinfo.conf.queue_size);
329 TEST_ASSERT(qinfo.conf.priority == ts_params->qconf.priority,
330 "Failed test for rte_bbdev_queue_info_get: "
331 "invalid queue_size:%u", qinfo.conf.priority);
333 TEST_ASSERT(qinfo.conf.deferred_start ==
334 ts_params->qconf.deferred_start,
335 "Failed test for rte_bbdev_queue_info_get: "
336 "invalid queue_size:%u", qinfo.conf.deferred_start);
338 /* Device - started; queue - stopped */
339 rte_bbdev_start(dev_id);
340 rte_bbdev_queue_stop(dev_id, queue_id);
342 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
344 "Failed test for rte_bbdev_queue_configure: "
345 "queue:%u on device:%u should be stopped", queue_id,
348 rte_bbdev_stop(dev_id);
350 /* After rte_bbdev_start(dev_id):
351 * - queue should be still stopped if deferred_start ==
353 rte_bbdev_start(dev_id);
355 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
357 "Failed test for rte_bbdev_info_get: "
358 "invalid return value from "
359 "rte_bbdev_queue_info_get function: %i", return_value);
361 TEST_ASSERT(qinfo.started == 0,
362 "Failed test for rte_bbdev_queue_info_get: "
363 "invalid value for qinfo.started:%u", qinfo.started);
365 rte_bbdev_stop(dev_id);
367 /* After rte_bbdev_start(dev_id):
368 * - queue should be started if deferred_start ==
370 ts_params->qconf.deferred_start = 0;
371 rte_bbdev_queue_configure(dev_id, queue_id, &ts_params->qconf);
372 rte_bbdev_start(dev_id);
374 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
376 "Failed test for rte_bbdev_info_get: "
377 "invalid return value from "
378 "rte_bbdev_queue_info_get function: %i", return_value);
380 TEST_ASSERT(qinfo.started == 1,
381 "Failed test for rte_bbdev_queue_info_get: "
382 "invalid value for qinfo.started:%u", qinfo.started);
388 test_bbdev_configure_invalid_queue_configure(void)
390 struct bbdev_testsuite_params *ts_params = &testsuite_params;
392 struct rte_bbdev_info info;
396 /* Valid dev_id values */
397 dev_id = null_dev_id;
399 /* Valid queue_id values */
402 rte_bbdev_stop(dev_id);
404 TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
405 "Failed test for rte_bbdev_info_get: "
406 "invalid return value:%i", return_value);
408 rte_bbdev_queue_stop(dev_id, queue_id);
410 ts_params->qconf.queue_size = info.drv.queue_size_lim + 1;
411 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
413 "Failed test for rte_bbdev_queue_configure: "
414 "invalid value qconf.queue_size: %u",
415 ts_params->qconf.queue_size);
417 ts_params->qconf.queue_size = info.drv.queue_size_lim;
418 ts_params->qconf.priority = info.drv.max_ul_queue_priority;
419 queue_id = info.num_queues;
420 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
422 "Failed test for rte_bbdev_queue_configure: "
423 "invalid value queue_id: %u", queue_id);
426 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
427 "Failed test for rte_bbdev_queue_configure: "
428 "NULL qconf structure ");
430 ts_params->qconf.socket = RTE_MAX_NUMA_NODES;
431 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
433 "Failed test for rte_bbdev_queue_configure: "
434 "invalid socket number ");
436 ts_params->qconf.socket = SOCKET_ID_ANY;
437 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
439 "Failed test for rte_bbdev_queue_configure: "
440 "invalid value qconf.queue_size: %u",
441 ts_params->qconf.queue_size);
443 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS, queue_id,
445 "Failed test for rte_bbdev_queue_configure: "
448 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
449 "Failed test for rte_bbdev_queue_configure: "
450 "invalid value qconf.queue_size: %u",
451 ts_params->qconf.queue_size);
457 test_bbdev_op_pool(void)
459 struct rte_mempool *mp;
461 unsigned int dec_size = sizeof(struct rte_bbdev_dec_op);
462 unsigned int enc_size = sizeof(struct rte_bbdev_enc_op);
464 const char *pool_dec = "Test_DEC";
465 const char *pool_enc = "Test_ENC";
467 /* Valid pool configuration */
469 uint32_t cache_size = 128;
471 TEST_ASSERT(rte_bbdev_op_pool_create(NULL,
472 RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0) == NULL,
473 "Failed test for rte_bbdev_op_pool_create: "
474 "NULL name parameter");
476 TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_dec,
477 RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0)) != NULL,
478 "Failed test for rte_bbdev_op_pool_create: "
479 "returned value is empty");
481 TEST_ASSERT(mp->size == size,
482 "Failed test for rte_bbdev_op_pool_create: "
483 "invalid size of the mempool, mp->size: %u", mp->size);
485 TEST_ASSERT(mp->cache_size == cache_size,
486 "Failed test for rte_bbdev_op_pool_create: "
487 "invalid size of the mempool, mp->size: %u",
490 TEST_ASSERT_SUCCESS(strcmp(mp->name, pool_dec),
491 "Failed test for rte_bbdev_op_pool_create: "
492 "invalid name of mempool, mp->name: %s", mp->name);
494 TEST_ASSERT(mp->elt_size == dec_size,
495 "Failed test for rte_bbdev_op_pool_create: "
496 "invalid element size for RTE_BBDEV_OP_TURBO_DEC, "
497 "mp->elt_size: %u", mp->elt_size);
499 rte_mempool_free(mp);
501 TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_enc,
502 RTE_BBDEV_OP_TURBO_ENC, size, cache_size, 0)) != NULL,
503 "Failed test for rte_bbdev_op_pool_create: "
504 "returned value is empty");
506 TEST_ASSERT(mp->elt_size == enc_size,
507 "Failed test for rte_bbdev_op_pool_create: "
508 "invalid element size for RTE_BBDEV_OP_TURBO_ENC, "
509 "mp->elt_size: %u", mp->elt_size);
511 rte_mempool_free(mp);
513 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_NONE",
514 RTE_BBDEV_OP_NONE, size, cache_size, 0)) != NULL,
515 "Failed test for rte_bbdev_op_pool_create: "
516 "returned value is empty for RTE_BBDEV_OP_NONE");
518 TEST_ASSERT(mp->elt_size == (enc_size > dec_size ? enc_size : dec_size),
519 "Failed test for rte_bbdev_op_pool_create: "
520 "invalid size for RTE_BBDEV_OP_NONE, mp->elt_size: %u",
523 rte_mempool_free(mp);
525 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_INV",
526 RTE_BBDEV_OP_TYPE_COUNT, size, cache_size, 0)) == NULL,
527 "Failed test for rte_bbdev_op_pool_create: "
528 "returned value is not NULL for invalid type");
530 /* Invalid pool configuration */
534 TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_InvSize",
535 RTE_BBDEV_OP_NONE, size, cache_size, 0)) == NULL,
536 "Failed test for rte_bbdev_op_pool_create: "
537 "returned value should be empty "
538 "because size of per-lcore local cache "
539 "is greater than size of the mempool.");
545 * Create pool of OP types RTE_BBDEV_OP_NONE, RTE_BBDEV_OP_TURBO_DEC and
546 * RTE_BBDEV_OP_TURBO_ENC and check that only ops of that type can be
550 test_bbdev_op_type(void)
552 struct rte_mempool *mp_dec;
554 const unsigned int OPS_COUNT = 32;
555 struct rte_bbdev_dec_op *dec_ops_arr[OPS_COUNT];
556 struct rte_bbdev_enc_op *enc_ops_arr[OPS_COUNT];
558 const char *pool_dec = "Test_op_dec";
560 /* Valid pool configuration */
561 uint32_t num_elements = 256;
562 uint32_t cache_size = 128;
564 /* mempool type : RTE_BBDEV_OP_TURBO_DEC */
565 mp_dec = rte_bbdev_op_pool_create(pool_dec,
566 RTE_BBDEV_OP_TURBO_DEC, num_elements, cache_size, 0);
567 TEST_ASSERT(mp_dec != NULL, "Failed to create %s mempool", pool_dec);
569 TEST_ASSERT(rte_bbdev_dec_op_alloc_bulk(mp_dec, dec_ops_arr, 1) == 0,
570 "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
571 "OPs type: RTE_BBDEV_OP_TURBO_DEC");
573 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_dec, enc_ops_arr, 1) != 0,
574 "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
575 "OPs type: RTE_BBDEV_OP_TURBO_ENC");
577 rte_mempool_free(mp_dec);
583 test_bbdev_op_pool_size(void)
585 struct rte_mempool *mp_none;
587 const unsigned int OPS_COUNT = 128;
588 struct rte_bbdev_enc_op *ops_enc_arr[OPS_COUNT];
589 struct rte_bbdev_enc_op *ops_ext_arr[OPS_COUNT];
590 struct rte_bbdev_enc_op *ops_ext2_arr[OPS_COUNT];
592 const char *pool_none = "Test_pool_size";
594 /* Valid pool configuration */
595 uint32_t num_elements = 256;
596 uint32_t cache_size = 0;
598 /* Create mempool type : RTE_BBDEV_OP_TURBO_ENC, size : 256 */
599 mp_none = rte_bbdev_op_pool_create(pool_none, RTE_BBDEV_OP_TURBO_ENC,
600 num_elements, cache_size, 0);
601 TEST_ASSERT(mp_none != NULL, "Failed to create %s mempool", pool_none);
603 /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
604 rte_bbdev_enc_op_alloc_bulk(mp_none, ops_enc_arr, OPS_COUNT);
606 /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
607 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext_arr,
609 "Failed test for allocating bbdev ops: "
610 "Mempool size: 256, Free : 128, Attempted to add: 128");
612 /* Try adding 128 more RTE_BBDEV_OP_TURBO_ENC ops, this should fail */
613 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
615 "Failed test for allocating bbdev ops: "
616 "Mempool size: 256, Free : 0, Attempted to add: 128");
618 /* Free-up 128 RTE_BBDEV_OP_TURBO_ENC ops */
619 rte_bbdev_enc_op_free_bulk(ops_enc_arr, OPS_COUNT);
621 /* Try adding 128 RTE_BBDEV_OP_TURBO_DEC ops, this should succeed */
622 /* Cache size > 0 causes reallocation of ops size > 127 fail */
623 TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
625 "Failed test for allocating ops after mempool freed: "
626 "Mempool size: 256, Free : 128, Attempted to add: 128");
628 rte_mempool_free(mp_none);
634 test_bbdev_count(void)
636 uint8_t num_devs, num_valid_devs = 0;
638 for (num_devs = 0; num_devs < RTE_BBDEV_MAX_DEVS; num_devs++) {
639 if (rte_bbdev_is_valid(num_devs))
643 num_devs = rte_bbdev_count();
644 TEST_ASSERT(num_valid_devs == num_devs,
645 "Failed test for rte_bbdev_is_valid: "
646 "invalid num_devs %u ", num_devs);
652 test_bbdev_stats(void)
654 uint8_t dev_id = null_dev_id;
655 uint16_t queue_id = 0;
656 struct rte_bbdev_dec_op *dec_ops[4096] = { 0 };
657 struct rte_bbdev_dec_op *dec_proc_ops[4096] = { 0 };
658 struct rte_bbdev_enc_op *enc_ops[4096] = { 0 };
659 struct rte_bbdev_enc_op *enc_proc_ops[4096] = { 0 };
660 uint16_t num_ops = 236;
661 struct rte_bbdev_stats stats;
662 struct bbdev_testsuite_params *ts_params = &testsuite_params;
664 TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
665 "Failed to stop queue %u on device %u ", queue_id,
667 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
668 "Failed to stop bbdev %u ", dev_id);
670 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
672 "Failed to configure queue %u on device %u ",
675 TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
676 "Failed to start bbdev %u ", dev_id);
678 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
679 "Failed to start queue %u on device %u ", queue_id,
682 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
683 "Failed to start queue %u on device %u ", queue_id,
686 /* Tests after enqueue operation */
687 rte_bbdev_enqueue_enc_ops(dev_id, queue_id, enc_ops, num_ops);
688 rte_bbdev_enqueue_dec_ops(dev_id, queue_id, dec_ops, num_ops);
690 TEST_ASSERT_FAIL(rte_bbdev_stats_get(RTE_BBDEV_MAX_DEVS, &stats),
691 "Failed test for rte_bbdev_stats_get on device %u ",
694 TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, NULL),
695 "Failed test for rte_bbdev_stats_get on device %u ",
698 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
699 "Failed test for rte_bbdev_stats_get on device %u ",
702 TEST_ASSERT(stats.enqueued_count == 2 * num_ops,
703 "Failed test for rte_bbdev_enqueue_ops: "
704 "invalid enqueued_count %" PRIu64 " ",
705 stats.enqueued_count);
707 TEST_ASSERT(stats.dequeued_count == 0,
708 "Failed test for rte_bbdev_stats_reset: "
709 "invalid dequeued_count %" PRIu64 " ",
710 stats.dequeued_count);
712 /* Tests after dequeue operation */
713 rte_bbdev_dequeue_enc_ops(dev_id, queue_id, enc_proc_ops, num_ops);
714 rte_bbdev_dequeue_dec_ops(dev_id, queue_id, dec_proc_ops, num_ops);
716 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
717 "Failed test for rte_bbdev_stats_get on device %u ",
720 TEST_ASSERT(stats.dequeued_count == 2 * num_ops,
721 "Failed test for rte_bbdev_dequeue_ops: "
722 "invalid enqueued_count %" PRIu64 " ",
723 stats.dequeued_count);
725 TEST_ASSERT(stats.enqueue_err_count == 0,
726 "Failed test for rte_bbdev_stats_reset: "
727 "invalid enqueue_err_count %" PRIu64 " ",
728 stats.enqueue_err_count);
730 TEST_ASSERT(stats.dequeue_err_count == 0,
731 "Failed test for rte_bbdev_stats_reset: "
732 "invalid dequeue_err_count %" PRIu64 " ",
733 stats.dequeue_err_count);
735 /* Tests after reset operation */
736 TEST_ASSERT_FAIL(rte_bbdev_stats_reset(RTE_BBDEV_MAX_DEVS),
737 "Failed to reset statistic for device %u ", dev_id);
739 TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
740 "Failed to reset statistic for device %u ", dev_id);
741 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
742 "Failed test for rte_bbdev_stats_get on device %u ",
745 TEST_ASSERT(stats.enqueued_count == 0,
746 "Failed test for rte_bbdev_stats_reset: "
747 "invalid enqueued_count %" PRIu64 " ",
748 stats.enqueued_count);
750 TEST_ASSERT(stats.dequeued_count == 0,
751 "Failed test for rte_bbdev_stats_reset: "
752 "invalid dequeued_count %" PRIu64 " ",
753 stats.dequeued_count);
755 TEST_ASSERT(stats.enqueue_err_count == 0,
756 "Failed test for rte_bbdev_stats_reset: "
757 "invalid enqueue_err_count %" PRIu64 " ",
758 stats.enqueue_err_count);
760 TEST_ASSERT(stats.dequeue_err_count == 0,
761 "Failed test for rte_bbdev_stats_reset: "
762 "invalid dequeue_err_count %" PRIu64 " ",
763 stats.dequeue_err_count);
769 test_bbdev_driver_init(void)
771 struct rte_bbdev *dev1, *dev2;
772 const char *name = "dev_name";
774 int num_devs, num_devs_tmp;
776 dev1 = rte_bbdev_allocate(NULL);
777 TEST_ASSERT(dev1 == NULL,
778 "Failed initialize bbdev driver with NULL name");
780 dev1 = rte_bbdev_allocate(name);
781 TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
783 dev2 = rte_bbdev_allocate(name);
784 TEST_ASSERT(dev2 == NULL,
785 "Failed to initialize bbdev driver: "
786 "driver with the same name has been initialized before");
788 num_devs = rte_bbdev_count() - 1;
789 num_devs_tmp = num_devs;
791 /* Initialize the maximum amount of devices */
793 snprintf(name_tmp, sizeof(name_tmp), "%s%i", "name_", num_devs);
794 dev2 = rte_bbdev_allocate(name_tmp);
795 TEST_ASSERT(dev2 != NULL,
796 "Failed to initialize bbdev driver");
798 } while (num_devs < (RTE_BBDEV_MAX_DEVS - 1));
800 snprintf(name_tmp, sizeof(name_tmp), "%s%i", "name_", num_devs);
801 dev2 = rte_bbdev_allocate(name_tmp);
802 TEST_ASSERT(dev2 == NULL, "Failed to initialize bbdev driver number %d "
803 "more drivers than RTE_BBDEV_MAX_DEVS: %d ", num_devs,
808 while (num_devs >= num_devs_tmp) {
809 snprintf(name_tmp, sizeof(name_tmp), "%s%i", "name_", num_devs);
810 dev2 = rte_bbdev_get_named_dev(name_tmp);
811 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
812 "Failed to uninitialize bbdev driver %s ",
817 TEST_ASSERT(dev1->data->dev_id < RTE_BBDEV_MAX_DEVS,
818 "Failed test rte_bbdev_allocate: "
819 "invalid dev_id %" PRIu8 ", max number of devices %d ",
820 dev1->data->dev_id, RTE_BBDEV_MAX_DEVS);
822 TEST_ASSERT(dev1->state == RTE_BBDEV_INITIALIZED,
823 "Failed test rte_bbdev_allocate: "
824 "invalid state %d (0 - RTE_BBDEV_UNUSED, 1 - RTE_BBDEV_INITIALIZED",
827 TEST_ASSERT_FAIL(rte_bbdev_release(NULL),
828 "Failed to uninitialize bbdev driver with NULL bbdev");
830 strlcpy(name_tmp, "invalid_name", sizeof(name_tmp));
831 dev2 = rte_bbdev_get_named_dev(name_tmp);
832 TEST_ASSERT_FAIL(rte_bbdev_release(dev2),
833 "Failed to uninitialize bbdev driver with invalid name");
835 dev2 = rte_bbdev_get_named_dev(name);
836 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
837 "Failed to uninitialize bbdev driver: %s ", name);
843 event_callback(uint16_t dev_id, enum rte_bbdev_event_type type, void *param,
846 RTE_SET_USED(dev_id);
847 RTE_SET_USED(ret_param);
852 if (type == RTE_BBDEV_EVENT_UNKNOWN ||
853 type == RTE_BBDEV_EVENT_ERROR ||
854 type == RTE_BBDEV_EVENT_MAX)
855 *(int *)param = type;
859 test_bbdev_callback(void)
861 struct rte_bbdev *dev1, *dev2;
862 const char *name = "dev_name1";
863 const char *name2 = "dev_name2";
865 uint8_t invalid_dev_id = RTE_BBDEV_MAX_DEVS;
866 enum rte_bbdev_event_type invalid_event_type = RTE_BBDEV_EVENT_MAX;
869 dev1 = rte_bbdev_allocate(name);
870 TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
873 * RTE_BBDEV_EVENT_UNKNOWN - unregistered
874 * RTE_BBDEV_EVENT_ERROR - unregistered
877 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
878 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
879 TEST_ASSERT(event_status == -1,
880 "Failed test for rte_bbdev_pmd_callback_process: "
881 "events were not registered ");
883 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
884 RTE_BBDEV_EVENT_MAX, event_callback, NULL),
885 "Failed to callback register for RTE_BBDEV_EVENT_MAX ");
887 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
888 RTE_BBDEV_EVENT_MAX, event_callback, NULL),
889 "Failed to unregister RTE_BBDEV_EVENT_MAX ");
892 * RTE_BBDEV_EVENT_UNKNOWN - registered
893 * RTE_BBDEV_EVENT_ERROR - unregistered
895 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
896 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
897 "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
899 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
900 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
901 "Failed test for rte_bbdev_pmd_callback_process "
902 "for RTE_BBDEV_EVENT_UNKNOWN ");
904 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
905 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
906 "Failed test for rte_bbdev_pmd_callback_process: "
907 "event RTE_BBDEV_EVENT_ERROR was not registered ");
910 * RTE_BBDEV_EVENT_UNKNOWN - registered
911 * RTE_BBDEV_EVENT_ERROR - registered
913 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
914 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
915 "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR ");
917 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
918 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
919 "Failed to callback register for RTE_BBDEV_EVENT_ERROR"
920 "(re-registration) ");
923 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
924 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
925 "Failed test for rte_bbdev_pmd_callback_process "
926 "for RTE_BBDEV_EVENT_UNKNOWN ");
928 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
929 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_ERROR,
930 "Failed test for rte_bbdev_pmd_callback_process "
931 "for RTE_BBDEV_EVENT_ERROR ");
934 * RTE_BBDEV_EVENT_UNKNOWN - registered
935 * RTE_BBDEV_EVENT_ERROR - unregistered
937 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev1->data->dev_id,
938 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
939 "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
942 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
943 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
944 "Failed test for rte_bbdev_pmd_callback_process "
945 "for RTE_BBDEV_EVENT_UNKNOWN ");
947 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
948 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
949 "Failed test for rte_bbdev_pmd_callback_process: "
950 "event RTE_BBDEV_EVENT_ERROR was unregistered ");
952 /* rte_bbdev_callback_register with invalid inputs */
953 TEST_ASSERT_FAIL(rte_bbdev_callback_register(invalid_dev_id,
954 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
955 "Failed test for rte_bbdev_callback_register "
956 "for invalid_dev_id ");
958 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
959 invalid_event_type, event_callback, &event_status),
960 "Failed to callback register for invalid event type ");
962 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
963 RTE_BBDEV_EVENT_ERROR, NULL, &event_status),
964 "Failed to callback register - no callback function ");
966 /* The impact of devices on each other */
967 dev2 = rte_bbdev_allocate(name2);
968 TEST_ASSERT(dev2 != NULL,
969 "Failed to initialize bbdev driver");
973 * RTE_BBDEV_EVENT_UNKNOWN - unregistered
974 * RTE_BBDEV_EVENT_ERROR - unregistered
977 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
978 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
979 TEST_ASSERT(event_status == -1,
980 "Failed test for rte_bbdev_pmd_callback_process: "
981 "events were not registered ");
984 * dev1: RTE_BBDEV_EVENT_ERROR - unregistered
985 * dev2: RTE_BBDEV_EVENT_ERROR - registered
987 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
988 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
989 "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR");
991 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
992 TEST_ASSERT(event_status == -1,
993 "Failed test for rte_bbdev_pmd_callback_process in dev1 "
994 "for RTE_BBDEV_EVENT_ERROR ");
996 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
997 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_ERROR,
998 "Failed test for rte_bbdev_pmd_callback_process in dev2 "
999 "for RTE_BBDEV_EVENT_ERROR ");
1002 * dev1: RTE_BBDEV_EVENT_UNKNOWN - registered
1003 * dev2: RTE_BBDEV_EVENT_UNKNOWN - unregistered
1005 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
1006 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1007 "Failed to callback register for RTE_BBDEV_EVENT_UNKNOWN "
1010 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1011 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
1012 "Failed test for rte_bbdev_pmd_callback_process in dev2"
1013 " for RTE_BBDEV_EVENT_UNKNOWN ");
1015 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1016 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1017 "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN ");
1019 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1020 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1021 "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN : "
1022 "unregister function called once again ");
1025 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1026 TEST_ASSERT(event_status == -1,
1027 "Failed test for rte_bbdev_pmd_callback_process in dev2"
1028 " for RTE_BBDEV_EVENT_UNKNOWN ");
1030 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1031 TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
1032 "Failed test for rte_bbdev_pmd_callback_process in dev2 "
1033 "for RTE_BBDEV_EVENT_UNKNOWN ");
1035 /* rte_bbdev_pmd_callback_process with invalid inputs */
1036 rte_bbdev_pmd_callback_process(NULL, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1039 rte_bbdev_pmd_callback_process(dev1, invalid_event_type, NULL);
1040 TEST_ASSERT(event_status == -1,
1041 "Failed test for rte_bbdev_pmd_callback_process: "
1042 "for invalid event type ");
1044 /* rte_dev_callback_unregister with invalid inputs */
1045 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(invalid_dev_id,
1046 RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1047 "Failed test for rte_dev_callback_unregister "
1048 "for invalid_dev_id ");
1050 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1051 invalid_event_type, event_callback, &event_status),
1052 "Failed rte_dev_callback_unregister "
1053 "for invalid event type ");
1055 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1056 invalid_event_type, NULL, &event_status),
1057 "Failed rte_dev_callback_unregister "
1058 "when no callback function ");
1060 dev_id = dev1->data->dev_id;
1062 rte_bbdev_release(dev1);
1063 rte_bbdev_release(dev2);
1065 TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev_id,
1066 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1067 "Failed test for rte_bbdev_callback_register: "
1068 "function called after rte_bbdev_driver_uninit .");
1070 TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev_id,
1071 RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1072 "Failed test for rte_dev_callback_unregister: "
1073 "function called after rte_bbdev_driver_uninit. ");
1076 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1077 rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
1078 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1079 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
1080 TEST_ASSERT(event_status == -1,
1081 "Failed test for rte_bbdev_pmd_callback_process: "
1082 "callback function was called after rte_bbdev_driver_uninit");
1084 return TEST_SUCCESS;
1088 test_bbdev_invalid_driver(void)
1090 struct rte_bbdev dev1, *dev2;
1091 uint8_t dev_id = null_dev_id;
1092 uint16_t queue_id = 0;
1093 struct rte_bbdev_stats stats;
1094 struct bbdev_testsuite_params *ts_params = &testsuite_params;
1095 struct rte_bbdev_queue_info qinfo;
1096 struct rte_bbdev_ops dev_ops_tmp;
1098 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u ",
1101 dev1 = rte_bbdev_devices[dev_id];
1102 dev2 = &rte_bbdev_devices[dev_id];
1104 /* Tests for rte_bbdev_setup_queues */
1105 dev2->dev_ops = NULL;
1106 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1107 "Failed test for rte_bbdev_setup_queues: "
1108 "NULL dev_ops structure ");
1109 dev2->dev_ops = dev1.dev_ops;
1111 dev_ops_tmp = *dev2->dev_ops;
1112 dev_ops_tmp.info_get = NULL;
1113 dev2->dev_ops = &dev_ops_tmp;
1114 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1115 "Failed test for rte_bbdev_setup_queues: "
1117 dev2->dev_ops = dev1.dev_ops;
1119 dev_ops_tmp = *dev2->dev_ops;
1120 dev_ops_tmp.queue_release = NULL;
1121 dev2->dev_ops = &dev_ops_tmp;
1122 TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1123 "Failed test for rte_bbdev_setup_queues: "
1124 "NULL queue_release ");
1125 dev2->dev_ops = dev1.dev_ops;
1127 dev2->data->socket_id = SOCKET_ID_ANY;
1128 TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, 1,
1129 SOCKET_ID_ANY), "Failed to configure bbdev %u", dev_id);
1131 /* Test for rte_bbdev_queue_configure */
1132 dev2->dev_ops = NULL;
1133 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1135 "Failed to configure queue %u on device %u "
1136 "with NULL dev_ops structure ", queue_id, dev_id);
1137 dev2->dev_ops = dev1.dev_ops;
1139 dev_ops_tmp = *dev2->dev_ops;
1140 dev_ops_tmp.queue_setup = NULL;
1141 dev2->dev_ops = &dev_ops_tmp;
1142 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1144 "Failed to configure queue %u on device %u "
1145 "with NULL queue_setup ", queue_id, dev_id);
1146 dev2->dev_ops = dev1.dev_ops;
1148 dev_ops_tmp = *dev2->dev_ops;
1149 dev_ops_tmp.info_get = NULL;
1150 dev2->dev_ops = &dev_ops_tmp;
1151 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1153 "Failed to configure queue %u on device %u "
1154 "with NULL info_get ", queue_id, dev_id);
1155 dev2->dev_ops = dev1.dev_ops;
1157 TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS,
1158 queue_id, &ts_params->qconf),
1159 "Failed to configure queue %u on device %u ",
1162 TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
1164 "Failed to configure queue %u on device %u ",
1167 /* Test for rte_bbdev_queue_info_get */
1168 dev2->dev_ops = NULL;
1169 TEST_ASSERT_SUCCESS(rte_bbdev_queue_info_get(dev_id, queue_id, &qinfo),
1170 "Failed test for rte_bbdev_info_get: "
1171 "NULL dev_ops structure ");
1172 dev2->dev_ops = dev1.dev_ops;
1174 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(RTE_BBDEV_MAX_DEVS,
1176 "Failed test for rte_bbdev_info_get: "
1179 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id,
1180 RTE_MAX_QUEUES_PER_PORT, &qinfo),
1181 "Failed test for rte_bbdev_info_get: "
1182 "invalid queue_id ");
1184 TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id, queue_id, NULL),
1185 "Failed test for rte_bbdev_info_get: "
1186 "invalid dev_info ");
1188 /* Test for rte_bbdev_start */
1189 dev2->dev_ops = NULL;
1190 TEST_ASSERT_FAIL(rte_bbdev_start(dev_id),
1191 "Failed to start bbdev %u "
1192 "with NULL dev_ops structure ", dev_id);
1193 dev2->dev_ops = dev1.dev_ops;
1195 TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
1196 "Failed to start bbdev %u ", dev_id);
1198 /* Test for rte_bbdev_queue_start */
1199 dev2->dev_ops = NULL;
1200 TEST_ASSERT_FAIL(rte_bbdev_queue_start(dev_id, queue_id),
1201 "Failed to start queue %u on device %u: "
1202 "NULL dev_ops structure", queue_id, dev_id);
1203 dev2->dev_ops = dev1.dev_ops;
1205 TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
1206 "Failed to start queue %u on device %u ", queue_id,
1209 /* Tests for rte_bbdev_stats_get */
1210 dev2->dev_ops = NULL;
1211 TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, &stats),
1212 "Failed test for rte_bbdev_stats_get on device %u ",
1214 dev2->dev_ops = dev1.dev_ops;
1216 dev_ops_tmp = *dev2->dev_ops;
1217 dev_ops_tmp.stats_reset = NULL;
1218 dev2->dev_ops = &dev_ops_tmp;
1219 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1220 "Failed test for rte_bbdev_stats_get: "
1222 dev2->dev_ops = dev1.dev_ops;
1224 TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1225 "Failed test for rte_bbdev_stats_get on device %u ",
1230 * rte_bbdev_callback_register,
1231 * rte_bbdev_pmd_callback_process,
1232 * rte_dev_callback_unregister
1234 dev2->dev_ops = NULL;
1235 TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev_id,
1236 RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1237 "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
1238 rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1240 TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev_id,
1241 RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1242 "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
1243 dev2->dev_ops = dev1.dev_ops;
1245 /* Tests for rte_bbdev_stats_reset */
1246 dev2->dev_ops = NULL;
1247 TEST_ASSERT_FAIL(rte_bbdev_stats_reset(dev_id),
1248 "Failed to reset statistic for device %u ", dev_id);
1249 dev2->dev_ops = dev1.dev_ops;
1251 dev_ops_tmp = *dev2->dev_ops;
1252 dev_ops_tmp.stats_reset = NULL;
1253 dev2->dev_ops = &dev_ops_tmp;
1254 TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1255 "Failed test for rte_bbdev_stats_reset: "
1256 "NULL stats_reset ");
1257 dev2->dev_ops = dev1.dev_ops;
1259 TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1260 "Failed to reset statistic for device %u ", dev_id);
1262 /* Tests for rte_bbdev_queue_stop */
1263 dev2->dev_ops = NULL;
1264 TEST_ASSERT_FAIL(rte_bbdev_queue_stop(dev_id, queue_id),
1265 "Failed to stop queue %u on device %u: "
1266 "NULL dev_ops structure", queue_id, dev_id);
1267 dev2->dev_ops = dev1.dev_ops;
1269 TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
1270 "Failed to stop queue %u on device %u ", queue_id,
1273 /* Tests for rte_bbdev_stop */
1274 dev2->dev_ops = NULL;
1275 TEST_ASSERT_FAIL(rte_bbdev_stop(dev_id),
1276 "Failed to stop bbdev %u with NULL dev_ops structure ",
1278 dev2->dev_ops = dev1.dev_ops;
1280 TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
1281 "Failed to stop bbdev %u ", dev_id);
1283 /* Tests for rte_bbdev_close */
1284 TEST_ASSERT_FAIL(rte_bbdev_close(RTE_BBDEV_MAX_DEVS),
1285 "Failed to close bbdev with invalid dev_id");
1287 dev2->dev_ops = NULL;
1288 TEST_ASSERT_FAIL(rte_bbdev_close(dev_id),
1289 "Failed to close bbdev %u with NULL dev_ops structure ",
1291 dev2->dev_ops = dev1.dev_ops;
1293 TEST_ASSERT_SUCCESS(rte_bbdev_close(dev_id),
1294 "Failed to close bbdev %u ", dev_id);
1296 return TEST_SUCCESS;
1300 test_bbdev_get_named_dev(void)
1302 struct rte_bbdev *dev, *dev_tmp;
1303 const char *name = "name";
1305 dev = rte_bbdev_allocate(name);
1306 TEST_ASSERT(dev != NULL, "Failed to initialize bbdev driver");
1308 dev_tmp = rte_bbdev_get_named_dev(NULL);
1309 TEST_ASSERT(dev_tmp == NULL, "Failed test for rte_bbdev_get_named_dev: "
1310 "function called with NULL parameter");
1312 dev_tmp = rte_bbdev_get_named_dev(name);
1314 TEST_ASSERT(dev == dev_tmp, "Failed test for rte_bbdev_get_named_dev: "
1315 "wrong device was returned ");
1317 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev),
1318 "Failed to uninitialize bbdev driver %s ", name);
1320 return TEST_SUCCESS;
1323 static struct unit_test_suite bbdev_null_testsuite = {
1324 .suite_name = "BBDEV NULL Unit Test Suite",
1325 .setup = testsuite_setup,
1326 .teardown = testsuite_teardown,
1327 .unit_test_cases = {
1329 TEST_CASE(test_bbdev_configure_invalid_dev_id),
1331 TEST_CASE_ST(ut_setup, ut_teardown,
1332 test_bbdev_configure_invalid_num_queues),
1334 TEST_CASE_ST(ut_setup, ut_teardown,
1335 test_bbdev_configure_stop_device),
1337 TEST_CASE_ST(ut_setup, ut_teardown,
1338 test_bbdev_configure_stop_queue),
1340 TEST_CASE_ST(ut_setup, ut_teardown,
1341 test_bbdev_configure_invalid_queue_configure),
1343 TEST_CASE_ST(ut_setup, ut_teardown,
1344 test_bbdev_op_pool),
1346 TEST_CASE_ST(ut_setup, ut_teardown,
1347 test_bbdev_op_type),
1349 TEST_CASE_ST(ut_setup, ut_teardown,
1350 test_bbdev_op_pool_size),
1352 TEST_CASE_ST(ut_setup, ut_teardown,
1355 TEST_CASE_ST(ut_setup, ut_teardown,
1356 test_bbdev_driver_init),
1358 TEST_CASE_ST(ut_setup, ut_teardown,
1359 test_bbdev_callback),
1361 TEST_CASE_ST(ut_setup, ut_teardown,
1362 test_bbdev_invalid_driver),
1364 TEST_CASE_ST(ut_setup, ut_teardown,
1365 test_bbdev_get_named_dev),
1367 TEST_CASE(test_bbdev_count),
1369 TEST_CASES_END() /**< NULL terminate unit test array */
1373 REGISTER_TEST_COMMAND(unittest, bbdev_null_testsuite);