test/test/test_eventdev.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2016 Cavium networks. All rights reserved.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *       * Redistributions of source code must retain the above copyright
  11  *         notice, this list of conditions and the following disclaimer.
  12  *       * Redistributions in binary form must reproduce the above copyright
  13  *         notice, this list of conditions and the following disclaimer in
  14  *         the documentation and/or other materials provided with the
  15  *         distribution.
  16  *       * Neither the name of Cavium networks nor the names of its
  17  *         contributors may be used to endorse or promote products derived
  18  *         from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <rte_common.h>
  34 #include <rte_hexdump.h>
  35 #include <rte_mbuf.h>
  36 #include <rte_malloc.h>
  37 #include <rte_memcpy.h>
  38 #include <rte_eventdev.h>
  39 #include <rte_dev.h>
  40
  41 #include "test.h"
  42
  43 #define TEST_DEV_ID   0
  44
  45 static int
  46 testsuite_setup(void)
  47 {
  48         RTE_BUILD_BUG_ON(sizeof(struct rte_event) != 16);
  49         uint8_t count;
  50         count = rte_event_dev_count();
  51         if (!count) {
  52                 printf("Failed to find a valid event device,"
  53                         " testing with event_skeleton device\n");
  54                 return rte_vdev_init("event_skeleton", NULL);
  55         }
  56         return TEST_SUCCESS;
  57 }
  58
  59 static void
  60 testsuite_teardown(void)
  61 {
  62 }
  63
  64 static int
  65 test_eventdev_count(void)
  66 {
  67         uint8_t count;
  68         count = rte_event_dev_count();
  69         TEST_ASSERT(count > 0, "Invalid eventdev count %" PRIu8, count);
  70         return TEST_SUCCESS;
  71 }
  72
  73 static int
  74 test_eventdev_get_dev_id(void)
  75 {
  76         int ret;
  77         ret = rte_event_dev_get_dev_id("not_a_valid_eventdev_driver");
  78         TEST_ASSERT_FAIL(ret, "Expected <0 for invalid dev name ret=%d", ret);
  79         return TEST_SUCCESS;
  80 }
  81
  82 static int
  83 test_eventdev_socket_id(void)
  84 {
  85         int socket_id;
  86         socket_id = rte_event_dev_socket_id(TEST_DEV_ID);
  87         TEST_ASSERT(socket_id != -EINVAL, "Failed to get socket_id %d",
  88                                 socket_id);
  89         socket_id = rte_event_dev_socket_id(RTE_EVENT_MAX_DEVS);
  90         TEST_ASSERT(socket_id == -EINVAL, "Expected -EINVAL %d", socket_id);
  91
  92         return TEST_SUCCESS;
  93 }
  94
  95 static int
  96 test_eventdev_info_get(void)
  97 {
  98         int ret;
  99         struct rte_event_dev_info info;
 100         ret = rte_event_dev_info_get(TEST_DEV_ID, NULL);
 101         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 102         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 103         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 104         TEST_ASSERT(info.max_event_ports > 0,
 105                         "Not enough event ports %d", info.max_event_ports);
 106         TEST_ASSERT(info.max_event_queues > 0,
 107                         "Not enough event queues %d", info.max_event_queues);
 108         return TEST_SUCCESS;
 109 }
 110
 111 static inline void
 112 devconf_set_default_sane_values(struct rte_event_dev_config *dev_conf,
 113                         struct rte_event_dev_info *info)
 114 {
 115         memset(dev_conf, 0, sizeof(struct rte_event_dev_config));
 116         dev_conf->dequeue_timeout_ns = info->min_dequeue_timeout_ns;
 117         dev_conf->nb_event_ports = info->max_event_ports;
 118         dev_conf->nb_event_queues = info->max_event_queues;
 119         dev_conf->nb_event_queue_flows = info->max_event_queue_flows;
 120         dev_conf->nb_event_port_dequeue_depth =
 121                         info->max_event_port_dequeue_depth;
 122         dev_conf->nb_event_port_enqueue_depth =
 123                         info->max_event_port_enqueue_depth;
 124         dev_conf->nb_event_port_enqueue_depth =
 125                         info->max_event_port_enqueue_depth;
 126         dev_conf->nb_events_limit =
 127                         info->max_num_events;
 128 }
 129
 130 static int
 131 test_ethdev_config_run(struct rte_event_dev_config *dev_conf,
 132                 struct rte_event_dev_info *info,
 133                 void (*fn)(struct rte_event_dev_config *dev_conf,
 134                         struct rte_event_dev_info *info))
 135 {
 136         devconf_set_default_sane_values(dev_conf, info);
 137         fn(dev_conf, info);
 138         return rte_event_dev_configure(TEST_DEV_ID, dev_conf);
 139 }
 140
 141 static void
 142 min_dequeue_limit(struct rte_event_dev_config *dev_conf,
 143                   struct rte_event_dev_info *info)
 144 {
 145         dev_conf->dequeue_timeout_ns = info->min_dequeue_timeout_ns - 1;
 146 }
 147
 148 static void
 149 max_dequeue_limit(struct rte_event_dev_config *dev_conf,
 150                   struct rte_event_dev_info *info)
 151 {
 152         dev_conf->dequeue_timeout_ns = info->max_dequeue_timeout_ns + 1;
 153 }
 154
 155 static void
 156 max_events_limit(struct rte_event_dev_config *dev_conf,
 157                   struct rte_event_dev_info *info)
 158 {
 159         dev_conf->nb_events_limit  = info->max_num_events + 1;
 160 }
 161
 162 static void
 163 max_event_ports(struct rte_event_dev_config *dev_conf,
 164                   struct rte_event_dev_info *info)
 165 {
 166         dev_conf->nb_event_ports = info->max_event_ports + 1;
 167 }
 168
 169 static void
 170 max_event_queues(struct rte_event_dev_config *dev_conf,
 171                   struct rte_event_dev_info *info)
 172 {
 173         dev_conf->nb_event_queues = info->max_event_queues + 1;
 174 }
 175
 176 static void
 177 max_event_queue_flows(struct rte_event_dev_config *dev_conf,
 178                   struct rte_event_dev_info *info)
 179 {
 180         dev_conf->nb_event_queue_flows = info->max_event_queue_flows + 1;
 181 }
 182
 183 static void
 184 max_event_port_dequeue_depth(struct rte_event_dev_config *dev_conf,
 185                   struct rte_event_dev_info *info)
 186 {
 187         dev_conf->nb_event_port_dequeue_depth =
 188                 info->max_event_port_dequeue_depth + 1;
 189 }
 190
 191 static void
 192 max_event_port_enqueue_depth(struct rte_event_dev_config *dev_conf,
 193                   struct rte_event_dev_info *info)
 194 {
 195         dev_conf->nb_event_port_enqueue_depth =
 196                 info->max_event_port_enqueue_depth + 1;
 197 }
 198
 199
 200 static int
 201 test_eventdev_configure(void)
 202 {
 203         int ret;
 204         struct rte_event_dev_config dev_conf;
 205         struct rte_event_dev_info info;
 206         ret = rte_event_dev_configure(TEST_DEV_ID, NULL);
 207         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 208
 209         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 210         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 211
 212         /* Check limits */
 213         TEST_ASSERT_EQUAL(-EINVAL,
 214                 test_ethdev_config_run(&dev_conf, &info, min_dequeue_limit),
 215                  "Config negative test failed");
 216         TEST_ASSERT_EQUAL(-EINVAL,
 217                 test_ethdev_config_run(&dev_conf, &info, max_dequeue_limit),
 218                  "Config negative test failed");
 219         TEST_ASSERT_EQUAL(-EINVAL,
 220                 test_ethdev_config_run(&dev_conf, &info, max_events_limit),
 221                  "Config negative test failed");
 222         TEST_ASSERT_EQUAL(-EINVAL,
 223                 test_ethdev_config_run(&dev_conf, &info, max_event_ports),
 224                  "Config negative test failed");
 225         TEST_ASSERT_EQUAL(-EINVAL,
 226                 test_ethdev_config_run(&dev_conf, &info, max_event_queues),
 227                  "Config negative test failed");
 228         TEST_ASSERT_EQUAL(-EINVAL,
 229                 test_ethdev_config_run(&dev_conf, &info, max_event_queue_flows),
 230                  "Config negative test failed");
 231         TEST_ASSERT_EQUAL(-EINVAL,
 232                 test_ethdev_config_run(&dev_conf, &info,
 233                         max_event_port_dequeue_depth),
 234                          "Config negative test failed");
 235         TEST_ASSERT_EQUAL(-EINVAL,
 236                 test_ethdev_config_run(&dev_conf, &info,
 237                 max_event_port_enqueue_depth),
 238                  "Config negative test failed");
 239
 240         /* Positive case */
 241         devconf_set_default_sane_values(&dev_conf, &info);
 242         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
 243         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 244
 245         /* re-configure */
 246         devconf_set_default_sane_values(&dev_conf, &info);
 247         dev_conf.nb_event_ports = RTE_MAX(info.max_event_ports/2, 1);
 248         dev_conf.nb_event_queues = RTE_MAX(info.max_event_queues/2, 1);
 249         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
 250         TEST_ASSERT_SUCCESS(ret, "Failed to re configure eventdev");
 251
 252         /* re-configure back to max_event_queues and max_event_ports */
 253         devconf_set_default_sane_values(&dev_conf, &info);
 254         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
 255         TEST_ASSERT_SUCCESS(ret, "Failed to re-configure eventdev");
 256
 257         return TEST_SUCCESS;
 258
 259 }
 260
 261 static int
 262 eventdev_configure_setup(void)
 263 {
 264         int ret;
 265         struct rte_event_dev_config dev_conf;
 266         struct rte_event_dev_info info;
 267
 268         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 269         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 270         devconf_set_default_sane_values(&dev_conf, &info);
 271         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
 272         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 273
 274         return TEST_SUCCESS;
 275 }
 276
 277 static int
 278 test_eventdev_queue_default_conf_get(void)
 279 {
 280         int i, ret;
 281         struct rte_event_queue_conf qconf;
 282
 283         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, NULL);
 284         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 285
 286         for (i = 0; i < rte_event_queue_count(TEST_DEV_ID); i++) {
 287                 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i,
 288                                                  &qconf);
 289                 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d info", i);
 290         }
 291
 292         return TEST_SUCCESS;
 293 }
 294
 295 static int
 296 test_eventdev_queue_setup(void)
 297 {
 298         int i, ret;
 299         struct rte_event_dev_info info;
 300         struct rte_event_queue_conf qconf;
 301
 302         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 303         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 304
 305         /* Negative cases */
 306         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
 307         TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info");
 308         qconf.event_queue_cfg = (RTE_EVENT_QUEUE_CFG_ALL_TYPES &
 309                  RTE_EVENT_QUEUE_CFG_TYPE_MASK);
 310         qconf.nb_atomic_flows = info.max_event_queue_flows + 1;
 311         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
 312         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 313
 314         qconf.nb_atomic_flows = info.max_event_queue_flows;
 315         qconf.event_queue_cfg = (RTE_EVENT_QUEUE_CFG_ORDERED_ONLY &
 316                  RTE_EVENT_QUEUE_CFG_TYPE_MASK);
 317         qconf.nb_atomic_order_sequences = info.max_event_queue_flows + 1;
 318         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
 319         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 320
 321         ret = rte_event_queue_setup(TEST_DEV_ID, info.max_event_queues,
 322                                         &qconf);
 323         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 324
 325         /* Positive case */
 326         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
 327         TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info");
 328         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
 329         TEST_ASSERT_SUCCESS(ret, "Failed to setup queue0");
 330
 331
 332         for (i = 0; i < rte_event_queue_count(TEST_DEV_ID); i++) {
 333                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
 334                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 335         }
 336
 337         return TEST_SUCCESS;
 338 }
 339
 340 static int
 341 test_eventdev_queue_count(void)
 342 {
 343         int ret;
 344         struct rte_event_dev_info info;
 345
 346         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 347         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 348
 349         TEST_ASSERT_EQUAL(rte_event_queue_count(TEST_DEV_ID),
 350                  info.max_event_queues, "Wrong queue count");
 351
 352         return TEST_SUCCESS;
 353 }
 354
 355 static int
 356 test_eventdev_queue_priority(void)
 357 {
 358         int i, ret;
 359         struct rte_event_dev_info info;
 360         struct rte_event_queue_conf qconf;
 361         uint8_t priority;
 362
 363         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 364         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 365
 366         for (i = 0; i < rte_event_queue_count(TEST_DEV_ID); i++) {
 367                 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i,
 368                                         &qconf);
 369                 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i);
 370                 qconf.priority = i %  RTE_EVENT_DEV_PRIORITY_LOWEST;
 371                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
 372                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 373         }
 374
 375         for (i = 0; i < rte_event_queue_count(TEST_DEV_ID); i++) {
 376                 priority =  rte_event_queue_priority(TEST_DEV_ID, i);
 377                 if (info.event_dev_cap & RTE_EVENT_DEV_CAP_QUEUE_QOS)
 378                         TEST_ASSERT_EQUAL(priority,
 379                          i %  RTE_EVENT_DEV_PRIORITY_LOWEST,
 380                          "Wrong priority value for queue%d", i);
 381                 else
 382                         TEST_ASSERT_EQUAL(priority,
 383                          RTE_EVENT_DEV_PRIORITY_NORMAL,
 384                          "Wrong priority value for queue%d", i);
 385         }
 386
 387         return TEST_SUCCESS;
 388 }
 389
 390 static int
 391 test_eventdev_port_default_conf_get(void)
 392 {
 393         int i, ret;
 394         struct rte_event_port_conf pconf;
 395
 396         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, NULL);
 397         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 398
 399         ret = rte_event_port_default_conf_get(TEST_DEV_ID,
 400                         rte_event_port_count(TEST_DEV_ID) + 1, NULL);
 401         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 402
 403         for (i = 0; i < rte_event_port_count(TEST_DEV_ID); i++) {
 404                 ret = rte_event_port_default_conf_get(TEST_DEV_ID, i,
 405                                                         &pconf);
 406                 TEST_ASSERT_SUCCESS(ret, "Failed to get port%d info", i);
 407         }
 408
 409         return TEST_SUCCESS;
 410 }
 411
 412 static int
 413 test_eventdev_port_setup(void)
 414 {
 415         int i, ret;
 416         struct rte_event_dev_info info;
 417         struct rte_event_port_conf pconf;
 418
 419         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 420         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 421
 422         /* Negative cases */
 423         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 424         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 425         pconf.new_event_threshold = info.max_num_events + 1;
 426         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 427         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 428
 429         pconf.new_event_threshold = info.max_num_events;
 430         pconf.dequeue_depth = info.max_event_port_dequeue_depth + 1;
 431         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 432         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 433
 434         pconf.dequeue_depth = info.max_event_port_dequeue_depth;
 435         pconf.enqueue_depth = info.max_event_port_enqueue_depth + 1;
 436         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 437         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 438
 439         ret = rte_event_port_setup(TEST_DEV_ID, info.max_event_ports,
 440                                         &pconf);
 441         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 442
 443         /* Positive case */
 444         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 445         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 446         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 447         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 448
 449
 450         for (i = 0; i < rte_event_port_count(TEST_DEV_ID); i++) {
 451                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
 452                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
 453         }
 454
 455         return TEST_SUCCESS;
 456 }
 457
 458 static int
 459 test_eventdev_dequeue_depth(void)
 460 {
 461         int ret;
 462         struct rte_event_dev_info info;
 463         struct rte_event_port_conf pconf;
 464
 465         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 466         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 467
 468         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 469         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 470         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 471         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 472
 473         TEST_ASSERT_EQUAL(rte_event_port_dequeue_depth(TEST_DEV_ID, 0),
 474                  pconf.dequeue_depth, "Wrong port dequeue depth");
 475
 476         return TEST_SUCCESS;
 477 }
 478
 479 static int
 480 test_eventdev_enqueue_depth(void)
 481 {
 482         int ret;
 483         struct rte_event_dev_info info;
 484         struct rte_event_port_conf pconf;
 485
 486         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 487         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 488
 489         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 490         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 491         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 492         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 493
 494         TEST_ASSERT_EQUAL(rte_event_port_enqueue_depth(TEST_DEV_ID, 0),
 495                  pconf.enqueue_depth, "Wrong port enqueue depth");
 496
 497         return TEST_SUCCESS;
 498 }
 499
 500 static int
 501 test_eventdev_port_count(void)
 502 {
 503         int ret;
 504         struct rte_event_dev_info info;
 505
 506         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 507         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 508
 509         TEST_ASSERT_EQUAL(rte_event_port_count(TEST_DEV_ID),
 510                  info.max_event_ports, "Wrong port count");
 511
 512         return TEST_SUCCESS;
 513 }
 514
 515 static int
 516 test_eventdev_timeout_ticks(void)
 517 {
 518         int ret;
 519         uint64_t timeout_ticks;
 520
 521         ret = rte_event_dequeue_timeout_ticks(TEST_DEV_ID, 100, &timeout_ticks);
 522         if (ret != -ENOTSUP)
 523                 TEST_ASSERT_SUCCESS(ret, "Fail to get timeout_ticks");
 524
 525         return ret;
 526 }
 527
 528
 529 static int
 530 test_eventdev_start_stop(void)
 531 {
 532         int i, ret;
 533
 534         ret = eventdev_configure_setup();
 535         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 536
 537         for (i = 0; i < rte_event_queue_count(TEST_DEV_ID); i++) {
 538                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
 539                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 540         }
 541
 542         for (i = 0; i < rte_event_port_count(TEST_DEV_ID); i++) {
 543                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
 544                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
 545         }
 546
 547         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 548         TEST_ASSERT(ret == rte_event_queue_count(TEST_DEV_ID),
 549                         "Failed to link port, device %d", TEST_DEV_ID);
 550
 551         ret = rte_event_dev_start(TEST_DEV_ID);
 552         TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
 553
 554         rte_event_dev_stop(TEST_DEV_ID);
 555         return TEST_SUCCESS;
 556 }
 557
 558
 559 static int
 560 eventdev_setup_device(void)
 561 {
 562         int i, ret;
 563
 564         ret = eventdev_configure_setup();
 565         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 566
 567         for (i = 0; i < rte_event_queue_count(TEST_DEV_ID); i++) {
 568                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
 569                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 570         }
 571
 572         for (i = 0; i < rte_event_port_count(TEST_DEV_ID); i++) {
 573                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
 574                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
 575         }
 576
 577         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 578         TEST_ASSERT(ret == rte_event_queue_count(TEST_DEV_ID),
 579                         "Failed to link port, device %d", TEST_DEV_ID);
 580
 581         ret = rte_event_dev_start(TEST_DEV_ID);
 582         TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
 583
 584         return TEST_SUCCESS;
 585 }
 586
 587 static void
 588 eventdev_stop_device(void)
 589 {
 590         rte_event_dev_stop(TEST_DEV_ID);
 591 }
 592
 593 static int
 594 test_eventdev_link(void)
 595 {
 596         int ret, nb_queues, i;
 597         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
 598         uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
 599
 600         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 601         TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
 602                                  TEST_DEV_ID);
 603
 604         nb_queues = rte_event_queue_count(TEST_DEV_ID);
 605         for (i = 0; i < nb_queues; i++) {
 606                 queues[i] = i;
 607                 priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
 608         }
 609
 610         ret = rte_event_port_link(TEST_DEV_ID, 0, queues,
 611                                         priorities, nb_queues);
 612         TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
 613                                  TEST_DEV_ID, ret);
 614         return TEST_SUCCESS;
 615 }
 616
 617 static int
 618 test_eventdev_unlink(void)
 619 {
 620         int ret, nb_queues, i;
 621         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
 622
 623         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
 624         TEST_ASSERT(ret >= 0, "Failed to unlink with NULL device%d",
 625                                  TEST_DEV_ID);
 626
 627         nb_queues = rte_event_queue_count(TEST_DEV_ID);
 628         for (i = 0; i < nb_queues; i++)
 629                 queues[i] = i;
 630
 631
 632         ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
 633         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 634                                  TEST_DEV_ID, ret);
 635         return TEST_SUCCESS;
 636 }
 637
 638 static int
 639 test_eventdev_link_get(void)
 640 {
 641         int ret, nb_queues, i;
 642         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
 643         uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
 644
 645         /* link all queues */
 646         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 647         TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
 648                                  TEST_DEV_ID);
 649
 650         nb_queues = rte_event_queue_count(TEST_DEV_ID);
 651         for (i = 0; i < nb_queues; i++)
 652                 queues[i] = i;
 653
 654         ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
 655         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 656                                  TEST_DEV_ID, ret);
 657
 658         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
 659         TEST_ASSERT(ret == 0, "(%d)Wrong link get=%d", TEST_DEV_ID, ret);
 660
 661         /* link all queues and get the links */
 662         nb_queues = rte_event_queue_count(TEST_DEV_ID);
 663         for (i = 0; i < nb_queues; i++) {
 664                 queues[i] = i;
 665                 priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
 666         }
 667         ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
 668                                          nb_queues);
 669         TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
 670                                  TEST_DEV_ID, ret);
 671         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
 672         TEST_ASSERT(ret == nb_queues, "(%d)Wrong link get ret=%d expected=%d",
 673                                  TEST_DEV_ID, ret, nb_queues);
 674         /* unlink all*/
 675         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
 676         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 677                                  TEST_DEV_ID, ret);
 678         /* link just one queue */
 679         queues[0] = 0;
 680         priorities[0] = RTE_EVENT_DEV_PRIORITY_NORMAL;
 681
 682         ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities, 1);
 683         TEST_ASSERT(ret == 1, "Failed to link(device%d) ret=%d",
 684                                  TEST_DEV_ID, ret);
 685         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
 686         TEST_ASSERT(ret == 1, "(%d)Wrong link get ret=%d expected=%d",
 687                                         TEST_DEV_ID, ret, 1);
 688         /* unlink all*/
 689         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
 690         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 691                                  TEST_DEV_ID, ret);
 692         /* 4links and 2 unlinks */
 693         nb_queues = rte_event_queue_count(TEST_DEV_ID);
 694         if (nb_queues >= 4) {
 695                 for (i = 0; i < 4; i++) {
 696                         queues[i] = i;
 697                         priorities[i] = 0x40;
 698                 }
 699                 ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
 700                                                 4);
 701                 TEST_ASSERT(ret == 4, "Failed to link(device%d) ret=%d",
 702                                          TEST_DEV_ID, ret);
 703
 704                 for (i = 0; i < 2; i++)
 705                         queues[i] = i;
 706
 707                 ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, 2);
 708                 TEST_ASSERT(ret == 2, "Failed to unlink(device%d) ret=%d",
 709                                          TEST_DEV_ID, ret);
 710                 ret = rte_event_port_links_get(TEST_DEV_ID, 0,
 711                                                 queues, priorities);
 712                 TEST_ASSERT(ret == 2, "(%d)Wrong link get ret=%d expected=%d",
 713                                                 TEST_DEV_ID, ret, 2);
 714                 TEST_ASSERT(queues[0] == 2, "ret=%d expected=%d", ret, 2);
 715                 TEST_ASSERT(priorities[0] == 0x40, "ret=%d expected=%d",
 716                                                         ret, 0x40);
 717                 TEST_ASSERT(queues[1] == 3, "ret=%d expected=%d", ret, 3);
 718                 TEST_ASSERT(priorities[1] == 0x40, "ret=%d expected=%d",
 719                                         ret, 0x40);
 720         }
 721
 722         return TEST_SUCCESS;
 723 }
 724
 725 static int
 726 test_eventdev_close(void)
 727 {
 728         rte_event_dev_stop(TEST_DEV_ID);
 729         return rte_event_dev_close(TEST_DEV_ID);
 730 }
 731
 732 static struct unit_test_suite eventdev_common_testsuite  = {
 733         .suite_name = "eventdev common code unit test suite",
 734         .setup = testsuite_setup,
 735         .teardown = testsuite_teardown,
 736         .unit_test_cases = {
 737                 TEST_CASE_ST(NULL, NULL,
 738                         test_eventdev_count),
 739                 TEST_CASE_ST(NULL, NULL,
 740                         test_eventdev_get_dev_id),
 741                 TEST_CASE_ST(NULL, NULL,
 742                         test_eventdev_socket_id),
 743                 TEST_CASE_ST(NULL, NULL,
 744                         test_eventdev_info_get),
 745                 TEST_CASE_ST(NULL, NULL,
 746                         test_eventdev_configure),
 747                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 748                         test_eventdev_queue_default_conf_get),
 749                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 750                         test_eventdev_queue_setup),
 751                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 752                         test_eventdev_queue_count),
 753                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 754                         test_eventdev_queue_priority),
 755                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 756                         test_eventdev_port_default_conf_get),
 757                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 758                         test_eventdev_port_setup),
 759                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 760                         test_eventdev_dequeue_depth),
 761                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 762                         test_eventdev_enqueue_depth),
 763                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 764                         test_eventdev_port_count),
 765                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 766                         test_eventdev_timeout_ticks),
 767                 TEST_CASE_ST(NULL, NULL,
 768                         test_eventdev_start_stop),
 769                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
 770                         test_eventdev_link),
 771                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
 772                         test_eventdev_unlink),
 773                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
 774                         test_eventdev_link_get),
 775                 TEST_CASE_ST(eventdev_setup_device, NULL,
 776                         test_eventdev_close),
 777                 TEST_CASES_END() /**< NULL terminate unit test array */
 778         }
 779 };
 780
 781 static int
 782 test_eventdev_common(void)
 783 {
 784         return unit_test_suite_runner(&eventdev_common_testsuite);
 785 }
 786
 787 REGISTER_TEST_COMMAND(eventdev_common_autotest, test_eventdev_common);