app/test/test_event_eth_rx_adapter.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Intel Corporation
   3  */
   4 #include <string.h>
   5 #include <rte_common.h>
   6 #include <rte_mempool.h>
   7 #include <rte_mbuf.h>
   8 #include <rte_ethdev.h>
   9 #include <rte_eventdev.h>
  10 #include <rte_bus_vdev.h>
  11
  12 #include <rte_event_eth_rx_adapter.h>
  13
  14 #include "test.h"
  15
  16 #define MAX_NUM_RX_QUEUE        64
  17 #define NB_MBUFS                (8192 * num_ports * MAX_NUM_RX_QUEUE)
  18 #define MBUF_CACHE_SIZE         512
  19 #define MBUF_PRIV_SIZE          0
  20 #define TEST_INST_ID            0
  21 #define TEST_DEV_ID             0
  22 #define TEST_ETHDEV_ID          0
  23
  24 struct event_eth_rx_adapter_test_params {
  25         struct rte_mempool *mp;
  26         uint16_t rx_rings, tx_rings;
  27         uint32_t caps;
  28         int rx_intr_port_inited;
  29         uint16_t rx_intr_port;
  30 };
  31
  32 static struct event_eth_rx_adapter_test_params default_params;
  33
  34 static inline int
  35 port_init_common(uint16_t port, const struct rte_eth_conf *port_conf,
  36                 struct rte_mempool *mp)
  37 {
  38         const uint16_t rx_ring_size = 512, tx_ring_size = 512;
  39         int retval;
  40         uint16_t q;
  41         struct rte_eth_dev_info dev_info;
  42
  43         if (!rte_eth_dev_is_valid_port(port))
  44                 return -1;
  45
  46         retval = rte_eth_dev_configure(port, 0, 0, port_conf);
  47
  48         rte_eth_dev_info_get(port, &dev_info);
  49
  50         default_params.rx_rings = RTE_MIN(dev_info.max_rx_queues,
  51                                         MAX_NUM_RX_QUEUE);
  52         default_params.tx_rings = 1;
  53
  54         /* Configure the Ethernet device. */
  55         retval = rte_eth_dev_configure(port, default_params.rx_rings,
  56                                 default_params.tx_rings, port_conf);
  57         if (retval != 0)
  58                 return retval;
  59
  60         for (q = 0; q < default_params.rx_rings; q++) {
  61                 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
  62                                 rte_eth_dev_socket_id(port), NULL, mp);
  63                 if (retval < 0)
  64                         return retval;
  65         }
  66
  67         /* Allocate and set up 1 TX queue per Ethernet port. */
  68         for (q = 0; q < default_params.tx_rings; q++) {
  69                 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
  70                                 rte_eth_dev_socket_id(port), NULL);
  71                 if (retval < 0)
  72                         return retval;
  73         }
  74
  75         /* Start the Ethernet port. */
  76         retval = rte_eth_dev_start(port);
  77         if (retval < 0)
  78                 return retval;
  79
  80         /* Display the port MAC address. */
  81         struct rte_ether_addr addr;
  82         rte_eth_macaddr_get(port, &addr);
  83         printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
  84                            " %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\n",
  85                         (unsigned int)port,
  86                         addr.addr_bytes[0], addr.addr_bytes[1],
  87                         addr.addr_bytes[2], addr.addr_bytes[3],
  88                         addr.addr_bytes[4], addr.addr_bytes[5]);
  89
  90         /* Enable RX in promiscuous mode for the Ethernet device. */
  91         rte_eth_promiscuous_enable(port);
  92
  93         return 0;
  94 }
  95
  96 static inline int
  97 port_init_rx_intr(uint16_t port, struct rte_mempool *mp)
  98 {
  99         static const struct rte_eth_conf port_conf_default = {
 100                 .rxmode = {
 101                         .mq_mode = ETH_MQ_RX_NONE,
 102                 },
 103                 .intr_conf = {
 104                         .rxq = 1,
 105                 },
 106         };
 107
 108         return port_init_common(port, &port_conf_default, mp);
 109 }
 110
 111 static inline int
 112 port_init(uint16_t port, struct rte_mempool *mp)
 113 {
 114         static const struct rte_eth_conf port_conf_default = {
 115                 .rxmode = {
 116                         .mq_mode = ETH_MQ_RX_NONE,
 117                 },
 118         };
 119
 120         return port_init_common(port, &port_conf_default, mp);
 121 }
 122
 123 static int
 124 init_port_rx_intr(int num_ports)
 125 {
 126         int retval;
 127         uint16_t portid;
 128         int err;
 129
 130         default_params.mp = rte_pktmbuf_pool_create("packet_pool",
 131                                                    NB_MBUFS,
 132                                                    MBUF_CACHE_SIZE,
 133                                                    MBUF_PRIV_SIZE,
 134                                                    RTE_MBUF_DEFAULT_BUF_SIZE,
 135                                                    rte_socket_id());
 136         if (!default_params.mp)
 137                 return -ENOMEM;
 138
 139         RTE_ETH_FOREACH_DEV(portid) {
 140                 retval = port_init_rx_intr(portid, default_params.mp);
 141                 if (retval)
 142                         continue;
 143                 err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, portid,
 144                                                         &default_params.caps);
 145                 if (err)
 146                         continue;
 147                 if (!(default_params.caps &
 148                         RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT)) {
 149                         default_params.rx_intr_port_inited = 1;
 150                         default_params.rx_intr_port = portid;
 151                         return 0;
 152                 }
 153                 rte_eth_dev_stop(portid);
 154         }
 155         return 0;
 156 }
 157
 158 static int
 159 init_ports(int num_ports)
 160 {
 161         uint16_t portid;
 162         int retval;
 163
 164         struct rte_mempool *ptr = rte_mempool_lookup("packet_pool");
 165
 166         if (ptr == NULL)
 167                 default_params.mp = rte_pktmbuf_pool_create("packet_pool",
 168                                                 NB_MBUFS,
 169                                                 MBUF_CACHE_SIZE,
 170                                                 MBUF_PRIV_SIZE,
 171                                                 RTE_MBUF_DEFAULT_BUF_SIZE,
 172                                                 rte_socket_id());
 173         else
 174                 default_params.mp = ptr;
 175
 176         if (!default_params.mp)
 177                 return -ENOMEM;
 178
 179         RTE_ETH_FOREACH_DEV(portid) {
 180                 retval = port_init(portid, default_params.mp);
 181                 if (retval)
 182                         return retval;
 183         }
 184
 185         return 0;
 186 }
 187
 188 static int
 189 testsuite_setup(void)
 190 {
 191         int err;
 192         uint8_t count;
 193         struct rte_event_dev_info dev_info;
 194
 195         count = rte_event_dev_count();
 196         if (!count) {
 197                 printf("Failed to find a valid event device,"
 198                         " testing with event_skeleton device\n");
 199                 rte_vdev_init("event_skeleton", NULL);
 200         }
 201
 202         struct rte_event_dev_config config = {
 203                         .nb_event_queues = 1,
 204                         .nb_event_ports = 1,
 205         };
 206
 207         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 208         config.nb_event_queue_flows = dev_info.max_event_queue_flows;
 209         config.nb_event_port_dequeue_depth =
 210                         dev_info.max_event_port_dequeue_depth;
 211         config.nb_event_port_enqueue_depth =
 212                         dev_info.max_event_port_enqueue_depth;
 213         config.nb_events_limit =
 214                         dev_info.max_num_events;
 215         err = rte_event_dev_configure(TEST_DEV_ID, &config);
 216         TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
 217                         err);
 218
 219         /*
 220          * eth devices like octeontx use event device to receive packets
 221          * so rte_eth_dev_start invokes rte_event_dev_start internally, so
 222          * call init_ports after rte_event_dev_configure
 223          */
 224         err = init_ports(rte_eth_dev_count_total());
 225         TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
 226
 227         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 228                                                 &default_params.caps);
 229         TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n",
 230                         err);
 231
 232         return err;
 233 }
 234
 235 static int
 236 testsuite_setup_rx_intr(void)
 237 {
 238         int err;
 239         uint8_t count;
 240         struct rte_event_dev_info dev_info;
 241
 242         count = rte_event_dev_count();
 243         if (!count) {
 244                 printf("Failed to find a valid event device,"
 245                         " testing with event_skeleton device\n");
 246                 rte_vdev_init("event_skeleton", NULL);
 247         }
 248
 249         struct rte_event_dev_config config = {
 250                 .nb_event_queues = 1,
 251                 .nb_event_ports = 1,
 252         };
 253
 254         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 255         config.nb_event_queue_flows = dev_info.max_event_queue_flows;
 256         config.nb_event_port_dequeue_depth =
 257                         dev_info.max_event_port_dequeue_depth;
 258         config.nb_event_port_enqueue_depth =
 259                         dev_info.max_event_port_enqueue_depth;
 260         config.nb_events_limit =
 261                         dev_info.max_num_events;
 262
 263         err = rte_event_dev_configure(TEST_DEV_ID, &config);
 264         TEST_ASSERT(err == 0, "Event device initialization failed err %d\n",
 265                         err);
 266
 267         /*
 268          * eth devices like octeontx use event device to receive packets
 269          * so rte_eth_dev_start invokes rte_event_dev_start internally, so
 270          * call init_ports after rte_event_dev_configure
 271          */
 272         err = init_port_rx_intr(rte_eth_dev_count_total());
 273         TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
 274
 275         if (!default_params.rx_intr_port_inited)
 276                 return 0;
 277
 278         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID,
 279                                                 default_params.rx_intr_port,
 280                                                 &default_params.caps);
 281         TEST_ASSERT(err == 0, "Failed to get adapter cap err %d\n", err);
 282
 283         return err;
 284 }
 285
 286 static void
 287 testsuite_teardown(void)
 288 {
 289         uint32_t i;
 290         RTE_ETH_FOREACH_DEV(i)
 291                 rte_eth_dev_stop(i);
 292
 293         rte_mempool_free(default_params.mp);
 294 }
 295
 296 static void
 297 testsuite_teardown_rx_intr(void)
 298 {
 299         if (!default_params.rx_intr_port_inited)
 300                 return;
 301
 302         rte_eth_dev_stop(default_params.rx_intr_port);
 303         rte_mempool_free(default_params.mp);
 304 }
 305
 306 static int
 307 adapter_create(void)
 308 {
 309         int err;
 310         struct rte_event_dev_info dev_info;
 311         struct rte_event_port_conf rx_p_conf;
 312
 313         memset(&rx_p_conf, 0, sizeof(rx_p_conf));
 314
 315         err = rte_event_dev_info_get(TEST_DEV_ID, &dev_info);
 316         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 317
 318         rx_p_conf.new_event_threshold = dev_info.max_num_events;
 319         rx_p_conf.dequeue_depth = dev_info.max_event_port_dequeue_depth;
 320         rx_p_conf.enqueue_depth = dev_info.max_event_port_enqueue_depth;
 321         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 322                                         &rx_p_conf);
 323         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 324
 325         return err;
 326 }
 327
 328 static void
 329 adapter_free(void)
 330 {
 331         rte_event_eth_rx_adapter_free(TEST_INST_ID);
 332 }
 333
 334 static int
 335 adapter_create_free(void)
 336 {
 337         int err;
 338
 339         struct rte_event_port_conf rx_p_conf = {
 340                         .dequeue_depth = 8,
 341                         .enqueue_depth = 8,
 342                         .new_event_threshold = 1200,
 343         };
 344
 345         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 346                                         NULL);
 347         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 348
 349         err = rte_event_eth_rx_adapter_create(TEST_INST_ID, TEST_DEV_ID,
 350                                         &rx_p_conf);
 351         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 352
 353         err = rte_event_eth_rx_adapter_create(TEST_INST_ID,
 354                                         TEST_DEV_ID, &rx_p_conf);
 355         TEST_ASSERT(err == -EEXIST, "Expected -EEXIST %d got %d", -EEXIST, err);
 356
 357         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 358         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 359
 360         err = rte_event_eth_rx_adapter_free(TEST_INST_ID);
 361         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 362
 363         err = rte_event_eth_rx_adapter_free(1);
 364         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL %d got %d", -EINVAL, err);
 365
 366         return TEST_SUCCESS;
 367 }
 368
 369 static int
 370 adapter_queue_add_del(void)
 371 {
 372         int err;
 373         struct rte_event ev;
 374         uint32_t cap;
 375
 376         struct rte_event_eth_rx_adapter_queue_conf queue_config;
 377
 378         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, TEST_ETHDEV_ID,
 379                                          &cap);
 380         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 381
 382         ev.queue_id = 0;
 383         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 384         ev.priority = 0;
 385
 386         queue_config.rx_queue_flags = 0;
 387         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 388                 ev.flow_id = 1;
 389                 queue_config.rx_queue_flags =
 390                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 391         }
 392         queue_config.ev = ev;
 393         queue_config.servicing_weight = 1;
 394
 395         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 396                                                 rte_eth_dev_count_total(),
 397                                                 -1, &queue_config);
 398         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 399
 400         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 401                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 402                                                         TEST_ETHDEV_ID, 0,
 403                                                         &queue_config);
 404                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 405
 406                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 407                                                         TEST_ETHDEV_ID, 0);
 408                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 409
 410                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 411                                                         TEST_ETHDEV_ID,
 412                                                         -1,
 413                                                         &queue_config);
 414                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 415
 416                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 417                                                         TEST_ETHDEV_ID,
 418                                                         -1);
 419                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 420         } else {
 421                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 422                                                         TEST_ETHDEV_ID,
 423                                                         0,
 424                                                         &queue_config);
 425                 TEST_ASSERT(err == -EINVAL, "Expected EINVAL got %d", err);
 426
 427                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 428                                                         TEST_ETHDEV_ID, -1,
 429                                                         &queue_config);
 430                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 431
 432                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 433                                                         TEST_ETHDEV_ID, 0);
 434                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 435
 436                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 437                                                         TEST_ETHDEV_ID, -1);
 438                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 439
 440                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 441                                                         TEST_ETHDEV_ID, -1);
 442                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 443         }
 444
 445         err = rte_event_eth_rx_adapter_queue_add(1, TEST_ETHDEV_ID, -1,
 446                                                 &queue_config);
 447         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 448
 449         err = rte_event_eth_rx_adapter_queue_del(1, TEST_ETHDEV_ID, -1);
 450         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 451
 452         return TEST_SUCCESS;
 453 }
 454
 455 static int
 456 adapter_multi_eth_add_del(void)
 457 {
 458         int err;
 459         struct rte_event ev;
 460
 461         uint16_t port_index, drv_id = 0;
 462         char driver_name[50];
 463
 464         struct rte_event_eth_rx_adapter_queue_conf queue_config;
 465
 466         ev.queue_id = 0;
 467         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 468         ev.priority = 0;
 469
 470         queue_config.rx_queue_flags = 0;
 471         queue_config.ev = ev;
 472         queue_config.servicing_weight = 1;
 473
 474         /* stop eth devices for existing */
 475         port_index = 0;
 476         for (; port_index < rte_eth_dev_count_total(); port_index += 1)
 477                 rte_eth_dev_stop(port_index);
 478
 479         /* add the max port for rx_adapter */
 480         port_index = rte_eth_dev_count_total();
 481         for (; port_index < RTE_MAX_ETHPORTS; port_index += 1) {
 482                 snprintf(driver_name, sizeof(driver_name), "%s%u", "net_null",
 483                                 drv_id);
 484                 err = rte_vdev_init(driver_name, NULL);
 485                 TEST_ASSERT(err == 0, "Failed driver %s got %d",
 486                 driver_name, err);
 487                 drv_id += 1;
 488         }
 489
 490         err = init_ports(rte_eth_dev_count_total());
 491         TEST_ASSERT(err == 0, "Port initialization failed err %d\n", err);
 492
 493         /* eth_rx_adapter_queue_add for n ports */
 494         port_index = 0;
 495         for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
 496                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 497                                 port_index, -1,
 498                                 &queue_config);
 499                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 500         }
 501
 502         /* eth_rx_adapter_queue_del n ports */
 503         port_index = 0;
 504         for (; port_index < rte_eth_dev_count_total(); port_index += 1) {
 505                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 506                                 port_index, -1);
 507                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 508         }
 509
 510         return TEST_SUCCESS;
 511 }
 512
 513 static int
 514 adapter_intr_queue_add_del(void)
 515 {
 516         int err;
 517         struct rte_event ev;
 518         uint32_t cap;
 519         uint16_t eth_port;
 520         struct rte_event_eth_rx_adapter_queue_conf queue_config;
 521
 522         if (!default_params.rx_intr_port_inited)
 523                 return 0;
 524
 525         eth_port = default_params.rx_intr_port;
 526         err = rte_event_eth_rx_adapter_caps_get(TEST_DEV_ID, eth_port, &cap);
 527         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 528
 529         ev.queue_id = 0;
 530         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 531         ev.priority = 0;
 532
 533         queue_config.rx_queue_flags = 0;
 534         queue_config.ev = ev;
 535
 536         /* weight = 0 => interrupt mode */
 537         queue_config.servicing_weight = 0;
 538
 539         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 540                 /* add queue 0 */
 541                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 542                                                         TEST_ETHDEV_ID, 0,
 543                                                         &queue_config);
 544                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 545         }
 546
 547         /* add all queues */
 548         queue_config.servicing_weight = 0;
 549         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 550                                                 TEST_ETHDEV_ID,
 551                                                 -1,
 552                                                 &queue_config);
 553         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 554
 555         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 556                 /* del queue 0 */
 557                 err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 558                                                         TEST_ETHDEV_ID,
 559                                                         0);
 560                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 561         }
 562
 563         /* del remaining queues */
 564         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 565                                                 TEST_ETHDEV_ID,
 566                                                 -1);
 567         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 568
 569         /* add all queues */
 570         queue_config.servicing_weight = 0;
 571         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 572                                                 TEST_ETHDEV_ID,
 573                                                 -1,
 574                                                 &queue_config);
 575         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 576
 577         /* intr -> poll mode queue */
 578         queue_config.servicing_weight = 1;
 579
 580         if (cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ) {
 581                 err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 582                                                         TEST_ETHDEV_ID,
 583                                                         0,
 584                                                         &queue_config);
 585                 TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 586         }
 587
 588         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID,
 589                                                 TEST_ETHDEV_ID,
 590                                                 -1,
 591                                                  &queue_config);
 592         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 593
 594         /* del queues */
 595         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID,
 596                                                 TEST_ETHDEV_ID,
 597                                                 -1);
 598         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 599
 600         return TEST_SUCCESS;
 601 }
 602
 603 static int
 604 adapter_start_stop(void)
 605 {
 606         int err;
 607         struct rte_event ev;
 608
 609         ev.queue_id = 0;
 610         ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
 611         ev.priority = 0;
 612
 613         struct rte_event_eth_rx_adapter_queue_conf queue_config;
 614
 615         queue_config.rx_queue_flags = 0;
 616         if (default_params.caps &
 617                 RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID) {
 618                 ev.flow_id = 1;
 619                 queue_config.rx_queue_flags =
 620                         RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID;
 621         }
 622
 623         queue_config.ev = ev;
 624         queue_config.servicing_weight = 1;
 625
 626         err = rte_event_eth_rx_adapter_queue_add(TEST_INST_ID, TEST_ETHDEV_ID,
 627                                         -1, &queue_config);
 628         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 629
 630         err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
 631         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 632
 633         err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
 634         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 635
 636         err = rte_event_eth_rx_adapter_queue_del(TEST_INST_ID, TEST_ETHDEV_ID,
 637                                                 -1);
 638         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 639
 640         err = rte_event_eth_rx_adapter_start(TEST_INST_ID);
 641         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 642
 643         err = rte_event_eth_rx_adapter_stop(TEST_INST_ID);
 644         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 645
 646         err = rte_event_eth_rx_adapter_start(1);
 647         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 648
 649         err = rte_event_eth_rx_adapter_stop(1);
 650         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 651
 652         return TEST_SUCCESS;
 653 }
 654
 655 static int
 656 adapter_stats(void)
 657 {
 658         int err;
 659         struct rte_event_eth_rx_adapter_stats stats;
 660
 661         err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, NULL);
 662         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 663
 664         err = rte_event_eth_rx_adapter_stats_get(TEST_INST_ID, &stats);
 665         TEST_ASSERT(err == 0, "Expected 0 got %d", err);
 666
 667         err = rte_event_eth_rx_adapter_stats_get(1, &stats);
 668         TEST_ASSERT(err == -EINVAL, "Expected -EINVAL got %d", err);
 669
 670         return TEST_SUCCESS;
 671 }
 672
 673 static struct unit_test_suite event_eth_rx_tests = {
 674         .suite_name = "rx event eth adapter test suite",
 675         .setup = testsuite_setup,
 676         .teardown = testsuite_teardown,
 677         .unit_test_cases = {
 678                 TEST_CASE_ST(NULL, NULL, adapter_create_free),
 679                 TEST_CASE_ST(adapter_create, adapter_free,
 680                                         adapter_queue_add_del),
 681                 TEST_CASE_ST(adapter_create, adapter_free,
 682                                         adapter_multi_eth_add_del),
 683                 TEST_CASE_ST(adapter_create, adapter_free, adapter_start_stop),
 684                 TEST_CASE_ST(adapter_create, adapter_free, adapter_stats),
 685                 TEST_CASES_END() /**< NULL terminate unit test array */
 686         }
 687 };
 688
 689 static struct unit_test_suite event_eth_rx_intr_tests = {
 690         .suite_name = "rx event eth adapter test suite",
 691         .setup = testsuite_setup_rx_intr,
 692         .teardown = testsuite_teardown_rx_intr,
 693         .unit_test_cases = {
 694                 TEST_CASE_ST(adapter_create, adapter_free,
 695                         adapter_intr_queue_add_del),
 696                 TEST_CASES_END() /**< NULL terminate unit test array */
 697         }
 698 };
 699
 700 static int
 701 test_event_eth_rx_adapter_common(void)
 702 {
 703         return unit_test_suite_runner(&event_eth_rx_tests);
 704 }
 705
 706 static int
 707 test_event_eth_rx_intr_adapter_common(void)
 708 {
 709         return unit_test_suite_runner(&event_eth_rx_intr_tests);
 710 }
 711
 712 REGISTER_TEST_COMMAND(event_eth_rx_adapter_autotest,
 713                 test_event_eth_rx_adapter_common);
 714 REGISTER_TEST_COMMAND(event_eth_rx_intr_adapter_autotest,
 715                 test_event_eth_rx_intr_adapter_common);