1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
2 /*
3  * Copyright 2014-2016 Freescale Semiconductor Inc.
4  * Copyright 2016-2019 NXP
5  *
6  */
7 #include <linux/types.h>
8 #include <linux/fsl/mc.h>
9 #include <soc/fsl/dpaa2-io.h>
10 #include <linux/init.h>
11 #include <linux/module.h>
12 #include <linux/platform_device.h>
13 #include <linux/interrupt.h>
14 #include <linux/dma-mapping.h>
15 #include <linux/dim.h>
16 #include <linux/slab.h>
17 
18 #include "dpio.h"
19 #include "qbman-portal.h"
20 
21 struct dpaa2_io {
22 	struct dpaa2_io_desc dpio_desc;
23 	struct qbman_swp_desc swp_desc;
24 	struct qbman_swp *swp;
25 	struct list_head node;
26 	/* protect against multiple management commands */
27 	spinlock_t lock_mgmt_cmd;
28 	/* protect notifications list */
29 	spinlock_t lock_notifications;
30 	struct list_head notifications;
31 	struct device *dev;
32 
33 	/* Net DIM */
34 	struct dim rx_dim;
35 	/* protect against concurrent Net DIM updates */
36 	spinlock_t dim_lock;
37 	u16 event_ctr;
38 	u64 bytes;
39 	u64 frames;
40 };
41 
42 struct dpaa2_io_store {
43 	unsigned int max;
44 	dma_addr_t paddr;
45 	struct dpaa2_dq *vaddr;
46 	void *alloced_addr;    /* unaligned value from kmalloc() */
47 	unsigned int idx;      /* position of the next-to-be-returned entry */
48 	struct qbman_swp *swp; /* portal used to issue VDQCR */
49 	struct device *dev;    /* device used for DMA mapping */
50 };
51 
52 /* keep a per cpu array of DPIOs for fast access */
53 static struct dpaa2_io *dpio_by_cpu[NR_CPUS];
54 static struct list_head dpio_list = LIST_HEAD_INIT(dpio_list);
55 static DEFINE_SPINLOCK(dpio_list_lock);
56 
57 static inline struct dpaa2_io *service_select_by_cpu(struct dpaa2_io *d,
58 						     int cpu)
59 {
60 	if (d)
61 		return d;
62 
63 	if (cpu != DPAA2_IO_ANY_CPU && cpu >= num_possible_cpus())
64 		return NULL;
65 
66 	/*
67 	 * If cpu == -1, choose the current cpu, with no guarantees about
68 	 * potentially being migrated away.
69 	 */
70 	if (cpu < 0)
71 		cpu = raw_smp_processor_id();
72 
73 	/* If a specific cpu was requested, pick it up immediately */
74 	return dpio_by_cpu[cpu];
75 }
76 
77 static inline struct dpaa2_io *service_select(struct dpaa2_io *d)
78 {
79 	if (d)
80 		return d;
81 
82 	d = service_select_by_cpu(d, -1);
83 	if (d)
84 		return d;
85 
86 	spin_lock(&dpio_list_lock);
87 	d = list_entry(dpio_list.next, struct dpaa2_io, node);
88 	list_del(&d->node);
89 	list_add_tail(&d->node, &dpio_list);
90 	spin_unlock(&dpio_list_lock);
91 
92 	return d;
93 }
94 
95 /**
96  * dpaa2_io_service_select() - return a dpaa2_io service affined to this cpu
97  * @cpu: the cpu id
98  *
99  * Return the affine dpaa2_io service, or NULL if there is no service affined
100  * to the specified cpu. If DPAA2_IO_ANY_CPU is used, return the next available
101  * service.
102  */
103 struct dpaa2_io *dpaa2_io_service_select(int cpu)
104 {
105 	if (cpu == DPAA2_IO_ANY_CPU)
106 		return service_select(NULL);
107 
108 	return service_select_by_cpu(NULL, cpu);
109 }
110 EXPORT_SYMBOL_GPL(dpaa2_io_service_select);
111 
112 static void dpaa2_io_dim_work(struct work_struct *w)
113 {
114 	struct dim *dim = container_of(w, struct dim, work);
115 	struct dim_cq_moder moder =
116 		net_dim_get_rx_moderation(dim->mode, dim->profile_ix);
117 	struct dpaa2_io *d = container_of(dim, struct dpaa2_io, rx_dim);
118 
119 	dpaa2_io_set_irq_coalescing(d, moder.usec);
120 	dim->state = DIM_START_MEASURE;
121 }
122 
123 /**
124  * dpaa2_io_create() - create a dpaa2_io object.
125  * @desc: the dpaa2_io descriptor
126  * @dev: the actual DPIO device
127  *
128  * Activates a "struct dpaa2_io" corresponding to the given config of an actual
129  * DPIO object.
130  *
131  * Return a valid dpaa2_io object for success, or NULL for failure.
132  */
133 struct dpaa2_io *dpaa2_io_create(const struct dpaa2_io_desc *desc,
134 				 struct device *dev)
135 {
136 	struct dpaa2_io *obj = kmalloc(sizeof(*obj), GFP_KERNEL);
137 	u32 qman_256_cycles_per_ns;
138 
139 	if (!obj)
140 		return NULL;
141 
142 	/* check if CPU is out of range (-1 means any cpu) */
143 	if (desc->cpu != DPAA2_IO_ANY_CPU && desc->cpu >= num_possible_cpus()) {
144 		kfree(obj);
145 		return NULL;
146 	}
147 
148 	obj->dpio_desc = *desc;
149 	obj->swp_desc.cena_bar = obj->dpio_desc.regs_cena;
150 	obj->swp_desc.cinh_bar = obj->dpio_desc.regs_cinh;
151 	obj->swp_desc.qman_clk = obj->dpio_desc.qman_clk;
152 	obj->swp_desc.qman_version = obj->dpio_desc.qman_version;
153 
154 	/* Compute how many 256 QBMAN cycles fit into one ns. This is because
155 	 * the interrupt timeout period register needs to be specified in QBMAN
156 	 * clock cycles in increments of 256.
157 	 */
158 	qman_256_cycles_per_ns = 256000 / (obj->swp_desc.qman_clk / 1000000);
159 	obj->swp_desc.qman_256_cycles_per_ns = qman_256_cycles_per_ns;
160 	obj->swp = qbman_swp_init(&obj->swp_desc);
161 
162 	if (!obj->swp) {
163 		kfree(obj);
164 		return NULL;
165 	}
166 
167 	INIT_LIST_HEAD(&obj->node);
168 	spin_lock_init(&obj->lock_mgmt_cmd);
169 	spin_lock_init(&obj->lock_notifications);
170 	spin_lock_init(&obj->dim_lock);
171 	INIT_LIST_HEAD(&obj->notifications);
172 
173 	/* For now only enable DQRR interrupts */
174 	qbman_swp_interrupt_set_trigger(obj->swp,
175 					QBMAN_SWP_INTERRUPT_DQRI);
176 	qbman_swp_interrupt_clear_status(obj->swp, 0xffffffff);
177 	if (obj->dpio_desc.receives_notifications)
178 		qbman_swp_push_set(obj->swp, 0, 1);
179 
180 	spin_lock(&dpio_list_lock);
181 	list_add_tail(&obj->node, &dpio_list);
182 	if (desc->cpu >= 0 && !dpio_by_cpu[desc->cpu])
183 		dpio_by_cpu[desc->cpu] = obj;
184 	spin_unlock(&dpio_list_lock);
185 
186 	obj->dev = dev;
187 
188 	memset(&obj->rx_dim, 0, sizeof(obj->rx_dim));
189 	INIT_WORK(&obj->rx_dim.work, dpaa2_io_dim_work);
190 	obj->event_ctr = 0;
191 	obj->bytes = 0;
192 	obj->frames = 0;
193 
194 	return obj;
195 }
196 
197 /**
198  * dpaa2_io_down() - release the dpaa2_io object.
199  * @d: the dpaa2_io object to be released.
200  *
201  * The "struct dpaa2_io" type can represent an individual DPIO object (as
202  * described by "struct dpaa2_io_desc") or an instance of a "DPIO service",
203  * which can be used to group/encapsulate multiple DPIO objects. In all cases,
204  * each handle obtained should be released using this function.
205  */
206 void dpaa2_io_down(struct dpaa2_io *d)
207 {
208 	spin_lock(&dpio_list_lock);
209 	dpio_by_cpu[d->dpio_desc.cpu] = NULL;
210 	list_del(&d->node);
211 	spin_unlock(&dpio_list_lock);
212 
213 	kfree(d);
214 }
215 
216 #define DPAA_POLL_MAX 32
217 
218 /**
219  * dpaa2_io_irq() - ISR for DPIO interrupts
220  *
221  * @obj: the given DPIO object.
222  *
223  * Return IRQ_HANDLED for success or IRQ_NONE if there
224  * were no pending interrupts.
225  */
226 irqreturn_t dpaa2_io_irq(struct dpaa2_io *obj)
227 {
228 	const struct dpaa2_dq *dq;
229 	int max = 0;
230 	struct qbman_swp *swp;
231 	u32 status;
232 
233 	obj->event_ctr++;
234 
235 	swp = obj->swp;
236 	status = qbman_swp_interrupt_read_status(swp);
237 	if (!status)
238 		return IRQ_NONE;
239 
240 	dq = qbman_swp_dqrr_next(swp);
241 	while (dq) {
242 		if (qbman_result_is_SCN(dq)) {
243 			struct dpaa2_io_notification_ctx *ctx;
244 			u64 q64;
245 
246 			q64 = qbman_result_SCN_ctx(dq);
247 			ctx = (void *)(uintptr_t)q64;
248 			ctx->cb(ctx);
249 		} else {
250 			pr_crit("fsl-mc-dpio: Unrecognised/ignored DQRR entry\n");
251 		}
252 		qbman_swp_dqrr_consume(swp, dq);
253 		++max;
254 		if (max > DPAA_POLL_MAX)
255 			goto done;
256 		dq = qbman_swp_dqrr_next(swp);
257 	}
258 done:
259 	qbman_swp_interrupt_clear_status(swp, status);
260 	qbman_swp_interrupt_set_inhibit(swp, 0);
261 	return IRQ_HANDLED;
262 }
263 
264 /**
265  * dpaa2_io_get_cpu() - get the cpu associated with a given DPIO object
266  *
267  * @d: the given DPIO object.
268  *
269  * Return the cpu associated with the DPIO object
270  */
271 int dpaa2_io_get_cpu(struct dpaa2_io *d)
272 {
273 	return d->dpio_desc.cpu;
274 }
275 EXPORT_SYMBOL(dpaa2_io_get_cpu);
276 
277 /**
278  * dpaa2_io_service_register() - Prepare for servicing of FQDAN or CDAN
279  *                               notifications on the given DPIO service.
280  * @d:   the given DPIO service.
281  * @ctx: the notification context.
282  * @dev: the device that requests the register
283  *
284  * The caller should make the MC command to attach a DPAA2 object to
285  * a DPIO after this function completes successfully.  In that way:
286  *    (a) The DPIO service is "ready" to handle a notification arrival
287  *        (which might happen before the "attach" command to MC has
288  *        returned control of execution back to the caller)
289  *    (b) The DPIO service can provide back to the caller the 'dpio_id' and
290  *        'qman64' parameters that it should pass along in the MC command
291  *        in order for the object to be configured to produce the right
292  *        notification fields to the DPIO service.
293  *
294  * Return 0 for success, or -ENODEV for failure.
295  */
296 int dpaa2_io_service_register(struct dpaa2_io *d,
297 			      struct dpaa2_io_notification_ctx *ctx,
298 			      struct device *dev)
299 {
300 	struct device_link *link;
301 	unsigned long irqflags;
302 
303 	d = service_select_by_cpu(d, ctx->desired_cpu);
304 	if (!d)
305 		return -ENODEV;
306 
307 	link = device_link_add(dev, d->dev, DL_FLAG_AUTOREMOVE_CONSUMER);
308 	if (!link)
309 		return -EINVAL;
310 
311 	ctx->dpio_id = d->dpio_desc.dpio_id;
312 	ctx->qman64 = (u64)(uintptr_t)ctx;
313 	ctx->dpio_private = d;
314 	spin_lock_irqsave(&d->lock_notifications, irqflags);
315 	list_add(&ctx->node, &d->notifications);
316 	spin_unlock_irqrestore(&d->lock_notifications, irqflags);
317 
318 	/* Enable the generation of CDAN notifications */
319 	if (ctx->is_cdan)
320 		return qbman_swp_CDAN_set_context_enable(d->swp,
321 							 (u16)ctx->id,
322 							 ctx->qman64);
323 	return 0;
324 }
325 EXPORT_SYMBOL_GPL(dpaa2_io_service_register);
326 
327 /**
328  * dpaa2_io_service_deregister - The opposite of 'register'.
329  * @service: the given DPIO service.
330  * @ctx: the notification context.
331  * @dev: the device that requests to be deregistered
332  *
333  * This function should be called only after sending the MC command to
334  * to detach the notification-producing device from the DPIO.
335  */
336 void dpaa2_io_service_deregister(struct dpaa2_io *service,
337 				 struct dpaa2_io_notification_ctx *ctx,
338 				 struct device *dev)
339 {
340 	struct dpaa2_io *d = ctx->dpio_private;
341 	unsigned long irqflags;
342 
343 	if (ctx->is_cdan)
344 		qbman_swp_CDAN_disable(d->swp, (u16)ctx->id);
345 
346 	spin_lock_irqsave(&d->lock_notifications, irqflags);
347 	list_del(&ctx->node);
348 	spin_unlock_irqrestore(&d->lock_notifications, irqflags);
349 
350 }
351 EXPORT_SYMBOL_GPL(dpaa2_io_service_deregister);
352 
353 /**
354  * dpaa2_io_service_rearm() - Rearm the notification for the given DPIO service.
355  * @d: the given DPIO service.
356  * @ctx: the notification context.
357  *
358  * Once a FQDAN/CDAN has been produced, the corresponding FQ/channel is
359  * considered "disarmed". Ie. the user can issue pull dequeue operations on that
360  * traffic source for as long as it likes. Eventually it may wish to "rearm"
361  * that source to allow it to produce another FQDAN/CDAN, that's what this
362  * function achieves.
363  *
364  * Return 0 for success.
365  */
366 int dpaa2_io_service_rearm(struct dpaa2_io *d,
367 			   struct dpaa2_io_notification_ctx *ctx)
368 {
369 	unsigned long irqflags;
370 	int err;
371 
372 	d = service_select_by_cpu(d, ctx->desired_cpu);
373 	if (!unlikely(d))
374 		return -ENODEV;
375 
376 	spin_lock_irqsave(&d->lock_mgmt_cmd, irqflags);
377 	if (ctx->is_cdan)
378 		err = qbman_swp_CDAN_enable(d->swp, (u16)ctx->id);
379 	else
380 		err = qbman_swp_fq_schedule(d->swp, ctx->id);
381 	spin_unlock_irqrestore(&d->lock_mgmt_cmd, irqflags);
382 
383 	return err;
384 }
385 EXPORT_SYMBOL_GPL(dpaa2_io_service_rearm);
386 
387 /**
388  * dpaa2_io_service_pull_fq() - pull dequeue functions from a fq.
389  * @d: the given DPIO service.
390  * @fqid: the given frame queue id.
391  * @s: the dpaa2_io_store object for the result.
392  *
393  * Return 0 for success, or error code for failure.
394  */
395 int dpaa2_io_service_pull_fq(struct dpaa2_io *d, u32 fqid,
396 			     struct dpaa2_io_store *s)
397 {
398 	struct qbman_pull_desc pd;
399 	int err;
400 
401 	qbman_pull_desc_clear(&pd);
402 	qbman_pull_desc_set_storage(&pd, s->vaddr, s->paddr, 1);
403 	qbman_pull_desc_set_numframes(&pd, (u8)s->max);
404 	qbman_pull_desc_set_fq(&pd, fqid);
405 
406 	d = service_select(d);
407 	if (!d)
408 		return -ENODEV;
409 	s->swp = d->swp;
410 	err = qbman_swp_pull(d->swp, &pd);
411 	if (err)
412 		s->swp = NULL;
413 
414 	return err;
415 }
416 EXPORT_SYMBOL(dpaa2_io_service_pull_fq);
417 
418 /**
419  * dpaa2_io_service_pull_channel() - pull dequeue functions from a channel.
420  * @d: the given DPIO service.
421  * @channelid: the given channel id.
422  * @s: the dpaa2_io_store object for the result.
423  *
424  * Return 0 for success, or error code for failure.
425  */
426 int dpaa2_io_service_pull_channel(struct dpaa2_io *d, u32 channelid,
427 				  struct dpaa2_io_store *s)
428 {
429 	struct qbman_pull_desc pd;
430 	int err;
431 
432 	qbman_pull_desc_clear(&pd);
433 	qbman_pull_desc_set_storage(&pd, s->vaddr, s->paddr, 1);
434 	qbman_pull_desc_set_numframes(&pd, (u8)s->max);
435 	qbman_pull_desc_set_channel(&pd, channelid, qbman_pull_type_prio);
436 
437 	d = service_select(d);
438 	if (!d)
439 		return -ENODEV;
440 
441 	s->swp = d->swp;
442 	err = qbman_swp_pull(d->swp, &pd);
443 	if (err)
444 		s->swp = NULL;
445 
446 	return err;
447 }
448 EXPORT_SYMBOL_GPL(dpaa2_io_service_pull_channel);
449 
450 /**
451  * dpaa2_io_service_enqueue_fq() - Enqueue a frame to a frame queue.
452  * @d: the given DPIO service.
453  * @fqid: the given frame queue id.
454  * @fd: the frame descriptor which is enqueued.
455  *
456  * Return 0 for successful enqueue, -EBUSY if the enqueue ring is not ready,
457  * or -ENODEV if there is no dpio service.
458  */
459 int dpaa2_io_service_enqueue_fq(struct dpaa2_io *d,
460 				u32 fqid,
461 				const struct dpaa2_fd *fd)
462 {
463 	struct qbman_eq_desc ed;
464 
465 	d = service_select(d);
466 	if (!d)
467 		return -ENODEV;
468 
469 	qbman_eq_desc_clear(&ed);
470 	qbman_eq_desc_set_no_orp(&ed, 0);
471 	qbman_eq_desc_set_fq(&ed, fqid);
472 
473 	return qbman_swp_enqueue(d->swp, &ed, fd);
474 }
475 EXPORT_SYMBOL(dpaa2_io_service_enqueue_fq);
476 
477 /**
478  * dpaa2_io_service_enqueue_multiple_fq() - Enqueue multiple frames
479  * to a frame queue using one fqid.
480  * @d: the given DPIO service.
481  * @fqid: the given frame queue id.
482  * @fd: the frame descriptor which is enqueued.
483  * @nb: number of frames to be enqueud
484  *
485  * Return 0 for successful enqueue, -EBUSY if the enqueue ring is not ready,
486  * or -ENODEV if there is no dpio service.
487  */
488 int dpaa2_io_service_enqueue_multiple_fq(struct dpaa2_io *d,
489 				u32 fqid,
490 				const struct dpaa2_fd *fd,
491 				int nb)
492 {
493 	struct qbman_eq_desc ed;
494 
495 	d = service_select(d);
496 	if (!d)
497 		return -ENODEV;
498 
499 	qbman_eq_desc_clear(&ed);
500 	qbman_eq_desc_set_no_orp(&ed, 0);
501 	qbman_eq_desc_set_fq(&ed, fqid);
502 
503 	return qbman_swp_enqueue_multiple(d->swp, &ed, fd, NULL, nb);
504 }
505 EXPORT_SYMBOL(dpaa2_io_service_enqueue_multiple_fq);
506 
507 /**
508  * dpaa2_io_service_enqueue_multiple_desc_fq() - Enqueue multiple frames
509  * to different frame queue using a list of fqids.
510  * @d: the given DPIO service.
511  * @fqid: the given list of frame queue ids.
512  * @fd: the frame descriptor which is enqueued.
513  * @nb: number of frames to be enqueud
514  *
515  * Return 0 for successful enqueue, -EBUSY if the enqueue ring is not ready,
516  * or -ENODEV if there is no dpio service.
517  */
518 int dpaa2_io_service_enqueue_multiple_desc_fq(struct dpaa2_io *d,
519 				u32 *fqid,
520 				const struct dpaa2_fd *fd,
521 				int nb)
522 {
523 	struct qbman_eq_desc *ed;
524 	int i, ret;
525 
526 	ed = kcalloc(32, sizeof(struct qbman_eq_desc), GFP_KERNEL);
527 	if (!ed)
528 		return -ENOMEM;
529 
530 	d = service_select(d);
531 	if (!d) {
532 		ret = -ENODEV;
533 		goto out;
534 	}
535 
536 	for (i = 0; i < nb; i++) {
537 		qbman_eq_desc_clear(&ed[i]);
538 		qbman_eq_desc_set_no_orp(&ed[i], 0);
539 		qbman_eq_desc_set_fq(&ed[i], fqid[i]);
540 	}
541 
542 	ret = qbman_swp_enqueue_multiple_desc(d->swp, &ed[0], fd, nb);
543 out:
544 	kfree(ed);
545 	return ret;
546 }
547 EXPORT_SYMBOL(dpaa2_io_service_enqueue_multiple_desc_fq);
548 
549 /**
550  * dpaa2_io_service_enqueue_qd() - Enqueue a frame to a QD.
551  * @d: the given DPIO service.
552  * @qdid: the given queuing destination id.
553  * @prio: the given queuing priority.
554  * @qdbin: the given queuing destination bin.
555  * @fd: the frame descriptor which is enqueued.
556  *
557  * Return 0 for successful enqueue, or -EBUSY if the enqueue ring is not ready,
558  * or -ENODEV if there is no dpio service.
559  */
560 int dpaa2_io_service_enqueue_qd(struct dpaa2_io *d,
561 				u32 qdid, u8 prio, u16 qdbin,
562 				const struct dpaa2_fd *fd)
563 {
564 	struct qbman_eq_desc ed;
565 
566 	d = service_select(d);
567 	if (!d)
568 		return -ENODEV;
569 
570 	qbman_eq_desc_clear(&ed);
571 	qbman_eq_desc_set_no_orp(&ed, 0);
572 	qbman_eq_desc_set_qd(&ed, qdid, qdbin, prio);
573 
574 	return qbman_swp_enqueue(d->swp, &ed, fd);
575 }
576 EXPORT_SYMBOL_GPL(dpaa2_io_service_enqueue_qd);
577 
578 /**
579  * dpaa2_io_service_release() - Release buffers to a buffer pool.
580  * @d: the given DPIO object.
581  * @bpid: the buffer pool id.
582  * @buffers: the buffers to be released.
583  * @num_buffers: the number of the buffers to be released.
584  *
585  * Return 0 for success, and negative error code for failure.
586  */
587 int dpaa2_io_service_release(struct dpaa2_io *d,
588 			     u16 bpid,
589 			     const u64 *buffers,
590 			     unsigned int num_buffers)
591 {
592 	struct qbman_release_desc rd;
593 
594 	d = service_select(d);
595 	if (!d)
596 		return -ENODEV;
597 
598 	qbman_release_desc_clear(&rd);
599 	qbman_release_desc_set_bpid(&rd, bpid);
600 
601 	return qbman_swp_release(d->swp, &rd, buffers, num_buffers);
602 }
603 EXPORT_SYMBOL_GPL(dpaa2_io_service_release);
604 
605 /**
606  * dpaa2_io_service_acquire() - Acquire buffers from a buffer pool.
607  * @d: the given DPIO object.
608  * @bpid: the buffer pool id.
609  * @buffers: the buffer addresses for acquired buffers.
610  * @num_buffers: the expected number of the buffers to acquire.
611  *
612  * Return a negative error code if the command failed, otherwise it returns
613  * the number of buffers acquired, which may be less than the number requested.
614  * Eg. if the buffer pool is empty, this will return zero.
615  */
616 int dpaa2_io_service_acquire(struct dpaa2_io *d,
617 			     u16 bpid,
618 			     u64 *buffers,
619 			     unsigned int num_buffers)
620 {
621 	unsigned long irqflags;
622 	int err;
623 
624 	d = service_select(d);
625 	if (!d)
626 		return -ENODEV;
627 
628 	spin_lock_irqsave(&d->lock_mgmt_cmd, irqflags);
629 	err = qbman_swp_acquire(d->swp, bpid, buffers, num_buffers);
630 	spin_unlock_irqrestore(&d->lock_mgmt_cmd, irqflags);
631 
632 	return err;
633 }
634 EXPORT_SYMBOL_GPL(dpaa2_io_service_acquire);
635 
636 /*
637  * 'Stores' are reusable memory blocks for holding dequeue results, and to
638  * assist with parsing those results.
639  */
640 
641 /**
642  * dpaa2_io_store_create() - Create the dma memory storage for dequeue result.
643  * @max_frames: the maximum number of dequeued result for frames, must be <= 32.
644  * @dev:        the device to allow mapping/unmapping the DMAable region.
645  *
646  * The size of the storage is "max_frames*sizeof(struct dpaa2_dq)".
647  * The 'dpaa2_io_store' returned is a DPIO service managed object.
648  *
649  * Return pointer to dpaa2_io_store struct for successfully created storage
650  * memory, or NULL on error.
651  */
652 struct dpaa2_io_store *dpaa2_io_store_create(unsigned int max_frames,
653 					     struct device *dev)
654 {
655 	struct dpaa2_io_store *ret;
656 	size_t size;
657 
658 	if (!max_frames || (max_frames > 32))
659 		return NULL;
660 
661 	ret = kmalloc(sizeof(*ret), GFP_KERNEL);
662 	if (!ret)
663 		return NULL;
664 
665 	ret->max = max_frames;
666 	size = max_frames * sizeof(struct dpaa2_dq) + 64;
667 	ret->alloced_addr = kzalloc(size, GFP_KERNEL);
668 	if (!ret->alloced_addr) {
669 		kfree(ret);
670 		return NULL;
671 	}
672 
673 	ret->vaddr = PTR_ALIGN(ret->alloced_addr, 64);
674 	ret->paddr = dma_map_single(dev, ret->vaddr,
675 				    sizeof(struct dpaa2_dq) * max_frames,
676 				    DMA_FROM_DEVICE);
677 	if (dma_mapping_error(dev, ret->paddr)) {
678 		kfree(ret->alloced_addr);
679 		kfree(ret);
680 		return NULL;
681 	}
682 
683 	ret->idx = 0;
684 	ret->dev = dev;
685 
686 	return ret;
687 }
688 EXPORT_SYMBOL_GPL(dpaa2_io_store_create);
689 
690 /**
691  * dpaa2_io_store_destroy() - Frees the dma memory storage for dequeue
692  *                            result.
693  * @s: the storage memory to be destroyed.
694  */
695 void dpaa2_io_store_destroy(struct dpaa2_io_store *s)
696 {
697 	dma_unmap_single(s->dev, s->paddr, sizeof(struct dpaa2_dq) * s->max,
698 			 DMA_FROM_DEVICE);
699 	kfree(s->alloced_addr);
700 	kfree(s);
701 }
702 EXPORT_SYMBOL_GPL(dpaa2_io_store_destroy);
703 
704 /**
705  * dpaa2_io_store_next() - Determine when the next dequeue result is available.
706  * @s: the dpaa2_io_store object.
707  * @is_last: indicate whether this is the last frame in the pull command.
708  *
709  * When an object driver performs dequeues to a dpaa2_io_store, this function
710  * can be used to determine when the next frame result is available. Once
711  * this function returns non-NULL, a subsequent call to it will try to find
712  * the next dequeue result.
713  *
714  * Note that if a pull-dequeue has a NULL result because the target FQ/channel
715  * was empty, then this function will also return NULL (rather than expecting
716  * the caller to always check for this. As such, "is_last" can be used to
717  * differentiate between "end-of-empty-dequeue" and "still-waiting".
718  *
719  * Return dequeue result for a valid dequeue result, or NULL for empty dequeue.
720  */
721 struct dpaa2_dq *dpaa2_io_store_next(struct dpaa2_io_store *s, int *is_last)
722 {
723 	int match;
724 	struct dpaa2_dq *ret = &s->vaddr[s->idx];
725 
726 	match = qbman_result_has_new_result(s->swp, ret);
727 	if (!match) {
728 		*is_last = 0;
729 		return NULL;
730 	}
731 
732 	s->idx++;
733 
734 	if (dpaa2_dq_is_pull_complete(ret)) {
735 		*is_last = 1;
736 		s->idx = 0;
737 		/*
738 		 * If we get an empty dequeue result to terminate a zero-results
739 		 * vdqcr, return NULL to the caller rather than expecting him to
740 		 * check non-NULL results every time.
741 		 */
742 		if (!(dpaa2_dq_flags(ret) & DPAA2_DQ_STAT_VALIDFRAME))
743 			ret = NULL;
744 	} else {
745 		prefetch(&s->vaddr[s->idx]);
746 		*is_last = 0;
747 	}
748 
749 	return ret;
750 }
751 EXPORT_SYMBOL_GPL(dpaa2_io_store_next);
752 
753 /**
754  * dpaa2_io_query_fq_count() - Get the frame and byte count for a given fq.
755  * @d: the given DPIO object.
756  * @fqid: the id of frame queue to be queried.
757  * @fcnt: the queried frame count.
758  * @bcnt: the queried byte count.
759  *
760  * Knowing the FQ count at run-time can be useful in debugging situations.
761  * The instantaneous frame- and byte-count are hereby returned.
762  *
763  * Return 0 for a successful query, and negative error code if query fails.
764  */
765 int dpaa2_io_query_fq_count(struct dpaa2_io *d, u32 fqid,
766 			    u32 *fcnt, u32 *bcnt)
767 {
768 	struct qbman_fq_query_np_rslt state;
769 	struct qbman_swp *swp;
770 	unsigned long irqflags;
771 	int ret;
772 
773 	d = service_select(d);
774 	if (!d)
775 		return -ENODEV;
776 
777 	swp = d->swp;
778 	spin_lock_irqsave(&d->lock_mgmt_cmd, irqflags);
779 	ret = qbman_fq_query_state(swp, fqid, &state);
780 	spin_unlock_irqrestore(&d->lock_mgmt_cmd, irqflags);
781 	if (ret)
782 		return ret;
783 	*fcnt = qbman_fq_state_frame_count(&state);
784 	*bcnt = qbman_fq_state_byte_count(&state);
785 
786 	return 0;
787 }
788 EXPORT_SYMBOL_GPL(dpaa2_io_query_fq_count);
789 
790 /**
791  * dpaa2_io_query_bp_count() - Query the number of buffers currently in a
792  * buffer pool.
793  * @d: the given DPIO object.
794  * @bpid: the index of buffer pool to be queried.
795  * @num: the queried number of buffers in the buffer pool.
796  *
797  * Return 0 for a successful query, and negative error code if query fails.
798  */
799 int dpaa2_io_query_bp_count(struct dpaa2_io *d, u16 bpid, u32 *num)
800 {
801 	struct qbman_bp_query_rslt state;
802 	struct qbman_swp *swp;
803 	unsigned long irqflags;
804 	int ret;
805 
806 	d = service_select(d);
807 	if (!d)
808 		return -ENODEV;
809 
810 	swp = d->swp;
811 	spin_lock_irqsave(&d->lock_mgmt_cmd, irqflags);
812 	ret = qbman_bp_query(swp, bpid, &state);
813 	spin_unlock_irqrestore(&d->lock_mgmt_cmd, irqflags);
814 	if (ret)
815 		return ret;
816 	*num = qbman_bp_info_num_free_bufs(&state);
817 	return 0;
818 }
819 EXPORT_SYMBOL_GPL(dpaa2_io_query_bp_count);
820 
821 /**
822  * dpaa2_io_set_irq_coalescing() - Set new IRQ coalescing values
823  * @d: the given DPIO object
824  * @irq_holdoff: interrupt holdoff (timeout) period in us
825  *
826  * Return 0 for success, or negative error code on error.
827  */
828 int dpaa2_io_set_irq_coalescing(struct dpaa2_io *d, u32 irq_holdoff)
829 {
830 	struct qbman_swp *swp = d->swp;
831 
832 	return qbman_swp_set_irq_coalescing(swp, swp->dqrr.dqrr_size - 1,
833 					    irq_holdoff);
834 }
835 EXPORT_SYMBOL(dpaa2_io_set_irq_coalescing);
836 
837 /**
838  * dpaa2_io_get_irq_coalescing() - Get the current IRQ coalescing parameters
839  * @d: the given DPIO object
840  * @irq_holdoff: interrupt holdoff (timeout) period in us
841  */
842 void dpaa2_io_get_irq_coalescing(struct dpaa2_io *d, u32 *irq_holdoff)
843 {
844 	struct qbman_swp *swp = d->swp;
845 
846 	qbman_swp_get_irq_coalescing(swp, NULL, irq_holdoff);
847 }
848 EXPORT_SYMBOL(dpaa2_io_get_irq_coalescing);
849 
850 /**
851  * dpaa2_io_set_adaptive_coalescing() - Enable/disable adaptive coalescing
852  * @d: the given DPIO object
853  * @use_adaptive_rx_coalesce: adaptive coalescing state
854  */
855 void dpaa2_io_set_adaptive_coalescing(struct dpaa2_io *d,
856 				      int use_adaptive_rx_coalesce)
857 {
858 	d->swp->use_adaptive_rx_coalesce = use_adaptive_rx_coalesce;
859 }
860 EXPORT_SYMBOL(dpaa2_io_set_adaptive_coalescing);
861 
862 /**
863  * dpaa2_io_get_adaptive_coalescing() - Query adaptive coalescing state
864  * @d: the given DPIO object
865  *
866  * Return 1 when adaptive coalescing is enabled on the DPIO object and 0
867  * otherwise.
868  */
869 int dpaa2_io_get_adaptive_coalescing(struct dpaa2_io *d)
870 {
871 	return d->swp->use_adaptive_rx_coalesce;
872 }
873 EXPORT_SYMBOL(dpaa2_io_get_adaptive_coalescing);
874 
875 /**
876  * dpaa2_io_update_net_dim() - Update Net DIM
877  * @d: the given DPIO object
878  * @frames: how many frames have been dequeued by the user since the last call
879  * @bytes: how many bytes have been dequeued by the user since the last call
880  */
881 void dpaa2_io_update_net_dim(struct dpaa2_io *d, __u64 frames, __u64 bytes)
882 {
883 	struct dim_sample dim_sample = {};
884 
885 	if (!d->swp->use_adaptive_rx_coalesce)
886 		return;
887 
888 	spin_lock(&d->dim_lock);
889 
890 	d->bytes += bytes;
891 	d->frames += frames;
892 
893 	dim_update_sample(d->event_ctr, d->frames, d->bytes, &dim_sample);
894 	net_dim(&d->rx_dim, dim_sample);
895 
896 	spin_unlock(&d->dim_lock);
897 }
898 EXPORT_SYMBOL(dpaa2_io_update_net_dim);
899