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