drivers/event/dlb2/dlb2_selftest.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2016-2020 Intel Corporation
   3  */
   4
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <stdint.h>
   8 #include <errno.h>
   9 #include <unistd.h>
  10 #include <sys/queue.h>
  11
  12 #include <rte_memory.h>
  13 #include <rte_memzone.h>
  14 #include <rte_launch.h>
  15 #include <rte_eal.h>
  16 #include <rte_per_lcore.h>
  17 #include <rte_lcore.h>
  18 #include <rte_debug.h>
  19 #include <rte_ethdev.h>
  20 #include <rte_cycles.h>
  21 #include <rte_eventdev.h>
  22 #include <rte_pause.h>
  23
  24 #include "dlb2_priv.h"
  25 #include "rte_pmd_dlb2.h"
  26
  27 #define MAX_PORTS 32
  28 #define MAX_QIDS 32
  29 #define DEFAULT_NUM_SEQ_NUMS 64
  30
  31 static struct rte_mempool *eventdev_func_mempool;
  32 static int evdev;
  33
  34 struct test {
  35         struct rte_mempool *mbuf_pool;
  36         int nb_qids;
  37 };
  38
  39 /* initialization and config */
  40 static inline int
  41 init(struct test *t, int nb_queues, int nb_ports)
  42 {
  43         struct rte_event_dev_config config = {0};
  44         struct rte_event_dev_info info;
  45         int ret;
  46
  47         memset(t, 0, sizeof(*t));
  48
  49         t->mbuf_pool = eventdev_func_mempool;
  50
  51         if (rte_event_dev_info_get(evdev, &info)) {
  52                 printf("%d: Error querying device info\n", __LINE__);
  53                 return -1;
  54         }
  55
  56         config.nb_event_queues = nb_queues;
  57         config.nb_event_ports = nb_ports;
  58         config.nb_event_queue_flows = info.max_event_queue_flows;
  59         config.nb_events_limit = info.max_num_events;
  60         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
  61         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
  62         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
  63         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
  64
  65         ret = rte_event_dev_configure(evdev, &config);
  66         if (ret < 0)
  67                 printf("%d: Error configuring device\n", __LINE__);
  68
  69         return ret;
  70 }
  71
  72 static inline int
  73 create_ports(int num_ports)
  74 {
  75         int i;
  76
  77         if (num_ports > MAX_PORTS)
  78                 return -1;
  79
  80         for (i = 0; i < num_ports; i++) {
  81                 struct rte_event_port_conf conf;
  82
  83                 if (rte_event_port_default_conf_get(evdev, i, &conf)) {
  84                         printf("%d: Error querying default port conf\n",
  85                                __LINE__);
  86                         return -1;
  87                 }
  88
  89                 if (rte_event_port_setup(evdev, i, &conf) < 0) {
  90                         printf("%d: Error setting up port %d\n", __LINE__, i);
  91                         return -1;
  92                 }
  93         }
  94
  95         return 0;
  96 }
  97
  98 static inline int
  99 create_lb_qids(struct test *t, int num_qids, uint32_t flags)
 100 {
 101         int i;
 102
 103         for (i = t->nb_qids; i < t->nb_qids + num_qids; i++) {
 104                 struct rte_event_queue_conf conf;
 105
 106                 if (rte_event_queue_default_conf_get(evdev, i, &conf)) {
 107                         printf("%d: Error querying default queue conf\n",
 108                                __LINE__);
 109                         return -1;
 110                 }
 111
 112                 conf.schedule_type = flags;
 113
 114                 if (conf.schedule_type == RTE_SCHED_TYPE_PARALLEL)
 115                         conf.nb_atomic_order_sequences = 0;
 116                 else
 117                         conf.nb_atomic_order_sequences = DEFAULT_NUM_SEQ_NUMS;
 118
 119                 if (rte_event_queue_setup(evdev, i, &conf) < 0) {
 120                         printf("%d: error creating qid %d\n", __LINE__, i);
 121                         return -1;
 122                 }
 123         }
 124
 125         t->nb_qids += num_qids;
 126         if (t->nb_qids > MAX_QIDS)
 127                 return -1;
 128
 129         return 0;
 130 }
 131
 132 static inline int
 133 create_atomic_qids(struct test *t, int num_qids)
 134 {
 135         return create_lb_qids(t, num_qids, RTE_SCHED_TYPE_ATOMIC);
 136 }
 137
 138 /* destruction */
 139 static inline void
 140 cleanup(void)
 141 {
 142         int ret = 0;
 143
 144         rte_event_dev_stop(evdev);
 145         ret = rte_event_dev_close(evdev);
 146
 147         if (ret)
 148                 printf("%d: rte_event_dev_close failed, ret = %d\n",
 149                         __LINE__, ret);
 150 };
 151
 152 static inline int
 153 enqueue_timeout(uint8_t port_id, struct rte_event *ev, uint64_t tmo_us)
 154 {
 155         const uint64_t start = rte_get_timer_cycles();
 156         const uint64_t ticks = (tmo_us * rte_get_timer_hz()) / 1E6;
 157
 158         while ((rte_get_timer_cycles() - start) < ticks) {
 159                 if (rte_event_enqueue_burst(evdev, port_id, ev, 1) == 1)
 160                         return 0;
 161
 162                 if (rte_errno != -ENOSPC) {
 163                         printf("enqueue_burst returned rte_errno %d\n",
 164                                rte_errno);
 165                         return -1;
 166                 }
 167         }
 168         printf("%s time out\n", __func__);
 169         return -1;
 170 }
 171
 172 static void
 173 flush(uint8_t id __rte_unused, struct rte_event event, void *arg __rte_unused)
 174 {
 175         rte_pktmbuf_free(event.mbuf);
 176 }
 177
 178 static int
 179 test_stop_flush(struct test *t) /* test to check we can properly flush events */
 180 {
 181         struct rte_event ev;
 182         uint32_t dequeue_depth;
 183         unsigned int i, count;
 184         uint8_t queue_id;
 185
 186         ev.op = RTE_EVENT_OP_NEW;
 187
 188         if (init(t, 2, 1) < 0 ||
 189             create_ports(1) < 0 ||
 190             create_atomic_qids(t, 2) < 0) {
 191                 printf("%d: Error initializing device\n", __LINE__);
 192                 return -1;
 193         }
 194
 195         if (rte_event_port_link(evdev, 0, NULL, NULL, 0) != 2) {
 196                 printf("%d: Error linking queues to the port\n", __LINE__);
 197                 goto err;
 198         }
 199
 200         if (rte_event_dev_start(evdev) < 0) {
 201                 printf("%d: Error with start call\n", __LINE__);
 202                 goto err;
 203         }
 204
 205         /* Unlink queue 1 so the PMD's stop callback has to cleanup an unlinked
 206          * queue.
 207          */
 208         queue_id = 1;
 209
 210         if (rte_event_port_unlink(evdev, 0, &queue_id, 1) != 1) {
 211                 printf("%d: Error unlinking queue 1 from port\n", __LINE__);
 212                 goto err;
 213         }
 214
 215         if (t->mbuf_pool)
 216                 count = rte_mempool_avail_count(t->mbuf_pool);
 217         else {
 218                 printf("%d: mbuf_pool is NULL\n", __LINE__);
 219                 goto err;
 220         }
 221
 222         if (rte_event_port_attr_get(evdev,
 223                                     0,
 224                                     RTE_EVENT_PORT_ATTR_DEQ_DEPTH,
 225                                     &dequeue_depth)) {
 226                 printf("%d: Error retrieveing dequeue depth\n", __LINE__);
 227                 goto err;
 228         }
 229
 230         /* Send QEs to queue 0 */
 231         for (i = 0; i < dequeue_depth + 1; i++) {
 232                 ev.mbuf = rte_pktmbuf_alloc(t->mbuf_pool);
 233                 ev.queue_id = 0;
 234                 ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 235
 236                 if (enqueue_timeout(0, &ev, 1000)) {
 237                         printf("%d: Error enqueuing events\n", __LINE__);
 238                         goto err;
 239                 }
 240         }
 241
 242         /* Send QEs to queue 1 */
 243         for (i = 0; i < dequeue_depth + 1; i++) {
 244                 ev.mbuf = rte_pktmbuf_alloc(t->mbuf_pool);
 245                 ev.queue_id = 1;
 246                 ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 247
 248                 if (enqueue_timeout(0, &ev, 1000)) {
 249                         printf("%d: Error enqueuing events\n", __LINE__);
 250                         goto err;
 251                 }
 252         }
 253
 254         /* Now the DLB is scheduling events from the port to the IQ, and at
 255          * least one event should be remaining in each queue.
 256          */
 257
 258         if (rte_event_dev_stop_flush_callback_register(evdev, flush, NULL)) {
 259                 printf("%d: Error installing the flush callback\n", __LINE__);
 260                 goto err;
 261         }
 262
 263         cleanup();
 264
 265         if (count != rte_mempool_avail_count(t->mbuf_pool)) {
 266                 printf("%d: Error executing the flush callback\n", __LINE__);
 267                 goto err;
 268         }
 269
 270         if (rte_event_dev_stop_flush_callback_register(evdev, NULL, NULL)) {
 271                 printf("%d: Error uninstalling the flush callback\n", __LINE__);
 272                 goto err;
 273         }
 274
 275         return 0;
 276 err:
 277         cleanup();
 278         return -1;
 279 }
 280
 281 static int
 282 test_single_link(void)
 283 {
 284         struct rte_event_dev_config config = {0};
 285         struct rte_event_queue_conf queue_conf;
 286         struct rte_event_port_conf port_conf;
 287         struct rte_event_dev_info info;
 288         uint8_t queue_id;
 289         int ret;
 290
 291         if (rte_event_dev_info_get(evdev, &info)) {
 292                 printf("%d: Error querying device info\n", __LINE__);
 293                 return -1;
 294         }
 295
 296         config.nb_event_queues = 2;
 297         config.nb_event_ports = 2;
 298         config.nb_single_link_event_port_queues = 1;
 299         config.nb_event_queue_flows = info.max_event_queue_flows;
 300         config.nb_events_limit = info.max_num_events;
 301         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
 302         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
 303         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
 304         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
 305
 306         ret = rte_event_dev_configure(evdev, &config);
 307         if (ret < 0) {
 308                 printf("%d: Error configuring device\n", __LINE__);
 309                 return -1;
 310         }
 311
 312         /* Create a directed port */
 313         if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
 314                 printf("%d: Error querying default port conf\n", __LINE__);
 315                 goto err;
 316         }
 317
 318         port_conf.event_port_cfg = RTE_EVENT_PORT_CFG_SINGLE_LINK;
 319
 320         if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
 321                 printf("%d: port 0 setup expected to succeed\n", __LINE__);
 322                 goto err;
 323         }
 324
 325         /* Attempt to create another directed port */
 326         if (rte_event_port_setup(evdev, 1, &port_conf) == 0) {
 327                 printf("%d: port 1 setup expected to fail\n", __LINE__);
 328                 goto err;
 329         }
 330
 331         port_conf.event_port_cfg = 0;
 332
 333         /* Create a load-balanced port */
 334         if (rte_event_port_setup(evdev, 1, &port_conf) < 0) {
 335                 printf("%d: port 1 setup expected to succeed\n", __LINE__);
 336                 goto err;
 337         }
 338
 339         /* Create a directed queue */
 340         if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
 341                 printf("%d: Error querying default queue conf\n", __LINE__);
 342                 goto err;
 343         }
 344
 345         queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
 346
 347         if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
 348                 printf("%d: queue 0 setup expected to succeed\n", __LINE__);
 349                 goto err;
 350         }
 351
 352         /* Attempt to create another directed queue */
 353         if (rte_event_queue_setup(evdev, 1, &queue_conf) == 0) {
 354                 printf("%d: queue 1 setup expected to fail\n", __LINE__);
 355                 goto err;
 356         }
 357
 358         /* Create a load-balanced queue */
 359         queue_conf.event_queue_cfg = 0;
 360
 361         if (rte_event_queue_setup(evdev, 1, &queue_conf) < 0) {
 362                 printf("%d: queue 1 setup expected to succeed\n", __LINE__);
 363                 goto err;
 364         }
 365
 366         /* Attempt to link directed and load-balanced resources */
 367         queue_id = 1;
 368         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) == 1) {
 369                 printf("%d: port 0 link expected to fail\n", __LINE__);
 370                 goto err;
 371         }
 372
 373         queue_id = 0;
 374         if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) == 1) {
 375                 printf("%d: port 1 link expected to fail\n", __LINE__);
 376                 goto err;
 377         }
 378
 379         /* Link ports to queues */
 380         queue_id = 0;
 381         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
 382                 printf("%d: port 0 link expected to succeed\n", __LINE__);
 383                 goto err;
 384         }
 385
 386         queue_id = 1;
 387         if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) != 1) {
 388                 printf("%d: port 1 link expected to succeed\n", __LINE__);
 389                 goto err;
 390         }
 391
 392         ret = rte_event_dev_close(evdev);
 393         if (ret)
 394                 printf("%d: rte_event_dev_close failed, ret = %d\n",
 395                         __LINE__, ret);
 396
 397         return 0;
 398
 399 err:
 400         ret = rte_event_dev_close(evdev);
 401         if (ret)
 402                 printf("%d: rte_event_dev_close failed, ret = %d\n",
 403                         __LINE__, ret);
 404
 405         return -1;
 406 }
 407
 408 #define NUM_LDB_PORTS 64
 409 #define NUM_LDB_QUEUES 32
 410
 411 static int
 412 test_info_get(void)
 413 {
 414         struct rte_event_dev_config config = {0};
 415         struct rte_event_dev_info info;
 416         int ret;
 417
 418         if (rte_event_dev_info_get(evdev, &info)) {
 419                 printf("%d: Error querying device info\n", __LINE__);
 420                 return -1;
 421         }
 422
 423         if (info.max_event_ports != NUM_LDB_PORTS) {
 424                 printf("%d: Got %u ports, expected %u\n",
 425                        __LINE__, info.max_event_ports, NUM_LDB_PORTS);
 426                 goto err;
 427         }
 428
 429         if (info.max_event_queues != NUM_LDB_QUEUES) {
 430                 printf("%d: Got %u queues, expected %u\n",
 431                        __LINE__, info.max_event_queues, NUM_LDB_QUEUES);
 432                 goto err;
 433         }
 434
 435         config.nb_event_ports = info.max_event_ports;
 436         config.nb_event_queues = NUM_LDB_QUEUES + info.max_event_ports / 2;
 437         config.nb_single_link_event_port_queues = info.max_event_ports / 2;
 438         config.nb_event_queue_flows = info.max_event_queue_flows;
 439         config.nb_events_limit = info.max_num_events;
 440         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
 441         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
 442         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
 443         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
 444
 445         ret = rte_event_dev_configure(evdev, &config);
 446         if (ret < 0) {
 447                 printf("%d: Error configuring device\n", __LINE__);
 448                 return -1;
 449         }
 450
 451         if (rte_event_dev_info_get(evdev, &info)) {
 452                 printf("%d: Error querying device info\n", __LINE__);
 453                 goto err;
 454         }
 455
 456         /* The DLB2 PMD only reports load-balanced ports and queues in its
 457          * info_get function. Confirm that these values don't include the
 458          * directed port or queue counts.
 459          */
 460
 461         if (info.max_event_ports != NUM_LDB_PORTS) {
 462                 printf("%d: Got %u ports, expected %u\n",
 463                        __LINE__, info.max_event_ports, NUM_LDB_PORTS);
 464                 goto err;
 465         }
 466
 467         if (info.max_event_queues != NUM_LDB_QUEUES) {
 468                 printf("%d: Got %u queues, expected %u\n",
 469                        __LINE__, info.max_event_queues, NUM_LDB_QUEUES);
 470                 goto err;
 471         }
 472
 473         ret = rte_event_dev_close(evdev);
 474         if (ret) {
 475                 printf("%d: rte_event_dev_close failed, ret = %d\n",
 476                         __LINE__, ret);
 477                 return -1;
 478         }
 479         return 0;
 480
 481 err:
 482         ret = rte_event_dev_close(evdev);
 483         if (ret)
 484                 printf("%d: rte_event_dev_close failed, ret = %d\n",
 485                         __LINE__, ret);
 486
 487         return -1;
 488 }
 489
 490 static int
 491 test_reconfiguration_link(void)
 492 {
 493         struct rte_event_dev_config config = {0};
 494         struct rte_event_queue_conf queue_conf;
 495         struct rte_event_port_conf port_conf;
 496         struct rte_event_dev_info info;
 497         uint8_t queue_id;
 498         int ret, i;
 499
 500         if (rte_event_dev_info_get(evdev, &info)) {
 501                 printf("%d: Error querying device info\n", __LINE__);
 502                 return -1;
 503         }
 504
 505         config.nb_event_queues = 2;
 506         config.nb_event_ports = 2;
 507         config.nb_single_link_event_port_queues = 0;
 508         config.nb_event_queue_flows = info.max_event_queue_flows;
 509         config.nb_events_limit = info.max_num_events;
 510         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
 511         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
 512         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
 513         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
 514
 515         /* Configure the device with 2 LDB ports and 2 LDB queues */
 516         ret = rte_event_dev_configure(evdev, &config);
 517         if (ret < 0) {
 518                 printf("%d: Error configuring device\n", __LINE__);
 519                 return -1;
 520         }
 521
 522         /* Configure the ports and queues */
 523         if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
 524                 printf("%d: Error querying default port conf\n", __LINE__);
 525                 goto err;
 526         }
 527
 528         for (i = 0; i < 2; i++) {
 529                 if (rte_event_port_setup(evdev, i, &port_conf) < 0) {
 530                         printf("%d: port %d setup expected to succeed\n",
 531                                __LINE__, i);
 532                         goto err;
 533                 }
 534         }
 535
 536         if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
 537                 printf("%d: Error querying default queue conf\n", __LINE__);
 538                 goto err;
 539         }
 540
 541         for (i = 0; i < 2; i++) {
 542                 if (rte_event_queue_setup(evdev, i, &queue_conf) < 0) {
 543                         printf("%d: queue %d setup expected to succeed\n",
 544                                __LINE__, i);
 545                         goto err;
 546                 }
 547         }
 548
 549         /* Link P0->Q0 and P1->Q1 */
 550         for (i = 0; i < 2; i++) {
 551                 queue_id = i;
 552
 553                 if (rte_event_port_link(evdev, i, &queue_id, NULL, 1) != 1) {
 554                         printf("%d: port %d link expected to succeed\n",
 555                                __LINE__, i);
 556                         goto err;
 557                 }
 558         }
 559
 560         /* Start the device */
 561         if (rte_event_dev_start(evdev) < 0) {
 562                 printf("%d: device start failed\n", __LINE__);
 563                 goto err;
 564         }
 565
 566         /* Stop the device */
 567         rte_event_dev_stop(evdev);
 568
 569         /* Reconfigure device */
 570         ret = rte_event_dev_configure(evdev, &config);
 571         if (ret < 0) {
 572                 printf("%d: Error re-configuring device\n", __LINE__);
 573                 return -1;
 574         }
 575
 576         /* Configure P1 and Q1, leave P0 and Q0 to be configured by the PMD. */
 577         if (rte_event_port_setup(evdev, 1, &port_conf) < 0) {
 578                 printf("%d: port 1 setup expected to succeed\n",
 579                        __LINE__);
 580                 goto err;
 581         }
 582
 583         if (rte_event_queue_setup(evdev, 1, &queue_conf) < 0) {
 584                 printf("%d: queue 1 setup expected to succeed\n",
 585                        __LINE__);
 586                 goto err;
 587         }
 588
 589         /* Link P0->Q0 and Q1 */
 590         for (i = 0; i < 2; i++) {
 591                 queue_id = i;
 592
 593                 if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
 594                         printf("%d: P0->Q%d link expected to succeed\n",
 595                                __LINE__, i);
 596                         goto err;
 597                 }
 598         }
 599
 600         /* Link P1->Q0 and Q1 */
 601         for (i = 0; i < 2; i++) {
 602                 queue_id = i;
 603
 604                 if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) != 1) {
 605                         printf("%d: P1->Q%d link expected to succeed\n",
 606                                __LINE__, i);
 607                         goto err;
 608                 }
 609         }
 610
 611         /* Start the device */
 612         if (rte_event_dev_start(evdev) < 0) {
 613                 printf("%d: device start failed\n", __LINE__);
 614                 goto err;
 615         }
 616
 617         /* Stop the device */
 618         rte_event_dev_stop(evdev);
 619
 620         /* Configure device with 2 DIR ports and 2 DIR queues */
 621         config.nb_single_link_event_port_queues = 2;
 622
 623         ret = rte_event_dev_configure(evdev, &config);
 624         if (ret < 0) {
 625                 printf("%d: Error configuring device\n", __LINE__);
 626                 return -1;
 627         }
 628
 629         /* Configure the ports and queues */
 630         port_conf.event_port_cfg = RTE_EVENT_PORT_CFG_SINGLE_LINK;
 631
 632         for (i = 0; i < 2; i++) {
 633                 if (rte_event_port_setup(evdev, i, &port_conf) < 0) {
 634                         printf("%d: port %d setup expected to succeed\n",
 635                                __LINE__, i);
 636                         goto err;
 637                 }
 638         }
 639
 640         queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
 641
 642         for (i = 0; i < 2; i++) {
 643                 if (rte_event_queue_setup(evdev, i, &queue_conf) < 0) {
 644                         printf("%d: queue %d setup expected to succeed\n",
 645                                __LINE__, i);
 646                         goto err;
 647                 }
 648         }
 649
 650         /* Link P0->Q0 and P1->Q1 */
 651         for (i = 0; i < 2; i++) {
 652                 queue_id = i;
 653
 654                 if (rte_event_port_link(evdev, i, &queue_id, NULL, 1) != 1) {
 655                         printf("%d: port %d link expected to succeed\n",
 656                                __LINE__, i);
 657                         goto err;
 658                 }
 659         }
 660
 661         /* Start the device */
 662         if (rte_event_dev_start(evdev) < 0) {
 663                 printf("%d: device start failed\n", __LINE__);
 664                 goto err;
 665         }
 666
 667         /* Stop the device */
 668         rte_event_dev_stop(evdev);
 669
 670         /* Reconfigure device */
 671         ret = rte_event_dev_configure(evdev, &config);
 672         if (ret < 0) {
 673                 printf("%d: Error re-configuring device\n", __LINE__);
 674                 return -1;
 675         }
 676
 677         /* Configure P1 and Q0, leave P0 and Q1 to be configured by the PMD. */
 678         if (rte_event_port_setup(evdev, 1, &port_conf) < 0) {
 679                 printf("%d: port 1 setup expected to succeed\n",
 680                        __LINE__);
 681                 goto err;
 682         }
 683
 684         if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
 685                 printf("%d: queue 1 setup expected to succeed\n",
 686                        __LINE__);
 687                 goto err;
 688         }
 689
 690         /* Link P0->Q1 */
 691         queue_id = 1;
 692
 693         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
 694                 printf("%d: P0->Q%d link expected to succeed\n",
 695                        __LINE__, i);
 696                 goto err;
 697         }
 698
 699         /* Link P1->Q0 */
 700         queue_id = 0;
 701
 702         if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) != 1) {
 703                 printf("%d: P1->Q%d link expected to succeed\n",
 704                        __LINE__, i);
 705                 goto err;
 706         }
 707
 708         /* Start the device */
 709         if (rte_event_dev_start(evdev) < 0) {
 710                 printf("%d: device start failed\n", __LINE__);
 711                 goto err;
 712         }
 713
 714         rte_event_dev_stop(evdev);
 715
 716         config.nb_event_queues = 5;
 717         config.nb_event_ports = 5;
 718         config.nb_single_link_event_port_queues = 1;
 719
 720         ret = rte_event_dev_configure(evdev, &config);
 721         if (ret < 0) {
 722                 printf("%d: Error re-configuring device\n", __LINE__);
 723                 return -1;
 724         }
 725
 726         for (i = 0; i < config.nb_event_queues - 1; i++) {
 727                 port_conf.event_port_cfg = 0;
 728                 queue_conf.event_queue_cfg = 0;
 729
 730                 if (rte_event_port_setup(evdev, i, &port_conf) < 0) {
 731                         printf("%d: port %d setup expected to succeed\n",
 732                                __LINE__, i);
 733                         goto err;
 734                 }
 735
 736                 if (rte_event_queue_setup(evdev, i, &queue_conf) < 0) {
 737                         printf("%d: queue %d setup expected to succeed\n",
 738                                __LINE__, i);
 739                         goto err;
 740                 }
 741
 742                 queue_id = i;
 743
 744                 if (rte_event_port_link(evdev, i, &queue_id, NULL, 1) != 1) {
 745                         printf("%d: P%d->Q%d link expected to succeed\n",
 746                                __LINE__, i, i);
 747                         goto err;
 748                 }
 749         }
 750
 751         port_conf.event_port_cfg = RTE_EVENT_PORT_CFG_SINGLE_LINK;
 752         queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
 753
 754         if (rte_event_port_setup(evdev, i, &port_conf) < 0) {
 755                 printf("%d: port %d setup expected to succeed\n",
 756                        __LINE__, i);
 757                 goto err;
 758         }
 759
 760         if (rte_event_queue_setup(evdev, i, &queue_conf) < 0) {
 761                 printf("%d: queue %d setup expected to succeed\n",
 762                        __LINE__, i);
 763                 goto err;
 764         }
 765
 766         queue_id = i;
 767
 768         if (rte_event_port_link(evdev, i, &queue_id, NULL, 1) != 1) {
 769                 printf("%d: P%d->Q%d link expected to succeed\n",
 770                        __LINE__, i, i);
 771                 goto err;
 772         }
 773
 774         /* Start the device */
 775         if (rte_event_dev_start(evdev) < 0) {
 776                 printf("%d: device start failed\n", __LINE__);
 777                 goto err;
 778         }
 779
 780         /* Stop the device */
 781         rte_event_dev_stop(evdev);
 782
 783         config.nb_event_ports += 1;
 784
 785         /* Reconfigure device with 1 more load-balanced port */
 786         ret = rte_event_dev_configure(evdev, &config);
 787         if (ret < 0) {
 788                 printf("%d: Error re-configuring device\n", __LINE__);
 789                 return -1;
 790         }
 791
 792         port_conf.event_port_cfg = 0;
 793
 794         /* Configure the new port */
 795         if (rte_event_port_setup(evdev, config.nb_event_ports - 1,
 796                                  &port_conf) < 0) {
 797                 printf("%d: port 1 setup expected to succeed\n",
 798                        __LINE__);
 799                 goto err;
 800         }
 801
 802         /* Start the device */
 803         if (rte_event_dev_start(evdev) < 0) {
 804                 printf("%d: device start failed\n", __LINE__);
 805                 goto err;
 806         }
 807
 808         cleanup();
 809         return 0;
 810
 811 err:
 812         cleanup();
 813         return -1;
 814 }
 815
 816 static int
 817 test_load_balanced_traffic(void)
 818 {
 819         uint64_t timeout;
 820         struct rte_event_dev_config config = {0};
 821         struct rte_event_queue_conf queue_conf;
 822         struct rte_event_port_conf port_conf;
 823         struct rte_event_dev_info info;
 824         struct rte_event ev;
 825         uint8_t queue_id;
 826         int ret;
 827
 828         if (rte_event_dev_info_get(evdev, &info)) {
 829                 printf("%d: Error querying device info\n", __LINE__);
 830                 return -1;
 831         }
 832
 833         config.nb_event_queues = 1;
 834         config.nb_event_ports = 1;
 835         config.nb_single_link_event_port_queues = 0;
 836         config.nb_event_queue_flows = info.max_event_queue_flows;
 837         config.nb_events_limit = info.max_num_events;
 838         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
 839         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
 840         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
 841         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
 842
 843         /* Configure the device with 1 LDB port and queue */
 844         ret = rte_event_dev_configure(evdev, &config);
 845         if (ret < 0) {
 846                 printf("%d: Error configuring device\n", __LINE__);
 847                 return -1;
 848         }
 849
 850         /* Configure the ports and queues */
 851         if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
 852                 printf("%d: Error querying default port conf\n", __LINE__);
 853                 goto err;
 854         }
 855
 856         if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
 857                 printf("%d: port 0 setup expected to succeed\n",
 858                        __LINE__);
 859                 goto err;
 860         }
 861
 862         if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
 863                 printf("%d: Error querying default queue conf\n", __LINE__);
 864                 goto err;
 865         }
 866
 867         if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
 868                 printf("%d: queue 0 setup expected to succeed\n",
 869                        __LINE__);
 870                 goto err;
 871         }
 872
 873         /* Link P0->Q0 */
 874         queue_id = 0;
 875
 876         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
 877                 printf("%d: port 0 link expected to succeed\n",
 878                        __LINE__);
 879                 goto err;
 880         }
 881
 882         /* Start the device */
 883         if (rte_event_dev_start(evdev) < 0) {
 884                 printf("%d: device start failed\n", __LINE__);
 885                 goto err;
 886         }
 887
 888         /* Enqueue 1 NEW event */
 889         ev.op = RTE_EVENT_OP_NEW;
 890         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 891         ev.queue_id = 0;
 892         ev.priority = 0;
 893         ev.u64 = 0;
 894
 895         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
 896                 printf("%d: NEW enqueue expected to succeed\n",
 897                        __LINE__);
 898                 goto err;
 899         }
 900
 901         /* Dequeue and enqueue 1 FORWARD event */
 902         timeout = 0xFFFFFFFFF;
 903         if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
 904                 printf("%d: event dequeue expected to succeed\n",
 905                        __LINE__);
 906                 goto err;
 907         }
 908
 909         ev.op = RTE_EVENT_OP_FORWARD;
 910
 911         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
 912                 printf("%d: NEW enqueue expected to succeed\n",
 913                        __LINE__);
 914                 goto err;
 915         }
 916
 917         /* Dequeue and enqueue 1 RELEASE operation */
 918         if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
 919                 printf("%d: event dequeue expected to succeed\n",
 920                        __LINE__);
 921                 goto err;
 922         }
 923
 924         ev.op = RTE_EVENT_OP_RELEASE;
 925
 926         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
 927                 printf("%d: NEW enqueue expected to succeed\n",
 928                        __LINE__);
 929                 goto err;
 930         }
 931
 932         cleanup();
 933         return 0;
 934
 935 err:
 936         cleanup();
 937         return -1;
 938 }
 939
 940 static int
 941 test_directed_traffic(void)
 942 {
 943         uint64_t timeout;
 944         struct rte_event_dev_config config = {0};
 945         struct rte_event_queue_conf queue_conf;
 946         struct rte_event_port_conf port_conf;
 947         struct rte_event_dev_info info;
 948         struct rte_event ev;
 949         uint8_t queue_id;
 950         int ret;
 951
 952         if (rte_event_dev_info_get(evdev, &info)) {
 953                 printf("%d: Error querying device info\n", __LINE__);
 954                 return -1;
 955         }
 956
 957         config.nb_event_queues = 1;
 958         config.nb_event_ports = 1;
 959         config.nb_single_link_event_port_queues = 1;
 960         config.nb_event_queue_flows = info.max_event_queue_flows;
 961         config.nb_events_limit = info.max_num_events;
 962         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
 963         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
 964         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
 965         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
 966
 967         /* Configure the device with 1 DIR port and queue */
 968         ret = rte_event_dev_configure(evdev, &config);
 969         if (ret < 0) {
 970                 printf("%d: Error configuring device\n", __LINE__);
 971                 return -1;
 972         }
 973
 974         /* Configure the ports and queues */
 975         if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
 976                 printf("%d: Error querying default port conf\n", __LINE__);
 977                 goto err;
 978         }
 979
 980         port_conf.event_port_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
 981
 982         if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
 983                 printf("%d: port 0 setup expected to succeed\n",
 984                        __LINE__);
 985                 goto err;
 986         }
 987
 988         if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
 989                 printf("%d: Error querying default queue conf\n", __LINE__);
 990                 goto err;
 991         }
 992
 993         queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
 994
 995         if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
 996                 printf("%d: queue 0 setup expected to succeed\n",
 997                        __LINE__);
 998                 goto err;
 999         }
