Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (c) 2023 Marvell.
3 : : */
4 : :
5 : : #include <eventdev_pmd.h>
6 : : #include <rte_service_component.h>
7 : :
8 : : #include "rte_event_dma_adapter.h"
9 : :
10 : : #define DMA_BATCH_SIZE 32
11 : : #define DMA_DEFAULT_MAX_NB 128
12 : : #define DMA_ADAPTER_NAME_LEN 32
13 : : #define DMA_ADAPTER_BUFFER_SIZE 1024
14 : :
15 : : #define DMA_ADAPTER_OPS_BUFFER_SIZE (DMA_BATCH_SIZE + DMA_BATCH_SIZE)
16 : :
17 : : #define DMA_ADAPTER_ARRAY "event_dma_adapter_array"
18 : :
19 : : /* Macros to check for valid adapter */
20 : : #define EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, retval) \
21 : : do { \
22 : : if (!edma_adapter_valid_id(id)) { \
23 : : RTE_EDEV_LOG_ERR("Invalid DMA adapter id = %d", id); \
24 : : return retval; \
25 : : } \
26 : : } while (0)
27 : :
28 : : /* DMA ops circular buffer */
29 : : struct __rte_cache_aligned dma_ops_circular_buffer {
30 : : /* Index of head element */
31 : : uint16_t head;
32 : :
33 : : /* Index of tail element */
34 : : uint16_t tail;
35 : :
36 : : /* Number of elements in buffer */
37 : : uint16_t count;
38 : :
39 : : /* Size of circular buffer */
40 : : uint16_t size;
41 : :
42 : : /* Pointer to hold rte_event_dma_adapter_op for processing */
43 : : struct rte_event_dma_adapter_op **op_buffer;
44 : : };
45 : :
46 : : /* Vchan information */
47 : : struct __rte_cache_aligned dma_vchan_info {
48 : : /* Set to indicate vchan queue is enabled */
49 : : bool vq_enabled;
50 : :
51 : : /* Circular buffer for batching DMA ops to dma_dev */
52 : : struct dma_ops_circular_buffer dma_buf;
53 : : };
54 : :
55 : : /* DMA device information */
56 : : struct __rte_cache_aligned dma_device_info {
57 : : /* Pointer to vchan queue info */
58 : : struct dma_vchan_info *vchanq;
59 : :
60 : : /* Pointer to vchan queue info.
61 : : * This holds ops passed by application till the
62 : : * dma completion is done.
63 : : */
64 : : struct dma_vchan_info *tqmap;
65 : :
66 : : /* If num_vchanq > 0, the start callback will
67 : : * be invoked if not already invoked
68 : : */
69 : : uint16_t num_vchanq;
70 : :
71 : : /* Number of vchans configured for a DMA device. */
72 : : uint16_t num_dma_dev_vchan;
73 : :
74 : : /* Next queue pair to be processed */
75 : : uint16_t next_vchan_id;
76 : :
77 : : /* Set to indicate processing has been started */
78 : : uint8_t dev_started;
79 : :
80 : : /* Set to indicate dmadev->eventdev packet
81 : : * transfer uses a hardware mechanism
82 : : */
83 : : uint8_t internal_event_port;
84 : : };
85 : :
86 : : struct __rte_cache_aligned event_dma_adapter {
87 : : /* Event device identifier */
88 : : uint8_t eventdev_id;
89 : :
90 : : /* Event port identifier */
91 : : uint8_t event_port_id;
92 : :
93 : : /* Adapter mode */
94 : : enum rte_event_dma_adapter_mode mode;
95 : :
96 : : /* Memory allocation name */
97 : : char mem_name[DMA_ADAPTER_NAME_LEN];
98 : :
99 : : /* Socket identifier cached from eventdev */
100 : : int socket_id;
101 : :
102 : : /* Lock to serialize config updates with service function */
103 : : rte_spinlock_t lock;
104 : :
105 : : /* Next dma device to be processed */
106 : : uint16_t next_dmadev_id;
107 : :
108 : : /* DMA device structure array */
109 : : struct dma_device_info *dma_devs;
110 : :
111 : : /* Circular buffer for processing DMA ops to eventdev */
112 : : struct dma_ops_circular_buffer ebuf;
113 : :
114 : : /* Configuration callback for rte_service configuration */
115 : : rte_event_dma_adapter_conf_cb conf_cb;
116 : :
117 : : /* Configuration callback argument */
118 : : void *conf_arg;
119 : :
120 : : /* Set if default_cb is being used */
121 : : int default_cb_arg;
122 : :
123 : : /* No. of vchan queue configured */
124 : : uint16_t nb_vchanq;
125 : :
126 : : /* Per adapter EAL service ID */
127 : : uint32_t service_id;
128 : :
129 : : /* Service initialization state */
130 : : uint8_t service_initialized;
131 : :
132 : : /* Max DMA ops processed in any service function invocation */
133 : : uint32_t max_nb;
134 : :
135 : : /* Store event port's implicit release capability */
136 : : uint8_t implicit_release_disabled;
137 : :
138 : : /* Flag to indicate backpressure at dma_dev
139 : : * Stop further dequeuing events from eventdev
140 : : */
141 : : bool stop_enq_to_dma_dev;
142 : :
143 : : /* Loop counter to flush dma ops */
144 : : uint16_t transmit_loop_count;
145 : :
146 : : /* Per instance stats structure */
147 : : struct rte_event_dma_adapter_stats dma_stats;
148 : : };
149 : :
150 : : static struct event_dma_adapter **event_dma_adapter;
151 : :
152 : : static inline int
153 : : edma_adapter_valid_id(uint8_t id)
154 : : {
155 : : return id < RTE_EVENT_DMA_ADAPTER_MAX_INSTANCE;
156 : : }
157 : :
158 : : static inline struct event_dma_adapter *
159 : : edma_id_to_adapter(uint8_t id)
160 : : {
161 [ # # # # : 0 : return event_dma_adapter ? event_dma_adapter[id] : NULL;
# # # # #
# # # # #
# # # # #
# # # #
# ]
162 : : }
163 : :
164 : : static int
165 : 0 : edma_array_init(void)
166 : : {
167 : : const struct rte_memzone *mz;
168 : : uint32_t sz;
169 : :
170 : 0 : mz = rte_memzone_lookup(DMA_ADAPTER_ARRAY);
171 [ # # ]: 0 : if (mz == NULL) {
172 : : sz = sizeof(struct event_dma_adapter *) * RTE_EVENT_DMA_ADAPTER_MAX_INSTANCE;
173 : : sz = RTE_ALIGN(sz, RTE_CACHE_LINE_SIZE);
174 : :
175 : 0 : mz = rte_memzone_reserve_aligned(DMA_ADAPTER_ARRAY, sz, rte_socket_id(), 0,
176 : : RTE_CACHE_LINE_SIZE);
177 [ # # ]: 0 : if (mz == NULL) {
178 : 0 : RTE_EDEV_LOG_ERR("Failed to reserve memzone : %s, err = %d",
179 : : DMA_ADAPTER_ARRAY, rte_errno);
180 : 0 : return -rte_errno;
181 : : }
182 : : }
183 : :
184 : 0 : event_dma_adapter = mz->addr;
185 : :
186 : 0 : return 0;
187 : : }
188 : :
189 : : static inline bool
190 : : edma_circular_buffer_batch_ready(struct dma_ops_circular_buffer *bufp)
191 : : {
192 : : return bufp->count >= DMA_BATCH_SIZE;
193 : : }
194 : :
195 : : static inline bool
196 : : edma_circular_buffer_space_for_batch(struct dma_ops_circular_buffer *bufp)
197 : : {
198 : 0 : return (bufp->size - bufp->count) >= DMA_BATCH_SIZE;
199 : : }
200 : :
201 : : static inline int
202 : : edma_circular_buffer_init(const char *name, struct dma_ops_circular_buffer *buf, uint16_t sz)
203 : : {
204 : 0 : buf->op_buffer = rte_zmalloc(name, sizeof(struct rte_event_dma_adapter_op *) * sz, 0);
205 [ # # # # : 0 : if (buf->op_buffer == NULL)
# # ]
206 : : return -ENOMEM;
207 : :
208 : 0 : buf->size = sz;
209 : :
210 : : return 0;
211 : : }
212 : :
213 : : static inline void
214 : : edma_circular_buffer_free(struct dma_ops_circular_buffer *buf)
215 : : {
216 : 0 : rte_free(buf->op_buffer);
217 : : }
218 : :
219 : : static inline int
220 : : edma_circular_buffer_add(struct dma_ops_circular_buffer *bufp, struct rte_event_dma_adapter_op *op)
221 : : {
222 : : uint16_t *tail = &bufp->tail;
223 : :
224 : 0 : bufp->op_buffer[*tail] = op;
225 : :
226 : : /* circular buffer, go round */
227 : 0 : *tail = (*tail + 1) % bufp->size;
228 : 0 : bufp->count++;
229 : :
230 : : return 0;
231 : : }
232 : :
233 : : static inline int
234 : 0 : edma_circular_buffer_flush_to_dma_dev(struct event_dma_adapter *adapter,
235 : : struct dma_ops_circular_buffer *bufp, uint8_t dma_dev_id,
236 : : uint16_t vchan, uint16_t *nb_ops_flushed)
237 : : {
238 : : struct rte_event_dma_adapter_op *op;
239 : : uint16_t *head = &bufp->head;
240 : : uint16_t *tail = &bufp->tail;
241 : : struct dma_vchan_info *tq;
242 : : uint16_t n;
243 : : uint16_t i;
244 : : int ret;
245 : :
246 [ # # ]: 0 : if (*tail > *head)
247 : 0 : n = *tail - *head;
248 [ # # ]: 0 : else if (*tail < *head)
249 : 0 : n = bufp->size - *head;
250 : : else {
251 : 0 : *nb_ops_flushed = 0;
252 : 0 : return 0; /* buffer empty */
253 : : }
254 : :
255 : 0 : tq = &adapter->dma_devs[dma_dev_id].tqmap[vchan];
256 : :
257 [ # # ]: 0 : for (i = 0; i < n; i++) {
258 : 0 : op = bufp->op_buffer[*head];
259 [ # # ]: 0 : if (op->nb_src == 1 && op->nb_dst == 1)
260 : 0 : ret = rte_dma_copy(dma_dev_id, vchan, op->src_dst_seg[0].addr,
261 : : op->src_dst_seg[1].addr, op->src_dst_seg[0].length,
262 : : op->flags);
263 : : else
264 : 0 : ret = rte_dma_copy_sg(dma_dev_id, vchan, &op->src_dst_seg[0],
265 : 0 : &op->src_dst_seg[op->nb_src], op->nb_src, op->nb_dst,
266 : : op->flags);
267 [ # # ]: 0 : if (ret < 0)
268 : : break;
269 : :
270 : : /* Enqueue in transaction queue. */
271 : : edma_circular_buffer_add(&tq->dma_buf, op);
272 : :
273 : 0 : *head = (*head + 1) % bufp->size;
274 : : }
275 : :
276 : 0 : *nb_ops_flushed = i;
277 : 0 : bufp->count -= *nb_ops_flushed;
278 [ # # ]: 0 : if (!bufp->count) {
279 : 0 : *head = 0;
280 : 0 : *tail = 0;
281 : : }
282 : :
283 [ # # ]: 0 : return *nb_ops_flushed == n ? 0 : -1;
284 : : }
285 : :
286 : : static int
287 [ # # ]: 0 : edma_default_config_cb(uint8_t id, uint8_t evdev_id, struct rte_event_dma_adapter_conf *conf,
288 : : void *arg)
289 : : {
290 : : struct rte_event_port_conf *port_conf;
291 : : struct rte_event_dev_config dev_conf;
292 : : struct event_dma_adapter *adapter;
293 : : struct rte_eventdev *dev;
294 : : uint8_t port_id;
295 : : int started;
296 : : int ret;
297 : :
298 : : adapter = edma_id_to_adapter(id);
299 [ # # ]: 0 : if (adapter == NULL)
300 : : return -EINVAL;
301 : :
302 : 0 : dev = &rte_eventdevs[adapter->eventdev_id];
303 : 0 : dev_conf = dev->data->dev_conf;
304 : :
305 : 0 : started = dev->data->dev_started;
306 [ # # ]: 0 : if (started)
307 : 0 : rte_event_dev_stop(evdev_id);
308 : :
309 : 0 : port_id = dev_conf.nb_event_ports;
310 : 0 : dev_conf.nb_event_ports += 1;
311 : :
312 : : port_conf = arg;
313 [ # # ]: 0 : if (port_conf->event_port_cfg & RTE_EVENT_PORT_CFG_SINGLE_LINK)
314 : 0 : dev_conf.nb_single_link_event_port_queues += 1;
315 : :
316 : 0 : ret = rte_event_dev_configure(evdev_id, &dev_conf);
317 [ # # ]: 0 : if (ret) {
318 : 0 : RTE_EDEV_LOG_ERR("Failed to configure event dev %u", evdev_id);
319 [ # # ]: 0 : if (started) {
320 [ # # ]: 0 : if (rte_event_dev_start(evdev_id))
321 : : return -EIO;
322 : : }
323 : 0 : return ret;
324 : : }
325 : :
326 : 0 : ret = rte_event_port_setup(evdev_id, port_id, port_conf);
327 [ # # ]: 0 : if (ret) {
328 : 0 : RTE_EDEV_LOG_ERR("Failed to setup event port %u", port_id);
329 : 0 : return ret;
330 : : }
331 : :
332 : 0 : conf->event_port_id = port_id;
333 : 0 : conf->max_nb = DMA_DEFAULT_MAX_NB;
334 [ # # ]: 0 : if (started)
335 : 0 : ret = rte_event_dev_start(evdev_id);
336 : :
337 : 0 : adapter->default_cb_arg = 1;
338 : 0 : adapter->event_port_id = conf->event_port_id;
339 : :
340 : 0 : return ret;
341 : : }
342 : :
343 : : int
344 : 0 : rte_event_dma_adapter_create_ext(uint8_t id, uint8_t evdev_id,
345 : : rte_event_dma_adapter_conf_cb conf_cb,
346 : : enum rte_event_dma_adapter_mode mode, void *conf_arg)
347 : : {
348 : : struct rte_event_dev_info dev_info;
349 : : struct event_dma_adapter *adapter;
350 : : char name[DMA_ADAPTER_NAME_LEN];
351 : : struct rte_dma_info info;
352 : : uint16_t num_dma_dev;
353 : : int socket_id;
354 : : uint8_t i;
355 : : int ret;
356 : :
357 [ # # ]: 0 : EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
358 [ # # ]: 0 : RTE_EVENTDEV_VALID_DEVID_OR_ERR_RET(evdev_id, -EINVAL);
359 : :
360 [ # # ]: 0 : if (conf_cb == NULL)
361 : : return -EINVAL;
362 : :
363 [ # # ]: 0 : if (event_dma_adapter == NULL) {
364 : 0 : ret = edma_array_init();
365 [ # # ]: 0 : if (ret)
366 : : return ret;
367 : : }
368 : :
369 : : adapter = edma_id_to_adapter(id);
370 [ # # ]: 0 : if (adapter != NULL) {
371 : 0 : RTE_EDEV_LOG_ERR("ML adapter ID %d already exists!", id);
372 : 0 : return -EEXIST;
373 : : }
374 : :
375 : 0 : socket_id = rte_event_dev_socket_id(evdev_id);
376 : : snprintf(name, DMA_ADAPTER_NAME_LEN, "rte_event_dma_adapter_%d", id);
377 : 0 : adapter = rte_zmalloc_socket(name, sizeof(struct event_dma_adapter), RTE_CACHE_LINE_SIZE,
378 : : socket_id);
379 [ # # ]: 0 : if (adapter == NULL) {
380 : 0 : RTE_EDEV_LOG_ERR("Failed to get mem for event ML adapter!");
381 : 0 : return -ENOMEM;
382 : : }
383 : :
384 : : if (edma_circular_buffer_init("edma_circular_buffer", &adapter->ebuf,
385 : : DMA_ADAPTER_BUFFER_SIZE)) {
386 : 0 : RTE_EDEV_LOG_ERR("Failed to get memory for event adapter circular buffer");
387 : 0 : rte_free(adapter);
388 : 0 : return -ENOMEM;
389 : : }
390 : :
391 : 0 : ret = rte_event_dev_info_get(evdev_id, &dev_info);
392 [ # # ]: 0 : if (ret < 0) {
393 : 0 : RTE_EDEV_LOG_ERR("Failed to get info for eventdev %d: %s", evdev_id,
394 : : dev_info.driver_name);
395 : : edma_circular_buffer_free(&adapter->ebuf);
396 : 0 : rte_free(adapter);
397 : 0 : return ret;
398 : : }
399 : :
400 : 0 : num_dma_dev = rte_dma_count_avail();
401 : :
402 : 0 : adapter->eventdev_id = evdev_id;
403 : 0 : adapter->mode = mode;
404 : 0 : rte_strscpy(adapter->mem_name, name, DMA_ADAPTER_NAME_LEN);
405 : 0 : adapter->socket_id = socket_id;
406 : 0 : adapter->conf_cb = conf_cb;
407 : 0 : adapter->conf_arg = conf_arg;
408 : 0 : adapter->dma_devs = rte_zmalloc_socket(adapter->mem_name,
409 : : num_dma_dev * sizeof(struct dma_device_info), 0,
410 : : socket_id);
411 [ # # ]: 0 : if (adapter->dma_devs == NULL) {
412 : 0 : RTE_EDEV_LOG_ERR("Failed to get memory for DMA devices");
413 : : edma_circular_buffer_free(&adapter->ebuf);
414 : 0 : rte_free(adapter);
415 : 0 : return -ENOMEM;
416 : : }
417 : :
418 : : rte_spinlock_init(&adapter->lock);
419 [ # # ]: 0 : for (i = 0; i < num_dma_dev; i++) {
420 : 0 : ret = rte_dma_info_get(i, &info);
421 [ # # ]: 0 : if (ret) {
422 : 0 : RTE_EDEV_LOG_ERR("Failed to get dma device info");
423 : : edma_circular_buffer_free(&adapter->ebuf);
424 : 0 : rte_free(adapter);
425 : 0 : return ret;
426 : : }
427 : :
428 : 0 : adapter->dma_devs[i].num_dma_dev_vchan = info.nb_vchans;
429 : : }
430 : :
431 : 0 : event_dma_adapter[id] = adapter;
432 : :
433 : 0 : return 0;
434 : : }
435 : :
436 : : int
437 : 0 : rte_event_dma_adapter_create(uint8_t id, uint8_t evdev_id, struct rte_event_port_conf *port_config,
438 : : enum rte_event_dma_adapter_mode mode)
439 : : {
440 : : struct rte_event_port_conf *pc;
441 : : int ret;
442 : :
443 [ # # ]: 0 : if (port_config == NULL)
444 : : return -EINVAL;
445 : :
446 [ # # ]: 0 : EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
447 : :
448 : 0 : pc = rte_malloc(NULL, sizeof(struct rte_event_port_conf), 0);
449 [ # # ]: 0 : if (pc == NULL)
450 : : return -ENOMEM;
451 : :
452 : : rte_memcpy(pc, port_config, sizeof(struct rte_event_port_conf));
453 : 0 : ret = rte_event_dma_adapter_create_ext(id, evdev_id, edma_default_config_cb, mode, pc);
454 [ # # ]: 0 : if (ret != 0)
455 : 0 : rte_free(pc);
456 : :
457 : : return ret;
458 : : }
459 : :
460 : : int
461 : 0 : rte_event_dma_adapter_free(uint8_t id)
462 : : {
463 : : struct event_dma_adapter *adapter;
464 : :
465 [ # # ]: 0 : EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
466 : :
467 : : adapter = edma_id_to_adapter(id);
468 [ # # ]: 0 : if (adapter == NULL)
469 : : return -EINVAL;
470 : :
471 : 0 : rte_free(adapter->conf_arg);
472 : 0 : rte_free(adapter->dma_devs);
473 : : edma_circular_buffer_free(&adapter->ebuf);
474 : 0 : rte_free(adapter);
475 : 0 : event_dma_adapter[id] = NULL;
476 : :
477 : 0 : return 0;
478 : : }
479 : :
480 : : int
481 : 0 : rte_event_dma_adapter_event_port_get(uint8_t id, uint8_t *event_port_id)
482 : : {
483 : : struct event_dma_adapter *adapter;
484 : :
485 [ # # ]: 0 : EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
486 : :
487 : : adapter = edma_id_to_adapter(id);
488 [ # # ]: 0 : if (adapter == NULL || event_port_id == NULL)
489 : : return -EINVAL;
490 : :
491 : 0 : *event_port_id = adapter->event_port_id;
492 : :
493 : 0 : return 0;
494 : : }
495 : :
496 : : static inline unsigned int
497 : 0 : edma_enq_to_dma_dev(struct event_dma_adapter *adapter, struct rte_event *ev, unsigned int cnt)
498 : : {
499 : : struct rte_event_dma_adapter_stats *stats = &adapter->dma_stats;
500 : : struct dma_vchan_info *vchan_qinfo = NULL;
501 : : struct rte_event_dma_adapter_op *dma_op;
502 : 0 : uint16_t vchan, nb_enqueued = 0;
503 : : int16_t dma_dev_id;
504 : : unsigned int i, n;
505 : : int ret;
506 : :
507 : : ret = 0;
508 : : n = 0;
509 : 0 : stats->event_deq_count += cnt;
510 : :
511 [ # # ]: 0 : for (i = 0; i < cnt; i++) {
512 : 0 : dma_op = ev[i].event_ptr;
513 [ # # ]: 0 : if (dma_op == NULL)
514 : 0 : continue;
515 : :
516 : 0 : dma_op->impl_opaque[0] = ev[i].event;
517 : 0 : dma_dev_id = dma_op->dma_dev_id;
518 : 0 : vchan = dma_op->vchan;
519 : 0 : vchan_qinfo = &adapter->dma_devs[dma_dev_id].vchanq[vchan];
520 [ # # ]: 0 : if (!vchan_qinfo->vq_enabled) {
521 [ # # ]: 0 : if (dma_op != NULL && dma_op->op_mp != NULL)
522 : 0 : rte_mempool_put(dma_op->op_mp, dma_op);
523 : 0 : continue;
524 : : }
525 : 0 : edma_circular_buffer_add(&vchan_qinfo->dma_buf, dma_op);
526 : :
527 [ # # ]: 0 : if (edma_circular_buffer_batch_ready(&vchan_qinfo->dma_buf)) {
528 : 0 : ret = edma_circular_buffer_flush_to_dma_dev(adapter, &vchan_qinfo->dma_buf,
529 : : dma_dev_id, vchan,
530 : : &nb_enqueued);
531 : 0 : stats->dma_enq_count += nb_enqueued;
532 : 0 : n += nb_enqueued;
533 : :
534 : : /**
535 : : * If some dma ops failed to flush to dma_dev and
536 : : * space for another batch is not available, stop
537 : : * dequeue from eventdev momentarily
538 : : */
539 [ # # # # ]: 0 : if (unlikely(ret < 0 &&
540 : : !edma_circular_buffer_space_for_batch(&vchan_qinfo->dma_buf)))
541 : 0 : adapter->stop_enq_to_dma_dev = true;
542 : : }
543 : : }
544 : :
545 : 0 : return n;
546 : : }
547 : :
548 : : static unsigned int
549 : 0 : edma_adapter_dev_flush(struct event_dma_adapter *adapter, int16_t dma_dev_id,
550 : : uint16_t *nb_ops_flushed)
551 : : {
552 : : struct dma_vchan_info *vchan_info;
553 : : struct dma_device_info *dev_info;
554 : 0 : uint16_t nb = 0, nb_enqueued = 0;
555 : : uint16_t vchan, nb_vchans;
556 : :
557 : 0 : dev_info = &adapter->dma_devs[dma_dev_id];
558 : 0 : nb_vchans = dev_info->num_vchanq;
559 : :
560 [ # # ]: 0 : for (vchan = 0; vchan < nb_vchans; vchan++) {
561 : :
562 : 0 : vchan_info = &dev_info->vchanq[vchan];
563 [ # # # # ]: 0 : if (unlikely(vchan_info == NULL || !vchan_info->vq_enabled))
564 : 0 : continue;
565 : :
566 : 0 : edma_circular_buffer_flush_to_dma_dev(adapter, &vchan_info->dma_buf, dma_dev_id,
567 : : vchan, &nb_enqueued);
568 : 0 : *nb_ops_flushed += vchan_info->dma_buf.count;
569 : 0 : nb += nb_enqueued;
570 : : }
571 : :
572 : 0 : return nb;
573 : : }
574 : :
575 : : static unsigned int
576 : 0 : edma_adapter_enq_flush(struct event_dma_adapter *adapter)
577 : : {
578 : : struct rte_event_dma_adapter_stats *stats = &adapter->dma_stats;
579 : : int16_t dma_dev_id;
580 : : uint16_t nb_enqueued = 0;
581 : 0 : uint16_t nb_ops_flushed = 0;
582 : 0 : uint16_t num_dma_dev = rte_dma_count_avail();
583 : :
584 [ # # ]: 0 : for (dma_dev_id = 0; dma_dev_id < num_dma_dev; dma_dev_id++)
585 : 0 : nb_enqueued += edma_adapter_dev_flush(adapter, dma_dev_id, &nb_ops_flushed);
586 : : /**
587 : : * Enable dequeue from eventdev if all ops from circular
588 : : * buffer flushed to dma_dev
589 : : */
590 [ # # ]: 0 : if (!nb_ops_flushed)
591 : 0 : adapter->stop_enq_to_dma_dev = false;
592 : :
593 : 0 : stats->dma_enq_count += nb_enqueued;
594 : :
595 : 0 : return nb_enqueued;
596 : : }
597 : :
598 : : /* Flush an instance's enqueue buffers every DMA_ENQ_FLUSH_THRESHOLD
599 : : * iterations of edma_adapter_enq_run()
600 : : */
601 : : #define DMA_ENQ_FLUSH_THRESHOLD 1024
602 : :
603 : : static int
604 : 0 : edma_adapter_enq_run(struct event_dma_adapter *adapter, unsigned int max_enq)
605 : : {
606 : : struct rte_event_dma_adapter_stats *stats = &adapter->dma_stats;
607 : 0 : uint8_t event_port_id = adapter->event_port_id;
608 : 0 : uint8_t event_dev_id = adapter->eventdev_id;
609 : : struct rte_event ev[DMA_BATCH_SIZE];
610 : : unsigned int nb_enq, nb_enqueued;
611 : : uint16_t n;
612 : :
613 [ # # ]: 0 : if (adapter->mode == RTE_EVENT_DMA_ADAPTER_OP_NEW)
614 : : return 0;
615 : :
616 : : nb_enqueued = 0;
617 [ # # ]: 0 : for (nb_enq = 0; nb_enq < max_enq; nb_enq += n) {
618 : :
619 [ # # ]: 0 : if (unlikely(adapter->stop_enq_to_dma_dev)) {
620 : 0 : nb_enqueued += edma_adapter_enq_flush(adapter);
621 : :
622 [ # # ]: 0 : if (unlikely(adapter->stop_enq_to_dma_dev))
623 : : break;
624 : : }
625 : :
626 : 0 : stats->event_poll_count++;
627 : 0 : n = rte_event_dequeue_burst(event_dev_id, event_port_id, ev, DMA_BATCH_SIZE, 0);
628 : :
629 [ # # ]: 0 : if (!n)
630 : : break;
631 : :
632 : 0 : nb_enqueued += edma_enq_to_dma_dev(adapter, ev, n);
633 : : }
634 : :
635 [ # # ]: 0 : if ((++adapter->transmit_loop_count & (DMA_ENQ_FLUSH_THRESHOLD - 1)) == 0)
636 : 0 : nb_enqueued += edma_adapter_enq_flush(adapter);
637 : :
638 : 0 : return nb_enqueued;
639 : : }
640 : :
641 : : #define DMA_ADAPTER_MAX_EV_ENQ_RETRIES 100
642 : :
643 : : static inline uint16_t
644 : 0 : edma_ops_enqueue_burst(struct event_dma_adapter *adapter, struct rte_event_dma_adapter_op **ops,
645 : : uint16_t num)
646 : : {
647 : : struct rte_event_dma_adapter_stats *stats = &adapter->dma_stats;
648 : 0 : uint8_t event_port_id = adapter->event_port_id;
649 : 0 : uint8_t event_dev_id = adapter->eventdev_id;
650 : : struct rte_event events[DMA_BATCH_SIZE];
651 : : uint16_t nb_enqueued, nb_ev;
652 : : uint8_t retry;
653 : : uint8_t i;
654 : :
655 : : nb_ev = 0;
656 : : retry = 0;
657 : : nb_enqueued = 0;
658 : 0 : num = RTE_MIN(num, DMA_BATCH_SIZE);
659 [ # # ]: 0 : for (i = 0; i < num; i++) {
660 : 0 : struct rte_event *ev = &events[nb_ev++];
661 : :
662 : 0 : ev->event = ops[i]->impl_opaque[0];
663 : 0 : ev->event_ptr = ops[i];
664 : 0 : ev->event_type = RTE_EVENT_TYPE_DMADEV;
665 [ # # ]: 0 : if (adapter->implicit_release_disabled)
666 : 0 : ev->op = RTE_EVENT_OP_FORWARD;
667 : : else
668 : 0 : ev->op = RTE_EVENT_OP_NEW;
669 : 0 : ev->event = ops[i]->event_meta;
670 : : }
671 : :
672 : : do {
673 : 0 : nb_enqueued += rte_event_enqueue_burst(event_dev_id, event_port_id,
674 : 0 : &events[nb_enqueued], nb_ev - nb_enqueued);
675 : :
676 [ # # # # ]: 0 : } while (retry++ < DMA_ADAPTER_MAX_EV_ENQ_RETRIES && nb_enqueued < nb_ev);
677 : :
678 : 0 : stats->event_enq_fail_count += nb_ev - nb_enqueued;
679 : 0 : stats->event_enq_count += nb_enqueued;
680 : 0 : stats->event_enq_retry_count += retry - 1;
681 : :
682 : 0 : return nb_enqueued;
683 : : }
684 : :
685 : : static int
686 : 0 : edma_circular_buffer_flush_to_evdev(struct event_dma_adapter *adapter,
687 : : struct dma_ops_circular_buffer *bufp,
688 : : uint16_t *enqueue_count)
689 : : {
690 : 0 : struct rte_event_dma_adapter_op **ops = bufp->op_buffer;
691 : : uint16_t n = 0, nb_ops_flushed;
692 : : uint16_t *head = &bufp->head;
693 : : uint16_t *tail = &bufp->tail;
694 : :
695 [ # # ]: 0 : if (*tail > *head)
696 : 0 : n = *tail - *head;
697 [ # # ]: 0 : else if (*tail < *head)
698 : 0 : n = bufp->size - *head;
699 : : else {
700 [ # # ]: 0 : if (enqueue_count)
701 : 0 : *enqueue_count = 0;
702 : 0 : return 0; /* buffer empty */
703 : : }
704 : :
705 [ # # ]: 0 : if (enqueue_count && n > *enqueue_count)
706 : : n = *enqueue_count;
707 : :
708 : 0 : nb_ops_flushed = edma_ops_enqueue_burst(adapter, &ops[*head], n);
709 [ # # ]: 0 : if (enqueue_count)
710 : 0 : *enqueue_count = nb_ops_flushed;
711 : :
712 : 0 : bufp->count -= nb_ops_flushed;
713 [ # # ]: 0 : if (!bufp->count) {
714 : 0 : *head = 0;
715 : 0 : *tail = 0;
716 : 0 : return 0; /* buffer empty */
717 : : }
718 : :
719 : 0 : *head = (*head + nb_ops_flushed) % bufp->size;
720 : 0 : return 1;
721 : : }
722 : :
723 : : static void
724 : 0 : edma_ops_buffer_flush(struct event_dma_adapter *adapter)
725 : : {
726 [ # # ]: 0 : if (likely(adapter->ebuf.count == 0))
727 : : return;
728 : :
729 [ # # ]: 0 : while (edma_circular_buffer_flush_to_evdev(adapter, &adapter->ebuf, NULL))
730 : : ;
731 : : }
732 : :
733 : : static inline unsigned int
734 : 0 : edma_adapter_deq_run(struct event_dma_adapter *adapter, unsigned int max_deq)
735 : : {
736 : : struct rte_event_dma_adapter_stats *stats = &adapter->dma_stats;
737 : : struct dma_vchan_info *vchan_info;
738 : : struct dma_ops_circular_buffer *tq_buf;
739 : : struct rte_event_dma_adapter_op *ops;
740 : : uint16_t n, nb_deq, nb_enqueued, i;
741 : : struct dma_device_info *dev_info;
742 : : uint16_t vchan, num_vchan;
743 : : uint16_t num_dma_dev;
744 : : int16_t dma_dev_id;
745 : : uint16_t index;
746 : : bool done;
747 : : bool err;
748 : :
749 : : nb_deq = 0;
750 : 0 : edma_ops_buffer_flush(adapter);
751 : :
752 : 0 : num_dma_dev = rte_dma_count_avail();
753 : : do {
754 : : done = true;
755 : :
756 [ # # ]: 0 : for (dma_dev_id = adapter->next_dmadev_id; dma_dev_id < num_dma_dev; dma_dev_id++) {
757 : : uint16_t queues = 0;
758 : 0 : dev_info = &adapter->dma_devs[dma_dev_id];
759 : 0 : num_vchan = dev_info->num_vchanq;
760 : :
761 [ # # ]: 0 : for (vchan = dev_info->next_vchan_id; queues < num_vchan;
762 : 0 : vchan = (vchan + 1) % num_vchan, queues++) {
763 : :
764 : 0 : vchan_info = &dev_info->vchanq[vchan];
765 [ # # # # ]: 0 : if (unlikely(vchan_info == NULL || !vchan_info->vq_enabled))
766 : 0 : continue;
767 : :
768 : 0 : n = rte_dma_completed(dma_dev_id, vchan, DMA_BATCH_SIZE,
769 : : &index, &err);
770 [ # # ]: 0 : if (!n)
771 : 0 : continue;
772 : :
773 : : done = false;
774 : 0 : stats->dma_deq_count += n;
775 : :
776 : 0 : tq_buf = &dev_info->tqmap[vchan].dma_buf;
777 : :
778 : 0 : nb_enqueued = n;
779 [ # # ]: 0 : if (unlikely(!adapter->ebuf.count))
780 : 0 : edma_circular_buffer_flush_to_evdev(adapter, tq_buf,
781 : : &nb_enqueued);
782 : :
783 [ # # ]: 0 : if (likely(nb_enqueued == n))
784 : 0 : goto check;
785 : :
786 : : /* Failed to enqueue events case */
787 [ # # ]: 0 : for (i = nb_enqueued; i < n; i++) {
788 : 0 : ops = tq_buf->op_buffer[tq_buf->head];
789 : : edma_circular_buffer_add(&adapter->ebuf, ops);
790 : 0 : tq_buf->head = (tq_buf->head + 1) % tq_buf->size;
791 : : }
792 : :
793 : 0 : check:
794 : 0 : nb_deq += n;
795 [ # # ]: 0 : if (nb_deq >= max_deq) {
796 [ # # ]: 0 : if ((vchan + 1) == num_vchan)
797 : 0 : adapter->next_dmadev_id =
798 : 0 : (dma_dev_id + 1) % num_dma_dev;
799 : :
800 : 0 : dev_info->next_vchan_id = (vchan + 1) % num_vchan;
801 : :
802 : 0 : return nb_deq;
803 : : }
804 : : }
805 : : }
806 : 0 : adapter->next_dmadev_id = 0;
807 : :
808 [ # # ]: 0 : } while (done == false);
809 : :
810 : 0 : return nb_deq;
811 : : }
812 : :
813 : : static int
814 : 0 : edma_adapter_run(struct event_dma_adapter *adapter, unsigned int max_ops)
815 : : {
816 : : unsigned int ops_left = max_ops;
817 : :
818 [ # # ]: 0 : while (ops_left > 0) {
819 : : unsigned int e_cnt, d_cnt;
820 : :
821 : 0 : e_cnt = edma_adapter_deq_run(adapter, ops_left);
822 : 0 : ops_left -= RTE_MIN(ops_left, e_cnt);
823 : :
824 : 0 : d_cnt = edma_adapter_enq_run(adapter, ops_left);
825 : 0 : ops_left -= RTE_MIN(ops_left, d_cnt);
826 : :
827 [ # # ]: 0 : if (e_cnt == 0 && d_cnt == 0)
828 : : break;
829 : : }
830 : :
831 [ # # ]: 0 : if (ops_left == max_ops) {
832 [ # # ]: 0 : rte_event_maintain(adapter->eventdev_id, adapter->event_port_id, 0);
833 : 0 : return -EAGAIN;
834 : : } else
835 : : return 0;
836 : : }
837 : :
838 : : static int
839 : 0 : edma_service_func(void *args)
840 : : {
841 : : struct event_dma_adapter *adapter = args;
842 : : int ret;
843 : :
844 [ # # ]: 0 : if (rte_spinlock_trylock(&adapter->lock) == 0)
845 : : return 0;
846 : 0 : ret = edma_adapter_run(adapter, adapter->max_nb);
847 : : rte_spinlock_unlock(&adapter->lock);
848 : :
849 : 0 : return ret;
850 : : }
851 : :
852 : : static int
853 : 0 : edma_init_service(struct event_dma_adapter *adapter, uint8_t id)
854 : : {
855 : : struct rte_event_dma_adapter_conf adapter_conf;
856 : : struct rte_service_spec service;
857 : : uint32_t impl_rel;
858 : : int ret;
859 : :
860 [ # # ]: 0 : if (adapter->service_initialized)
861 : : return 0;
862 : :
863 : : memset(&service, 0, sizeof(service));
864 : 0 : snprintf(service.name, DMA_ADAPTER_NAME_LEN, "rte_event_dma_adapter_%d", id);
865 : 0 : service.socket_id = adapter->socket_id;
866 : 0 : service.callback = edma_service_func;
867 : 0 : service.callback_userdata = adapter;
868 : :
869 : : /* Service function handles locking for queue add/del updates */
870 : 0 : service.capabilities = RTE_SERVICE_CAP_MT_SAFE;
871 : 0 : ret = rte_service_component_register(&service, &adapter->service_id);
872 [ # # ]: 0 : if (ret) {
873 : 0 : RTE_EDEV_LOG_ERR("failed to register service %s err = %" PRId32, service.name, ret);
874 : 0 : return ret;
875 : : }
876 : :
877 : 0 : ret = adapter->conf_cb(id, adapter->eventdev_id, &adapter_conf, adapter->conf_arg);
878 [ # # ]: 0 : if (ret) {
879 : 0 : RTE_EDEV_LOG_ERR("configuration callback failed err = %" PRId32, ret);
880 : 0 : return ret;
881 : : }
882 : :
883 : 0 : adapter->max_nb = adapter_conf.max_nb;
884 : 0 : adapter->event_port_id = adapter_conf.event_port_id;
885 : :
886 [ # # ]: 0 : if (rte_event_port_attr_get(adapter->eventdev_id, adapter->event_port_id,
887 : : RTE_EVENT_PORT_ATTR_IMPLICIT_RELEASE_DISABLE, &impl_rel)) {
888 : 0 : RTE_EDEV_LOG_ERR("Failed to get port info for eventdev %" PRId32,
889 : : adapter->eventdev_id);
890 : : edma_circular_buffer_free(&adapter->ebuf);
891 : 0 : rte_free(adapter);
892 : 0 : return -EINVAL;
893 : : }
894 : :
895 : 0 : adapter->implicit_release_disabled = (uint8_t)impl_rel;
896 : 0 : adapter->service_initialized = 1;
897 : :
898 : 0 : return ret;
899 : : }
900 : :
901 : : static void
902 : 0 : edma_update_vchanq_info(struct event_dma_adapter *adapter, struct dma_device_info *dev_info,
903 : : uint16_t vchan, uint8_t add)
904 : : {
905 : : struct dma_vchan_info *vchan_info;
906 : : struct dma_vchan_info *tqmap_info;
907 : : int enabled;
908 : : uint16_t i;
909 : :
910 [ # # ]: 0 : if (dev_info->vchanq == NULL)
911 : : return;
912 : :
913 [ # # ]: 0 : if (vchan == RTE_DMA_ALL_VCHAN) {
914 [ # # ]: 0 : for (i = 0; i < dev_info->num_dma_dev_vchan; i++)
915 : 0 : edma_update_vchanq_info(adapter, dev_info, i, add);
916 : : } else {
917 : 0 : tqmap_info = &dev_info->tqmap[vchan];
918 : 0 : vchan_info = &dev_info->vchanq[vchan];
919 : 0 : enabled = vchan_info->vq_enabled;
920 [ # # ]: 0 : if (add) {
921 : 0 : adapter->nb_vchanq += !enabled;
922 : 0 : dev_info->num_vchanq += !enabled;
923 : : } else {
924 : 0 : adapter->nb_vchanq -= enabled;
925 : 0 : dev_info->num_vchanq -= enabled;
926 : : }
927 : 0 : vchan_info->vq_enabled = !!add;
928 : 0 : tqmap_info->vq_enabled = !!add;
929 : : }
930 : : }
931 : :
932 : : static int
933 : 0 : edma_add_vchan(struct event_dma_adapter *adapter, int16_t dma_dev_id, uint16_t vchan)
934 : : {
935 : 0 : struct dma_device_info *dev_info = &adapter->dma_devs[dma_dev_id];
936 : : struct dma_vchan_info *vchanq;
937 : : struct dma_vchan_info *tqmap;
938 : : uint16_t nb_vchans;
939 : : uint32_t i;
940 : :
941 [ # # ]: 0 : if (dev_info->vchanq == NULL) {
942 : 0 : nb_vchans = dev_info->num_dma_dev_vchan;
943 : :
944 : 0 : dev_info->vchanq = rte_zmalloc_socket(adapter->mem_name,
945 : : nb_vchans * sizeof(struct dma_vchan_info),
946 : : 0, adapter->socket_id);
947 [ # # ]: 0 : if (dev_info->vchanq == NULL)
948 : : return -ENOMEM;
949 : :
950 : 0 : dev_info->tqmap = rte_zmalloc_socket(adapter->mem_name,
951 : : nb_vchans * sizeof(struct dma_vchan_info),
952 : : 0, adapter->socket_id);
953 [ # # ]: 0 : if (dev_info->tqmap == NULL)
954 : : return -ENOMEM;
955 : :
956 [ # # ]: 0 : for (i = 0; i < nb_vchans; i++) {
957 : 0 : vchanq = &dev_info->vchanq[i];
958 : :
959 : : if (edma_circular_buffer_init("dma_dev_circular_buffer", &vchanq->dma_buf,
960 : : DMA_ADAPTER_OPS_BUFFER_SIZE)) {
961 : 0 : RTE_EDEV_LOG_ERR("Failed to get memory for dma_dev buffer");
962 : 0 : rte_free(vchanq);
963 : 0 : return -ENOMEM;
964 : : }
965 : :
966 : 0 : tqmap = &dev_info->tqmap[i];
967 : : if (edma_circular_buffer_init("dma_dev_circular_trans_buf", &tqmap->dma_buf,
968 : : DMA_ADAPTER_OPS_BUFFER_SIZE)) {
969 : 0 : RTE_EDEV_LOG_ERR(
970 : : "Failed to get memory for dma_dev transaction buffer");
971 : 0 : rte_free(tqmap);
972 : 0 : return -ENOMEM;
973 : : }
974 : : }
975 : : }
976 : :
977 [ # # ]: 0 : if (vchan == RTE_DMA_ALL_VCHAN) {
978 [ # # ]: 0 : for (i = 0; i < dev_info->num_dma_dev_vchan; i++)
979 : 0 : edma_update_vchanq_info(adapter, dev_info, i, 1);
980 : : } else
981 : 0 : edma_update_vchanq_info(adapter, dev_info, vchan, 1);
982 : :
983 : : return 0;
984 : : }
985 : :
986 : : int
987 : 0 : rte_event_dma_adapter_vchan_add(uint8_t id, int16_t dma_dev_id, uint16_t vchan,
988 : : const struct rte_event *event)
989 : : {
990 : : struct event_dma_adapter *adapter;
991 : : struct dma_device_info *dev_info;
992 : : struct rte_eventdev *dev;
993 : : uint32_t cap;
994 : : int ret;
995 : :
996 [ # # ]: 0 : EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
997 : :
998 [ # # ]: 0 : if (!rte_dma_is_valid(dma_dev_id)) {
999 : 0 : RTE_EDEV_LOG_ERR("Invalid dma_dev_id = %" PRIu8, dma_dev_id);
1000 : 0 : return -EINVAL;
1001 : : }
1002 : :
1003 : : adapter = edma_id_to_adapter(id);
1004 [ # # ]: 0 : if (adapter == NULL)
1005 : : return -EINVAL;
1006 : :
1007 : 0 : dev = &rte_eventdevs[adapter->eventdev_id];
1008 : 0 : ret = rte_event_dma_adapter_caps_get(adapter->eventdev_id, dma_dev_id, &cap);
1009 [ # # ]: 0 : if (ret) {
1010 : 0 : RTE_EDEV_LOG_ERR("Failed to get adapter caps dev %u dma_dev %u", id, dma_dev_id);
1011 : 0 : return ret;
1012 : : }
1013 : :
1014 [ # # # # ]: 0 : if ((cap & RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_VCHAN_EV_BIND) && (event == NULL)) {
1015 : 0 : RTE_EDEV_LOG_ERR("Event can not be NULL for dma_dev_id = %u", dma_dev_id);
1016 : 0 : return -EINVAL;
1017 : : }
1018 : :
1019 : 0 : dev_info = &adapter->dma_devs[dma_dev_id];
1020 [ # # # # ]: 0 : if (vchan != RTE_DMA_ALL_VCHAN && vchan >= dev_info->num_dma_dev_vchan) {
1021 : 0 : RTE_EDEV_LOG_ERR("Invalid vhcan %u", vchan);
1022 : 0 : return -EINVAL;
1023 : : }
1024 : :
1025 : : /* In case HW cap is RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_OP_FWD, no
1026 : : * need of service core as HW supports event forward capability.
1027 : : */
1028 [ # # # # ]: 0 : if ((cap & RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) ||
1029 : 0 : (cap & RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_VCHAN_EV_BIND &&
1030 [ # # ]: 0 : adapter->mode == RTE_EVENT_DMA_ADAPTER_OP_NEW) ||
1031 [ # # ]: 0 : (cap & RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_OP_NEW &&
1032 [ # # ]: 0 : adapter->mode == RTE_EVENT_DMA_ADAPTER_OP_NEW)) {
1033 [ # # ]: 0 : if (*dev->dev_ops->dma_adapter_vchan_add == NULL)
1034 : : return -ENOTSUP;
1035 [ # # ]: 0 : if (dev_info->vchanq == NULL) {
1036 : 0 : dev_info->vchanq = rte_zmalloc_socket(adapter->mem_name,
1037 : 0 : dev_info->num_dma_dev_vchan *
1038 : : sizeof(struct dma_vchan_info),
1039 : : 0, adapter->socket_id);
1040 [ # # ]: 0 : if (dev_info->vchanq == NULL) {
1041 : 0 : RTE_EDEV_LOG_ERR("Queue pair add not supported");
1042 : 0 : return -ENOMEM;
1043 : : }
1044 : : }
1045 : :
1046 [ # # ]: 0 : if (dev_info->tqmap == NULL) {
1047 : 0 : dev_info->tqmap = rte_zmalloc_socket(adapter->mem_name,
1048 : 0 : dev_info->num_dma_dev_vchan *
1049 : : sizeof(struct dma_vchan_info),
1050 : : 0, adapter->socket_id);
1051 [ # # ]: 0 : if (dev_info->tqmap == NULL) {
1052 : 0 : RTE_EDEV_LOG_ERR("tq pair add not supported");
1053 : 0 : return -ENOMEM;
1054 : : }
1055 : : }
1056 : :
1057 : 0 : ret = (*dev->dev_ops->dma_adapter_vchan_add)(dev, dma_dev_id, vchan, event);
1058 [ # # ]: 0 : if (ret)
1059 : : return ret;
1060 : :
1061 : : else
1062 : 0 : edma_update_vchanq_info(adapter, &adapter->dma_devs[dma_dev_id], vchan, 1);
1063 : : }
1064 : :
1065 : : /* In case HW cap is RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_OP_NEW, or SW adapter, initiate
1066 : : * services so the application can choose which ever way it wants to use the adapter.
1067 : : *
1068 : : * Case 1: RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_OP_NEW. Application may wants to use one
1069 : : * of below two modes
1070 : : *
1071 : : * a. OP_FORWARD mode -> HW Dequeue + SW enqueue
1072 : : * b. OP_NEW mode -> HW Dequeue
1073 : : *
1074 : : * Case 2: No HW caps, use SW adapter
1075 : : *
1076 : : * a. OP_FORWARD mode -> SW enqueue & dequeue
1077 : : * b. OP_NEW mode -> SW Dequeue
1078 : : */
1079 [ # # ]: 0 : if ((cap & RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_OP_NEW &&
1080 : 0 : !(cap & RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) &&
1081 [ # # ]: 0 : adapter->mode == RTE_EVENT_DMA_ADAPTER_OP_FORWARD) ||
1082 : : (!(cap & RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_OP_NEW) &&
1083 [ # # ]: 0 : !(cap & RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) &&
1084 : : !(cap & RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_VCHAN_EV_BIND))) {
1085 : 0 : rte_spinlock_lock(&adapter->lock);
1086 : 0 : ret = edma_init_service(adapter, id);
1087 [ # # ]: 0 : if (ret == 0)
1088 : 0 : ret = edma_add_vchan(adapter, dma_dev_id, vchan);
1089 : : rte_spinlock_unlock(&adapter->lock);
1090 : :
1091 [ # # ]: 0 : if (ret)
1092 : : return ret;
1093 : :
1094 : 0 : rte_service_component_runstate_set(adapter->service_id, 1);
1095 : : }
1096 : :
1097 : : return 0;
1098 : : }
1099 : :
1100 : : int
1101 : 0 : rte_event_dma_adapter_vchan_del(uint8_t id, int16_t dma_dev_id, uint16_t vchan)
1102 : : {
1103 : : struct event_dma_adapter *adapter;
1104 : : struct dma_device_info *dev_info;
1105 : : struct rte_eventdev *dev;
1106 : : uint32_t cap;
1107 : : int ret;
1108 : :
1109 [ # # ]: 0 : EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1110 : :
1111 [ # # ]: 0 : if (!rte_dma_is_valid(dma_dev_id)) {
1112 : 0 : RTE_EDEV_LOG_ERR("Invalid dma_dev_id = %" PRIu8, dma_dev_id);
1113 : 0 : return -EINVAL;
1114 : : }
1115 : :
1116 : : adapter = edma_id_to_adapter(id);
1117 [ # # ]: 0 : if (adapter == NULL)
1118 : : return -EINVAL;
1119 : :
1120 : 0 : dev = &rte_eventdevs[adapter->eventdev_id];
1121 : 0 : ret = rte_event_dma_adapter_caps_get(adapter->eventdev_id, dma_dev_id, &cap);
1122 [ # # ]: 0 : if (ret)
1123 : : return ret;
1124 : :
1125 : 0 : dev_info = &adapter->dma_devs[dma_dev_id];
1126 : :
1127 [ # # # # ]: 0 : if (vchan != RTE_DMA_ALL_VCHAN && vchan >= dev_info->num_dma_dev_vchan) {
1128 : 0 : RTE_EDEV_LOG_ERR("Invalid vhcan %" PRIu16, vchan);
1129 : 0 : return -EINVAL;
1130 : : }
1131 : :
1132 [ # # ]: 0 : if ((cap & RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) ||
1133 [ # # ]: 0 : (cap & RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_OP_NEW &&
1134 [ # # ]: 0 : adapter->mode == RTE_EVENT_DMA_ADAPTER_OP_NEW)) {
1135 [ # # ]: 0 : if (*dev->dev_ops->dma_adapter_vchan_del == NULL)
1136 : : return -ENOTSUP;
1137 : 0 : ret = (*dev->dev_ops->dma_adapter_vchan_del)(dev, dma_dev_id, vchan);
1138 [ # # ]: 0 : if (ret == 0) {
1139 : 0 : edma_update_vchanq_info(adapter, dev_info, vchan, 0);
1140 [ # # ]: 0 : if (dev_info->num_vchanq == 0) {
1141 : 0 : rte_free(dev_info->vchanq);
1142 : 0 : dev_info->vchanq = NULL;
1143 : : }
1144 : : }
1145 : : } else {
1146 [ # # ]: 0 : if (adapter->nb_vchanq == 0)
1147 : : return 0;
1148 : :
1149 : 0 : rte_spinlock_lock(&adapter->lock);
1150 : 0 : edma_update_vchanq_info(adapter, dev_info, vchan, 0);
1151 : :
1152 [ # # ]: 0 : if (dev_info->num_vchanq == 0) {
1153 : 0 : rte_free(dev_info->vchanq);
1154 : 0 : rte_free(dev_info->tqmap);
1155 : 0 : dev_info->vchanq = NULL;
1156 : 0 : dev_info->tqmap = NULL;
1157 : : }
1158 : :
1159 : : rte_spinlock_unlock(&adapter->lock);
1160 : 0 : rte_service_component_runstate_set(adapter->service_id, adapter->nb_vchanq);
1161 : : }
1162 : :
1163 : : return ret;
1164 : : }
1165 : :
1166 : : int
1167 : 0 : rte_event_dma_adapter_service_id_get(uint8_t id, uint32_t *service_id)
1168 : : {
1169 : : struct event_dma_adapter *adapter;
1170 : :
1171 [ # # ]: 0 : EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1172 : :
1173 : : adapter = edma_id_to_adapter(id);
1174 [ # # ]: 0 : if (adapter == NULL || service_id == NULL)
1175 : : return -EINVAL;
1176 : :
1177 [ # # ]: 0 : if (adapter->service_initialized)
1178 : 0 : *service_id = adapter->service_id;
1179 : :
1180 [ # # ]: 0 : return adapter->service_initialized ? 0 : -ESRCH;
1181 : : }
1182 : :
1183 : : static int
1184 : 0 : edma_adapter_ctrl(uint8_t id, int start)
1185 : : {
1186 : : struct event_dma_adapter *adapter;
1187 : : struct dma_device_info *dev_info;
1188 : : struct rte_eventdev *dev;
1189 : : uint16_t num_dma_dev;
1190 : : int stop = !start;
1191 : : int use_service;
1192 : : uint32_t i;
1193 : :
1194 : : use_service = 0;
1195 [ # # ]: 0 : EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1196 : : adapter = edma_id_to_adapter(id);
1197 [ # # ]: 0 : if (adapter == NULL)
1198 : : return -EINVAL;
1199 : :
1200 : 0 : num_dma_dev = rte_dma_count_avail();
1201 : 0 : dev = &rte_eventdevs[adapter->eventdev_id];
1202 : :
1203 [ # # ]: 0 : for (i = 0; i < num_dma_dev; i++) {
1204 : 0 : dev_info = &adapter->dma_devs[i];
1205 : : /* start check for num queue pairs */
1206 [ # # # # ]: 0 : if (start && !dev_info->num_vchanq)
1207 : 0 : continue;
1208 : : /* stop check if dev has been started */
1209 [ # # # # ]: 0 : if (stop && !dev_info->dev_started)
1210 : 0 : continue;
1211 : 0 : use_service |= !dev_info->internal_event_port;
1212 : 0 : dev_info->dev_started = start;
1213 [ # # ]: 0 : if (dev_info->internal_event_port == 0)
1214 : 0 : continue;
1215 [ # # ]: 0 : start ? (*dev->dev_ops->dma_adapter_start)(dev, i) :
1216 : 0 : (*dev->dev_ops->dma_adapter_stop)(dev, i);
1217 : : }
1218 : :
1219 [ # # ]: 0 : if (use_service)
1220 : 0 : rte_service_runstate_set(adapter->service_id, start);
1221 : :
1222 : : return 0;
1223 : : }
1224 : :
1225 : : int
1226 : 0 : rte_event_dma_adapter_start(uint8_t id)
1227 : : {
1228 : : struct event_dma_adapter *adapter;
1229 : :
1230 [ # # ]: 0 : EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1231 : :
1232 : : adapter = edma_id_to_adapter(id);
1233 [ # # ]: 0 : if (adapter == NULL)
1234 : : return -EINVAL;
1235 : :
1236 : 0 : return edma_adapter_ctrl(id, 1);
1237 : : }
1238 : :
1239 : : int
1240 : 0 : rte_event_dma_adapter_stop(uint8_t id)
1241 : : {
1242 : 0 : return edma_adapter_ctrl(id, 0);
1243 : : }
1244 : :
1245 : : #define DEFAULT_MAX_NB 128
1246 : :
1247 : : int
1248 : 0 : rte_event_dma_adapter_runtime_params_init(struct rte_event_dma_adapter_runtime_params *params)
1249 : : {
1250 [ # # ]: 0 : if (params == NULL)
1251 : : return -EINVAL;
1252 : :
1253 : : memset(params, 0, sizeof(*params));
1254 : 0 : params->max_nb = DEFAULT_MAX_NB;
1255 : :
1256 : 0 : return 0;
1257 : : }
1258 : :
1259 : : static int
1260 : 0 : dma_adapter_cap_check(struct event_dma_adapter *adapter)
1261 : : {
1262 : : uint32_t caps;
1263 : : int ret;
1264 : :
1265 [ # # ]: 0 : if (!adapter->nb_vchanq)
1266 : : return -EINVAL;
1267 : :
1268 : 0 : ret = rte_event_dma_adapter_caps_get(adapter->eventdev_id, adapter->next_dmadev_id, &caps);
1269 [ # # ]: 0 : if (ret) {
1270 : 0 : RTE_EDEV_LOG_ERR("Failed to get adapter caps dev %" PRIu8 " cdev %" PRIu8,
1271 : : adapter->eventdev_id, adapter->next_dmadev_id);
1272 : 0 : return ret;
1273 : : }
1274 : :
1275 [ # # ]: 0 : if ((caps & RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_OP_FWD) ||
1276 : : (caps & RTE_EVENT_DMA_ADAPTER_CAP_INTERNAL_PORT_OP_NEW))
1277 : 0 : return -ENOTSUP;
1278 : :
1279 : : return 0;
1280 : : }
1281 : :
1282 : : int
1283 : 0 : rte_event_dma_adapter_runtime_params_set(uint8_t id,
1284 : : struct rte_event_dma_adapter_runtime_params *params)
1285 : : {
1286 : : struct event_dma_adapter *adapter;
1287 : : int ret;
1288 : :
1289 [ # # ]: 0 : EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1290 : :
1291 [ # # ]: 0 : if (params == NULL) {
1292 : 0 : RTE_EDEV_LOG_ERR("params pointer is NULL");
1293 : 0 : return -EINVAL;
1294 : : }
1295 : :
1296 : : adapter = edma_id_to_adapter(id);
1297 [ # # ]: 0 : if (adapter == NULL)
1298 : : return -EINVAL;
1299 : :
1300 : 0 : ret = dma_adapter_cap_check(adapter);
1301 [ # # ]: 0 : if (ret)
1302 : : return ret;
1303 : :
1304 : 0 : rte_spinlock_lock(&adapter->lock);
1305 : 0 : adapter->max_nb = params->max_nb;
1306 : : rte_spinlock_unlock(&adapter->lock);
1307 : :
1308 : 0 : return 0;
1309 : : }
1310 : :
1311 : : int
1312 : 0 : rte_event_dma_adapter_runtime_params_get(uint8_t id,
1313 : : struct rte_event_dma_adapter_runtime_params *params)
1314 : : {
1315 : : struct event_dma_adapter *adapter;
1316 : : int ret;
1317 : :
1318 [ # # ]: 0 : EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1319 : :
1320 [ # # ]: 0 : if (params == NULL) {
1321 : 0 : RTE_EDEV_LOG_ERR("params pointer is NULL");
1322 : 0 : return -EINVAL;
1323 : : }
1324 : :
1325 : : adapter = edma_id_to_adapter(id);
1326 [ # # ]: 0 : if (adapter == NULL)
1327 : : return -EINVAL;
1328 : :
1329 : 0 : ret = dma_adapter_cap_check(adapter);
1330 [ # # ]: 0 : if (ret)
1331 : : return ret;
1332 : :
1333 : 0 : params->max_nb = adapter->max_nb;
1334 : :
1335 : 0 : return 0;
1336 : : }
1337 : :
1338 : : int
1339 : 0 : rte_event_dma_adapter_stats_get(uint8_t id, struct rte_event_dma_adapter_stats *stats)
1340 : : {
1341 : : struct rte_event_dma_adapter_stats dev_stats_sum = {0};
1342 : : struct rte_event_dma_adapter_stats dev_stats;
1343 : : struct event_dma_adapter *adapter;
1344 : : struct dma_device_info *dev_info;
1345 : : struct rte_eventdev *dev;
1346 : : uint16_t num_dma_dev;
1347 : : uint32_t i;
1348 : : int ret;
1349 : :
1350 [ # # ]: 0 : EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1351 : :
1352 : : adapter = edma_id_to_adapter(id);
1353 [ # # ]: 0 : if (adapter == NULL || stats == NULL)
1354 : : return -EINVAL;
1355 : :
1356 : 0 : num_dma_dev = rte_dma_count_avail();
1357 : 0 : dev = &rte_eventdevs[adapter->eventdev_id];
1358 : : memset(stats, 0, sizeof(*stats));
1359 [ # # ]: 0 : for (i = 0; i < num_dma_dev; i++) {
1360 : 0 : dev_info = &adapter->dma_devs[i];
1361 : :
1362 [ # # ]: 0 : if (dev_info->internal_event_port == 0 ||
1363 [ # # ]: 0 : dev->dev_ops->dma_adapter_stats_get == NULL)
1364 : 0 : continue;
1365 : :
1366 : 0 : ret = (*dev->dev_ops->dma_adapter_stats_get)(dev, i, &dev_stats);
1367 [ # # ]: 0 : if (ret)
1368 : 0 : continue;
1369 : :
1370 : 0 : dev_stats_sum.dma_deq_count += dev_stats.dma_deq_count;
1371 : 0 : dev_stats_sum.event_enq_count += dev_stats.event_enq_count;
1372 : : }
1373 : :
1374 [ # # ]: 0 : if (adapter->service_initialized)
1375 : 0 : *stats = adapter->dma_stats;
1376 : :
1377 : 0 : stats->dma_deq_count += dev_stats_sum.dma_deq_count;
1378 : 0 : stats->event_enq_count += dev_stats_sum.event_enq_count;
1379 : :
1380 : 0 : return 0;
1381 : : }
1382 : :
1383 : : int
1384 : 0 : rte_event_dma_adapter_stats_reset(uint8_t id)
1385 : : {
1386 : : struct event_dma_adapter *adapter;
1387 : : struct dma_device_info *dev_info;
1388 : : struct rte_eventdev *dev;
1389 : : uint16_t num_dma_dev;
1390 : : uint32_t i;
1391 : :
1392 [ # # ]: 0 : EVENT_DMA_ADAPTER_ID_VALID_OR_ERR_RET(id, -EINVAL);
1393 : :
1394 : : adapter = edma_id_to_adapter(id);
1395 [ # # ]: 0 : if (adapter == NULL)
1396 : : return -EINVAL;
1397 : :
1398 : 0 : num_dma_dev = rte_dma_count_avail();
1399 : 0 : dev = &rte_eventdevs[adapter->eventdev_id];
1400 [ # # ]: 0 : for (i = 0; i < num_dma_dev; i++) {
1401 : 0 : dev_info = &adapter->dma_devs[i];
1402 : :
1403 [ # # ]: 0 : if (dev_info->internal_event_port == 0 ||
1404 [ # # ]: 0 : dev->dev_ops->dma_adapter_stats_reset == NULL)
1405 : 0 : continue;
1406 : :
1407 : 0 : (*dev->dev_ops->dma_adapter_stats_reset)(dev, i);
1408 : : }
1409 : :
1410 : 0 : memset(&adapter->dma_stats, 0, sizeof(adapter->dma_stats));
1411 : :
1412 : 0 : return 0;
1413 : : }
1414 : :
1415 : : uint16_t
1416 : 0 : rte_event_dma_adapter_enqueue(uint8_t dev_id, uint8_t port_id, struct rte_event ev[],
1417 : : uint16_t nb_events)
1418 : : {
1419 : : const struct rte_event_fp_ops *fp_ops;
1420 : : void *port;
1421 : :
1422 : 0 : fp_ops = &rte_event_fp_ops[dev_id];
1423 : 0 : port = fp_ops->data[port_id];
1424 : :
1425 : 0 : return fp_ops->dma_enqueue(port, ev, nb_events);
1426 : : }
|
