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
  18 #include "main.h"
  19
  20
  21 #define BBDEV_NAME_NULL          ("bbdev_null")
  22
  23 struct bbdev_testsuite_params {
  24         struct rte_bbdev_queue_conf qconf;
  25 };
  26
  27 static struct bbdev_testsuite_params testsuite_params;
  28
  29 static uint8_t null_dev_id;
  30
  31 static int
  32 testsuite_setup(void)
  33 {
  34         uint8_t nb_devs;
  35         int ret;
  36         char buf[RTE_BBDEV_NAME_MAX_LEN];
  37
  38         /* Create test device */
  39         snprintf(buf, sizeof(buf), "%s_unittest", BBDEV_NAME_NULL);
  40         ret = rte_vdev_init(buf, NULL);
  41         TEST_ASSERT(ret == 0, "Failed to create instance of pmd: %s", buf);
  42
  43         nb_devs = rte_bbdev_count();
  44         TEST_ASSERT(nb_devs != 0, "No devices found");
  45
  46         /* Most recently created device is our device */
  47         null_dev_id = nb_devs - 1;
  48
  49         return TEST_SUCCESS;
  50 }
  51
  52 static void
  53 testsuite_teardown(void)
  54 {
  55         char buf[RTE_BBDEV_NAME_MAX_LEN];
  56
  57         snprintf(buf, sizeof(buf), "%s_unittest", BBDEV_NAME_NULL);
  58         rte_vdev_uninit(buf);
  59 }
  60
  61 static int
  62 ut_setup(void)
  63 {
  64         struct bbdev_testsuite_params *ts_params = &testsuite_params;
  65         uint8_t num_queues;
  66
  67         /* Valid queue configuration */
  68         ts_params->qconf.priority = 0;
  69         ts_params->qconf.socket = SOCKET_ID_ANY;
  70         ts_params->qconf.deferred_start = 1;
  71
  72         num_queues = 1;
  73         TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(null_dev_id, num_queues,
  74                         SOCKET_ID_ANY), "Failed to setup queues for bbdev %u",
  75                         0);
  76
  77         /* Start the device */
  78         TEST_ASSERT_SUCCESS(rte_bbdev_start(null_dev_id),
  79                         "Failed to start bbdev %u", 0);
  80
  81         return TEST_SUCCESS;
  82 }
  83
  84 static void
  85 ut_teardown(void)
  86 {
  87         rte_bbdev_close(null_dev_id);
  88 }
  89
  90 static int
  91 test_bbdev_configure_invalid_dev_id(void)
  92 {
  93         uint8_t dev_id;
  94         uint8_t num_queues;
  95
  96         num_queues = 1;
  97         for (dev_id = 0; dev_id < RTE_BBDEV_MAX_DEVS; dev_id++) {
  98                 if (!rte_bbdev_is_valid(dev_id)) {
  99                         TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id,
 100                                         num_queues, SOCKET_ID_ANY),
 101                                         "Failed test for rte_bbdev_setup_queues: "
 102                                         "invalid dev_num %u", dev_id);
 103                         TEST_ASSERT(rte_bbdev_intr_enable(dev_id) == -ENODEV,
 104                                         "Failed test for rte_bbdev_intr_enable: "
 105                                         "invalid dev_num %u", dev_id);
 106                         break;
 107                 }
 108         }
 109
 110         return TEST_SUCCESS;
 111 }
 112
 113 static int
 114 test_bbdev_configure_invalid_num_queues(void)
 115 {
 116         struct rte_bbdev_info info;
 117         uint8_t dev_id, num_devs;
 118         uint8_t num_queues;
 119         int return_value;
 120
 121         TEST_ASSERT((num_devs = rte_bbdev_count()) >= 1,
 122                         "Need at least %d devices for test", 1);
 123
 124         /* valid num_queues values */
 125         num_queues = 8;
 126
 127         /* valid dev_id values */
 128         dev_id = null_dev_id;
 129
 130         /* Stop the device in case it's started so it can be configured */
 131         rte_bbdev_stop(dev_id);
 132
 133         TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 0, SOCKET_ID_ANY),
 134                         "Failed test for rte_bbdev_setup_queues: "
 135                         "invalid num_queues %d", 0);
 136
 137         TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, num_queues,
 138                         SOCKET_ID_ANY),
 139                         "Failed test for rte_bbdev_setup_queues: "
 140                         "invalid dev_num %u", dev_id);
 141
 142         TEST_ASSERT_FAIL(return_value = rte_bbdev_info_get(dev_id, NULL),
 143                          "Failed test for rte_bbdev_info_get: "
 144                          "returned value:%i", return_value);
 145
 146         TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
 147                         "Failed test for rte_bbdev_info_get: "
 148                         "invalid return value:%i", return_value);
 149
 150         TEST_ASSERT(info.num_queues == num_queues,
 151                         "Failed test for rte_bbdev_info_get: "
 152                         "invalid num_queues:%u", info.num_queues);
 153
 154         num_queues = info.drv.max_num_queues;
 155         TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, num_queues,
 156                         SOCKET_ID_ANY),
 157                         "Failed test for rte_bbdev_setup_queues: "
 158                         "invalid num_queues: %u", num_queues);
 159
 160         num_queues++;
 161         TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, num_queues,
 162                         SOCKET_ID_ANY),
 163                         "Failed test for rte_bbdev_setup_queues: "
 164                         "invalid num_queues: %u", num_queues);
 165
 166         return TEST_SUCCESS;
 167 }
 168
 169 static int
 170 test_bbdev_configure_stop_device(void)
 171 {
 172         struct rte_bbdev_info info;
 173         uint8_t dev_id;
 174         int return_value;
 175
 176         /* valid dev_id values */
 177         dev_id = null_dev_id;
 178
 179         /* Stop the device so it can be configured */
 180         rte_bbdev_stop(dev_id);
 181
 182         TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
 183                         "Failed test for rte_bbdev_info_get: "
 184                         "invalid return value from "
 185                         "rte_bbdev_info_get function: %i", return_value);
 186
 187         TEST_ASSERT_SUCCESS(info.started, "Failed test for rte_bbdev_info_get: "
 188                         "started value: %u", info.started);
 189
 190         TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id,
 191                         info.drv.max_num_queues, SOCKET_ID_ANY),
 192                         "Failed test for rte_bbdev_setup_queues: "
 193                         "device should be stopped, dev_id: %u", dev_id);
 194
 195         return_value = rte_bbdev_intr_enable(dev_id);
 196         TEST_ASSERT(return_value != -EBUSY,
 197                         "Failed test for rte_bbdev_intr_enable: device should be stopped, dev_id: %u",
 198                         dev_id);
 199
 200         /* Start the device so it cannot be configured */
 201         TEST_ASSERT_FAIL(rte_bbdev_start(RTE_BBDEV_MAX_DEVS),
 202                         "Failed to start bbdev %u", dev_id);
 203
 204         TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
 205                         "Failed to start bbdev %u", dev_id);
 206
 207         TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
 208                         "Failed test for rte_bbdev_info_get: "
 209                         "invalid return value from "
 210                         "rte_bbdev_info_get function: %i", return_value);
 211
 212         TEST_ASSERT_FAIL(info.started, "Failed test for rte_bbdev_info_get: "
 213                         "started value: %u", info.started);
 214
 215         TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id,
 216                         info.drv.max_num_queues, SOCKET_ID_ANY),
 217                         "Failed test for rte_bbdev_setup_queues: "
 218                         "device should be started, dev_id: %u", dev_id);
 219
 220         return_value = rte_bbdev_intr_enable(dev_id);
 221         TEST_ASSERT(return_value == -EBUSY,
 222                         "Failed test for rte_bbdev_intr_enable: device should be started, dev_id: %u",
 223                         dev_id);
 224
 225         /* Stop again the device so it can be once again configured */
 226         TEST_ASSERT_FAIL(rte_bbdev_stop(RTE_BBDEV_MAX_DEVS),
 227                         "Failed to start bbdev %u", dev_id);
 228
 229         TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u",
 230                         dev_id);
 231
 232         TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
 233                         "Failed test for rte_bbdev_info_get: "
 234                         "invalid return value from "
 235                         "rte_bbdev_info_get function: %i", return_value);
 236
 237         TEST_ASSERT_SUCCESS(info.started, "Failed test for rte_bbdev_info_get: "
 238                         "started value: %u", info.started);
 239
 240         TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id,
 241                         info.drv.max_num_queues, SOCKET_ID_ANY),
 242                         "Failed test for rte_bbdev_setup_queues: "
 243                         "device should be stopped, dev_id: %u", dev_id);
 244
 245         return_value = rte_bbdev_intr_enable(dev_id);
 246         TEST_ASSERT(return_value != -EBUSY,
 247                         "Failed test for rte_bbdev_intr_enable: device should be stopped, dev_id: %u",
 248                         dev_id);
 249
 250         return TEST_SUCCESS;
 251 }
 252
 253 static int
 254 test_bbdev_configure_stop_queue(void)
 255 {
 256         struct bbdev_testsuite_params *ts_params = &testsuite_params;
 257         struct rte_bbdev_info info;
 258         struct rte_bbdev_queue_info qinfo;
 259         uint8_t dev_id;
 260         uint16_t queue_id;
 261         int return_value;
 262
 263         /* Valid dev_id values */
 264         dev_id = null_dev_id;
 265
 266         /* Valid queue_id values */
 267         queue_id = 0;
 268
 269         rte_bbdev_stop(dev_id);
 270         TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
 271                         "Failed test for rte_bbdev_info_get: "
 272                         "invalid return value:%i", return_value);
 273
 274         /* Valid queue configuration */
 275         ts_params->qconf.queue_size = info.drv.queue_size_lim;
 276         ts_params->qconf.priority = info.drv.max_queue_priority;
 277
 278         /* Device - started; queue - started */
 279         rte_bbdev_start(dev_id);
 280
 281         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 282                         &ts_params->qconf),
 283                         "Failed test for rte_bbdev_queue_configure: "
 284                         "queue:%u on device:%u should be stopped",
 285                          queue_id, dev_id);
 286
 287         /* Device - stopped; queue - started */
 288         rte_bbdev_stop(dev_id);
 289
 290         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 291                         &ts_params->qconf),
 292                         "Failed test for rte_bbdev_queue_configure: "
 293                         "queue:%u on device:%u should be stopped",
 294                          queue_id, dev_id);
 295
 296         TEST_ASSERT_FAIL(rte_bbdev_queue_stop(RTE_BBDEV_MAX_DEVS, queue_id),
 297                         "Failed test for rte_bbdev_queue_stop "
 298                         "invalid dev_id ");
 299
 300         TEST_ASSERT_FAIL(rte_bbdev_queue_stop(dev_id, RTE_MAX_QUEUES_PER_PORT),
 301                         "Failed test for rte_bbdev_queue_stop "
 302                         "invalid queue_id ");
 303
 304         /* Device - stopped; queue - stopped */
 305         rte_bbdev_queue_stop(dev_id, queue_id);
 306
 307         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
 308                         &ts_params->qconf),
 309                         "Failed test for rte_bbdev_queue_configure: "
 310                         "queue:%u on device:%u should be stopped", queue_id,
 311                         dev_id);
 312
 313         TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
 314                         queue_id, &qinfo),
 315                         "Failed test for rte_bbdev_info_get: "
 316                         "invalid return value from "
 317                         "rte_bbdev_queue_info_get function: %i", return_value);
 318
 319         TEST_ASSERT(qinfo.conf.socket == ts_params->qconf.socket,
 320                         "Failed test for rte_bbdev_queue_info_get: "
 321                         "invalid queue_size:%u", qinfo.conf.socket);
 322
 323         TEST_ASSERT(qinfo.conf.queue_size == ts_params->qconf.queue_size,
 324                         "Failed test for rte_bbdev_queue_info_get: "
 325                         "invalid queue_size:%u", qinfo.conf.queue_size);
 326
 327         TEST_ASSERT(qinfo.conf.priority == ts_params->qconf.priority,
 328                         "Failed test for rte_bbdev_queue_info_get: "
 329                         "invalid queue_size:%u", qinfo.conf.priority);
 330
 331         TEST_ASSERT(qinfo.conf.deferred_start ==
 332                         ts_params->qconf.deferred_start,
 333                         "Failed test for rte_bbdev_queue_info_get: "
 334                         "invalid queue_size:%u", qinfo.conf.deferred_start);
 335
 336         /* Device - started; queue - stopped */
 337         rte_bbdev_start(dev_id);
 338         rte_bbdev_queue_stop(dev_id, queue_id);
 339
 340         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 341                         &ts_params->qconf),
 342                         "Failed test for rte_bbdev_queue_configure: "
 343                         "queue:%u on device:%u should be stopped", queue_id,
 344                         dev_id);
 345
 346         rte_bbdev_stop(dev_id);
 347
 348         /* After rte_bbdev_start(dev_id):
 349          * - queue should be still stopped if deferred_start ==
 350          */
 351         rte_bbdev_start(dev_id);
 352
 353         TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
 354                         queue_id, &qinfo),
 355                         "Failed test for rte_bbdev_info_get: "
 356                         "invalid return value from "
 357                         "rte_bbdev_queue_info_get function: %i", return_value);
 358
 359         TEST_ASSERT(qinfo.started == 0,
 360                         "Failed test for rte_bbdev_queue_info_get: "
 361                         "invalid value for qinfo.started:%u", qinfo.started);
 362
 363         rte_bbdev_stop(dev_id);
 364
 365         /* After rte_bbdev_start(dev_id):
 366          * - queue should be started if deferred_start ==
 367          */
 368         ts_params->qconf.deferred_start = 0;
 369         rte_bbdev_queue_configure(dev_id, queue_id, &ts_params->qconf);
 370         rte_bbdev_start(dev_id);
 371
 372         TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
 373                         queue_id, &qinfo),
 374                         "Failed test for rte_bbdev_info_get: "
 375                         "invalid return value from "
 376                         "rte_bbdev_queue_info_get function: %i", return_value);
 377
 378         TEST_ASSERT(qinfo.started == 1,
 379                         "Failed test for rte_bbdev_queue_info_get: "
 380                         "invalid value for qinfo.started:%u", qinfo.started);
 381
 382         return TEST_SUCCESS;
 383 }
 384
 385 static int
 386 test_bbdev_configure_invalid_queue_configure(void)
 387 {
 388         struct bbdev_testsuite_params *ts_params = &testsuite_params;
 389         int return_value;
 390         struct rte_bbdev_info info;
 391         uint8_t dev_id;
 392         uint16_t queue_id;
 393
 394         /* Valid dev_id values */
 395         dev_id = null_dev_id;
 396
 397         /* Valid queue_id values */
 398         queue_id = 0;
 399
 400         rte_bbdev_stop(dev_id);
 401
 402         TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
 403                         "Failed test for rte_bbdev_info_get: "
 404                         "invalid return value:%i", return_value);
 405
 406         rte_bbdev_queue_stop(dev_id, queue_id);
 407
 408         ts_params->qconf.queue_size = info.drv.queue_size_lim + 1;
 409         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 410                         &ts_params->qconf),
 411                         "Failed test for rte_bbdev_queue_configure: "
 412                         "invalid value qconf.queue_size: %u",
 413                         ts_params->qconf.queue_size);
 414
 415         ts_params->qconf.queue_size = info.drv.queue_size_lim;
 416         ts_params->qconf.priority = info.drv.max_queue_priority + 1;
 417         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 418                         &ts_params->qconf),
 419                         "Failed test for rte_bbdev_queue_configure: "
 420                         "invalid value qconf.queue_size: %u",
 421                         ts_params->qconf.queue_size);
 422
 423         ts_params->qconf.priority = info.drv.max_queue_priority;
 424         queue_id = info.num_queues;
 425         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 426                         &ts_params->qconf),
 427                         "Failed test for rte_bbdev_queue_configure: "
 428                         "invalid value queue_id: %u", queue_id);
 429
 430         queue_id = 0;
 431         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
 432                         "Failed test for rte_bbdev_queue_configure: "
 433                         "NULL qconf structure ");
 434
 435         ts_params->qconf.socket = RTE_MAX_NUMA_NODES;
 436         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 437                         &ts_params->qconf),
 438                         "Failed test for rte_bbdev_queue_configure: "
 439                         "invalid socket number ");
 440
 441         ts_params->qconf.socket = SOCKET_ID_ANY;
 442         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
 443                         &ts_params->qconf),
 444                         "Failed test for rte_bbdev_queue_configure: "
 445                         "invalid value qconf.queue_size: %u",
 446                         ts_params->qconf.queue_size);
 447
 448         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS, queue_id,
 449                         &ts_params->qconf),
 450                         "Failed test for rte_bbdev_queue_configure: "
 451                         "invalid dev_id");
 452
 453         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
 454                         "Failed test for rte_bbdev_queue_configure: "
 455                         "invalid value qconf.queue_size: %u",
 456                         ts_params->qconf.queue_size);
 457
 458         return TEST_SUCCESS;
 459 }
 460
 461 static int
 462 test_bbdev_op_pool(void)
 463 {
 464         struct rte_mempool *mp;
 465
 466         unsigned int dec_size = sizeof(struct rte_bbdev_dec_op);
 467         unsigned int enc_size = sizeof(struct rte_bbdev_enc_op);
 468
 469         const char *pool_dec = "Test_DEC";
 470         const char *pool_enc = "Test_ENC";
 471
 472         /* Valid pool configuration */
 473         uint32_t size = 256;
 474         uint32_t cache_size = 128;
 475
 476         TEST_ASSERT(rte_bbdev_op_pool_create(NULL,
 477                         RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0) == NULL,
 478                         "Failed test for rte_bbdev_op_pool_create: "
 479                         "NULL name parameter");
 480
 481         TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_dec,
 482                         RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0)) != NULL,
 483                         "Failed test for rte_bbdev_op_pool_create: "
 484                         "returned value is empty");
 485
 486         TEST_ASSERT(mp->size == size,
 487                         "Failed test for rte_bbdev_op_pool_create: "
 488                         "invalid size of the mempool, mp->size: %u", mp->size);
 489
 490         TEST_ASSERT(mp->cache_size == cache_size,
 491                         "Failed test for rte_bbdev_op_pool_create: "
 492                         "invalid size of the mempool, mp->size: %u",
 493                         mp->cache_size);
 494
 495         TEST_ASSERT_SUCCESS(strcmp(mp->name, pool_dec),
 496                         "Failed test for rte_bbdev_op_pool_create: "
 497                         "invalid name of mempool, mp->name: %s", mp->name);
 498
 499         TEST_ASSERT(mp->elt_size == dec_size,
 500                         "Failed test for rte_bbdev_op_pool_create: "
 501                         "invalid element size for RTE_BBDEV_OP_TURBO_DEC, "
 502                         "mp->elt_size: %u", mp->elt_size);
 503
 504         rte_mempool_free(mp);
 505
 506         TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_enc,
 507                         RTE_BBDEV_OP_TURBO_ENC, size, cache_size, 0)) != NULL,
 508                          "Failed test for rte_bbdev_op_pool_create: "
 509                         "returned value is empty");
 510
 511         TEST_ASSERT(mp->elt_size == enc_size,
 512                         "Failed test for rte_bbdev_op_pool_create: "
 513                         "invalid element size for RTE_BBDEV_OP_TURBO_ENC, "
 514                         "mp->elt_size: %u", mp->elt_size);
 515
 516         rte_mempool_free(mp);
 517
 518         TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_NONE",
 519                         RTE_BBDEV_OP_NONE, size, cache_size, 0)) != NULL,
 520                         "Failed test for rte_bbdev_op_pool_create: "
 521                         "returned value is empty for RTE_BBDEV_OP_NONE");
 522
 523         TEST_ASSERT(mp->elt_size == (enc_size > dec_size ? enc_size : dec_size),
 524                         "Failed test for rte_bbdev_op_pool_create: "
 525                         "invalid  size for RTE_BBDEV_OP_NONE, mp->elt_size: %u",
 526                         mp->elt_size);
 527
 528         rte_mempool_free(mp);
 529
 530         TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_INV",
 531                         RTE_BBDEV_OP_TYPE_COUNT, size, cache_size, 0)) == NULL,
 532                         "Failed test for rte_bbdev_op_pool_create: "
 533                         "returned value is not NULL for invalid type");
 534
 535         /* Invalid pool configuration */
 536         size = 128;
 537         cache_size = 256;
 538
 539         TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_InvSize",
 540                         RTE_BBDEV_OP_NONE, size, cache_size, 0)) == NULL,
 541                         "Failed test for rte_bbdev_op_pool_create: "
 542                         "returned value should be empty "
 543                         "because size of per-lcore local cache "
 544                         "is greater than size of the mempool.");
 545
 546         return TEST_SUCCESS;
 547 }
 548
 549 /**
 550  *  Create pool of OP types RTE_BBDEV_OP_NONE, RTE_BBDEV_OP_TURBO_DEC and
 551  *  RTE_BBDEV_OP_TURBO_ENC and check that only ops of that type can be
 552  *  allocated
 553  */
 554 static int
 555 test_bbdev_op_type(void)
 556 {
 557         struct rte_mempool *mp_dec;
 558
 559         const unsigned int OPS_COUNT = 32;
 560         struct rte_bbdev_dec_op *dec_ops_arr[OPS_COUNT];
 561         struct rte_bbdev_enc_op *enc_ops_arr[OPS_COUNT];
 562
 563         const char *pool_dec = "Test_op_dec";
 564
 565         /* Valid pool configuration */
 566         uint32_t num_elements = 256;
 567         uint32_t cache_size = 128;
 568
 569         /* mempool type : RTE_BBDEV_OP_TURBO_DEC */
 570         mp_dec = rte_bbdev_op_pool_create(pool_dec,
 571                         RTE_BBDEV_OP_TURBO_DEC, num_elements, cache_size, 0);
 572         TEST_ASSERT(mp_dec != NULL, "Failed to create %s mempool", pool_dec);
 573
 574         TEST_ASSERT(rte_bbdev_dec_op_alloc_bulk(mp_dec, dec_ops_arr, 1) == 0,
 575                         "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
 576                         "OPs type: RTE_BBDEV_OP_TURBO_DEC");
 577
 578         TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_dec, enc_ops_arr, 1) != 0,
 579                         "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
 580                         "OPs type: RTE_BBDEV_OP_TURBO_ENC");
 581
 582         rte_mempool_free(mp_dec);
 583
 584         return TEST_SUCCESS;
 585 }
 586
 587 static int
 588 test_bbdev_op_pool_size(void)
 589 {
 590         struct rte_mempool *mp_none;
 591
 592         const unsigned int OPS_COUNT = 128;
 593         struct rte_bbdev_enc_op *ops_enc_arr[OPS_COUNT];
 594         struct rte_bbdev_enc_op *ops_ext_arr[OPS_COUNT];
 595         struct rte_bbdev_enc_op *ops_ext2_arr[OPS_COUNT];
 596
 597         const char *pool_none = "Test_pool_size";
 598
 599         /* Valid pool configuration */
 600         uint32_t num_elements = 256;
 601         uint32_t cache_size = 0;
 602
 603         /* Create mempool type : RTE_BBDEV_OP_TURBO_ENC, size : 256 */
 604         mp_none = rte_bbdev_op_pool_create(pool_none, RTE_BBDEV_OP_TURBO_ENC,
 605                         num_elements, cache_size, 0);
 606         TEST_ASSERT(mp_none != NULL, "Failed to create %s mempool", pool_none);
 607
 608         /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
 609         rte_bbdev_enc_op_alloc_bulk(mp_none, ops_enc_arr, OPS_COUNT);
 610
 611         /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
 612         TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext_arr,
 613                         OPS_COUNT) == 0,
 614                         "Failed test for allocating bbdev ops: "
 615                         "Mempool size: 256, Free : 128, Attempted to add: 128");
 616
 617         /* Try adding 128 more RTE_BBDEV_OP_TURBO_ENC ops, this should fail */
 618         TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
 619                         OPS_COUNT) != 0,
 620                         "Failed test for allocating bbdev ops: "
 621                         "Mempool size: 256, Free : 0, Attempted to add: 128");
 622
 623         /* Free-up 128 RTE_BBDEV_OP_TURBO_ENC ops */
 624         rte_bbdev_enc_op_free_bulk(ops_enc_arr, OPS_COUNT);
 625
 626         /* Try adding 128 RTE_BBDEV_OP_TURBO_DEC ops, this should succeed */
 627         /* Cache size > 0 causes reallocation of ops size > 127 fail */
 628         TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
 629                         OPS_COUNT) == 0,
 630                         "Failed test for allocating ops after mempool freed:  "
 631                         "Mempool size: 256, Free : 128, Attempted to add: 128");
 632
 633         rte_mempool_free(mp_none);
 634
 635         return TEST_SUCCESS;
 636 }
 637
 638 static int
 639 test_bbdev_count(void)
 640 {
 641         uint8_t num_devs, num_valid_devs = 0;
 642
 643         for (num_devs = 0; num_devs < RTE_BBDEV_MAX_DEVS; num_devs++) {
 644                 if (rte_bbdev_is_valid(num_devs))
 645                         num_valid_devs++;
 646         }
 647
 648         num_devs = rte_bbdev_count();
 649         TEST_ASSERT(num_valid_devs == num_devs,
 650                         "Failed test for rte_bbdev_is_valid: "
 651                         "invalid num_devs %u ", num_devs);
 652
 653         return TEST_SUCCESS;
 654 }
 655
 656 static int
 657 test_bbdev_stats(void)
 658 {
 659         uint8_t dev_id = null_dev_id;
 660         uint16_t queue_id = 0;
 661         struct rte_bbdev_dec_op *dec_ops[4096] = { 0 };
 662         struct rte_bbdev_dec_op *dec_proc_ops[4096] = { 0 };
 663         struct rte_bbdev_enc_op *enc_ops[4096] = { 0 };
 664         struct rte_bbdev_enc_op *enc_proc_ops[4096] = { 0 };
 665         uint16_t num_ops = 236;
 666         struct rte_bbdev_stats stats;
 667         struct bbdev_testsuite_params *ts_params = &testsuite_params;
 668
 669         TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
 670                         "Failed to stop queue %u on device %u ", queue_id,
 671                         dev_id);
 672         TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
 673                         "Failed to stop bbdev %u ", dev_id);
 674
 675         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
 676                         &ts_params->qconf),
 677                         "Failed to configure queue %u on device %u ",
 678                         queue_id, dev_id);
 679
 680         TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
 681                         "Failed to start bbdev %u ", dev_id);
 682
 683         TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
 684                         "Failed to start queue %u on device %u ", queue_id,
 685                         dev_id);
 686
 687         TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
 688                         "Failed to start queue %u on device %u ", queue_id,
 689                         dev_id);
 690
 691         /* Tests after enqueue operation */
 692         rte_bbdev_enqueue_enc_ops(dev_id, queue_id, enc_ops, num_ops);
 693         rte_bbdev_enqueue_dec_ops(dev_id, queue_id, dec_ops, num_ops);
 694
 695         TEST_ASSERT_FAIL(rte_bbdev_stats_get(RTE_BBDEV_MAX_DEVS, &stats),
 696                         "Failed test for rte_bbdev_stats_get on device %u ",
 697                         dev_id);
 698
 699         TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, NULL),
 700                         "Failed test for rte_bbdev_stats_get on device %u ",
 701                         dev_id);
 702
 703         TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
 704                         "Failed test for rte_bbdev_stats_get on device %u ",
 705                         dev_id);
 706
 707         TEST_ASSERT(stats.enqueued_count == 2 * num_ops,
 708                         "Failed test for rte_bbdev_enqueue_ops: "
 709                         "invalid enqueued_count %" PRIu64 " ",
 710                         stats.enqueued_count);
 711
 712         TEST_ASSERT(stats.dequeued_count == 0,
 713                         "Failed test for rte_bbdev_stats_reset: "
 714                         "invalid dequeued_count %" PRIu64 " ",
 715                         stats.dequeued_count);
 716
 717         /* Tests after dequeue operation */
 718         rte_bbdev_dequeue_enc_ops(dev_id, queue_id, enc_proc_ops, num_ops);
 719         rte_bbdev_dequeue_dec_ops(dev_id, queue_id, dec_proc_ops, num_ops);
 720
 721         TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
 722                         "Failed test for rte_bbdev_stats_get on device %u ",
 723                         dev_id);
 724
 725         TEST_ASSERT(stats.dequeued_count == 2 * num_ops,
 726                         "Failed test for rte_bbdev_dequeue_ops: "
 727                         "invalid enqueued_count %" PRIu64 " ",
 728                         stats.dequeued_count);
 729
 730         TEST_ASSERT(stats.enqueue_err_count == 0,
 731                         "Failed test for rte_bbdev_stats_reset: "
 732                         "invalid enqueue_err_count %" PRIu64 " ",
 733                         stats.enqueue_err_count);
 734
 735         TEST_ASSERT(stats.dequeue_err_count == 0,
 736                         "Failed test for rte_bbdev_stats_reset: "
 737                         "invalid dequeue_err_count %" PRIu64 " ",
 738                         stats.dequeue_err_count);
 739
 740         /* Tests after reset operation */
 741         TEST_ASSERT_FAIL(rte_bbdev_stats_reset(RTE_BBDEV_MAX_DEVS),
 742                         "Failed to reset statistic for device %u ", dev_id);
 743
 744         TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
 745                         "Failed to reset statistic for device %u ", dev_id);
 746         TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
 747                         "Failed test for rte_bbdev_stats_get on device %u ",
 748                         dev_id);
 749
 750         TEST_ASSERT(stats.enqueued_count == 0,
 751                         "Failed test for rte_bbdev_stats_reset: "
 752                         "invalid enqueued_count %" PRIu64 " ",
 753                         stats.enqueued_count);
 754
 755         TEST_ASSERT(stats.dequeued_count == 0,
 756                         "Failed test for rte_bbdev_stats_reset: "
 757                         "invalid dequeued_count %" PRIu64 " ",
 758                         stats.dequeued_count);
 759
 760         TEST_ASSERT(stats.enqueue_err_count == 0,
 761                         "Failed test for rte_bbdev_stats_reset: "
 762                         "invalid enqueue_err_count %" PRIu64 " ",
 763                         stats.enqueue_err_count);
 764
 765         TEST_ASSERT(stats.dequeue_err_count == 0,
 766                         "Failed test for rte_bbdev_stats_reset: "
 767                         "invalid dequeue_err_count %" PRIu64 " ",
 768                         stats.dequeue_err_count);
 769
 770         return TEST_SUCCESS;
 771 }
 772
 773 static int
 774 test_bbdev_driver_init(void)
 775 {
 776         struct rte_bbdev *dev1, *dev2;
 777         const char *name = "dev_name";
 778         char name_tmp[16];
 779         int num_devs, num_devs_tmp;
 780
 781         dev1 = rte_bbdev_allocate(NULL);
 782         TEST_ASSERT(dev1 == NULL,
 783                         "Failed initialize bbdev driver with NULL name");
 784
 785         dev1 = rte_bbdev_allocate(name);
 786         TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
 787
 788         dev2 = rte_bbdev_allocate(name);
 789         TEST_ASSERT(dev2 == NULL,
 790                         "Failed to initialize bbdev driver: "
 791                         "driver with the same name has been initialized before");
 792
 793         num_devs = rte_bbdev_count() - 1;
 794         num_devs_tmp = num_devs;
 795
 796         /* Initialize the maximum amount of devices */
 797         do {
 798                 sprintf(name_tmp, "%s%i", "name_", num_devs);
 799                 dev2 = rte_bbdev_allocate(name_tmp);
 800                 TEST_ASSERT(dev2 != NULL,
 801                                 "Failed to initialize bbdev driver");
 802                 ++num_devs;
 803         } while (num_devs < (RTE_BBDEV_MAX_DEVS - 1));
 804
 805         sprintf(name_tmp, "%s%i", "name_", num_devs);
 806         dev2 = rte_bbdev_allocate(name_tmp);
 807         TEST_ASSERT(dev2 == NULL, "Failed to initialize bbdev driver number %d "
 808                         "more drivers than RTE_BBDEV_MAX_DEVS: %d ", num_devs,
 809                         RTE_BBDEV_MAX_DEVS);
 810
 811         num_devs--;
 812
 813         while (num_devs >= num_devs_tmp) {
 814                 sprintf(name_tmp, "%s%i", "name_", num_devs);
 815                 dev2 = rte_bbdev_get_named_dev(name_tmp);
 816                 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
 817                                 "Failed to uninitialize bbdev driver %s ",
 818                                 name_tmp);
 819                 num_devs--;
 820         }
 821
 822         TEST_ASSERT(dev1->data->dev_id < RTE_BBDEV_MAX_DEVS,
 823                         "Failed test rte_bbdev_allocate: "
 824                         "invalid dev_id %" PRIu8 ", max number of devices %d ",
 825                         dev1->data->dev_id, RTE_BBDEV_MAX_DEVS);
 826
 827         TEST_ASSERT(dev1->state == RTE_BBDEV_INITIALIZED,
 828                         "Failed test rte_bbdev_allocate: "
 829                         "invalid state %d (0 - RTE_BBDEV_UNUSED, 1 - RTE_BBDEV_INITIALIZED",
 830                         dev1->state);
 831
 832         TEST_ASSERT_FAIL(rte_bbdev_release(NULL),
 833                         "Failed to uninitialize bbdev driver with NULL bbdev");
 834
 835         sprintf(name_tmp, "%s", "invalid_name");
 836         dev2 = rte_bbdev_get_named_dev(name_tmp);
 837         TEST_ASSERT_FAIL(rte_bbdev_release(dev2),
 838                         "Failed to uninitialize bbdev driver with invalid name");
 839
 840         dev2 = rte_bbdev_get_named_dev(name);
 841         TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
 842                         "Failed to uninitialize bbdev driver: %s ", name);
 843
 844         return TEST_SUCCESS;
 845 }
 846
 847 static void
 848 event_callback(uint16_t dev_id, enum rte_bbdev_event_type type, void *param,
 849                 void *ret_param)
 850 {
 851         RTE_SET_USED(dev_id);
 852         RTE_SET_USED(ret_param);
 853
 854         if (param == NULL)
 855                 return;
 856
 857         if (type == RTE_BBDEV_EVENT_UNKNOWN ||
 858                         type == RTE_BBDEV_EVENT_ERROR ||
 859                         type == RTE_BBDEV_EVENT_MAX)
 860                 *(int *)param = type;
 861 }
 862
 863 static int
 864 test_bbdev_callback(void)
 865 {
 866         struct rte_bbdev *dev1, *dev2;
 867         const char *name = "dev_name1";
 868         const char *name2 = "dev_name2";
 869         int event_status;
 870         uint8_t invalid_dev_id = RTE_BBDEV_MAX_DEVS;
 871         enum rte_bbdev_event_type invalid_event_type = RTE_BBDEV_EVENT_MAX;
 872         uint8_t dev_id;
 873
 874         dev1 = rte_bbdev_allocate(name);
 875         TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
 876
 877         /*
 878          * RTE_BBDEV_EVENT_UNKNOWN - unregistered
 879          * RTE_BBDEV_EVENT_ERROR - unregistered
 880          */
 881         event_status = -1;
 882         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
 883         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
 884         TEST_ASSERT(event_status == -1,
 885                         "Failed test for rte_bbdev_pmd_callback_process: "
 886                         "events were not registered ");
 887
 888         TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
 889                         RTE_BBDEV_EVENT_MAX, event_callback, NULL),
 890                         "Failed to callback register for RTE_BBDEV_EVENT_MAX ");
 891
 892         TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
 893                         RTE_BBDEV_EVENT_MAX, event_callback, NULL),
 894                         "Failed to unregister RTE_BBDEV_EVENT_MAX ");
 895
 896         /*
 897          * RTE_BBDEV_EVENT_UNKNOWN - registered
 898          * RTE_BBDEV_EVENT_ERROR - unregistered
 899          */
 900         TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
 901                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
 902                         "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
 903
 904         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
 905         TEST_ASSERT(event_status == 0,
 906                         "Failed test for rte_bbdev_pmd_callback_process "
 907                         "for RTE_BBDEV_EVENT_UNKNOWN ");
 908
 909         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
 910         TEST_ASSERT(event_status == 0,
 911                         "Failed test for rte_bbdev_pmd_callback_process: "
 912                         "event RTE_BBDEV_EVENT_ERROR was not registered ");
 913
 914         /*
 915          * RTE_BBDEV_EVENT_UNKNOWN - registered
 916          * RTE_BBDEV_EVENT_ERROR - registered
 917          */
 918         TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
 919                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
 920                         "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR ");
 921
 922         TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
 923                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
 924                         "Failed to callback register for RTE_BBDEV_EVENT_ERROR"
 925                         "(re-registration) ");
 926
 927         event_status = -1;
 928         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
 929         TEST_ASSERT(event_status == 0,
 930                         "Failed test for rte_bbdev_pmd_callback_process "
 931                         "for RTE_BBDEV_EVENT_UNKNOWN ");
 932
 933         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
 934         TEST_ASSERT(event_status == 1,
 935                         "Failed test for rte_bbdev_pmd_callback_process "
 936                         "for RTE_BBDEV_EVENT_ERROR ");
 937
 938         /*
 939          * RTE_BBDEV_EVENT_UNKNOWN - registered
 940          * RTE_BBDEV_EVENT_ERROR - unregistered
 941          */
 942         TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev1->data->dev_id,
 943                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
 944                         "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
 945
 946         event_status = -1;
 947         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
 948         TEST_ASSERT(event_status == 0,
 949                         "Failed test for rte_bbdev_pmd_callback_process "
 950                         "for RTE_BBDEV_EVENT_UNKNOWN ");
 951
 952         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
 953         TEST_ASSERT(event_status == 0,
 954                         "Failed test for rte_bbdev_pmd_callback_process: "
 955                         "event RTE_BBDEV_EVENT_ERROR was unregistered ");
 956
 957         /* rte_bbdev_callback_register with invalid inputs */
 958         TEST_ASSERT_FAIL(rte_bbdev_callback_register(invalid_dev_id,
 959                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
 960                         "Failed test for rte_bbdev_callback_register "
 961                         "for invalid_dev_id ");
 962
 963         TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
 964                         invalid_event_type, event_callback, &event_status),
 965                         "Failed to callback register for invalid event type ");
 966
 967         TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
 968                         RTE_BBDEV_EVENT_ERROR, NULL, &event_status),
 969                         "Failed to callback register - no callback function ");
 970
 971         /* The impact of devices on each other */
 972         dev2 = rte_bbdev_allocate(name2);
 973         TEST_ASSERT(dev2 != NULL,
 974                         "Failed to initialize bbdev driver");
 975
 976         /*
 977          * dev2:
 978          * RTE_BBDEV_EVENT_UNKNOWN - unregistered
 979          * RTE_BBDEV_EVENT_ERROR - unregistered
 980          */
 981         event_status = -1;
 982         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
 983         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
 984         TEST_ASSERT(event_status == -1,
 985                         "Failed test for rte_bbdev_pmd_callback_process: "
 986                         "events were not registered ");
 987
 988         /*
 989          * dev1: RTE_BBDEV_EVENT_ERROR - unregistered
 990          * dev2: RTE_BBDEV_EVENT_ERROR - registered
 991          */
 992         TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
 993                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
 994                         "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR");
 995
 996         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
 997         TEST_ASSERT(event_status == -1,
 998                 "Failed test for rte_bbdev_pmd_callback_process in dev1 "
 999                 "for RTE_BBDEV_EVENT_ERROR ");
