1 /* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */
2 /*
3  * Copyright (C) 2014-2016 Freescale Semiconductor, Inc.
4  * Copyright 2016-2019 NXP
5  *
6  */
7 #ifndef __FSL_QBMAN_PORTAL_H
8 #define __FSL_QBMAN_PORTAL_H
9 
10 #include <soc/fsl/dpaa2-fd.h>
11 
12 #define QMAN_REV_4000   0x04000000
13 #define QMAN_REV_4100   0x04010000
14 #define QMAN_REV_4101   0x04010001
15 #define QMAN_REV_5000   0x05000000
16 
17 #define QMAN_REV_MASK   0xffff0000
18 
19 struct dpaa2_dq;
20 struct qbman_swp;
21 
22 /* qbman software portal descriptor structure */
23 struct qbman_swp_desc {
24 	void *cena_bar; /* Cache-enabled portal base address */
25 	void __iomem *cinh_bar; /* Cache-inhibited portal base address */
26 	u32 qman_version;
27 };
28 
29 #define QBMAN_SWP_INTERRUPT_EQRI 0x01
30 #define QBMAN_SWP_INTERRUPT_EQDI 0x02
31 #define QBMAN_SWP_INTERRUPT_DQRI 0x04
32 #define QBMAN_SWP_INTERRUPT_RCRI 0x08
33 #define QBMAN_SWP_INTERRUPT_RCDI 0x10
34 #define QBMAN_SWP_INTERRUPT_VDCI 0x20
35 
36 /* the structure for pull dequeue descriptor */
37 struct qbman_pull_desc {
38 	u8 verb;
39 	u8 numf;
40 	u8 tok;
41 	u8 reserved;
42 	__le32 dq_src;
43 	__le64 rsp_addr;
44 	u64 rsp_addr_virt;
45 	u8 padding[40];
46 };
47 
48 enum qbman_pull_type_e {
49 	/* dequeue with priority precedence, respect intra-class scheduling */
50 	qbman_pull_type_prio = 1,
51 	/* dequeue with active FQ precedence, respect ICS */
52 	qbman_pull_type_active,
53 	/* dequeue with active FQ precedence, no ICS */
54 	qbman_pull_type_active_noics
55 };
56 
57 /* Definitions for parsing dequeue entries */
58 #define QBMAN_RESULT_MASK      0x7f
59 #define QBMAN_RESULT_DQ        0x60
60 #define QBMAN_RESULT_FQRN      0x21
61 #define QBMAN_RESULT_FQRNI     0x22
62 #define QBMAN_RESULT_FQPN      0x24
63 #define QBMAN_RESULT_FQDAN     0x25
64 #define QBMAN_RESULT_CDAN      0x26
65 #define QBMAN_RESULT_CSCN_MEM  0x27
66 #define QBMAN_RESULT_CGCU      0x28
67 #define QBMAN_RESULT_BPSCN     0x29
68 #define QBMAN_RESULT_CSCN_WQ   0x2a
69 
70 /* QBMan FQ management command codes */
71 #define QBMAN_FQ_SCHEDULE	0x48
72 #define QBMAN_FQ_FORCE		0x49
73 #define QBMAN_FQ_XON		0x4d
74 #define QBMAN_FQ_XOFF		0x4e
75 
76 /* structure of enqueue descriptor */
77 struct qbman_eq_desc {
78 	u8 verb;
79 	u8 dca;
80 	__le16 seqnum;
81 	__le16 orpid;
82 	__le16 reserved1;
83 	__le32 tgtid;
84 	__le32 tag;
85 	__le16 qdbin;
86 	u8 qpri;
87 	u8 reserved[3];
88 	u8 wae;
89 	u8 rspid;
90 	__le64 rsp_addr;
91 };
92 
93 struct qbman_eq_desc_with_fd {
94 	struct qbman_eq_desc desc;
95 	u8 fd[32];
96 };
97 
98 /* buffer release descriptor */
99 struct qbman_release_desc {
100 	u8 verb;
101 	u8 reserved;
102 	__le16 bpid;
103 	__le32 reserved2;
104 	__le64 buf[7];
105 };
106 
107 /* Management command result codes */
108 #define QBMAN_MC_RSLT_OK      0xf0
109 
110 #define CODE_CDAN_WE_EN    0x1
111 #define CODE_CDAN_WE_CTX   0x4
112 
113 /* portal data structure */
114 struct qbman_swp {
115 	const struct qbman_swp_desc *desc;
116 	void *addr_cena;
117 	void __iomem *addr_cinh;
118 
119 	/* Management commands */
120 	struct {
121 		u32 valid_bit; /* 0x00 or 0x80 */
122 	} mc;
123 
124 	/* Management response */
125 	struct {
126 		u32 valid_bit; /* 0x00 or 0x80 */
127 	} mr;
128 
129 	/* Push dequeues */
130 	u32 sdq;
131 
132 	/* Volatile dequeues */
133 	struct {
134 		atomic_t available; /* indicates if a command can be sent */
135 		u32 valid_bit; /* 0x00 or 0x80 */
136 		struct dpaa2_dq *storage; /* NULL if DQRR */
137 	} vdq;
138 
139 	/* DQRR */
140 	struct {
141 		u32 next_idx;
142 		u32 valid_bit;
143 		u8 dqrr_size;
144 		int reset_bug; /* indicates dqrr reset workaround is needed */
145 	} dqrr;
146 
147 	struct {
148 		u32 pi;
149 		u32 pi_vb;
150 		u32 pi_ring_size;
151 		u32 pi_ci_mask;
152 		u32 ci;
153 		int available;
154 		u32 pend;
155 		u32 no_pfdr;
156 	} eqcr;
157 
158 	spinlock_t access_spinlock;
159 };
160 
161 /* Function pointers */
162 extern
163 int (*qbman_swp_enqueue_ptr)(struct qbman_swp *s,
164 			     const struct qbman_eq_desc *d,
165 			     const struct dpaa2_fd *fd);
166 extern
167 int (*qbman_swp_enqueue_multiple_ptr)(struct qbman_swp *s,
168 				      const struct qbman_eq_desc *d,
169 				      const struct dpaa2_fd *fd,
170 				      uint32_t *flags,
171 				      int num_frames);
172 extern
173 int (*qbman_swp_enqueue_multiple_desc_ptr)(struct qbman_swp *s,
174 					   const struct qbman_eq_desc *d,
175 					   const struct dpaa2_fd *fd,
176 					   int num_frames);
177 extern
178 int (*qbman_swp_pull_ptr)(struct qbman_swp *s, struct qbman_pull_desc *d);
179 extern
180 const struct dpaa2_dq *(*qbman_swp_dqrr_next_ptr)(struct qbman_swp *s);
181 extern
182 int (*qbman_swp_release_ptr)(struct qbman_swp *s,
183 			     const struct qbman_release_desc *d,
184 			     const u64 *buffers,
185 			     unsigned int num_buffers);
186 
187 /* Functions */
188 struct qbman_swp *qbman_swp_init(const struct qbman_swp_desc *d);
189 void qbman_swp_finish(struct qbman_swp *p);
190 u32 qbman_swp_interrupt_read_status(struct qbman_swp *p);
191 void qbman_swp_interrupt_clear_status(struct qbman_swp *p, u32 mask);
192 u32 qbman_swp_interrupt_get_trigger(struct qbman_swp *p);
193 void qbman_swp_interrupt_set_trigger(struct qbman_swp *p, u32 mask);
194 int qbman_swp_interrupt_get_inhibit(struct qbman_swp *p);
195 void qbman_swp_interrupt_set_inhibit(struct qbman_swp *p, int inhibit);
196 
197 void qbman_swp_push_get(struct qbman_swp *p, u8 channel_idx, int *enabled);
198 void qbman_swp_push_set(struct qbman_swp *p, u8 channel_idx, int enable);
199 
200 void qbman_pull_desc_clear(struct qbman_pull_desc *d);
201 void qbman_pull_desc_set_storage(struct qbman_pull_desc *d,
202 				 struct dpaa2_dq *storage,
203 				 dma_addr_t storage_phys,
204 				 int stash);
205 void qbman_pull_desc_set_numframes(struct qbman_pull_desc *d, u8 numframes);
206 void qbman_pull_desc_set_fq(struct qbman_pull_desc *d, u32 fqid);
207 void qbman_pull_desc_set_wq(struct qbman_pull_desc *d, u32 wqid,
208 			    enum qbman_pull_type_e dct);
209 void qbman_pull_desc_set_channel(struct qbman_pull_desc *d, u32 chid,
210 				 enum qbman_pull_type_e dct);
211 
212 void qbman_swp_dqrr_consume(struct qbman_swp *s, const struct dpaa2_dq *dq);
213 
214 int qbman_result_has_new_result(struct qbman_swp *p, const struct dpaa2_dq *dq);
215 
216 void qbman_eq_desc_clear(struct qbman_eq_desc *d);
217 void qbman_eq_desc_set_no_orp(struct qbman_eq_desc *d, int respond_success);
218 void qbman_eq_desc_set_token(struct qbman_eq_desc *d, u8 token);
219 void qbman_eq_desc_set_fq(struct qbman_eq_desc *d, u32 fqid);
220 void qbman_eq_desc_set_qd(struct qbman_eq_desc *d, u32 qdid,
221 			  u32 qd_bin, u32 qd_prio);
222 
223 
224 void qbman_release_desc_clear(struct qbman_release_desc *d);
225 void qbman_release_desc_set_bpid(struct qbman_release_desc *d, u16 bpid);
226 void qbman_release_desc_set_rcdi(struct qbman_release_desc *d, int enable);
227 
228 int qbman_swp_acquire(struct qbman_swp *s, u16 bpid, u64 *buffers,
229 		      unsigned int num_buffers);
230 int qbman_swp_alt_fq_state(struct qbman_swp *s, u32 fqid,
231 			   u8 alt_fq_verb);
232 int qbman_swp_CDAN_set(struct qbman_swp *s, u16 channelid,
233 		       u8 we_mask, u8 cdan_en,
234 		       u64 ctx);
235 
236 void *qbman_swp_mc_start(struct qbman_swp *p);
237 void qbman_swp_mc_submit(struct qbman_swp *p, void *cmd, u8 cmd_verb);
238 void *qbman_swp_mc_result(struct qbman_swp *p);
239 
240 /**
241  * qbman_swp_enqueue() - Issue an enqueue command
242  * @s:  the software portal used for enqueue
243  * @d:  the enqueue descriptor
244  * @fd: the frame descriptor to be enqueued
245  *
246  * Return 0 for successful enqueue, -EBUSY if the EQCR is not ready.
247  */
248 static inline int
249 qbman_swp_enqueue(struct qbman_swp *s, const struct qbman_eq_desc *d,
250 		  const struct dpaa2_fd *fd)
251 {
252 	return qbman_swp_enqueue_ptr(s, d, fd);
253 }
254 
255 /**
256  * qbman_swp_enqueue_multiple() - Issue a multi enqueue command
257  * using one enqueue descriptor
258  * @s:  the software portal used for enqueue
259  * @d:  the enqueue descriptor
260  * @fd: table pointer of frame descriptor table to be enqueued
261  * @flags: table pointer of QBMAN_ENQUEUE_FLAG_DCA flags, not used if NULL
262  * @num_frames: number of fd to be enqueued
263  *
264  * Return the number of fd enqueued, or a negative error number.
265  */
266 static inline int
267 qbman_swp_enqueue_multiple(struct qbman_swp *s,
268 			   const struct qbman_eq_desc *d,
269 			   const struct dpaa2_fd *fd,
270 			   uint32_t *flags,
271 			   int num_frames)
272 {
273 	return qbman_swp_enqueue_multiple_ptr(s, d, fd, flags, num_frames);
274 }
275 
276 /**
277  * qbman_swp_enqueue_multiple_desc() - Issue a multi enqueue command
278  * using multiple enqueue descriptor
279  * @s:  the software portal used for enqueue
280  * @d:  table of minimal enqueue descriptor
281  * @fd: table pointer of frame descriptor table to be enqueued
282  * @num_frames: number of fd to be enqueued
283  *
284  * Return the number of fd enqueued, or a negative error number.
285  */
286 static inline int
287 qbman_swp_enqueue_multiple_desc(struct qbman_swp *s,
288 				const struct qbman_eq_desc *d,
289 				const struct dpaa2_fd *fd,
290 				int num_frames)
291 {
292 	return qbman_swp_enqueue_multiple_desc_ptr(s, d, fd, num_frames);
293 }
294 
295 /**
296  * qbman_result_is_DQ() - check if the dequeue result is a dequeue response
297  * @dq: the dequeue result to be checked
298  *
299  * DQRR entries may contain non-dequeue results, ie. notifications
300  */
301 static inline int qbman_result_is_DQ(const struct dpaa2_dq *dq)
302 {
303 	return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_DQ);
304 }
305 
306 /**
307  * qbman_result_is_SCN() - Check the dequeue result is notification or not
308  * @dq: the dequeue result to be checked
309  *
310  */
311 static inline int qbman_result_is_SCN(const struct dpaa2_dq *dq)
312 {
313 	return !qbman_result_is_DQ(dq);
314 }
315 
316 /* FQ Data Availability */
317 static inline int qbman_result_is_FQDAN(const struct dpaa2_dq *dq)
318 {
319 	return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_FQDAN);
320 }
321 
322 /* Channel Data Availability */
323 static inline int qbman_result_is_CDAN(const struct dpaa2_dq *dq)
324 {
325 	return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_CDAN);
326 }
327 
328 /* Congestion State Change */
329 static inline int qbman_result_is_CSCN(const struct dpaa2_dq *dq)
330 {
331 	return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_CSCN_WQ);
332 }
333 
334 /* Buffer Pool State Change */
335 static inline int qbman_result_is_BPSCN(const struct dpaa2_dq *dq)
336 {
337 	return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_BPSCN);
338 }
339 
340 /* Congestion Group Count Update */
341 static inline int qbman_result_is_CGCU(const struct dpaa2_dq *dq)
342 {
343 	return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_CGCU);
344 }
345 
346 /* Retirement */
347 static inline int qbman_result_is_FQRN(const struct dpaa2_dq *dq)
348 {
349 	return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_FQRN);
350 }
351 
352 /* Retirement Immediate */
353 static inline int qbman_result_is_FQRNI(const struct dpaa2_dq *dq)
354 {
355 	return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_FQRNI);
356 }
357 
358  /* Park */
359 static inline int qbman_result_is_FQPN(const struct dpaa2_dq *dq)
360 {
361 	return ((dq->dq.verb & QBMAN_RESULT_MASK) == QBMAN_RESULT_FQPN);
362 }
363 
364 /**
365  * qbman_result_SCN_state() - Get the state field in State-change notification
366  */
367 static inline u8 qbman_result_SCN_state(const struct dpaa2_dq *scn)
368 {
369 	return scn->scn.state;
370 }
371 
372 #define SCN_RID_MASK 0x00FFFFFF
373 
374 /**
375  * qbman_result_SCN_rid() - Get the resource id in State-change notification
376  */
377 static inline u32 qbman_result_SCN_rid(const struct dpaa2_dq *scn)
378 {
379 	return le32_to_cpu(scn->scn.rid_tok) & SCN_RID_MASK;
380 }
381 
382 /**
383  * qbman_result_SCN_ctx() - Get the context data in State-change notification
384  */
385 static inline u64 qbman_result_SCN_ctx(const struct dpaa2_dq *scn)
386 {
387 	return le64_to_cpu(scn->scn.ctx);
388 }
389 
390 /**
391  * qbman_swp_fq_schedule() - Move the fq to the scheduled state
392  * @s:    the software portal object
393  * @fqid: the index of frame queue to be scheduled
394  *
395  * There are a couple of different ways that a FQ can end up parked state,
396  * This schedules it.
397  *
398  * Return 0 for success, or negative error code for failure.
399  */
400 static inline int qbman_swp_fq_schedule(struct qbman_swp *s, u32 fqid)
401 {
402 	return qbman_swp_alt_fq_state(s, fqid, QBMAN_FQ_SCHEDULE);
403 }
404 
405 /**
406  * qbman_swp_fq_force() - Force the FQ to fully scheduled state
407  * @s:    the software portal object
408  * @fqid: the index of frame queue to be forced
409  *
410  * Force eligible will force a tentatively-scheduled FQ to be fully-scheduled
411  * and thus be available for selection by any channel-dequeuing behaviour (push
412  * or pull). If the FQ is subsequently "dequeued" from the channel and is still
413  * empty at the time this happens, the resulting dq_entry will have no FD.
414  * (qbman_result_DQ_fd() will return NULL.)
415  *
416  * Return 0 for success, or negative error code for failure.
417  */
418 static inline int qbman_swp_fq_force(struct qbman_swp *s, u32 fqid)
419 {
420 	return qbman_swp_alt_fq_state(s, fqid, QBMAN_FQ_FORCE);
421 }
422 
423 /**
424  * qbman_swp_fq_xon() - sets FQ flow-control to XON
425  * @s:    the software portal object
426  * @fqid: the index of frame queue
427  *
428  * This setting doesn't affect enqueues to the FQ, just dequeues.
429  *
430  * Return 0 for success, or negative error code for failure.
431  */
432 static inline int qbman_swp_fq_xon(struct qbman_swp *s, u32 fqid)
433 {
434 	return qbman_swp_alt_fq_state(s, fqid, QBMAN_FQ_XON);
435 }
436 
437 /**
438  * qbman_swp_fq_xoff() - sets FQ flow-control to XOFF
439  * @s:    the software portal object
440  * @fqid: the index of frame queue
441  *
442  * This setting doesn't affect enqueues to the FQ, just dequeues.
443  * XOFF FQs will remain in the tenatively-scheduled state, even when
444  * non-empty, meaning they won't be selected for scheduled dequeuing.
445  * If a FQ is changed to XOFF after it had already become truly-scheduled
446  * to a channel, and a pull dequeue of that channel occurs that selects
447  * that FQ for dequeuing, then the resulting dq_entry will have no FD.
448  * (qbman_result_DQ_fd() will return NULL.)
449  *
450  * Return 0 for success, or negative error code for failure.
451  */
452 static inline int qbman_swp_fq_xoff(struct qbman_swp *s, u32 fqid)
453 {
454 	return qbman_swp_alt_fq_state(s, fqid, QBMAN_FQ_XOFF);
455 }
456 
457 /* If the user has been allocated a channel object that is going to generate
458  * CDANs to another channel, then the qbman_swp_CDAN* functions will be
459  * necessary.
460  *
461  * CDAN-enabled channels only generate a single CDAN notification, after which
462  * they need to be reenabled before they'll generate another. The idea is
463  * that pull dequeuing will occur in reaction to the CDAN, followed by a
464  * reenable step. Each function generates a distinct command to hardware, so a
465  * combination function is provided if the user wishes to modify the "context"
466  * (which shows up in each CDAN message) each time they reenable, as a single
467  * command to hardware.
468  */
469 
470 /**
471  * qbman_swp_CDAN_set_context() - Set CDAN context
472  * @s:         the software portal object
473  * @channelid: the channel index
474  * @ctx:       the context to be set in CDAN
475  *
476  * Return 0 for success, or negative error code for failure.
477  */
478 static inline int qbman_swp_CDAN_set_context(struct qbman_swp *s, u16 channelid,
479 					     u64 ctx)
480 {
481 	return qbman_swp_CDAN_set(s, channelid,
482 				  CODE_CDAN_WE_CTX,
483 				  0, ctx);
484 }
485 
486 /**
487  * qbman_swp_CDAN_enable() - Enable CDAN for the channel
488  * @s:         the software portal object
489  * @channelid: the index of the channel to generate CDAN
490  *
491  * Return 0 for success, or negative error code for failure.
492  */
493 static inline int qbman_swp_CDAN_enable(struct qbman_swp *s, u16 channelid)
494 {
495 	return qbman_swp_CDAN_set(s, channelid,
496 				  CODE_CDAN_WE_EN,
497 				  1, 0);
498 }
499 
500 /**
501  * qbman_swp_CDAN_disable() - disable CDAN for the channel
502  * @s:         the software portal object
503  * @channelid: the index of the channel to generate CDAN
504  *
505  * Return 0 for success, or negative error code for failure.
506  */
507 static inline int qbman_swp_CDAN_disable(struct qbman_swp *s, u16 channelid)
508 {
509 	return qbman_swp_CDAN_set(s, channelid,
510 				  CODE_CDAN_WE_EN,
511 				  0, 0);
512 }
513 
514 /**
515  * qbman_swp_CDAN_set_context_enable() - Set CDAN contest and enable CDAN
516  * @s:         the software portal object
517  * @channelid: the index of the channel to generate CDAN
518  * @ctx:i      the context set in CDAN
519  *
520  * Return 0 for success, or negative error code for failure.
521  */
522 static inline int qbman_swp_CDAN_set_context_enable(struct qbman_swp *s,
523 						    u16 channelid,
524 						    u64 ctx)
525 {
526 	return qbman_swp_CDAN_set(s, channelid,
527 				  CODE_CDAN_WE_EN | CODE_CDAN_WE_CTX,
528 				  1, ctx);
529 }
530 
531 /* Wraps up submit + poll-for-result */
532 static inline void *qbman_swp_mc_complete(struct qbman_swp *swp, void *cmd,
533 					  u8 cmd_verb)
534 {
535 	int loopvar = 2000;
536 
537 	qbman_swp_mc_submit(swp, cmd, cmd_verb);
538 
539 	do {
540 		cmd = qbman_swp_mc_result(swp);
541 	} while (!cmd && loopvar--);
542 
543 	WARN_ON(!loopvar);
544 
545 	return cmd;
546 }
547 
548 /* Query APIs */
549 struct qbman_fq_query_np_rslt {
550 	u8 verb;
551 	u8 rslt;
552 	u8 st1;
553 	u8 st2;
554 	u8 reserved[2];
555 	__le16 od1_sfdr;
556 	__le16 od2_sfdr;
557 	__le16 od3_sfdr;
558 	__le16 ra1_sfdr;
559 	__le16 ra2_sfdr;
560 	__le32 pfdr_hptr;
561 	__le32 pfdr_tptr;
562 	__le32 frm_cnt;
563 	__le32 byte_cnt;
564 	__le16 ics_surp;
565 	u8 is;
566 	u8 reserved2[29];
567 };
568 
569 int qbman_fq_query_state(struct qbman_swp *s, u32 fqid,
570 			 struct qbman_fq_query_np_rslt *r);
571 u32 qbman_fq_state_frame_count(const struct qbman_fq_query_np_rslt *r);
572 u32 qbman_fq_state_byte_count(const struct qbman_fq_query_np_rslt *r);
573 
574 struct qbman_bp_query_rslt {
575 	u8 verb;
576 	u8 rslt;
577 	u8 reserved[4];
578 	u8 bdi;
579 	u8 state;
580 	__le32 fill;
581 	__le32 hdotr;
582 	__le16 swdet;
583 	__le16 swdxt;
584 	__le16 hwdet;
585 	__le16 hwdxt;
586 	__le16 swset;
587 	__le16 swsxt;
588 	__le16 vbpid;
589 	__le16 icid;
590 	__le64 bpscn_addr;
591 	__le64 bpscn_ctx;
592 	__le16 hw_targ;
593 	u8 dbe;
594 	u8 reserved2;
595 	u8 sdcnt;
596 	u8 hdcnt;
597 	u8 sscnt;
598 	u8 reserved3[9];
599 };
600 
601 int qbman_bp_query(struct qbman_swp *s, u16 bpid,
602 		   struct qbman_bp_query_rslt *r);
603 
604 u32 qbman_bp_info_num_free_bufs(struct qbman_bp_query_rslt *a);
605 
606 /**
607  * qbman_swp_release() - Issue a buffer release command
608  * @s:           the software portal object
609  * @d:           the release descriptor
610  * @buffers:     a pointer pointing to the buffer address to be released
611  * @num_buffers: number of buffers to be released,  must be less than 8
612  *
613  * Return 0 for success, -EBUSY if the release command ring is not ready.
614  */
615 static inline int qbman_swp_release(struct qbman_swp *s,
616 				    const struct qbman_release_desc *d,
617 				    const u64 *buffers,
618 				    unsigned int num_buffers)
619 {
620 	return qbman_swp_release_ptr(s, d, buffers, num_buffers);
621 }
622 
623 /**
624  * qbman_swp_pull() - Issue the pull dequeue command
625  * @s: the software portal object
626  * @d: the software portal descriptor which has been configured with
627  *     the set of qbman_pull_desc_set_*() calls
628  *
629  * Return 0 for success, and -EBUSY if the software portal is not ready
630  * to do pull dequeue.
631  */
632 static inline int qbman_swp_pull(struct qbman_swp *s,
633 				 struct qbman_pull_desc *d)
634 {
635 	return qbman_swp_pull_ptr(s, d);
636 }
637 
638 /**
639  * qbman_swp_dqrr_next() - Get an valid DQRR entry
640  * @s: the software portal object
641  *
642  * Return NULL if there are no unconsumed DQRR entries. Return a DQRR entry
643  * only once, so repeated calls can return a sequence of DQRR entries, without
644  * requiring they be consumed immediately or in any particular order.
645  */
646 static inline const struct dpaa2_dq *qbman_swp_dqrr_next(struct qbman_swp *s)
647 {
648 	return qbman_swp_dqrr_next_ptr(s);
649 }
650 
651 #endif /* __FSL_QBMAN_PORTAL_H */
652