drivers/bus/dpaa/base/qbman/qman.h

   1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
   2  *
   3  * Copyright 2008-2016 Freescale Semiconductor Inc.
   4  * Copyright 2017 NXP
   5  *
   6  */
   7
   8 #include "qman_priv.h"
   9
  10 /***************************/
  11 /* Portal register assists */
  12 /***************************/
  13 #define QM_REG_EQCR_PI_CINH     0x3000
  14 #define QM_REG_EQCR_CI_CINH     0x3040
  15 #define QM_REG_EQCR_ITR         0x3080
  16 #define QM_REG_DQRR_PI_CINH     0x3100
  17 #define QM_REG_DQRR_CI_CINH     0x3140
  18 #define QM_REG_DQRR_ITR         0x3180
  19 #define QM_REG_DQRR_DCAP        0x31C0
  20 #define QM_REG_DQRR_SDQCR       0x3200
  21 #define QM_REG_DQRR_VDQCR       0x3240
  22 #define QM_REG_DQRR_PDQCR       0x3280
  23 #define QM_REG_MR_PI_CINH       0x3300
  24 #define QM_REG_MR_CI_CINH       0x3340
  25 #define QM_REG_MR_ITR           0x3380
  26 #define QM_REG_CFG              0x3500
  27 #define QM_REG_ISR              0x3600
  28 #define QM_REG_IIR              0x36C0
  29 #define QM_REG_ITPR             0x3740
  30
  31 /* Cache-enabled register offsets */
  32 #define QM_CL_EQCR              0x0000
  33 #define QM_CL_DQRR              0x1000
  34 #define QM_CL_MR                0x2000
  35 #define QM_CL_EQCR_PI_CENA      0x3000
  36 #define QM_CL_EQCR_CI_CENA      0x3040
  37 #define QM_CL_DQRR_PI_CENA      0x3100
  38 #define QM_CL_DQRR_CI_CENA      0x3140
  39 #define QM_CL_MR_PI_CENA        0x3300
  40 #define QM_CL_MR_CI_CENA        0x3340
  41 #define QM_CL_CR                0x3800
  42 #define QM_CL_RR0               0x3900
  43 #define QM_CL_RR1               0x3940
  44
  45 /* BTW, the drivers (and h/w programming model) already obtain the required
  46  * synchronisation for portal accesses via lwsync(), hwsync(), and
  47  * data-dependencies. Use of barrier()s or other order-preserving primitives
  48  * simply degrade performance. Hence the use of the __raw_*() interfaces, which
  49  * simply ensure that the compiler treats the portal registers as volatile (ie.
  50  * non-coherent).
  51  */
  52
  53 /* Cache-inhibited register access. */
  54 #define __qm_in(qm, o)          be32_to_cpu(__raw_readl((qm)->ci  + (o)))
  55 #define __qm_out(qm, o, val)    __raw_writel((cpu_to_be32(val)), \
  56                                              (qm)->ci + (o))
  57 #define qm_in(reg)              __qm_in(&portal->addr, QM_REG_##reg)
  58 #define qm_out(reg, val)        __qm_out(&portal->addr, QM_REG_##reg, val)
  59
  60 /* Cache-enabled (index) register access */
  61 #define __qm_cl_touch_ro(qm, o) dcbt_ro((qm)->ce + (o))
  62 #define __qm_cl_touch_rw(qm, o) dcbt_rw((qm)->ce + (o))
  63 #define __qm_cl_in(qm, o)       be32_to_cpu(__raw_readl((qm)->ce + (o)))
  64 #define __qm_cl_out(qm, o, val) \
  65         do { \
  66                 u32 *__tmpclout = (qm)->ce + (o); \
  67                 __raw_writel(cpu_to_be32(val), __tmpclout); \
  68                 dcbf(__tmpclout); \
  69         } while (0)
  70 #define __qm_cl_invalidate(qm, o) dccivac((qm)->ce + (o))
  71 #define qm_cl_touch_ro(reg) __qm_cl_touch_ro(&portal->addr, QM_CL_##reg##_CENA)
  72 #define qm_cl_touch_rw(reg) __qm_cl_touch_rw(&portal->addr, QM_CL_##reg##_CENA)
  73 #define qm_cl_in(reg)       __qm_cl_in(&portal->addr, QM_CL_##reg##_CENA)
  74 #define qm_cl_out(reg, val) __qm_cl_out(&portal->addr, QM_CL_##reg##_CENA, val)
  75 #define qm_cl_invalidate(reg)\
  76         __qm_cl_invalidate(&portal->addr, QM_CL_##reg##_CENA)
  77
  78 /* Cache-enabled ring access */
  79 #define qm_cl(base, idx)        ((void *)base + ((idx) << 6))
  80
  81 /* Cyclic helper for rings. FIXME: once we are able to do fine-grain perf
  82  * analysis, look at using the "extra" bit in the ring index registers to avoid
  83  * cyclic issues.
  84  */
  85 static inline u8 qm_cyc_diff(u8 ringsize, u8 first, u8 last)
  86 {
  87         /* 'first' is included, 'last' is excluded */
  88         if (first <= last)
  89                 return last - first;
  90         return ringsize + last - first;
  91 }
  92
  93 /* Portal modes.
  94  *   Enum types;
  95  *     pmode == production mode
  96  *     cmode == consumption mode,
  97  *     dmode == h/w dequeue mode.
  98  *   Enum values use 3 letter codes. First letter matches the portal mode,
  99  *   remaining two letters indicate;
 100  *     ci == cache-inhibited portal register
 101  *     ce == cache-enabled portal register
 102  *     vb == in-band valid-bit (cache-enabled)
 103  *     dc == DCA (Discrete Consumption Acknowledgment), DQRR-only
 104  *   As for "enum qm_dqrr_dmode", it should be self-explanatory.
 105  */
 106 enum qm_eqcr_pmode {            /* matches QCSP_CFG::EPM */
 107         qm_eqcr_pci = 0,        /* PI index, cache-inhibited */
 108         qm_eqcr_pce = 1,        /* PI index, cache-enabled */
 109         qm_eqcr_pvb = 2         /* valid-bit */
 110 };
 111
 112 enum qm_dqrr_dmode {            /* matches QCSP_CFG::DP */
 113         qm_dqrr_dpush = 0,      /* SDQCR  + VDQCR */
 114         qm_dqrr_dpull = 1       /* PDQCR */
 115 };
 116
 117 enum qm_dqrr_pmode {            /* s/w-only */
 118         qm_dqrr_pci,            /* reads DQRR_PI_CINH */
 119         qm_dqrr_pce,            /* reads DQRR_PI_CENA */
 120         qm_dqrr_pvb             /* reads valid-bit */
 121 };
 122
 123 enum qm_dqrr_cmode {            /* matches QCSP_CFG::DCM */
 124         qm_dqrr_cci = 0,        /* CI index, cache-inhibited */
 125         qm_dqrr_cce = 1,        /* CI index, cache-enabled */
 126         qm_dqrr_cdc = 2         /* Discrete Consumption Acknowledgment */
 127 };
 128
 129 enum qm_mr_pmode {              /* s/w-only */
 130         qm_mr_pci,              /* reads MR_PI_CINH */
 131         qm_mr_pce,              /* reads MR_PI_CENA */
 132         qm_mr_pvb               /* reads valid-bit */
 133 };
 134
 135 enum qm_mr_cmode {              /* matches QCSP_CFG::MM */
 136         qm_mr_cci = 0,          /* CI index, cache-inhibited */
 137         qm_mr_cce = 1           /* CI index, cache-enabled */
 138 };
 139
 140 /* ------------------------- */
 141 /* --- Portal structures --- */
 142
 143 #define QM_EQCR_SIZE            8
 144 #define QM_DQRR_SIZE            16
 145 #define QM_MR_SIZE              8
 146
 147 struct qm_eqcr {
 148         struct qm_eqcr_entry *ring, *cursor;
 149         u8 ci, available, ithresh, vbit;
 150 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 151         u32 busy;
 152         enum qm_eqcr_pmode pmode;
 153 #endif
 154 };
 155
 156 struct qm_dqrr {
 157         struct qm_dqrr_entry *ring, *cursor;
 158         u8 pi, ci, fill, ithresh, vbit;
 159 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 160         enum qm_dqrr_dmode dmode;
 161         enum qm_dqrr_pmode pmode;
 162         enum qm_dqrr_cmode cmode;
 163 #endif
 164 };
 165
 166 struct qm_mr {
 167         const struct qm_mr_entry *ring, *cursor;
 168         u8 pi, ci, fill, ithresh, vbit;
 169 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 170         enum qm_mr_pmode pmode;
 171         enum qm_mr_cmode cmode;
 172 #endif
 173 };
 174
 175 struct qm_mc {
 176         struct qm_mc_command *cr;
 177         struct qm_mc_result *rr;
 178         u8 rridx, vbit;
 179 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 180         enum {
 181                 /* Can be _mc_start()ed */
 182                 qman_mc_idle,
 183                 /* Can be _mc_commit()ed or _mc_abort()ed */
 184                 qman_mc_user,
 185                 /* Can only be _mc_retry()ed */
 186                 qman_mc_hw
 187         } state;
 188 #endif
 189 };
 190
 191 #define QM_PORTAL_ALIGNMENT ____cacheline_aligned
 192
 193 struct qm_addr {
 194         void __iomem *ce;       /* cache-enabled */
 195         void __iomem *ci;       /* cache-inhibited */
 196 };
 197
 198 struct qm_portal {
 199         struct qm_addr addr;
 200         struct qm_eqcr eqcr;
 201         struct qm_dqrr dqrr;
 202         struct qm_mr mr;
 203         struct qm_mc mc;
 204 } QM_PORTAL_ALIGNMENT;
 205
 206 /* Bit-wise logic to wrap a ring pointer by clearing the "carry bit" */
 207 #define EQCR_CARRYCLEAR(p) \
 208         (void *)((unsigned long)(p) & (~(unsigned long)(QM_EQCR_SIZE << 6)))
 209
 210 extern dma_addr_t rte_mem_virt2iova(const void *addr);
 211
 212 /* Bit-wise logic to convert a ring pointer to a ring index */
 213 static inline u8 EQCR_PTR2IDX(struct qm_eqcr_entry *e)
 214 {
 215         return ((uintptr_t)e >> 6) & (QM_EQCR_SIZE - 1);
 216 }
 217
 218 /* Increment the 'cursor' ring pointer, taking 'vbit' into account */
 219 static inline void EQCR_INC(struct qm_eqcr *eqcr)
 220 {
 221         /* NB: this is odd-looking, but experiments show that it generates fast
 222          * code with essentially no branching overheads. We increment to the
 223          * next EQCR pointer and handle overflow and 'vbit'.
 224          */
 225         struct qm_eqcr_entry *partial = eqcr->cursor + 1;
 226
 227         eqcr->cursor = EQCR_CARRYCLEAR(partial);
 228         if (partial != eqcr->cursor)
 229                 eqcr->vbit ^= QM_EQCR_VERB_VBIT;
 230 }
 231
 232 static inline struct qm_eqcr_entry *qm_eqcr_start_no_stash(struct qm_portal
 233                                                                  *portal)
 234 {
 235         register struct qm_eqcr *eqcr = &portal->eqcr;
 236
 237 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 238         DPAA_ASSERT(!eqcr->busy);
 239 #endif
 240         if (!eqcr->available)
 241                 return NULL;
 242
 243 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 244         eqcr->busy = 1;
 245 #endif
 246
 247         return eqcr->cursor;
 248 }
 249
 250 static inline struct qm_eqcr_entry *qm_eqcr_start_stash(struct qm_portal
 251                                                                 *portal)
 252 {
 253         register struct qm_eqcr *eqcr = &portal->eqcr;
 254         u8 diff, old_ci;
 255
 256 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 257         DPAA_ASSERT(!eqcr->busy);
 258 #endif
 259         if (!eqcr->available) {
 260                 old_ci = eqcr->ci;
 261                 eqcr->ci = qm_cl_in(EQCR_CI) & (QM_EQCR_SIZE - 1);
 262                 diff = qm_cyc_diff(QM_EQCR_SIZE, old_ci, eqcr->ci);
 263                 eqcr->available += diff;
 264                 if (!diff)
 265                         return NULL;
 266         }
 267 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 268         eqcr->busy = 1;
 269 #endif
 270         return eqcr->cursor;
 271 }
 272
 273 static inline void qm_eqcr_abort(struct qm_portal *portal)
 274 {
 275         __maybe_unused register struct qm_eqcr *eqcr = &portal->eqcr;
 276
 277 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 278         DPAA_ASSERT(eqcr->busy);
 279         eqcr->busy = 0;
 280 #endif
 281 }
 282
 283 static inline struct qm_eqcr_entry *qm_eqcr_pend_and_next(
 284                                         struct qm_portal *portal, u8 myverb)
 285 {
 286         register struct qm_eqcr *eqcr = &portal->eqcr;
 287
 288 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 289         DPAA_ASSERT(eqcr->busy);
 290         DPAA_ASSERT(eqcr->pmode != qm_eqcr_pvb);
 291 #endif
 292         if (eqcr->available == 1)
 293                 return NULL;
 294         eqcr->cursor->__dont_write_directly__verb = myverb | eqcr->vbit;
 295         dcbf(eqcr->cursor);
 296         EQCR_INC(eqcr);
 297         eqcr->available--;
 298         return eqcr->cursor;
 299 }
 300
 301 #define EQCR_COMMIT_CHECKS(eqcr) \
 302 do { \
 303         DPAA_ASSERT(eqcr->busy); \
 304         DPAA_ASSERT(eqcr->cursor->orp == (eqcr->cursor->orp & 0x00ffffff)); \
 305         DPAA_ASSERT(eqcr->cursor->fqid == (eqcr->cursor->fqid & 0x00ffffff)); \
 306 } while (0)
 307
 308 static inline void qm_eqcr_pci_commit(struct qm_portal *portal, u8 myverb)
 309 {
 310         register struct qm_eqcr *eqcr = &portal->eqcr;
 311
 312 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 313         EQCR_COMMIT_CHECKS(eqcr);
 314         DPAA_ASSERT(eqcr->pmode == qm_eqcr_pci);
 315 #endif
 316         eqcr->cursor->__dont_write_directly__verb = myverb | eqcr->vbit;
 317         EQCR_INC(eqcr);
 318         eqcr->available--;
 319         dcbf(eqcr->cursor);
 320         hwsync();
 321         qm_out(EQCR_PI_CINH, EQCR_PTR2IDX(eqcr->cursor));
 322 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 323         eqcr->busy = 0;
 324 #endif
 325 }
 326
 327 static inline void qm_eqcr_pce_prefetch(struct qm_portal *portal)
 328 {
 329         __maybe_unused register struct qm_eqcr *eqcr = &portal->eqcr;
 330
 331 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 332         DPAA_ASSERT(eqcr->pmode == qm_eqcr_pce);
 333 #endif
 334         qm_cl_invalidate(EQCR_PI);
 335         qm_cl_touch_rw(EQCR_PI);
 336 }
 337
 338 static inline void qm_eqcr_pce_commit(struct qm_portal *portal, u8 myverb)
 339 {
 340         register struct qm_eqcr *eqcr = &portal->eqcr;
 341
 342 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 343         EQCR_COMMIT_CHECKS(eqcr);
 344         DPAA_ASSERT(eqcr->pmode == qm_eqcr_pce);
 345 #endif
 346         eqcr->cursor->__dont_write_directly__verb = myverb | eqcr->vbit;
 347         EQCR_INC(eqcr);
 348         eqcr->available--;
 349         dcbf(eqcr->cursor);
 350         lwsync();
 351         qm_cl_out(EQCR_PI, EQCR_PTR2IDX(eqcr->cursor));
 352 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 353         eqcr->busy = 0;
 354 #endif
 355 }
 356
 357 static inline void qm_eqcr_pvb_commit(struct qm_portal *portal, u8 myverb)
 358 {
 359         register struct qm_eqcr *eqcr = &portal->eqcr;
 360         struct qm_eqcr_entry *eqcursor;
 361
 362 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 363         EQCR_COMMIT_CHECKS(eqcr);
 364         DPAA_ASSERT(eqcr->pmode == qm_eqcr_pvb);
 365 #endif
 366         lwsync();
 367         eqcursor = eqcr->cursor;
 368         eqcursor->__dont_write_directly__verb = myverb | eqcr->vbit;
 369         dcbf(eqcursor);
 370         EQCR_INC(eqcr);
 371         eqcr->available--;
 372 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 373         eqcr->busy = 0;
 374 #endif
 375 }
 376
 377 static inline u8 qm_eqcr_cci_update(struct qm_portal *portal)
 378 {
 379         register struct qm_eqcr *eqcr = &portal->eqcr;
 380         u8 diff, old_ci = eqcr->ci;
 381
 382         eqcr->ci = qm_in(EQCR_CI_CINH) & (QM_EQCR_SIZE - 1);
 383         diff = qm_cyc_diff(QM_EQCR_SIZE, old_ci, eqcr->ci);
 384         eqcr->available += diff;
 385         return diff;
 386 }
 387
 388 static inline void qm_eqcr_cce_prefetch(struct qm_portal *portal)
 389 {
 390         __maybe_unused register struct qm_eqcr *eqcr = &portal->eqcr;
 391
 392         qm_cl_touch_ro(EQCR_CI);
 393 }
 394
 395 static inline u8 qm_eqcr_cce_update(struct qm_portal *portal)
 396 {
 397         register struct qm_eqcr *eqcr = &portal->eqcr;
 398         u8 diff, old_ci = eqcr->ci;
 399
 400         eqcr->ci = qm_cl_in(EQCR_CI) & (QM_EQCR_SIZE - 1);
 401         qm_cl_invalidate(EQCR_CI);
 402         diff = qm_cyc_diff(QM_EQCR_SIZE, old_ci, eqcr->ci);
 403         eqcr->available += diff;
 404         return diff;
 405 }
 406
 407 static inline u8 qm_eqcr_get_ithresh(struct qm_portal *portal)
 408 {
 409         register struct qm_eqcr *eqcr = &portal->eqcr;
 410
 411         return eqcr->ithresh;
 412 }
 413
 414 static inline void qm_eqcr_set_ithresh(struct qm_portal *portal, u8 ithresh)
 415 {
 416         register struct qm_eqcr *eqcr = &portal->eqcr;
 417
 418         eqcr->ithresh = ithresh;
 419         qm_out(EQCR_ITR, ithresh);
 420 }
 421
 422 static inline u8 qm_eqcr_get_avail(struct qm_portal *portal)
 423 {
 424         register struct qm_eqcr *eqcr = &portal->eqcr;
 425
 426         return eqcr->available;
 427 }
 428
 429 static inline u8 qm_eqcr_get_fill(struct qm_portal *portal)
 430 {
 431         register struct qm_eqcr *eqcr = &portal->eqcr;
 432
 433         return QM_EQCR_SIZE - 1 - eqcr->available;
 434 }
 435
 436 #define DQRR_CARRYCLEAR(p) \
 437         (void *)((unsigned long)(p) & (~(unsigned long)(QM_DQRR_SIZE << 6)))
 438
 439 static inline u8 DQRR_PTR2IDX(const struct qm_dqrr_entry *e)
 440 {
 441         return ((uintptr_t)e >> 6) & (QM_DQRR_SIZE - 1);
 442 }
 443
 444 static inline struct qm_dqrr_entry *DQRR_INC(
 445                                                 const struct qm_dqrr_entry *e)
 446 {
 447         return DQRR_CARRYCLEAR(e + 1);
 448 }
 449
 450 static inline void qm_dqrr_set_maxfill(struct qm_portal *portal, u8 mf)
 451 {
 452         qm_out(CFG, (qm_in(CFG) & 0xff0fffff) |
 453                 ((mf & (QM_DQRR_SIZE - 1)) << 20));
 454 }
 455
 456 static inline const struct qm_dqrr_entry *qm_dqrr_current(
 457                                                 struct qm_portal *portal)
 458 {
 459         register struct qm_dqrr *dqrr = &portal->dqrr;
 460
 461         if (!dqrr->fill)
 462                 return NULL;
 463         return dqrr->cursor;
 464 }
 465
 466 static inline u8 qm_dqrr_cursor(struct qm_portal *portal)
 467 {
 468         register struct qm_dqrr *dqrr = &portal->dqrr;
 469
 470         return DQRR_PTR2IDX(dqrr->cursor);
 471 }
 472
 473 static inline u8 qm_dqrr_next(struct qm_portal *portal)
 474 {
 475         register struct qm_dqrr *dqrr = &portal->dqrr;
 476
 477         DPAA_ASSERT(dqrr->fill);
 478         dqrr->cursor = DQRR_INC(dqrr->cursor);
 479         return --dqrr->fill;
 480 }
 481
 482 static inline u8 qm_dqrr_pci_update(struct qm_portal *portal)
 483 {
 484         register struct qm_dqrr *dqrr = &portal->dqrr;
 485         u8 diff, old_pi = dqrr->pi;
 486
 487 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 488         DPAA_ASSERT(dqrr->pmode == qm_dqrr_pci);
 489 #endif
 490         dqrr->pi = qm_in(DQRR_PI_CINH) & (QM_DQRR_SIZE - 1);
 491         diff = qm_cyc_diff(QM_DQRR_SIZE, old_pi, dqrr->pi);
 492         dqrr->fill += diff;
 493         return diff;
 494 }
 495
 496 static inline void qm_dqrr_pce_prefetch(struct qm_portal *portal)
 497 {
 498         __maybe_unused register struct qm_dqrr *dqrr = &portal->dqrr;
 499
 500 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 501         DPAA_ASSERT(dqrr->pmode == qm_dqrr_pce);
 502 #endif
 503         qm_cl_invalidate(DQRR_PI);
 504         qm_cl_touch_ro(DQRR_PI);
 505 }
 506
 507 static inline u8 qm_dqrr_pce_update(struct qm_portal *portal)
 508 {
 509         register struct qm_dqrr *dqrr = &portal->dqrr;
 510         u8 diff, old_pi = dqrr->pi;
 511
 512 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 513         DPAA_ASSERT(dqrr->pmode == qm_dqrr_pce);
 514 #endif
 515         dqrr->pi = qm_cl_in(DQRR_PI) & (QM_DQRR_SIZE - 1);
 516         diff = qm_cyc_diff(QM_DQRR_SIZE, old_pi, dqrr->pi);
 517         dqrr->fill += diff;
 518         return diff;
 519 }
 520
 521 static inline void qm_dqrr_pvb_update(struct qm_portal *portal)
 522 {
 523         register struct qm_dqrr *dqrr = &portal->dqrr;
 524         const struct qm_dqrr_entry *res = qm_cl(dqrr->ring, dqrr->pi);
 525
 526 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 527         DPAA_ASSERT(dqrr->pmode == qm_dqrr_pvb);
 528 #endif
 529         /* when accessing 'verb', use __raw_readb() to ensure that compiler
 530          * inlining doesn't try to optimise out "excess reads".
 531          */
 532         if ((__raw_readb(&res->verb) & QM_DQRR_VERB_VBIT) == dqrr->vbit) {
 533                 dqrr->pi = (dqrr->pi + 1) & (QM_DQRR_SIZE - 1);
 534                 if (!dqrr->pi)
 535                         dqrr->vbit ^= QM_DQRR_VERB_VBIT;
 536                 dqrr->fill++;
 537         }
 538 }
 539
 540 static inline void qm_dqrr_cci_consume(struct qm_portal *portal, u8 num)
 541 {
 542         register struct qm_dqrr *dqrr = &portal->dqrr;
 543
 544 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 545         DPAA_ASSERT(dqrr->cmode == qm_dqrr_cci);
 546 #endif
 547         dqrr->ci = (dqrr->ci + num) & (QM_DQRR_SIZE - 1);
 548         qm_out(DQRR_CI_CINH, dqrr->ci);
 549 }
 550
 551 static inline void qm_dqrr_cci_consume_to_current(struct qm_portal *portal)
 552 {
 553         register struct qm_dqrr *dqrr = &portal->dqrr;
 554
 555 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 556         DPAA_ASSERT(dqrr->cmode == qm_dqrr_cci);
 557 #endif
 558         dqrr->ci = DQRR_PTR2IDX(dqrr->cursor);
 559         qm_out(DQRR_CI_CINH, dqrr->ci);
 560 }
 561
 562 static inline void qm_dqrr_cce_prefetch(struct qm_portal *portal)
 563 {
 564         __maybe_unused register struct qm_dqrr *dqrr = &portal->dqrr;
 565
 566 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 567         DPAA_ASSERT(dqrr->cmode == qm_dqrr_cce);
 568 #endif
 569         qm_cl_invalidate(DQRR_CI);
 570         qm_cl_touch_rw(DQRR_CI);
 571 }
 572
 573 static inline void qm_dqrr_cce_consume(struct qm_portal *portal, u8 num)
 574 {
 575         register struct qm_dqrr *dqrr = &portal->dqrr;
 576
 577 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 578         DPAA_ASSERT(dqrr->cmode == qm_dqrr_cce);
 579 #endif
 580         dqrr->ci = (dqrr->ci + num) & (QM_DQRR_SIZE - 1);
 581         qm_cl_out(DQRR_CI, dqrr->ci);
 582 }
 583
 584 static inline void qm_dqrr_cce_consume_to_current(struct qm_portal *portal)
 585 {
 586         register struct qm_dqrr *dqrr = &portal->dqrr;
 587
 588 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 589         DPAA_ASSERT(dqrr->cmode == qm_dqrr_cce);
 590 #endif
 591         dqrr->ci = DQRR_PTR2IDX(dqrr->cursor);
 592         qm_cl_out(DQRR_CI, dqrr->ci);
 593 }
 594
 595 static inline void qm_dqrr_cdc_consume_1(struct qm_portal *portal, u8 idx,
 596                                          int park)
 597 {
 598         __maybe_unused register struct qm_dqrr *dqrr = &portal->dqrr;
 599
 600 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 601         DPAA_ASSERT(dqrr->cmode == qm_dqrr_cdc);
 602 #endif
 603         DPAA_ASSERT(idx < QM_DQRR_SIZE);
 604         qm_out(DQRR_DCAP, (0 << 8) |    /* S */
 605                 ((park ? 1 : 0) << 6) | /* PK */
 606                 idx);                   /* DCAP_CI */
 607 }
 608
 609 static inline void qm_dqrr_cdc_consume_1ptr(struct qm_portal *portal,
 610                                             const struct qm_dqrr_entry *dq,
 611                                         int park)
 612 {
 613         __maybe_unused register struct qm_dqrr *dqrr = &portal->dqrr;
 614         u8 idx = DQRR_PTR2IDX(dq);
 615
 616 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 617         DPAA_ASSERT(dqrr->cmode == qm_dqrr_cdc);
 618 #endif
 619         DPAA_ASSERT(idx < QM_DQRR_SIZE);
 620         qm_out(DQRR_DCAP, (0 << 8) |            /* DQRR_DCAP::S */
 621                 ((park ? 1 : 0) << 6) |         /* DQRR_DCAP::PK */
 622                 idx);                           /* DQRR_DCAP::DCAP_CI */
 623 }
 624
 625 static inline void qm_dqrr_cdc_consume_n(struct qm_portal *portal, u16 bitmask)
 626 {
 627         __maybe_unused register struct qm_dqrr *dqrr = &portal->dqrr;
 628
 629 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 630         DPAA_ASSERT(dqrr->cmode == qm_dqrr_cdc);
 631 #endif
 632         qm_out(DQRR_DCAP, (1 << 8) |            /* DQRR_DCAP::S */
 633                 ((u32)bitmask << 16));          /* DQRR_DCAP::DCAP_CI */
 634         dqrr->ci = qm_in(DQRR_CI_CINH) & (QM_DQRR_SIZE - 1);
 635         dqrr->fill = qm_cyc_diff(QM_DQRR_SIZE, dqrr->ci, dqrr->pi);
 636 }
 637
 638 static inline u8 qm_dqrr_cdc_cci(struct qm_portal *portal)
 639 {
 640         __maybe_unused register struct qm_dqrr *dqrr = &portal->dqrr;
 641
 642 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 643         DPAA_ASSERT(dqrr->cmode == qm_dqrr_cdc);
 644 #endif
 645         return qm_in(DQRR_CI_CINH) & (QM_DQRR_SIZE - 1);
 646 }
 647
 648 static inline void qm_dqrr_cdc_cce_prefetch(struct qm_portal *portal)
 649 {
 650         __maybe_unused register struct qm_dqrr *dqrr = &portal->dqrr;
 651
 652 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 653         DPAA_ASSERT(dqrr->cmode == qm_dqrr_cdc);
 654 #endif
 655         qm_cl_invalidate(DQRR_CI);
 656         qm_cl_touch_ro(DQRR_CI);
 657 }
 658
 659 static inline u8 qm_dqrr_cdc_cce(struct qm_portal *portal)
 660 {
 661         __maybe_unused register struct qm_dqrr *dqrr = &portal->dqrr;
 662
 663 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 664         DPAA_ASSERT(dqrr->cmode == qm_dqrr_cdc);
 665 #endif
 666         return qm_cl_in(DQRR_CI) & (QM_DQRR_SIZE - 1);
 667 }
 668
 669 static inline u8 qm_dqrr_get_ci(struct qm_portal *portal)
 670 {
 671         register struct qm_dqrr *dqrr = &portal->dqrr;
 672
 673 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 674         DPAA_ASSERT(dqrr->cmode != qm_dqrr_cdc);
 675 #endif
 676         return dqrr->ci;
 677 }
 678
 679 static inline void qm_dqrr_park(struct qm_portal *portal, u8 idx)
 680 {
 681         __maybe_unused register struct qm_dqrr *dqrr = &portal->dqrr;
 682
 683 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 684         DPAA_ASSERT(dqrr->cmode != qm_dqrr_cdc);
 685 #endif
 686         qm_out(DQRR_DCAP, (0 << 8) |            /* S */
 687                 (1 << 6) |                      /* PK */
 688                 (idx & (QM_DQRR_SIZE - 1)));    /* DCAP_CI */
 689 }
 690
 691 static inline void qm_dqrr_park_current(struct qm_portal *portal)
 692 {
 693         register struct qm_dqrr *dqrr = &portal->dqrr;
 694
 695 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 696         DPAA_ASSERT(dqrr->cmode != qm_dqrr_cdc);
 697 #endif
 698         qm_out(DQRR_DCAP, (0 << 8) |            /* S */
 699                 (1 << 6) |                      /* PK */
 700                 DQRR_PTR2IDX(dqrr->cursor));    /* DCAP_CI */
 701 }
 702
 703 static inline void qm_dqrr_sdqcr_set(struct qm_portal *portal, u32 sdqcr)
 704 {
 705         qm_out(DQRR_SDQCR, sdqcr);
 706 }
 707
 708 static inline u32 qm_dqrr_sdqcr_get(struct qm_portal *portal)
 709 {
 710         return qm_in(DQRR_SDQCR);
 711 }
 712
 713 static inline void qm_dqrr_vdqcr_set(struct qm_portal *portal, u32 vdqcr)
 714 {
 715         qm_out(DQRR_VDQCR, vdqcr);
 716 }
 717
 718 static inline u32 qm_dqrr_vdqcr_get(struct qm_portal *portal)
 719 {
 720         return qm_in(DQRR_VDQCR);
 721 }
 722
 723 static inline u8 qm_dqrr_get_ithresh(struct qm_portal *portal)
 724 {
 725         register struct qm_dqrr *dqrr = &portal->dqrr;
 726
 727         return dqrr->ithresh;
 728 }
 729
 730 static inline void qm_dqrr_set_ithresh(struct qm_portal *portal, u8 ithresh)
 731 {
 732         qm_out(DQRR_ITR, ithresh);
 733 }
 734
 735 static inline u8 qm_dqrr_get_maxfill(struct qm_portal *portal)
 736 {
 737         return (qm_in(CFG) & 0x00f00000) >> 20;
 738 }
 739
 740 /* -------------- */
 741 /* --- MR API --- */
 742
 743 #define MR_CARRYCLEAR(p) \
 744         (void *)((unsigned long)(p) & (~(unsigned long)(QM_MR_SIZE << 6)))
 745
 746 static inline u8 MR_PTR2IDX(const struct qm_mr_entry *e)
 747 {
 748         return ((uintptr_t)e >> 6) & (QM_MR_SIZE - 1);
 749 }
 750
 751 static inline const struct qm_mr_entry *MR_INC(const struct qm_mr_entry *e)
 752 {
 753         return MR_CARRYCLEAR(e + 1);
 754 }
 755
 756 static inline void qm_mr_finish(struct qm_portal *portal)
 757 {
 758         register struct qm_mr *mr = &portal->mr;
 759
 760         if (mr->ci != MR_PTR2IDX(mr->cursor))
 761                 pr_crit("Ignoring completed MR entries\n");
 762 }
 763
 764 static inline const struct qm_mr_entry *qm_mr_current(struct qm_portal *portal)
 765 {
 766         register struct qm_mr *mr = &portal->mr;
 767
 768         if (!mr->fill)
 769                 return NULL;
 770         return mr->cursor;
 771 }
 772
 773 static inline u8 qm_mr_next(struct qm_portal *portal)
 774 {
 775         register struct qm_mr *mr = &portal->mr;
 776
 777         DPAA_ASSERT(mr->fill);
 778         mr->cursor = MR_INC(mr->cursor);
 779         return --mr->fill;
 780 }
 781
 782 static inline void qm_mr_cci_consume(struct qm_portal *portal, u8 num)
 783 {
 784         register struct qm_mr *mr = &portal->mr;
 785
 786 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 787         DPAA_ASSERT(mr->cmode == qm_mr_cci);
 788 #endif
 789         mr->ci = (mr->ci + num) & (QM_MR_SIZE - 1);
 790         qm_out(MR_CI_CINH, mr->ci);
 791 }
 792
 793 static inline void qm_mr_cci_consume_to_current(struct qm_portal *portal)
 794 {
 795         register struct qm_mr *mr = &portal->mr;
 796
 797 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 798         DPAA_ASSERT(mr->cmode == qm_mr_cci);
 799 #endif
 800         mr->ci = MR_PTR2IDX(mr->cursor);
 801         qm_out(MR_CI_CINH, mr->ci);
 802 }
 803
 804 static inline void qm_mr_set_ithresh(struct qm_portal *portal, u8 ithresh)
 805 {
 806         qm_out(MR_ITR, ithresh);
 807 }
 808
 809 /* ------------------------------ */
 810 /* --- Management command API --- */
 811 static inline int qm_mc_init(struct qm_portal *portal)
 812 {
 813         register struct qm_mc *mc = &portal->mc;
 814
 815         mc->cr = portal->addr.ce + QM_CL_CR;
 816         mc->rr = portal->addr.ce + QM_CL_RR0;
 817         mc->rridx = (__raw_readb(&mc->cr->__dont_write_directly__verb) &
 818                         QM_MCC_VERB_VBIT) ?  0 : 1;
 819         mc->vbit = mc->rridx ? QM_MCC_VERB_VBIT : 0;
 820 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 821         mc->state = qman_mc_idle;
 822 #endif
 823         return 0;
 824 }
 825
 826 static inline void qm_mc_finish(struct qm_portal *portal)
 827 {
 828         __maybe_unused register struct qm_mc *mc = &portal->mc;
 829
 830 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 831         DPAA_ASSERT(mc->state == qman_mc_idle);
 832         if (mc->state != qman_mc_idle)
 833                 pr_crit("Losing incomplete MC command\n");
 834 #endif
 835 }
 836
 837 static inline struct qm_mc_command *qm_mc_start(struct qm_portal *portal)
 838 {
 839         register struct qm_mc *mc = &portal->mc;
 840
 841 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 842         DPAA_ASSERT(mc->state == qman_mc_idle);
 843         mc->state = qman_mc_user;
 844 #endif
 845         dcbz_64(mc->cr);
 846         return mc->cr;
 847 }
 848
 849 static inline void qm_mc_commit(struct qm_portal *portal, u8 myverb)
 850 {
 851         register struct qm_mc *mc = &portal->mc;
 852         struct qm_mc_result *rr = mc->rr + mc->rridx;
 853
 854 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 855         DPAA_ASSERT(mc->state == qman_mc_user);
 856 #endif
 857         lwsync();
 858         mc->cr->__dont_write_directly__verb = myverb | mc->vbit;
 859         dcbf(mc->cr);
 860         dcbit_ro(rr);
 861 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 862         mc->state = qman_mc_hw;
 863 #endif
 864 }
 865
 866 static inline struct qm_mc_result *qm_mc_result(struct qm_portal *portal)
 867 {
 868         register struct qm_mc *mc = &portal->mc;
 869         struct qm_mc_result *rr = mc->rr + mc->rridx;
 870
 871 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 872         DPAA_ASSERT(mc->state == qman_mc_hw);
 873 #endif
 874         /* The inactive response register's verb byte always returns zero until
 875          * its command is submitted and completed. This includes the valid-bit,
 876          * in case you were wondering.
 877          */
 878         if (!__raw_readb(&rr->verb)) {
 879                 dcbit_ro(rr);
 880                 return NULL;
 881         }
 882         mc->rridx ^= 1;
 883         mc->vbit ^= QM_MCC_VERB_VBIT;
 884 #ifdef RTE_LIBRTE_DPAA_HWDEBUG
 885         mc->state = qman_mc_idle;
 886 #endif
 887         return rr;
 888 }
 889
 890 /* Portal interrupt register API */
 891 static inline void qm_isr_set_iperiod(struct qm_portal *portal, u16 iperiod)
 892 {
 893         qm_out(ITPR, iperiod);
 894 }
 895
 896 static inline u32 __qm_isr_read(struct qm_portal *portal, enum qm_isr_reg n)
 897 {
 898 #if defined(RTE_ARCH_ARM64)
 899         return __qm_in(&portal->addr, QM_REG_ISR + (n << 6));
 900 #else
 901         return __qm_in(&portal->addr, QM_REG_ISR + (n << 2));
 902 #endif
 903 }
 904
 905 static inline void __qm_isr_write(struct qm_portal *portal, enum qm_isr_reg n,
 906                                   u32 val)
 907 {
 908 #if defined(RTE_ARCH_ARM64)
 909         __qm_out(&portal->addr, QM_REG_ISR + (n << 6), val);
 910 #else
 911         __qm_out(&portal->addr, QM_REG_ISR + (n << 2), val);
 912 #endif
 913 }