Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(C) 2021 Marvell.
3 : : */
4 : :
5 : : #include "cn9k_worker.h"
6 : : #include "cnxk_eventdev.h"
7 : : #include "cnxk_worker.h"
8 : :
9 : : #define CN9K_DUAL_WS_PAIR_ID(x, id) (((x)*CN9K_DUAL_WS_NB_WS) + id)
10 : :
11 : : #define CN9K_SET_EVDEV_DEQ_OP(dev, deq_op, deq_ops) \
12 : : deq_op = deq_ops[dev->rx_offloads & (NIX_RX_OFFLOAD_MAX - 1)]
13 : :
14 : : #define CN9K_SET_EVDEV_ENQ_OP(dev, enq_op, enq_ops) \
15 : : enq_op = enq_ops[dev->tx_offloads & (NIX_TX_OFFLOAD_MAX - 1)]
16 : :
17 : : static int
18 : 0 : cn9k_sso_hws_link(void *arg, void *port, uint16_t *map, uint16_t nb_link, uint8_t profile)
19 : : {
20 : : struct cnxk_sso_evdev *dev = arg;
21 : : struct cn9k_sso_hws_dual *dws;
22 : : struct cn9k_sso_hws *ws;
23 : : int rc;
24 : :
25 [ # # ]: 0 : if (dev->dual_ws) {
26 : : dws = port;
27 : 0 : rc = roc_sso_hws_link(&dev->sso, CN9K_DUAL_WS_PAIR_ID(dws->hws_id, 0), map, nb_link,
28 : : profile);
29 : 0 : rc |= roc_sso_hws_link(&dev->sso, CN9K_DUAL_WS_PAIR_ID(dws->hws_id, 1), map,
30 : : nb_link, profile);
31 : : } else {
32 : : ws = port;
33 : 0 : rc = roc_sso_hws_link(&dev->sso, ws->hws_id, map, nb_link, profile);
34 : : }
35 : :
36 : 0 : return rc;
37 : : }
38 : :
39 : : static int
40 : 0 : cn9k_sso_hws_unlink(void *arg, void *port, uint16_t *map, uint16_t nb_link, uint8_t profile)
41 : : {
42 : : struct cnxk_sso_evdev *dev = arg;
43 : : struct cn9k_sso_hws_dual *dws;
44 : : struct cn9k_sso_hws *ws;
45 : : int rc;
46 : :
47 [ # # ]: 0 : if (dev->dual_ws) {
48 : : dws = port;
49 : 0 : rc = roc_sso_hws_unlink(&dev->sso, CN9K_DUAL_WS_PAIR_ID(dws->hws_id, 0), map,
50 : : nb_link, profile);
51 : 0 : rc |= roc_sso_hws_unlink(&dev->sso, CN9K_DUAL_WS_PAIR_ID(dws->hws_id, 1), map,
52 : : nb_link, profile);
53 : : } else {
54 : : ws = port;
55 : 0 : rc = roc_sso_hws_unlink(&dev->sso, ws->hws_id, map, nb_link, profile);
56 : : }
57 : :
58 : 0 : return rc;
59 : : }
60 : :
61 : : static void
62 : 0 : cn9k_sso_hws_setup(void *arg, void *hws, uintptr_t grp_base)
63 : : {
64 : : struct cnxk_sso_evdev *dev = arg;
65 : : struct cn9k_sso_hws_dual *dws;
66 : : struct cn9k_sso_hws *ws;
67 : : uint64_t val;
68 : :
69 : : /* Set get_work tmo for HWS */
70 : 0 : val = NSEC2USEC(dev->deq_tmo_ns);
71 [ # # ]: 0 : val = val ? val - 1 : 0;
72 [ # # ]: 0 : if (dev->dual_ws) {
73 : : dws = hws;
74 : 0 : dws->grp_base = grp_base;
75 : 0 : dws->fc_mem = (uint64_t *)dev->fc_iova;
76 : 0 : dws->xaq_lmt = dev->xaq_lmt;
77 : :
78 : 0 : plt_write64(val, dws->base[0] + SSOW_LF_GWS_NW_TIM);
79 : 0 : plt_write64(val, dws->base[1] + SSOW_LF_GWS_NW_TIM);
80 : : } else {
81 : : ws = hws;
82 : 0 : ws->grp_base = grp_base;
83 : 0 : ws->fc_mem = (uint64_t *)dev->fc_iova;
84 : 0 : ws->xaq_lmt = dev->xaq_lmt;
85 : :
86 : 0 : plt_write64(val, ws->base + SSOW_LF_GWS_NW_TIM);
87 : : }
88 : 0 : }
89 : :
90 : : static void
91 : 0 : cn9k_sso_hws_release(void *arg, void *hws)
92 : : {
93 : : struct cnxk_sso_evdev *dev = arg;
94 : : struct cn9k_sso_hws_dual *dws;
95 : : struct cn9k_sso_hws *ws;
96 : : uint16_t i, k;
97 : :
98 [ # # ]: 0 : if (dev->dual_ws) {
99 : : dws = hws;
100 [ # # ]: 0 : for (i = 0; i < dev->nb_event_queues; i++) {
101 [ # # ]: 0 : for (k = 0; k < CNXK_SSO_MAX_PROFILES; k++) {
102 : 0 : roc_sso_hws_unlink(&dev->sso, CN9K_DUAL_WS_PAIR_ID(dws->hws_id, 0),
103 : : &i, 1, k);
104 : 0 : roc_sso_hws_unlink(&dev->sso, CN9K_DUAL_WS_PAIR_ID(dws->hws_id, 1),
105 : : &i, 1, k);
106 : : }
107 : : }
108 : : memset(dws, 0, sizeof(*dws));
109 : : } else {
110 : : ws = hws;
111 [ # # ]: 0 : for (i = 0; i < dev->nb_event_queues; i++)
112 [ # # ]: 0 : for (k = 0; k < CNXK_SSO_MAX_PROFILES; k++)
113 : 0 : roc_sso_hws_unlink(&dev->sso, ws->hws_id, &i, 1, k);
114 : : memset(ws, 0, sizeof(*ws));
115 : : }
116 : 0 : }
117 : :
118 : : static int
119 [ # # ]: 0 : cn9k_sso_hws_flush_events(void *hws, uint8_t queue_id, uintptr_t base,
120 : : cnxk_handle_event_t fn, void *arg)
121 : : {
122 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(arg);
123 : : uint64_t retry = CNXK_SSO_FLUSH_RETRY_MAX;
124 : : struct cnxk_timesync_info **tstamp;
125 : : struct cn9k_sso_hws_dual *dws;
126 : : struct cn9k_sso_hws *ws;
127 : : uint64_t cq_ds_cnt = 1;
128 : : uint64_t aq_cnt = 1;
129 : : uint64_t ds_cnt = 1;
130 : : struct rte_event ev;
131 : : uintptr_t ws_base;
132 : : uint64_t val, req;
133 : : void *lookup_mem;
134 : :
135 [ # # ]: 0 : plt_write64(0, base + SSO_LF_GGRP_QCTL);
136 : :
137 : 0 : req = queue_id; /* GGRP ID */
138 : : req |= BIT_ULL(18); /* Grouped */
139 : 0 : req |= BIT_ULL(16); /* WAIT */
140 : :
141 [ # # ]: 0 : aq_cnt = plt_read64(base + SSO_LF_GGRP_AQ_CNT);
142 : 0 : ds_cnt = plt_read64(base + SSO_LF_GGRP_MISC_CNT);
143 : 0 : cq_ds_cnt = plt_read64(base + SSO_LF_GGRP_INT_CNT);
144 : 0 : cq_ds_cnt &= 0x3FFF3FFF0000;
145 : :
146 [ # # ]: 0 : if (dev->dual_ws) {
147 : : dws = hws;
148 : 0 : ws_base = dws->base[0];
149 : 0 : lookup_mem = dws->lookup_mem;
150 : 0 : tstamp = dws->tstamp;
151 : : } else {
152 : : ws = hws;
153 : 0 : ws_base = ws->base;
154 : 0 : lookup_mem = ws->lookup_mem;
155 : 0 : tstamp = ws->tstamp;
156 : : }
157 : :
158 [ # # ]: 0 : while (aq_cnt || cq_ds_cnt || ds_cnt) {
159 : 0 : plt_write64(req, ws_base + SSOW_LF_GWS_OP_GET_WORK0);
160 : 0 : cn9k_sso_hws_get_work_empty(ws_base, &ev, dev->rx_offloads,
161 : : lookup_mem, tstamp);
162 [ # # # # ]: 0 : if (fn != NULL && ev.u64 != 0)
163 : 0 : fn(arg, ev);
164 [ # # ]: 0 : if (ev.sched_type != SSO_TT_EMPTY)
165 : : cnxk_sso_hws_swtag_flush(ws_base);
166 [ # # ]: 0 : else if (retry-- == 0)
167 : : break;
168 : : do {
169 [ # # ]: 0 : val = plt_read64(ws_base + SSOW_LF_GWS_PENDSTATE);
170 [ # # ]: 0 : } while (val & BIT_ULL(56));
171 : : aq_cnt = plt_read64(base + SSO_LF_GGRP_AQ_CNT);
172 : : ds_cnt = plt_read64(base + SSO_LF_GGRP_MISC_CNT);
173 : : cq_ds_cnt = plt_read64(base + SSO_LF_GGRP_INT_CNT);
174 : : /* Extract cq and ds count */
175 : 0 : cq_ds_cnt &= 0x3FFF3FFF0000;
176 : : }
177 : :
178 [ # # ]: 0 : if (aq_cnt || cq_ds_cnt || ds_cnt)
179 : : return -EAGAIN;
180 : :
181 : 0 : plt_write64(0, ws_base + SSOW_LF_GWS_OP_GWC_INVAL);
182 : :
183 : 0 : return 0;
184 : : }
185 : :
186 : : static void
187 : 0 : cn9k_sso_hws_reset(void *arg, void *hws)
188 : : {
189 : : struct cnxk_sso_evdev *dev = arg;
190 : : struct cn9k_sso_hws_dual *dws;
191 : : struct cn9k_sso_hws *ws;
192 : : uint64_t pend_state;
193 : : uint8_t pend_tt;
194 : : uintptr_t base;
195 : : bool is_pend;
196 : : uint64_t tag;
197 : : uint8_t i;
198 : :
199 : : dws = hws;
200 : : ws = hws;
201 [ # # # # ]: 0 : for (i = 0; i < (dev->dual_ws ? CN9K_DUAL_WS_NB_WS : 1); i++) {
202 [ # # ]: 0 : base = dev->dual_ws ? dws->base[i] : ws->base;
203 : : is_pend = false;
204 : : /* Work in WQE0 is always consumed, unless its a SWTAG. */
205 [ # # ]: 0 : pend_state = plt_read64(base + SSOW_LF_GWS_PENDSTATE);
206 [ # # # # : 0 : if (pend_state & (BIT_ULL(63) | BIT_ULL(62) | BIT_ULL(54)) ||
# # ]
207 [ # # # # ]: 0 : (dev->dual_ws ? (dws->swtag_req && i == !dws->vws) :
208 [ # # ]: 0 : ws->swtag_req))
209 : : is_pend = true;
210 : : /* Wait till getwork/swtp/waitw/desched completes. */
211 : : do {
212 : : pend_state = plt_read64(base + SSOW_LF_GWS_PENDSTATE);
213 [ # # ]: 0 : } while (pend_state & (BIT_ULL(63) | BIT_ULL(62) | BIT_ULL(58) |
214 : : BIT_ULL(56)));
215 : :
216 [ # # ]: 0 : tag = plt_read64(base + SSOW_LF_GWS_TAG);
217 : 0 : pend_tt = (tag >> 32) & 0x3;
218 [ # # ]: 0 : if (is_pend && pend_tt != SSO_TT_EMPTY) { /* Work was pending */
219 [ # # ]: 0 : if (pend_tt == SSO_TT_ATOMIC ||
220 : : pend_tt == SSO_TT_ORDERED)
221 : : cnxk_sso_hws_swtag_untag(
222 : 0 : base + SSOW_LF_GWS_OP_SWTAG_UNTAG);
223 : 0 : plt_write64(0, base + SSOW_LF_GWS_OP_DESCHED);
224 [ # # ]: 0 : } else if (pend_tt != SSO_TT_EMPTY) {
225 : 0 : plt_write64(0, base + SSOW_LF_GWS_OP_SWTAG_FLUSH);
226 : : }
227 : :
228 : : /* Wait for desched to complete. */
229 : : do {
230 : : pend_state = plt_read64(base + SSOW_LF_GWS_PENDSTATE);
231 [ # # ]: 0 : } while (pend_state & (BIT_ULL(58) | BIT_ULL(56)));
232 : 0 : plt_write64(0, base + SSOW_LF_GWS_OP_GWC_INVAL);
233 : : }
234 [ # # ]: 0 : if (dev->dual_ws)
235 : 0 : dws->swtag_req = 0;
236 : : else
237 : 0 : ws->swtag_req = 0;
238 : 0 : }
239 : :
240 : : static int
241 : 0 : cn9k_sso_rsrc_init(void *arg, uint8_t hws, uint8_t hwgrp)
242 : : {
243 : : struct cnxk_tim_evdev *tim_dev = cnxk_tim_priv_get();
244 : : struct cnxk_sso_evdev *dev = arg;
245 : : uint16_t nb_tim_lfs;
246 : :
247 [ # # ]: 0 : if (dev->dual_ws)
248 : 0 : hws = hws * CN9K_DUAL_WS_NB_WS;
249 : :
250 [ # # ]: 0 : nb_tim_lfs = tim_dev ? tim_dev->nb_rings : 0;
251 : 0 : return roc_sso_rsrc_init(&dev->sso, hws, hwgrp, nb_tim_lfs);
252 : : }
253 : :
254 : : static int
255 [ # # ]: 0 : cn9k_sso_updt_tx_adptr_data(const struct rte_eventdev *event_dev)
256 : : {
257 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
258 : : int i;
259 : :
260 [ # # ]: 0 : if (dev->tx_adptr_data == NULL)
261 : : return 0;
262 : :
263 [ # # ]: 0 : for (i = 0; i < dev->nb_event_ports; i++) {
264 [ # # ]: 0 : if (dev->dual_ws) {
265 : 0 : struct cn9k_sso_hws_dual *dws =
266 : 0 : event_dev->data->ports[i];
267 : : void *ws_cookie;
268 : :
269 : : ws_cookie = cnxk_sso_hws_get_cookie(dws);
270 : 0 : ws_cookie = rte_realloc_socket(
271 : : ws_cookie,
272 : : sizeof(struct cnxk_sso_hws_cookie) +
273 : : sizeof(struct cn9k_sso_hws_dual) +
274 : 0 : dev->tx_adptr_data_sz,
275 : : RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
276 [ # # ]: 0 : if (ws_cookie == NULL)
277 : : return -ENOMEM;
278 : 0 : dws = RTE_PTR_ADD(ws_cookie,
279 : : sizeof(struct cnxk_sso_hws_cookie));
280 : 0 : memcpy(&dws->tx_adptr_data, dev->tx_adptr_data,
281 : : dev->tx_adptr_data_sz);
282 : 0 : event_dev->data->ports[i] = dws;
283 : : } else {
284 : 0 : struct cn9k_sso_hws *ws = event_dev->data->ports[i];
285 : : void *ws_cookie;
286 : :
287 : : ws_cookie = cnxk_sso_hws_get_cookie(ws);
288 : 0 : ws_cookie = rte_realloc_socket(
289 : : ws_cookie,
290 : : sizeof(struct cnxk_sso_hws_cookie) +
291 : : sizeof(struct cn9k_sso_hws_dual) +
292 : 0 : dev->tx_adptr_data_sz,
293 : : RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
294 [ # # ]: 0 : if (ws_cookie == NULL)
295 : : return -ENOMEM;
296 : 0 : ws = RTE_PTR_ADD(ws_cookie,
297 : : sizeof(struct cnxk_sso_hws_cookie));
298 : 0 : memcpy(&ws->tx_adptr_data, dev->tx_adptr_data,
299 : : dev->tx_adptr_data_sz);
300 : 0 : event_dev->data->ports[i] = ws;
301 : : }
302 : : }
303 : : rte_mb();
304 : :
305 : 0 : return 0;
306 : : }
307 : :
308 : : static void
309 : : cn9k_sso_fp_fns_set(struct rte_eventdev *event_dev)
310 : : {
311 : : #if defined(RTE_ARCH_ARM64)
312 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
313 : : /* Single WS modes */
314 : : const event_dequeue_t sso_hws_deq[NIX_RX_OFFLOAD_MAX] = {
315 : : #define R(name, flags)[flags] = cn9k_sso_hws_deq_##name,
316 : : NIX_RX_FASTPATH_MODES
317 : : #undef R
318 : : };
319 : :
320 : : const event_dequeue_burst_t sso_hws_deq_burst[NIX_RX_OFFLOAD_MAX] = {
321 : : #define R(name, flags)[flags] = cn9k_sso_hws_deq_burst_##name,
322 : : NIX_RX_FASTPATH_MODES
323 : : #undef R
324 : : };
325 : :
326 : : const event_dequeue_t sso_hws_deq_tmo[NIX_RX_OFFLOAD_MAX] = {
327 : : #define R(name, flags)[flags] = cn9k_sso_hws_deq_tmo_##name,
328 : : NIX_RX_FASTPATH_MODES
329 : : #undef R
330 : : };
331 : :
332 : : const event_dequeue_burst_t sso_hws_deq_tmo_burst[NIX_RX_OFFLOAD_MAX] = {
333 : : #define R(name, flags)[flags] = cn9k_sso_hws_deq_tmo_burst_##name,
334 : : NIX_RX_FASTPATH_MODES
335 : : #undef R
336 : : };
337 : :
338 : : const event_dequeue_t sso_hws_deq_seg[NIX_RX_OFFLOAD_MAX] = {
339 : : #define R(name, flags)[flags] = cn9k_sso_hws_deq_seg_##name,
340 : : NIX_RX_FASTPATH_MODES
341 : : #undef R
342 : : };
343 : :
344 : : const event_dequeue_burst_t sso_hws_deq_seg_burst[NIX_RX_OFFLOAD_MAX] = {
345 : : #define R(name, flags)[flags] = cn9k_sso_hws_deq_seg_burst_##name,
346 : : NIX_RX_FASTPATH_MODES
347 : : #undef R
348 : : };
349 : :
350 : : const event_dequeue_t sso_hws_deq_tmo_seg[NIX_RX_OFFLOAD_MAX] = {
351 : : #define R(name, flags)[flags] = cn9k_sso_hws_deq_tmo_seg_##name,
352 : : NIX_RX_FASTPATH_MODES
353 : : #undef R
354 : : };
355 : :
356 : : const event_dequeue_burst_t sso_hws_deq_tmo_seg_burst[NIX_RX_OFFLOAD_MAX] = {
357 : : #define R(name, flags)[flags] = cn9k_sso_hws_deq_tmo_seg_burst_##name,
358 : : NIX_RX_FASTPATH_MODES
359 : : #undef R
360 : : };
361 : :
362 : : /* Dual WS modes */
363 : : const event_dequeue_t sso_hws_dual_deq[NIX_RX_OFFLOAD_MAX] = {
364 : : #define R(name, flags)[flags] = cn9k_sso_hws_dual_deq_##name,
365 : : NIX_RX_FASTPATH_MODES
366 : : #undef R
367 : : };
368 : :
369 : : const event_dequeue_burst_t sso_hws_dual_deq_burst[NIX_RX_OFFLOAD_MAX] = {
370 : : #define R(name, flags)[flags] = cn9k_sso_hws_dual_deq_burst_##name,
371 : : NIX_RX_FASTPATH_MODES
372 : : #undef R
373 : : };
374 : :
375 : : const event_dequeue_t sso_hws_dual_deq_tmo[NIX_RX_OFFLOAD_MAX] = {
376 : : #define R(name, flags)[flags] = cn9k_sso_hws_dual_deq_tmo_##name,
377 : : NIX_RX_FASTPATH_MODES
378 : : #undef R
379 : : };
380 : :
381 : : const event_dequeue_burst_t sso_hws_dual_deq_tmo_burst[NIX_RX_OFFLOAD_MAX] = {
382 : : #define R(name, flags)[flags] = cn9k_sso_hws_dual_deq_tmo_burst_##name,
383 : : NIX_RX_FASTPATH_MODES
384 : : #undef R
385 : : };
386 : :
387 : : const event_dequeue_t sso_hws_dual_deq_seg[NIX_RX_OFFLOAD_MAX] = {
388 : : #define R(name, flags)[flags] = cn9k_sso_hws_dual_deq_seg_##name,
389 : : NIX_RX_FASTPATH_MODES
390 : : #undef R
391 : : };
392 : :
393 : : const event_dequeue_burst_t sso_hws_dual_deq_seg_burst[NIX_RX_OFFLOAD_MAX] = {
394 : : #define R(name, flags)[flags] = cn9k_sso_hws_dual_deq_seg_burst_##name,
395 : : NIX_RX_FASTPATH_MODES
396 : : #undef R
397 : : };
398 : :
399 : : const event_dequeue_t sso_hws_dual_deq_tmo_seg[NIX_RX_OFFLOAD_MAX] = {
400 : : #define R(name, flags)[flags] = cn9k_sso_hws_dual_deq_tmo_seg_##name,
401 : : NIX_RX_FASTPATH_MODES
402 : : #undef R
403 : : };
404 : :
405 : : const event_dequeue_burst_t sso_hws_dual_deq_tmo_seg_burst[NIX_RX_OFFLOAD_MAX] = {
406 : : #define R(name, flags)[flags] = cn9k_sso_hws_dual_deq_tmo_seg_burst_##name,
407 : : NIX_RX_FASTPATH_MODES
408 : : #undef R
409 : : };
410 : :
411 : : /* Tx modes */
412 : : const event_tx_adapter_enqueue_t sso_hws_tx_adptr_enq[NIX_TX_OFFLOAD_MAX] = {
413 : : #define T(name, sz, flags)[flags] = cn9k_sso_hws_tx_adptr_enq_##name,
414 : : NIX_TX_FASTPATH_MODES
415 : : #undef T
416 : : };
417 : :
418 : : const event_tx_adapter_enqueue_t sso_hws_tx_adptr_enq_seg[NIX_TX_OFFLOAD_MAX] = {
419 : : #define T(name, sz, flags)[flags] = cn9k_sso_hws_tx_adptr_enq_seg_##name,
420 : : NIX_TX_FASTPATH_MODES
421 : : #undef T
422 : : };
423 : :
424 : : const event_tx_adapter_enqueue_t sso_hws_dual_tx_adptr_enq[NIX_TX_OFFLOAD_MAX] = {
425 : : #define T(name, sz, flags)[flags] = cn9k_sso_hws_dual_tx_adptr_enq_##name,
426 : : NIX_TX_FASTPATH_MODES
427 : : #undef T
428 : : };
429 : :
430 : : const event_tx_adapter_enqueue_t sso_hws_dual_tx_adptr_enq_seg[NIX_TX_OFFLOAD_MAX] = {
431 : : #define T(name, sz, flags)[flags] = cn9k_sso_hws_dual_tx_adptr_enq_seg_##name,
432 : : NIX_TX_FASTPATH_MODES
433 : : #undef T
434 : : };
435 : :
436 : : event_dev->enqueue = cn9k_sso_hws_enq;
437 : : event_dev->enqueue_burst = cn9k_sso_hws_enq_burst;
438 : : event_dev->enqueue_new_burst = cn9k_sso_hws_enq_new_burst;
439 : : event_dev->enqueue_forward_burst = cn9k_sso_hws_enq_fwd_burst;
440 : : event_dev->profile_switch = cn9k_sso_hws_profile_switch;
441 : : if (dev->rx_offloads & NIX_RX_MULTI_SEG_F) {
442 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue, sso_hws_deq_seg);
443 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue_burst,
444 : : sso_hws_deq_seg_burst);
445 : : if (dev->is_timeout_deq) {
446 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue,
447 : : sso_hws_deq_tmo_seg);
448 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue_burst,
449 : : sso_hws_deq_tmo_seg_burst);
450 : : }
451 : : } else {
452 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue, sso_hws_deq);
453 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue_burst,
454 : : sso_hws_deq_burst);
455 : : if (dev->is_timeout_deq) {
456 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue,
457 : : sso_hws_deq_tmo);
458 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue_burst,
459 : : sso_hws_deq_tmo_burst);
460 : : }
461 : : }
462 : : event_dev->ca_enqueue = cn9k_sso_hws_ca_enq;
463 : :
464 : : if (dev->tx_offloads & NIX_TX_MULTI_SEG_F)
465 : : CN9K_SET_EVDEV_ENQ_OP(dev, event_dev->txa_enqueue,
466 : : sso_hws_tx_adptr_enq_seg);
467 : : else
468 : : CN9K_SET_EVDEV_ENQ_OP(dev, event_dev->txa_enqueue,
469 : : sso_hws_tx_adptr_enq);
470 : :
471 : : if (dev->dual_ws) {
472 : : event_dev->enqueue = cn9k_sso_hws_dual_enq;
473 : : event_dev->enqueue_burst = cn9k_sso_hws_dual_enq_burst;
474 : : event_dev->enqueue_new_burst = cn9k_sso_hws_dual_enq_new_burst;
475 : : event_dev->enqueue_forward_burst =
476 : : cn9k_sso_hws_dual_enq_fwd_burst;
477 : : event_dev->ca_enqueue = cn9k_sso_hws_dual_ca_enq;
478 : : event_dev->profile_switch = cn9k_sso_hws_dual_profile_switch;
479 : :
480 : : if (dev->rx_offloads & NIX_RX_MULTI_SEG_F) {
481 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue,
482 : : sso_hws_dual_deq_seg);
483 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue_burst,
484 : : sso_hws_dual_deq_seg_burst);
485 : : if (dev->is_timeout_deq) {
486 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue,
487 : : sso_hws_dual_deq_tmo_seg);
488 : : CN9K_SET_EVDEV_DEQ_OP(
489 : : dev, event_dev->dequeue_burst,
490 : : sso_hws_dual_deq_tmo_seg_burst);
491 : : }
492 : : } else {
493 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue,
494 : : sso_hws_dual_deq);
495 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue_burst,
496 : : sso_hws_dual_deq_burst);
497 : : if (dev->is_timeout_deq) {
498 : : CN9K_SET_EVDEV_DEQ_OP(dev, event_dev->dequeue,
499 : : sso_hws_dual_deq_tmo);
500 : : CN9K_SET_EVDEV_DEQ_OP(
501 : : dev, event_dev->dequeue_burst,
502 : : sso_hws_dual_deq_tmo_burst);
503 : : }
504 : : }
505 : :
506 : : if (dev->tx_offloads & NIX_TX_MULTI_SEG_F)
507 : : CN9K_SET_EVDEV_ENQ_OP(dev, event_dev->txa_enqueue,
508 : : sso_hws_dual_tx_adptr_enq_seg);
509 : : else
510 : : CN9K_SET_EVDEV_ENQ_OP(dev, event_dev->txa_enqueue,
511 : : sso_hws_dual_tx_adptr_enq);
512 : : }
513 : :
514 : : event_dev->txa_enqueue_same_dest = event_dev->txa_enqueue;
515 : : rte_mb();
516 : : #else
517 : : RTE_SET_USED(event_dev);
518 : : #endif
519 : : }
520 : :
521 : : static void *
522 : 0 : cn9k_sso_init_hws_mem(void *arg, uint8_t port_id)
523 : : {
524 : : struct cnxk_sso_evdev *dev = arg;
525 : : struct cn9k_sso_hws_dual *dws;
526 : : struct cn9k_sso_hws *ws;
527 : : void *data;
528 : :
529 [ # # ]: 0 : if (dev->dual_ws) {
530 : 0 : dws = rte_zmalloc("cn9k_dual_ws",
531 : : sizeof(struct cn9k_sso_hws_dual) +
532 : : RTE_CACHE_LINE_SIZE,
533 : : RTE_CACHE_LINE_SIZE);
534 [ # # ]: 0 : if (dws == NULL) {
535 : 0 : plt_err("Failed to alloc memory for port=%d", port_id);
536 : 0 : return NULL;
537 : : }
538 : :
539 : 0 : dws = RTE_PTR_ADD(dws, sizeof(struct cnxk_sso_hws_cookie));
540 : 0 : dws->base[0] = roc_sso_hws_base_get(
541 : : &dev->sso, CN9K_DUAL_WS_PAIR_ID(port_id, 0));
542 : 0 : dws->base[1] = roc_sso_hws_base_get(
543 : 0 : &dev->sso, CN9K_DUAL_WS_PAIR_ID(port_id, 1));
544 : 0 : dws->hws_id = port_id;
545 : 0 : dws->swtag_req = 0;
546 : 0 : dws->vws = 0;
547 [ # # ]: 0 : if (dev->deq_tmo_ns)
548 : 0 : dws->gw_wdata = BIT_ULL(16);
549 : 0 : dws->gw_wdata |= 1;
550 : :
551 : : data = dws;
552 : : } else {
553 : : /* Allocate event port memory */
554 : 0 : ws = rte_zmalloc("cn9k_ws",
555 : : sizeof(struct cn9k_sso_hws) +
556 : : RTE_CACHE_LINE_SIZE,
557 : : RTE_CACHE_LINE_SIZE);
558 [ # # ]: 0 : if (ws == NULL) {
559 : 0 : plt_err("Failed to alloc memory for port=%d", port_id);
560 : 0 : return NULL;
561 : : }
562 : :
563 : : /* First cache line is reserved for cookie */
564 : 0 : ws = RTE_PTR_ADD(ws, sizeof(struct cnxk_sso_hws_cookie));
565 : 0 : ws->base = roc_sso_hws_base_get(&dev->sso, port_id);
566 : 0 : ws->hws_id = port_id;
567 : 0 : ws->swtag_req = 0;
568 [ # # ]: 0 : if (dev->deq_tmo_ns)
569 : 0 : ws->gw_wdata = BIT_ULL(16);
570 : 0 : ws->gw_wdata |= 1;
571 : :
572 : : data = ws;
573 : : }
574 : :
575 : : return data;
576 : : }
577 : :
578 : : static void
579 : 0 : cn9k_sso_info_get(struct rte_eventdev *event_dev,
580 : : struct rte_event_dev_info *dev_info)
581 : : {
582 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
583 : :
584 : 0 : dev_info->driver_name = RTE_STR(EVENTDEV_NAME_CN9K_PMD);
585 : 0 : cnxk_sso_info_get(dev, dev_info);
586 : 0 : }
587 : :
588 : : static int
589 : 0 : cn9k_sso_dev_configure(const struct rte_eventdev *event_dev)
590 : : {
591 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
592 : : int rc;
593 : :
594 : 0 : rc = cnxk_sso_dev_validate(event_dev, 1, 1);
595 [ # # ]: 0 : if (rc < 0) {
596 : 0 : plt_err("Invalid event device configuration");
597 : 0 : return -EINVAL;
598 : : }
599 : :
600 : 0 : rc = cn9k_sso_rsrc_init(dev, dev->nb_event_ports, dev->nb_event_queues);
601 [ # # ]: 0 : if (rc < 0) {
602 : 0 : plt_err("Failed to initialize SSO resources");
603 : 0 : return -ENODEV;
604 : : }
605 : :
606 : 0 : rc = cnxk_sso_xaq_allocate(dev);
607 [ # # ]: 0 : if (rc < 0)
608 : 0 : goto cnxk_rsrc_fini;
609 : :
610 : 0 : rc = cnxk_setup_event_ports(event_dev, cn9k_sso_init_hws_mem,
611 : : cn9k_sso_hws_setup);
612 [ # # ]: 0 : if (rc < 0)
613 : 0 : goto cnxk_rsrc_fini;
614 : :
615 : : /* Restore any prior port-queue mapping. */
616 : 0 : cnxk_sso_restore_links(event_dev, cn9k_sso_hws_link);
617 : :
618 : 0 : dev->configured = 1;
619 : : rte_mb();
620 : :
621 : 0 : return 0;
622 : 0 : cnxk_rsrc_fini:
623 : 0 : roc_sso_rsrc_fini(&dev->sso);
624 : 0 : dev->nb_event_ports = 0;
625 : 0 : return rc;
626 : : }
627 : :
628 : : static int
629 : 0 : cn9k_sso_port_setup(struct rte_eventdev *event_dev, uint8_t port_id,
630 : : const struct rte_event_port_conf *port_conf)
631 : : {
632 : :
633 : : RTE_SET_USED(port_conf);
634 : 0 : return cnxk_sso_port_setup(event_dev, port_id, cn9k_sso_hws_setup);
635 : : }
636 : :
637 : : static void
638 [ # # ]: 0 : cn9k_sso_port_release(void *port)
639 : : {
640 : : struct cnxk_sso_hws_cookie *gws_cookie = cnxk_sso_hws_get_cookie(port);
641 : : struct cnxk_sso_evdev *dev;
642 : :
643 [ # # ]: 0 : if (port == NULL)
644 : : return;
645 : :
646 [ # # ]: 0 : dev = cnxk_sso_pmd_priv(gws_cookie->event_dev);
647 [ # # ]: 0 : if (!gws_cookie->configured)
648 : 0 : goto free;
649 : :
650 : 0 : cn9k_sso_hws_release(dev, port);
651 : : memset(gws_cookie, 0, sizeof(*gws_cookie));
652 : 0 : free:
653 : 0 : rte_free(gws_cookie);
654 : : }
655 : :
656 : : static void
657 : 0 : cn9k_sso_port_quiesce(struct rte_eventdev *event_dev, void *port,
658 : : rte_eventdev_port_flush_t flush_cb, void *args)
659 : : {
660 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
661 : : struct cn9k_sso_hws_dual *dws;
662 : : struct cn9k_sso_hws *ws;
663 : : struct rte_event ev;
664 : : uintptr_t base;
665 : : uint64_t ptag;
666 : : bool is_pend;
667 : : uint8_t i;
668 : :
669 : : dws = port;
670 : : ws = port;
671 [ # # # # ]: 0 : for (i = 0; i < (dev->dual_ws ? CN9K_DUAL_WS_NB_WS : 1); i++) {
672 [ # # ]: 0 : base = dev->dual_ws ? dws->base[i] : ws->base;
673 : : is_pend = false;
674 : : /* Work in WQE0 is always consumed, unless its a SWTAG. */
675 [ # # ]: 0 : ptag = plt_read64(base + SSOW_LF_GWS_PENDSTATE);
676 [ # # # # : 0 : if (ptag & (BIT_ULL(63) | BIT_ULL(62) | BIT_ULL(54)) ||
# # ]
677 [ # # # # ]: 0 : (dev->dual_ws ? (dws->swtag_req && i == !dws->vws) :
678 [ # # ]: 0 : ws->swtag_req))
679 : : is_pend = true;
680 : : /* Wait till getwork/swtp/waitw/desched completes. */
681 : : do {
682 : : ptag = plt_read64(base + SSOW_LF_GWS_PENDSTATE);
683 [ # # ]: 0 : } while (ptag & (BIT_ULL(63) | BIT_ULL(62) | BIT_ULL(58) |
684 : : BIT_ULL(56)));
685 : :
686 [ # # # # ]: 0 : cn9k_sso_hws_get_work_empty(
687 : 0 : base, &ev, dev->rx_offloads,
688 : : dev->dual_ws ? dws->lookup_mem : ws->lookup_mem,
689 : : dev->dual_ws ? dws->tstamp : ws->tstamp);
690 [ # # # # ]: 0 : if (is_pend && ev.u64)
691 [ # # ]: 0 : if (flush_cb)
692 : 0 : flush_cb(event_dev->data->dev_id, ev, args);
693 : :
694 : 0 : ptag = (plt_read64(base + SSOW_LF_GWS_TAG) >> 32) & SSO_TT_EMPTY;
695 [ # # ]: 0 : if (ptag != SSO_TT_EMPTY)
696 : : cnxk_sso_hws_swtag_flush(base);
697 : :
698 : : do {
699 : : ptag = plt_read64(base + SSOW_LF_GWS_PENDSTATE);
700 [ # # ]: 0 : } while (ptag & BIT_ULL(56));
701 : :
702 : 0 : plt_write64(0, base + SSOW_LF_GWS_OP_GWC_INVAL);
703 : : }
704 : :
705 [ # # ]: 0 : if (dev->dual_ws)
706 : 0 : dws->swtag_req = 0;
707 : : else
708 : 0 : ws->swtag_req = 0;
709 : 0 : }
710 : :
711 : : static int
712 : 0 : cn9k_sso_port_link_profile(struct rte_eventdev *event_dev, void *port, const uint8_t queues[],
713 : : const uint8_t priorities[], uint16_t nb_links, uint8_t profile)
714 : 0 : {
715 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
716 : 0 : uint16_t hwgrp_ids[nb_links];
717 : : uint16_t link;
718 : :
719 : : RTE_SET_USED(priorities);
720 [ # # ]: 0 : for (link = 0; link < nb_links; link++)
721 : 0 : hwgrp_ids[link] = queues[link];
722 : 0 : nb_links = cn9k_sso_hws_link(dev, port, hwgrp_ids, nb_links, profile);
723 : :
724 : 0 : return (int)nb_links;
725 : : }
726 : :
727 : : static int
728 : 0 : cn9k_sso_port_unlink_profile(struct rte_eventdev *event_dev, void *port, uint8_t queues[],
729 : : uint16_t nb_unlinks, uint8_t profile)
730 : 0 : {
731 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
732 : 0 : uint16_t hwgrp_ids[nb_unlinks];
733 : : uint16_t unlink;
734 : :
735 [ # # ]: 0 : for (unlink = 0; unlink < nb_unlinks; unlink++)
736 : 0 : hwgrp_ids[unlink] = queues[unlink];
737 : 0 : nb_unlinks = cn9k_sso_hws_unlink(dev, port, hwgrp_ids, nb_unlinks, profile);
738 : :
739 : 0 : return (int)nb_unlinks;
740 : : }
741 : :
742 : : static int
743 : 0 : cn9k_sso_port_link(struct rte_eventdev *event_dev, void *port, const uint8_t queues[],
744 : : const uint8_t priorities[], uint16_t nb_links)
745 : : {
746 : 0 : return cn9k_sso_port_link_profile(event_dev, port, queues, priorities, nb_links, 0);
747 : : }
748 : :
749 : : static int
750 : 0 : cn9k_sso_port_unlink(struct rte_eventdev *event_dev, void *port, uint8_t queues[],
751 : : uint16_t nb_unlinks)
752 : : {
753 : 0 : return cn9k_sso_port_unlink_profile(event_dev, port, queues, nb_unlinks, 0);
754 : : }
755 : :
756 : : static int
757 : 0 : cn9k_sso_start(struct rte_eventdev *event_dev)
758 : : {
759 : : int rc;
760 : :
761 : 0 : rc = cn9k_sso_updt_tx_adptr_data(event_dev);
762 [ # # ]: 0 : if (rc < 0)
763 : : return rc;
764 : :
765 : 0 : rc = cnxk_sso_start(event_dev, cn9k_sso_hws_reset,
766 : : cn9k_sso_hws_flush_events);
767 : : if (rc < 0)
768 : : return rc;
769 : :
770 : : cn9k_sso_fp_fns_set(event_dev);
771 : :
772 : : return rc;
773 : : }
774 : :
775 : : static void
776 : 0 : cn9k_sso_stop(struct rte_eventdev *event_dev)
777 : : {
778 : 0 : cnxk_sso_stop(event_dev, cn9k_sso_hws_reset, cn9k_sso_hws_flush_events);
779 : 0 : }
780 : :
781 : : static int
782 : 0 : cn9k_sso_close(struct rte_eventdev *event_dev)
783 : : {
784 : 0 : return cnxk_sso_close(event_dev, cn9k_sso_hws_unlink);
785 : : }
786 : :
787 : : static int
788 : 0 : cn9k_sso_selftest(void)
789 : : {
790 : 0 : return cnxk_sso_selftest(RTE_STR(event_cn9k));
791 : : }
792 : :
793 : : static int
794 : 0 : cn9k_sso_rx_adapter_caps_get(const struct rte_eventdev *event_dev,
795 : : const struct rte_eth_dev *eth_dev, uint32_t *caps)
796 : : {
797 : : int rc;
798 : :
799 : : RTE_SET_USED(event_dev);
800 : 0 : rc = strncmp(eth_dev->device->driver->name, "net_cn9k", 9);
801 [ # # ]: 0 : if (rc)
802 : 0 : *caps = RTE_EVENT_ETH_RX_ADAPTER_SW_CAP;
803 : : else
804 : 0 : *caps = RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT |
805 : : RTE_EVENT_ETH_RX_ADAPTER_CAP_MULTI_EVENTQ |
806 : : RTE_EVENT_ETH_RX_ADAPTER_CAP_OVERRIDE_FLOW_ID;
807 : :
808 : 0 : return 0;
809 : : }
810 : :
811 : : static void
812 : 0 : cn9k_sso_set_priv_mem(const struct rte_eventdev *event_dev, void *lookup_mem)
813 : : {
814 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
815 : : int i;
816 : :
817 [ # # ]: 0 : for (i = 0; i < dev->nb_event_ports; i++) {
818 [ # # ]: 0 : if (dev->dual_ws) {
819 : 0 : struct cn9k_sso_hws_dual *dws =
820 : : event_dev->data->ports[i];
821 : 0 : dws->xaq_lmt = dev->xaq_lmt;
822 : 0 : dws->fc_mem = (uint64_t *)dev->fc_iova;
823 : 0 : dws->tstamp = dev->tstamp;
824 [ # # ]: 0 : if (lookup_mem)
825 : 0 : dws->lookup_mem = lookup_mem;
826 : : } else {
827 : 0 : struct cn9k_sso_hws *ws = event_dev->data->ports[i];
828 : 0 : ws->xaq_lmt = dev->xaq_lmt;
829 : 0 : ws->fc_mem = (uint64_t *)dev->fc_iova;
830 : 0 : ws->tstamp = dev->tstamp;
831 [ # # ]: 0 : if (lookup_mem)
832 : 0 : ws->lookup_mem = lookup_mem;
833 : : }
834 : : }
835 : 0 : }
836 : :
837 : : static int
838 : 0 : cn9k_sso_rx_adapter_queue_add(
839 : : const struct rte_eventdev *event_dev, const struct rte_eth_dev *eth_dev,
840 : : int32_t rx_queue_id,
841 : : const struct rte_event_eth_rx_adapter_queue_conf *queue_conf)
842 : : {
843 : : struct cn9k_eth_rxq *rxq;
844 : : void *lookup_mem;
845 : : int rc;
846 : :
847 : 0 : rc = strncmp(eth_dev->device->driver->name, "net_cn9k", 8);
848 [ # # ]: 0 : if (rc)
849 : : return -EINVAL;
850 : :
851 : 0 : rc = cnxk_sso_rx_adapter_queue_add(event_dev, eth_dev, rx_queue_id,
852 : : queue_conf);
853 [ # # ]: 0 : if (rc)
854 : : return -EINVAL;
855 : :
856 : 0 : rxq = eth_dev->data->rx_queues[0];
857 : 0 : lookup_mem = rxq->lookup_mem;
858 : 0 : cn9k_sso_set_priv_mem(event_dev, lookup_mem);
859 : : cn9k_sso_fp_fns_set((struct rte_eventdev *)(uintptr_t)event_dev);
860 : :
861 : 0 : return 0;
862 : : }
863 : :
864 : : static int
865 : 0 : cn9k_sso_rx_adapter_queue_del(const struct rte_eventdev *event_dev,
866 : : const struct rte_eth_dev *eth_dev,
867 : : int32_t rx_queue_id)
868 : : {
869 : : int rc;
870 : :
871 : 0 : rc = strncmp(eth_dev->device->driver->name, "net_cn9k", 8);
872 [ # # ]: 0 : if (rc)
873 : : return -EINVAL;
874 : :
875 : 0 : return cnxk_sso_rx_adapter_queue_del(event_dev, eth_dev, rx_queue_id);
876 : : }
877 : :
878 : : static int
879 : 0 : cn9k_sso_tx_adapter_caps_get(const struct rte_eventdev *dev,
880 : : const struct rte_eth_dev *eth_dev, uint32_t *caps)
881 : : {
882 : : int ret;
883 : :
884 : : RTE_SET_USED(dev);
885 : 0 : ret = strncmp(eth_dev->device->driver->name, "net_cn9k", 8);
886 [ # # ]: 0 : if (ret)
887 : 0 : *caps = 0;
888 : : else
889 : 0 : *caps = RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT;
890 : :
891 : 0 : return 0;
892 : : }
893 : :
894 : : static void
895 : 0 : cn9k_sso_txq_fc_update(const struct rte_eth_dev *eth_dev, int32_t tx_queue_id)
896 : : {
897 : 0 : struct cnxk_eth_dev *cnxk_eth_dev = eth_dev->data->dev_private;
898 : : struct cn9k_eth_txq *txq;
899 : : struct roc_nix_sq *sq;
900 : : int i;
901 : :
902 [ # # ]: 0 : if (tx_queue_id < 0) {
903 [ # # ]: 0 : for (i = 0; i < eth_dev->data->nb_tx_queues; i++)
904 : 0 : cn9k_sso_txq_fc_update(eth_dev, i);
905 : : } else {
906 : : uint16_t sqes_per_sqb;
907 : :
908 : 0 : sq = &cnxk_eth_dev->sqs[tx_queue_id];
909 : 0 : txq = eth_dev->data->tx_queues[tx_queue_id];
910 : 0 : sqes_per_sqb = 1U << txq->sqes_per_sqb_log2;
911 [ # # ]: 0 : if (cnxk_eth_dev->tx_offloads & RTE_ETH_TX_OFFLOAD_SECURITY)
912 : 0 : sq->nb_sqb_bufs_adj -= (cnxk_eth_dev->outb.nb_desc / sqes_per_sqb);
913 : 0 : txq->nb_sqb_bufs_adj = sq->nb_sqb_bufs_adj;
914 : : }
915 : 0 : }
916 : :
917 : : static int
918 : 0 : cn9k_sso_tx_adapter_queue_add(uint8_t id, const struct rte_eventdev *event_dev,
919 : : const struct rte_eth_dev *eth_dev,
920 : : int32_t tx_queue_id)
921 : : {
922 : 0 : struct cnxk_eth_dev *cnxk_eth_dev = eth_dev->data->dev_private;
923 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
924 : : uint64_t tx_offloads;
925 : : int rc;
926 : :
927 : : RTE_SET_USED(id);
928 : 0 : rc = cnxk_sso_tx_adapter_queue_add(event_dev, eth_dev, tx_queue_id);
929 [ # # ]: 0 : if (rc < 0)
930 : : return rc;
931 : :
932 : : /* Can't enable tstamp if all the ports don't have it enabled. */
933 : 0 : tx_offloads = cnxk_eth_dev->tx_offload_flags;
934 [ # # ]: 0 : if (dev->tx_adptr_configured) {
935 : 0 : uint8_t tstmp_req = !!(tx_offloads & NIX_TX_OFFLOAD_TSTAMP_F);
936 : : uint8_t tstmp_ena =
937 : 0 : !!(dev->tx_offloads & NIX_TX_OFFLOAD_TSTAMP_F);
938 : :
939 [ # # ]: 0 : if (tstmp_ena && !tstmp_req)
940 : 0 : dev->tx_offloads &= ~(NIX_TX_OFFLOAD_TSTAMP_F);
941 [ # # ]: 0 : else if (!tstmp_ena && tstmp_req)
942 : 0 : tx_offloads &= ~(NIX_TX_OFFLOAD_TSTAMP_F);
943 : : }
944 : :
945 : 0 : dev->tx_offloads |= tx_offloads;
946 : 0 : cn9k_sso_txq_fc_update(eth_dev, tx_queue_id);
947 : 0 : rc = cn9k_sso_updt_tx_adptr_data(event_dev);
948 [ # # ]: 0 : if (rc < 0)
949 : : return rc;
950 : : cn9k_sso_fp_fns_set((struct rte_eventdev *)(uintptr_t)event_dev);
951 : 0 : dev->tx_adptr_configured = 1;
952 : :
953 : 0 : return 0;
954 : : }
955 : :
956 : : static int
957 : 0 : cn9k_sso_tx_adapter_queue_del(uint8_t id, const struct rte_eventdev *event_dev,
958 : : const struct rte_eth_dev *eth_dev,
959 : : int32_t tx_queue_id)
960 : : {
961 : : int rc;
962 : :
963 : : RTE_SET_USED(id);
964 : 0 : rc = cnxk_sso_tx_adapter_queue_del(event_dev, eth_dev, tx_queue_id);
965 [ # # ]: 0 : if (rc < 0)
966 : : return rc;
967 : 0 : cn9k_sso_txq_fc_update(eth_dev, tx_queue_id);
968 : 0 : return cn9k_sso_updt_tx_adptr_data(event_dev);
969 : : }
970 : :
971 : : static int
972 : 0 : cn9k_crypto_adapter_caps_get(const struct rte_eventdev *event_dev, const struct rte_cryptodev *cdev,
973 : : uint32_t *caps)
974 : : {
975 [ # # ]: 0 : CNXK_VALID_DEV_OR_ERR_RET(event_dev->dev, "event_cn9k", ENOTSUP);
976 [ # # ]: 0 : CNXK_VALID_DEV_OR_ERR_RET(cdev->device, "crypto_cn9k", ENOTSUP);
977 : :
978 : 0 : *caps = RTE_EVENT_CRYPTO_ADAPTER_CAP_INTERNAL_PORT_OP_FWD |
979 : : RTE_EVENT_CRYPTO_ADAPTER_CAP_SESSION_PRIVATE_DATA;
980 : :
981 : 0 : return 0;
982 : : }
983 : :
984 : : static int
985 : 0 : cn9k_crypto_adapter_qp_add(const struct rte_eventdev *event_dev,
986 : : const struct rte_cryptodev *cdev,
987 : : int32_t queue_pair_id,
988 : : const struct rte_event_crypto_adapter_queue_conf *conf)
989 : : {
990 : : int ret;
991 : :
992 [ # # ]: 0 : CNXK_VALID_DEV_OR_ERR_RET(event_dev->dev, "event_cn9k", EINVAL);
993 [ # # ]: 0 : CNXK_VALID_DEV_OR_ERR_RET(cdev->device, "crypto_cn9k", EINVAL);
994 : :
995 : : cn9k_sso_fp_fns_set((struct rte_eventdev *)(uintptr_t)event_dev);
996 : :
997 : 0 : ret = cnxk_crypto_adapter_qp_add(event_dev, cdev, queue_pair_id, conf);
998 : 0 : cn9k_sso_set_priv_mem(event_dev, NULL);
999 : :
1000 : 0 : return ret;
1001 : : }
1002 : :
1003 : : static int
1004 : 0 : cn9k_crypto_adapter_qp_del(const struct rte_eventdev *event_dev, const struct rte_cryptodev *cdev,
1005 : : int32_t queue_pair_id)
1006 : : {
1007 [ # # ]: 0 : CNXK_VALID_DEV_OR_ERR_RET(event_dev->dev, "event_cn9k", EINVAL);
1008 [ # # ]: 0 : CNXK_VALID_DEV_OR_ERR_RET(cdev->device, "crypto_cn9k", EINVAL);
1009 : :
1010 : 0 : return cnxk_crypto_adapter_qp_del(cdev, queue_pair_id);
1011 : : }
1012 : :
1013 : : static int
1014 : 0 : cn9k_tim_caps_get(const struct rte_eventdev *evdev, uint64_t flags,
1015 : : uint32_t *caps, const struct event_timer_adapter_ops **ops)
1016 : : {
1017 : 0 : return cnxk_tim_caps_get(evdev, flags, caps, ops,
1018 : : cn9k_sso_set_priv_mem);
1019 : : }
1020 : :
1021 : : static struct eventdev_ops cn9k_sso_dev_ops = {
1022 : : .dev_infos_get = cn9k_sso_info_get,
1023 : : .dev_configure = cn9k_sso_dev_configure,
1024 : :
1025 : : .queue_def_conf = cnxk_sso_queue_def_conf,
1026 : : .queue_setup = cnxk_sso_queue_setup,
1027 : : .queue_release = cnxk_sso_queue_release,
1028 : : .queue_attr_set = cnxk_sso_queue_attribute_set,
1029 : :
1030 : : .port_def_conf = cnxk_sso_port_def_conf,
1031 : : .port_setup = cn9k_sso_port_setup,
1032 : : .port_release = cn9k_sso_port_release,
1033 : : .port_quiesce = cn9k_sso_port_quiesce,
1034 : : .port_link = cn9k_sso_port_link,
1035 : : .port_unlink = cn9k_sso_port_unlink,
1036 : : .port_link_profile = cn9k_sso_port_link_profile,
1037 : : .port_unlink_profile = cn9k_sso_port_unlink_profile,
1038 : : .timeout_ticks = cnxk_sso_timeout_ticks,
1039 : :
1040 : : .eth_rx_adapter_caps_get = cn9k_sso_rx_adapter_caps_get,
1041 : : .eth_rx_adapter_queue_add = cn9k_sso_rx_adapter_queue_add,
1042 : : .eth_rx_adapter_queue_del = cn9k_sso_rx_adapter_queue_del,
1043 : : .eth_rx_adapter_start = cnxk_sso_rx_adapter_start,
1044 : : .eth_rx_adapter_stop = cnxk_sso_rx_adapter_stop,
1045 : :
1046 : : .eth_tx_adapter_caps_get = cn9k_sso_tx_adapter_caps_get,
1047 : : .eth_tx_adapter_queue_add = cn9k_sso_tx_adapter_queue_add,
1048 : : .eth_tx_adapter_queue_del = cn9k_sso_tx_adapter_queue_del,
1049 : : .eth_tx_adapter_start = cnxk_sso_tx_adapter_start,
1050 : : .eth_tx_adapter_stop = cnxk_sso_tx_adapter_stop,
1051 : : .eth_tx_adapter_free = cnxk_sso_tx_adapter_free,
1052 : :
1053 : : .timer_adapter_caps_get = cn9k_tim_caps_get,
1054 : :
1055 : : .crypto_adapter_caps_get = cn9k_crypto_adapter_caps_get,
1056 : : .crypto_adapter_queue_pair_add = cn9k_crypto_adapter_qp_add,
1057 : : .crypto_adapter_queue_pair_del = cn9k_crypto_adapter_qp_del,
1058 : :
1059 : : .xstats_get = cnxk_sso_xstats_get,
1060 : : .xstats_reset = cnxk_sso_xstats_reset,
1061 : : .xstats_get_names = cnxk_sso_xstats_get_names,
1062 : :
1063 : : .dump = cnxk_sso_dump,
1064 : : .dev_start = cn9k_sso_start,
1065 : : .dev_stop = cn9k_sso_stop,
1066 : : .dev_close = cn9k_sso_close,
1067 : : .dev_selftest = cn9k_sso_selftest,
1068 : : };
1069 : :
1070 : : static int
1071 : 0 : cn9k_sso_init(struct rte_eventdev *event_dev)
1072 : : {
1073 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
1074 : : int rc;
1075 : :
1076 : 0 : rc = roc_plt_init();
1077 [ # # ]: 0 : if (rc < 0) {
1078 : 0 : plt_err("Failed to initialize platform model");
1079 : 0 : return rc;
1080 : : }
1081 : :
1082 : 0 : event_dev->dev_ops = &cn9k_sso_dev_ops;
1083 : : /* For secondary processes, the primary has done all the work */
1084 [ # # ]: 0 : if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
1085 : : cn9k_sso_fp_fns_set(event_dev);
1086 : : return 0;
1087 : : }
1088 : :
1089 : 0 : rc = cnxk_sso_init(event_dev);
1090 [ # # ]: 0 : if (rc < 0)
1091 : : return rc;
1092 : :
1093 : 0 : cn9k_sso_set_rsrc(cnxk_sso_pmd_priv(event_dev));
1094 [ # # # # ]: 0 : if (!dev->max_event_ports || !dev->max_event_queues) {
1095 : 0 : plt_err("Not enough eventdev resource queues=%d ports=%d",
1096 : : dev->max_event_queues, dev->max_event_ports);
1097 : 0 : cnxk_sso_fini(event_dev);
1098 : 0 : return -ENODEV;
1099 : : }
1100 : :
1101 : 0 : plt_sso_dbg("Initializing %s max_queues=%d max_ports=%d",
1102 : : event_dev->data->name, dev->max_event_queues,
1103 : : dev->max_event_ports);
1104 : :
1105 : 0 : return 0;
1106 : : }
1107 : :
1108 : : static int
1109 : 0 : cn9k_sso_probe(struct rte_pci_driver *pci_drv, struct rte_pci_device *pci_dev)
1110 : : {
1111 : 0 : return rte_event_pmd_pci_probe(
1112 : : pci_drv, pci_dev, sizeof(struct cnxk_sso_evdev), cn9k_sso_init);
1113 : : }
1114 : :
1115 : : static const struct rte_pci_id cn9k_pci_sso_map[] = {
1116 : : CNXK_PCI_ID(PCI_SUBSYSTEM_DEVID_CN9KA, PCI_DEVID_CNXK_RVU_SSO_TIM_PF),
1117 : : CNXK_PCI_ID(PCI_SUBSYSTEM_DEVID_CN9KB, PCI_DEVID_CNXK_RVU_SSO_TIM_PF),
1118 : : CNXK_PCI_ID(PCI_SUBSYSTEM_DEVID_CN9KC, PCI_DEVID_CNXK_RVU_SSO_TIM_PF),
1119 : : CNXK_PCI_ID(PCI_SUBSYSTEM_DEVID_CN9KD, PCI_DEVID_CNXK_RVU_SSO_TIM_PF),
1120 : : CNXK_PCI_ID(PCI_SUBSYSTEM_DEVID_CN9KE, PCI_DEVID_CNXK_RVU_SSO_TIM_PF),
1121 : : CNXK_PCI_ID(PCI_SUBSYSTEM_DEVID_CNF9KA, PCI_DEVID_CNXK_RVU_SSO_TIM_PF),
1122 : : CNXK_PCI_ID(PCI_SUBSYSTEM_DEVID_CN9KA, PCI_DEVID_CNXK_RVU_SSO_TIM_VF),
1123 : : CNXK_PCI_ID(PCI_SUBSYSTEM_DEVID_CN9KB, PCI_DEVID_CNXK_RVU_SSO_TIM_VF),
1124 : : CNXK_PCI_ID(PCI_SUBSYSTEM_DEVID_CN9KC, PCI_DEVID_CNXK_RVU_SSO_TIM_VF),
1125 : : CNXK_PCI_ID(PCI_SUBSYSTEM_DEVID_CN9KD, PCI_DEVID_CNXK_RVU_SSO_TIM_VF),
1126 : : CNXK_PCI_ID(PCI_SUBSYSTEM_DEVID_CN9KE, PCI_DEVID_CNXK_RVU_SSO_TIM_VF),
1127 : : CNXK_PCI_ID(PCI_SUBSYSTEM_DEVID_CNF9KA, PCI_DEVID_CNXK_RVU_SSO_TIM_VF),
1128 : : {
1129 : : .vendor_id = 0,
1130 : : },
1131 : : };
1132 : :
1133 : : static struct rte_pci_driver cn9k_pci_sso = {
1134 : : .id_table = cn9k_pci_sso_map,
1135 : : .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_NEED_IOVA_AS_VA,
1136 : : .probe = cn9k_sso_probe,
1137 : : .remove = cnxk_sso_remove,
1138 : : };
1139 : :
1140 : 235 : RTE_PMD_REGISTER_PCI(event_cn9k, cn9k_pci_sso);
1141 : : RTE_PMD_REGISTER_PCI_TABLE(event_cn9k, cn9k_pci_sso_map);
1142 : : RTE_PMD_REGISTER_KMOD_DEP(event_cn9k, "vfio-pci");
1143 : : RTE_PMD_REGISTER_PARAM_STRING(event_cn9k, CNXK_SSO_XAE_CNT "=<int>"
1144 : : CNXK_SSO_GGRP_QOS "=<string>"
1145 : : CNXK_SSO_FORCE_BP "=1"
1146 : : CN9K_SSO_SINGLE_WS "=1"
1147 : : CNXK_TIM_DISABLE_NPA "=1"
1148 : : CNXK_TIM_CHNK_SLOTS "=<int>"
1149 : : CNXK_TIM_RINGS_LMT "=<int>"
1150 : : CNXK_TIM_STATS_ENA "=1");
|