ceph/src/spdk/dpdk/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_ul_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_ul_queue_priority;
 417         queue_id = info.num_queues;
 418         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 419                         &ts_params->qconf),
 420                         "Failed test for rte_bbdev_queue_configure: "
 421                         "invalid value queue_id: %u", queue_id);
 422
 423         queue_id = 0;
 424         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
 425                         "Failed test for rte_bbdev_queue_configure: "
 426                         "NULL qconf structure ");
 427
 428         ts_params->qconf.socket = RTE_MAX_NUMA_NODES;
 429         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
 430                         &ts_params->qconf),
 431                         "Failed test for rte_bbdev_queue_configure: "
 432                         "invalid socket number ");
 433
 434         ts_params->qconf.socket = SOCKET_ID_ANY;
 435         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
 436                         &ts_params->qconf),
 437                         "Failed test for rte_bbdev_queue_configure: "
 438                         "invalid value qconf.queue_size: %u",
 439                         ts_params->qconf.queue_size);
 440
 441         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS, queue_id,
 442                         &ts_params->qconf),
 443                         "Failed test for rte_bbdev_queue_configure: "
 444                         "invalid dev_id");
 445
 446         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
 447                         "Failed test for rte_bbdev_queue_configure: "
 448                         "invalid value qconf.queue_size: %u",
 449                         ts_params->qconf.queue_size);
 450
 451         return TEST_SUCCESS;
 452 }
 453
 454 static int
 455 test_bbdev_op_pool(void)
 456 {
 457         struct rte_mempool *mp;
 458
 459         unsigned int dec_size = sizeof(struct rte_bbdev_dec_op);
 460         unsigned int enc_size = sizeof(struct rte_bbdev_enc_op);
 461
 462         const char *pool_dec = "Test_DEC";
 463         const char *pool_enc = "Test_ENC";
 464
 465         /* Valid pool configuration */
 466         uint32_t size = 256;
 467         uint32_t cache_size = 128;
 468
 469         TEST_ASSERT(rte_bbdev_op_pool_create(NULL,
 470                         RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0) == NULL,
 471                         "Failed test for rte_bbdev_op_pool_create: "
 472                         "NULL name parameter");
 473
 474         TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_dec,
 475                         RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0)) != NULL,
 476                         "Failed test for rte_bbdev_op_pool_create: "
 477                         "returned value is empty");
 478
 479         TEST_ASSERT(mp->size == size,
 480                         "Failed test for rte_bbdev_op_pool_create: "
 481                         "invalid size of the mempool, mp->size: %u", mp->size);
 482
 483         TEST_ASSERT(mp->cache_size == cache_size,
 484                         "Failed test for rte_bbdev_op_pool_create: "
 485                         "invalid size of the mempool, mp->size: %u",
 486                         mp->cache_size);
 487
 488         TEST_ASSERT_SUCCESS(strcmp(mp->name, pool_dec),
 489                         "Failed test for rte_bbdev_op_pool_create: "
 490                         "invalid name of mempool, mp->name: %s", mp->name);
 491
 492         TEST_ASSERT(mp->elt_size == dec_size,
 493                         "Failed test for rte_bbdev_op_pool_create: "
 494                         "invalid element size for RTE_BBDEV_OP_TURBO_DEC, "
 495                         "mp->elt_size: %u", mp->elt_size);
 496
 497         rte_mempool_free(mp);
 498
 499         TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_enc,
 500                         RTE_BBDEV_OP_TURBO_ENC, size, cache_size, 0)) != NULL,
 501                          "Failed test for rte_bbdev_op_pool_create: "
 502                         "returned value is empty");
 503
 504         TEST_ASSERT(mp->elt_size == enc_size,
 505                         "Failed test for rte_bbdev_op_pool_create: "
 506                         "invalid element size for RTE_BBDEV_OP_TURBO_ENC, "
 507                         "mp->elt_size: %u", mp->elt_size);
 508
 509         rte_mempool_free(mp);
 510
 511         TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_NONE",
 512                         RTE_BBDEV_OP_NONE, size, cache_size, 0)) != NULL,
 513                         "Failed test for rte_bbdev_op_pool_create: "
 514                         "returned value is empty for RTE_BBDEV_OP_NONE");
 515
 516         TEST_ASSERT(mp->elt_size == (enc_size > dec_size ? enc_size : dec_size),
 517                         "Failed test for rte_bbdev_op_pool_create: "
 518                         "invalid  size for RTE_BBDEV_OP_NONE, mp->elt_size: %u",
 519                         mp->elt_size);
 520
 521         rte_mempool_free(mp);
 522
 523         TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_INV",
 524                         RTE_BBDEV_OP_TYPE_COUNT, size, cache_size, 0)) == NULL,
 525                         "Failed test for rte_bbdev_op_pool_create: "
 526                         "returned value is not NULL for invalid type");
 527
 528         /* Invalid pool configuration */
 529         size = 128;
 530         cache_size = 256;
 531
 532         TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_InvSize",
 533                         RTE_BBDEV_OP_NONE, size, cache_size, 0)) == NULL,
 534                         "Failed test for rte_bbdev_op_pool_create: "
 535                         "returned value should be empty "
 536                         "because size of per-lcore local cache "
 537                         "is greater than size of the mempool.");
 538
 539         return TEST_SUCCESS;
 540 }
 541
 542 /**
 543  *  Create pool of OP types RTE_BBDEV_OP_NONE, RTE_BBDEV_OP_TURBO_DEC and
 544  *  RTE_BBDEV_OP_TURBO_ENC and check that only ops of that type can be
 545  *  allocated
 546  */
 547 static int
 548 test_bbdev_op_type(void)
 549 {
 550         struct rte_mempool *mp_dec;
 551
 552         const unsigned int OPS_COUNT = 32;
 553         struct rte_bbdev_dec_op *dec_ops_arr[OPS_COUNT];
 554         struct rte_bbdev_enc_op *enc_ops_arr[OPS_COUNT];
 555
 556         const char *pool_dec = "Test_op_dec";
 557
 558         /* Valid pool configuration */
 559         uint32_t num_elements = 256;
 560         uint32_t cache_size = 128;
 561
 562         /* mempool type : RTE_BBDEV_OP_TURBO_DEC */
 563         mp_dec = rte_bbdev_op_pool_create(pool_dec,
 564                         RTE_BBDEV_OP_TURBO_DEC, num_elements, cache_size, 0);
 565         TEST_ASSERT(mp_dec != NULL, "Failed to create %s mempool", pool_dec);
 566
 567         TEST_ASSERT(rte_bbdev_dec_op_alloc_bulk(mp_dec, dec_ops_arr, 1) == 0,
 568                         "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
 569                         "OPs type: RTE_BBDEV_OP_TURBO_DEC");
 570
 571         TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_dec, enc_ops_arr, 1) != 0,
 572                         "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
 573                         "OPs type: RTE_BBDEV_OP_TURBO_ENC");
 574
 575         rte_mempool_free(mp_dec);
 576
 577         return TEST_SUCCESS;
 578 }
 579
 580 static int
 581 test_bbdev_op_pool_size(void)
 582 {
 583         struct rte_mempool *mp_none;
 584
 585         const unsigned int OPS_COUNT = 128;
 586         struct rte_bbdev_enc_op *ops_enc_arr[OPS_COUNT];
 587         struct rte_bbdev_enc_op *ops_ext_arr[OPS_COUNT];
 588         struct rte_bbdev_enc_op *ops_ext2_arr[OPS_COUNT];
 589
 590         const char *pool_none = "Test_pool_size";
 591
 592         /* Valid pool configuration */
 593         uint32_t num_elements = 256;
 594         uint32_t cache_size = 0;
 595
 596         /* Create mempool type : RTE_BBDEV_OP_TURBO_ENC, size : 256 */
 597         mp_none = rte_bbdev_op_pool_create(pool_none, RTE_BBDEV_OP_TURBO_ENC,
 598                         num_elements, cache_size, 0);
 599         TEST_ASSERT(mp_none != NULL, "Failed to create %s mempool", pool_none);
 600
 601         /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
 602         rte_bbdev_enc_op_alloc_bulk(mp_none, ops_enc_arr, OPS_COUNT);
 603
 604         /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
 605         TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext_arr,
 606                         OPS_COUNT) == 0,
 607                         "Failed test for allocating bbdev ops: "
 608                         "Mempool size: 256, Free : 128, Attempted to add: 128");
 609
 610         /* Try adding 128 more RTE_BBDEV_OP_TURBO_ENC ops, this should fail */
 611         TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
 612                         OPS_COUNT) != 0,
 613                         "Failed test for allocating bbdev ops: "
 614                         "Mempool size: 256, Free : 0, Attempted to add: 128");
 615
 616         /* Free-up 128 RTE_BBDEV_OP_TURBO_ENC ops */
 617         rte_bbdev_enc_op_free_bulk(ops_enc_arr, OPS_COUNT);
 618
 619         /* Try adding 128 RTE_BBDEV_OP_TURBO_DEC ops, this should succeed */
 620         /* Cache size > 0 causes reallocation of ops size > 127 fail */
 621         TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
 622                         OPS_COUNT) == 0,
 623                         "Failed test for allocating ops after mempool freed:  "
 624                         "Mempool size: 256, Free : 128, Attempted to add: 128");
 625
 626         rte_mempool_free(mp_none);
 627
 628         return TEST_SUCCESS;
 629 }
 630
 631 static int
 632 test_bbdev_count(void)
 633 {
 634         uint8_t num_devs, num_valid_devs = 0;
 635
 636         for (num_devs = 0; num_devs < RTE_BBDEV_MAX_DEVS; num_devs++) {
 637                 if (rte_bbdev_is_valid(num_devs))
 638                         num_valid_devs++;
 639         }
 640
 641         num_devs = rte_bbdev_count();
 642         TEST_ASSERT(num_valid_devs == num_devs,
 643                         "Failed test for rte_bbdev_is_valid: "
 644                         "invalid num_devs %u ", num_devs);
 645
 646         return TEST_SUCCESS;
 647 }
 648
 649 static int
 650 test_bbdev_stats(void)
 651 {
 652         uint8_t dev_id = null_dev_id;
 653         uint16_t queue_id = 0;
 654         struct rte_bbdev_dec_op *dec_ops[4096] = { 0 };
 655         struct rte_bbdev_dec_op *dec_proc_ops[4096] = { 0 };
 656         struct rte_bbdev_enc_op *enc_ops[4096] = { 0 };
 657         struct rte_bbdev_enc_op *enc_proc_ops[4096] = { 0 };
 658         uint16_t num_ops = 236;
 659         struct rte_bbdev_stats stats;
 660         struct bbdev_testsuite_params *ts_params = &testsuite_params;
 661
 662         TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
 663                         "Failed to stop queue %u on device %u ", queue_id,
 664                         dev_id);
 665         TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
 666                         "Failed to stop bbdev %u ", dev_id);
 667
 668         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
 669                         &ts_params->qconf),
 670                         "Failed to configure queue %u on device %u ",
 671                         queue_id, dev_id);
 672
 673         TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
 674                         "Failed to start bbdev %u ", dev_id);
 675
 676         TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
 677                         "Failed to start queue %u on device %u ", queue_id,
 678                         dev_id);
 679
 680         TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
 681                         "Failed to start queue %u on device %u ", queue_id,
 682                         dev_id);
 683
 684         /* Tests after enqueue operation */
 685         rte_bbdev_enqueue_enc_ops(dev_id, queue_id, enc_ops, num_ops);
 686         rte_bbdev_enqueue_dec_ops(dev_id, queue_id, dec_ops, num_ops);
 687
 688         TEST_ASSERT_FAIL(rte_bbdev_stats_get(RTE_BBDEV_MAX_DEVS, &stats),
 689                         "Failed test for rte_bbdev_stats_get on device %u ",
 690                         dev_id);
 691
 692         TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, NULL),
 693                         "Failed test for rte_bbdev_stats_get on device %u ",
 694                         dev_id);
 695
 696         TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
 697                         "Failed test for rte_bbdev_stats_get on device %u ",
 698                         dev_id);
 699
 700         TEST_ASSERT(stats.enqueued_count == 2 * num_ops,
 701                         "Failed test for rte_bbdev_enqueue_ops: "
 702                         "invalid enqueued_count %" PRIu64 " ",
 703                         stats.enqueued_count);
 704
 705         TEST_ASSERT(stats.dequeued_count == 0,
 706                         "Failed test for rte_bbdev_stats_reset: "
 707                         "invalid dequeued_count %" PRIu64 " ",
 708                         stats.dequeued_count);
 709
 710         /* Tests after dequeue operation */
 711         rte_bbdev_dequeue_enc_ops(dev_id, queue_id, enc_proc_ops, num_ops);
 712         rte_bbdev_dequeue_dec_ops(dev_id, queue_id, dec_proc_ops, num_ops);
 713
 714         TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
 715                         "Failed test for rte_bbdev_stats_get on device %u ",
 716                         dev_id);
 717
 718         TEST_ASSERT(stats.dequeued_count == 2 * num_ops,
 719                         "Failed test for rte_bbdev_dequeue_ops: "
 720                         "invalid enqueued_count %" PRIu64 " ",
 721                         stats.dequeued_count);
 722
 723         TEST_ASSERT(stats.enqueue_err_count == 0,
 724                         "Failed test for rte_bbdev_stats_reset: "
 725                         "invalid enqueue_err_count %" PRIu64 " ",
 726                         stats.enqueue_err_count);
 727
 728         TEST_ASSERT(stats.dequeue_err_count == 0,
 729                         "Failed test for rte_bbdev_stats_reset: "
 730                         "invalid dequeue_err_count %" PRIu64 " ",
 731                         stats.dequeue_err_count);
 732
 733         /* Tests after reset operation */
 734         TEST_ASSERT_FAIL(rte_bbdev_stats_reset(RTE_BBDEV_MAX_DEVS),
 735                         "Failed to reset statistic for device %u ", dev_id);
 736
 737         TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
 738                         "Failed to reset statistic for device %u ", dev_id);
 739         TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
 740                         "Failed test for rte_bbdev_stats_get on device %u ",
 741                         dev_id);
 742
 743         TEST_ASSERT(stats.enqueued_count == 0,
 744                         "Failed test for rte_bbdev_stats_reset: "
 745                         "invalid enqueued_count %" PRIu64 " ",
 746                         stats.enqueued_count);
 747
 748         TEST_ASSERT(stats.dequeued_count == 0,
 749                         "Failed test for rte_bbdev_stats_reset: "
 750                         "invalid dequeued_count %" PRIu64 " ",
 751                         stats.dequeued_count);
 752
 753         TEST_ASSERT(stats.enqueue_err_count == 0,
 754                         "Failed test for rte_bbdev_stats_reset: "
 755                         "invalid enqueue_err_count %" PRIu64 " ",
 756                         stats.enqueue_err_count);
 757
 758         TEST_ASSERT(stats.dequeue_err_count == 0,
 759                         "Failed test for rte_bbdev_stats_reset: "
 760                         "invalid dequeue_err_count %" PRIu64 " ",
 761                         stats.dequeue_err_count);
 762
 763         return TEST_SUCCESS;
 764 }
 765
 766 static int
 767 test_bbdev_driver_init(void)
 768 {
 769         struct rte_bbdev *dev1, *dev2;
 770         const char *name = "dev_name";
 771         char name_tmp[32];
 772         int num_devs, num_devs_tmp;
 773
 774         dev1 = rte_bbdev_allocate(NULL);
 775         TEST_ASSERT(dev1 == NULL,
 776                         "Failed initialize bbdev driver with NULL name");
 777
 778         dev1 = rte_bbdev_allocate(name);
 779         TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
 780
 781         dev2 = rte_bbdev_allocate(name);
 782         TEST_ASSERT(dev2 == NULL,
 783                         "Failed to initialize bbdev driver: "
 784                         "driver with the same name has been initialized before");
 785
 786         num_devs = rte_bbdev_count() - 1;
 787         num_devs_tmp = num_devs;
 788
 789         /* Initialize the maximum amount of devices */
 790         do {
 791                 sprintf(name_tmp, "%s%i", "name_", num_devs);
 792                 dev2 = rte_bbdev_allocate(name_tmp);
 793                 TEST_ASSERT(dev2 != NULL,
 794                                 "Failed to initialize bbdev driver");
 795                 ++num_devs;
 796         } while (num_devs < (RTE_BBDEV_MAX_DEVS - 1));
 797
 798         sprintf(name_tmp, "%s%i", "name_", num_devs);
 799         dev2 = rte_bbdev_allocate(name_tmp);
 800         TEST_ASSERT(dev2 == NULL, "Failed to initialize bbdev driver number %d "
 801                         "more drivers than RTE_BBDEV_MAX_DEVS: %d ", num_devs,
 802                         RTE_BBDEV_MAX_DEVS);
 803
 804         num_devs--;
 805
 806         while (num_devs >= num_devs_tmp) {
 807                 sprintf(name_tmp, "%s%i", "name_", num_devs);
 808                 dev2 = rte_bbdev_get_named_dev(name_tmp);
 809                 TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
 810                                 "Failed to uninitialize bbdev driver %s ",
 811                                 name_tmp);
 812                 num_devs--;
 813         }
 814
 815         TEST_ASSERT(dev1->data->dev_id < RTE_BBDEV_MAX_DEVS,
 816                         "Failed test rte_bbdev_allocate: "
 817                         "invalid dev_id %" PRIu8 ", max number of devices %d ",
 818                         dev1->data->dev_id, RTE_BBDEV_MAX_DEVS);
 819
 820         TEST_ASSERT(dev1->state == RTE_BBDEV_INITIALIZED,
 821                         "Failed test rte_bbdev_allocate: "
 822                         "invalid state %d (0 - RTE_BBDEV_UNUSED, 1 - RTE_BBDEV_INITIALIZED",
 823                         dev1->state);
 824
 825         TEST_ASSERT_FAIL(rte_bbdev_release(NULL),
 826                         "Failed to uninitialize bbdev driver with NULL bbdev");
 827
 828         sprintf(name_tmp, "%s", "invalid_name");
 829         dev2 = rte_bbdev_get_named_dev(name_tmp);
 830         TEST_ASSERT_FAIL(rte_bbdev_release(dev2),
 831                         "Failed to uninitialize bbdev driver with invalid name");
 832
 833         dev2 = rte_bbdev_get_named_dev(name);
 834         TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
 835                         "Failed to uninitialize bbdev driver: %s ", name);
 836
 837         return TEST_SUCCESS;
 838 }
 839
 840 static void
 841 event_callback(uint16_t dev_id, enum rte_bbdev_event_type type, void *param,
 842                 void *ret_param)
 843 {
 844         RTE_SET_USED(dev_id);
 845         RTE_SET_USED(ret_param);
 846
 847         if (param == NULL)
 848                 return;
 849
 850         if (type == RTE_BBDEV_EVENT_UNKNOWN ||
 851                         type == RTE_BBDEV_EVENT_ERROR ||
 852                         type == RTE_BBDEV_EVENT_MAX)
 853                 *(int *)param = type;
 854 }
 855
 856 static int
 857 test_bbdev_callback(void)
 858 {
 859         struct rte_bbdev *dev1, *dev2;
 860         const char *name = "dev_name1";
 861         const char *name2 = "dev_name2";
 862         int event_status;
 863         uint8_t invalid_dev_id = RTE_BBDEV_MAX_DEVS;
 864         enum rte_bbdev_event_type invalid_event_type = RTE_BBDEV_EVENT_MAX;
 865         uint8_t dev_id;
 866
 867         dev1 = rte_bbdev_allocate(name);
 868         TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
 869
 870         /*
 871          * RTE_BBDEV_EVENT_UNKNOWN - unregistered
 872          * RTE_BBDEV_EVENT_ERROR - unregistered
 873          */
 874         event_status = -1;
 875         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
 876         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
 877         TEST_ASSERT(event_status == -1,
 878                         "Failed test for rte_bbdev_pmd_callback_process: "
 879                         "events were not registered ");
 880
 881         TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
 882                         RTE_BBDEV_EVENT_MAX, event_callback, NULL),
 883                         "Failed to callback register for RTE_BBDEV_EVENT_MAX ");
 884
 885         TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
 886                         RTE_BBDEV_EVENT_MAX, event_callback, NULL),
 887                         "Failed to unregister RTE_BBDEV_EVENT_MAX ");
 888
 889         /*
 890          * RTE_BBDEV_EVENT_UNKNOWN - registered
 891          * RTE_BBDEV_EVENT_ERROR - unregistered
 892          */
 893         TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
 894                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
 895                         "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
 896
 897         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
 898         TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
 899                         "Failed test for rte_bbdev_pmd_callback_process "
 900                         "for RTE_BBDEV_EVENT_UNKNOWN ");
 901
 902         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
 903         TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
 904                         "Failed test for rte_bbdev_pmd_callback_process: "
 905                         "event RTE_BBDEV_EVENT_ERROR was not registered ");
 906
 907         /*
 908          * RTE_BBDEV_EVENT_UNKNOWN - registered
 909          * RTE_BBDEV_EVENT_ERROR - registered
 910          */
 911         TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
 912                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
 913                         "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR ");
 914
 915         TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
 916                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
 917                         "Failed to callback register for RTE_BBDEV_EVENT_ERROR"
 918                         "(re-registration) ");
 919
 920         event_status = -1;
 921         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
 922         TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
 923                         "Failed test for rte_bbdev_pmd_callback_process "
 924                         "for RTE_BBDEV_EVENT_UNKNOWN ");
 925
 926         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
 927         TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_ERROR,
 928                         "Failed test for rte_bbdev_pmd_callback_process "
 929                         "for RTE_BBDEV_EVENT_ERROR ");
 930
 931         /*
 932          * RTE_BBDEV_EVENT_UNKNOWN - registered
 933          * RTE_BBDEV_EVENT_ERROR - unregistered
 934          */
 935         TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev1->data->dev_id,
 936                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
 937                         "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
 938
 939         event_status = -1;
 940         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
 941         TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
 942                         "Failed test for rte_bbdev_pmd_callback_process "
 943                         "for RTE_BBDEV_EVENT_UNKNOWN ");
 944
 945         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
 946         TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
 947                         "Failed test for rte_bbdev_pmd_callback_process: "
 948                         "event RTE_BBDEV_EVENT_ERROR was unregistered ");
 949
 950         /* rte_bbdev_callback_register with invalid inputs */
 951         TEST_ASSERT_FAIL(rte_bbdev_callback_register(invalid_dev_id,
 952                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
 953                         "Failed test for rte_bbdev_callback_register "
 954                         "for invalid_dev_id ");
 955
 956         TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
 957                         invalid_event_type, event_callback, &event_status),
 958                         "Failed to callback register for invalid event type ");
 959
 960         TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
 961                         RTE_BBDEV_EVENT_ERROR, NULL, &event_status),
 962                         "Failed to callback register - no callback function ");
 963
 964         /* The impact of devices on each other */
 965         dev2 = rte_bbdev_allocate(name2);
 966         TEST_ASSERT(dev2 != NULL,
 967                         "Failed to initialize bbdev driver");
 968
 969         /*
 970          * dev2:
 971          * RTE_BBDEV_EVENT_UNKNOWN - unregistered
 972          * RTE_BBDEV_EVENT_ERROR - unregistered
 973          */
 974         event_status = -1;
 975         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
 976         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
 977         TEST_ASSERT(event_status == -1,
 978                         "Failed test for rte_bbdev_pmd_callback_process: "
 979                         "events were not registered ");
 980
 981         /*
 982          * dev1: RTE_BBDEV_EVENT_ERROR - unregistered
 983          * dev2: RTE_BBDEV_EVENT_ERROR - registered
 984          */
 985         TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
 986                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
 987                         "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR");
 988
 989         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
 990         TEST_ASSERT(event_status == -1,
 991                 "Failed test for rte_bbdev_pmd_callback_process in dev1 "
 992                 "for RTE_BBDEV_EVENT_ERROR ");
 993
 994         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
 995         TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_ERROR,
 996                 "Failed test for rte_bbdev_pmd_callback_process in dev2 "
 997                 "for RTE_BBDEV_EVENT_ERROR ");
 998
 999         /*
1000          * dev1: RTE_BBDEV_EVENT_UNKNOWN - registered
1001          * dev2: RTE_BBDEV_EVENT_UNKNOWN - unregistered
1002          */
1003         TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
1004                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1005                         "Failed to callback register for RTE_BBDEV_EVENT_UNKNOWN "
1006                         "in dev 2 ");
1007
1008         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1009         TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
1010                         "Failed test for rte_bbdev_pmd_callback_process in dev2"
1011                         " for RTE_BBDEV_EVENT_UNKNOWN ");
1012
1013         TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1014                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1015                         "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN ");
1016
1017         TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1018                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1019                         "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN : "
1020                         "unregister function called once again ");
1021
1022         event_status = -1;
1023         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1024         TEST_ASSERT(event_status == -1,
1025                         "Failed test for rte_bbdev_pmd_callback_process in dev2"
1026                 " for RTE_BBDEV_EVENT_UNKNOWN ");
1027
1028         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1029         TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
1030                         "Failed test for rte_bbdev_pmd_callback_process in dev2 "
1031                         "for RTE_BBDEV_EVENT_UNKNOWN ");
1032
1033         /* rte_bbdev_pmd_callback_process with invalid inputs */
1034         rte_bbdev_pmd_callback_process(NULL, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1035
1036         event_status = -1;
1037         rte_bbdev_pmd_callback_process(dev1, invalid_event_type, NULL);
1038         TEST_ASSERT(event_status == -1,
1039                         "Failed test for rte_bbdev_pmd_callback_process: "
1040                         "for invalid event type ");
1041
1042         /* rte_dev_callback_unregister with invalid inputs */
1043         TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(invalid_dev_id,
1044                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1045                         "Failed test for rte_dev_callback_unregister "
1046                         "for invalid_dev_id ");
1047
1048         TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1049                         invalid_event_type, event_callback, &event_status),
1050                         "Failed rte_dev_callback_unregister "
1051                         "for invalid event type ");
1052
1053         TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1054                         invalid_event_type, NULL, &event_status),
1055                         "Failed rte_dev_callback_unregister "
1056                         "when no callback function ");
1057
1058         dev_id = dev1->data->dev_id;
1059
1060         rte_bbdev_release(dev1);
1061         rte_bbdev_release(dev2);
1062
1063         TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev_id,
1064                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1065                         "Failed test for rte_bbdev_callback_register: "
1066                         "function called after rte_bbdev_driver_uninit .");
1067
1068         TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev_id,
1069                         RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1070                         "Failed test for rte_dev_callback_unregister: "
1071                         "function called after rte_bbdev_driver_uninit. ");
1072
1073         event_status = -1;
1074         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1075         rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
1076         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1077         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
1078         TEST_ASSERT(event_status == -1,
1079                         "Failed test for rte_bbdev_pmd_callback_process: "
1080                         "callback function was called after rte_bbdev_driver_uninit");
1081
1082         return TEST_SUCCESS;
1083 }
1084
1085 static int
1086 test_bbdev_invalid_driver(void)
1087 {
1088         struct rte_bbdev dev1, *dev2;
1089         uint8_t dev_id = null_dev_id;
1090         uint16_t queue_id = 0;
1091         struct rte_bbdev_stats stats;
1092         struct bbdev_testsuite_params *ts_params = &testsuite_params;
1093         struct rte_bbdev_queue_info qinfo;
1094         struct rte_bbdev_ops dev_ops_tmp;
1095
1096         TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u ",
1097                         dev_id);
1098
1099         dev1 = rte_bbdev_devices[dev_id];
1100         dev2 = &rte_bbdev_devices[dev_id];
1101
1102         /* Tests for rte_bbdev_setup_queues */
1103         dev2->dev_ops = NULL;
1104         TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1105                         "Failed test for rte_bbdev_setup_queues: "
1106                         "NULL dev_ops structure ");
1107         dev2->dev_ops = dev1.dev_ops;
1108
1109         dev_ops_tmp = *dev2->dev_ops;
1110         dev_ops_tmp.info_get = NULL;
1111         dev2->dev_ops = &dev_ops_tmp;
1112         TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1113                         "Failed test for rte_bbdev_setup_queues: "
1114                         "NULL info_get ");
1115         dev2->dev_ops = dev1.dev_ops;
1116
1117         dev_ops_tmp = *dev2->dev_ops;
1118         dev_ops_tmp.queue_release = NULL;
1119         dev2->dev_ops = &dev_ops_tmp;
1120         TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1121                         "Failed test for rte_bbdev_setup_queues: "
1122                         "NULL queue_release ");
1123         dev2->dev_ops = dev1.dev_ops;
1124
1125         dev2->data->socket_id = SOCKET_ID_ANY;
1126         TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, 1,
1127                         SOCKET_ID_ANY), "Failed to configure bbdev %u", dev_id);
1128
1129         /* Test for rte_bbdev_queue_configure */
1130         dev2->dev_ops = NULL;
1131         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1132                         &ts_params->qconf),
1133                         "Failed to configure queue %u on device %u "
1134                         "with NULL dev_ops structure ", queue_id, dev_id);
1135         dev2->dev_ops = dev1.dev_ops;
1136
1137         dev_ops_tmp = *dev2->dev_ops;
1138         dev_ops_tmp.queue_setup = NULL;
1139         dev2->dev_ops = &dev_ops_tmp;
1140         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1141                         &ts_params->qconf),
1142                         "Failed to configure queue %u on device %u "
1143                         "with NULL queue_setup ", queue_id, dev_id);
1144         dev2->dev_ops = dev1.dev_ops;
1145
1146         dev_ops_tmp = *dev2->dev_ops;
1147         dev_ops_tmp.info_get = NULL;
1148         dev2->dev_ops = &dev_ops_tmp;
1149         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1150                         &ts_params->qconf),
1151                         "Failed to configure queue %u on device %u "
1152                         "with NULL info_get ", queue_id, dev_id);
1153         dev2->dev_ops = dev1.dev_ops;
1154
1155         TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS,
1156                         queue_id, &ts_params->qconf),
1157                         "Failed to configure queue %u on device %u ",
1158                         queue_id, dev_id);
1159
1160         TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
1161                         &ts_params->qconf),
1162                         "Failed to configure queue %u on device %u ",
1163                         queue_id, dev_id);
1164
1165         /* Test for rte_bbdev_queue_info_get */
1166         dev2->dev_ops = NULL;
1167         TEST_ASSERT_SUCCESS(rte_bbdev_queue_info_get(dev_id, queue_id, &qinfo),
1168                         "Failed test for rte_bbdev_info_get: "
1169                         "NULL dev_ops structure  ");
1170         dev2->dev_ops = dev1.dev_ops;
1171
1172         TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(RTE_BBDEV_MAX_DEVS,
1173                         queue_id, &qinfo),
1174                         "Failed test for rte_bbdev_info_get: "
1175                         "invalid dev_id ");
1176
1177         TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id,
1178                         RTE_MAX_QUEUES_PER_PORT, &qinfo),
1179                         "Failed test for rte_bbdev_info_get: "
1180                         "invalid queue_id ");
1181
1182         TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id, queue_id, NULL),
1183                         "Failed test for rte_bbdev_info_get: "
1184                         "invalid dev_info ");
1185
1186         /* Test for rte_bbdev_start */
1187         dev2->dev_ops = NULL;
1188         TEST_ASSERT_FAIL(rte_bbdev_start(dev_id),
1189                         "Failed to start bbdev %u "
1190                         "with NULL dev_ops structure ", dev_id);
1191         dev2->dev_ops = dev1.dev_ops;
1192
1193         TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
1194                         "Failed to start bbdev %u ", dev_id);
1195
1196         /* Test for rte_bbdev_queue_start */
1197         dev2->dev_ops = NULL;
1198         TEST_ASSERT_FAIL(rte_bbdev_queue_start(dev_id, queue_id),
1199                         "Failed to start queue %u on device %u: "
1200                         "NULL dev_ops structure", queue_id, dev_id);
1201         dev2->dev_ops = dev1.dev_ops;
1202
1203         TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
1204                         "Failed to start queue %u on device %u ", queue_id,
1205                         dev_id);
1206
1207         /* Tests for rte_bbdev_stats_get */
1208         dev2->dev_ops = NULL;
1209         TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, &stats),
1210                         "Failed test for rte_bbdev_stats_get on device %u ",
1211                         dev_id);
1212         dev2->dev_ops = dev1.dev_ops;
1213
1214         dev_ops_tmp = *dev2->dev_ops;
1215         dev_ops_tmp.stats_reset = NULL;
1216         dev2->dev_ops = &dev_ops_tmp;
1217         TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1218                         "Failed test for rte_bbdev_stats_get: "
1219                         "NULL stats_get ");
1220         dev2->dev_ops = dev1.dev_ops;
1221
1222         TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1223                         "Failed test for rte_bbdev_stats_get on device %u ",
1224                         dev_id);
1225
1226         /*
1227          * Tests for:
1228          * rte_bbdev_callback_register,
1229          * rte_bbdev_pmd_callback_process,
1230          * rte_dev_callback_unregister
1231          */
1232         dev2->dev_ops = NULL;
1233         TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev_id,
1234                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1235                         "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
1236         rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1237
1238         TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev_id,
1239                         RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1240                         "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
1241         dev2->dev_ops = dev1.dev_ops;
1242
1243         /* Tests for rte_bbdev_stats_reset */
1244         dev2->dev_ops = NULL;
1245         TEST_ASSERT_FAIL(rte_bbdev_stats_reset(dev_id),
1246                         "Failed to reset statistic for device %u ", dev_id);
1247         dev2->dev_ops = dev1.dev_ops;
1248
1249         dev_ops_tmp = *dev2->dev_ops;
1250         dev_ops_tmp.stats_reset = NULL;
1251         dev2->dev_ops = &dev_ops_tmp;
1252         TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1253                         "Failed test for rte_bbdev_stats_reset: "
1254                         "NULL stats_reset ");
1255         dev2->dev_ops = dev1.dev_ops;
1256
1257         TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1258                         "Failed to reset statistic for device %u ", dev_id);
1259
1260         /* Tests for rte_bbdev_queue_stop */
1261         dev2->dev_ops = NULL;
1262         TEST_ASSERT_FAIL(rte_bbdev_queue_stop(dev_id, queue_id),
1263                         "Failed to stop queue %u on device %u: "
1264                         "NULL dev_ops structure", queue_id, dev_id);
1265         dev2->dev_ops = dev1.dev_ops;
1266
1267         TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
1268                         "Failed to stop queue %u on device %u ", queue_id,
1269                         dev_id);
1270
1271         /* Tests for rte_bbdev_stop */
1272         dev2->dev_ops = NULL;
1273         TEST_ASSERT_FAIL(rte_bbdev_stop(dev_id),
1274                         "Failed to stop bbdev %u with NULL dev_ops structure ",
1275                         dev_id);
1276         dev2->dev_ops = dev1.dev_ops;
1277
1278         TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
1279                         "Failed to stop bbdev %u ", dev_id);
1280
1281         /* Tests for rte_bbdev_close */
1282         TEST_ASSERT_FAIL(rte_bbdev_close(RTE_BBDEV_MAX_DEVS),
1283                         "Failed to close bbdev with invalid dev_id");
1284
1285         dev2->dev_ops = NULL;
1286         TEST_ASSERT_FAIL(rte_bbdev_close(dev_id),
1287                         "Failed to close bbdev %u with NULL dev_ops structure ",
1288                         dev_id);
1289         dev2->dev_ops = dev1.dev_ops;
1290
1291         TEST_ASSERT_SUCCESS(rte_bbdev_close(dev_id),
1292                         "Failed to close bbdev %u ", dev_id);
1293
1294         return TEST_SUCCESS;
1295 }
1296
1297 static int
1298 test_bbdev_get_named_dev(void)
1299 {
1300         struct rte_bbdev *dev, *dev_tmp;
1301         const char *name = "name";
1302
1303         dev = rte_bbdev_allocate(name);
1304         TEST_ASSERT(dev != NULL, "Failed to initialize bbdev driver");
1305
1306         dev_tmp = rte_bbdev_get_named_dev(NULL);
1307         TEST_ASSERT(dev_tmp == NULL, "Failed test for rte_bbdev_get_named_dev: "
1308                         "function called with NULL parameter");
1309
1310         dev_tmp = rte_bbdev_get_named_dev(name);
1311
1312         TEST_ASSERT(dev == dev_tmp, "Failed test for rte_bbdev_get_named_dev: "
1313                         "wrong device was returned ");
1314
1315         TEST_ASSERT_SUCCESS(rte_bbdev_release(dev),
1316                         "Failed to uninitialize bbdev driver %s ", name);
1317
1318         return TEST_SUCCESS;
1319 }
1320
1321 static struct unit_test_suite bbdev_null_testsuite = {
1322         .suite_name = "BBDEV NULL Unit Test Suite",
1323         .setup = testsuite_setup,
1324         .teardown = testsuite_teardown,
1325         .unit_test_cases = {
1326
1327                 TEST_CASE(test_bbdev_configure_invalid_dev_id),
1328
1329                 TEST_CASE_ST(ut_setup, ut_teardown,
1330                                 test_bbdev_configure_invalid_num_queues),
1331
1332                 TEST_CASE_ST(ut_setup, ut_teardown,
1333                                 test_bbdev_configure_stop_device),
1334
1335                 TEST_CASE_ST(ut_setup, ut_teardown,
1336                                 test_bbdev_configure_stop_queue),
1337
1338                 TEST_CASE_ST(ut_setup, ut_teardown,
1339                                 test_bbdev_configure_invalid_queue_configure),
1340
1341                 TEST_CASE_ST(ut_setup, ut_teardown,
1342                                 test_bbdev_op_pool),
1343
1344                 TEST_CASE_ST(ut_setup, ut_teardown,
1345                                 test_bbdev_op_type),
1346
1347                 TEST_CASE_ST(ut_setup, ut_teardown,
1348                                 test_bbdev_op_pool_size),
1349
1350                 TEST_CASE_ST(ut_setup, ut_teardown,
1351                                 test_bbdev_stats),
1352
1353                 TEST_CASE_ST(ut_setup, ut_teardown,
1354                                 test_bbdev_driver_init),
1355
1356                 TEST_CASE_ST(ut_setup, ut_teardown,
1357                                 test_bbdev_callback),
1358
1359                 TEST_CASE_ST(ut_setup, ut_teardown,
1360                                 test_bbdev_invalid_driver),
1361
1362                 TEST_CASE_ST(ut_setup, ut_teardown,
1363                                 test_bbdev_get_named_dev),
1364
1365                 TEST_CASE(test_bbdev_count),
1366
1367                 TEST_CASES_END() /**< NULL terminate unit test array */
1368         }
1369 };
1370
1371 REGISTER_TEST_COMMAND(unittest, bbdev_null_testsuite);