test/test/test_eventdev.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2016 Cavium, Inc. 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, Inc 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 max_dequeue_limit(struct rte_event_dev_config *dev_conf,
 143                   struct rte_event_dev_info *info)
 144 {
 145         dev_conf->dequeue_timeout_ns = info->max_dequeue_timeout_ns + 1;
 146 }
 147
 148 static void
 149 max_events_limit(struct rte_event_dev_config *dev_conf,
 150                   struct rte_event_dev_info *info)
 151 {
 152         dev_conf->nb_events_limit  = info->max_num_events + 1;
 153 }
 154
 155 static void
 156 max_event_ports(struct rte_event_dev_config *dev_conf,
 157                   struct rte_event_dev_info *info)
 158 {
 159         dev_conf->nb_event_ports = info->max_event_ports + 1;
 160 }
 161
 162 static void
 163 max_event_queues(struct rte_event_dev_config *dev_conf,
 164                   struct rte_event_dev_info *info)
 165 {
 166         dev_conf->nb_event_queues = info->max_event_queues + 1;
 167 }
 168
 169 static void
 170 max_event_queue_flows(struct rte_event_dev_config *dev_conf,
 171                   struct rte_event_dev_info *info)
 172 {
 173         dev_conf->nb_event_queue_flows = info->max_event_queue_flows + 1;
 174 }
 175
 176 static void
 177 max_event_port_dequeue_depth(struct rte_event_dev_config *dev_conf,
 178                   struct rte_event_dev_info *info)
 179 {
 180         dev_conf->nb_event_port_dequeue_depth =
 181                 info->max_event_port_dequeue_depth + 1;
 182 }
 183
 184 static void
 185 max_event_port_enqueue_depth(struct rte_event_dev_config *dev_conf,
 186                   struct rte_event_dev_info *info)
 187 {
 188         dev_conf->nb_event_port_enqueue_depth =
 189                 info->max_event_port_enqueue_depth + 1;
 190 }
 191
 192
 193 static int
 194 test_eventdev_configure(void)
 195 {
 196         int ret;
 197         struct rte_event_dev_config dev_conf;
 198         struct rte_event_dev_info info;
 199         ret = rte_event_dev_configure(TEST_DEV_ID, NULL);
 200         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 201
 202         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 203         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 204
 205         /* Check limits */
 206         TEST_ASSERT_EQUAL(-EINVAL,
 207                 test_ethdev_config_run(&dev_conf, &info, max_dequeue_limit),
 208                  "Config negative test failed");
 209         TEST_ASSERT_EQUAL(-EINVAL,
 210                 test_ethdev_config_run(&dev_conf, &info, max_events_limit),
 211                  "Config negative test failed");
 212         TEST_ASSERT_EQUAL(-EINVAL,
 213                 test_ethdev_config_run(&dev_conf, &info, max_event_ports),
 214                  "Config negative test failed");
 215         TEST_ASSERT_EQUAL(-EINVAL,
 216                 test_ethdev_config_run(&dev_conf, &info, max_event_queues),
 217                  "Config negative test failed");
 218         TEST_ASSERT_EQUAL(-EINVAL,
 219                 test_ethdev_config_run(&dev_conf, &info, max_event_queue_flows),
 220                  "Config negative test failed");
 221         TEST_ASSERT_EQUAL(-EINVAL,
 222                 test_ethdev_config_run(&dev_conf, &info,
 223                         max_event_port_dequeue_depth),
 224                          "Config negative test failed");
 225         TEST_ASSERT_EQUAL(-EINVAL,
 226                 test_ethdev_config_run(&dev_conf, &info,
 227                 max_event_port_enqueue_depth),
 228                  "Config negative test failed");
 229
 230         /* Positive case */
 231         devconf_set_default_sane_values(&dev_conf, &info);
 232         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
 233         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 234
 235         /* re-configure */
 236         devconf_set_default_sane_values(&dev_conf, &info);
 237         dev_conf.nb_event_ports = RTE_MAX(info.max_event_ports/2, 1);
 238         dev_conf.nb_event_queues = RTE_MAX(info.max_event_queues/2, 1);
 239         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
 240         TEST_ASSERT_SUCCESS(ret, "Failed to re configure eventdev");
 241
 242         /* re-configure back to max_event_queues and max_event_ports */
 243         devconf_set_default_sane_values(&dev_conf, &info);
 244         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
 245         TEST_ASSERT_SUCCESS(ret, "Failed to re-configure eventdev");
 246
 247         return TEST_SUCCESS;
 248
 249 }
 250
 251 static int
 252 eventdev_configure_setup(void)
 253 {
 254         int ret;
 255         struct rte_event_dev_config dev_conf;
 256         struct rte_event_dev_info info;
 257
 258         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 259         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 260         devconf_set_default_sane_values(&dev_conf, &info);
 261         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
 262         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 263
 264         return TEST_SUCCESS;
 265 }
 266
 267 static int
 268 test_eventdev_queue_default_conf_get(void)
 269 {
 270         int i, ret;
 271         struct rte_event_queue_conf qconf;
 272
 273         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, NULL);
 274         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 275
 276         uint32_t queue_count;
 277         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 278                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 279                             "Queue count get failed");
 280
 281         for (i = 0; i < (int)queue_count; i++) {
 282                 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i,
 283                                                  &qconf);
 284                 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d info", i);
 285         }
 286
 287         return TEST_SUCCESS;
 288 }
 289
 290 static int
 291 test_eventdev_queue_setup(void)
 292 {
 293         int i, ret;
 294         struct rte_event_dev_info info;
 295         struct rte_event_queue_conf qconf;
 296
 297         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 298         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 299
 300         /* Negative cases */
 301         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
 302         TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info");
 303         qconf.event_queue_cfg = (RTE_EVENT_QUEUE_CFG_ALL_TYPES &
 304                  RTE_EVENT_QUEUE_CFG_TYPE_MASK);
 305         qconf.nb_atomic_flows = info.max_event_queue_flows + 1;
 306         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
 307         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 308
 309         qconf.nb_atomic_flows = info.max_event_queue_flows;
 310         qconf.event_queue_cfg = (RTE_EVENT_QUEUE_CFG_ORDERED_ONLY &
 311                  RTE_EVENT_QUEUE_CFG_TYPE_MASK);
 312         qconf.nb_atomic_order_sequences = info.max_event_queue_flows + 1;
 313         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
 314         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 315
 316         ret = rte_event_queue_setup(TEST_DEV_ID, info.max_event_queues,
 317                                         &qconf);
 318         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 319
 320         /* Positive case */
 321         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
 322         TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info");
 323         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
 324         TEST_ASSERT_SUCCESS(ret, "Failed to setup queue0");
 325
 326         uint32_t queue_count;
 327         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 328                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 329                             "Queue count get failed");
 330
 331         for (i = 0; i < (int)queue_count; i++) {
 332                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
 333                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 334         }
 335
 336         return TEST_SUCCESS;
 337 }
 338
 339 static int
 340 test_eventdev_queue_count(void)
 341 {
 342         int ret;
 343         struct rte_event_dev_info info;
 344
 345         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 346         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 347
 348         uint32_t queue_count;
 349         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 350                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 351                             "Queue count get failed");
 352         TEST_ASSERT_EQUAL(queue_count, info.max_event_queues,
 353                           "Wrong queue count");
 354
 355         return TEST_SUCCESS;
 356 }
 357
 358 static int
 359 test_eventdev_queue_priority(void)
 360 {
 361         int i, ret;
 362         struct rte_event_dev_info info;
 363         struct rte_event_queue_conf qconf;
 364         uint8_t priority;
 365
 366         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 367         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 368
 369         uint32_t queue_count;
 370         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 371                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 372                             "Queue count get failed");
 373
 374         for (i = 0; i < (int)queue_count; i++) {
 375                 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i,
 376                                         &qconf);
 377                 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i);
 378                 qconf.priority = i %  RTE_EVENT_DEV_PRIORITY_LOWEST;
 379                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
 380                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 381         }
 382
 383         for (i = 0; i < (int)queue_count; i++) {
 384                 uint32_t tmp;
 385                 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
 386                                     RTE_EVENT_QUEUE_ATTR_PRIORITY, &tmp),
 387                                     "Queue priority get failed");
 388                 priority = tmp;
 389
 390                 if (info.event_dev_cap & RTE_EVENT_DEV_CAP_QUEUE_QOS)
 391                         TEST_ASSERT_EQUAL(priority,
 392                          i %  RTE_EVENT_DEV_PRIORITY_LOWEST,
 393                          "Wrong priority value for queue%d", i);
 394                 else
 395                         TEST_ASSERT_EQUAL(priority,
 396                          RTE_EVENT_DEV_PRIORITY_NORMAL,
 397                          "Wrong priority value for queue%d", i);
 398         }
 399
 400         return TEST_SUCCESS;
 401 }
 402
 403 static int
 404 test_eventdev_port_default_conf_get(void)
 405 {
 406         int i, ret;
 407         struct rte_event_port_conf pconf;
 408
 409         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, NULL);
 410         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 411
 412         uint32_t port_count;
 413         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 414                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 415                                 &port_count), "Port count get failed");
 416
 417         ret = rte_event_port_default_conf_get(TEST_DEV_ID,
 418                         port_count + 1, NULL);
 419         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 420
 421         for (i = 0; i < (int)port_count; i++) {
 422                 ret = rte_event_port_default_conf_get(TEST_DEV_ID, i,
 423                                                         &pconf);
 424                 TEST_ASSERT_SUCCESS(ret, "Failed to get port%d info", i);
 425         }
 426
 427         return TEST_SUCCESS;
 428 }
 429
 430 static int
 431 test_eventdev_port_setup(void)
 432 {
 433         int i, ret;
 434         struct rte_event_dev_info info;
 435         struct rte_event_port_conf pconf;
 436
 437         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 438         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 439
 440         /* Negative cases */
 441         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 442         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 443         pconf.new_event_threshold = info.max_num_events + 1;
 444         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 445         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 446
 447         pconf.new_event_threshold = info.max_num_events;
 448         pconf.dequeue_depth = info.max_event_port_dequeue_depth + 1;
 449         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 450         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 451
 452         pconf.dequeue_depth = info.max_event_port_dequeue_depth;
 453         pconf.enqueue_depth = info.max_event_port_enqueue_depth + 1;
 454         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 455         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 456
 457         ret = rte_event_port_setup(TEST_DEV_ID, info.max_event_ports,
 458                                         &pconf);
 459         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 460
 461         /* Positive case */
 462         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 463         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 464         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 465         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 466
 467         uint32_t port_count;
 468         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 469                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 470                                 &port_count), "Port count get failed");
 471
 472         for (i = 0; i < (int)port_count; i++) {
 473                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
 474                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
 475         }
 476
 477         return TEST_SUCCESS;
 478 }
 479
 480 static int
 481 test_eventdev_dequeue_depth(void)
 482 {
 483         int ret;
 484         struct rte_event_dev_info info;
 485         struct rte_event_port_conf pconf;
 486
 487         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 488         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 489
 490         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 491         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 492         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 493         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 494
 495         uint32_t value;
 496         TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
 497                         RTE_EVENT_PORT_ATTR_DEQ_DEPTH, &value),
 498                         0, "Call to port dequeue depth failed");
 499         TEST_ASSERT_EQUAL(value, pconf.dequeue_depth,
 500                         "Wrong port dequeue depth");
 501
 502         return TEST_SUCCESS;
 503 }
 504
 505 static int
 506 test_eventdev_enqueue_depth(void)
 507 {
 508         int ret;
 509         struct rte_event_dev_info info;
 510         struct rte_event_port_conf pconf;
 511
 512         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 513         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 514
 515         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 516         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 517         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 518         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 519
 520         uint32_t value;
 521         TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
 522                         RTE_EVENT_PORT_ATTR_ENQ_DEPTH, &value),
 523                         0, "Call to port enqueue depth failed");
 524         TEST_ASSERT_EQUAL(value, pconf.enqueue_depth,
 525                         "Wrong port enqueue depth");
 526
 527         return TEST_SUCCESS;
 528 }
 529
 530 static int
 531 test_eventdev_port_count(void)
 532 {
 533         int ret;
 534         struct rte_event_dev_info info;
 535
 536         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 537         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 538
 539         uint32_t port_count;
 540         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 541                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 542                                 &port_count), "Port count get failed");
 543         TEST_ASSERT_EQUAL(port_count, info.max_event_ports, "Wrong port count");
 544
 545         return TEST_SUCCESS;
 546 }
 547
 548 static int
 549 test_eventdev_timeout_ticks(void)
 550 {
 551         int ret;
 552         uint64_t timeout_ticks;
 553
 554         ret = rte_event_dequeue_timeout_ticks(TEST_DEV_ID, 100, &timeout_ticks);
 555         if (ret != -ENOTSUP)
 556                 TEST_ASSERT_SUCCESS(ret, "Fail to get timeout_ticks");
 557
 558         return ret;
 559 }
 560
 561
 562 static int
 563 test_eventdev_start_stop(void)
 564 {
 565         int i, ret;
 566
 567         ret = eventdev_configure_setup();
 568         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 569
 570         uint32_t queue_count;
 571         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 572                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 573                             "Queue count get failed");
 574         for (i = 0; i < (int)queue_count; i++) {
 575                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
 576                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 577         }
 578
 579         uint32_t port_count;
 580         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 581                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 582                                 &port_count), "Port count get failed");
 583
 584         for (i = 0; i < (int)port_count; i++) {
 585                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
 586                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
 587         }
 588
 589         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 590         TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
 591                     TEST_DEV_ID);
 592
 593         ret = rte_event_dev_start(TEST_DEV_ID);
 594         TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
 595
 596         rte_event_dev_stop(TEST_DEV_ID);
 597         return TEST_SUCCESS;
 598 }
 599
 600
 601 static int
 602 eventdev_setup_device(void)
 603 {
 604         int i, ret;
 605
 606         ret = eventdev_configure_setup();
 607         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 608
 609         uint32_t queue_count;
 610         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 611                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 612                             "Queue count get failed");
 613         for (i = 0; i < (int)queue_count; i++) {
 614                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
 615                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 616         }
 617
 618         uint32_t port_count;
 619         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 620                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 621                                 &port_count), "Port count get failed");
 622
 623         for (i = 0; i < (int)port_count; i++) {
 624                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
 625                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
 626         }
 627
 628         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 629         TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
 630                     TEST_DEV_ID);
 631
 632         ret = rte_event_dev_start(TEST_DEV_ID);
 633         TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
 634
 635         return TEST_SUCCESS;
 636 }
 637
 638 static void
 639 eventdev_stop_device(void)
 640 {
 641         rte_event_dev_stop(TEST_DEV_ID);
 642 }
 643
 644 static int
 645 test_eventdev_link(void)
 646 {
 647         int ret, nb_queues, i;
 648         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
 649         uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
 650
 651         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 652         TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
 653                                  TEST_DEV_ID);
 654
 655         uint32_t queue_count;
 656         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 657                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 658                             "Queue count get failed");
 659         nb_queues = queue_count;
 660         for (i = 0; i < nb_queues; i++) {
 661                 queues[i] = i;
 662                 priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
 663         }
 664
 665         ret = rte_event_port_link(TEST_DEV_ID, 0, queues,
 666                                         priorities, nb_queues);
 667         TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
 668                                  TEST_DEV_ID, ret);
 669         return TEST_SUCCESS;
 670 }
 671
 672 static int
 673 test_eventdev_unlink(void)
 674 {
 675         int ret, nb_queues, i;
 676         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
 677
 678         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
 679         TEST_ASSERT(ret >= 0, "Failed to unlink with NULL device%d",
 680                                  TEST_DEV_ID);
 681
 682         uint32_t queue_count;
 683         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 684                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 685                             "Queue count get failed");
 686         nb_queues = queue_count;
 687         for (i = 0; i < nb_queues; i++)
 688                 queues[i] = i;
 689
 690
 691         ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
 692         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 693                                  TEST_DEV_ID, ret);
 694         return TEST_SUCCESS;
 695 }
 696
 697 static int
 698 test_eventdev_link_get(void)
 699 {
 700         int ret, i;
 701         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
 702         uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
 703
 704         /* link all queues */
 705         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 706         TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
 707                                  TEST_DEV_ID);
 708
 709         uint32_t queue_count;
 710         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 711                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 712                             "Queue count get failed");
 713         const int nb_queues = queue_count;
 714         for (i = 0; i < nb_queues; i++)
 715                 queues[i] = i;
 716
 717         ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
 718         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 719                                  TEST_DEV_ID, ret);
 720
 721         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
 722         TEST_ASSERT(ret == 0, "(%d)Wrong link get=%d", TEST_DEV_ID, ret);
 723
 724         /* link all queues and get the links */
 725         for (i = 0; i < nb_queues; i++) {
 726                 queues[i] = i;
 727                 priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
 728         }
 729         ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
 730                                          nb_queues);
 731         TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
 732                                  TEST_DEV_ID, ret);
 733         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
 734         TEST_ASSERT(ret == nb_queues, "(%d)Wrong link get ret=%d expected=%d",
 735                                  TEST_DEV_ID, ret, nb_queues);
 736         /* unlink all*/
 737         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
 738         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 739                                  TEST_DEV_ID, ret);
 740         /* link just one queue */
 741         queues[0] = 0;
 742         priorities[0] = RTE_EVENT_DEV_PRIORITY_NORMAL;
 743
 744         ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities, 1);
 745         TEST_ASSERT(ret == 1, "Failed to link(device%d) ret=%d",
 746                                  TEST_DEV_ID, ret);
 747         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
 748         TEST_ASSERT(ret == 1, "(%d)Wrong link get ret=%d expected=%d",
 749                                         TEST_DEV_ID, ret, 1);
 750         /* unlink all*/
 751         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
 752         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 753                                  TEST_DEV_ID, ret);
 754
 755         /* 4links and 2 unlinks */
 756         if (nb_queues >= 4) {
 757                 for (i = 0; i < 4; i++) {
 758                         queues[i] = i;
 759                         priorities[i] = 0x40;
 760                 }
 761                 ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
 762                                                 4);
 763                 TEST_ASSERT(ret == 4, "Failed to link(device%d) ret=%d",
 764                                          TEST_DEV_ID, ret);
 765
 766                 for (i = 0; i < 2; i++)
 767                         queues[i] = i;
 768
 769                 ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, 2);
 770                 TEST_ASSERT(ret == 2, "Failed to unlink(device%d) ret=%d",
 771                                          TEST_DEV_ID, ret);
 772                 ret = rte_event_port_links_get(TEST_DEV_ID, 0,
 773                                                 queues, priorities);
 774                 TEST_ASSERT(ret == 2, "(%d)Wrong link get ret=%d expected=%d",
 775                                                 TEST_DEV_ID, ret, 2);
 776                 TEST_ASSERT(queues[0] == 2, "ret=%d expected=%d", ret, 2);
 777                 TEST_ASSERT(priorities[0] == 0x40, "ret=%d expected=%d",
 778                                                         ret, 0x40);
 779                 TEST_ASSERT(queues[1] == 3, "ret=%d expected=%d", ret, 3);
 780                 TEST_ASSERT(priorities[1] == 0x40, "ret=%d expected=%d",
 781                                         ret, 0x40);
 782         }
 783
 784         return TEST_SUCCESS;
 785 }
 786
 787 static int
 788 test_eventdev_close(void)
 789 {
 790         rte_event_dev_stop(TEST_DEV_ID);
 791         return rte_event_dev_close(TEST_DEV_ID);
 792 }
 793
 794 static struct unit_test_suite eventdev_common_testsuite  = {
 795         .suite_name = "eventdev common code unit test suite",
 796         .setup = testsuite_setup,
 797         .teardown = testsuite_teardown,
 798         .unit_test_cases = {
 799                 TEST_CASE_ST(NULL, NULL,
 800                         test_eventdev_count),
 801                 TEST_CASE_ST(NULL, NULL,
 802                         test_eventdev_get_dev_id),
 803                 TEST_CASE_ST(NULL, NULL,
 804                         test_eventdev_socket_id),
 805                 TEST_CASE_ST(NULL, NULL,
 806                         test_eventdev_info_get),
 807                 TEST_CASE_ST(NULL, NULL,
 808                         test_eventdev_configure),
 809                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 810                         test_eventdev_queue_default_conf_get),
 811                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 812                         test_eventdev_queue_setup),
 813                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 814                         test_eventdev_queue_count),
 815                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 816                         test_eventdev_queue_priority),
 817                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 818                         test_eventdev_port_default_conf_get),
 819                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 820                         test_eventdev_port_setup),
 821                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 822                         test_eventdev_dequeue_depth),
 823                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 824                         test_eventdev_enqueue_depth),
 825                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 826                         test_eventdev_port_count),
 827                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 828                         test_eventdev_timeout_ticks),
 829                 TEST_CASE_ST(NULL, NULL,
 830                         test_eventdev_start_stop),
 831                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
 832                         test_eventdev_link),
 833                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
 834                         test_eventdev_unlink),
 835                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
 836                         test_eventdev_link_get),
 837                 TEST_CASE_ST(eventdev_setup_device, NULL,
 838                         test_eventdev_close),
 839                 TEST_CASES_END() /**< NULL terminate unit test array */
 840         }
 841 };
 842
 843 static int
 844 test_eventdev_common(void)
 845 {
 846         return unit_test_suite_runner(&eventdev_common_testsuite);
 847 }
 848
 849 REGISTER_TEST_COMMAND(eventdev_common_autotest, test_eventdev_common);