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