test/test/test_eventdev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2016 Cavium, Inc
   3  */
   4
   5 #include <rte_common.h>
   6 #include <rte_hexdump.h>
   7 #include <rte_mbuf.h>
   8 #include <rte_malloc.h>
   9 #include <rte_memcpy.h>
  10 #include <rte_eventdev.h>
  11 #include <rte_dev.h>
  12 #include <rte_bus_vdev.h>
  13
  14 #include "test.h"
  15
  16 #define TEST_DEV_ID   0
  17
  18 static int
  19 testsuite_setup(void)
  20 {
  21         RTE_BUILD_BUG_ON(sizeof(struct rte_event) != 16);
  22         uint8_t count;
  23         count = rte_event_dev_count();
  24         if (!count) {
  25                 printf("Failed to find a valid event device,"
  26                         " testing with event_skeleton device\n");
  27                 return rte_vdev_init("event_skeleton", NULL);
  28         }
  29         return TEST_SUCCESS;
  30 }
  31
  32 static void
  33 testsuite_teardown(void)
  34 {
  35 }
  36
  37 static int
  38 test_eventdev_count(void)
  39 {
  40         uint8_t count;
  41         count = rte_event_dev_count();
  42         TEST_ASSERT(count > 0, "Invalid eventdev count %" PRIu8, count);
  43         return TEST_SUCCESS;
  44 }
  45
  46 static int
  47 test_eventdev_get_dev_id(void)
  48 {
  49         int ret;
  50         ret = rte_event_dev_get_dev_id("not_a_valid_eventdev_driver");
  51         TEST_ASSERT_FAIL(ret, "Expected <0 for invalid dev name ret=%d", ret);
  52         return TEST_SUCCESS;
  53 }
  54
  55 static int
  56 test_eventdev_socket_id(void)
  57 {
  58         int socket_id;
  59         socket_id = rte_event_dev_socket_id(TEST_DEV_ID);
  60         TEST_ASSERT(socket_id != -EINVAL, "Failed to get socket_id %d",
  61                                 socket_id);
  62         socket_id = rte_event_dev_socket_id(RTE_EVENT_MAX_DEVS);
  63         TEST_ASSERT(socket_id == -EINVAL, "Expected -EINVAL %d", socket_id);
  64
  65         return TEST_SUCCESS;
  66 }
  67
  68 static int
  69 test_eventdev_info_get(void)
  70 {
  71         int ret;
  72         struct rte_event_dev_info info;
  73         ret = rte_event_dev_info_get(TEST_DEV_ID, NULL);
  74         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
  75         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
  76         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
  77         TEST_ASSERT(info.max_event_ports > 0,
  78                         "Not enough event ports %d", info.max_event_ports);
  79         TEST_ASSERT(info.max_event_queues > 0,
  80                         "Not enough event queues %d", info.max_event_queues);
  81         return TEST_SUCCESS;
  82 }
  83
  84 static inline void
  85 devconf_set_default_sane_values(struct rte_event_dev_config *dev_conf,
  86                         struct rte_event_dev_info *info)
  87 {
  88         memset(dev_conf, 0, sizeof(struct rte_event_dev_config));
  89         dev_conf->dequeue_timeout_ns = info->min_dequeue_timeout_ns;
  90         dev_conf->nb_event_ports = info->max_event_ports;
  91         dev_conf->nb_event_queues = info->max_event_queues;
  92         dev_conf->nb_event_queue_flows = info->max_event_queue_flows;
  93         dev_conf->nb_event_port_dequeue_depth =
  94                         info->max_event_port_dequeue_depth;
  95         dev_conf->nb_event_port_enqueue_depth =
  96                         info->max_event_port_enqueue_depth;
  97         dev_conf->nb_event_port_enqueue_depth =
  98                         info->max_event_port_enqueue_depth;
  99         dev_conf->nb_events_limit =
 100                         info->max_num_events;
 101 }
 102
 103 static int
 104 test_ethdev_config_run(struct rte_event_dev_config *dev_conf,
 105                 struct rte_event_dev_info *info,
 106                 void (*fn)(struct rte_event_dev_config *dev_conf,
 107                         struct rte_event_dev_info *info))
 108 {
 109         devconf_set_default_sane_values(dev_conf, info);
 110         fn(dev_conf, info);
 111         return rte_event_dev_configure(TEST_DEV_ID, dev_conf);
 112 }
 113
 114 static void
 115 max_dequeue_limit(struct rte_event_dev_config *dev_conf,
 116                   struct rte_event_dev_info *info)
 117 {
 118         dev_conf->dequeue_timeout_ns = info->max_dequeue_timeout_ns + 1;
 119 }
 120
 121 static void
 122 max_events_limit(struct rte_event_dev_config *dev_conf,
 123                   struct rte_event_dev_info *info)
 124 {
 125         dev_conf->nb_events_limit  = info->max_num_events + 1;
 126 }
 127
 128 static void
 129 max_event_ports(struct rte_event_dev_config *dev_conf,
 130                   struct rte_event_dev_info *info)
 131 {
 132         dev_conf->nb_event_ports = info->max_event_ports + 1;
 133 }
 134
 135 static void
 136 max_event_queues(struct rte_event_dev_config *dev_conf,
 137                   struct rte_event_dev_info *info)
 138 {
 139         dev_conf->nb_event_queues = info->max_event_queues + 1;
 140 }
 141
 142 static void
 143 max_event_queue_flows(struct rte_event_dev_config *dev_conf,
 144                   struct rte_event_dev_info *info)
 145 {
 146         dev_conf->nb_event_queue_flows = info->max_event_queue_flows + 1;
 147 }
 148
 149 static void
 150 max_event_port_dequeue_depth(struct rte_event_dev_config *dev_conf,
 151                   struct rte_event_dev_info *info)
 152 {
 153         dev_conf->nb_event_port_dequeue_depth =
 154                 info->max_event_port_dequeue_depth + 1;
 155 }
 156
 157 static void
 158 max_event_port_enqueue_depth(struct rte_event_dev_config *dev_conf,
 159                   struct rte_event_dev_info *info)
 160 {
 161         dev_conf->nb_event_port_enqueue_depth =
 162                 info->max_event_port_enqueue_depth + 1;
 163 }
 164
 165
 166 static int
 167 test_eventdev_configure(void)
 168 {
 169         int ret;
 170         struct rte_event_dev_config dev_conf;
 171         struct rte_event_dev_info info;
 172         ret = rte_event_dev_configure(TEST_DEV_ID, NULL);
 173         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 174
 175         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 176         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 177
 178         /* Check limits */
 179         TEST_ASSERT_EQUAL(-EINVAL,
 180                 test_ethdev_config_run(&dev_conf, &info, max_dequeue_limit),
 181                  "Config negative test failed");
 182         TEST_ASSERT_EQUAL(-EINVAL,
 183                 test_ethdev_config_run(&dev_conf, &info, max_events_limit),
 184                  "Config negative test failed");
 185         TEST_ASSERT_EQUAL(-EINVAL,
 186                 test_ethdev_config_run(&dev_conf, &info, max_event_ports),
 187                  "Config negative test failed");
 188         TEST_ASSERT_EQUAL(-EINVAL,
 189                 test_ethdev_config_run(&dev_conf, &info, max_event_queues),
 190                  "Config negative test failed");
 191         TEST_ASSERT_EQUAL(-EINVAL,
 192                 test_ethdev_config_run(&dev_conf, &info, max_event_queue_flows),
 193                  "Config negative test failed");
 194         TEST_ASSERT_EQUAL(-EINVAL,
 195                 test_ethdev_config_run(&dev_conf, &info,
 196                         max_event_port_dequeue_depth),
 197                          "Config negative test failed");
 198         TEST_ASSERT_EQUAL(-EINVAL,
 199                 test_ethdev_config_run(&dev_conf, &info,
 200                 max_event_port_enqueue_depth),
 201                  "Config negative test failed");
 202
 203         /* Positive case */
 204         devconf_set_default_sane_values(&dev_conf, &info);
 205         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
 206         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 207
 208         /* re-configure */
 209         devconf_set_default_sane_values(&dev_conf, &info);
 210         dev_conf.nb_event_ports = RTE_MAX(info.max_event_ports/2, 1);
 211         dev_conf.nb_event_queues = RTE_MAX(info.max_event_queues/2, 1);
 212         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
 213         TEST_ASSERT_SUCCESS(ret, "Failed to re configure eventdev");
 214
 215         /* re-configure back to max_event_queues and max_event_ports */
 216         devconf_set_default_sane_values(&dev_conf, &info);
 217         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
 218         TEST_ASSERT_SUCCESS(ret, "Failed to re-configure eventdev");
 219
 220         return TEST_SUCCESS;
 221
 222 }
 223
 224 static int
 225 eventdev_configure_setup(void)
 226 {
 227         int ret;
 228         struct rte_event_dev_config dev_conf;
 229         struct rte_event_dev_info info;
 230
 231         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 232         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 233         devconf_set_default_sane_values(&dev_conf, &info);
 234         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
 235         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 236
 237         return TEST_SUCCESS;
 238 }
 239
 240 static int
 241 test_eventdev_queue_default_conf_get(void)
 242 {
 243         int i, ret;
 244         struct rte_event_queue_conf qconf;
 245
 246         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, NULL);
 247         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 248
 249         uint32_t queue_count;
 250         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 251                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 252                             "Queue count get failed");
 253
 254         for (i = 0; i < (int)queue_count; i++) {
 255                 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i,
 256                                                  &qconf);
 257                 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d info", i);
 258         }
 259
 260         return TEST_SUCCESS;
 261 }
 262
 263 static int
 264 test_eventdev_queue_setup(void)
 265 {
 266         int i, ret;
 267         struct rte_event_dev_info info;
 268         struct rte_event_queue_conf qconf;
 269
 270         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 271         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 272
 273         /* Negative cases */
 274         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
 275         TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info");
 276         qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_ALL_TYPES;
 277         qconf.nb_atomic_flows = info.max_event_queue_flows + 1;
 278         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
 279         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 280
 281         qconf.nb_atomic_flows = info.max_event_queue_flows;
 282         qconf.schedule_type = RTE_SCHED_TYPE_ORDERED;
 283         qconf.nb_atomic_order_sequences = info.max_event_queue_flows + 1;
 284         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
 285         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 286
 287         ret = rte_event_queue_setup(TEST_DEV_ID, info.max_event_queues,
 288                                         &qconf);
 289         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 290
 291         /* Positive case */
 292         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
 293         TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info");
 294         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
 295         TEST_ASSERT_SUCCESS(ret, "Failed to setup queue0");
 296
 297         uint32_t queue_count;
 298         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 299                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 300                             "Queue count get failed");
 301
 302         for (i = 0; i < (int)queue_count; i++) {
 303                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
 304                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 305         }
 306
 307         return TEST_SUCCESS;
 308 }
 309
 310 static int
 311 test_eventdev_queue_count(void)
 312 {
 313         int ret;
 314         struct rte_event_dev_info info;
 315
 316         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 317         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 318
 319         uint32_t queue_count;
 320         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 321                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 322                             "Queue count get failed");
 323         TEST_ASSERT_EQUAL(queue_count, info.max_event_queues,
 324                           "Wrong queue count");
 325
 326         return TEST_SUCCESS;
 327 }
 328
 329 static int
 330 test_eventdev_queue_attr_priority(void)
 331 {
 332         int i, ret;
 333         struct rte_event_dev_info info;
 334         struct rte_event_queue_conf qconf;
 335         uint8_t priority;
 336
 337         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 338         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 339
 340         uint32_t queue_count;
 341         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 342                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 343                             "Queue count get failed");
 344
 345         for (i = 0; i < (int)queue_count; i++) {
 346                 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i,
 347                                         &qconf);
 348                 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i);
 349                 qconf.priority = i %  RTE_EVENT_DEV_PRIORITY_LOWEST;
 350                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
 351                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 352         }
 353
 354         for (i = 0; i < (int)queue_count; i++) {
 355                 uint32_t tmp;
 356                 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
 357                                     RTE_EVENT_QUEUE_ATTR_PRIORITY, &tmp),
 358                                     "Queue priority get failed");
 359                 priority = tmp;
 360
 361                 if (info.event_dev_cap & RTE_EVENT_DEV_CAP_QUEUE_QOS)
 362                         TEST_ASSERT_EQUAL(priority,
 363                          i %  RTE_EVENT_DEV_PRIORITY_LOWEST,
 364                          "Wrong priority value for queue%d", i);
 365                 else
 366                         TEST_ASSERT_EQUAL(priority,
 367                          RTE_EVENT_DEV_PRIORITY_NORMAL,
 368                          "Wrong priority value for queue%d", i);
 369         }
 370
 371         return TEST_SUCCESS;
 372 }
 373
 374 static int
 375 test_eventdev_queue_attr_nb_atomic_flows(void)
 376 {
 377         int i, ret;
 378         struct rte_event_dev_info info;
 379         struct rte_event_queue_conf qconf;
 380         uint32_t nb_atomic_flows;
 381
 382         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 383         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 384
 385         uint32_t queue_count;
 386         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 387                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 388                             "Queue count get failed");
 389
 390         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
 391         TEST_ASSERT_SUCCESS(ret, "Failed to get queue 0's def conf");
 392
 393         if (qconf.nb_atomic_flows == 0)
 394                 /* Assume PMD doesn't support atomic flows, return early */
 395                 return -ENOTSUP;
 396
 397         qconf.schedule_type = RTE_SCHED_TYPE_ATOMIC;
 398
 399         for (i = 0; i < (int)queue_count; i++) {
 400                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
 401                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 402         }
 403
 404         for (i = 0; i < (int)queue_count; i++) {
 405                 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
 406                                     RTE_EVENT_QUEUE_ATTR_NB_ATOMIC_FLOWS,
 407                                     &nb_atomic_flows),
 408                                     "Queue nb_atomic_flows get failed");
 409
 410                 TEST_ASSERT_EQUAL(nb_atomic_flows, qconf.nb_atomic_flows,
 411                                   "Wrong atomic flows value for queue%d", i);
 412         }
 413
 414         return TEST_SUCCESS;
 415 }
 416
 417 static int
 418 test_eventdev_queue_attr_nb_atomic_order_sequences(void)
 419 {
 420         int i, ret;
 421         struct rte_event_dev_info info;
 422         struct rte_event_queue_conf qconf;
 423         uint32_t nb_atomic_order_sequences;
 424
 425         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 426         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 427
 428         uint32_t queue_count;
 429         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 430                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 431                             "Queue count get failed");
 432
 433         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
 434         TEST_ASSERT_SUCCESS(ret, "Failed to get queue 0's def conf");
 435
 436         if (qconf.nb_atomic_order_sequences == 0)
 437                 /* Assume PMD doesn't support reordering */
 438                 return -ENOTSUP;
 439
 440         qconf.schedule_type = RTE_SCHED_TYPE_ORDERED;
 441
 442         for (i = 0; i < (int)queue_count; i++) {
 443                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
 444                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 445         }
 446
 447         for (i = 0; i < (int)queue_count; i++) {
 448                 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
 449                             RTE_EVENT_QUEUE_ATTR_NB_ATOMIC_ORDER_SEQUENCES,
 450                             &nb_atomic_order_sequences),
 451                             "Queue nb_atomic_order_sequencess get failed");
 452
 453                 TEST_ASSERT_EQUAL(nb_atomic_order_sequences,
 454                                   qconf.nb_atomic_order_sequences,
 455                                   "Wrong atomic order sequences value for queue%d",
 456                                   i);
 457         }
 458
 459         return TEST_SUCCESS;
 460 }
 461
 462 static int
 463 test_eventdev_queue_attr_event_queue_cfg(void)
 464 {
 465         int i, ret;
 466         struct rte_event_dev_info info;
 467         struct rte_event_queue_conf qconf;
 468         uint32_t event_queue_cfg;
 469
 470         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 471         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 472
 473         uint32_t queue_count;
 474         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 475                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 476                             "Queue count get failed");
 477
 478         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
 479         TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 def conf");
 480
 481         qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
 482
 483         for (i = 0; i < (int)queue_count; i++) {
 484                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
 485                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 486         }
 487
 488         for (i = 0; i < (int)queue_count; i++) {
 489                 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
 490                                     RTE_EVENT_QUEUE_ATTR_EVENT_QUEUE_CFG,
 491                                     &event_queue_cfg),
 492                                     "Queue event_queue_cfg get failed");
 493
 494                 TEST_ASSERT_EQUAL(event_queue_cfg, qconf.event_queue_cfg,
 495                                   "Wrong event_queue_cfg value for queue%d",
 496                                   i);
 497         }
 498
 499         return TEST_SUCCESS;
 500 }
 501
 502 static int
 503 test_eventdev_port_default_conf_get(void)
 504 {
 505         int i, ret;
 506         struct rte_event_port_conf pconf;
 507
 508         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, NULL);
 509         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 510
 511         uint32_t port_count;
 512         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 513                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 514                                 &port_count), "Port count get failed");
 515
 516         ret = rte_event_port_default_conf_get(TEST_DEV_ID,
 517                         port_count + 1, NULL);
 518         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 519
 520         for (i = 0; i < (int)port_count; i++) {
 521                 ret = rte_event_port_default_conf_get(TEST_DEV_ID, i,
 522                                                         &pconf);
 523                 TEST_ASSERT_SUCCESS(ret, "Failed to get port%d info", i);
 524         }
 525
 526         return TEST_SUCCESS;
 527 }
 528
 529 static int
 530 test_eventdev_port_setup(void)
 531 {
 532         int i, ret;
 533         struct rte_event_dev_info info;
 534         struct rte_event_port_conf pconf;
 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         /* Negative cases */
 540         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 541         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 542         pconf.new_event_threshold = info.max_num_events + 1;
 543         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 544         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 545
 546         pconf.new_event_threshold = info.max_num_events;
 547         pconf.dequeue_depth = info.max_event_port_dequeue_depth + 1;
 548         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 549         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 550
 551         pconf.dequeue_depth = info.max_event_port_dequeue_depth;
 552         pconf.enqueue_depth = info.max_event_port_enqueue_depth + 1;
 553         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 554         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 555
 556         ret = rte_event_port_setup(TEST_DEV_ID, info.max_event_ports,
 557                                         &pconf);
 558         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
 559
 560         /* Positive case */
 561         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 562         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 563         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 564         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 565
 566         uint32_t port_count;
 567         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 568                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 569                                 &port_count), "Port count get failed");
 570
 571         for (i = 0; i < (int)port_count; i++) {
 572                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
 573                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
 574         }
 575
 576         return TEST_SUCCESS;
 577 }
 578
 579 static int
 580 test_eventdev_port_attr_dequeue_depth(void)
 581 {
 582         int ret;
 583         struct rte_event_dev_info info;
 584         struct rte_event_port_conf pconf;
 585
 586         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 587         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 588
 589         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 590         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 591         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 592         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 593
 594         uint32_t value;
 595         TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
 596                         RTE_EVENT_PORT_ATTR_DEQ_DEPTH, &value),
 597                         0, "Call to get port dequeue depth failed");
 598         TEST_ASSERT_EQUAL(value, pconf.dequeue_depth,
 599                         "Wrong port dequeue depth");
 600
 601         return TEST_SUCCESS;
 602 }
 603
 604 static int
 605 test_eventdev_port_attr_enqueue_depth(void)
 606 {
 607         int ret;
 608         struct rte_event_dev_info info;
 609         struct rte_event_port_conf pconf;
 610
 611         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 612         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 613
 614         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 615         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 616         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 617         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 618
 619         uint32_t value;
 620         TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
 621                         RTE_EVENT_PORT_ATTR_ENQ_DEPTH, &value),
 622                         0, "Call to get port enqueue depth failed");
 623         TEST_ASSERT_EQUAL(value, pconf.enqueue_depth,
 624                         "Wrong port enqueue depth");
 625
 626         return TEST_SUCCESS;
 627 }
 628
 629 static int
 630 test_eventdev_port_attr_new_event_threshold(void)
 631 {
 632         int ret;
 633         struct rte_event_dev_info info;
 634         struct rte_event_port_conf pconf;
 635
 636         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 637         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 638
 639         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
 640         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
 641         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
 642         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
 643
 644         uint32_t value;
 645         TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
 646                         RTE_EVENT_PORT_ATTR_NEW_EVENT_THRESHOLD, &value),
 647                         0, "Call to get port new event threshold failed");
 648         TEST_ASSERT_EQUAL((int32_t) value, pconf.new_event_threshold,
 649                         "Wrong port new event threshold");
 650
 651         return TEST_SUCCESS;
 652 }
 653
 654 static int
 655 test_eventdev_port_count(void)
 656 {
 657         int ret;
 658         struct rte_event_dev_info info;
 659
 660         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
 661         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
 662
 663         uint32_t port_count;
 664         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 665                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 666                                 &port_count), "Port count get failed");
 667         TEST_ASSERT_EQUAL(port_count, info.max_event_ports, "Wrong port count");
 668
 669         return TEST_SUCCESS;
 670 }
 671
 672 static int
 673 test_eventdev_timeout_ticks(void)
 674 {
 675         int ret;
 676         uint64_t timeout_ticks;
 677
 678         ret = rte_event_dequeue_timeout_ticks(TEST_DEV_ID, 100, &timeout_ticks);
 679         if (ret != -ENOTSUP)
 680                 TEST_ASSERT_SUCCESS(ret, "Fail to get timeout_ticks");
 681
 682         return ret;
 683 }
 684
 685
 686 static int
 687 test_eventdev_start_stop(void)
 688 {
 689         int i, ret;
 690
 691         ret = eventdev_configure_setup();
 692         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 693
 694         uint32_t queue_count;
 695         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 696                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 697                             "Queue count get failed");
 698         for (i = 0; i < (int)queue_count; i++) {
 699                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
 700                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 701         }
 702
 703         uint32_t port_count;
 704         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 705                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 706                                 &port_count), "Port count get failed");
 707
 708         for (i = 0; i < (int)port_count; i++) {
 709                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
 710                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
 711         }
 712
 713         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 714         TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
 715                     TEST_DEV_ID);
 716
 717         ret = rte_event_dev_start(TEST_DEV_ID);
 718         TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
 719
 720         rte_event_dev_stop(TEST_DEV_ID);
 721         return TEST_SUCCESS;
 722 }
 723
 724
 725 static int
 726 eventdev_setup_device(void)
 727 {
 728         int i, ret;
 729
 730         ret = eventdev_configure_setup();
 731         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
 732
 733         uint32_t queue_count;
 734         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 735                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 736                             "Queue count get failed");
 737         for (i = 0; i < (int)queue_count; i++) {
 738                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
 739                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
 740         }
 741
 742         uint32_t port_count;
 743         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 744                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
 745                                 &port_count), "Port count get failed");
 746
 747         for (i = 0; i < (int)port_count; i++) {
 748                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
 749                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
 750         }
 751
 752         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 753         TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
 754                     TEST_DEV_ID);
 755
 756         ret = rte_event_dev_start(TEST_DEV_ID);
 757         TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
 758
 759         return TEST_SUCCESS;
 760 }
 761
 762 static void
 763 eventdev_stop_device(void)
 764 {
 765         rte_event_dev_stop(TEST_DEV_ID);
 766 }
 767
 768 static int
 769 test_eventdev_link(void)
 770 {
 771         int ret, nb_queues, i;
 772         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
 773         uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
 774
 775         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 776         TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
 777                                  TEST_DEV_ID);
 778
 779         uint32_t queue_count;
 780         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
 781                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
 782                             "Queue count get failed");
 783         nb_queues = queue_count;
 784         for (i = 0; i < nb_queues; i++) {
 785                 queues[i] = i;
 786                 priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
 787         }
 788
 789         ret = rte_event_port_link(TEST_DEV_ID, 0, queues,
 790                                         priorities, nb_queues);
 791         TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
 792                                  TEST_DEV_ID, ret);
 793         return TEST_SUCCESS;
 794 }
 795
 796 static int
 797 test_eventdev_unlink(void)
 798 {
 799         int ret, nb_queues, i;
 800         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
 801
 802         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
 803         TEST_ASSERT(ret >= 0, "Failed to unlink 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
 814
 815         ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
 816         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 817                                  TEST_DEV_ID, ret);
 818         return TEST_SUCCESS;
 819 }
 820
 821 static int
 822 test_eventdev_link_get(void)
 823 {
 824         int ret, i;
 825         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
 826         uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
 827
 828         /* link all queues */
 829         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
 830         TEST_ASSERT(ret >= 0, "Failed to link 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         const int nb_queues = queue_count;
 838         for (i = 0; i < nb_queues; i++)
 839                 queues[i] = i;
 840
 841         ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
 842         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 843                                  TEST_DEV_ID, ret);
 844
 845         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
 846         TEST_ASSERT(ret == 0, "(%d)Wrong link get=%d", TEST_DEV_ID, ret);
 847
 848         /* link all queues and get the links */
 849         for (i = 0; i < nb_queues; i++) {
 850                 queues[i] = i;
 851                 priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
 852         }
 853         ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
 854                                          nb_queues);
 855         TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
 856                                  TEST_DEV_ID, ret);
 857         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
 858         TEST_ASSERT(ret == nb_queues, "(%d)Wrong link get ret=%d expected=%d",
 859                                  TEST_DEV_ID, ret, nb_queues);
 860         /* unlink all*/
 861         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
 862         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 863                                  TEST_DEV_ID, ret);
 864         /* link just one queue */
 865         queues[0] = 0;
 866         priorities[0] = RTE_EVENT_DEV_PRIORITY_NORMAL;
 867
 868         ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities, 1);
 869         TEST_ASSERT(ret == 1, "Failed to link(device%d) ret=%d",
 870                                  TEST_DEV_ID, ret);
 871         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
 872         TEST_ASSERT(ret == 1, "(%d)Wrong link get ret=%d expected=%d",
 873                                         TEST_DEV_ID, ret, 1);
 874         /* unlink all*/
 875         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
 876         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
 877                                  TEST_DEV_ID, ret);
 878
 879         /* 4links and 2 unlinks */
 880         if (nb_queues >= 4) {
 881                 for (i = 0; i < 4; i++) {
 882                         queues[i] = i;
 883                         priorities[i] = 0x40;
 884                 }
 885                 ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
 886                                                 4);
 887                 TEST_ASSERT(ret == 4, "Failed to link(device%d) ret=%d",
 888                                          TEST_DEV_ID, ret);
 889
 890                 for (i = 0; i < 2; i++)
 891                         queues[i] = i;
 892
 893                 ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, 2);
 894                 TEST_ASSERT(ret == 2, "Failed to unlink(device%d) ret=%d",
 895                                          TEST_DEV_ID, ret);
 896                 ret = rte_event_port_links_get(TEST_DEV_ID, 0,
 897                                                 queues, priorities);
 898                 TEST_ASSERT(ret == 2, "(%d)Wrong link get ret=%d expected=%d",
 899                                                 TEST_DEV_ID, ret, 2);
 900                 TEST_ASSERT(queues[0] == 2, "ret=%d expected=%d", ret, 2);
 901                 TEST_ASSERT(priorities[0] == 0x40, "ret=%d expected=%d",
 902                                                         ret, 0x40);
 903                 TEST_ASSERT(queues[1] == 3, "ret=%d expected=%d", ret, 3);
 904                 TEST_ASSERT(priorities[1] == 0x40, "ret=%d expected=%d",
 905                                         ret, 0x40);
 906         }
 907
 908         return TEST_SUCCESS;
 909 }
 910
 911 static int
 912 test_eventdev_close(void)
 913 {
 914         rte_event_dev_stop(TEST_DEV_ID);
 915         return rte_event_dev_close(TEST_DEV_ID);
 916 }
 917
 918 static struct unit_test_suite eventdev_common_testsuite  = {
 919         .suite_name = "eventdev common code unit test suite",
 920         .setup = testsuite_setup,
 921         .teardown = testsuite_teardown,
 922         .unit_test_cases = {
 923                 TEST_CASE_ST(NULL, NULL,
 924                         test_eventdev_count),
 925                 TEST_CASE_ST(NULL, NULL,
 926                         test_eventdev_get_dev_id),
 927                 TEST_CASE_ST(NULL, NULL,
 928                         test_eventdev_socket_id),
 929                 TEST_CASE_ST(NULL, NULL,
 930                         test_eventdev_info_get),
 931                 TEST_CASE_ST(NULL, NULL,
 932                         test_eventdev_configure),
 933                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 934                         test_eventdev_queue_default_conf_get),
 935                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 936                         test_eventdev_queue_setup),
 937                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 938                         test_eventdev_queue_count),
 939                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 940                         test_eventdev_queue_attr_priority),
 941                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 942                         test_eventdev_queue_attr_nb_atomic_flows),
 943                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 944                         test_eventdev_queue_attr_nb_atomic_order_sequences),
 945                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 946                         test_eventdev_queue_attr_event_queue_cfg),
 947                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 948                         test_eventdev_port_default_conf_get),
 949                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 950                         test_eventdev_port_setup),
 951                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 952                         test_eventdev_port_attr_dequeue_depth),
 953                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 954                         test_eventdev_port_attr_enqueue_depth),
 955                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 956                         test_eventdev_port_attr_new_event_threshold),
 957                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 958                         test_eventdev_port_count),
 959                 TEST_CASE_ST(eventdev_configure_setup, NULL,
 960                         test_eventdev_timeout_ticks),
 961                 TEST_CASE_ST(NULL, NULL,
 962                         test_eventdev_start_stop),
 963                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
 964                         test_eventdev_link),
 965                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
 966                         test_eventdev_unlink),
 967                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
 968                         test_eventdev_link_get),
 969                 TEST_CASE_ST(eventdev_setup_device, NULL,
 970                         test_eventdev_close),
 971                 TEST_CASES_END() /**< NULL terminate unit test array */
 972         }
 973 };
 974
 975 static int
 976 test_eventdev_common(void)
 977 {
 978         return unit_test_suite_runner(&eventdev_common_testsuite);
 979 }
 980
 981 REGISTER_TEST_COMMAND(eventdev_common_autotest, test_eventdev_common);