app/test-bbdev/test_bbdev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Intel Corporation
   3  */
   4
   5 #include <rte_common.h>
   6 #include <rte_hexdump.h>
   7 #include <rte_mbuf.h>
   8 #include <rte_malloc.h>
   9 #include <rte_memcpy.h>
  10 #include <rte_cycles.h>
  11
  12 #include <rte_bus_vdev.h>
  13
  14 #include <rte_bbdev.h>
  15 #include <rte_bbdev_op.h>
  16 #include <rte_bbdev_pmd.h>
  17 #include<string.h>
  18 #include <rte_string_fns.h>
  19
  20 #include "main.h"
  21
  22
  23 #define BBDEV_NAME_NULL          ("bbdev_null")
  24
  25 struct bbdev_testsuite_params {
  26         struct rte_bbdev_queue_conf qconf;
  27 };
  28
  29 static struct bbdev_testsuite_params testsuite_params;
  30
  31 static uint8_t null_dev_id;
  32
  33 static int
  34 testsuite_setup(void)
  35 {
  36         uint8_t nb_devs;
  37         int ret;
  38         char buf[RTE_BBDEV_NAME_MAX_LEN];
  39
  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);
  44
  45         nb_devs = rte_bbdev_count();
  46         TEST_ASSERT(nb_devs != 0, "No devices found");
  47
  48         /* Most recently created device is our device */
  49         null_dev_id = nb_devs - 1;
  50
  51         return TEST_SUCCESS;
  52 }
  53
  54 static void
  55 testsuite_teardown(void)
  56 {
  57         char buf[RTE_BBDEV_NAME_MAX_LEN];
  58
  59         snprintf(buf, sizeof(buf), "%s_unittest", BBDEV_NAME_NULL);
  60         rte_vdev_uninit(buf);
  61 }
  62
  63 static int
  64 ut_setup(void)
  65 {
  66         struct bbdev_testsuite_params *ts_params = &testsuite_params;
  67         uint8_t num_queues;
  68
  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;
  73
  74         num_queues = 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",
  77                         0);
  78
  79         /* Start the device */
  80         TEST_ASSERT_SUCCESS(rte_bbdev_start(null_dev_id),
  81                         "Failed to start bbdev %u", 0);
  82
  83         return TEST_SUCCESS;
  84 }
  85
  86 static void
  87 ut_teardown(void)
  88 {
  89         rte_bbdev_close(null_dev_id);
  90 }
  91
  92 static int
  93 test_bbdev_configure_invalid_dev_id(void)
  94 {
  95         uint8_t dev_id;
  96         uint8_t num_queues;
  97
  98         num_queues = 1;
  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);
 108                         break;
 109                 }
 110         }
 111
 112         return TEST_SUCCESS;
 113 }
 114
 115 static int
 116 test_bbdev_configure_invalid_num_queues(void)
 117 {
 118         struct rte_bbdev_info info;
 119         uint8_t dev_id, num_devs;
 120         uint8_t num_queues;
 121         int return_value;
 122
 123         TEST_ASSERT((num_devs = rte_bbdev_count()) >= 1,
 124                         "Need at least %d devices for test", 1);
 125
 126         /* valid num_queues values */
 127         num_queues = 8;
 128
 129         /* valid dev_id values */
 130         dev_id = null_dev_id;
 131
 132         /* Stop the device in case it's started so it can be configured */
 133         rte_bbdev_stop(dev_id);
 134
 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);
 138
 139         TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, num_queues,
 140                         SOCKET_ID_ANY),
 141                         "Failed test for rte_bbdev_setup_queues: "
 142                         "invalid dev_num %u", dev_id);
 143
 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);
 147
 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);
 151
 152         TEST_ASSERT(info.num_queues == num_queues,
 153                         "Failed test for rte_bbdev_info_get: "
 154                         "invalid num_queues:%u", info.num_queues);
 155
 156         num_queues = info.drv.max_num_queues;
 157         TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, num_queues,
 158                         SOCKET_ID_ANY),
 159                         "Failed test for rte_bbdev_setup_queues: "
 160                         "invalid num_queues: %u", num_queues);
 161
 162         num_queues++;
 163         TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, num_queues,
 164                         SOCKET_ID_ANY),
 165                         "Failed test for rte_bbdev_setup_queues: "
 166                         "invalid num_queues: %u", num_queues);
 167
 168         return TEST_SUCCESS;
 169 }
 170
 171 static int
 172 test_bbdev_configure_stop_device(void)
 173 {
 174         struct rte_bbdev_info info;
 175         uint8_t dev_id;
 176         int return_value;
 177
 178         /* valid dev_id values */
 179         dev_id = null_dev_id;
 180
 181         /* Stop the device so it can be configured */
 182         rte_bbdev_stop(dev_id);
 183
 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);
 188
 189         TEST_ASSERT_SUCCESS(info.started, "Failed test for rte_bbdev_info_get: "
 190                         "started value: %u", info.started);
 191
 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);
 196
 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",
 200                         dev_id);
 201
 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);
 205
 206         TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
 207                         "Failed to start bbdev %u", dev_id);
 208
 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);
 213
 214         TEST_ASSERT_FAIL(info.started, "Failed test for rte_bbdev_info_get: "
 215                         "started value: %u", info.started);
 216
 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);
 221
 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",
 225                         dev_id);
 226
 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);
 230
 231         TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u",
 232                         dev_id);
 233
 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);
 238
 239         TEST_ASSERT_SUCCESS(info.started, "Failed test for rte_bbdev_info_get: "
 240                         "started value: %u", info.started);
 241
 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);
 246
 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",
 250                         dev_id);
 251
 252         return TEST_SUCCESS;
 253 }
 254
 255 static int
 256 test_bbdev_configure_stop_queue(void)
 257 {
 258         struct bbdev_testsuite_params *ts_params = &testsuite_params;
 259         struct rte_bbdev_info info;
 260         struct rte_bbdev_queue_info qinfo;
 261         uint8_t dev_id;
 262         uint16_t queue_id;
 263         int return_value;
 264
 265         /* Valid dev_id values */
 266         dev_id = null_dev_id;
 267
 268         /* Valid queue_id values */
 269         queue_id = 0;
 270
 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);
 275
 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;
 279
 280         /* Device - started; queue - started */
 281         rte_bbdev_start(dev_id);
 282
 283         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 284                         &ts_params->qconf),
 285                         "Failed test for rte_bbdev_queue_configure: "
 286                         "queue:%u on device:%u should be stopped",
 287                          queue_id, dev_id);
 288
 289         /* Device - stopped; queue - started */
 290         rte_bbdev_stop(dev_id);
 291
 292         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 293                         &ts_params->qconf),
 294                         "Failed test for rte_bbdev_queue_configure: "
 295                         "queue:%u on device:%u should be stopped",
 296                          queue_id, dev_id);
 297
 298         TEST_ASSERT_FAIL(rte_bbdev_queue_stop(RTE_BBDEV_MAX_DEVS, queue_id),
 299                         "Failed test for rte_bbdev_queue_stop "
 300                         "invalid dev_id ");
 301
 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 ");
 305
 306         /* Device - stopped; queue - stopped */
 307         rte_bbdev_queue_stop(dev_id, queue_id);
 308
 309         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
 310                         &ts_params->qconf),
 311                         "Failed test for rte_bbdev_queue_configure: "
 312                         "queue:%u on device:%u should be stopped", queue_id,
 313                         dev_id);
 314
 315         TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
 316                         queue_id, &qinfo),
 317                         "Failed test for rte_bbdev_info_get: "
 318                         "invalid return value from "
 319                         "rte_bbdev_queue_info_get function: %i", return_value);
 320
 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);
 324
 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);
 328
 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);
 332
 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);
 337
 338         /* Device - started; queue - stopped */
 339         rte_bbdev_start(dev_id);
 340         rte_bbdev_queue_stop(dev_id, queue_id);
 341
 342         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 343                         &ts_params->qconf),
 344                         "Failed test for rte_bbdev_queue_configure: "
 345                         "queue:%u on device:%u should be stopped", queue_id,
 346                         dev_id);
 347
 348         rte_bbdev_stop(dev_id);
 349
 350         /* After rte_bbdev_start(dev_id):
 351          * - queue should be still stopped if deferred_start ==
 352          */
 353         rte_bbdev_start(dev_id);
 354
 355         TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
 356                         queue_id, &qinfo),
 357                         "Failed test for rte_bbdev_info_get: "
 358                         "invalid return value from "
 359                         "rte_bbdev_queue_info_get function: %i", return_value);
 360
 361         TEST_ASSERT(qinfo.started == 0,
 362                         "Failed test for rte_bbdev_queue_info_get: "
 363                         "invalid value for qinfo.started:%u", qinfo.started);
 364
 365         rte_bbdev_stop(dev_id);
 366
 367         /* After rte_bbdev_start(dev_id):
 368          * - queue should be started if deferred_start ==
 369          */
 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);
 373
 374         TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
 375                         queue_id, &qinfo),
 376                         "Failed test for rte_bbdev_info_get: "
 377                         "invalid return value from "
 378                         "rte_bbdev_queue_info_get function: %i", return_value);
 379
 380         TEST_ASSERT(qinfo.started == 1,
 381                         "Failed test for rte_bbdev_queue_info_get: "
 382                         "invalid value for qinfo.started:%u", qinfo.started);
 383
 384         return TEST_SUCCESS;
 385 }
 386
 387 static int
 388 test_bbdev_configure_invalid_queue_configure(void)
 389 {
 390         struct bbdev_testsuite_params *ts_params = &testsuite_params;
 391         int return_value;
 392         struct rte_bbdev_info info;
 393         uint8_t dev_id;
 394         uint16_t queue_id;
 395
 396         /* Valid dev_id values */
 397         dev_id = null_dev_id;
 398
 399         /* Valid queue_id values */
 400         queue_id = 0;
 401
 402         rte_bbdev_stop(dev_id);
 403
 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);
 407
 408         rte_bbdev_queue_stop(dev_id, queue_id);
 409
 410         ts_params->qconf.queue_size = info.drv.queue_size_lim + 1;
 411         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 412                         &ts_params->qconf),
 413                         "Failed test for rte_bbdev_queue_configure: "
 414                         "invalid value qconf.queue_size: %u",
 415                         ts_params->qconf.queue_size);
 416
 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,
 421                         &ts_params->qconf),
 422                         "Failed test for rte_bbdev_queue_configure: "
 423                         "invalid value queue_id: %u", queue_id);
 424
 425         queue_id = 0;
 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 ");
 429
 430         ts_params->qconf.socket = RTE_MAX_NUMA_NODES;
 431         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 432                         &ts_params->qconf),
 433                         "Failed test for rte_bbdev_queue_configure: "
 434                         "invalid socket number ");
 435
 436         ts_params->qconf.socket = SOCKET_ID_ANY;
 437         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
 438                         &ts_params->qconf),
 439                         "Failed test for rte_bbdev_queue_configure: "
 440                         "invalid value qconf.queue_size: %u",
 441                         ts_params->qconf.queue_size);
 442
 443         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS, queue_id,
 444                         &ts_params->qconf),
 445                         "Failed test for rte_bbdev_queue_configure: "
 446                         "invalid dev_id");
 447
 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);
 452
 453         return TEST_SUCCESS;
 454 }
 455
 456 static int
 457 test_bbdev_op_pool(void)
 458 {
 459         struct rte_mempool *mp;
 460
 461         unsigned int dec_size = sizeof(struct rte_bbdev_dec_op);
 462         unsigned int enc_size = sizeof(struct rte_bbdev_enc_op);
 463
 464         const char *pool_dec = "Test_DEC";
 465         const char *pool_enc = "Test_ENC";
 466
 467         /* Valid pool configuration */
 468         uint32_t size = 256;
 469         uint32_t cache_size = 128;
 470
 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");
 475
 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");
 480
 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);
 484
 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",
 488                         mp->cache_size);
 489
 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);
 493
 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);
 498
 499         rte_mempool_free(mp);
 500
 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");
 505
 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);
 510
 511         rte_mempool_free(mp);
 512
 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");
 517
 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",
 521                         mp->elt_size);
 522
 523         rte_mempool_free(mp);
 524
 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");
 529
 530         /* Invalid pool configuration */
 531         size = 128;
 532         cache_size = 256;
 533
 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.");
 540
 541         return TEST_SUCCESS;
 542 }
 543
 544 /**
 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
 547  *  allocated
 548  */
 549 static int
 550 test_bbdev_op_type(void)
 551 {
 552         struct rte_mempool *mp_dec;
 553
 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];
 557
 558         const char *pool_dec = "Test_op_dec";
 559
 560         /* Valid pool configuration */
 561         uint32_t num_elements = 256;
 562         uint32_t cache_size = 128;
 563
 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);
 568
 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");
 572
 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");
 576
 577         rte_mempool_free(mp_dec);
 578
 579         return TEST_SUCCESS;
 580 }
 581
 582 static int
 583 test_bbdev_op_pool_size(void)
 584 {
 585         struct rte_mempool *mp_none;
 586
 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];
 591
 592         const char *pool_none = "Test_pool_size";
 593
 594         /* Valid pool configuration */
 595         uint32_t num_elements = 256;
 596         uint32_t cache_size = 0;
 597
 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);
 602
 603         /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
 604         rte_bbdev_enc_op_alloc_bulk(mp_none, ops_enc_arr, OPS_COUNT);
 605
 606         /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
 607         TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext_arr,
 608                         OPS_COUNT) == 0,
 609                         "Failed test for allocating bbdev ops: "
 610                         "Mempool size: 256, Free : 128, Attempted to add: 128");
 611
 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,
 614                         OPS_COUNT) != 0,
 615                         "Failed test for allocating bbdev ops: "
 616                         "Mempool size: 256, Free : 0, Attempted to add: 128");
 617
 618         /* Free-up 128 RTE_BBDEV_OP_TURBO_ENC ops */
 619         rte_bbdev_enc_op_free_bulk(ops_enc_arr, OPS_COUNT);
 620
 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,
 624                         OPS_COUNT) == 0,
 625                         "Failed test for allocating ops after mempool freed:  "
 626                         "Mempool size: 256, Free : 128, Attempted to add: 128");
 627
 628         rte_mempool_free(mp_none);
 629
 630         return TEST_SUCCESS;
 631 }
 632
 633 static int
 634 test_bbdev_count(void)
 635 {
 636         uint8_t num_devs, num_valid_devs = 0;
 637
 638         for (num_devs = 0; num_devs < RTE_BBDEV_MAX_DEVS; num_devs++) {
 639                 if (rte_bbdev_is_valid(num_devs))
 640                         num_valid_devs++;
 641         }
 642
 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);
 647
 648         return TEST_SUCCESS;
 649 }
 650
 651 static int
 652 test_bbdev_stats(void)
 653 {
 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;
 663
 664         TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
 665                         "Failed to stop queue %u on device %u ", queue_id,
 666                         dev_id);
 667         TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
 668                         "Failed to stop bbdev %u ", dev_id);
 669
 670         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
 671                         &ts_params->qconf),
 672                         "Failed to configure queue %u on device %u ",
 673                         queue_id, dev_id);
 674
 675         TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
 676                         "Failed to start bbdev %u ", dev_id);
 677
 678         TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
 679                         "Failed to start queue %u on device %u ", queue_id,
 680                         dev_id);
 681
 682         TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
 683                         "Failed to start queue %u on device %u ", queue_id,
 684                         dev_id);
 685
 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);
 689
 690         TEST_ASSERT_FAIL(rte_bbdev_stats_get(RTE_BBDEV_MAX_DEVS, &stats),
 691                         "Failed test for rte_bbdev_stats_get on device %u ",
 692                         dev_id);
 693
 694         TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, NULL),
 695                         "Failed test for rte_bbdev_stats_get on device %u ",
 696                         dev_id);
 697
 698         TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
 699                         "Failed test for rte_bbdev_stats_get on device %u ",
 700                         dev_id);
 701
 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);
 706
 707         TEST_ASSERT(stats.dequeued_count == 0,
 708                         "Failed test for rte_bbdev_stats_reset: "
 709                         "invalid dequeued_count %" PRIu64 " ",
 710                         stats.dequeued_count);
 711
 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);
 715
 716         TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
 717                         "Failed test for rte_bbdev_stats_get on device %u ",
 718                         dev_id);
 719
 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);
 724
 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);
 729
 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);
 734
 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);
 738
 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 ",
 743                         dev_id);
 744
 745         TEST_ASSERT(stats.enqueued_count == 0,
 746                         "Failed test for rte_bbdev_stats_reset: "
 747                         "invalid enqueued_count %" PRIu64 " ",
 748                         stats.enqueued_count);
 749
 750         TEST_ASSERT(stats.dequeued_count == 0,
 751                         "Failed test for rte_bbdev_stats_reset: "
 752                         "invalid dequeued_count %" PRIu64 " ",
 753                         stats.dequeued_count);
 754
 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);
 759
 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);
 764
 765         return TEST_SUCCESS;
 766 }
 767
 768 static int
 769 test_bbdev_driver_init(void)
 770 {
 771         struct rte_bbdev *dev1, *dev2;
 772         const char *name = "dev_name";
 773         char name_tmp[16];
 774         int num_devs, num_devs_tmp;
 775
 776         dev1 = rte_bbdev_allocate(NULL);
 777         TEST_ASSERT(dev1 == NULL,
 778                         "Failed initialize bbdev driver with NULL name");
 779
 780         dev1 = rte_bbdev_allocate(name);
 781         TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
 782
 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");
 787
 788         num_devs = rte_bbdev_count() - 1;
 789         num_devs_tmp = num_devs;
 790
 791         /* Initialize the maximum amount of devices */
 792         do {
 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");
 797                 ++num_devs;
 798         } while (num_devs < (RTE_BBDEV_MAX_DEVS - 1));
 799
 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,
 804                         RTE_BBDEV_MAX_DEVS);
 805
 806         num_devs--;
 807
 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 ",
 813                                 name_tmp);
 814                 num_devs--;
 815         }
 816
 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);
 821
 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",
 825                         dev1->state);
 826
 827         TEST_ASSERT_FAIL(rte_bbdev_release(NULL),
 828                         "Failed to uninitialize bbdev driver with NULL bbdev");
 829
 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");
 834
 835         dev2 = rte_bbdev_get_named_dev(name);
 836         TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
 837                         "Failed to uninitialize bbdev driver: %s ", name);
 838
 839         return TEST_SUCCESS;
 840 }
 841
 842 static void
 843 event_callback(uint16_t dev_id, enum rte_bbdev_event_type type, void *param,
 844                 void *ret_param)
 845 {
 846         RTE_SET_USED(dev_id);
 847         RTE_SET_USED(ret_param);
 848
 849         if (param == NULL)
 850                 return;
 851
 852         if (type == RTE_BBDEV_EVENT_UNKNOWN ||
 853                         type == RTE_BBDEV_EVENT_ERROR ||
 854                         type == RTE_BBDEV_EVENT_MAX)
 855                 *(int *)param = type;
 856 }
 857
 858 static int
 859 test_bbdev_callback(void)
 860 {
 861         struct rte_bbdev *dev1, *dev2;
 862         const char *name = "dev_name1";
 863         const char *name2 = "dev_name2";
 864         int event_status;
 865         uint8_t invalid_dev_id = RTE_BBDEV_MAX_DEVS;
 866         enum rte_bbdev_event_type invalid_event_type = RTE_BBDEV_EVENT_MAX;
 867         uint8_t dev_id;
 868
 869         dev1 = rte_bbdev_allocate(name);
 870         TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
 871
 872         /*
 873          * RTE_BBDEV_EVENT_UNKNOWN - unregistered
 874          * RTE_BBDEV_EVENT_ERROR - unregistered
 875          */
 876         event_status = -1;
 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 ");
 882
 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 ");
 886
 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 ");
 890
 891         /*
 892          * RTE_BBDEV_EVENT_UNKNOWN - registered
 893          * RTE_BBDEV_EVENT_ERROR - unregistered
 894          */
 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");
 898
 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 ");
 903
 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 ");
 908
 909         /*
 910          * RTE_BBDEV_EVENT_UNKNOWN - registered
 911          * RTE_BBDEV_EVENT_ERROR - registered
 912          */
 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 ");
 916
 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) ");
 921
 922         event_status = -1;
 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 ");
 927
 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 ");
 932
 933         /*
 934          * RTE_BBDEV_EVENT_UNKNOWN - registered
 935          * RTE_BBDEV_EVENT_ERROR - unregistered
 936          */
 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 ");
 940
 941         event_status = -1;
 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 ");
 946
 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 ");
 951
 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 ");
 957
 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 ");
 961
 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 ");
 965
 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");
 970
 971         /*
 972          * dev2:
 973          * RTE_BBDEV_EVENT_UNKNOWN - unregistered
 974          * RTE_BBDEV_EVENT_ERROR - unregistered
 975          */
 976         event_status = -1;
 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 ");
 982
 983         /*
 984          * dev1: RTE_BBDEV_EVENT_ERROR - unregistered
 985          * dev2: RTE_BBDEV_EVENT_ERROR - registered
 986          */
 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");
 990
 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 ");
 995
 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 ");
