1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(C) 2019 Marvell International Ltd.
3 */
4
5 #include <stdbool.h>
6 #include <getopt.h>
7
8 #include <rte_cycles.h>
9 #include <rte_ethdev.h>
10 #include <rte_eventdev.h>
11 #include <rte_event_eth_rx_adapter.h>
12 #include <rte_event_eth_tx_adapter.h>
13 #include <rte_lcore.h>
14 #include <rte_malloc.h>
15 #include <rte_spinlock.h>
16
17 #include "l2fwd_event.h"
18
19 #define L2FWD_EVENT_SINGLE 0x1
20 #define L2FWD_EVENT_BURST 0x2
21 #define L2FWD_EVENT_TX_DIRECT 0x4
22 #define L2FWD_EVENT_TX_ENQ 0x8
23 #define L2FWD_EVENT_UPDT_MAC 0x10
24
25 static inline int
l2fwd_event_service_enable(uint32_t service_id)26 l2fwd_event_service_enable(uint32_t service_id)
27 {
28 uint8_t min_service_count = UINT8_MAX;
29 uint32_t slcore_array[RTE_MAX_LCORE];
30 unsigned int slcore = 0;
31 uint8_t service_count;
32 int32_t slcore_count;
33
34 if (!rte_service_lcore_count())
35 return -ENOENT;
36
37 slcore_count = rte_service_lcore_list(slcore_array, RTE_MAX_LCORE);
38 if (slcore_count < 0)
39 return -ENOENT;
40 /* Get the core which has least number of services running. */
41 while (slcore_count--) {
42 /* Reset default mapping */
43 if (rte_service_map_lcore_set(service_id,
44 slcore_array[slcore_count], 0) != 0)
45 return -ENOENT;
46 service_count = rte_service_lcore_count_services(
47 slcore_array[slcore_count]);
48 if (service_count < min_service_count) {
49 slcore = slcore_array[slcore_count];
50 min_service_count = service_count;
51 }
52 }
53 if (rte_service_map_lcore_set(service_id, slcore, 1) != 0)
54 return -ENOENT;
55 rte_service_lcore_start(slcore);
56
57 return 0;
58 }
59
60 void
l2fwd_event_service_setup(struct l2fwd_resources * rsrc)61 l2fwd_event_service_setup(struct l2fwd_resources *rsrc)
62 {
63 struct l2fwd_event_resources *evt_rsrc = rsrc->evt_rsrc;
64 struct rte_event_dev_info evdev_info;
65 uint32_t service_id, caps;
66 int ret, i;
67
68 /* Running eventdev scheduler service on service core. 8< */
69 rte_event_dev_info_get(evt_rsrc->event_d_id, &evdev_info);
70 if (!(evdev_info.event_dev_cap & RTE_EVENT_DEV_CAP_DISTRIBUTED_SCHED)) {
71 ret = rte_event_dev_service_id_get(evt_rsrc->event_d_id,
72 &service_id);
73 if (ret != -ESRCH && ret != 0)
74 rte_panic("Error in starting eventdev service\n");
75 l2fwd_event_service_enable(service_id);
76 }
77 /* >8 End of running eventdev scheduler service on service core. */
78
79 /* Gets service ID for RX/TX adapters. 8< */
80 for (i = 0; i < evt_rsrc->rx_adptr.nb_rx_adptr; i++) {
81 ret = rte_event_eth_rx_adapter_caps_get(evt_rsrc->event_d_id,
82 evt_rsrc->rx_adptr.rx_adptr[i], &caps);
83 if (ret < 0)
84 rte_panic("Failed to get Rx adapter[%d] caps\n",
85 evt_rsrc->rx_adptr.rx_adptr[i]);
86 ret = rte_event_eth_rx_adapter_service_id_get(
87 evt_rsrc->event_d_id,
88 &service_id);
89 if (ret != -ESRCH && ret != 0)
90 rte_panic("Error in starting Rx adapter[%d] service\n",
91 evt_rsrc->rx_adptr.rx_adptr[i]);
92 l2fwd_event_service_enable(service_id);
93 }
94
95 for (i = 0; i < evt_rsrc->tx_adptr.nb_tx_adptr; i++) {
96 ret = rte_event_eth_tx_adapter_caps_get(evt_rsrc->event_d_id,
97 evt_rsrc->tx_adptr.tx_adptr[i], &caps);
98 if (ret < 0)
99 rte_panic("Failed to get Rx adapter[%d] caps\n",
100 evt_rsrc->tx_adptr.tx_adptr[i]);
101 ret = rte_event_eth_tx_adapter_service_id_get(
102 evt_rsrc->event_d_id,
103 &service_id);
104 if (ret != -ESRCH && ret != 0)
105 rte_panic("Error in starting Rx adapter[%d] service\n",
106 evt_rsrc->tx_adptr.tx_adptr[i]);
107 l2fwd_event_service_enable(service_id);
108 }
109 /* >8 End of get service ID for RX/TX adapters. */
110 }
111
112 static void
l2fwd_event_capability_setup(struct l2fwd_event_resources * evt_rsrc)113 l2fwd_event_capability_setup(struct l2fwd_event_resources *evt_rsrc)
114 {
115 uint32_t caps = 0;
116 uint16_t i;
117 int ret;
118
119 RTE_ETH_FOREACH_DEV(i) {
120 ret = rte_event_eth_tx_adapter_caps_get(0, i, &caps);
121 if (ret)
122 rte_panic("Invalid capability for Tx adptr port %d\n",
123 i);
124
125 evt_rsrc->tx_mode_q |= !(caps &
126 RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT);
127 }
128
129 if (evt_rsrc->tx_mode_q)
130 l2fwd_event_set_generic_ops(&evt_rsrc->ops);
131 else
132 l2fwd_event_set_internal_port_ops(&evt_rsrc->ops);
133 }
134
135 static __rte_noinline int
l2fwd_get_free_event_port(struct l2fwd_event_resources * evt_rsrc)136 l2fwd_get_free_event_port(struct l2fwd_event_resources *evt_rsrc)
137 {
138 static int index;
139 int port_id;
140
141 rte_spinlock_lock(&evt_rsrc->evp.lock);
142 if (index >= evt_rsrc->evp.nb_ports) {
143 printf("No free event port is available\n");
144 return -1;
145 }
146
147 port_id = evt_rsrc->evp.event_p_id[index];
148 index++;
149 rte_spinlock_unlock(&evt_rsrc->evp.lock);
150
151 return port_id;
152 }
153
154 static __rte_always_inline void
l2fwd_event_fwd(struct l2fwd_resources * rsrc,struct rte_event * ev,const uint8_t tx_q_id,const uint64_t timer_period,const uint32_t flags)155 l2fwd_event_fwd(struct l2fwd_resources *rsrc, struct rte_event *ev,
156 const uint8_t tx_q_id, const uint64_t timer_period,
157 const uint32_t flags)
158 {
159 struct rte_mbuf *mbuf = ev->mbuf;
160 uint16_t dst_port;
161
162 rte_prefetch0(rte_pktmbuf_mtod(mbuf, void *));
163 dst_port = rsrc->dst_ports[mbuf->port];
164
165 if (timer_period > 0)
166 __atomic_fetch_add(&rsrc->port_stats[mbuf->port].rx,
167 1, __ATOMIC_RELAXED);
168 mbuf->port = dst_port;
169
170 if (flags & L2FWD_EVENT_UPDT_MAC)
171 l2fwd_mac_updating(mbuf, dst_port, &rsrc->eth_addr[dst_port]);
172
173 if (flags & L2FWD_EVENT_TX_ENQ) {
174 ev->queue_id = tx_q_id;
175 ev->op = RTE_EVENT_OP_FORWARD;
176 }
177
178 if (flags & L2FWD_EVENT_TX_DIRECT)
179 rte_event_eth_tx_adapter_txq_set(mbuf, 0);
180
181 if (timer_period > 0)
182 __atomic_fetch_add(&rsrc->port_stats[mbuf->port].tx,
183 1, __ATOMIC_RELAXED);
184 }
185
186 static __rte_always_inline void
l2fwd_event_loop_single(struct l2fwd_resources * rsrc,const uint32_t flags)187 l2fwd_event_loop_single(struct l2fwd_resources *rsrc,
188 const uint32_t flags)
189 {
190 struct l2fwd_event_resources *evt_rsrc = rsrc->evt_rsrc;
191 const int port_id = l2fwd_get_free_event_port(evt_rsrc);
192 const uint8_t tx_q_id = evt_rsrc->evq.event_q_id[
193 evt_rsrc->evq.nb_queues - 1];
194 const uint64_t timer_period = rsrc->timer_period;
195 const uint8_t event_d_id = evt_rsrc->event_d_id;
196 uint8_t enq = 0, deq = 0;
197 struct rte_event ev;
198
199 if (port_id < 0)
200 return;
201
202 printf("%s(): entering eventdev main loop on lcore %u\n", __func__,
203 rte_lcore_id());
204
205 while (!rsrc->force_quit) {
206 /* Read packet from eventdev */
207 deq = rte_event_dequeue_burst(event_d_id, port_id, &ev, 1, 0);
208 if (!deq)
209 continue;
210
211 l2fwd_event_fwd(rsrc, &ev, tx_q_id, timer_period, flags);
212
213 if (flags & L2FWD_EVENT_TX_ENQ) {
214 do {
215 enq = rte_event_enqueue_burst(event_d_id,
216 port_id, &ev, 1);
217 } while (!enq && !rsrc->force_quit);
218 }
219
220 if (flags & L2FWD_EVENT_TX_DIRECT) {
221 do {
222 enq = rte_event_eth_tx_adapter_enqueue(
223 event_d_id, port_id, &ev, 1, 0);
224 } while (!enq && !rsrc->force_quit);
225 }
226 }
227
228 l2fwd_event_worker_cleanup(event_d_id, port_id, &ev, enq, deq, 0);
229 }
230
231 static __rte_always_inline void
l2fwd_event_loop_burst(struct l2fwd_resources * rsrc,const uint32_t flags)232 l2fwd_event_loop_burst(struct l2fwd_resources *rsrc,
233 const uint32_t flags)
234 {
235 struct l2fwd_event_resources *evt_rsrc = rsrc->evt_rsrc;
236 const int port_id = l2fwd_get_free_event_port(evt_rsrc);
237 const uint8_t tx_q_id = evt_rsrc->evq.event_q_id[
238 evt_rsrc->evq.nb_queues - 1];
239 const uint64_t timer_period = rsrc->timer_period;
240 const uint8_t event_d_id = evt_rsrc->event_d_id;
241 const uint8_t deq_len = evt_rsrc->deq_depth;
242 struct rte_event ev[MAX_PKT_BURST];
243 uint16_t nb_rx = 0, nb_tx = 0;
244 uint8_t i;
245
246 if (port_id < 0)
247 return;
248
249 printf("%s(): entering eventdev main loop on lcore %u\n", __func__,
250 rte_lcore_id());
251
252 while (!rsrc->force_quit) {
253 /* Read packet from eventdev. 8< */
254 nb_rx = rte_event_dequeue_burst(event_d_id, port_id, ev,
255 deq_len, 0);
256 if (nb_rx == 0)
257 continue;
258
259 for (i = 0; i < nb_rx; i++) {
260 l2fwd_event_fwd(rsrc, &ev[i], tx_q_id, timer_period,
261 flags);
262 }
263 /* >8 End of reading packets from eventdev. */
264
265 if (flags & L2FWD_EVENT_TX_ENQ) {
266 /* Forwarding to destination ports. 8< */
267 nb_tx = rte_event_enqueue_burst(event_d_id, port_id,
268 ev, nb_rx);
269 while (nb_tx < nb_rx && !rsrc->force_quit)
270 nb_tx += rte_event_enqueue_burst(event_d_id,
271 port_id, ev + nb_tx,
272 nb_rx - nb_tx);
273 /* >8 End of forwarding to destination ports. */
274 }
275
276 if (flags & L2FWD_EVENT_TX_DIRECT) {
277 nb_tx = rte_event_eth_tx_adapter_enqueue(event_d_id,
278 port_id, ev,
279 nb_rx, 0);
280 while (nb_tx < nb_rx && !rsrc->force_quit)
281 nb_tx += rte_event_eth_tx_adapter_enqueue(
282 event_d_id, port_id,
283 ev + nb_tx, nb_rx - nb_tx, 0);
284 }
285 }
286
287 l2fwd_event_worker_cleanup(event_d_id, port_id, ev, nb_rx, nb_tx, 0);
288 }
289
290 static __rte_always_inline void
l2fwd_event_loop(struct l2fwd_resources * rsrc,const uint32_t flags)291 l2fwd_event_loop(struct l2fwd_resources *rsrc,
292 const uint32_t flags)
293 {
294 if (flags & L2FWD_EVENT_SINGLE)
295 l2fwd_event_loop_single(rsrc, flags);
296 if (flags & L2FWD_EVENT_BURST)
297 l2fwd_event_loop_burst(rsrc, flags);
298 }
299
300 static void __rte_noinline
l2fwd_event_main_loop_tx_d(struct l2fwd_resources * rsrc)301 l2fwd_event_main_loop_tx_d(struct l2fwd_resources *rsrc)
302 {
303 l2fwd_event_loop(rsrc,
304 L2FWD_EVENT_TX_DIRECT | L2FWD_EVENT_SINGLE);
305 }
306
307 static void __rte_noinline
l2fwd_event_main_loop_tx_d_brst(struct l2fwd_resources * rsrc)308 l2fwd_event_main_loop_tx_d_brst(struct l2fwd_resources *rsrc)
309 {
310 l2fwd_event_loop(rsrc, L2FWD_EVENT_TX_DIRECT | L2FWD_EVENT_BURST);
311 }
312
313 static void __rte_noinline
l2fwd_event_main_loop_tx_q(struct l2fwd_resources * rsrc)314 l2fwd_event_main_loop_tx_q(struct l2fwd_resources *rsrc)
315 {
316 l2fwd_event_loop(rsrc, L2FWD_EVENT_TX_ENQ | L2FWD_EVENT_SINGLE);
317 }
318
319 static void __rte_noinline
l2fwd_event_main_loop_tx_q_brst(struct l2fwd_resources * rsrc)320 l2fwd_event_main_loop_tx_q_brst(struct l2fwd_resources *rsrc)
321 {
322 l2fwd_event_loop(rsrc, L2FWD_EVENT_TX_ENQ | L2FWD_EVENT_BURST);
323 }
324
325 static void __rte_noinline
l2fwd_event_main_loop_tx_d_mac(struct l2fwd_resources * rsrc)326 l2fwd_event_main_loop_tx_d_mac(struct l2fwd_resources *rsrc)
327 {
328 l2fwd_event_loop(rsrc, L2FWD_EVENT_UPDT_MAC |
329 L2FWD_EVENT_TX_DIRECT | L2FWD_EVENT_SINGLE);
330 }
331
332 static void __rte_noinline
l2fwd_event_main_loop_tx_d_brst_mac(struct l2fwd_resources * rsrc)333 l2fwd_event_main_loop_tx_d_brst_mac(struct l2fwd_resources *rsrc)
334 {
335 l2fwd_event_loop(rsrc, L2FWD_EVENT_UPDT_MAC |
336 L2FWD_EVENT_TX_DIRECT | L2FWD_EVENT_BURST);
337 }
338
339 static void __rte_noinline
l2fwd_event_main_loop_tx_q_mac(struct l2fwd_resources * rsrc)340 l2fwd_event_main_loop_tx_q_mac(struct l2fwd_resources *rsrc)
341 {
342 l2fwd_event_loop(rsrc, L2FWD_EVENT_UPDT_MAC |
343 L2FWD_EVENT_TX_ENQ | L2FWD_EVENT_SINGLE);
344 }
345
346 static void __rte_noinline
l2fwd_event_main_loop_tx_q_brst_mac(struct l2fwd_resources * rsrc)347 l2fwd_event_main_loop_tx_q_brst_mac(struct l2fwd_resources *rsrc)
348 {
349 l2fwd_event_loop(rsrc, L2FWD_EVENT_UPDT_MAC |
350 L2FWD_EVENT_TX_ENQ | L2FWD_EVENT_BURST);
351 }
352
353 static __rte_always_inline void
l2fwd_event_vector_fwd(struct l2fwd_resources * rsrc,struct rte_event_vector * vec,const uint64_t timer_period,const uint32_t flags)354 l2fwd_event_vector_fwd(struct l2fwd_resources *rsrc,
355 struct rte_event_vector *vec,
356 const uint64_t timer_period, const uint32_t flags)
357 {
358 struct rte_mbuf **mbufs = vec->mbufs;
359 uint16_t i, j;
360
361 rte_prefetch0(rte_pktmbuf_mtod(mbufs[0], void *));
362
363 /* If vector attribute is valid, mbufs will be from same port/queue */
364 if (vec->attr_valid) {
365 vec->port = rsrc->dst_ports[mbufs[0]->port];
366 if (flags & L2FWD_EVENT_TX_DIRECT)
367 vec->queue = 0;
368
369 if (timer_period > 0)
370 __atomic_fetch_add(&rsrc->port_stats[mbufs[0]->port].rx,
371 vec->nb_elem, __ATOMIC_RELAXED);
372
373 for (i = 0, j = 1; i < vec->nb_elem; i++, j++) {
374 if (j < vec->nb_elem)
375 rte_prefetch0(
376 rte_pktmbuf_mtod(mbufs[j], void *));
377
378 if (flags & L2FWD_EVENT_UPDT_MAC)
379 l2fwd_mac_updating(
380 mbufs[i], vec->port,
381 &rsrc->eth_addr[vec->port]);
382 }
383
384 if (timer_period > 0)
385 __atomic_fetch_add(&rsrc->port_stats[vec->port].tx,
386 vec->nb_elem, __ATOMIC_RELAXED);
387 } else {
388 for (i = 0, j = 1; i < vec->nb_elem; i++, j++) {
389 if (timer_period > 0)
390 __atomic_fetch_add(
391 &rsrc->port_stats[mbufs[i]->port].rx, 1,
392 __ATOMIC_RELAXED);
393
394 if (j < vec->nb_elem)
395 rte_prefetch0(
396 rte_pktmbuf_mtod(mbufs[j], void *));
397
398 mbufs[i]->port = rsrc->dst_ports[mbufs[i]->port];
399
400 if (flags & L2FWD_EVENT_UPDT_MAC)
401 l2fwd_mac_updating(
402 mbufs[i], mbufs[i]->port,
403 &rsrc->eth_addr[mbufs[i]->port]);
404
405 if (flags & L2FWD_EVENT_TX_DIRECT)
406 rte_event_eth_tx_adapter_txq_set(mbufs[i], 0);
407
408 if (timer_period > 0)
409 __atomic_fetch_add(
410 &rsrc->port_stats[mbufs[i]->port].tx, 1,
411 __ATOMIC_RELAXED);
412 }
413 }
414 }
415
416 static __rte_always_inline void
l2fwd_event_loop_vector(struct l2fwd_resources * rsrc,const uint32_t flags)417 l2fwd_event_loop_vector(struct l2fwd_resources *rsrc, const uint32_t flags)
418 {
419 struct l2fwd_event_resources *evt_rsrc = rsrc->evt_rsrc;
420 const int port_id = l2fwd_get_free_event_port(evt_rsrc);
421 const uint8_t tx_q_id =
422 evt_rsrc->evq.event_q_id[evt_rsrc->evq.nb_queues - 1];
423 const uint64_t timer_period = rsrc->timer_period;
424 const uint8_t event_d_id = evt_rsrc->event_d_id;
425 const uint8_t deq_len = evt_rsrc->deq_depth;
426 struct rte_event ev[MAX_PKT_BURST];
427 uint16_t nb_rx = 0, nb_tx = 0;
428 uint8_t i;
429
430 if (port_id < 0)
431 return;
432
433 printf("%s(): entering eventdev main loop on lcore %u\n", __func__,
434 rte_lcore_id());
435
436 while (!rsrc->force_quit) {
437 nb_rx = rte_event_dequeue_burst(event_d_id, port_id, ev,
438 deq_len, 0);
439 if (nb_rx == 0)
440 continue;
441
442 for (i = 0; i < nb_rx; i++) {
443 if (flags & L2FWD_EVENT_TX_ENQ) {
444 ev[i].queue_id = tx_q_id;
445 ev[i].op = RTE_EVENT_OP_FORWARD;
446 }
447
448 l2fwd_event_vector_fwd(rsrc, ev[i].vec, timer_period,
449 flags);
450 }
451
452 if (flags & L2FWD_EVENT_TX_ENQ) {
453 nb_tx = rte_event_enqueue_burst(event_d_id, port_id, ev,
454 nb_rx);
455 while (nb_tx < nb_rx && !rsrc->force_quit)
456 nb_tx += rte_event_enqueue_burst(
457 event_d_id, port_id, ev + nb_tx,
458 nb_rx - nb_tx);
459 }
460
461 if (flags & L2FWD_EVENT_TX_DIRECT) {
462 nb_tx = rte_event_eth_tx_adapter_enqueue(
463 event_d_id, port_id, ev, nb_rx, 0);
464 while (nb_tx < nb_rx && !rsrc->force_quit)
465 nb_tx += rte_event_eth_tx_adapter_enqueue(
466 event_d_id, port_id, ev + nb_tx,
467 nb_rx - nb_tx, 0);
468 }
469 }
470
471 l2fwd_event_worker_cleanup(event_d_id, port_id, ev, nb_rx, nb_tx, 1);
472 }
473
474 static void __rte_noinline
l2fwd_event_main_loop_tx_d_vec(struct l2fwd_resources * rsrc)475 l2fwd_event_main_loop_tx_d_vec(struct l2fwd_resources *rsrc)
476 {
477 l2fwd_event_loop_vector(rsrc, L2FWD_EVENT_TX_DIRECT);
478 }
479
480 static void __rte_noinline
l2fwd_event_main_loop_tx_d_brst_vec(struct l2fwd_resources * rsrc)481 l2fwd_event_main_loop_tx_d_brst_vec(struct l2fwd_resources *rsrc)
482 {
483 l2fwd_event_loop_vector(rsrc, L2FWD_EVENT_TX_DIRECT);
484 }
485
486 static void __rte_noinline
l2fwd_event_main_loop_tx_q_vec(struct l2fwd_resources * rsrc)487 l2fwd_event_main_loop_tx_q_vec(struct l2fwd_resources *rsrc)
488 {
489 l2fwd_event_loop_vector(rsrc, L2FWD_EVENT_TX_ENQ);
490 }
491
492 static void __rte_noinline
l2fwd_event_main_loop_tx_q_brst_vec(struct l2fwd_resources * rsrc)493 l2fwd_event_main_loop_tx_q_brst_vec(struct l2fwd_resources *rsrc)
494 {
495 l2fwd_event_loop_vector(rsrc, L2FWD_EVENT_TX_ENQ);
496 }
497
498 static void __rte_noinline
l2fwd_event_main_loop_tx_d_mac_vec(struct l2fwd_resources * rsrc)499 l2fwd_event_main_loop_tx_d_mac_vec(struct l2fwd_resources *rsrc)
500 {
501 l2fwd_event_loop_vector(rsrc,
502 L2FWD_EVENT_UPDT_MAC | L2FWD_EVENT_TX_DIRECT);
503 }
504
505 static void __rte_noinline
l2fwd_event_main_loop_tx_d_brst_mac_vec(struct l2fwd_resources * rsrc)506 l2fwd_event_main_loop_tx_d_brst_mac_vec(struct l2fwd_resources *rsrc)
507 {
508 l2fwd_event_loop_vector(rsrc,
509 L2FWD_EVENT_UPDT_MAC | L2FWD_EVENT_TX_DIRECT);
510 }
511
512 static void __rte_noinline
l2fwd_event_main_loop_tx_q_mac_vec(struct l2fwd_resources * rsrc)513 l2fwd_event_main_loop_tx_q_mac_vec(struct l2fwd_resources *rsrc)
514 {
515 l2fwd_event_loop_vector(rsrc,
516 L2FWD_EVENT_UPDT_MAC | L2FWD_EVENT_TX_ENQ);
517 }
518
519 static void __rte_noinline
l2fwd_event_main_loop_tx_q_brst_mac_vec(struct l2fwd_resources * rsrc)520 l2fwd_event_main_loop_tx_q_brst_mac_vec(struct l2fwd_resources *rsrc)
521 {
522 l2fwd_event_loop_vector(rsrc,
523 L2FWD_EVENT_UPDT_MAC | L2FWD_EVENT_TX_ENQ);
524 }
525
526 void
l2fwd_event_resource_setup(struct l2fwd_resources * rsrc)527 l2fwd_event_resource_setup(struct l2fwd_resources *rsrc)
528 {
529 /* [MAC_UPDT][TX_MODE][BURST] */
530 const event_loop_cb event_loop[2][2][2][2] = {
531 [0][0][0][0] = l2fwd_event_main_loop_tx_d,
532 [0][0][0][1] = l2fwd_event_main_loop_tx_d_brst,
533 [0][0][1][0] = l2fwd_event_main_loop_tx_q,
534 [0][0][1][1] = l2fwd_event_main_loop_tx_q_brst,
535 [0][1][0][0] = l2fwd_event_main_loop_tx_d_mac,
536 [0][1][0][1] = l2fwd_event_main_loop_tx_d_brst_mac,
537 [0][1][1][0] = l2fwd_event_main_loop_tx_q_mac,
538 [0][1][1][1] = l2fwd_event_main_loop_tx_q_brst_mac,
539 [1][0][0][0] = l2fwd_event_main_loop_tx_d_vec,
540 [1][0][0][1] = l2fwd_event_main_loop_tx_d_brst_vec,
541 [1][0][1][0] = l2fwd_event_main_loop_tx_q_vec,
542 [1][0][1][1] = l2fwd_event_main_loop_tx_q_brst_vec,
543 [1][1][0][0] = l2fwd_event_main_loop_tx_d_mac_vec,
544 [1][1][0][1] = l2fwd_event_main_loop_tx_d_brst_mac_vec,
545 [1][1][1][0] = l2fwd_event_main_loop_tx_q_mac_vec,
546 [1][1][1][1] = l2fwd_event_main_loop_tx_q_brst_mac_vec,
547 };
548 struct l2fwd_event_resources *evt_rsrc;
549 uint32_t event_queue_cfg;
550 int ret;
551
552 if (!rte_event_dev_count())
553 rte_panic("No Eventdev found\n");
554
555 evt_rsrc = rte_zmalloc("l2fwd_event",
556 sizeof(struct l2fwd_event_resources), 0);
557 if (evt_rsrc == NULL)
558 rte_panic("Failed to allocate memory\n");
559
560 rsrc->evt_rsrc = evt_rsrc;
561
562 /* Setup eventdev capability callbacks */
563 l2fwd_event_capability_setup(evt_rsrc);
564
565 /* Event device configuration */
566 event_queue_cfg = evt_rsrc->ops.event_device_setup(rsrc);
567
568 /* Event queue configuration */
569 evt_rsrc->ops.event_queue_setup(rsrc, event_queue_cfg);
570
571 /* Event port configuration */
572 evt_rsrc->ops.event_port_setup(rsrc);
573
574 /* Rx/Tx adapters configuration */
575 evt_rsrc->ops.adapter_setup(rsrc);
576
577 /* Start event device */
578 ret = rte_event_dev_start(evt_rsrc->event_d_id);
579 if (ret < 0)
580 rte_panic("Error in starting eventdev\n");
581
582 evt_rsrc->ops.l2fwd_event_loop =
583 event_loop[rsrc->evt_vec.enabled][rsrc->mac_updating]
584 [evt_rsrc->tx_mode_q][evt_rsrc->has_burst];
585 }
586