Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2021 Marvell International Ltd.
3 : : */
4 : :
5 : : #include <eal_export.h>
6 : : #include <rte_vect.h>
7 : :
8 : : #include "cnxk_dmadev.h"
9 : : #include <rte_event_dma_adapter.h>
10 : :
11 : : #include <cn10k_eventdev.h>
12 : : #include <cnxk_eventdev.h>
13 : :
14 : : static __plt_always_inline void
15 : : __dpi_cpy_scalar(uint64_t *src, uint64_t *dst, uint8_t n)
16 : : {
17 : : uint8_t i;
18 : :
19 [ # # # # : 0 : for (i = 0; i < n; i++)
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
20 : 0 : dst[i] = src[i];
21 : : }
22 : :
23 : : #if defined(RTE_ARCH_ARM64)
24 : : static __plt_always_inline void
25 : : __dpi_cpy_vector(uint64_t *src, uint64_t *dst, uint8_t n)
26 : : {
27 : : uint64x2_t vec;
28 : : uint8_t i;
29 : :
30 : : for (i = 0; i < n; i += 2) {
31 : : vec = vld1q_u64((const uint64_t *)&src[i]);
32 : : vst1q_u64(&dst[i], vec);
33 : : }
34 : : }
35 : :
36 : : static __plt_always_inline void
37 : : __dpi_cpy_vector_sg(const struct rte_dma_sge *src, uint64_t *dst, uint16_t n)
38 : : {
39 : : uint64x2_t mask = {0xFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL};
40 : : uint64x2_t vec;
41 : : uint8_t i;
42 : :
43 : : for (i = 0; i < n; i++) {
44 : : vec = vld1q_u64((const uint64_t *)&src[i]);
45 : : vec = vextq_u64(vec, vec, 1);
46 : : vec = vandq_u64(vec, mask);
47 : : vst1q_u64(dst, vec);
48 : : dst += 2;
49 : : }
50 : : }
51 : :
52 : : static __plt_always_inline uint8_t
53 : : __dpi_cpy_vector_sg_lmt(const struct rte_dma_sge *src, uint64_t *dst, uint16_t n, uint16_t lmt)
54 : : {
55 : : uint64x2_t mask = {0xFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL};
56 : : uint64x2_t vec;
57 : : uint8_t i;
58 : :
59 : : for (i = 0; i < n && lmt; i++) {
60 : : vec = vld1q_u64((const uint64_t *)&src[i]);
61 : : vec = vextq_u64(vec, vec, 1);
62 : : vec = vandq_u64(vec, mask);
63 : : vst1q_u64(dst, vec);
64 : : dst += 2;
65 : : lmt -= 2;
66 : : }
67 : :
68 : : return i;
69 : : }
70 : : #else
71 : : static __plt_always_inline void
72 : : __dpi_cpy_scalar_sg(const struct rte_dma_sge *src, uint64_t *dst, uint16_t n)
73 : : {
74 : : uint8_t i;
75 : :
76 [ # # # # : 0 : for (i = 0; i < n; i++) {
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
77 : 0 : *dst++ = src[i].length;
78 : 0 : *dst++ = src[i].addr;
79 : : }
80 : : }
81 : :
82 : : static __plt_always_inline uint8_t
83 : : __dpi_cpy_scalar_sg_lmt(const struct rte_dma_sge *src, uint64_t *dst, uint16_t n, uint16_t lmt)
84 : : {
85 : : uint8_t i;
86 : :
87 [ # # # # : 0 : for (i = 0; i < n && lmt; i++) {
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
88 : 0 : *dst++ = src[i].length;
89 : 0 : *dst++ = src[i].addr;
90 : 0 : lmt -= 2;
91 : : }
92 : :
93 : : return i;
94 : : }
95 : : #endif
96 : :
97 : : static __plt_always_inline void
98 : : __dpi_cpy(uint64_t *src, uint64_t *dst, uint8_t n)
99 : : {
100 : : #if defined(RTE_ARCH_ARM64)
101 : : __dpi_cpy_vector(src, dst, n);
102 : : #else
103 : : __dpi_cpy_scalar(src, dst, n);
104 : : #endif
105 : : }
106 : :
107 : : static __plt_always_inline void
108 : : __dpi_cpy_sg(const struct rte_dma_sge *src, uint64_t *dst, uint16_t n)
109 : : {
110 : : #if defined(RTE_ARCH_ARM64)
111 : : __dpi_cpy_vector_sg(src, dst, n);
112 : : #else
113 : : __dpi_cpy_scalar_sg(src, dst, n);
114 : : #endif
115 : : }
116 : :
117 : : static __plt_always_inline uint8_t
118 : : __dpi_cpy_sg_lmt(const struct rte_dma_sge *src, uint64_t *dst, uint16_t n, uint16_t lmt)
119 : : {
120 : : #if defined(RTE_ARCH_ARM64)
121 : : return __dpi_cpy_vector_sg_lmt(src, dst, n, lmt);
122 : : #else
123 : : return __dpi_cpy_scalar_sg_lmt(src, dst, n, lmt);
124 : : #endif
125 : : }
126 : :
127 : : static __plt_always_inline int
128 : : __dpi_queue_write_single(struct cnxk_dpi_vf_s *dpi, uint64_t *cmd)
129 : : {
130 : 0 : uint64_t *ptr = dpi->chunk_base;
131 : :
132 : : /* Check if command fits in the current chunk. */
133 [ # # ]: 0 : if (dpi->chunk_head + CNXK_DPI_DW_PER_SINGLE_CMD < dpi->chunk_size_m1) {
134 : 0 : ptr += dpi->chunk_head;
135 : :
136 : : __dpi_cpy_scalar(cmd, ptr, CNXK_DPI_DW_PER_SINGLE_CMD);
137 : 0 : dpi->chunk_head += CNXK_DPI_DW_PER_SINGLE_CMD;
138 : : } else {
139 : 0 : uint64_t *new_buff = NULL;
140 : : int count;
141 : :
142 [ # # # # : 0 : if (rte_mempool_get(dpi->chunk_pool, (void **)&new_buff) < 0) {
# # # # ]
143 : 0 : plt_dpi_dbg("Failed to alloc next buffer from NPA");
144 : 0 : return -ENOSPC;
145 : : }
146 : :
147 : : /*
148 : : * Figure out how many cmd words will fit in the current chunk
149 : : * and copy them.
150 : : */
151 : 0 : count = dpi->chunk_size_m1 - dpi->chunk_head;
152 : 0 : ptr += dpi->chunk_head;
153 : :
154 : 0 : __dpi_cpy_scalar(cmd, ptr, count);
155 : :
156 : 0 : ptr += count;
157 : 0 : *ptr = (uint64_t)new_buff;
158 : : ptr = new_buff;
159 : :
160 : : /* Copy the remaining cmd words to new chunk. */
161 : 0 : __dpi_cpy_scalar(cmd + count, ptr, CNXK_DPI_DW_PER_SINGLE_CMD - count);
162 : :
163 : 0 : dpi->chunk_base = new_buff;
164 : 0 : dpi->chunk_head = CNXK_DPI_DW_PER_SINGLE_CMD - count;
165 : : }
166 : :
167 : : return 0;
168 : : }
169 : :
170 : : static __plt_always_inline int
171 : : __dpi_queue_write_sg(struct cnxk_dpi_vf_s *dpi, uint64_t *hdr, const struct rte_dma_sge *src,
172 : : const struct rte_dma_sge *dst, uint16_t nb_src, uint16_t nb_dst)
173 : : {
174 : 0 : uint8_t cmd_len = CNXK_DPI_CMD_LEN(nb_src, nb_dst);
175 : 0 : uint64_t *ptr = dpi->chunk_base;
176 : :
177 : : /* Check if command fits in the current chunk. */
178 [ # # ]: 0 : if (dpi->chunk_head + cmd_len < dpi->chunk_size_m1) {
179 : 0 : ptr += dpi->chunk_head;
180 : :
181 : : __dpi_cpy(hdr, ptr, CNXK_DPI_HDR_LEN);
182 : 0 : ptr += CNXK_DPI_HDR_LEN;
183 : : __dpi_cpy_sg(src, ptr, nb_src);
184 : 0 : ptr += (nb_src << 1);
185 : : __dpi_cpy_sg(dst, ptr, nb_dst);
186 : :
187 : 0 : dpi->chunk_head += cmd_len;
188 : : } else {
189 : 0 : uint64_t *new_buff = NULL, *buf;
190 : : uint16_t count;
191 : :
192 [ # # # # : 0 : if (rte_mempool_get(dpi->chunk_pool, (void **)&new_buff) < 0) {
# # # # #
# # # # #
# # # # #
# ]
193 : 0 : plt_dpi_dbg("Failed to alloc next buffer from NPA");
194 : 0 : return -ENOSPC;
195 : : }
196 : :
197 : : /*
198 : : * Figure out how many cmd words will fit in the current chunk
199 : : * and copy them, copy the rest to the new buffer.
200 : : */
201 : 0 : count = dpi->chunk_size_m1 - dpi->chunk_head;
202 : 0 : ptr += dpi->chunk_head;
203 : 0 : buf = new_buff;
204 [ # # # # : 0 : if (count <= 4) {
# # # # #
# ]
205 : 0 : __dpi_cpy(hdr, ptr, count);
206 : 0 : ptr += count;
207 : : __dpi_cpy(&hdr[count], buf, 4);
208 : 0 : buf += (4 - count);
209 : : } else {
210 : : uint8_t i;
211 : :
212 : : __dpi_cpy(hdr, ptr, 4);
213 : 0 : ptr += 4;
214 : 0 : count -= 4;
215 : :
216 : : i = __dpi_cpy_sg_lmt(src, ptr, nb_src, count);
217 : 0 : src += i;
218 : 0 : nb_src -= i;
219 : 0 : count -= (i << 1);
220 : 0 : ptr += (i << 1);
221 : :
222 : : i = __dpi_cpy_sg_lmt(dst, ptr, nb_dst, count);
223 : 0 : dst += i;
224 : 0 : nb_dst -= i;
225 : 0 : ptr += (i << 1);
226 : : }
227 : 0 : *ptr = (uint64_t)new_buff;
228 : :
229 : 0 : __dpi_cpy_sg(src, buf, nb_src);
230 : 0 : buf += (nb_src << 1);
231 : :
232 : 0 : __dpi_cpy_sg(dst, buf, nb_dst);
233 : 0 : buf += (nb_dst << 1);
234 : :
235 : 0 : dpi->chunk_base = new_buff;
236 : 0 : dpi->chunk_head = buf - new_buff;
237 : : }
238 : :
239 : : return 0;
240 : : }
241 : :
242 : : int
243 : 0 : cnxk_dmadev_copy(void *dev_private, uint16_t vchan, rte_iova_t src, rte_iova_t dst, uint32_t length,
244 : : uint64_t flags)
245 : : {
246 : : struct cnxk_dpi_vf_s *dpivf = dev_private;
247 : 0 : struct cnxk_dpi_conf *dpi_conf = &dpivf->conf[vchan];
248 : : uint64_t cmd[CNXK_DPI_DW_PER_SINGLE_CMD];
249 : : uint8_t *comp_ptr;
250 : : int rc;
251 : :
252 [ # # ]: 0 : if (unlikely(((dpi_conf->c_desc.tail + 1) & dpi_conf->c_desc.max_cnt) ==
253 : : dpi_conf->c_desc.head))
254 : : return -ENOSPC;
255 : :
256 : 0 : comp_ptr = &dpi_conf->c_desc.compl_ptr[dpi_conf->c_desc.tail * CNXK_DPI_COMPL_OFFSET];
257 : 0 : CNXK_DPI_STRM_INC(dpi_conf->c_desc, tail);
258 : :
259 : 0 : cmd[0] = (1UL << 54) | (1UL << 48);
260 : 0 : cmd[1] = dpi_conf->cmd.u | ((flags & RTE_DMA_OP_FLAG_AUTO_FREE) << 37);
261 : 0 : cmd[2] = (uint64_t)comp_ptr;
262 : 0 : cmd[4] = length;
263 : 0 : cmd[6] = length;
264 : :
265 : : /*
266 : : * For inbound case, src pointers are last pointers.
267 : : * For all other cases, src pointers are first pointers.
268 : : */
269 [ # # ]: 0 : if (((dpi_conf->cmd.u >> 48) & DPI_HDR_XTYPE_MASK) == DPI_XTYPE_INBOUND) {
270 : 0 : cmd[5] = dst;
271 : 0 : cmd[7] = src;
272 : : } else {
273 : 0 : cmd[5] = src;
274 : 0 : cmd[7] = dst;
275 : : }
276 : :
277 : : rc = __dpi_queue_write_single(dpivf, cmd);
278 [ # # ]: 0 : if (unlikely(rc)) {
279 [ # # ]: 0 : CNXK_DPI_STRM_DEC(dpi_conf->c_desc, tail);
280 : 0 : return rc;
281 : : }
282 : :
283 [ # # ]: 0 : if (flags & RTE_DMA_OP_FLAG_SUBMIT) {
284 : : rte_wmb();
285 : 0 : plt_write64(dpivf->total_pnum_words + CNXK_DPI_DW_PER_SINGLE_CMD,
286 : : dpivf->rdpi.rbase + DPI_VDMA_DBELL);
287 : 0 : dpivf->total_pnum_words = 0;
288 : : } else {
289 : 0 : dpivf->total_pnum_words += CNXK_DPI_DW_PER_SINGLE_CMD;
290 : : }
291 : :
292 : 0 : dpi_conf->stats.submitted += 1;
293 : :
294 : 0 : return dpi_conf->desc_idx++;
295 : : }
296 : :
297 : : int
298 : 0 : cnxk_dmadev_copy_sg(void *dev_private, uint16_t vchan, const struct rte_dma_sge *src,
299 : : const struct rte_dma_sge *dst, uint16_t nb_src, uint16_t nb_dst, uint64_t flags)
300 : : {
301 : : struct cnxk_dpi_vf_s *dpivf = dev_private;
302 : 0 : struct cnxk_dpi_conf *dpi_conf = &dpivf->conf[vchan];
303 : : const struct rte_dma_sge *fptr, *lptr;
304 : : uint8_t *comp_ptr;
305 : : uint64_t hdr[4];
306 : : int rc;
307 : :
308 [ # # ]: 0 : if (unlikely(((dpi_conf->c_desc.tail + 1) & dpi_conf->c_desc.max_cnt) ==
309 : : dpi_conf->c_desc.head))
310 : : return -ENOSPC;
311 : :
312 : 0 : comp_ptr = &dpi_conf->c_desc.compl_ptr[dpi_conf->c_desc.tail * CNXK_DPI_COMPL_OFFSET];
313 : 0 : CNXK_DPI_STRM_INC(dpi_conf->c_desc, tail);
314 : :
315 : 0 : hdr[1] = dpi_conf->cmd.u | ((flags & RTE_DMA_OP_FLAG_AUTO_FREE) << 37);
316 : 0 : hdr[2] = (uint64_t)comp_ptr;
317 : :
318 : : /*
319 : : * For inbound case, src pointers are last pointers.
320 : : * For all other cases, src pointers are first pointers.
321 : : */
322 [ # # ]: 0 : if (((dpi_conf->cmd.u >> 48) & DPI_HDR_XTYPE_MASK) == DPI_XTYPE_INBOUND) {
323 : : fptr = dst;
324 : : lptr = src;
325 : : RTE_SWAP(nb_src, nb_dst);
326 : : } else {
327 : : fptr = src;
328 : : lptr = dst;
329 : : }
330 : 0 : hdr[0] = ((uint64_t)nb_dst << 54) | (uint64_t)nb_src << 48;
331 : :
332 [ # # ]: 0 : rc = __dpi_queue_write_sg(dpivf, hdr, fptr, lptr, nb_src, nb_dst);
333 [ # # ]: 0 : if (unlikely(rc)) {
334 [ # # ]: 0 : CNXK_DPI_STRM_DEC(dpi_conf->c_desc, tail);
335 : 0 : return rc;
336 : : }
337 : :
338 [ # # ]: 0 : if (flags & RTE_DMA_OP_FLAG_SUBMIT) {
339 : : rte_wmb();
340 : 0 : plt_write64(dpivf->total_pnum_words + CNXK_DPI_CMD_LEN(nb_src, nb_dst),
341 : : dpivf->rdpi.rbase + DPI_VDMA_DBELL);
342 : 0 : dpivf->total_pnum_words = 0;
343 : : } else {
344 : 0 : dpivf->total_pnum_words += CNXK_DPI_CMD_LEN(nb_src, nb_dst);
345 : : }
346 : :
347 : 0 : dpi_conf->stats.submitted += 1;
348 : :
349 : 0 : return dpi_conf->desc_idx++;
350 : : }
351 : :
352 : : int
353 : 0 : cn10k_dmadev_copy(void *dev_private, uint16_t vchan, rte_iova_t src, rte_iova_t dst,
354 : : uint32_t length, uint64_t flags)
355 : : {
356 : : struct cnxk_dpi_vf_s *dpivf = dev_private;
357 : 0 : struct cnxk_dpi_conf *dpi_conf = &dpivf->conf[vchan];
358 : : uint64_t cmd[CNXK_DPI_DW_PER_SINGLE_CMD];
359 : : uint8_t *comp_ptr;
360 : : int rc;
361 : :
362 [ # # ]: 0 : if (unlikely(((dpi_conf->c_desc.tail + 1) & dpi_conf->c_desc.max_cnt) ==
363 : : dpi_conf->c_desc.head))
364 : : return -ENOSPC;
365 : :
366 : 0 : comp_ptr = &dpi_conf->c_desc.compl_ptr[dpi_conf->c_desc.tail * CNXK_DPI_COMPL_OFFSET];
367 : 0 : CNXK_DPI_STRM_INC(dpi_conf->c_desc, tail);
368 : :
369 : 0 : cmd[0] = dpi_conf->cmd.u | (1U << 6) | 1U;
370 : 0 : cmd[1] = (uint64_t)comp_ptr;
371 : 0 : cmd[2] = (1UL << 47) | ((flags & RTE_DMA_OP_FLAG_AUTO_FREE) << 43);
372 : 0 : cmd[4] = length;
373 : 0 : cmd[5] = src;
374 : 0 : cmd[6] = length;
375 [ # # ]: 0 : cmd[7] = dst;
376 : :
377 : : rc = __dpi_queue_write_single(dpivf, cmd);
378 [ # # ]: 0 : if (unlikely(rc)) {
379 [ # # ]: 0 : CNXK_DPI_STRM_DEC(dpi_conf->c_desc, tail);
380 : 0 : return rc;
381 : : }
382 : :
383 [ # # ]: 0 : if (flags & RTE_DMA_OP_FLAG_SUBMIT) {
384 : : rte_wmb();
385 : 0 : plt_write64(dpivf->total_pnum_words + CNXK_DPI_DW_PER_SINGLE_CMD,
386 : : dpivf->rdpi.rbase + DPI_VDMA_DBELL);
387 : 0 : dpivf->total_pnum_words = 0;
388 : : } else {
389 : 0 : dpivf->total_pnum_words += CNXK_DPI_DW_PER_SINGLE_CMD;
390 : : }
391 : :
392 : 0 : dpi_conf->stats.submitted += 1;
393 : :
394 : 0 : return dpi_conf->desc_idx++;
395 : : }
396 : :
397 : : int
398 : 0 : cn10k_dmadev_copy_sg(void *dev_private, uint16_t vchan, const struct rte_dma_sge *src,
399 : : const struct rte_dma_sge *dst, uint16_t nb_src, uint16_t nb_dst,
400 : : uint64_t flags)
401 : : {
402 : : struct cnxk_dpi_vf_s *dpivf = dev_private;
403 : 0 : struct cnxk_dpi_conf *dpi_conf = &dpivf->conf[vchan];
404 : : uint8_t *comp_ptr;
405 : : uint64_t hdr[4];
406 : : int rc;
407 : :
408 [ # # ]: 0 : if (unlikely(((dpi_conf->c_desc.tail + 1) & dpi_conf->c_desc.max_cnt) ==
409 : : dpi_conf->c_desc.head))
410 : : return -ENOSPC;
411 : :
412 : 0 : comp_ptr = &dpi_conf->c_desc.compl_ptr[dpi_conf->c_desc.tail * CNXK_DPI_COMPL_OFFSET];
413 : 0 : CNXK_DPI_STRM_INC(dpi_conf->c_desc, tail);
414 : :
415 : 0 : hdr[0] = dpi_conf->cmd.u | (nb_dst << 6) | nb_src;
416 : 0 : hdr[1] = (uint64_t)comp_ptr;
417 : 0 : hdr[2] = (1UL << 47) | ((flags & RTE_DMA_OP_FLAG_AUTO_FREE) << 43);
418 : :
419 [ # # ]: 0 : rc = __dpi_queue_write_sg(dpivf, hdr, src, dst, nb_src, nb_dst);
420 [ # # ]: 0 : if (unlikely(rc)) {
421 [ # # ]: 0 : CNXK_DPI_STRM_DEC(dpi_conf->c_desc, tail);
422 : 0 : return rc;
423 : : }
424 : :
425 [ # # ]: 0 : if (flags & RTE_DMA_OP_FLAG_SUBMIT) {
426 : : rte_wmb();
427 : 0 : plt_write64(dpivf->total_pnum_words + CNXK_DPI_CMD_LEN(nb_src, nb_dst),
428 : : dpivf->rdpi.rbase + DPI_VDMA_DBELL);
429 : 0 : dpivf->total_pnum_words = 0;
430 : : } else {
431 : 0 : dpivf->total_pnum_words += CNXK_DPI_CMD_LEN(nb_src, nb_dst);
432 : : }
433 : :
434 : 0 : dpi_conf->stats.submitted += 1;
435 : :
436 : 0 : return dpi_conf->desc_idx++;
437 : : }
438 : :
439 : : static inline uint64_t
440 : : cnxk_dma_adapter_format_event(uint64_t event)
441 : : {
442 : : uint64_t w0;
443 : 0 : w0 = (event & 0xFFC000000000) >> 6 |
444 : 0 : (event & 0xFFFFFFF) | RTE_EVENT_TYPE_DMADEV << 28;
445 : :
446 : : return w0;
447 : : }
448 : :
449 : : RTE_EXPORT_INTERNAL_SYMBOL(cn10k_dma_adapter_enqueue)
450 : : uint16_t
451 : 0 : cn10k_dma_adapter_enqueue(void *ws, struct rte_event ev[], uint16_t nb_events)
452 : : {
453 : : const struct rte_dma_sge *src, *dst;
454 : : struct rte_event_dma_adapter_op *op;
455 : : struct cnxk_dpi_conf *dpi_conf;
456 : : struct cnxk_dpi_vf_s *dpivf;
457 : : struct cn10k_sso_hws *work;
458 : : uint16_t nb_src, nb_dst;
459 : : rte_mcslock_t mcs_lock_me;
460 : : uint64_t hdr[4];
461 : : uint16_t count;
462 : : int rc;
463 : :
464 : : work = (struct cn10k_sso_hws *)ws;
465 : :
466 [ # # ]: 0 : for (count = 0; count < nb_events; count++) {
467 : 0 : op = ev[count].event_ptr;
468 : 0 : dpivf = rte_dma_fp_objs[op->dma_dev_id].dev_private;
469 : 0 : dpi_conf = &dpivf->conf[op->vchan];
470 : :
471 : 0 : nb_src = op->nb_src & CNXK_DPI_MAX_POINTER;
472 : 0 : nb_dst = op->nb_dst & CNXK_DPI_MAX_POINTER;
473 : :
474 : 0 : hdr[0] = dpi_conf->cmd.u | ((uint64_t)DPI_HDR_PT_WQP << 54);
475 : 0 : hdr[0] |= (nb_dst << 6) | nb_src;
476 : 0 : hdr[1] = (uint64_t)op;
477 : 0 : hdr[2] = cnxk_dma_adapter_format_event(ev[count].event);
478 : :
479 : 0 : src = &op->src_dst_seg[0];
480 : 0 : dst = &op->src_dst_seg[op->nb_src];
481 : :
482 [ # # ]: 0 : if (CNXK_TAG_IS_HEAD(work->gw_rdata) ||
483 [ # # ]: 0 : ((CNXK_TT_FROM_TAG(work->gw_rdata) == SSO_TT_ORDERED) &&
484 [ # # ]: 0 : (ev[count].sched_type & DPI_HDR_TT_MASK) == RTE_SCHED_TYPE_ORDERED))
485 : 0 : roc_sso_hws_head_wait(work->base);
486 : :
487 : 0 : rte_mcslock_lock(&dpivf->mcs_lock, &mcs_lock_me);
488 : : rc = __dpi_queue_write_sg(dpivf, hdr, src, dst, nb_src, nb_dst);
489 [ # # ]: 0 : if (unlikely(rc)) {
490 : 0 : rte_mcslock_unlock(&dpivf->mcs_lock, &mcs_lock_me);
491 : 0 : return rc;
492 : : }
493 : :
494 [ # # ]: 0 : if (op->flags & RTE_DMA_OP_FLAG_SUBMIT) {
495 : : rte_wmb();
496 : 0 : plt_write64(dpivf->total_pnum_words + CNXK_DPI_CMD_LEN(nb_src, nb_dst),
497 : : dpivf->rdpi.rbase + DPI_VDMA_DBELL);
498 : 0 : dpivf->total_pnum_words = 0;
499 : : } else {
500 : 0 : dpivf->total_pnum_words += CNXK_DPI_CMD_LEN(nb_src, nb_dst);
501 : : }
502 : 0 : dpi_conf->stats.submitted += 1;
503 : 0 : rte_mcslock_unlock(&dpivf->mcs_lock, &mcs_lock_me);
504 : : }
505 : :
506 : : return count;
507 : : }
508 : :
509 : : RTE_EXPORT_INTERNAL_SYMBOL(cn9k_dma_adapter_dual_enqueue)
510 : : uint16_t
511 : 0 : cn9k_dma_adapter_dual_enqueue(void *ws, struct rte_event ev[], uint16_t nb_events)
512 : : {
513 : : const struct rte_dma_sge *fptr, *lptr;
514 : : struct rte_event_dma_adapter_op *op;
515 : : struct cn9k_sso_hws_dual *work;
516 : : struct cnxk_dpi_conf *dpi_conf;
517 : : struct cnxk_dpi_vf_s *dpivf;
518 : : struct rte_event *rsp_info;
519 : : uint16_t nb_src, nb_dst;
520 : : rte_mcslock_t mcs_lock_me;
521 : : uint64_t hdr[4];
522 : : uint16_t count;
523 : : int rc;
524 : :
525 : : work = (struct cn9k_sso_hws_dual *)ws;
526 : :
527 [ # # ]: 0 : for (count = 0; count < nb_events; count++) {
528 : 0 : op = ev[count].event_ptr;
529 : : rsp_info = (struct rte_event *)((uint8_t *)op +
530 : : sizeof(struct rte_event_dma_adapter_op));
531 : 0 : dpivf = rte_dma_fp_objs[op->dma_dev_id].dev_private;
532 : 0 : dpi_conf = &dpivf->conf[op->vchan];
533 : :
534 : 0 : hdr[1] = dpi_conf->cmd.u | ((uint64_t)DPI_HDR_PT_WQP << 36);
535 : 0 : hdr[2] = (uint64_t)op;
536 : :
537 : 0 : nb_src = op->nb_src & CNXK_DPI_MAX_POINTER;
538 : 0 : nb_dst = op->nb_dst & CNXK_DPI_MAX_POINTER;
539 : : /*
540 : : * For inbound case, src pointers are last pointers.
541 : : * For all other cases, src pointers are first pointers.
542 : : */
543 [ # # ]: 0 : if (((dpi_conf->cmd.u >> 48) & DPI_HDR_XTYPE_MASK) == DPI_XTYPE_INBOUND) {
544 : 0 : fptr = &op->src_dst_seg[nb_src];
545 : 0 : lptr = &op->src_dst_seg[0];
546 : : RTE_SWAP(nb_src, nb_dst);
547 : : } else {
548 : 0 : fptr = &op->src_dst_seg[0];
549 : 0 : lptr = &op->src_dst_seg[nb_src];
550 : : }
551 : :
552 : 0 : hdr[0] = ((uint64_t)nb_dst << 54) | (uint64_t)nb_src << 48;
553 : 0 : hdr[0] |= cnxk_dma_adapter_format_event(rsp_info->event);
554 : :
555 [ # # ]: 0 : if ((rsp_info->sched_type & DPI_HDR_TT_MASK) == RTE_SCHED_TYPE_ORDERED)
556 : 0 : roc_sso_hws_head_wait(work->base[!work->vws]);
557 : :
558 : 0 : rte_mcslock_lock(&dpivf->mcs_lock, &mcs_lock_me);
559 [ # # ]: 0 : rc = __dpi_queue_write_sg(dpivf, hdr, fptr, lptr, nb_src, nb_dst);
560 [ # # ]: 0 : if (unlikely(rc)) {
561 : 0 : rte_mcslock_unlock(&dpivf->mcs_lock, &mcs_lock_me);
562 : 0 : return rc;
563 : : }
564 : :
565 [ # # ]: 0 : if (op->flags & RTE_DMA_OP_FLAG_SUBMIT) {
566 : : rte_wmb();
567 : 0 : plt_write64(dpivf->total_pnum_words + CNXK_DPI_CMD_LEN(nb_src, nb_dst),
568 : : dpivf->rdpi.rbase + DPI_VDMA_DBELL);
569 : 0 : dpivf->total_pnum_words = 0;
570 : : } else {
571 : 0 : dpivf->total_pnum_words += CNXK_DPI_CMD_LEN(nb_src, nb_dst);
572 : : }
573 : 0 : dpi_conf->stats.submitted += 1;
574 : 0 : rte_mcslock_unlock(&dpivf->mcs_lock, &mcs_lock_me);
575 : : }
576 : :
577 : : return count;
578 : : }
579 : :
580 : : RTE_EXPORT_INTERNAL_SYMBOL(cn9k_dma_adapter_enqueue)
581 : : uint16_t
582 : 0 : cn9k_dma_adapter_enqueue(void *ws, struct rte_event ev[], uint16_t nb_events)
583 : : {
584 : : const struct rte_dma_sge *fptr, *lptr;
585 : : struct rte_event_dma_adapter_op *op;
586 : : struct cnxk_dpi_conf *dpi_conf;
587 : : struct cnxk_dpi_vf_s *dpivf;
588 : : struct cn9k_sso_hws *work;
589 : : uint16_t nb_src, nb_dst;
590 : : rte_mcslock_t mcs_lock_me;
591 : : uint64_t hdr[4];
592 : : uint16_t count;
593 : : int rc;
594 : :
595 : : work = (struct cn9k_sso_hws *)ws;
596 : :
597 [ # # ]: 0 : for (count = 0; count < nb_events; count++) {
598 : 0 : op = ev[count].event_ptr;
599 : 0 : dpivf = rte_dma_fp_objs[op->dma_dev_id].dev_private;
600 : 0 : dpi_conf = &dpivf->conf[op->vchan];
601 : :
602 : 0 : hdr[1] = dpi_conf->cmd.u | ((uint64_t)DPI_HDR_PT_WQP << 36);
603 : 0 : hdr[2] = (uint64_t)op;
604 : :
605 : 0 : nb_src = op->nb_src & CNXK_DPI_MAX_POINTER;
606 : 0 : nb_dst = op->nb_dst & CNXK_DPI_MAX_POINTER;
607 : : /*
608 : : * For inbound case, src pointers are last pointers.
609 : : * For all other cases, src pointers are first pointers.
610 : : */
611 [ # # ]: 0 : if (((dpi_conf->cmd.u >> 48) & DPI_HDR_XTYPE_MASK) == DPI_XTYPE_INBOUND) {
612 : 0 : fptr = &op->src_dst_seg[nb_src];
613 : 0 : lptr = &op->src_dst_seg[0];
614 : : RTE_SWAP(nb_src, nb_dst);
615 : : } else {
616 : 0 : fptr = &op->src_dst_seg[0];
617 : 0 : lptr = &op->src_dst_seg[nb_src];
618 : : }
619 : :
620 : 0 : hdr[0] = ((uint64_t)nb_dst << 54) | (uint64_t)nb_src << 48;
621 : 0 : hdr[0] |= cnxk_dma_adapter_format_event(ev[count].event);
622 : :
623 [ # # ]: 0 : if ((ev[count].sched_type & DPI_HDR_TT_MASK) == RTE_SCHED_TYPE_ORDERED)
624 : 0 : roc_sso_hws_head_wait(work->base);
625 : :
626 : 0 : rte_mcslock_lock(&dpivf->mcs_lock, &mcs_lock_me);
627 [ # # ]: 0 : rc = __dpi_queue_write_sg(dpivf, hdr, fptr, lptr, nb_src, nb_dst);
628 [ # # ]: 0 : if (unlikely(rc)) {
629 : 0 : rte_mcslock_unlock(&dpivf->mcs_lock, &mcs_lock_me);
630 : 0 : return rc;
631 : : }
632 : :
633 [ # # ]: 0 : if (op->flags & RTE_DMA_OP_FLAG_SUBMIT) {
634 : : rte_wmb();
635 : 0 : plt_write64(dpivf->total_pnum_words + CNXK_DPI_CMD_LEN(nb_src, nb_dst),
636 : : dpivf->rdpi.rbase + DPI_VDMA_DBELL);
637 : 0 : dpivf->total_pnum_words = 0;
638 : : } else {
639 : 0 : dpivf->total_pnum_words += CNXK_DPI_CMD_LEN(nb_src, nb_dst);
640 : : }
641 : 0 : dpi_conf->stats.submitted += 1;
642 : 0 : rte_mcslock_unlock(&dpivf->mcs_lock, &mcs_lock_me);
643 : : }
644 : :
645 : : return count;
646 : : }
647 : :
648 : : RTE_EXPORT_INTERNAL_SYMBOL(cnxk_dma_adapter_dequeue)
649 : : uintptr_t
650 : 0 : cnxk_dma_adapter_dequeue(uintptr_t get_work1)
651 : : {
652 : : struct rte_event_dma_adapter_op *op;
653 : : struct cnxk_dpi_conf *dpi_conf;
654 : : struct cnxk_dpi_vf_s *dpivf;
655 : :
656 : 0 : op = (struct rte_event_dma_adapter_op *)get_work1;
657 : 0 : dpivf = rte_dma_fp_objs[op->dma_dev_id].dev_private;
658 : 0 : dpi_conf = &dpivf->conf[op->vchan];
659 : :
660 [ # # ]: 0 : if (rte_atomic_load_explicit((RTE_ATOMIC(uint64_t) *)&op->impl_opaque[0],
661 : : rte_memory_order_relaxed) != 0)
662 : 0 : rte_atomic_fetch_add_explicit((RTE_ATOMIC(uint64_t) *)&dpi_conf->stats.errors, 1,
663 : : rte_memory_order_relaxed);
664 : :
665 : : /* Take into account errors also. This is similar to
666 : : * cnxk_dmadev_completed_status().
667 : : */
668 : 0 : rte_atomic_fetch_add_explicit((RTE_ATOMIC(uint64_t) *)&dpi_conf->stats.completed, 1,
669 : : rte_memory_order_relaxed);
670 : :
671 : 0 : return (uintptr_t)op;
672 : : }
|