1000
1001         /*
1002          * dev1: RTE_BBDEV_EVENT_UNKNOWN - registered
1003          * dev2: RTE_BBDEV_EVENT_UNKNOWN - unregistered
1004          */
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 "
1008                         "in dev 2 ");
1009
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 ");
1014
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 ");
1018
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 ");
1023
1024         event_status = -1;
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 ");
1029
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 ");
1034
1035         /* rte_bbdev_pmd_callback_process with invalid inputs */
1036         rte_bbdev_pmd_callback_process(NULL, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1037
1038         event_status = -1;
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 ");
1043
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 ");
1049
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 ");
1054
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 ");
1059
1060         dev_id = dev1->data->dev_id;
1061
1062         rte_bbdev_release(dev1);
1063         rte_bbdev_release(dev2);
1064
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 .");
1069
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. ");
1074
1075         event_status = -1;
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");
1083
1084         return TEST_SUCCESS;
1085 }
1086
1087 static int
1088 test_bbdev_invalid_driver(void)
1089 {
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;
1097
1098         TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u ",
1099                         dev_id);
1100
1101         dev1 = rte_bbdev_devices[dev_id];
1102         dev2 = &rte_bbdev_devices[dev_id];
1103
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;
1110
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: "
1116                         "NULL info_get ");
1117         dev2->dev_ops = dev1.dev_ops;
1118
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;
1126
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);
1130
1131         /* Test for rte_bbdev_queue_configure */
1132         dev2->dev_ops = NULL;
1133         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1134                         &ts_params->qconf),
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;
1138
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,
1143                         &ts_params->qconf),
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;
1147
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,
1152                         &ts_params->qconf),
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;
1156
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 ",
1160                         queue_id, dev_id);
1161
1162         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
1163                         &ts_params->qconf),
1164                         "Failed to configure queue %u on device %u ",
1165                         queue_id, dev_id);
1166
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;
1173
1174         TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(RTE_BBDEV_MAX_DEVS,
1175                         queue_id, &qinfo),
1176                         "Failed test for rte_bbdev_info_get: "
1177                         "invalid dev_id ");
1178
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 ");
1183
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 ");
1187
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;
1194
1195         TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
1196                         "Failed to start bbdev %u ", dev_id);
1197
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;
1204
1205         TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
1206                         "Failed to start queue %u on device %u ", queue_id,
1207                         dev_id);
1208
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 ",
1213                         dev_id);
1214         dev2->dev_ops = dev1.dev_ops;
1215
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: "
1221                         "NULL stats_get ");
1222         dev2->dev_ops = dev1.dev_ops;
1223
1224         TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1225                         "Failed test for rte_bbdev_stats_get on device %u ",
1226                         dev_id);
1227
1228         /*
1229          * Tests for:
1230          * rte_bbdev_callback_register,
1231          * rte_bbdev_pmd_callback_process,
1232          * rte_dev_callback_unregister
1233          */
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);
1239
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;
1244
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;
1250
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;
1258
1259         TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1260                         "Failed to reset statistic for device %u ", dev_id);
1261
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;
1268
1269         TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
1270                         "Failed to stop queue %u on device %u ", queue_id,
1271                         dev_id);
1272
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 ",
1277                         dev_id);
1278         dev2->dev_ops = dev1.dev_ops;
1279
1280         TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
1281                         "Failed to stop bbdev %u ", dev_id);
1282
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");
1286
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 ",
1290                         dev_id);
1291         dev2->dev_ops = dev1.dev_ops;
1292
1293         TEST_ASSERT_SUCCESS(rte_bbdev_close(dev_id),
1294                         "Failed to close bbdev %u ", dev_id);
1295
1296         return TEST_SUCCESS;
1297 }
1298
1299 static int
1300 test_bbdev_get_named_dev(void)
1301 {
1302         struct rte_bbdev *dev, *dev_tmp;
1303         const char *name = "name";
1304
1305         dev = rte_bbdev_allocate(name);
1306         TEST_ASSERT(dev != NULL, "Failed to initialize bbdev driver");
1307
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");
1311
1312         dev_tmp = rte_bbdev_get_named_dev(name);
1313
1314         TEST_ASSERT(dev == dev_tmp, "Failed test for rte_bbdev_get_named_dev: "
1315                         "wrong device was returned ");
1316
1317         TEST_ASSERT_SUCCESS(rte_bbdev_release(dev),
1318                         "Failed to uninitialize bbdev driver %s ", name);
1319
1320         return TEST_SUCCESS;
1321 }
1322
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 = {
1328
1329                 TEST_CASE(test_bbdev_configure_invalid_dev_id),
1330
1331                 TEST_CASE_ST(ut_setup, ut_teardown,
1332                                 test_bbdev_configure_invalid_num_queues),
1333
1334                 TEST_CASE_ST(ut_setup, ut_teardown,
1335                                 test_bbdev_configure_stop_device),
1336
1337                 TEST_CASE_ST(ut_setup, ut_teardown,
1338                                 test_bbdev_configure_stop_queue),
1339
1340                 TEST_CASE_ST(ut_setup, ut_teardown,
1341                                 test_bbdev_configure_invalid_queue_configure),
1342
1343                 TEST_CASE_ST(ut_setup, ut_teardown,
1344                                 test_bbdev_op_pool),
1345
1346                 TEST_CASE_ST(ut_setup, ut_teardown,
1347                                 test_bbdev_op_type),
1348
1349                 TEST_CASE_ST(ut_setup, ut_teardown,
1350                                 test_bbdev_op_pool_size),
1351
1352                 TEST_CASE_ST(ut_setup, ut_teardown,
1353                                 test_bbdev_stats),
1354
1355                 TEST_CASE_ST(ut_setup, ut_teardown,
1356                                 test_bbdev_driver_init),
1357
1358                 TEST_CASE_ST(ut_setup, ut_teardown,
1359                                 test_bbdev_callback),
1360
1361                 TEST_CASE_ST(ut_setup, ut_teardown,
1362                                 test_bbdev_invalid_driver),
1363
1364                 TEST_CASE_ST(ut_setup, ut_teardown,
1365                                 test_bbdev_get_named_dev),
1366
1367                 TEST_CASE(test_bbdev_count),
1368
1369                 TEST_CASES_END() /**< NULL terminate unit test array */
1370         }
1371 };
1372
1373 REGISTER_TEST_COMMAND(unittest, bbdev_null_testsuite);