1000
1001         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
1002         TEST_ASSERT(event_status == 1,
1003                 "Failed test for rte_bbdev_pmd_callback_process in dev2 "
1004                 "for RTE_BBDEV_EVENT_ERROR ");
1005
1006         /*
1007          * dev1: RTE_BBDEV_EVENT_UNKNOWN - registered
1008          * dev2: RTE_BBDEV_EVENT_UNKNOWN - unregistered
1009          */
1010         TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
1011                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1012                         "Failed to callback register for RTE_BBDEV_EVENT_UNKNOWN "
1013                         "in dev 2 ");
1014
1015         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1016         TEST_ASSERT(event_status == 0,
1017                         "Failed test for rte_bbdev_pmd_callback_process in dev2"
1018                         " for RTE_BBDEV_EVENT_UNKNOWN ");
1019
1020         TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1021                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1022                         "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN ");
1023
1024         TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1025                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1026                         "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN : "
1027                         "unregister function called once again ");
1028
1029         event_status = -1;
1030         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1031         TEST_ASSERT(event_status == -1,
1032                         "Failed test for rte_bbdev_pmd_callback_process in dev2"
1033                 " for RTE_BBDEV_EVENT_UNKNOWN ");
1034
1035         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1036         TEST_ASSERT(event_status == 0,
1037                         "Failed test for rte_bbdev_pmd_callback_process in dev2 "
1038                         "for RTE_BBDEV_EVENT_UNKNOWN ");
1039
1040         /* rte_bbdev_pmd_callback_process with invalid inputs */
1041         rte_bbdev_pmd_callback_process(NULL, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1042
1043         event_status = -1;
1044         rte_bbdev_pmd_callback_process(dev1, invalid_event_type, NULL);
1045         TEST_ASSERT(event_status == -1,
1046                         "Failed test for rte_bbdev_pmd_callback_process: "
1047                         "for invalid event type ");
1048
1049         /* rte_dev_callback_unregister with invalid inputs */
1050         TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(invalid_dev_id,
1051                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1052                         "Failed test for rte_dev_callback_unregister "
1053                         "for invalid_dev_id ");
1054
1055         TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1056                         invalid_event_type, event_callback, &event_status),
1057                         "Failed rte_dev_callback_unregister "
1058                         "for invalid event type ");
1059
1060         TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1061                         invalid_event_type, NULL, &event_status),
1062                         "Failed rte_dev_callback_unregister "
1063                         "when no callback function ");
1064
1065         dev_id = dev1->data->dev_id;
1066
1067         rte_bbdev_release(dev1);
1068         rte_bbdev_release(dev2);
1069
1070         TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev_id,
1071                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1072                         "Failed test for rte_bbdev_callback_register: "
1073                         "function called after rte_bbdev_driver_uninit .");
1074
1075         TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev_id,
1076                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1077                         "Failed test for rte_dev_callback_unregister: "
1078                         "function called after rte_bbdev_driver_uninit. ");
1079
1080         event_status = -1;
1081         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1082         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
1083         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1084         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
1085         TEST_ASSERT(event_status == -1,
1086                         "Failed test for rte_bbdev_pmd_callback_process: "
1087                         "callback function was called after rte_bbdev_driver_uninit");
1088
1089         return TEST_SUCCESS;
1090 }
1091
1092 static int
1093 test_bbdev_invalid_driver(void)
1094 {
1095         struct rte_bbdev dev1, *dev2;
1096         uint8_t dev_id = null_dev_id;
1097         uint16_t queue_id = 0;
1098         struct rte_bbdev_stats stats;
1099         struct bbdev_testsuite_params *ts_params = &testsuite_params;
1100         struct rte_bbdev_queue_info qinfo;
1101         struct rte_bbdev_ops dev_ops_tmp;
1102
1103         TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u ",
1104                         dev_id);
1105
1106         dev1 = rte_bbdev_devices[dev_id];
1107         dev2 = &rte_bbdev_devices[dev_id];
1108
1109         /* Tests for rte_bbdev_setup_queues */
1110         dev2->dev_ops = NULL;
1111         TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1112                         "Failed test for rte_bbdev_setup_queues: "
1113                         "NULL dev_ops structure ");
1114         dev2->dev_ops = dev1.dev_ops;
1115
1116         dev_ops_tmp = *dev2->dev_ops;
1117         dev_ops_tmp.info_get = NULL;
1118         dev2->dev_ops = &dev_ops_tmp;
1119         TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1120                         "Failed test for rte_bbdev_setup_queues: "
1121                         "NULL info_get ");
1122         dev2->dev_ops = dev1.dev_ops;
1123
1124         dev_ops_tmp = *dev2->dev_ops;
1125         dev_ops_tmp.queue_release = NULL;
1126         dev2->dev_ops = &dev_ops_tmp;
1127         TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1128                         "Failed test for rte_bbdev_setup_queues: "
1129                         "NULL queue_release ");
1130         dev2->dev_ops = dev1.dev_ops;
1131
1132         dev2->data->socket_id = SOCKET_ID_ANY;
1133         TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, 1,
1134                         SOCKET_ID_ANY), "Failed to configure bbdev %u", dev_id);
1135
1136         /* Test for rte_bbdev_queue_configure */
1137         dev2->dev_ops = NULL;
1138         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1139                         &ts_params->qconf),
1140                         "Failed to configure queue %u on device %u "
1141                         "with NULL dev_ops structure ", queue_id, dev_id);
1142         dev2->dev_ops = dev1.dev_ops;
1143
1144         dev_ops_tmp = *dev2->dev_ops;
1145         dev_ops_tmp.queue_setup = NULL;
1146         dev2->dev_ops = &dev_ops_tmp;
1147         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1148                         &ts_params->qconf),
1149                         "Failed to configure queue %u on device %u "
1150                         "with NULL queue_setup ", queue_id, dev_id);
1151         dev2->dev_ops = dev1.dev_ops;
1152
1153         dev_ops_tmp = *dev2->dev_ops;
1154         dev_ops_tmp.info_get = NULL;
1155         dev2->dev_ops = &dev_ops_tmp;
1156         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1157                         &ts_params->qconf),
1158                         "Failed to configure queue %u on device %u "
1159                         "with NULL info_get ", queue_id, dev_id);
1160         dev2->dev_ops = dev1.dev_ops;
1161
1162         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS,
1163                         queue_id, &ts_params->qconf),
1164                         "Failed to configure queue %u on device %u ",
1165                         queue_id, dev_id);
1166
1167         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
1168                         &ts_params->qconf),
1169                         "Failed to configure queue %u on device %u ",
1170                         queue_id, dev_id);
1171
1172         /* Test for rte_bbdev_queue_info_get */
1173         dev2->dev_ops = NULL;
1174         TEST_ASSERT_SUCCESS(rte_bbdev_queue_info_get(dev_id, queue_id, &qinfo),
1175                         "Failed test for rte_bbdev_info_get: "
1176                         "NULL dev_ops structure  ");
1177         dev2->dev_ops = dev1.dev_ops;
1178
1179         TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(RTE_BBDEV_MAX_DEVS,
1180                         queue_id, &qinfo),
1181                         "Failed test for rte_bbdev_info_get: "
1182                         "invalid dev_id ");
1183
1184         TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id,
1185                         RTE_MAX_QUEUES_PER_PORT, &qinfo),
1186                         "Failed test for rte_bbdev_info_get: "
1187                         "invalid queue_id ");
1188
1189         TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id, queue_id, NULL),
1190                         "Failed test for rte_bbdev_info_get: "
1191                         "invalid dev_info ");
1192
1193         /* Test for rte_bbdev_start */
1194         dev2->dev_ops = NULL;
1195         TEST_ASSERT_FAIL(rte_bbdev_start(dev_id),
1196                         "Failed to start bbdev %u "
1197                         "with NULL dev_ops structure ", dev_id);
1198         dev2->dev_ops = dev1.dev_ops;
1199
1200         TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
1201                         "Failed to start bbdev %u ", dev_id);
1202
1203         /* Test for rte_bbdev_queue_start */
1204         dev2->dev_ops = NULL;
1205         TEST_ASSERT_FAIL(rte_bbdev_queue_start(dev_id, queue_id),
1206                         "Failed to start queue %u on device %u: "
1207                         "NULL dev_ops structure", queue_id, dev_id);
1208         dev2->dev_ops = dev1.dev_ops;
1209
1210         TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
1211                         "Failed to start queue %u on device %u ", queue_id,
1212                         dev_id);
1213
1214         /* Tests for rte_bbdev_stats_get */
1215         dev2->dev_ops = NULL;
1216         TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, &stats),
1217                         "Failed test for rte_bbdev_stats_get on device %u ",
1218                         dev_id);
1219         dev2->dev_ops = dev1.dev_ops;
1220
1221         dev_ops_tmp = *dev2->dev_ops;
1222         dev_ops_tmp.stats_reset = NULL;
1223         dev2->dev_ops = &dev_ops_tmp;
1224         TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1225                         "Failed test for rte_bbdev_stats_get: "
1226                         "NULL stats_get ");
1227         dev2->dev_ops = dev1.dev_ops;
1228
1229         TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1230                         "Failed test for rte_bbdev_stats_get on device %u ",
1231                         dev_id);
1232
1233         /*
1234          * Tests for:
1235          * rte_bbdev_callback_register,
1236          * rte_bbdev_pmd_callback_process,
1237          * rte_dev_callback_unregister
1238          */
1239         dev2->dev_ops = NULL;
1240         TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev_id,
1241                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1242                         "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
1243         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1244
1245         TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev_id,
1246                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1247                         "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
1248         dev2->dev_ops = dev1.dev_ops;
1249
1250         /* Tests for rte_bbdev_stats_reset */
1251         dev2->dev_ops = NULL;
1252         TEST_ASSERT_FAIL(rte_bbdev_stats_reset(dev_id),
1253                         "Failed to reset statistic for device %u ", dev_id);
1254         dev2->dev_ops = dev1.dev_ops;
1255
1256         dev_ops_tmp = *dev2->dev_ops;
1257         dev_ops_tmp.stats_reset = NULL;
1258         dev2->dev_ops = &dev_ops_tmp;
1259         TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1260                         "Failed test for rte_bbdev_stats_reset: "
1261                         "NULL stats_reset ");
1262         dev2->dev_ops = dev1.dev_ops;
1263
1264         TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1265                         "Failed to reset statistic for device %u ", dev_id);
1266
1267         /* Tests for rte_bbdev_queue_stop */
1268         dev2->dev_ops = NULL;
1269         TEST_ASSERT_FAIL(rte_bbdev_queue_stop(dev_id, queue_id),
1270                         "Failed to stop queue %u on device %u: "
1271                         "NULL dev_ops structure", queue_id, dev_id);
1272         dev2->dev_ops = dev1.dev_ops;
1273
1274         TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
1275                         "Failed to stop queue %u on device %u ", queue_id,
1276                         dev_id);
1277
1278         /* Tests for rte_bbdev_stop */
1279         dev2->dev_ops = NULL;
1280         TEST_ASSERT_FAIL(rte_bbdev_stop(dev_id),
1281                         "Failed to stop bbdev %u with NULL dev_ops structure ",
1282                         dev_id);
1283         dev2->dev_ops = dev1.dev_ops;
1284
1285         TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
1286                         "Failed to stop bbdev %u ", dev_id);
1287
1288         /* Tests for rte_bbdev_close */
1289         TEST_ASSERT_FAIL(rte_bbdev_close(RTE_BBDEV_MAX_DEVS),
1290                         "Failed to close bbdev with invalid dev_id");
1291
1292         dev2->dev_ops = NULL;
1293         TEST_ASSERT_FAIL(rte_bbdev_close(dev_id),
1294                         "Failed to close bbdev %u with NULL dev_ops structure ",
1295                         dev_id);
1296         dev2->dev_ops = dev1.dev_ops;
1297
1298         TEST_ASSERT_SUCCESS(rte_bbdev_close(dev_id),
1299                         "Failed to close bbdev %u ", dev_id);
1300
1301         return TEST_SUCCESS;
1302 }
1303
1304 static int
1305 test_bbdev_get_named_dev(void)
1306 {
1307         struct rte_bbdev *dev, *dev_tmp;
1308         const char *name = "name";
1309
1310         dev = rte_bbdev_allocate(name);
1311         TEST_ASSERT(dev != NULL, "Failed to initialize bbdev driver");
1312
1313         dev_tmp = rte_bbdev_get_named_dev(NULL);
1314         TEST_ASSERT(dev_tmp == NULL, "Failed test for rte_bbdev_get_named_dev: "
1315                         "function called with NULL parameter");
1316
1317         dev_tmp = rte_bbdev_get_named_dev(name);
1318
1319         TEST_ASSERT(dev == dev_tmp, "Failed test for rte_bbdev_get_named_dev: "
1320                         "wrong device was returned ");
1321
1322         TEST_ASSERT_SUCCESS(rte_bbdev_release(dev),
1323                         "Failed to uninitialize bbdev driver %s ", name);
1324
1325         return TEST_SUCCESS;
1326 }
1327
1328 static struct unit_test_suite bbdev_null_testsuite = {
1329         .suite_name = "BBDEV NULL Unit Test Suite",
1330         .setup = testsuite_setup,
1331         .teardown = testsuite_teardown,
1332         .unit_test_cases = {
1333
1334                 TEST_CASE(test_bbdev_configure_invalid_dev_id),
1335
1336                 TEST_CASE_ST(ut_setup, ut_teardown,
1337                                 test_bbdev_configure_invalid_num_queues),
1338
1339                 TEST_CASE_ST(ut_setup, ut_teardown,
1340                                 test_bbdev_configure_stop_device),
1341
1342                 TEST_CASE_ST(ut_setup, ut_teardown,
1343                                 test_bbdev_configure_stop_queue),
1344
1345                 TEST_CASE_ST(ut_setup, ut_teardown,
1346                                 test_bbdev_configure_invalid_queue_configure),
1347
1348                 TEST_CASE_ST(ut_setup, ut_teardown,
1349                                 test_bbdev_op_pool),
1350
1351                 TEST_CASE_ST(ut_setup, ut_teardown,
1352                                 test_bbdev_op_type),
1353
1354                 TEST_CASE_ST(ut_setup, ut_teardown,
1355                                 test_bbdev_op_pool_size),
1356
1357                 TEST_CASE_ST(ut_setup, ut_teardown,
1358                                 test_bbdev_stats),
1359
1360                 TEST_CASE_ST(ut_setup, ut_teardown,
1361                                 test_bbdev_driver_init),
1362
1363                 TEST_CASE_ST(ut_setup, ut_teardown,
1364                                 test_bbdev_callback),
1365
1366                 TEST_CASE_ST(ut_setup, ut_teardown,
1367                                 test_bbdev_invalid_driver),
1368
1369                 TEST_CASE_ST(ut_setup, ut_teardown,
1370                                 test_bbdev_get_named_dev),
1371
1372                 TEST_CASE(test_bbdev_count),
1373
1374                 TEST_CASES_END() /**< NULL terminate unit test array */
1375         }
1376 };
1377
1378 REGISTER_TEST_COMMAND(unittest, bbdev_null_testsuite);