1000
1001         /* Link P0->Q0 */
1002         queue_id = 0;
1003
1004         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
1005                 printf("%d: port 0 link expected to succeed\n",
1006                        __LINE__);
1007                 goto err;
1008         }
1009
1010         /* Start the device */
1011         if (rte_event_dev_start(evdev) < 0) {
1012                 printf("%d: device start failed\n", __LINE__);
1013                 goto err;
1014         }
1015
1016         /* Enqueue 1 NEW event */
1017         ev.op = RTE_EVENT_OP_NEW;
1018         ev.queue_id = 0;
1019         ev.priority = 0;
1020         ev.u64 = 0;
1021
1022         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1023                 printf("%d: NEW enqueue expected to succeed\n",
1024                        __LINE__);
1025                 goto err;
1026         }
1027
1028         /* Dequeue and enqueue 1 FORWARD event */
1029         timeout = 0xFFFFFFFFF;
1030         if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1031                 printf("%d: event dequeue expected to succeed\n",
1032                        __LINE__);
1033                 goto err;
1034         }
1035
1036         if (ev.queue_id != 0) {
1037                 printf("%d: invalid dequeued event queue ID (%d)\n",
1038                        __LINE__, ev.queue_id);
1039                 goto err;
1040         }
1041
1042         ev.op = RTE_EVENT_OP_FORWARD;
1043
1044         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1045                 printf("%d: NEW enqueue expected to succeed\n",
1046                        __LINE__);
1047                 goto err;
1048         }
1049
1050         /* Dequeue and enqueue 1 RELEASE operation */
1051         if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1052                 printf("%d: event dequeue expected to succeed\n",
1053                        __LINE__);
1054                 goto err;
1055         }
1056
1057         ev.op = RTE_EVENT_OP_RELEASE;
1058
1059         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1060                 printf("%d: NEW enqueue expected to succeed\n",
1061                        __LINE__);
1062                 goto err;
1063         }
1064
1065         cleanup();
1066         return 0;
1067
1068 err:
1069         cleanup();
1070         return -1;
1071 }
1072
1073 static int
1074 test_deferred_sched(void)
1075 {
1076         uint64_t timeout;
1077         struct rte_event_dev_config config = {0};
1078         struct rte_event_queue_conf queue_conf;
1079         struct rte_event_port_conf port_conf;
1080         struct rte_event_dev_info info;
1081         const int num_events = 128;
1082         struct rte_event ev;
1083         uint8_t queue_id;
1084         int ret, i;
1085
1086         if (rte_event_dev_info_get(evdev, &info)) {
1087                 printf("%d: Error querying device info\n", __LINE__);
1088                 return -1;
1089         }
1090
1091         config.nb_event_queues = 1;
1092         config.nb_event_ports = 2;
1093         config.nb_single_link_event_port_queues = 0;
1094         config.nb_event_queue_flows = info.max_event_queue_flows;
1095         config.nb_events_limit = info.max_num_events;
1096         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
1097         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
1098         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
1099         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
1100
1101         /* Configure the device with 2 LDB ports and 1 queue */
1102         ret = rte_event_dev_configure(evdev, &config);
1103         if (ret < 0) {
1104                 printf("%d: Error configuring device\n", __LINE__);
1105                 return -1;
1106         }
1107
1108         ret = rte_pmd_dlb2_set_token_pop_mode(evdev, 0, DEFERRED_POP);
1109         if (ret < 0) {
1110                 printf("%d: Error setting deferred scheduling\n", __LINE__);
1111                 goto err;
1112         }
1113
1114         ret = rte_pmd_dlb2_set_token_pop_mode(evdev, 1, DEFERRED_POP);
1115         if (ret < 0) {
1116                 printf("%d: Error setting deferred scheduling\n", __LINE__);
1117                 goto err;
1118         }
1119
1120         /* Configure the ports and queues */
1121         if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
1122                 printf("%d: Error querying default port conf\n", __LINE__);
1123                 goto err;
1124         }
1125
1126         port_conf.dequeue_depth = 1;
1127
1128         if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
1129                 printf("%d: port 0 setup expected to succeed\n",
1130                        __LINE__);
1131                 goto err;
1132         }
1133
1134         if (rte_event_port_setup(evdev, 1, &port_conf) < 0) {
1135                 printf("%d: port 1 setup expected to succeed\n",
1136                        __LINE__);
1137                 goto err;
1138         }
1139
1140         if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
1141                 printf("%d: Error querying default queue conf\n", __LINE__);
1142                 goto err;
1143         }
1144
1145         queue_conf.schedule_type = RTE_SCHED_TYPE_PARALLEL;
1146         queue_conf.nb_atomic_order_sequences = 0;
1147
1148         if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
1149                 printf("%d: queue 0 setup expected to succeed\n",
1150                        __LINE__);
1151                 goto err;
1152         }
1153
1154         /* Link P0->Q0 and P1->Q0 */
1155         queue_id = 0;
1156
1157         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
1158                 printf("%d: port 0 link expected to succeed\n",
1159                        __LINE__);
1160                 goto err;
1161         }
1162
1163         if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) != 1) {
1164                 printf("%d: port 1 link expected to succeed\n",
1165                        __LINE__);
1166                 goto err;
1167         }
1168
1169         /* Start the device */
1170         if (rte_event_dev_start(evdev) < 0) {
1171                 printf("%d: device start failed\n", __LINE__);
1172                 goto err;
1173         }
1174
1175         /* Enqueue 128 NEW events */
1176         ev.op = RTE_EVENT_OP_NEW;
1177         ev.sched_type = RTE_SCHED_TYPE_PARALLEL;
1178         ev.queue_id = 0;
1179         ev.priority = 0;
1180         ev.u64 = 0;
1181
1182         for (i = 0; i < num_events; i++) {
1183                 if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1184                         printf("%d: NEW enqueue expected to succeed\n",
1185                                __LINE__);
1186                         goto err;
1187                 }
1188         }
1189
1190         /* Dequeue one event from port 0 */
1191         timeout = 0xFFFFFFFFF;
1192         if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1193                 printf("%d: event dequeue expected to succeed\n",
1194                        __LINE__);
1195                 goto err;
1196         }
1197
1198         /* Dequeue (and release) all other events from port 1. Deferred
1199          * scheduling ensures no other events are scheduled to port 0 without a
1200          * subsequent rte_event_dequeue_burst() call.
1201          */
1202         for (i = 0; i < num_events - 1; i++) {
1203                 if (rte_event_dequeue_burst(evdev, 1, &ev, 1, timeout) != 1) {
1204                         printf("%d: event dequeue expected to succeed\n",
1205                                __LINE__);
1206                         goto err;
1207                 }
1208
1209                 ev.op = RTE_EVENT_OP_RELEASE;
1210
1211                 if (rte_event_enqueue_burst(evdev, 1, &ev, 1) != 1) {
1212                         printf("%d: RELEASE enqueue expected to succeed\n",
1213                                __LINE__);
1214                         goto err;
1215                 }
1216         }
1217
1218         cleanup();
1219         return 0;
1220
1221 err:
1222         cleanup();
1223         return -1;
1224 }
1225
1226 static int
1227 test_delayed_pop(void)
1228 {
1229         uint64_t timeout;
1230         struct rte_event_dev_config config = {0};
1231         struct rte_event_queue_conf queue_conf;
1232         struct rte_event_port_conf port_conf;
1233         struct rte_event_dev_info info;
1234         int ret, i, num_events;
1235         struct rte_event ev;
1236         uint8_t queue_id;
1237
1238         if (rte_event_dev_info_get(evdev, &info)) {
1239                 printf("%d: Error querying device info\n", __LINE__);
1240                 return -1;
1241         }
1242
1243         config.nb_event_queues = 1;
1244         config.nb_event_ports = 1;
1245         config.nb_single_link_event_port_queues = 0;
1246         config.nb_event_queue_flows = info.max_event_queue_flows;
1247         config.nb_events_limit = info.max_num_events;
1248         config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
1249         config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
1250         config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
1251         config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
1252
1253         /* Configure the device with 1 LDB port and queue */
1254         ret = rte_event_dev_configure(evdev, &config);
1255         if (ret < 0) {
1256                 printf("%d: Error configuring device\n", __LINE__);
1257                 return -1;
1258         }
1259
1260         ret = rte_pmd_dlb2_set_token_pop_mode(evdev, 0, DELAYED_POP);
1261         if (ret < 0) {
1262                 printf("%d: Error setting deferred scheduling\n", __LINE__);
1263                 goto err;
1264         }
1265
1266         /* Configure the ports and queues */
1267         if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
1268                 printf("%d: Error querying default port conf\n", __LINE__);
1269                 goto err;
1270         }
1271
1272         port_conf.event_port_cfg = RTE_EVENT_PORT_CFG_DISABLE_IMPL_REL;
1273
1274         if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
1275                 printf("%d: port 0 setup expected to succeed\n",
1276                        __LINE__);
1277                 goto err;
1278         }
1279
1280         if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
1281                 printf("%d: Error querying default queue conf\n", __LINE__);
1282                 goto err;
1283         }
1284
1285         if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
1286                 printf("%d: queue 0 setup expected to succeed\n",
1287                        __LINE__);
1288                 goto err;
1289         }
1290
1291         /* Link P0->Q0 */
1292         queue_id = 0;
1293
1294         if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
1295                 printf("%d: port 0 link expected to succeed\n",
1296                        __LINE__);
1297                 goto err;
1298         }
1299
1300         /* Start the device */
1301         if (rte_event_dev_start(evdev) < 0) {
1302                 printf("%d: device start failed\n", __LINE__);
1303                 goto err;
1304         }
1305
1306         num_events = 2 * port_conf.dequeue_depth;
1307
1308         /* Enqueue 2 * dequeue_depth NEW events */
1309         ev.op = RTE_EVENT_OP_NEW;
1310         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
1311         ev.queue_id = 0;
1312         ev.priority = 0;
1313         ev.u64 = 0;
1314
1315         for (i = 0; i < num_events; i++) {
1316                 if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1317                         printf("%d: NEW enqueue expected to succeed\n",
1318                                __LINE__);
1319                         goto err;
1320                 }
1321         }
1322
1323         /* Dequeue dequeue_depth events but only release dequeue_depth - 1.
1324          * Delayed pop won't perform the pop and no more events will be
1325          * scheduled.
1326          */
1327         timeout = 0xFFFFFFFFF;
1328
1329         for (i = 0; i < port_conf.dequeue_depth; i++) {
1330                 if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1331                         printf("%d: event dequeue expected to succeed\n",
1332                                __LINE__);
1333                         goto err;
1334                 }
1335         }
1336
1337         ev.op = RTE_EVENT_OP_RELEASE;
1338
1339         for (i = 0; i < port_conf.dequeue_depth - 1; i++) {
1340                 if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1341                         printf("%d: RELEASE enqueue expected to succeed\n",
1342                                __LINE__);
1343                         goto err;
1344                 }
1345         }
1346
1347         timeout = 0x10000;
1348
1349         ret = rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout);
1350         if (ret != 0) {
1351                 printf("%d: event dequeue expected to fail (ret = %d)\n",
1352                        __LINE__, ret);
1353                 goto err;
1354         }
1355
1356         /* Release one more event. This will trigger the token pop, and
1357          * dequeue_depth - 1 more events will be scheduled to the device.
1358          */
1359         ev.op = RTE_EVENT_OP_RELEASE;
1360
1361         if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1362                 printf("%d: RELEASE enqueue expected to succeed\n",
1363                        __LINE__);
1364                 goto err;
1365         }
1366
1367         timeout = 0xFFFFFFFFF;
1368
1369         for (i = 0; i < port_conf.dequeue_depth - 1; i++) {
1370                 if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1371                         printf("%d: event dequeue expected to succeed\n",
1372                                __LINE__);
1373                         goto err;
1374                 }
1375         }
1376
1377         timeout = 0x10000;
1378
1379         if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 0) {
1380                 printf("%d: event dequeue expected to fail\n",
1381                        __LINE__);
1382                 goto err;
1383         }
1384
1385         cleanup();
1386         return 0;
1387
1388 err:
1389         cleanup();
1390         return -1;
1391 }
1392
1393 static int
1394 do_selftest(void)
1395 {
1396         struct test t;
1397         int ret;
1398
1399         /* Only create mbuf pool once, reuse for each test run */
1400         if (!eventdev_func_mempool) {
1401                 eventdev_func_mempool =
1402                         rte_pktmbuf_pool_create("EVENTDEV_DLB2_ST_POOL",
1403                                                 (1 << 12), /* 4k buffers */
1404                                                 32 /*MBUF_CACHE_SIZE*/,
1405                                                 0,
1406                                                 512, /* use very small mbufs */
1407                                                 rte_socket_id());
1408                 if (!eventdev_func_mempool) {
1409                         printf("ERROR creating mempool\n");
1410                         goto test_fail;
1411                 }
1412         }
1413         t.mbuf_pool = eventdev_func_mempool;
1414
1415         printf("*** Running Stop Flush test...\n");
1416         ret = test_stop_flush(&t);
1417         if (ret != 0) {
1418                 printf("ERROR - Stop Flush test FAILED.\n");
1419                 return ret;
1420         }
1421
1422         printf("*** Running Single Link test...\n");
1423         ret = test_single_link();
1424         if (ret != 0) {
1425                 printf("ERROR - Single Link test FAILED.\n");
1426
1427                 goto test_fail;
1428         }
1429
1430         printf("*** Running Info Get test...\n");
1431         ret = test_info_get();
1432         if (ret != 0) {
1433                 printf("ERROR - Stop Flush test FAILED.\n");
1434                 return ret;
1435         }
1436
1437         printf("*** Running Reconfiguration Link test...\n");
1438         ret = test_reconfiguration_link();
1439         if (ret != 0) {
1440                 printf("ERROR - Reconfiguration Link test FAILED.\n");
1441
1442                 goto test_fail;
1443         }
1444
1445         printf("*** Running Load-Balanced Traffic test...\n");
1446         ret = test_load_balanced_traffic();
1447         if (ret != 0) {
1448                 printf("ERROR - Load-Balanced Traffic test FAILED.\n");
1449
1450                 goto test_fail;
1451         }
1452
1453         printf("*** Running Directed Traffic test...\n");
1454         ret = test_directed_traffic();
1455         if (ret != 0) {
1456                 printf("ERROR - Directed Traffic test FAILED.\n");
1457
1458                 goto test_fail;
1459         }
1460
1461         printf("*** Running Deferred Scheduling test...\n");
1462         ret = test_deferred_sched();
1463         if (ret != 0) {
1464                 printf("ERROR - Deferred Scheduling test FAILED.\n");
1465
1466                 goto test_fail;
1467         }
1468
1469         printf("*** Running Delayed Pop test...\n");
1470         ret = test_delayed_pop();
1471         if (ret != 0) {
1472                 printf("ERROR - Delayed Pop test FAILED.\n");
1473
1474                 goto test_fail;
1475         }
1476
1477         return 0;
1478
1479 test_fail:
1480         return -1;
1481 }
1482
1483 int
1484 test_dlb2_eventdev(void)
1485 {
1486         const char *dlb2_eventdev_name = "dlb2_event";
1487         uint8_t num_evdevs = rte_event_dev_count();
1488         int i, ret = 0;
1489         int found = 0, skipped = 0, passed = 0, failed = 0;
1490         struct rte_event_dev_info info;
1491
1492         for (i = 0; found + skipped < num_evdevs && i < RTE_EVENT_MAX_DEVS;
1493              i++) {
1494                 ret = rte_event_dev_info_get(i, &info);
1495                 if (ret < 0)
1496                         continue;
1497
1498                 /* skip non-dlb2 event devices */
1499                 if (strncmp(info.driver_name, dlb2_eventdev_name,
1500                             sizeof(*info.driver_name)) != 0) {
1501                         skipped++;
1502                         continue;
1503                 }
1504
1505                 evdev = rte_event_dev_get_dev_id(info.driver_name);
1506                 if (evdev < 0) {
1507                         printf("Could not get dev_id for eventdev with name %s, i=%d\n",
1508                                info.driver_name, i);
1509                         skipped++;
1510                         continue;
1511                 }
1512                 found++;
1513                 printf("Running selftest on eventdev %s\n", info.driver_name);
1514                 ret = do_selftest();
1515                 if (ret == 0) {
1516                         passed++;
1517                         printf("Selftest passed for eventdev %s\n",
1518                                info.driver_name);
1519                 } else {
1520                         failed++;
1521                         printf("Selftest failed for eventdev %s, err=%d\n",
1522                                info.driver_name, ret);
1523                 }
1524         }
1525
1526         printf("Ran selftest on %d eventdevs, %d skipped, %d passed, %d failed\n",
1527                found, skipped, passed, failed);
1528         return ret;
1529 }