Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(C) 2021 Marvell.
3 : : */
4 : :
5 : : #include "cnxk_cryptodev_ops.h"
6 : : #include "cnxk_ethdev.h"
7 : : #include "cnxk_eventdev.h"
8 : : #include "cnxk_dmadev.h"
9 : :
10 : : void
11 : 0 : cnxk_sso_updt_xae_cnt(struct cnxk_sso_evdev *dev, void *data,
12 : : uint32_t event_type)
13 : : {
14 : : int i;
15 : :
16 [ # # # # ]: 0 : switch (event_type) {
17 : : case RTE_EVENT_TYPE_ETHDEV: {
18 : : struct cnxk_eth_rxq_sp *rxq = data;
19 : : uint64_t *old_ptr;
20 : :
21 [ # # ]: 0 : for (i = 0; i < dev->rx_adptr_pool_cnt; i++) {
22 [ # # ]: 0 : if ((uint64_t)rxq->qconf.mp == dev->rx_adptr_pools[i])
23 : : return;
24 : : }
25 : :
26 : 0 : dev->rx_adptr_pool_cnt++;
27 : 0 : old_ptr = dev->rx_adptr_pools;
28 : 0 : dev->rx_adptr_pools = rte_realloc(
29 : : dev->rx_adptr_pools,
30 : 0 : sizeof(uint64_t) * dev->rx_adptr_pool_cnt, 0);
31 [ # # ]: 0 : if (dev->rx_adptr_pools == NULL) {
32 : 0 : dev->adptr_xae_cnt += rxq->qconf.mp->size;
33 : 0 : dev->rx_adptr_pools = old_ptr;
34 : 0 : dev->rx_adptr_pool_cnt--;
35 : 0 : return;
36 : : }
37 : 0 : dev->rx_adptr_pools[dev->rx_adptr_pool_cnt - 1] =
38 : 0 : (uint64_t)rxq->qconf.mp;
39 : :
40 : 0 : dev->adptr_xae_cnt += rxq->qconf.mp->size;
41 : 0 : break;
42 : : }
43 : : case RTE_EVENT_TYPE_ETHDEV_VECTOR: {
44 : : struct rte_mempool *mp = data;
45 : : uint64_t *old_ptr;
46 : :
47 [ # # ]: 0 : for (i = 0; i < dev->vec_pool_cnt; i++) {
48 [ # # ]: 0 : if ((uint64_t)mp == dev->vec_pools[i])
49 : : return;
50 : : }
51 : :
52 : 0 : dev->vec_pool_cnt++;
53 : 0 : old_ptr = dev->vec_pools;
54 : 0 : dev->vec_pools =
55 : 0 : rte_realloc(dev->vec_pools,
56 : 0 : sizeof(uint64_t) * dev->vec_pool_cnt, 0);
57 [ # # ]: 0 : if (dev->vec_pools == NULL) {
58 : 0 : dev->adptr_xae_cnt += mp->size;
59 : 0 : dev->vec_pools = old_ptr;
60 : 0 : dev->vec_pool_cnt--;
61 : 0 : return;
62 : : }
63 : 0 : dev->vec_pools[dev->vec_pool_cnt - 1] = (uint64_t)mp;
64 : :
65 : 0 : dev->adptr_xae_cnt += mp->size;
66 : 0 : break;
67 : : }
68 : : case RTE_EVENT_TYPE_TIMER: {
69 : : struct cnxk_tim_ring *timr = data;
70 : : uint16_t *old_ring_ptr;
71 : : uint64_t *old_sz_ptr;
72 : :
73 [ # # ]: 0 : for (i = 0; i < dev->tim_adptr_ring_cnt; i++) {
74 [ # # ]: 0 : if (timr->ring_id != dev->timer_adptr_rings[i])
75 : : continue;
76 [ # # ]: 0 : if (timr->nb_timers == dev->timer_adptr_sz[i])
77 : : return;
78 : 0 : dev->adptr_xae_cnt -= dev->timer_adptr_sz[i];
79 : 0 : dev->adptr_xae_cnt += timr->nb_timers;
80 : 0 : dev->timer_adptr_sz[i] = timr->nb_timers;
81 : :
82 : 0 : return;
83 : : }
84 : :
85 : 0 : dev->tim_adptr_ring_cnt++;
86 : 0 : old_ring_ptr = dev->timer_adptr_rings;
87 : 0 : old_sz_ptr = dev->timer_adptr_sz;
88 : :
89 : 0 : dev->timer_adptr_rings = rte_realloc(
90 : : dev->timer_adptr_rings,
91 : 0 : sizeof(uint16_t) * dev->tim_adptr_ring_cnt, 0);
92 [ # # ]: 0 : if (dev->timer_adptr_rings == NULL) {
93 : 0 : dev->adptr_xae_cnt += timr->nb_timers;
94 : 0 : dev->timer_adptr_rings = old_ring_ptr;
95 : 0 : dev->tim_adptr_ring_cnt--;
96 : 0 : return;
97 : : }
98 : :
99 : 0 : dev->timer_adptr_sz = rte_realloc(
100 : 0 : dev->timer_adptr_sz,
101 : 0 : sizeof(uint64_t) * dev->tim_adptr_ring_cnt, 0);
102 : :
103 [ # # ]: 0 : if (dev->timer_adptr_sz == NULL) {
104 : 0 : dev->adptr_xae_cnt += timr->nb_timers;
105 : 0 : dev->timer_adptr_sz = old_sz_ptr;
106 : 0 : dev->tim_adptr_ring_cnt--;
107 : 0 : return;
108 : : }
109 : :
110 : 0 : dev->timer_adptr_rings[dev->tim_adptr_ring_cnt - 1] =
111 : 0 : timr->ring_id;
112 : 0 : dev->timer_adptr_sz[dev->tim_adptr_ring_cnt - 1] =
113 : 0 : timr->nb_timers;
114 : :
115 : 0 : dev->adptr_xae_cnt += timr->nb_timers;
116 : 0 : break;
117 : : }
118 : : default:
119 : : break;
120 : : }
121 : : }
122 : :
123 : : static int
124 : 0 : cnxk_sso_rxq_enable(struct cnxk_eth_dev *cnxk_eth_dev, uint16_t rq_id,
125 : : uint16_t port_id, const struct rte_event *ev,
126 : : uint8_t custom_flowid)
127 : : {
128 : 0 : struct roc_nix *nix = &cnxk_eth_dev->nix;
129 : : struct roc_nix_rq *rq;
130 : : uint16_t wqe_skip;
131 : : int rc;
132 : :
133 : 0 : rq = &cnxk_eth_dev->rqs[rq_id];
134 : 0 : rq->sso_ena = 1;
135 : 0 : rq->tt = ev->sched_type;
136 : 0 : rq->hwgrp = ev->queue_id;
137 : 0 : rq->flow_tag_width = 20;
138 : : wqe_skip = RTE_ALIGN_CEIL(sizeof(struct rte_mbuf), ROC_CACHE_LINE_SZ);
139 : : wqe_skip = wqe_skip / ROC_CACHE_LINE_SZ;
140 : 0 : rq->wqe_skip = wqe_skip;
141 : 0 : rq->tag_mask = (port_id & 0xF) << 20;
142 : 0 : rq->tag_mask |= (((port_id >> 4) & 0xF) | (RTE_EVENT_TYPE_ETHDEV << 4))
143 : 0 : << 24;
144 : :
145 [ # # ]: 0 : if (custom_flowid) {
146 : 0 : rq->flow_tag_width = 0;
147 : 0 : rq->tag_mask |= ev->flow_id;
148 : : }
149 : :
150 : 0 : rc = roc_nix_rq_modify(&cnxk_eth_dev->nix, rq, 0);
151 [ # # ]: 0 : if (rc)
152 : : return rc;
153 : :
154 [ # # # # ]: 0 : if (rq_id == 0 && roc_nix_inl_inb_is_enabled(nix)) {
155 : : uint32_t sec_tag_const;
156 : :
157 : : /* IPSec tag const is 8-bit left shifted value of tag_mask
158 : : * as it applies to bit 32:8 of tag only.
159 : : */
160 : 0 : sec_tag_const = rq->tag_mask >> 8;
161 : 0 : rc = roc_nix_inl_inb_tag_update(nix, sec_tag_const,
162 : 0 : ev->sched_type);
163 [ # # ]: 0 : if (rc)
164 : 0 : plt_err("Failed to set tag conf for ipsec, rc=%d", rc);
165 : : }
166 : :
167 : : return rc;
168 : : }
169 : :
170 : : static int
171 : : cnxk_sso_rxq_disable(struct cnxk_eth_dev *cnxk_eth_dev, uint16_t rq_id)
172 : : {
173 : : struct roc_nix_rq *rq;
174 : :
175 : 0 : rq = &cnxk_eth_dev->rqs[rq_id];
176 : 0 : rq->sso_ena = 0;
177 : 0 : rq->flow_tag_width = 32;
178 : 0 : rq->tag_mask = 0;
179 : :
180 : 0 : return roc_nix_rq_modify(&cnxk_eth_dev->nix, rq, 0);
181 : : }
182 : :
183 : : static int
184 : 0 : cnxk_sso_rx_adapter_vwqe_enable(struct cnxk_eth_dev *cnxk_eth_dev,
185 : : uint16_t port_id, uint16_t rq_id, uint16_t sz,
186 : : uint64_t tmo_ns, struct rte_mempool *vmp)
187 : : {
188 : : struct roc_nix_rq *rq;
189 : :
190 : 0 : rq = &cnxk_eth_dev->rqs[rq_id];
191 : :
192 [ # # ]: 0 : if (!rq->sso_ena)
193 : : return -EINVAL;
194 [ # # ]: 0 : if (rq->flow_tag_width == 0)
195 : : return -EINVAL;
196 : :
197 : 0 : rq->vwqe_ena = 1;
198 : 0 : rq->vwqe_first_skip = 0;
199 : 0 : rq->vwqe_aura_handle = vmp->pool_id;
200 [ # # ]: 0 : rq->vwqe_max_sz_exp = rte_log2_u32(sz);
201 : 0 : rq->vwqe_wait_tmo =
202 : 0 : tmo_ns /
203 : 0 : ((roc_nix_get_vwqe_interval(&cnxk_eth_dev->nix) + 1) * 100);
204 : 0 : rq->tag_mask = (port_id & 0xF) << 20;
205 : 0 : rq->tag_mask |=
206 : : (((port_id >> 4) & 0xF) | (RTE_EVENT_TYPE_ETHDEV_VECTOR << 4))
207 : 0 : << 24;
208 : :
209 : 0 : return roc_nix_rq_modify(&cnxk_eth_dev->nix, rq, 0);
210 : : }
211 : :
212 : : static void
213 : : cnxk_sso_tstamp_cfg(uint16_t port_id, struct cnxk_eth_dev *cnxk_eth_dev,
214 : : struct cnxk_sso_evdev *dev)
215 : : {
216 : 0 : if (cnxk_eth_dev->rx_offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP)
217 : 0 : dev->tstamp[port_id] = &cnxk_eth_dev->tstamp;
218 : : }
219 : :
220 : : int
221 : 0 : cnxk_sso_rx_adapter_queue_add(
222 : : const struct rte_eventdev *event_dev, const struct rte_eth_dev *eth_dev,
223 : : int32_t rx_queue_id,
224 : : const struct rte_event_eth_rx_adapter_queue_conf *queue_conf)
225 : : {
226 [ # # ]: 0 : struct cnxk_eth_dev *cnxk_eth_dev = eth_dev->data->dev_private;
227 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
228 : 0 : uint16_t port = eth_dev->data->port_id;
229 : : struct cnxk_eth_rxq_sp *rxq_sp;
230 : : int i, rc = 0;
231 : :
232 [ # # ]: 0 : if (rx_queue_id < 0) {
233 [ # # ]: 0 : for (i = 0; i < eth_dev->data->nb_rx_queues; i++)
234 : 0 : rc |= cnxk_sso_rx_adapter_queue_add(event_dev, eth_dev,
235 : : i, queue_conf);
236 : : } else {
237 : 0 : rxq_sp = cnxk_eth_rxq_to_sp(
238 : 0 : eth_dev->data->rx_queues[rx_queue_id]);
239 : 0 : cnxk_sso_updt_xae_cnt(dev, rxq_sp, RTE_EVENT_TYPE_ETHDEV);
240 : 0 : rc = cnxk_sso_xae_reconfigure(
241 : : (struct rte_eventdev *)(uintptr_t)event_dev);
242 : 0 : rc |= cnxk_sso_rxq_enable(
243 : : cnxk_eth_dev, (uint16_t)rx_queue_id, port,
244 : : &queue_conf->ev,
245 : 0 : !!(queue_conf->rx_queue_flags &
246 : : RTE_EVENT_ETH_RX_ADAPTER_QUEUE_FLOW_ID_VALID));
247 [ # # ]: 0 : if (queue_conf->rx_queue_flags &
248 : : RTE_EVENT_ETH_RX_ADAPTER_QUEUE_EVENT_VECTOR) {
249 : 0 : cnxk_sso_updt_xae_cnt(dev, queue_conf->vector_mp,
250 : : RTE_EVENT_TYPE_ETHDEV_VECTOR);
251 : 0 : rc |= cnxk_sso_xae_reconfigure(
252 : : (struct rte_eventdev *)(uintptr_t)event_dev);
253 : 0 : rc |= cnxk_sso_rx_adapter_vwqe_enable(
254 : : cnxk_eth_dev, port, rx_queue_id,
255 : 0 : queue_conf->vector_sz,
256 : 0 : queue_conf->vector_timeout_ns,
257 : 0 : queue_conf->vector_mp);
258 : :
259 [ # # ]: 0 : if (cnxk_eth_dev->vec_drop_re_dis)
260 : 0 : rc |= roc_nix_rx_drop_re_set(&cnxk_eth_dev->nix,
261 : : false);
262 : : }
263 : :
264 : : /* Propagate force bp devarg */
265 : 0 : cnxk_eth_dev->nix.force_rx_aura_bp = dev->force_ena_bp;
266 [ # # ]: 0 : cnxk_sso_tstamp_cfg(eth_dev->data->port_id, cnxk_eth_dev, dev);
267 : 0 : cnxk_eth_dev->nb_rxq_sso++;
268 : : }
269 : :
270 [ # # ]: 0 : if (rc < 0) {
271 : 0 : plt_err("Failed to configure Rx adapter port=%d, q=%d", port,
272 : : queue_conf->ev.queue_id);
273 : 0 : return rc;
274 : : }
275 : :
276 : 0 : dev->rx_offloads |= cnxk_eth_dev->rx_offload_flags;
277 : 0 : return 0;
278 : : }
279 : :
280 : : int
281 : 0 : cnxk_sso_rx_adapter_queue_del(const struct rte_eventdev *event_dev,
282 : : const struct rte_eth_dev *eth_dev,
283 : : int32_t rx_queue_id)
284 : : {
285 : 0 : struct cnxk_eth_dev *cnxk_eth_dev = eth_dev->data->dev_private;
286 : : int i, rc = 0;
287 : :
288 : : RTE_SET_USED(event_dev);
289 [ # # ]: 0 : if (rx_queue_id < 0) {
290 [ # # ]: 0 : for (i = 0; i < eth_dev->data->nb_rx_queues; i++)
291 : 0 : cnxk_sso_rx_adapter_queue_del(event_dev, eth_dev, i);
292 : : } else {
293 : 0 : rc = cnxk_sso_rxq_disable(cnxk_eth_dev, (uint16_t)rx_queue_id);
294 : 0 : cnxk_eth_dev->nb_rxq_sso--;
295 : :
296 : : /* Enable drop_re if it was disabled earlier */
297 [ # # # # ]: 0 : if (cnxk_eth_dev->vec_drop_re_dis && !cnxk_eth_dev->nb_rxq_sso)
298 : 0 : rc |= roc_nix_rx_drop_re_set(&cnxk_eth_dev->nix, true);
299 : : }
300 : :
301 [ # # ]: 0 : if (rc < 0)
302 : 0 : plt_err("Failed to clear Rx adapter config port=%d, q=%d",
303 : : eth_dev->data->port_id, rx_queue_id);
304 : 0 : return rc;
305 : : }
306 : :
307 : : int
308 : 0 : cnxk_sso_rx_adapter_start(const struct rte_eventdev *event_dev,
309 : : const struct rte_eth_dev *eth_dev)
310 : : {
311 : 0 : struct cnxk_eth_dev *cnxk_eth_dev = eth_dev->data->dev_private;
312 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
313 : 0 : dev->rx_offloads |= cnxk_eth_dev->rx_offload_flags;
314 : 0 : return 0;
315 : : }
316 : :
317 : : int
318 : 0 : cnxk_sso_rx_adapter_stop(const struct rte_eventdev *event_dev,
319 : : const struct rte_eth_dev *eth_dev)
320 : : {
321 : : RTE_SET_USED(eth_dev);
322 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
323 : 0 : dev->rx_offloads = 0;
324 : 0 : return 0;
325 : : }
326 : :
327 : : static int
328 : 0 : cnxk_sso_sqb_aura_limit_edit(struct roc_nix_sq *sq, uint16_t nb_sqb_bufs)
329 : : {
330 : : int rc;
331 : :
332 [ # # ]: 0 : if (sq->aura_sqb_bufs != nb_sqb_bufs) {
333 : 0 : rc = roc_npa_aura_limit_modify(
334 : : sq->aura_handle,
335 : 0 : RTE_MIN(nb_sqb_bufs, sq->aura_sqb_bufs));
336 [ # # ]: 0 : if (rc < 0)
337 : : return rc;
338 : :
339 : 0 : sq->nb_sqb_bufs = RTE_MIN(nb_sqb_bufs, sq->aura_sqb_bufs) -
340 : 0 : sq->roc_nix->sqb_slack;
341 : : }
342 : : return 0;
343 : : }
344 : :
345 : : static void
346 : 0 : cnxk_sso_tx_queue_data_init(struct cnxk_sso_evdev *dev, uint64_t *txq_data,
347 : : uint16_t eth_port_id, uint16_t tx_queue_id)
348 : : {
349 : : uint64_t offset = 0;
350 : : int i;
351 : :
352 : 0 : dev->max_queue_id[0] = RTE_MAX(dev->max_queue_id[0], eth_port_id);
353 [ # # ]: 0 : for (i = 1; i < eth_port_id; i++) {
354 : 0 : offset += (dev->max_queue_id[i - 1] + 1);
355 : 0 : txq_data[i] |= offset << 48;
356 : : }
357 : 0 : dev->max_port_id = RTE_MAX(dev->max_port_id, eth_port_id);
358 : 0 : dev->max_queue_id[eth_port_id] =
359 : 0 : RTE_MAX(dev->max_queue_id[eth_port_id], tx_queue_id);
360 : 0 : }
361 : :
362 : : static void
363 : 0 : cnxk_sso_tx_queue_data_cpy(struct cnxk_sso_evdev *dev, uint64_t *txq_data,
364 : : uint64_t *otxq_data, uint16_t eth_port_id)
365 : : {
366 : : uint64_t offset = 0;
367 : : int i, j;
368 : :
369 [ # # ]: 0 : for (i = 1; i < eth_port_id; i++) {
370 : 0 : offset += (dev->max_queue_id[i - 1] + 1);
371 : 0 : txq_data[i] |= offset << 48;
372 : 0 : for (j = 0;
373 [ # # # # ]: 0 : (i < dev->max_port_id) && (j < dev->max_queue_id[i] + 1);
374 : 0 : j++)
375 : 0 : txq_data[offset + j] =
376 : 0 : otxq_data[(otxq_data[i] >> 48) + j];
377 : : }
378 : 0 : }
379 : :
380 : : static void
381 : 0 : cnxk_sso_tx_queue_data_cpy_max(struct cnxk_sso_evdev *dev, uint64_t *txq_data,
382 : : uint64_t *otxq_data, uint16_t eth_port_id,
383 : : uint16_t max_port_id, uint16_t max_queue_id)
384 : : {
385 : : uint64_t offset = 0;
386 : : int i, j;
387 : :
388 [ # # ]: 0 : for (i = 1; i < max_port_id + 1; i++) {
389 : 0 : offset += (dev->max_queue_id[i - 1] + 1);
390 : 0 : txq_data[i] |= offset << 48;
391 [ # # ]: 0 : for (j = 0; j < dev->max_queue_id[i] + 1; j++) {
392 [ # # # # ]: 0 : if (i == eth_port_id && j > max_queue_id)
393 : 0 : continue;
394 : 0 : txq_data[offset + j] =
395 : 0 : otxq_data[(otxq_data[i] >> 48) + j];
396 : : }
397 : : }
398 : 0 : }
399 : :
400 : : static void
401 : 0 : cnxk_sso_tx_queue_data_rewrite(struct cnxk_sso_evdev *dev, uint64_t *txq_data,
402 : : uint16_t eth_port_id, uint16_t tx_queue_id,
403 : : uint64_t *otxq_data, uint16_t max_port_id,
404 : : uint16_t max_queue_id)
405 : : {
406 : : int i;
407 : :
408 [ # # ]: 0 : for (i = 0; i < dev->max_queue_id[0] + 1; i++)
409 : 0 : txq_data[i] |= (otxq_data[i] & ~((BIT_ULL(16) - 1) << 48));
410 : :
411 [ # # ]: 0 : if (eth_port_id > max_port_id) {
412 : 0 : dev->max_queue_id[0] =
413 : 0 : RTE_MAX(dev->max_queue_id[0], eth_port_id);
414 : 0 : dev->max_port_id = RTE_MAX(dev->max_port_id, eth_port_id);
415 : :
416 : 0 : cnxk_sso_tx_queue_data_cpy(dev, txq_data, otxq_data,
417 : : eth_port_id);
418 : 0 : dev->max_queue_id[eth_port_id] =
419 : 0 : RTE_MAX(dev->max_queue_id[eth_port_id], tx_queue_id);
420 [ # # ]: 0 : } else if (tx_queue_id > max_queue_id) {
421 : 0 : dev->max_queue_id[eth_port_id] =
422 : 0 : RTE_MAX(dev->max_queue_id[eth_port_id], tx_queue_id);
423 : 0 : dev->max_port_id = RTE_MAX(max_port_id, eth_port_id);
424 : 0 : cnxk_sso_tx_queue_data_cpy_max(dev, txq_data, otxq_data,
425 : : eth_port_id, max_port_id,
426 : : max_queue_id);
427 : : }
428 : 0 : }
429 : :
430 : : static void
431 : 0 : cnxk_sso_tx_queue_data_sz(struct cnxk_sso_evdev *dev, uint16_t eth_port_id,
432 : : uint16_t tx_queue_id, uint16_t max_port_id,
433 : : uint16_t max_queue_id, uint64_t *r, size_t *sz)
434 : : {
435 : : uint64_t row = 0;
436 : : size_t size = 0;
437 : : int i;
438 : :
439 [ # # ]: 0 : if (dev->tx_adptr_data == NULL) {
440 : 0 : size = (eth_port_id + 1);
441 : 0 : size += (eth_port_id + tx_queue_id);
442 : 0 : row = 2 * eth_port_id;
443 : 0 : *r = row;
444 : 0 : *sz = size;
445 : 0 : return;
446 : : }
447 : :
448 [ # # ]: 0 : if (eth_port_id > max_port_id) {
449 : 0 : size = (RTE_MAX(eth_port_id, dev->max_queue_id[0]) + 1);
450 [ # # ]: 0 : for (i = 1; i < eth_port_id; i++)
451 : 0 : size += (dev->max_queue_id[i] + 1);
452 : : row = size;
453 : 0 : size += (tx_queue_id + 1);
454 [ # # ]: 0 : } else if (tx_queue_id > max_queue_id) {
455 : : size = !eth_port_id ?
456 [ # # ]: 0 : tx_queue_id + 1 :
457 : 0 : RTE_MAX(max_port_id, dev->max_queue_id[0]) + 1;
458 [ # # ]: 0 : for (i = 1; i < max_port_id + 1; i++) {
459 [ # # ]: 0 : if (i == eth_port_id) {
460 : : row = size;
461 : 0 : size += tx_queue_id + 1;
462 : : } else {
463 : 0 : size += dev->max_queue_id[i] + 1;
464 : : }
465 : : }
466 : : }
467 : 0 : *r = row;
468 : 0 : *sz = size;
469 : : }
470 : :
471 : : static int
472 [ # # ]: 0 : cnxk_sso_updt_tx_queue_data(const struct rte_eventdev *event_dev,
473 : : uint16_t eth_port_id, uint16_t tx_queue_id,
474 : : void *txq)
475 : : {
476 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
477 : 0 : uint16_t max_queue_id = dev->max_queue_id[eth_port_id];
478 : 0 : uint16_t max_port_id = dev->max_port_id;
479 : : uint64_t *txq_data = NULL;
480 : 0 : uint64_t row = 0;
481 : 0 : size_t size = 0;
482 : :
483 [ # # ]: 0 : if (((uint64_t)txq) & 0xFFFF000000000000)
484 : : return -EINVAL;
485 : :
486 : 0 : cnxk_sso_tx_queue_data_sz(dev, eth_port_id, tx_queue_id, max_port_id,
487 : : max_queue_id, &row, &size);
488 : :
489 : 0 : size *= sizeof(uint64_t);
490 : :
491 [ # # ]: 0 : if (size) {
492 : 0 : uint64_t *otxq_data = dev->tx_adptr_data;
493 : :
494 : 0 : txq_data = malloc(size);
495 [ # # ]: 0 : if (txq_data == NULL)
496 : : return -ENOMEM;
497 : : memset(txq_data, 0, size);
498 : 0 : txq_data[eth_port_id] = ((uint64_t)row) << 48;
499 : 0 : txq_data[row + tx_queue_id] = (uint64_t)txq;
500 : :
501 [ # # ]: 0 : if (otxq_data != NULL)
502 : 0 : cnxk_sso_tx_queue_data_rewrite(
503 : : dev, txq_data, eth_port_id, tx_queue_id,
504 : : otxq_data, max_port_id, max_queue_id);
505 : : else
506 : 0 : cnxk_sso_tx_queue_data_init(dev, txq_data, eth_port_id,
507 : : tx_queue_id);
508 : 0 : dev->tx_adptr_data_sz = size;
509 : 0 : free(otxq_data);
510 : 0 : dev->tx_adptr_data = txq_data;
511 : : } else {
512 : 0 : txq_data = dev->tx_adptr_data;
513 : 0 : row = txq_data[eth_port_id] >> 48;
514 : 0 : txq_data[row + tx_queue_id] &= ~(BIT_ULL(48) - 1);
515 : 0 : txq_data[row + tx_queue_id] |= (uint64_t)txq;
516 : : }
517 : :
518 : : return 0;
519 : : }
520 : :
521 : : int
522 : 0 : cnxk_sso_tx_adapter_queue_add(const struct rte_eventdev *event_dev,
523 : : const struct rte_eth_dev *eth_dev,
524 : : int32_t tx_queue_id)
525 : : {
526 : 0 : struct cnxk_eth_dev *cnxk_eth_dev = eth_dev->data->dev_private;
527 : : struct roc_nix_sq *sq;
528 : : int i, ret = 0;
529 : : void *txq;
530 : :
531 [ # # ]: 0 : if (tx_queue_id < 0) {
532 [ # # ]: 0 : for (i = 0; i < eth_dev->data->nb_tx_queues; i++)
533 : 0 : ret |= cnxk_sso_tx_adapter_queue_add(event_dev, eth_dev,
534 : : i);
535 : : } else {
536 : 0 : txq = eth_dev->data->tx_queues[tx_queue_id];
537 : 0 : sq = &cnxk_eth_dev->sqs[tx_queue_id];
538 : 0 : cnxk_sso_sqb_aura_limit_edit(sq, sq->aura_sqb_bufs);
539 : 0 : ret = cnxk_sso_updt_tx_queue_data(
540 : 0 : event_dev, eth_dev->data->port_id, tx_queue_id, txq);
541 [ # # ]: 0 : if (ret < 0)
542 : : return ret;
543 : : }
544 : :
545 [ # # ]: 0 : if (ret < 0) {
546 : 0 : plt_err("Failed to configure Tx adapter port=%d, q=%d",
547 : : eth_dev->data->port_id, tx_queue_id);
548 : 0 : return ret;
549 : : }
550 : :
551 : : return 0;
552 : : }
553 : :
554 : : int
555 : 0 : cnxk_sso_tx_adapter_queue_del(const struct rte_eventdev *event_dev,
556 : : const struct rte_eth_dev *eth_dev,
557 : : int32_t tx_queue_id)
558 : : {
559 : 0 : struct cnxk_eth_dev *cnxk_eth_dev = eth_dev->data->dev_private;
560 : : struct roc_nix_sq *sq;
561 : : int i, ret = 0;
562 : :
563 : : RTE_SET_USED(event_dev);
564 [ # # ]: 0 : if (tx_queue_id < 0) {
565 [ # # ]: 0 : for (i = 0; i < eth_dev->data->nb_tx_queues; i++)
566 : 0 : ret |= cnxk_sso_tx_adapter_queue_del(event_dev, eth_dev,
567 : : i);
568 : : } else {
569 : 0 : sq = &cnxk_eth_dev->sqs[tx_queue_id];
570 : 0 : cnxk_sso_sqb_aura_limit_edit(sq, sq->aura_sqb_bufs);
571 : 0 : ret = cnxk_sso_updt_tx_queue_data(
572 : 0 : event_dev, eth_dev->data->port_id, tx_queue_id, NULL);
573 [ # # ]: 0 : if (ret < 0)
574 : : return ret;
575 : : }
576 : :
577 [ # # ]: 0 : if (ret < 0) {
578 : 0 : plt_err("Failed to clear Tx adapter config port=%d, q=%d",
579 : : eth_dev->data->port_id, tx_queue_id);
580 : 0 : return ret;
581 : : }
582 : :
583 : : return 0;
584 : : }
585 : :
586 : : int
587 : 0 : cnxk_sso_tx_adapter_start(uint8_t id, const struct rte_eventdev *event_dev)
588 : : {
589 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
590 : :
591 : 0 : dev->tx_adptr_active_mask |= (1 << id);
592 : :
593 : 0 : return 0;
594 : : }
595 : :
596 : : int
597 : 0 : cnxk_sso_tx_adapter_stop(uint8_t id, const struct rte_eventdev *event_dev)
598 : : {
599 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
600 : :
601 : 0 : dev->tx_adptr_active_mask &= ~(1 << id);
602 : :
603 : 0 : return 0;
604 : : }
605 : :
606 : : int
607 [ # # ]: 0 : cnxk_sso_tx_adapter_free(uint8_t id __rte_unused,
608 : : const struct rte_eventdev *event_dev)
609 : : {
610 : : struct cnxk_sso_evdev *dev = cnxk_sso_pmd_priv(event_dev);
611 : :
612 [ # # # # ]: 0 : if (dev->tx_adptr_data_sz && dev->tx_adptr_active_mask == 0) {
613 : 0 : dev->tx_adptr_data_sz = 0;
614 : 0 : free(dev->tx_adptr_data);
615 : 0 : dev->tx_adptr_data = NULL;
616 : : }
617 : :
618 : 0 : return 0;
619 : : }
620 : :
621 : : static int
622 [ # # ]: 0 : crypto_adapter_qp_setup(const struct rte_cryptodev *cdev, struct cnxk_cpt_qp *qp,
623 : : const struct rte_event_crypto_adapter_queue_conf *conf)
624 : : {
625 : : char name[RTE_MEMPOOL_NAMESIZE];
626 : : uint32_t cache_size, nb_req;
627 : : unsigned int req_size;
628 : : uint32_t nb_desc_min;
629 : :
630 : : /*
631 : : * Update CPT FC threshold. Decrement by hardware burst size to allow
632 : : * simultaneous enqueue from all available cores.
633 : : */
634 [ # # ]: 0 : if (roc_model_is_cn10k())
635 : 0 : nb_desc_min = rte_lcore_count() * 32;
636 : : else
637 : 0 : nb_desc_min = rte_lcore_count() * 2;
638 : :
639 [ # # ]: 0 : if (qp->lmtline.fc_thresh < nb_desc_min) {
640 : 0 : plt_err("CPT queue depth not sufficient to allow enqueueing from %d cores",
641 : : rte_lcore_count());
642 : 0 : return -ENOSPC;
643 : : }
644 : :
645 : 0 : qp->lmtline.fc_thresh -= nb_desc_min;
646 : :
647 [ # # ]: 0 : snprintf(name, RTE_MEMPOOL_NAMESIZE, "cnxk_ca_req_%u:%u", cdev->data->dev_id, qp->lf.lf_id);
648 : : req_size = sizeof(struct cpt_inflight_req);
649 [ # # ]: 0 : cache_size = RTE_MIN(RTE_MEMPOOL_CACHE_MAX_SIZE, qp->lf.nb_desc / 1.5);
650 : 0 : nb_req = RTE_MAX(qp->lf.nb_desc, cache_size * rte_lcore_count());
651 : 0 : qp->ca.req_mp = rte_mempool_create(name, nb_req, req_size, cache_size, 0, NULL, NULL, NULL,
652 : 0 : NULL, rte_socket_id(), 0);
653 [ # # ]: 0 : if (qp->ca.req_mp == NULL)
654 : : return -ENOMEM;
655 : :
656 [ # # ]: 0 : if (conf != NULL) {
657 : 0 : qp->ca.vector_sz = conf->vector_sz;
658 : 0 : qp->ca.vector_mp = conf->vector_mp;
659 : : }
660 : 0 : qp->ca.enabled = true;
661 : :
662 : 0 : return 0;
663 : : }
664 : :
665 : : int
666 [ # # ]: 0 : cnxk_crypto_adapter_qp_add(const struct rte_eventdev *event_dev, const struct rte_cryptodev *cdev,
667 : : int32_t queue_pair_id,
668 : : const struct rte_event_crypto_adapter_queue_conf *conf)
669 : : {
670 : : struct cnxk_sso_evdev *sso_evdev = cnxk_sso_pmd_priv(event_dev);
671 : : uint32_t adptr_xae_cnt = 0;
672 : : struct cnxk_cpt_qp *qp;
673 : : int ret;
674 : :
675 [ # # ]: 0 : if (queue_pair_id == -1) {
676 : : uint16_t qp_id;
677 : :
678 [ # # ]: 0 : for (qp_id = 0; qp_id < cdev->data->nb_queue_pairs; qp_id++) {
679 : 0 : qp = cdev->data->queue_pairs[qp_id];
680 : 0 : ret = crypto_adapter_qp_setup(cdev, qp, conf);
681 [ # # ]: 0 : if (ret) {
682 : 0 : cnxk_crypto_adapter_qp_del(cdev, -1);
683 : 0 : return ret;
684 : : }
685 : 0 : adptr_xae_cnt += qp->ca.req_mp->size;
686 : : }
687 : : } else {
688 : 0 : qp = cdev->data->queue_pairs[queue_pair_id];
689 : 0 : ret = crypto_adapter_qp_setup(cdev, qp, conf);
690 [ # # ]: 0 : if (ret)
691 : : return ret;
692 : 0 : adptr_xae_cnt = qp->ca.req_mp->size;
693 : : }
694 : :
695 : : /* Update crypto adapter XAE count */
696 : 0 : sso_evdev->adptr_xae_cnt += adptr_xae_cnt;
697 : 0 : cnxk_sso_xae_reconfigure((struct rte_eventdev *)(uintptr_t)event_dev);
698 : :
699 : 0 : return 0;
700 : : }
701 : :
702 : : static int
703 : 0 : crypto_adapter_qp_free(struct cnxk_cpt_qp *qp)
704 : : {
705 : : int ret;
706 : :
707 : 0 : rte_mempool_free(qp->ca.req_mp);
708 : 0 : qp->ca.enabled = false;
709 : :
710 : 0 : ret = roc_cpt_lmtline_init(qp->lf.roc_cpt, &qp->lmtline, qp->lf.lf_id);
711 [ # # ]: 0 : if (ret < 0) {
712 : 0 : plt_err("Could not reset lmtline for queue pair %d", qp->lf.lf_id);
713 : 0 : return ret;
714 : : }
715 : :
716 : : return 0;
717 : : }
718 : :
719 : : int
720 : 0 : cnxk_crypto_adapter_qp_del(const struct rte_cryptodev *cdev,
721 : : int32_t queue_pair_id)
722 : : {
723 : : struct cnxk_cpt_qp *qp;
724 : :
725 [ # # ]: 0 : if (queue_pair_id == -1) {
726 : : uint16_t qp_id;
727 : :
728 [ # # ]: 0 : for (qp_id = 0; qp_id < cdev->data->nb_queue_pairs; qp_id++) {
729 : 0 : qp = cdev->data->queue_pairs[qp_id];
730 [ # # ]: 0 : if (qp->ca.enabled)
731 : 0 : crypto_adapter_qp_free(qp);
732 : : }
733 : : } else {
734 : 0 : qp = cdev->data->queue_pairs[queue_pair_id];
735 [ # # ]: 0 : if (qp->ca.enabled)
736 : 0 : crypto_adapter_qp_free(qp);
737 : : }
738 : :
739 : 0 : return 0;
740 : : }
741 : :
742 : : static int
743 : 0 : dma_adapter_vchan_setup(const int16_t dma_dev_id, struct cnxk_dpi_conf *vchan,
744 : : uint16_t vchan_id)
745 : : {
746 : : char name[RTE_MEMPOOL_NAMESIZE];
747 : : uint32_t cache_size, nb_req;
748 : : unsigned int req_size;
749 : :
750 : 0 : snprintf(name, RTE_MEMPOOL_NAMESIZE, "cnxk_dma_req_%u:%u", dma_dev_id, vchan_id);
751 : : req_size = sizeof(struct cnxk_dpi_compl_s);
752 : :
753 : 0 : nb_req = vchan->c_desc.max_cnt;
754 : : cache_size = 16;
755 : 0 : nb_req += (cache_size * rte_lcore_count());
756 : :
757 : 0 : vchan->adapter_info.req_mp = rte_mempool_create(name, nb_req, req_size, cache_size, 0,
758 : 0 : NULL, NULL, NULL, NULL, rte_socket_id(), 0);
759 [ # # ]: 0 : if (vchan->adapter_info.req_mp == NULL)
760 : : return -ENOMEM;
761 : :
762 : 0 : vchan->adapter_info.enabled = true;
763 : :
764 : 0 : return 0;
765 : : }
766 : :
767 : : int
768 [ # # ]: 0 : cnxk_dma_adapter_vchan_add(const struct rte_eventdev *event_dev,
769 : : const int16_t dma_dev_id, uint16_t vchan_id)
770 : : {
771 : : struct cnxk_sso_evdev *sso_evdev = cnxk_sso_pmd_priv(event_dev);
772 : : uint32_t adptr_xae_cnt = 0;
773 : : struct cnxk_dpi_vf_s *dpivf;
774 : : struct cnxk_dpi_conf *vchan;
775 : : int ret;
776 : :
777 : 0 : dpivf = rte_dma_fp_objs[dma_dev_id].dev_private;
778 [ # # ]: 0 : if ((int16_t)vchan_id == -1) {
779 : : uint16_t vchan_id;
780 : :
781 [ # # ]: 0 : for (vchan_id = 0; vchan_id < dpivf->num_vchans; vchan_id++) {
782 : 0 : vchan = &dpivf->conf[vchan_id];
783 : 0 : ret = dma_adapter_vchan_setup(dma_dev_id, vchan, vchan_id);
784 [ # # ]: 0 : if (ret) {
785 : 0 : cnxk_dma_adapter_vchan_del(dma_dev_id, -1);
786 : 0 : return ret;
787 : : }
788 : 0 : adptr_xae_cnt += vchan->adapter_info.req_mp->size;
789 : : }
790 : : } else {
791 : 0 : vchan = &dpivf->conf[vchan_id];
792 : 0 : ret = dma_adapter_vchan_setup(dma_dev_id, vchan, vchan_id);
793 [ # # ]: 0 : if (ret)
794 : : return ret;
795 : 0 : adptr_xae_cnt = vchan->adapter_info.req_mp->size;
796 : : }
797 : :
798 : : /* Update dma adapter XAE count */
799 : 0 : sso_evdev->adptr_xae_cnt += adptr_xae_cnt;
800 : 0 : cnxk_sso_xae_reconfigure((struct rte_eventdev *)(uintptr_t)event_dev);
801 : :
802 : 0 : return 0;
803 : : }
804 : :
805 : : static int
806 : : dma_adapter_vchan_free(struct cnxk_dpi_conf *vchan)
807 : : {
808 : 0 : rte_mempool_free(vchan->adapter_info.req_mp);
809 : 0 : vchan->adapter_info.enabled = false;
810 : :
811 : 0 : return 0;
812 : : }
813 : :
814 : : int
815 : 0 : cnxk_dma_adapter_vchan_del(const int16_t dma_dev_id, uint16_t vchan_id)
816 : : {
817 : : struct cnxk_dpi_vf_s *dpivf;
818 : : struct cnxk_dpi_conf *vchan;
819 : :
820 : 0 : dpivf = rte_dma_fp_objs[dma_dev_id].dev_private;
821 [ # # ]: 0 : if ((int16_t)vchan_id == -1) {
822 : : uint16_t vchan_id;
823 : :
824 [ # # ]: 0 : for (vchan_id = 0; vchan_id < dpivf->num_vchans; vchan_id++) {
825 : 0 : vchan = &dpivf->conf[vchan_id];
826 [ # # ]: 0 : if (vchan->adapter_info.enabled)
827 : : dma_adapter_vchan_free(vchan);
828 : : }
829 : : } else {
830 : 0 : vchan = &dpivf->conf[vchan_id];
831 [ # # ]: 0 : if (vchan->adapter_info.enabled)
832 : : dma_adapter_vchan_free(vchan);
833 : : }
834 : :
835 : 0 : return 0;
836 : : }
|