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