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         qconf.nb_atomic_flows = info.max_event_queue_flows + 1;
 305         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
 306         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 307
 308         qconf.nb_atomic_flows = info.max_event_queue_flows;
 309         qconf.schedule_type = RTE_SCHED_TYPE_ORDERED;
 310         qconf.nb_atomic_order_sequences = 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         ret = rte_event_queue_setup(TEST_DEV_ID, info.max_event_queues,
 315                                         &qconf);
 316         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 317
 318         /* Positive case */
 319         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
 320         TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info");
 321         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
 322         TEST_ASSERT_SUCCESS(ret, "Failed to setup queue0");
 323
 324         uint32_t queue_count;
 325         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 326                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 327                             "Queue count get failed");
 328
 329         for (i = 0; i < (int)queue_count; i++) {
 330                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
 331                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 332         }
 333
 334         return TEST_SUCCESS;
 335 }
 336
 337 static int
 338 test_eventdev_queue_count(void)
 339 {
 340         int ret;
 341         struct rte_event_dev_info info;
 342
 343         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 344         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 345
 346         uint32_t queue_count;
 347         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 348                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 349                             "Queue count get failed");
 350         TEST_ASSERT_EQUAL(queue_count, info.max_event_queues,
 351                           "Wrong queue count");
 352
 353         return TEST_SUCCESS;
 354 }
 355
 356 static int
 357 test_eventdev_queue_attr_priority(void)
 358 {
 359         int i, ret;
 360         struct rte_event_dev_info info;
 361         struct rte_event_queue_conf qconf;
 362         uint8_t priority;
 363
 364         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 365         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 366
 367         uint32_t queue_count;
 368         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 369                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 370                             "Queue count get failed");
 371
 372         for (i = 0; i < (int)queue_count; i++) {
 373                 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i,
 374                                         &qconf);
 375                 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i);
 376                 qconf.priority = i %  RTE_EVENT_DEV_PRIORITY_LOWEST;
 377                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
 378                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 379         }
 380
 381         for (i = 0; i < (int)queue_count; i++) {
 382                 uint32_t tmp;
 383                 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
 384                                     RTE_EVENT_QUEUE_ATTR_PRIORITY, &tmp),
 385                                     "Queue priority get failed");
 386                 priority = tmp;
 387
 388                 if (info.event_dev_cap & RTE_EVENT_DEV_CAP_QUEUE_QOS)
 389                         TEST_ASSERT_EQUAL(priority,
 390                          i %  RTE_EVENT_DEV_PRIORITY_LOWEST,
 391                          "Wrong priority value for queue%d", i);
 392                 else
 393                         TEST_ASSERT_EQUAL(priority,
 394                          RTE_EVENT_DEV_PRIORITY_NORMAL,
 395                          "Wrong priority value for queue%d", i);
 396         }
 397
 398         return TEST_SUCCESS;
 399 }
 400
 401 static int
 402 test_eventdev_queue_attr_nb_atomic_flows(void)
 403 {
 404         int i, ret;
 405         struct rte_event_dev_info info;
 406         struct rte_event_queue_conf qconf;
 407         uint32_t nb_atomic_flows;
 408
 409         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 410         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 411
 412         uint32_t queue_count;
 413         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 414                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 415                             "Queue count get failed");
 416
 417         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
 418         TEST_ASSERT_SUCCESS(ret, "Failed to get queue 0's def conf");
 419
 420         if (qconf.nb_atomic_flows == 0)
 421                 /* Assume PMD doesn't support atomic flows, return early */
 422                 return -ENOTSUP;
 423
 424         qconf.schedule_type = RTE_SCHED_TYPE_ATOMIC;
 425
 426         for (i = 0; i < (int)queue_count; i++) {
 427                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
 428                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 429         }
 430
 431         for (i = 0; i < (int)queue_count; i++) {
 432                 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
 433                                     RTE_EVENT_QUEUE_ATTR_NB_ATOMIC_FLOWS,
 434                                     &nb_atomic_flows),
 435                                     "Queue nb_atomic_flows get failed");
 436
 437                 TEST_ASSERT_EQUAL(nb_atomic_flows, qconf.nb_atomic_flows,
 438                                   "Wrong atomic flows value for queue%d", i);
 439         }
 440
 441         return TEST_SUCCESS;
 442 }
 443
 444 static int
 445 test_eventdev_queue_attr_nb_atomic_order_sequences(void)
 446 {
 447         int i, ret;
 448         struct rte_event_dev_info info;
 449         struct rte_event_queue_conf qconf;
 450         uint32_t nb_atomic_order_sequences;
 451
 452         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 453         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 454
 455         uint32_t queue_count;
 456         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 457                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 458                             "Queue count get failed");
 459
 460         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
 461         TEST_ASSERT_SUCCESS(ret, "Failed to get queue 0's def conf");
 462
 463         if (qconf.nb_atomic_order_sequences == 0)
 464                 /* Assume PMD doesn't support reordering */
 465                 return -ENOTSUP;
 466
 467         qconf.schedule_type = RTE_SCHED_TYPE_ORDERED;
 468
 469         for (i = 0; i < (int)queue_count; i++) {
 470                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
 471                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 472         }
 473
 474         for (i = 0; i < (int)queue_count; i++) {
 475                 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
 476                             RTE_EVENT_QUEUE_ATTR_NB_ATOMIC_ORDER_SEQUENCES,
 477                             &nb_atomic_order_sequences),
 478                             "Queue nb_atomic_order_sequencess get failed");
 479
 480                 TEST_ASSERT_EQUAL(nb_atomic_order_sequences,
 481                                   qconf.nb_atomic_order_sequences,
 482                                   "Wrong atomic order sequences value for queue%d",
 483                                   i);
 484         }
 485
 486         return TEST_SUCCESS;
 487 }
 488
 489 static int
 490 test_eventdev_queue_attr_event_queue_cfg(void)
 491 {
 492         int i, ret;
 493         struct rte_event_dev_info info;
 494         struct rte_event_queue_conf qconf;
 495         uint32_t event_queue_cfg;
 496
 497         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 498         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 499
 500         uint32_t queue_count;
 501         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 502                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 503                             "Queue count get failed");
 504
 505         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
 506         TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 def conf");
 507
 508         qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
 509
 510         for (i = 0; i < (int)queue_count; i++) {
 511                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
 512                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 513         }
 514
 515         for (i = 0; i < (int)queue_count; i++) {
 516                 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
 517                                     RTE_EVENT_QUEUE_ATTR_EVENT_QUEUE_CFG,
 518                                     &event_queue_cfg),
 519                                     "Queue event_queue_cfg get failed");
 520
 521                 TEST_ASSERT_EQUAL(event_queue_cfg, qconf.event_queue_cfg,
 522                                   "Wrong event_queue_cfg value for queue%d",
 523                                   i);
 524         }
 525
 526         return TEST_SUCCESS;
 527 }
 528
 529 static int
 530 test_eventdev_port_default_conf_get(void)
 531 {
 532         int i, ret;
 533         struct rte_event_port_conf pconf;
 534
 535         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, NULL);
 536         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 537
 538         uint32_t port_count;
 539         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 540                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 541                                 &port_count), "Port count get failed");
 542
 543         ret = rte_event_port_default_conf_get(TEST_DEV_ID,
 544                         port_count + 1, NULL);
 545         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 546
 547         for (i = 0; i < (int)port_count; i++) {
 548                 ret = rte_event_port_default_conf_get(TEST_DEV_ID, i,
 549                                                         &pconf);
 550                 TEST_ASSERT_SUCCESS(ret, "Failed to get port%d info", i);
 551         }
 552
 553         return TEST_SUCCESS;
 554 }
 555
 556 static int
 557 test_eventdev_port_setup(void)
 558 {
 559         int i, ret;
 560         struct rte_event_dev_info info;
 561         struct rte_event_port_conf pconf;
 562
 563         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 564         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 565
 566         /* Negative cases */
 567         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 568         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 569         pconf.new_event_threshold = info.max_num_events + 1;
 570         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 571         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 572
 573         pconf.new_event_threshold = info.max_num_events;
 574         pconf.dequeue_depth = info.max_event_port_dequeue_depth + 1;
 575         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 576         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 577
 578         pconf.dequeue_depth = info.max_event_port_dequeue_depth;
 579         pconf.enqueue_depth = info.max_event_port_enqueue_depth + 1;
 580         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 581         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 582
 583         ret = rte_event_port_setup(TEST_DEV_ID, info.max_event_ports,
 584                                         &pconf);
 585         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 586
 587         /* Positive case */
 588         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 589         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 590         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 591         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 592
 593         uint32_t port_count;
 594         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 595                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 596                                 &port_count), "Port count get failed");
 597
 598         for (i = 0; i < (int)port_count; i++) {
 599                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
 600                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
 601         }
 602
 603         return TEST_SUCCESS;
 604 }
 605
 606 static int
 607 test_eventdev_port_attr_dequeue_depth(void)
 608 {
 609         int ret;
 610         struct rte_event_dev_info info;
 611         struct rte_event_port_conf pconf;
 612
 613         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 614         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 615
 616         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 617         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 618         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 619         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 620
 621         uint32_t value;
 622         TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
 623                         RTE_EVENT_PORT_ATTR_DEQ_DEPTH, &value),
 624                         0, "Call to get port dequeue depth failed");
 625         TEST_ASSERT_EQUAL(value, pconf.dequeue_depth,
 626                         "Wrong port dequeue depth");
 627
 628         return TEST_SUCCESS;
 629 }
 630
 631 static int
 632 test_eventdev_port_attr_enqueue_depth(void)
 633 {
 634         int ret;
 635         struct rte_event_dev_info info;
 636         struct rte_event_port_conf pconf;
 637
 638         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 639         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 640
 641         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 642         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 643         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 644         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 645
 646         uint32_t value;
 647         TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
 648                         RTE_EVENT_PORT_ATTR_ENQ_DEPTH, &value),
 649                         0, "Call to get port enqueue depth failed");
 650         TEST_ASSERT_EQUAL(value, pconf.enqueue_depth,
 651                         "Wrong port enqueue depth");
 652
 653         return TEST_SUCCESS;
 654 }
 655
 656 static int
 657 test_eventdev_port_attr_new_event_threshold(void)
 658 {
 659         int ret;
 660         struct rte_event_dev_info info;
 661         struct rte_event_port_conf pconf;
 662
 663         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 664         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 665
 666         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 667         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 668         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 669         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 670
 671         uint32_t value;
 672         TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
 673                         RTE_EVENT_PORT_ATTR_NEW_EVENT_THRESHOLD, &value),
 674                         0, "Call to get port new event threshold failed");
 675         TEST_ASSERT_EQUAL((int32_t) value, pconf.new_event_threshold,
 676                         "Wrong port new event threshold");
 677
 678         return TEST_SUCCESS;
 679 }
 680
 681 static int
 682 test_eventdev_port_count(void)
 683 {
 684         int ret;
 685         struct rte_event_dev_info info;
 686
 687         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 688         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 689
 690         uint32_t port_count;
 691         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 692                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 693                                 &port_count), "Port count get failed");
 694         TEST_ASSERT_EQUAL(port_count, info.max_event_ports, "Wrong port count");
 695
 696         return TEST_SUCCESS;
 697 }
 698
 699 static int
 700 test_eventdev_timeout_ticks(void)
 701 {
 702         int ret;
 703         uint64_t timeout_ticks;
 704
 705         ret = rte_event_dequeue_timeout_ticks(TEST_DEV_ID, 100, &timeout_ticks);
 706         if (ret != -ENOTSUP)
 707                 TEST_ASSERT_SUCCESS(ret, "Fail to get timeout_ticks");
 708
 709         return ret;
 710 }
 711
 712
 713 static int
 714 test_eventdev_start_stop(void)
 715 {
 716         int i, ret;
 717
 718         ret = eventdev_configure_setup();
 719         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 720
 721         uint32_t queue_count;
 722         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 723                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 724                             "Queue count get failed");
 725         for (i = 0; i < (int)queue_count; i++) {
 726                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
 727                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 728         }
 729
 730         uint32_t port_count;
 731         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 732                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 733                                 &port_count), "Port count get failed");
 734
 735         for (i = 0; i < (int)port_count; i++) {
 736                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
 737                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
 738         }
 739
 740         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 741         TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
 742                     TEST_DEV_ID);
 743
 744         ret = rte_event_dev_start(TEST_DEV_ID);
 745         TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
 746
 747         rte_event_dev_stop(TEST_DEV_ID);
 748         return TEST_SUCCESS;
 749 }
 750
 751
 752 static int
 753 eventdev_setup_device(void)
 754 {
 755         int i, ret;
 756
 757         ret = eventdev_configure_setup();
 758         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 759
 760         uint32_t queue_count;
 761         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 762                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 763                             "Queue count get failed");
 764         for (i = 0; i < (int)queue_count; i++) {
 765                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
 766                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 767         }
 768
 769         uint32_t port_count;
 770         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 771                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 772                                 &port_count), "Port count get failed");
 773
 774         for (i = 0; i < (int)port_count; i++) {
 775                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
 776                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
 777         }
 778
 779         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 780         TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
 781                     TEST_DEV_ID);
 782
 783         ret = rte_event_dev_start(TEST_DEV_ID);
 784         TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
 785
 786         return TEST_SUCCESS;
 787 }
 788
 789 static void
 790 eventdev_stop_device(void)
 791 {
 792         rte_event_dev_stop(TEST_DEV_ID);
 793 }
 794
 795 static int
 796 test_eventdev_link(void)
 797 {
 798         int ret, nb_queues, i;
 799         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
 800         uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
 801
 802         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 803         TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
 804                                  TEST_DEV_ID);
 805
 806         uint32_t queue_count;
 807         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 808                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 809                             "Queue count get failed");
 810         nb_queues = queue_count;
 811         for (i = 0; i < nb_queues; i++) {
 812                 queues[i] = i;
 813                 priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
 814         }
 815
 816         ret = rte_event_port_link(TEST_DEV_ID, 0, queues,
 817                                         priorities, nb_queues);
 818         TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
 819                                  TEST_DEV_ID, ret);
 820         return TEST_SUCCESS;
 821 }
 822
 823 static int
 824 test_eventdev_unlink(void)
 825 {
 826         int ret, nb_queues, i;
 827         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
 828
 829         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
 830         TEST_ASSERT(ret >= 0, "Failed to unlink with NULL device%d",
 831                                  TEST_DEV_ID);
 832
 833         uint32_t queue_count;
 834         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 835                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 836                             "Queue count get failed");
 837         nb_queues = queue_count;
 838         for (i = 0; i < nb_queues; i++)
 839                 queues[i] = i;
 840
 841
 842         ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
 843         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 844                                  TEST_DEV_ID, ret);
 845         return TEST_SUCCESS;
 846 }
 847
 848 static int
 849 test_eventdev_link_get(void)
 850 {
 851         int ret, i;
 852         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
 853         uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
 854
 855         /* link all queues */
 856         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 857         TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
 858                                  TEST_DEV_ID);
 859
 860         uint32_t queue_count;
 861         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 862                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 863                             "Queue count get failed");
 864         const int nb_queues = queue_count;
 865         for (i = 0; i < nb_queues; i++)
 866                 queues[i] = i;
 867
 868         ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
 869         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 870                                  TEST_DEV_ID, ret);
 871
 872         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
 873         TEST_ASSERT(ret == 0, "(%d)Wrong link get=%d", TEST_DEV_ID, ret);
 874
 875         /* link all queues and get the links */
 876         for (i = 0; i < nb_queues; i++) {
 877                 queues[i] = i;
 878                 priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
 879         }
 880         ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
 881                                          nb_queues);
 882         TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
 883                                  TEST_DEV_ID, ret);
 884         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
 885         TEST_ASSERT(ret == nb_queues, "(%d)Wrong link get ret=%d expected=%d",
 886                                  TEST_DEV_ID, ret, nb_queues);
 887         /* unlink all*/
 888         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
 889         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 890                                  TEST_DEV_ID, ret);
 891         /* link just one queue */
 892         queues[0] = 0;
 893         priorities[0] = RTE_EVENT_DEV_PRIORITY_NORMAL;
 894
 895         ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities, 1);
 896         TEST_ASSERT(ret == 1, "Failed to link(device%d) ret=%d",
 897                                  TEST_DEV_ID, ret);
 898         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
 899         TEST_ASSERT(ret == 1, "(%d)Wrong link get ret=%d expected=%d",
 900                                         TEST_DEV_ID, ret, 1);
 901         /* unlink all*/
 902         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
 903         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 904                                  TEST_DEV_ID, ret);
 905
 906         /* 4links and 2 unlinks */
 907         if (nb_queues >= 4) {
 908                 for (i = 0; i < 4; i++) {
 909                         queues[i] = i;
 910                         priorities[i] = 0x40;
 911                 }
 912                 ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
 913                                                 4);
 914                 TEST_ASSERT(ret == 4, "Failed to link(device%d) ret=%d",
 915                                          TEST_DEV_ID, ret);
 916
 917                 for (i = 0; i < 2; i++)
 918                         queues[i] = i;
 919
 920                 ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, 2);
 921                 TEST_ASSERT(ret == 2, "Failed to unlink(device%d) ret=%d",
 922                                          TEST_DEV_ID, ret);
 923                 ret = rte_event_port_links_get(TEST_DEV_ID, 0,
 924                                                 queues, priorities);
 925                 TEST_ASSERT(ret == 2, "(%d)Wrong link get ret=%d expected=%d",
 926                                                 TEST_DEV_ID, ret, 2);
 927                 TEST_ASSERT(queues[0] == 2, "ret=%d expected=%d", ret, 2);
 928                 TEST_ASSERT(priorities[0] == 0x40, "ret=%d expected=%d",
 929                                                         ret, 0x40);
 930                 TEST_ASSERT(queues[1] == 3, "ret=%d expected=%d", ret, 3);
 931                 TEST_ASSERT(priorities[1] == 0x40, "ret=%d expected=%d",
 932                                         ret, 0x40);
 933         }
 934
 935         return TEST_SUCCESS;
 936 }
 937
 938 static int
 939 test_eventdev_close(void)
 940 {
 941         rte_event_dev_stop(TEST_DEV_ID);
 942         return rte_event_dev_close(TEST_DEV_ID);
 943 }
 944
 945 static struct unit_test_suite eventdev_common_testsuite  = {
 946         .suite_name = "eventdev common code unit test suite",
 947         .setup = testsuite_setup,
 948         .teardown = testsuite_teardown,
 949         .unit_test_cases = {
 950                 TEST_CASE_ST(NULL, NULL,
 951                         test_eventdev_count),
 952                 TEST_CASE_ST(NULL, NULL,
 953                         test_eventdev_get_dev_id),
 954                 TEST_CASE_ST(NULL, NULL,
 955                         test_eventdev_socket_id),
 956                 TEST_CASE_ST(NULL, NULL,
 957                         test_eventdev_info_get),
 958                 TEST_CASE_ST(NULL, NULL,
 959                         test_eventdev_configure),
 960                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 961                         test_eventdev_queue_default_conf_get),
 962                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 963                         test_eventdev_queue_setup),
 964                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 965                         test_eventdev_queue_count),
 966                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 967                         test_eventdev_queue_attr_priority),
 968                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 969                         test_eventdev_queue_attr_nb_atomic_flows),
 970                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 971                         test_eventdev_queue_attr_nb_atomic_order_sequences),
 972                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 973                         test_eventdev_queue_attr_event_queue_cfg),
 974                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 975                         test_eventdev_port_default_conf_get),
 976                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 977                         test_eventdev_port_setup),
 978                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 979                         test_eventdev_port_attr_dequeue_depth),
 980                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 981                         test_eventdev_port_attr_enqueue_depth),
 982                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 983                         test_eventdev_port_attr_new_event_threshold),
 984                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 985                         test_eventdev_port_count),
 986                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 987                         test_eventdev_timeout_ticks),
 988                 TEST_CASE_ST(NULL, NULL,
 989                         test_eventdev_start_stop),
 990                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
 991                         test_eventdev_link),
 992                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
 993                         test_eventdev_unlink),
 994                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
 995                         test_eventdev_link_get),
 996                 TEST_CASE_ST(eventdev_setup_device, NULL,
 997                         test_eventdev_close),
 998                 TEST_CASES_END() /**< NULL terminate unit test array */
 999         }
1000 };
1001
1002 static int
1003 test_eventdev_common(void)
1004 {
1005         return unit_test_suite_runner(&eventdev_common_testsuite);
1006 }
1007
1008 REGISTER_TEST_COMMAND(eventdev_common_autotest, test_eventdev_common);