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