1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright (C) 2020 Marvell International Ltd.
4 #include <rte_bitmap.h>
5 #include <rte_ethdev.h>
6 #include <rte_eventdev.h>
7 #include <rte_event_eth_rx_adapter.h>
8 #include <rte_event_eth_tx_adapter.h>
9 #include <rte_malloc.h>
12 #include "event_helper.h"
15 eh_get_enabled_cores(struct rte_bitmap *eth_core_mask)
19 RTE_LCORE_FOREACH(i) {
20 /* Check if this core is enabled in core mask*/
21 if (rte_bitmap_get(eth_core_mask, i)) {
22 /* Found enabled core */
29 static inline unsigned int
30 eh_get_next_eth_core(struct eventmode_conf *em_conf)
32 static unsigned int prev_core = -1;
33 unsigned int next_core;
36 * Make sure we have at least one eth core running, else the following
37 * logic would lead to an infinite loop.
39 if (eh_get_enabled_cores(em_conf->eth_core_mask) == 0) {
40 EH_LOG_ERR("No enabled eth core found");
44 /* Only some cores are marked as eth cores, skip others */
46 /* Get the next core */
47 next_core = rte_get_next_lcore(prev_core, 0, 1);
49 /* Check if we have reached max lcores */
50 if (next_core == RTE_MAX_LCORE)
53 /* Update prev_core */
54 prev_core = next_core;
55 } while (!(rte_bitmap_get(em_conf->eth_core_mask, next_core)));
60 static inline unsigned int
61 eh_get_next_active_core(struct eventmode_conf *em_conf, unsigned int prev_core)
63 unsigned int next_core;
65 /* Get next active core skipping cores reserved as eth cores */
67 /* Get the next core */
68 next_core = rte_get_next_lcore(prev_core, 0, 0);
70 /* Check if we have reached max lcores */
71 if (next_core == RTE_MAX_LCORE)
74 prev_core = next_core;
75 } while (rte_bitmap_get(em_conf->eth_core_mask, next_core));
80 static struct eventdev_params *
81 eh_get_eventdev_params(struct eventmode_conf *em_conf, uint8_t eventdev_id)
85 for (i = 0; i < em_conf->nb_eventdev; i++) {
86 if (em_conf->eventdev_config[i].eventdev_id == eventdev_id)
91 if (i == em_conf->nb_eventdev)
94 return &(em_conf->eventdev_config[i]);
97 eh_set_default_conf_eventdev(struct eventmode_conf *em_conf)
99 int lcore_count, nb_eventdev, nb_eth_dev, ret;
100 struct eventdev_params *eventdev_config;
101 struct rte_event_dev_info dev_info;
103 /* Get the number of event devices */
104 nb_eventdev = rte_event_dev_count();
105 if (nb_eventdev == 0) {
106 EH_LOG_ERR("No event devices detected");
110 if (nb_eventdev != 1) {
111 EH_LOG_ERR("Event mode does not support multiple event devices. "
112 "Please provide only one event device.");
116 /* Get the number of eth devs */
117 nb_eth_dev = rte_eth_dev_count_avail();
118 if (nb_eth_dev == 0) {
119 EH_LOG_ERR("No eth devices detected");
123 /* Get the number of lcores */
124 lcore_count = rte_lcore_count();
126 /* Read event device info */
127 ret = rte_event_dev_info_get(0, &dev_info);
129 EH_LOG_ERR("Failed to read event device info %d", ret);
133 /* Check if enough ports are available */
134 if (dev_info.max_event_ports < 2) {
135 EH_LOG_ERR("Not enough event ports available");
139 /* Get the first event dev conf */
140 eventdev_config = &(em_conf->eventdev_config[0]);
142 /* Save number of queues & ports available */
143 eventdev_config->eventdev_id = 0;
144 eventdev_config->nb_eventqueue = dev_info.max_event_queues;
145 eventdev_config->nb_eventport = dev_info.max_event_ports;
146 eventdev_config->ev_queue_mode = RTE_EVENT_QUEUE_CFG_ALL_TYPES;
148 /* Check if there are more queues than required */
149 if (eventdev_config->nb_eventqueue > nb_eth_dev + 1) {
150 /* One queue is reserved for Tx */
151 eventdev_config->nb_eventqueue = nb_eth_dev + 1;
154 /* Check if there are more ports than required */
155 if (eventdev_config->nb_eventport > lcore_count) {
156 /* One port per lcore is enough */
157 eventdev_config->nb_eventport = lcore_count;
160 /* Update the number of event devices */
161 em_conf->nb_eventdev++;
167 eh_set_default_conf_link(struct eventmode_conf *em_conf)
169 struct eventdev_params *eventdev_config;
170 struct eh_event_link_info *link;
171 unsigned int lcore_id = -1;
175 * Create a 1:1 mapping from event ports to cores. If the number
176 * of event ports is lesser than the cores, some cores won't
177 * execute worker. If there are more event ports, then some ports
183 * The event queue-port mapping is done according to the link. Since
184 * we are falling back to the default link config, enabling
185 * "all_ev_queue_to_ev_port" mode flag. This will map all queues
188 em_conf->ext_params.all_ev_queue_to_ev_port = 1;
190 /* Get first event dev conf */
191 eventdev_config = &(em_conf->eventdev_config[0]);
193 /* Loop through the ports */
194 for (i = 0; i < eventdev_config->nb_eventport; i++) {
196 /* Get next active core id */
197 lcore_id = eh_get_next_active_core(em_conf,
200 if (lcore_id == RTE_MAX_LCORE) {
201 /* Reached max cores */
205 /* Save the current combination as one link */
208 link_index = em_conf->nb_link;
210 /* Get the corresponding link */
211 link = &(em_conf->link[link_index]);
214 link->eventdev_id = eventdev_config->eventdev_id;
215 link->event_port_id = i;
216 link->lcore_id = lcore_id;
219 * Don't set eventq_id as by default all queues
220 * need to be mapped to the port, which is controlled
221 * by the operating mode.
224 /* Update number of links */
232 eh_set_default_conf_rx_adapter(struct eventmode_conf *em_conf)
234 struct rx_adapter_connection_info *conn;
235 struct eventdev_params *eventdev_config;
236 struct rx_adapter_conf *adapter;
237 bool single_ev_queue = false;
244 /* Create one adapter with eth queues mapped to event queue(s) */
246 if (em_conf->nb_eventdev == 0) {
247 EH_LOG_ERR("No event devs registered");
251 /* Get the number of eth devs */
252 nb_eth_dev = rte_eth_dev_count_avail();
254 /* Use the first event dev */
255 eventdev_config = &(em_conf->eventdev_config[0]);
257 /* Get eventdev ID */
258 eventdev_id = eventdev_config->eventdev_id;
261 /* Get adapter conf */
262 adapter = &(em_conf->rx_adapter[adapter_id]);
264 /* Set adapter conf */
265 adapter->eventdev_id = eventdev_id;
266 adapter->adapter_id = adapter_id;
267 adapter->rx_core_id = eh_get_next_eth_core(em_conf);
270 * Map all queues of eth device (port) to an event queue. If there
271 * are more event queues than eth ports then create 1:1 mapping.
272 * Otherwise map all eth ports to a single event queue.
274 if (nb_eth_dev > eventdev_config->nb_eventqueue)
275 single_ev_queue = true;
277 for (i = 0; i < nb_eth_dev; i++) {
279 /* Use only the ports enabled */
280 if ((em_conf->eth_portmask & (1 << i)) == 0)
283 /* Get the connection id */
284 conn_id = adapter->nb_connections;
286 /* Get the connection */
287 conn = &(adapter->conn[conn_id]);
289 /* Set mapping between eth ports & event queues*/
291 conn->eventq_id = single_ev_queue ? 0 : i;
293 /* Add all eth queues eth port to event queue */
294 conn->ethdev_rx_qid = -1;
296 /* Update no of connections */
297 adapter->nb_connections++;
301 /* We have setup one adapter */
302 em_conf->nb_rx_adapter = 1;
308 eh_set_default_conf_tx_adapter(struct eventmode_conf *em_conf)
310 struct tx_adapter_connection_info *conn;
311 struct eventdev_params *eventdev_config;
312 struct tx_adapter_conf *tx_adapter;
320 * Create one Tx adapter with all eth queues mapped to event queues
324 if (em_conf->nb_eventdev == 0) {
325 EH_LOG_ERR("No event devs registered");
329 /* Get the number of eth devs */
330 nb_eth_dev = rte_eth_dev_count_avail();
332 /* Use the first event dev */
333 eventdev_config = &(em_conf->eventdev_config[0]);
335 /* Get eventdev ID */
336 eventdev_id = eventdev_config->eventdev_id;
339 /* Get adapter conf */
340 tx_adapter = &(em_conf->tx_adapter[adapter_id]);
342 /* Set adapter conf */
343 tx_adapter->eventdev_id = eventdev_id;
344 tx_adapter->adapter_id = adapter_id;
346 /* TODO: Tx core is required only when internal port is not present */
347 tx_adapter->tx_core_id = eh_get_next_eth_core(em_conf);
350 * Application uses one event queue per adapter for submitting
351 * packets for Tx. Reserve the last queue available and decrement
352 * the total available event queues for this
355 /* Queue numbers start at 0 */
356 tx_adapter->tx_ev_queue = eventdev_config->nb_eventqueue - 1;
359 * Map all Tx queues of the eth device (port) to the event device.
362 /* Set defaults for connections */
365 * One eth device (port) is one connection. Map all Tx queues
366 * of the device to the Tx adapter.
369 for (i = 0; i < nb_eth_dev; i++) {
371 /* Use only the ports enabled */
372 if ((em_conf->eth_portmask & (1 << i)) == 0)
375 /* Get the connection id */
376 conn_id = tx_adapter->nb_connections;
378 /* Get the connection */
379 conn = &(tx_adapter->conn[conn_id]);
381 /* Add ethdev to connections */
384 /* Add all eth tx queues to adapter */
385 conn->ethdev_tx_qid = -1;
387 /* Update no of connections */
388 tx_adapter->nb_connections++;
391 /* We have setup one adapter */
392 em_conf->nb_tx_adapter = 1;
397 eh_validate_conf(struct eventmode_conf *em_conf)
402 * Check if event devs are specified. Else probe the event devices
403 * and initialize the config with all ports & queues available
405 if (em_conf->nb_eventdev == 0) {
406 ret = eh_set_default_conf_eventdev(em_conf);
412 * Check if links are specified. Else generate a default config for
413 * the event ports used.
415 if (em_conf->nb_link == 0) {
416 ret = eh_set_default_conf_link(em_conf);
422 * Check if rx adapters are specified. Else generate a default config
423 * with one rx adapter and all eth queues - event queue mapped.
425 if (em_conf->nb_rx_adapter == 0) {
426 ret = eh_set_default_conf_rx_adapter(em_conf);
432 * Check if tx adapters are specified. Else generate a default config
433 * with one tx adapter.
435 if (em_conf->nb_tx_adapter == 0) {
436 ret = eh_set_default_conf_tx_adapter(em_conf);
445 eh_initialize_eventdev(struct eventmode_conf *em_conf)
447 struct rte_event_queue_conf eventq_conf = {0};
448 struct rte_event_dev_info evdev_default_conf;
449 struct rte_event_dev_config eventdev_conf;
450 struct eventdev_params *eventdev_config;
451 int nb_eventdev = em_conf->nb_eventdev;
452 struct eh_event_link_info *link;
453 uint8_t *queue = NULL;
459 for (i = 0; i < nb_eventdev; i++) {
461 /* Get eventdev config */
462 eventdev_config = &(em_conf->eventdev_config[i]);
464 /* Get event dev ID */
465 eventdev_id = eventdev_config->eventdev_id;
467 /* Get the number of queues */
468 nb_eventqueue = eventdev_config->nb_eventqueue;
470 /* Reset the default conf */
471 memset(&evdev_default_conf, 0,
472 sizeof(struct rte_event_dev_info));
474 /* Get default conf of eventdev */
475 ret = rte_event_dev_info_get(eventdev_id, &evdev_default_conf);
478 "Error in getting event device info[devID:%d]",
483 memset(&eventdev_conf, 0, sizeof(struct rte_event_dev_config));
484 eventdev_conf.nb_events_limit =
485 evdev_default_conf.max_num_events;
486 eventdev_conf.nb_event_queues = nb_eventqueue;
487 eventdev_conf.nb_event_ports =
488 eventdev_config->nb_eventport;
489 eventdev_conf.nb_event_queue_flows =
490 evdev_default_conf.max_event_queue_flows;
491 eventdev_conf.nb_event_port_dequeue_depth =
492 evdev_default_conf.max_event_port_dequeue_depth;
493 eventdev_conf.nb_event_port_enqueue_depth =
494 evdev_default_conf.max_event_port_enqueue_depth;
496 /* Configure event device */
497 ret = rte_event_dev_configure(eventdev_id, &eventdev_conf);
499 EH_LOG_ERR("Error in configuring event device");
503 /* Configure event queues */
504 for (j = 0; j < nb_eventqueue; j++) {
506 memset(&eventq_conf, 0,
507 sizeof(struct rte_event_queue_conf));
509 /* Per event dev queues can be ATQ or SINGLE LINK */
510 eventq_conf.event_queue_cfg =
511 eventdev_config->ev_queue_mode;
513 * All queues need to be set with sched_type as
514 * schedule type for the application stage. One queue
515 * would be reserved for the final eth tx stage. This
516 * will be an atomic queue.
518 if (j == nb_eventqueue-1) {
519 eventq_conf.schedule_type =
520 RTE_SCHED_TYPE_ATOMIC;
522 eventq_conf.schedule_type =
523 em_conf->ext_params.sched_type;
526 /* Set max atomic flows to 1024 */
527 eventq_conf.nb_atomic_flows = 1024;
528 eventq_conf.nb_atomic_order_sequences = 1024;
530 /* Setup the queue */
531 ret = rte_event_queue_setup(eventdev_id, j,
534 EH_LOG_ERR("Failed to setup event queue %d",
540 /* Configure event ports */
541 for (j = 0; j < eventdev_config->nb_eventport; j++) {
542 ret = rte_event_port_setup(eventdev_id, j, NULL);
544 EH_LOG_ERR("Failed to setup event port %d",
551 /* Make event queue - event port link */
552 for (j = 0; j < em_conf->nb_link; j++) {
555 link = &(em_conf->link[j]);
557 /* Get event dev ID */
558 eventdev_id = link->eventdev_id;
561 * If "all_ev_queue_to_ev_port" params flag is selected, all
562 * queues need to be mapped to the port.
564 if (em_conf->ext_params.all_ev_queue_to_ev_port)
567 queue = &(link->eventq_id);
569 /* Link queue to port */
570 ret = rte_event_port_link(eventdev_id, link->event_port_id,
573 EH_LOG_ERR("Failed to link event port %d", ret);
578 /* Start event devices */
579 for (i = 0; i < nb_eventdev; i++) {
581 /* Get eventdev config */
582 eventdev_config = &(em_conf->eventdev_config[i]);
584 ret = rte_event_dev_start(eventdev_config->eventdev_id);
586 EH_LOG_ERR("Failed to start event device %d, %d",
595 eh_rx_adapter_configure(struct eventmode_conf *em_conf,
596 struct rx_adapter_conf *adapter)
598 struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0};
599 struct rte_event_dev_info evdev_default_conf = {0};
600 struct rte_event_port_conf port_conf = {0};
601 struct rx_adapter_connection_info *conn;
607 /* Get event dev ID */
608 eventdev_id = adapter->eventdev_id;
610 /* Get default configuration of event dev */
611 ret = rte_event_dev_info_get(eventdev_id, &evdev_default_conf);
613 EH_LOG_ERR("Failed to get event dev info %d", ret);
617 /* Setup port conf */
618 port_conf.new_event_threshold = 1200;
619 port_conf.dequeue_depth =
620 evdev_default_conf.max_event_port_dequeue_depth;
621 port_conf.enqueue_depth =
622 evdev_default_conf.max_event_port_enqueue_depth;
624 /* Create Rx adapter */
625 ret = rte_event_eth_rx_adapter_create(adapter->adapter_id,
626 adapter->eventdev_id, &port_conf);
628 EH_LOG_ERR("Failed to create rx adapter %d", ret);
632 /* Setup various connections in the adapter */
633 for (j = 0; j < adapter->nb_connections; j++) {
635 conn = &(adapter->conn[j]);
637 /* Setup queue conf */
638 queue_conf.ev.queue_id = conn->eventq_id;
639 queue_conf.ev.sched_type = em_conf->ext_params.sched_type;
640 queue_conf.ev.event_type = RTE_EVENT_TYPE_ETHDEV;
642 /* Add queue to the adapter */
643 ret = rte_event_eth_rx_adapter_queue_add(adapter->adapter_id,
644 conn->ethdev_id, conn->ethdev_rx_qid,
647 EH_LOG_ERR("Failed to add eth queue to rx adapter %d",
653 /* Get the service ID used by rx adapter */
654 ret = rte_event_eth_rx_adapter_service_id_get(adapter->adapter_id,
656 if (ret != -ESRCH && ret < 0) {
657 EH_LOG_ERR("Failed to get service id used by rx adapter %d",
662 rte_service_set_runstate_mapped_check(service_id, 0);
665 ret = rte_event_eth_rx_adapter_start(adapter->adapter_id);
667 EH_LOG_ERR("Failed to start rx adapter %d", ret);
675 eh_initialize_rx_adapter(struct eventmode_conf *em_conf)
677 struct rx_adapter_conf *adapter;
680 /* Configure rx adapters */
681 for (i = 0; i < em_conf->nb_rx_adapter; i++) {
682 adapter = &(em_conf->rx_adapter[i]);
683 ret = eh_rx_adapter_configure(em_conf, adapter);
685 EH_LOG_ERR("Failed to configure rx adapter %d", ret);
693 eh_tx_adapter_configure(struct eventmode_conf *em_conf,
694 struct tx_adapter_conf *adapter)
696 struct rte_event_dev_info evdev_default_conf = {0};
697 struct rte_event_port_conf port_conf = {0};
698 struct tx_adapter_connection_info *conn;
699 struct eventdev_params *eventdev_config;
700 uint8_t tx_port_id = 0;
705 /* Get event dev ID */
706 eventdev_id = adapter->eventdev_id;
708 /* Get event device conf */
709 eventdev_config = eh_get_eventdev_params(em_conf, eventdev_id);
711 /* Create Tx adapter */
713 /* Get default configuration of event dev */
714 ret = rte_event_dev_info_get(eventdev_id, &evdev_default_conf);
716 EH_LOG_ERR("Failed to get event dev info %d", ret);
720 /* Setup port conf */
721 port_conf.new_event_threshold =
722 evdev_default_conf.max_num_events;
723 port_conf.dequeue_depth =
724 evdev_default_conf.max_event_port_dequeue_depth;
725 port_conf.enqueue_depth =
726 evdev_default_conf.max_event_port_enqueue_depth;
729 ret = rte_event_eth_tx_adapter_create(adapter->adapter_id,
730 adapter->eventdev_id, &port_conf);
732 EH_LOG_ERR("Failed to create tx adapter %d", ret);
736 /* Setup various connections in the adapter */
737 for (j = 0; j < adapter->nb_connections; j++) {
740 conn = &(adapter->conn[j]);
742 /* Add queue to the adapter */
743 ret = rte_event_eth_tx_adapter_queue_add(adapter->adapter_id,
744 conn->ethdev_id, conn->ethdev_tx_qid);
746 EH_LOG_ERR("Failed to add eth queue to tx adapter %d",
752 /* Setup Tx queue & port */
754 /* Get event port used by the adapter */
755 ret = rte_event_eth_tx_adapter_event_port_get(
756 adapter->adapter_id, &tx_port_id);
758 EH_LOG_ERR("Failed to get tx adapter port id %d", ret);
763 * Tx event queue is reserved for Tx adapter. Unlink this queue
764 * from all other ports
767 for (j = 0; j < eventdev_config->nb_eventport; j++) {
768 rte_event_port_unlink(eventdev_id, j,
769 &(adapter->tx_ev_queue), 1);
772 /* Link Tx event queue to Tx port */
773 ret = rte_event_port_link(eventdev_id, tx_port_id,
774 &(adapter->tx_ev_queue), NULL, 1);
776 EH_LOG_ERR("Failed to link event queue to port");
780 /* Get the service ID used by Tx adapter */
781 ret = rte_event_eth_tx_adapter_service_id_get(adapter->adapter_id,
783 if (ret != -ESRCH && ret < 0) {
784 EH_LOG_ERR("Failed to get service id used by tx adapter %d",
789 rte_service_set_runstate_mapped_check(service_id, 0);
792 ret = rte_event_eth_tx_adapter_start(adapter->adapter_id);
794 EH_LOG_ERR("Failed to start tx adapter %d", ret);
802 eh_initialize_tx_adapter(struct eventmode_conf *em_conf)
804 struct tx_adapter_conf *adapter;
807 /* Configure Tx adapters */
808 for (i = 0; i < em_conf->nb_tx_adapter; i++) {
809 adapter = &(em_conf->tx_adapter[i]);
810 ret = eh_tx_adapter_configure(em_conf, adapter);
812 EH_LOG_ERR("Failed to configure tx adapter %d", ret);
820 eh_display_operating_mode(struct eventmode_conf *em_conf)
822 char sched_types[][32] = {
823 "RTE_SCHED_TYPE_ORDERED",
824 "RTE_SCHED_TYPE_ATOMIC",
825 "RTE_SCHED_TYPE_PARALLEL",
827 EH_LOG_INFO("Operating mode:");
829 EH_LOG_INFO("\tScheduling type: \t%s",
830 sched_types[em_conf->ext_params.sched_type]);
836 eh_display_event_dev_conf(struct eventmode_conf *em_conf)
838 char queue_mode[][32] = {
840 "ATQ (ALL TYPE QUEUE)",
843 char print_buf[256] = { 0 };
846 EH_LOG_INFO("Event Device Configuration:");
848 for (i = 0; i < em_conf->nb_eventdev; i++) {
850 "\tDev ID: %-2d \tQueues: %-2d \tPorts: %-2d",
851 em_conf->eventdev_config[i].eventdev_id,
852 em_conf->eventdev_config[i].nb_eventqueue,
853 em_conf->eventdev_config[i].nb_eventport);
854 sprintf(print_buf + strlen(print_buf),
856 queue_mode[em_conf->eventdev_config[i].ev_queue_mode]);
857 EH_LOG_INFO("%s", print_buf);
863 eh_display_rx_adapter_conf(struct eventmode_conf *em_conf)
865 int nb_rx_adapter = em_conf->nb_rx_adapter;
866 struct rx_adapter_connection_info *conn;
867 struct rx_adapter_conf *adapter;
868 char print_buf[256] = { 0 };
871 EH_LOG_INFO("Rx adapters configured: %d", nb_rx_adapter);
873 for (i = 0; i < nb_rx_adapter; i++) {
874 adapter = &(em_conf->rx_adapter[i]);
876 "\tRx adaper ID: %-2d\tConnections: %-2d\tEvent dev ID: %-2d"
879 adapter->nb_connections,
880 adapter->eventdev_id,
881 adapter->rx_core_id);
883 for (j = 0; j < adapter->nb_connections; j++) {
884 conn = &(adapter->conn[j]);
887 "\t\tEthdev ID: %-2d", conn->ethdev_id);
889 if (conn->ethdev_rx_qid == -1)
890 sprintf(print_buf + strlen(print_buf),
891 "\tEth rx queue: %-2s", "ALL");
893 sprintf(print_buf + strlen(print_buf),
894 "\tEth rx queue: %-2d",
895 conn->ethdev_rx_qid);
897 sprintf(print_buf + strlen(print_buf),
898 "\tEvent queue: %-2d", conn->eventq_id);
899 EH_LOG_INFO("%s", print_buf);
906 eh_display_tx_adapter_conf(struct eventmode_conf *em_conf)
908 int nb_tx_adapter = em_conf->nb_tx_adapter;
909 struct tx_adapter_connection_info *conn;
910 struct tx_adapter_conf *adapter;
911 char print_buf[256] = { 0 };
914 EH_LOG_INFO("Tx adapters configured: %d", nb_tx_adapter);
916 for (i = 0; i < nb_tx_adapter; i++) {
917 adapter = &(em_conf->tx_adapter[i]);
919 "\tTx adapter ID: %-2d\tConnections: %-2d\tEvent dev ID: %-2d",
921 adapter->nb_connections,
922 adapter->eventdev_id);
923 if (adapter->tx_core_id == (uint32_t)-1)
924 sprintf(print_buf + strlen(print_buf),
925 "\tTx core: %-2s", "[INTERNAL PORT]");
926 else if (adapter->tx_core_id == RTE_MAX_LCORE)
927 sprintf(print_buf + strlen(print_buf),
928 "\tTx core: %-2s", "[NONE]");
930 sprintf(print_buf + strlen(print_buf),
931 "\tTx core: %-2d,\tInput event queue: %-2d",
932 adapter->tx_core_id, adapter->tx_ev_queue);
934 EH_LOG_INFO("%s", print_buf);
936 for (j = 0; j < adapter->nb_connections; j++) {
937 conn = &(adapter->conn[j]);
940 "\t\tEthdev ID: %-2d", conn->ethdev_id);
942 if (conn->ethdev_tx_qid == -1)
943 sprintf(print_buf + strlen(print_buf),
944 "\tEth tx queue: %-2s", "ALL");
946 sprintf(print_buf + strlen(print_buf),
947 "\tEth tx queue: %-2d",
948 conn->ethdev_tx_qid);
949 EH_LOG_INFO("%s", print_buf);
956 eh_display_link_conf(struct eventmode_conf *em_conf)
958 struct eh_event_link_info *link;
959 char print_buf[256] = { 0 };
962 EH_LOG_INFO("Links configured: %d", em_conf->nb_link);
964 for (i = 0; i < em_conf->nb_link; i++) {
965 link = &(em_conf->link[i]);
968 "\tEvent dev ID: %-2d\tEvent port: %-2d",
970 link->event_port_id);
972 if (em_conf->ext_params.all_ev_queue_to_ev_port)
973 sprintf(print_buf + strlen(print_buf),
974 "Event queue: %-2s\t", "ALL");
976 sprintf(print_buf + strlen(print_buf),
977 "Event queue: %-2d\t", link->eventq_id);
979 sprintf(print_buf + strlen(print_buf),
980 "Lcore: %-2d", link->lcore_id);
981 EH_LOG_INFO("%s", print_buf);
987 eh_display_conf(struct eh_conf *conf)
989 struct eventmode_conf *em_conf;
992 EH_LOG_ERR("Invalid event helper configuration");
996 if (conf->mode != EH_PKT_TRANSFER_MODE_EVENT)
999 if (conf->mode_params == NULL) {
1000 EH_LOG_ERR("Invalid event mode parameters");
1004 /* Get eventmode conf */
1005 em_conf = (struct eventmode_conf *)(conf->mode_params);
1007 /* Display user exposed operating modes */
1008 eh_display_operating_mode(em_conf);
1010 /* Display event device conf */
1011 eh_display_event_dev_conf(em_conf);
1013 /* Display Rx adapter conf */
1014 eh_display_rx_adapter_conf(em_conf);
1016 /* Display Tx adapter conf */
1017 eh_display_tx_adapter_conf(em_conf);
1019 /* Display event-lcore link */
1020 eh_display_link_conf(em_conf);
1024 eh_devs_init(struct eh_conf *conf)
1026 struct eventmode_conf *em_conf;
1031 EH_LOG_ERR("Invalid event helper configuration");
1035 if (conf->mode != EH_PKT_TRANSFER_MODE_EVENT)
1038 if (conf->mode_params == NULL) {
1039 EH_LOG_ERR("Invalid event mode parameters");
1043 /* Get eventmode conf */
1044 em_conf = conf->mode_params;
1046 /* Eventmode conf would need eth portmask */
1047 em_conf->eth_portmask = conf->eth_portmask;
1049 /* Validate the requested config */
1050 ret = eh_validate_conf(em_conf);
1052 EH_LOG_ERR("Failed to validate the requested config %d", ret);
1056 /* Display the current configuration */
1057 eh_display_conf(conf);
1059 /* Stop eth devices before setting up adapter */
1060 RTE_ETH_FOREACH_DEV(port_id) {
1062 /* Use only the ports enabled */
1063 if ((conf->eth_portmask & (1 << port_id)) == 0)
1066 rte_eth_dev_stop(port_id);
1069 /* Setup eventdev */
1070 ret = eh_initialize_eventdev(em_conf);
1072 EH_LOG_ERR("Failed to initialize event dev %d", ret);
1076 /* Setup Rx adapter */
1077 ret = eh_initialize_rx_adapter(em_conf);
1079 EH_LOG_ERR("Failed to initialize rx adapter %d", ret);
1083 /* Setup Tx adapter */
1084 ret = eh_initialize_tx_adapter(em_conf);
1086 EH_LOG_ERR("Failed to initialize tx adapter %d", ret);
1090 /* Start eth devices after setting up adapter */
1091 RTE_ETH_FOREACH_DEV(port_id) {
1093 /* Use only the ports enabled */
1094 if ((conf->eth_portmask & (1 << port_id)) == 0)
1097 ret = rte_eth_dev_start(port_id);
1099 EH_LOG_ERR("Failed to start eth dev %d, %d",
1109 eh_devs_uninit(struct eh_conf *conf)
1111 struct eventmode_conf *em_conf;
1116 EH_LOG_ERR("Invalid event helper configuration");
1120 if (conf->mode != EH_PKT_TRANSFER_MODE_EVENT)
1123 if (conf->mode_params == NULL) {
1124 EH_LOG_ERR("Invalid event mode parameters");
1128 /* Get eventmode conf */
1129 em_conf = conf->mode_params;
1131 /* Stop and release rx adapters */
1132 for (i = 0; i < em_conf->nb_rx_adapter; i++) {
1134 id = em_conf->rx_adapter[i].adapter_id;
1135 ret = rte_event_eth_rx_adapter_stop(id);
1137 EH_LOG_ERR("Failed to stop rx adapter %d", ret);
1141 for (j = 0; j < em_conf->rx_adapter[i].nb_connections; j++) {
1143 ret = rte_event_eth_rx_adapter_queue_del(id,
1144 em_conf->rx_adapter[i].conn[j].ethdev_id, -1);
1147 "Failed to remove rx adapter queues %d",
1153 ret = rte_event_eth_rx_adapter_free(id);
1155 EH_LOG_ERR("Failed to free rx adapter %d", ret);
1160 /* Stop and release event devices */
1161 for (i = 0; i < em_conf->nb_eventdev; i++) {
1163 id = em_conf->eventdev_config[i].eventdev_id;
1164 rte_event_dev_stop(id);
1166 ret = rte_event_dev_close(id);
1168 EH_LOG_ERR("Failed to close event dev %d, %d", id, ret);
1173 /* Stop and release tx adapters */
1174 for (i = 0; i < em_conf->nb_tx_adapter; i++) {
1176 id = em_conf->tx_adapter[i].adapter_id;
1177 ret = rte_event_eth_tx_adapter_stop(id);
1179 EH_LOG_ERR("Failed to stop tx adapter %d", ret);
1183 for (j = 0; j < em_conf->tx_adapter[i].nb_connections; j++) {
1185 ret = rte_event_eth_tx_adapter_queue_del(id,
1186 em_conf->tx_adapter[i].conn[j].ethdev_id, -1);
1189 "Failed to remove tx adapter queues %d",
1195 ret = rte_event_eth_tx_adapter_free(id);
1197 EH_LOG_ERR("Failed to free tx adapter %d", ret);
1206 eh_get_tx_queue(struct eh_conf *conf, uint8_t eventdev_id)
1208 struct eventdev_params *eventdev_config;
1209 struct eventmode_conf *em_conf;
1212 EH_LOG_ERR("Invalid event helper configuration");
1216 if (conf->mode_params == NULL) {
1217 EH_LOG_ERR("Invalid event mode parameters");
1221 /* Get eventmode conf */
1222 em_conf = conf->mode_params;
1224 /* Get event device conf */
1225 eventdev_config = eh_get_eventdev_params(em_conf, eventdev_id);
1227 if (eventdev_config == NULL) {
1228 EH_LOG_ERR("Failed to read eventdev config");
1233 * The last queue is reserved to be used as atomic queue for the
1234 * last stage (eth packet tx stage)
1236 return eventdev_config->nb_eventqueue - 1;