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