source: rtems-libbsd/linux/drivers/soc/fsl/qbman/qman.c @ de5791b

55-freebsd-126-freebsd-12
Last change on this file since de5791b was de5791b, checked in by Sebastian Huber <sebastian.huber@…>, on Jul 13, 2017 at 6:31:46 AM

dpaa: Add "libbsd,dedicated-portal" to QMan portals

By default, the network interfaces use a pool channel, see
dpaa_get_channel() in dpaa_eth_priv_probe(). To enable a dedicated QMan
software portal, use libbsd,dedicated-portal = "enabled";. This option
is useful for special purpose 10Gbit/s Ethernet processing.

/ {

soc: soc@ffe000000 {

fman0: fman@400000 {

enet7: ethernet@f2000 {

libbsd,dedicated-portal = "enabled";

};

};

};

};

  • Property mode set to 100644
File size: 77.0 KB
Line 
1#include <machine/rtems-bsd-kernel-space.h>
2
3#include <rtems/bsd/local/opt_dpaa.h>
4
5/* Copyright 2008 - 2016 Freescale Semiconductor, Inc.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are met:
9 *     * Redistributions of source code must retain the above copyright
10 *       notice, this list of conditions and the following disclaimer.
11 *     * Redistributions in binary form must reproduce the above copyright
12 *       notice, this list of conditions and the following disclaimer in the
13 *       documentation and/or other materials provided with the distribution.
14 *     * Neither the name of Freescale Semiconductor nor the
15 *       names of its contributors may be used to endorse or promote products
16 *       derived from this software without specific prior written permission.
17 *
18 * ALTERNATIVELY, this software may be distributed under the terms of the
19 * GNU General Public License ("GPL") as published by the Free Software
20 * Foundation, either version 2 of that License or (at your option) any
21 * later version.
22 *
23 * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY
24 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
27 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
30 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 */
34
35#include "qman_priv.h"
36#ifdef __rtems__
37#undef dev_crit
38#undef dev_dbg
39#undef dev_err
40#define dev_crit(dev, fmt, ...) printf(fmt, ##__VA_ARGS__)
41#define dev_dbg dev_crit
42#define dev_err dev_crit
43#endif /* __rtems__ */
44
45#define DQRR_MAXFILL    15
46#define EQCR_ITHRESH    4       /* if EQCR congests, interrupt threshold */
47#define IRQNAME         "QMan portal %d"
48#define MAX_IRQNAME     16      /* big enough for "QMan portal %d" */
49#define QMAN_POLL_LIMIT 32
50#define QMAN_PIRQ_DQRR_ITHRESH 12
51#define QMAN_PIRQ_MR_ITHRESH 4
52#define QMAN_PIRQ_IPERIOD 100
53
54/* Portal register assists */
55
56/* Cache-inhibited register offsets */
57#define QM_REG_EQCR_PI_CINH     0x0000
58#define QM_REG_EQCR_CI_CINH     0x0004
59#define QM_REG_EQCR_ITR         0x0008
60#define QM_REG_DQRR_PI_CINH     0x0040
61#define QM_REG_DQRR_CI_CINH     0x0044
62#define QM_REG_DQRR_ITR         0x0048
63#define QM_REG_DQRR_DCAP        0x0050
64#define QM_REG_DQRR_SDQCR       0x0054
65#define QM_REG_DQRR_VDQCR       0x0058
66#define QM_REG_DQRR_PDQCR       0x005c
67#define QM_REG_MR_PI_CINH       0x0080
68#define QM_REG_MR_CI_CINH       0x0084
69#define QM_REG_MR_ITR           0x0088
70#define QM_REG_CFG              0x0100
71#define QM_REG_ISR              0x0e00
72#define QM_REG_IER              0x0e04
73#define QM_REG_ISDR             0x0e08
74#define QM_REG_IIR              0x0e0c
75#define QM_REG_ITPR             0x0e14
76
77/* Cache-enabled register offsets */
78#define QM_CL_EQCR              0x0000
79#define QM_CL_DQRR              0x1000
80#define QM_CL_MR                0x2000
81#define QM_CL_EQCR_PI_CENA      0x3000
82#define QM_CL_EQCR_CI_CENA      0x3100
83#define QM_CL_DQRR_PI_CENA      0x3200
84#define QM_CL_DQRR_CI_CENA      0x3300
85#define QM_CL_MR_PI_CENA        0x3400
86#define QM_CL_MR_CI_CENA        0x3500
87#define QM_CL_CR                0x3800
88#define QM_CL_RR0               0x3900
89#define QM_CL_RR1               0x3940
90
91/*
92 * BTW, the drivers (and h/w programming model) already obtain the required
93 * synchronisation for portal accesses and data-dependencies. Use of barrier()s
94 * or other order-preserving primitives simply degrade performance. Hence the
95 * use of the __raw_*() interfaces, which simply ensure that the compiler treats
96 * the portal registers as volatile
97 */
98
99/* Cache-enabled ring access */
100#define qm_cl(base, idx)        ((void *)base + ((idx) << 6))
101
102/*
103 * Portal modes.
104 *   Enum types;
105 *     pmode == production mode
106 *     cmode == consumption mode,
107 *     dmode == h/w dequeue mode.
108 *   Enum values use 3 letter codes. First letter matches the portal mode,
109 *   remaining two letters indicate;
110 *     ci == cache-inhibited portal register
111 *     ce == cache-enabled portal register
112 *     vb == in-band valid-bit (cache-enabled)
113 *     dc == DCA (Discrete Consumption Acknowledgment), DQRR-only
114 *   As for "enum qm_dqrr_dmode", it should be self-explanatory.
115 */
116enum qm_eqcr_pmode {            /* matches QCSP_CFG::EPM */
117        qm_eqcr_pci = 0,        /* PI index, cache-inhibited */
118        qm_eqcr_pce = 1,        /* PI index, cache-enabled */
119        qm_eqcr_pvb = 2         /* valid-bit */
120};
121enum qm_dqrr_dmode {            /* matches QCSP_CFG::DP */
122        qm_dqrr_dpush = 0,      /* SDQCR  + VDQCR */
123        qm_dqrr_dpull = 1       /* PDQCR */
124};
125enum qm_dqrr_pmode {            /* s/w-only */
126        qm_dqrr_pci,            /* reads DQRR_PI_CINH */
127        qm_dqrr_pce,            /* reads DQRR_PI_CENA */
128        qm_dqrr_pvb             /* reads valid-bit */
129};
130enum qm_dqrr_cmode {            /* matches QCSP_CFG::DCM */
131        qm_dqrr_cci = 0,        /* CI index, cache-inhibited */
132        qm_dqrr_cce = 1,        /* CI index, cache-enabled */
133        qm_dqrr_cdc = 2         /* Discrete Consumption Acknowledgment */
134};
135enum qm_mr_pmode {              /* s/w-only */
136        qm_mr_pci,              /* reads MR_PI_CINH */
137        qm_mr_pce,              /* reads MR_PI_CENA */
138        qm_mr_pvb               /* reads valid-bit */
139};
140enum qm_mr_cmode {              /* matches QCSP_CFG::MM */
141        qm_mr_cci = 0,          /* CI index, cache-inhibited */
142        qm_mr_cce = 1           /* CI index, cache-enabled */
143};
144
145/* --- Portal structures --- */
146
147#define QM_EQCR_SIZE            8
148#define QM_DQRR_SIZE            16
149#define QM_MR_SIZE              8
150
151/* "Enqueue Command" */
152struct qm_eqcr_entry {
153        u8 _ncw_verb; /* writes to this are non-coherent */
154        u8 dca;
155        __be16 seqnum;
156        u8 __reserved[4];
157        __be32 fqid;    /* 24-bit */
158        __be32 tag;
159        struct qm_fd fd;
160        u8 __reserved3[32];
161} __packed;
162#define QM_EQCR_VERB_VBIT               0x80
163#define QM_EQCR_VERB_CMD_MASK           0x61    /* but only one value; */
164#define QM_EQCR_VERB_CMD_ENQUEUE        0x01
165#define QM_EQCR_SEQNUM_NESN             0x8000  /* Advance NESN */
166#define QM_EQCR_SEQNUM_NLIS             0x4000  /* More fragments to come */
167#define QM_EQCR_SEQNUM_SEQMASK          0x3fff  /* sequence number goes here */
168
169struct qm_eqcr {
170        struct qm_eqcr_entry *ring, *cursor;
171        u8 ci, available, ithresh, vbit;
172#ifdef CONFIG_FSL_DPAA_CHECKING
173        u32 busy;
174        enum qm_eqcr_pmode pmode;
175#endif
176};
177
178struct qm_dqrr {
179        const struct qm_dqrr_entry *ring, *cursor;
180        u8 pi, ci, fill, ithresh, vbit;
181#ifdef CONFIG_FSL_DPAA_CHECKING
182        enum qm_dqrr_dmode dmode;
183        enum qm_dqrr_pmode pmode;
184        enum qm_dqrr_cmode cmode;
185#endif
186};
187
188struct qm_mr {
189        union qm_mr_entry *ring, *cursor;
190        u8 pi, ci, fill, ithresh, vbit;
191#ifdef CONFIG_FSL_DPAA_CHECKING
192        enum qm_mr_pmode pmode;
193        enum qm_mr_cmode cmode;
194#endif
195};
196
197/* MC (Management Command) command */
198/* "FQ" command layout */
199struct qm_mcc_fq {
200        u8 _ncw_verb;
201        u8 __reserved1[3];
202        __be32 fqid;    /* 24-bit */
203        u8 __reserved2[56];
204} __packed;
205
206/* "CGR" command layout */
207struct qm_mcc_cgr {
208        u8 _ncw_verb;
209        u8 __reserved1[30];
210        u8 cgid;
211        u8 __reserved2[32];
212};
213
214#define QM_MCC_VERB_VBIT                0x80
215#define QM_MCC_VERB_MASK                0x7f    /* where the verb contains; */
216#define QM_MCC_VERB_INITFQ_PARKED       0x40
217#define QM_MCC_VERB_INITFQ_SCHED        0x41
218#define QM_MCC_VERB_QUERYFQ             0x44
219#define QM_MCC_VERB_QUERYFQ_NP          0x45    /* "non-programmable" fields */
220#define QM_MCC_VERB_QUERYWQ             0x46
221#define QM_MCC_VERB_QUERYWQ_DEDICATED   0x47
222#define QM_MCC_VERB_ALTER_SCHED         0x48    /* Schedule FQ */
223#define QM_MCC_VERB_ALTER_FE            0x49    /* Force Eligible FQ */
224#define QM_MCC_VERB_ALTER_RETIRE        0x4a    /* Retire FQ */
225#define QM_MCC_VERB_ALTER_OOS           0x4b    /* Take FQ out of service */
226#define QM_MCC_VERB_ALTER_FQXON         0x4d    /* FQ XON */
227#define QM_MCC_VERB_ALTER_FQXOFF        0x4e    /* FQ XOFF */
228#define QM_MCC_VERB_INITCGR             0x50
229#define QM_MCC_VERB_MODIFYCGR           0x51
230#define QM_MCC_VERB_CGRTESTWRITE        0x52
231#define QM_MCC_VERB_QUERYCGR            0x58
232#define QM_MCC_VERB_QUERYCONGESTION     0x59
233union qm_mc_command {
234        struct {
235                u8 _ncw_verb; /* writes to this are non-coherent */
236                u8 __reserved[63];
237        };
238        struct qm_mcc_initfq initfq;
239        struct qm_mcc_initcgr initcgr;
240        struct qm_mcc_fq fq;
241        struct qm_mcc_cgr cgr;
242};
243
244/* MC (Management Command) result */
245/* "Query FQ" */
246struct qm_mcr_queryfq {
247        u8 verb;
248        u8 result;
249        u8 __reserved1[8];
250        struct qm_fqd fqd;      /* the FQD fields are here */
251        u8 __reserved2[30];
252} __packed;
253
254/* "Alter FQ State Commands" */
255struct qm_mcr_alterfq {
256        u8 verb;
257        u8 result;
258        u8 fqs;         /* Frame Queue Status */
259        u8 __reserved1[61];
260};
261#define QM_MCR_VERB_RRID                0x80
262#define QM_MCR_VERB_MASK                QM_MCC_VERB_MASK
263#define QM_MCR_VERB_INITFQ_PARKED       QM_MCC_VERB_INITFQ_PARKED
264#define QM_MCR_VERB_INITFQ_SCHED        QM_MCC_VERB_INITFQ_SCHED
265#define QM_MCR_VERB_QUERYFQ             QM_MCC_VERB_QUERYFQ
266#define QM_MCR_VERB_QUERYFQ_NP          QM_MCC_VERB_QUERYFQ_NP
267#define QM_MCR_VERB_QUERYWQ             QM_MCC_VERB_QUERYWQ
268#define QM_MCR_VERB_QUERYWQ_DEDICATED   QM_MCC_VERB_QUERYWQ_DEDICATED
269#define QM_MCR_VERB_ALTER_SCHED         QM_MCC_VERB_ALTER_SCHED
270#define QM_MCR_VERB_ALTER_FE            QM_MCC_VERB_ALTER_FE
271#define QM_MCR_VERB_ALTER_RETIRE        QM_MCC_VERB_ALTER_RETIRE
272#define QM_MCR_VERB_ALTER_OOS           QM_MCC_VERB_ALTER_OOS
273#define QM_MCR_RESULT_NULL              0x00
274#define QM_MCR_RESULT_OK                0xf0
275#define QM_MCR_RESULT_ERR_FQID          0xf1
276#define QM_MCR_RESULT_ERR_FQSTATE       0xf2
277#define QM_MCR_RESULT_ERR_NOTEMPTY      0xf3    /* OOS fails if FQ is !empty */
278#define QM_MCR_RESULT_ERR_BADCHANNEL    0xf4
279#define QM_MCR_RESULT_PENDING           0xf8
280#define QM_MCR_RESULT_ERR_BADCOMMAND    0xff
281#define QM_MCR_FQS_ORLPRESENT           0x02    /* ORL fragments to come */
282#define QM_MCR_FQS_NOTEMPTY             0x01    /* FQ has enqueued frames */
283#define QM_MCR_TIMEOUT                  10000   /* us */
284union qm_mc_result {
285        struct {
286                u8 verb;
287                u8 result;
288                u8 __reserved1[62];
289        };
290        struct qm_mcr_queryfq queryfq;
291        struct qm_mcr_alterfq alterfq;
292        struct qm_mcr_querycgr querycgr;
293        struct qm_mcr_querycongestion querycongestion;
294        struct qm_mcr_querywq querywq;
295        struct qm_mcr_queryfq_np queryfq_np;
296};
297
298struct qm_mc {
299        union qm_mc_command *cr;
300        union qm_mc_result *rr;
301        u8 rridx, vbit;
302#ifdef CONFIG_FSL_DPAA_CHECKING
303        enum {
304                /* Can be _mc_start()ed */
305                qman_mc_idle,
306                /* Can be _mc_commit()ed or _mc_abort()ed */
307                qman_mc_user,
308                /* Can only be _mc_retry()ed */
309                qman_mc_hw
310        } state;
311#endif
312};
313
314struct qm_addr {
315        void __iomem *ce;       /* cache-enabled */
316        void __iomem *ci;       /* cache-inhibited */
317};
318
319struct qm_portal {
320        /*
321         * In the non-CONFIG_FSL_DPAA_CHECKING case, the following stuff up to
322         * and including 'mc' fits within a cacheline (yay!). The 'config' part
323         * is setup-only, so isn't a cause for a concern. In other words, don't
324         * rearrange this structure on a whim, there be dragons ...
325         */
326        struct qm_addr addr;
327        struct qm_eqcr eqcr;
328        struct qm_dqrr dqrr;
329        struct qm_mr mr;
330        struct qm_mc mc;
331} ____cacheline_aligned;
332
333/* Cache-inhibited register access. */
334static inline u32 qm_in(struct qm_portal *p, u32 offset)
335{
336        return be32_to_cpu(__raw_readl(p->addr.ci + offset));
337}
338
339static inline void qm_out(struct qm_portal *p, u32 offset, u32 val)
340{
341        __raw_writel(cpu_to_be32(val), p->addr.ci + offset);
342}
343
344/* Cache Enabled Portal Access */
345static inline void qm_cl_invalidate(struct qm_portal *p, u32 offset)
346{
347        dpaa_invalidate(p->addr.ce + offset);
348}
349
350static inline void qm_cl_touch_ro(struct qm_portal *p, u32 offset)
351{
352        dpaa_touch_ro(p->addr.ce + offset);
353}
354
355static inline u32 qm_ce_in(struct qm_portal *p, u32 offset)
356{
357        return be32_to_cpu(__raw_readl(p->addr.ce + offset));
358}
359
360/* --- EQCR API --- */
361
362#define EQCR_SHIFT      ilog2(sizeof(struct qm_eqcr_entry))
363#define EQCR_CARRY      (uintptr_t)(QM_EQCR_SIZE << EQCR_SHIFT)
364
365/* Bit-wise logic to wrap a ring pointer by clearing the "carry bit" */
366static struct qm_eqcr_entry *eqcr_carryclear(struct qm_eqcr_entry *p)
367{
368        uintptr_t addr = (uintptr_t)p;
369
370        addr &= ~EQCR_CARRY;
371
372        return (struct qm_eqcr_entry *)addr;
373}
374
375/* Bit-wise logic to convert a ring pointer to a ring index */
376static int eqcr_ptr2idx(struct qm_eqcr_entry *e)
377{
378        return ((uintptr_t)e >> EQCR_SHIFT) & (QM_EQCR_SIZE - 1);
379}
380
381/* Increment the 'cursor' ring pointer, taking 'vbit' into account */
382static inline void eqcr_inc(struct qm_eqcr *eqcr)
383{
384        /* increment to the next EQCR pointer and handle overflow and 'vbit' */
385        struct qm_eqcr_entry *partial = eqcr->cursor + 1;
386
387        eqcr->cursor = eqcr_carryclear(partial);
388        if (partial != eqcr->cursor)
389                eqcr->vbit ^= QM_EQCR_VERB_VBIT;
390}
391
392static inline int qm_eqcr_init(struct qm_portal *portal,
393                                enum qm_eqcr_pmode pmode,
394                                unsigned int eq_stash_thresh,
395                                int eq_stash_prio)
396{
397        struct qm_eqcr *eqcr = &portal->eqcr;
398        u32 cfg;
399        u8 pi;
400
401        eqcr->ring = portal->addr.ce + QM_CL_EQCR;
402        eqcr->ci = qm_in(portal, QM_REG_EQCR_CI_CINH) & (QM_EQCR_SIZE - 1);
403        qm_cl_invalidate(portal, QM_CL_EQCR_CI_CENA);
404        pi = qm_in(portal, QM_REG_EQCR_PI_CINH) & (QM_EQCR_SIZE - 1);
405        eqcr->cursor = eqcr->ring + pi;
406        eqcr->vbit = (qm_in(portal, QM_REG_EQCR_PI_CINH) & QM_EQCR_SIZE) ?
407                     QM_EQCR_VERB_VBIT : 0;
408        eqcr->available = QM_EQCR_SIZE - 1 -
409                          dpaa_cyc_diff(QM_EQCR_SIZE, eqcr->ci, pi);
410        eqcr->ithresh = qm_in(portal, QM_REG_EQCR_ITR);
411#ifdef CONFIG_FSL_DPAA_CHECKING
412        eqcr->busy = 0;
413        eqcr->pmode = pmode;
414#endif
415        cfg = (qm_in(portal, QM_REG_CFG) & 0x00ffffff) |
416              (eq_stash_thresh << 28) | /* QCSP_CFG: EST */
417              (eq_stash_prio << 26) | /* QCSP_CFG: EP */
418              ((pmode & 0x3) << 24); /* QCSP_CFG::EPM */
419        qm_out(portal, QM_REG_CFG, cfg);
420        return 0;
421}
422
423static inline unsigned int qm_eqcr_get_ci_stashing(struct qm_portal *portal)
424{
425        return (qm_in(portal, QM_REG_CFG) >> 28) & 0x7;
426}
427
428static inline void qm_eqcr_finish(struct qm_portal *portal)
429{
430        struct qm_eqcr *eqcr = &portal->eqcr;
431        u8 pi = qm_in(portal, QM_REG_EQCR_PI_CINH) & (QM_EQCR_SIZE - 1);
432        u8 ci = qm_in(portal, QM_REG_EQCR_CI_CINH) & (QM_EQCR_SIZE - 1);
433
434        DPAA_ASSERT(!eqcr->busy);
435        if (pi != eqcr_ptr2idx(eqcr->cursor))
436                pr_crit("losing uncommitted EQCR entries\n");
437        if (ci != eqcr->ci)
438                pr_crit("missing existing EQCR completions\n");
439        if (eqcr->ci != eqcr_ptr2idx(eqcr->cursor))
440                pr_crit("EQCR destroyed unquiesced\n");
441}
442
443static inline struct qm_eqcr_entry *qm_eqcr_start_no_stash(struct qm_portal
444                                                                 *portal)
445{
446        struct qm_eqcr *eqcr = &portal->eqcr;
447
448        DPAA_ASSERT(!eqcr->busy);
449        if (!eqcr->available)
450                return NULL;
451
452#ifdef CONFIG_FSL_DPAA_CHECKING
453        eqcr->busy = 1;
454#endif
455        dpaa_zero(eqcr->cursor);
456        return eqcr->cursor;
457}
458
459static inline struct qm_eqcr_entry *qm_eqcr_start_stash(struct qm_portal
460                                                                *portal)
461{
462        struct qm_eqcr *eqcr = &portal->eqcr;
463        u8 diff, old_ci;
464
465        DPAA_ASSERT(!eqcr->busy);
466        if (!eqcr->available) {
467                old_ci = eqcr->ci;
468                eqcr->ci = qm_ce_in(portal, QM_CL_EQCR_CI_CENA) &
469                           (QM_EQCR_SIZE - 1);
470                diff = dpaa_cyc_diff(QM_EQCR_SIZE, old_ci, eqcr->ci);
471                eqcr->available += diff;
472                if (!diff)
473                        return NULL;
474        }
475#ifdef CONFIG_FSL_DPAA_CHECKING
476        eqcr->busy = 1;
477#endif
478        dpaa_zero(eqcr->cursor);
479        return eqcr->cursor;
480}
481
482static inline void eqcr_commit_checks(struct qm_eqcr *eqcr)
483{
484        DPAA_ASSERT(eqcr->busy);
485        DPAA_ASSERT(!(be32_to_cpu(eqcr->cursor->fqid) & ~QM_FQID_MASK));
486        DPAA_ASSERT(eqcr->available >= 1);
487}
488
489static inline void qm_eqcr_pvb_commit(struct qm_portal *portal, u8 myverb)
490{
491        struct qm_eqcr *eqcr = &portal->eqcr;
492        struct qm_eqcr_entry *eqcursor;
493
494        eqcr_commit_checks(eqcr);
495        DPAA_ASSERT(eqcr->pmode == qm_eqcr_pvb);
496        dma_wmb();
497        eqcursor = eqcr->cursor;
498        eqcursor->_ncw_verb = myverb | eqcr->vbit;
499        dpaa_flush(eqcursor);
500        eqcr_inc(eqcr);
501        eqcr->available--;
502#ifdef CONFIG_FSL_DPAA_CHECKING
503        eqcr->busy = 0;
504#endif
505}
506
507static inline void qm_eqcr_cce_prefetch(struct qm_portal *portal)
508{
509        qm_cl_touch_ro(portal, QM_CL_EQCR_CI_CENA);
510}
511
512static inline u8 qm_eqcr_cce_update(struct qm_portal *portal)
513{
514        struct qm_eqcr *eqcr = &portal->eqcr;
515        u8 diff, old_ci = eqcr->ci;
516
517        eqcr->ci = qm_ce_in(portal, QM_CL_EQCR_CI_CENA) & (QM_EQCR_SIZE - 1);
518        qm_cl_invalidate(portal, QM_CL_EQCR_CI_CENA);
519        diff = dpaa_cyc_diff(QM_EQCR_SIZE, old_ci, eqcr->ci);
520        eqcr->available += diff;
521        return diff;
522}
523
524static inline void qm_eqcr_set_ithresh(struct qm_portal *portal, u8 ithresh)
525{
526        struct qm_eqcr *eqcr = &portal->eqcr;
527
528        eqcr->ithresh = ithresh;
529        qm_out(portal, QM_REG_EQCR_ITR, ithresh);
530}
531
532static inline u8 qm_eqcr_get_avail(struct qm_portal *portal)
533{
534        struct qm_eqcr *eqcr = &portal->eqcr;
535
536        return eqcr->available;
537}
538
539static inline u8 qm_eqcr_get_fill(struct qm_portal *portal)
540{
541        struct qm_eqcr *eqcr = &portal->eqcr;
542
543        return QM_EQCR_SIZE - 1 - eqcr->available;
544}
545
546/* --- DQRR API --- */
547
548#define DQRR_SHIFT      ilog2(sizeof(struct qm_dqrr_entry))
549#define DQRR_CARRY      (uintptr_t)(QM_DQRR_SIZE << DQRR_SHIFT)
550
551static const struct qm_dqrr_entry *dqrr_carryclear(
552                                        const struct qm_dqrr_entry *p)
553{
554        uintptr_t addr = (uintptr_t)p;
555
556        addr &= ~DQRR_CARRY;
557
558        return (const struct qm_dqrr_entry *)addr;
559}
560
561static inline int dqrr_ptr2idx(const struct qm_dqrr_entry *e)
562{
563        return ((uintptr_t)e >> DQRR_SHIFT) & (QM_DQRR_SIZE - 1);
564}
565
566static const struct qm_dqrr_entry *dqrr_inc(const struct qm_dqrr_entry *e)
567{
568        return dqrr_carryclear(e + 1);
569}
570
571static inline void qm_dqrr_set_maxfill(struct qm_portal *portal, u8 mf)
572{
573        qm_out(portal, QM_REG_CFG, (qm_in(portal, QM_REG_CFG) & 0xff0fffff) |
574                                   ((mf & (QM_DQRR_SIZE - 1)) << 20));
575}
576
577static inline int qm_dqrr_init(struct qm_portal *portal,
578                               const struct qm_portal_config *config,
579                               enum qm_dqrr_dmode dmode,
580                               enum qm_dqrr_pmode pmode,
581                               enum qm_dqrr_cmode cmode, u8 max_fill)
582{
583        struct qm_dqrr *dqrr = &portal->dqrr;
584        u32 cfg;
585
586        /* Make sure the DQRR will be idle when we enable */
587        qm_out(portal, QM_REG_DQRR_SDQCR, 0);
588        qm_out(portal, QM_REG_DQRR_VDQCR, 0);
589        qm_out(portal, QM_REG_DQRR_PDQCR, 0);
590        dqrr->ring = portal->addr.ce + QM_CL_DQRR;
591        dqrr->pi = qm_in(portal, QM_REG_DQRR_PI_CINH) & (QM_DQRR_SIZE - 1);
592        dqrr->ci = qm_in(portal, QM_REG_DQRR_CI_CINH) & (QM_DQRR_SIZE - 1);
593        dqrr->cursor = dqrr->ring + dqrr->ci;
594        dqrr->fill = dpaa_cyc_diff(QM_DQRR_SIZE, dqrr->ci, dqrr->pi);
595        dqrr->vbit = (qm_in(portal, QM_REG_DQRR_PI_CINH) & QM_DQRR_SIZE) ?
596                        QM_DQRR_VERB_VBIT : 0;
597        dqrr->ithresh = qm_in(portal, QM_REG_DQRR_ITR);
598#ifdef CONFIG_FSL_DPAA_CHECKING
599        dqrr->dmode = dmode;
600        dqrr->pmode = pmode;
601        dqrr->cmode = cmode;
602#endif
603        /* Invalidate every ring entry before beginning */
604        for (cfg = 0; cfg < QM_DQRR_SIZE; cfg++)
605                dpaa_invalidate(qm_cl(dqrr->ring, cfg));
606        cfg = (qm_in(portal, QM_REG_CFG) & 0xff000f00) |
607                ((max_fill & (QM_DQRR_SIZE - 1)) << 20) | /* DQRR_MF */
608                ((dmode & 1) << 18) |                   /* DP */
609                ((cmode & 3) << 16) |                   /* DCM */
610#ifndef CONFIG_FSL_PAMU
611                0xa0 |                                  /* RE+SE */
612#endif
613                (0 ? 0x40 : 0) |                        /* Ignore RP */
614                (0 ? 0x10 : 0);                         /* Ignore SP */
615        qm_out(portal, QM_REG_CFG, cfg);
616        qm_dqrr_set_maxfill(portal, max_fill);
617        return 0;
618}
619
620static inline void qm_dqrr_finish(struct qm_portal *portal)
621{
622#ifdef CONFIG_FSL_DPAA_CHECKING
623        struct qm_dqrr *dqrr = &portal->dqrr;
624
625        if (dqrr->cmode != qm_dqrr_cdc &&
626            dqrr->ci != dqrr_ptr2idx(dqrr->cursor))
627                pr_crit("Ignoring completed DQRR entries\n");
628#endif
629}
630
631static inline const struct qm_dqrr_entry *qm_dqrr_current(
632                                                struct qm_portal *portal)
633{
634        struct qm_dqrr *dqrr = &portal->dqrr;
635
636        if (!dqrr->fill)
637                return NULL;
638        return dqrr->cursor;
639}
640
641static inline u8 qm_dqrr_next(struct qm_portal *portal)
642{
643        struct qm_dqrr *dqrr = &portal->dqrr;
644
645        DPAA_ASSERT(dqrr->fill);
646        dqrr->cursor = dqrr_inc(dqrr->cursor);
647        return --dqrr->fill;
648}
649
650static inline void qm_dqrr_pvb_update(struct qm_portal *portal)
651{
652        struct qm_dqrr *dqrr = &portal->dqrr;
653        struct qm_dqrr_entry *res = qm_cl(dqrr->ring, dqrr->pi);
654
655        DPAA_ASSERT(dqrr->pmode == qm_dqrr_pvb);
656#ifndef CONFIG_FSL_PAMU
657        /*
658         * If PAMU is not available we need to invalidate the cache.
659         * When PAMU is available the cache is updated by stash
660         */
661        dpaa_invalidate_touch_ro(res);
662#endif
663        /*
664         *  when accessing 'verb', use __raw_readb() to ensure that compiler
665         * inlining doesn't try to optimise out "excess reads".
666         */
667        if ((__raw_readb(&res->verb) & QM_DQRR_VERB_VBIT) == dqrr->vbit) {
668                dqrr->pi = (dqrr->pi + 1) & (QM_DQRR_SIZE - 1);
669                if (!dqrr->pi)
670                        dqrr->vbit ^= QM_DQRR_VERB_VBIT;
671                dqrr->fill++;
672        }
673}
674
675static inline void qm_dqrr_cdc_consume_1ptr(struct qm_portal *portal,
676                                        const struct qm_dqrr_entry *dq,
677                                        int park)
678{
679        __maybe_unused struct qm_dqrr *dqrr = &portal->dqrr;
680        int idx = dqrr_ptr2idx(dq);
681
682        DPAA_ASSERT(dqrr->cmode == qm_dqrr_cdc);
683        DPAA_ASSERT((dqrr->ring + idx) == dq);
684        DPAA_ASSERT(idx < QM_DQRR_SIZE);
685        qm_out(portal, QM_REG_DQRR_DCAP, (0 << 8) | /* DQRR_DCAP::S */
686               ((park ? 1 : 0) << 6) |              /* DQRR_DCAP::PK */
687               idx);                                /* DQRR_DCAP::DCAP_CI */
688}
689
690static inline void qm_dqrr_cdc_consume_n(struct qm_portal *portal, u32 bitmask)
691{
692        __maybe_unused struct qm_dqrr *dqrr = &portal->dqrr;
693
694        DPAA_ASSERT(dqrr->cmode == qm_dqrr_cdc);
695        qm_out(portal, QM_REG_DQRR_DCAP, (1 << 8) | /* DQRR_DCAP::S */
696               (bitmask << 16));                    /* DQRR_DCAP::DCAP_CI */
697}
698
699static inline void qm_dqrr_sdqcr_set(struct qm_portal *portal, u32 sdqcr)
700{
701        qm_out(portal, QM_REG_DQRR_SDQCR, sdqcr);
702}
703
704static inline void qm_dqrr_vdqcr_set(struct qm_portal *portal, u32 vdqcr)
705{
706        qm_out(portal, QM_REG_DQRR_VDQCR, vdqcr);
707}
708
709static inline void qm_dqrr_set_ithresh(struct qm_portal *portal, u8 ithresh)
710{
711        qm_out(portal, QM_REG_DQRR_ITR, ithresh);
712}
713
714/* --- MR API --- */
715
716#define MR_SHIFT        ilog2(sizeof(union qm_mr_entry))
717#define MR_CARRY        (uintptr_t)(QM_MR_SIZE << MR_SHIFT)
718
719static union qm_mr_entry *mr_carryclear(union qm_mr_entry *p)
720{
721        uintptr_t addr = (uintptr_t)p;
722
723        addr &= ~MR_CARRY;
724
725        return (union qm_mr_entry *)addr;
726}
727
728static inline int mr_ptr2idx(const union qm_mr_entry *e)
729{
730        return ((uintptr_t)e >> MR_SHIFT) & (QM_MR_SIZE - 1);
731}
732
733static inline union qm_mr_entry *mr_inc(union qm_mr_entry *e)
734{
735        return mr_carryclear(e + 1);
736}
737
738static inline int qm_mr_init(struct qm_portal *portal, enum qm_mr_pmode pmode,
739                             enum qm_mr_cmode cmode)
740{
741        struct qm_mr *mr = &portal->mr;
742        u32 cfg;
743
744        mr->ring = portal->addr.ce + QM_CL_MR;
745        mr->pi = qm_in(portal, QM_REG_MR_PI_CINH) & (QM_MR_SIZE - 1);
746        mr->ci = qm_in(portal, QM_REG_MR_CI_CINH) & (QM_MR_SIZE - 1);
747        mr->cursor = mr->ring + mr->ci;
748        mr->fill = dpaa_cyc_diff(QM_MR_SIZE, mr->ci, mr->pi);
749        mr->vbit = (qm_in(portal, QM_REG_MR_PI_CINH) & QM_MR_SIZE)
750                ? QM_MR_VERB_VBIT : 0;
751        mr->ithresh = qm_in(portal, QM_REG_MR_ITR);
752#ifdef CONFIG_FSL_DPAA_CHECKING
753        mr->pmode = pmode;
754        mr->cmode = cmode;
755#endif
756        cfg = (qm_in(portal, QM_REG_CFG) & 0xfffff0ff) |
757              ((cmode & 1) << 8);       /* QCSP_CFG:MM */
758        qm_out(portal, QM_REG_CFG, cfg);
759        return 0;
760}
761
762static inline void qm_mr_finish(struct qm_portal *portal)
763{
764        struct qm_mr *mr = &portal->mr;
765
766        if (mr->ci != mr_ptr2idx(mr->cursor))
767                pr_crit("Ignoring completed MR entries\n");
768}
769
770static inline const union qm_mr_entry *qm_mr_current(struct qm_portal *portal)
771{
772        struct qm_mr *mr = &portal->mr;
773
774        if (!mr->fill)
775                return NULL;
776        return mr->cursor;
777}
778
779static inline int qm_mr_next(struct qm_portal *portal)
780{
781        struct qm_mr *mr = &portal->mr;
782
783        DPAA_ASSERT(mr->fill);
784        mr->cursor = mr_inc(mr->cursor);
785        return --mr->fill;
786}
787
788static inline void qm_mr_pvb_update(struct qm_portal *portal)
789{
790        struct qm_mr *mr = &portal->mr;
791        union qm_mr_entry *res = qm_cl(mr->ring, mr->pi);
792
793        DPAA_ASSERT(mr->pmode == qm_mr_pvb);
794        /*
795         *  when accessing 'verb', use __raw_readb() to ensure that compiler
796         * inlining doesn't try to optimise out "excess reads".
797         */
798        if ((__raw_readb(&res->verb) & QM_MR_VERB_VBIT) == mr->vbit) {
799                mr->pi = (mr->pi + 1) & (QM_MR_SIZE - 1);
800                if (!mr->pi)
801                        mr->vbit ^= QM_MR_VERB_VBIT;
802                mr->fill++;
803                res = mr_inc(res);
804        }
805        dpaa_invalidate_touch_ro(res);
806}
807
808static inline void qm_mr_cci_consume(struct qm_portal *portal, u8 num)
809{
810        struct qm_mr *mr = &portal->mr;
811
812        DPAA_ASSERT(mr->cmode == qm_mr_cci);
813        mr->ci = (mr->ci + num) & (QM_MR_SIZE - 1);
814        qm_out(portal, QM_REG_MR_CI_CINH, mr->ci);
815}
816
817static inline void qm_mr_cci_consume_to_current(struct qm_portal *portal)
818{
819        struct qm_mr *mr = &portal->mr;
820
821        DPAA_ASSERT(mr->cmode == qm_mr_cci);
822        mr->ci = mr_ptr2idx(mr->cursor);
823        qm_out(portal, QM_REG_MR_CI_CINH, mr->ci);
824}
825
826static inline void qm_mr_set_ithresh(struct qm_portal *portal, u8 ithresh)
827{
828        qm_out(portal, QM_REG_MR_ITR, ithresh);
829}
830
831/* --- Management command API --- */
832
833static inline int qm_mc_init(struct qm_portal *portal)
834{
835        struct qm_mc *mc = &portal->mc;
836
837        mc->cr = portal->addr.ce + QM_CL_CR;
838        mc->rr = portal->addr.ce + QM_CL_RR0;
839        mc->rridx = (__raw_readb(&mc->cr->_ncw_verb) & QM_MCC_VERB_VBIT)
840                    ? 0 : 1;
841        mc->vbit = mc->rridx ? QM_MCC_VERB_VBIT : 0;
842#ifdef CONFIG_FSL_DPAA_CHECKING
843        mc->state = qman_mc_idle;
844#endif
845        return 0;
846}
847
848static inline void qm_mc_finish(struct qm_portal *portal)
849{
850#ifdef CONFIG_FSL_DPAA_CHECKING
851        struct qm_mc *mc = &portal->mc;
852
853        DPAA_ASSERT(mc->state == qman_mc_idle);
854        if (mc->state != qman_mc_idle)
855                pr_crit("Losing incomplete MC command\n");
856#endif
857}
858
859static inline union qm_mc_command *qm_mc_start(struct qm_portal *portal)
860{
861        struct qm_mc *mc = &portal->mc;
862
863        DPAA_ASSERT(mc->state == qman_mc_idle);
864#ifdef CONFIG_FSL_DPAA_CHECKING
865        mc->state = qman_mc_user;
866#endif
867        dpaa_zero(mc->cr);
868        return mc->cr;
869}
870
871static inline void qm_mc_commit(struct qm_portal *portal, u8 myverb)
872{
873        struct qm_mc *mc = &portal->mc;
874        union qm_mc_result *rr = mc->rr + mc->rridx;
875
876        DPAA_ASSERT(mc->state == qman_mc_user);
877        dma_wmb();
878        mc->cr->_ncw_verb = myverb | mc->vbit;
879        dpaa_flush(mc->cr);
880        dpaa_invalidate_touch_ro(rr);
881#ifdef CONFIG_FSL_DPAA_CHECKING
882        mc->state = qman_mc_hw;
883#endif
884}
885
886static inline union qm_mc_result *qm_mc_result(struct qm_portal *portal)
887{
888        struct qm_mc *mc = &portal->mc;
889        union qm_mc_result *rr = mc->rr + mc->rridx;
890
891        DPAA_ASSERT(mc->state == qman_mc_hw);
892        /*
893         *  The inactive response register's verb byte always returns zero until
894         * its command is submitted and completed. This includes the valid-bit,
895         * in case you were wondering...
896         */
897        if (!__raw_readb(&rr->verb)) {
898                dpaa_invalidate_touch_ro(rr);
899                return NULL;
900        }
901        mc->rridx ^= 1;
902        mc->vbit ^= QM_MCC_VERB_VBIT;
903#ifdef CONFIG_FSL_DPAA_CHECKING
904        mc->state = qman_mc_idle;
905#endif
906        return rr;
907}
908
909static inline int qm_mc_result_timeout(struct qm_portal *portal,
910                                       union qm_mc_result **mcr)
911{
912        int timeout = QM_MCR_TIMEOUT;
913
914        do {
915                *mcr = qm_mc_result(portal);
916                if (*mcr)
917                        break;
918                udelay(1);
919        } while (--timeout);
920
921        return timeout;
922}
923
924static inline void fq_set(struct qman_fq *fq, u32 mask)
925{
926        set_bits(mask, &fq->flags);
927}
928
929static inline void fq_clear(struct qman_fq *fq, u32 mask)
930{
931        clear_bits(mask, &fq->flags);
932}
933
934static inline int fq_isset(struct qman_fq *fq, u32 mask)
935{
936        return fq->flags & mask;
937}
938
939static inline int fq_isclear(struct qman_fq *fq, u32 mask)
940{
941        return !(fq->flags & mask);
942}
943
944struct qman_portal {
945        struct qm_portal p;
946        /* PORTAL_BITS_*** - dynamic, strictly internal */
947        unsigned long bits;
948        /* interrupt sources processed by portal_isr(), configurable */
949        unsigned long irq_sources;
950        u32 use_eqcr_ci_stashing;
951        /* only 1 volatile dequeue at a time */
952        struct qman_fq *vdqcr_owned;
953        u32 sdqcr;
954        /* probing time config params for cpu-affine portals */
955        const struct qm_portal_config *config;
956        /* 2-element array. cgrs[0] is mask, cgrs[1] is snapshot. */
957        struct qman_cgrs *cgrs;
958        /* linked-list of CSCN handlers. */
959        struct list_head cgr_cbs;
960        /* list lock */
961        spinlock_t cgr_lock;
962#ifndef __rtems__
963        struct work_struct congestion_work;
964        struct work_struct mr_work;
965#endif /* __rtems__ */
966        char irqname[MAX_IRQNAME];
967};
968
969#ifndef __rtems__
970static cpumask_t affine_mask;
971static DEFINE_SPINLOCK(affine_mask_lock);
972static u16 affine_channels[NR_CPUS];
973#endif /* __rtems__ */
974static DEFINE_PER_CPU(struct qman_portal, qman_affine_portal);
975struct qman_portal *affine_portals[NR_CPUS];
976
977static inline struct qman_portal *get_affine_portal(void)
978{
979        return &get_cpu_var(qman_affine_portal);
980}
981
982static inline void put_affine_portal(void)
983{
984        put_cpu_var(qman_affine_portal);
985}
986
987#ifndef __rtems__
988static struct workqueue_struct *qm_portal_wq;
989#endif /* __rtems__ */
990
991int qman_wq_alloc(void)
992{
993#ifndef __rtems__
994        qm_portal_wq = alloc_workqueue("qman_portal_wq", 0, 1);
995        if (!qm_portal_wq)
996                return -ENOMEM;
997#endif /* __rtems__ */
998        return 0;
999}
1000
1001/*
1002 * This is what everything can wait on, even if it migrates to a different cpu
1003 * to the one whose affine portal it is waiting on.
1004 */
1005static DECLARE_WAIT_QUEUE_HEAD(affine_queue);
1006
1007static struct qman_fq **fq_table;
1008static u32 num_fqids;
1009
1010int qman_alloc_fq_table(u32 _num_fqids)
1011{
1012        num_fqids = _num_fqids;
1013
1014        fq_table = vzalloc(num_fqids * 2 * sizeof(struct qman_fq *));
1015        if (!fq_table)
1016                return -ENOMEM;
1017
1018        pr_debug("Allocated fq lookup table at %p, entry count %u\n",
1019                 fq_table, num_fqids * 2);
1020        return 0;
1021}
1022
1023static struct qman_fq *idx_to_fq(u32 idx)
1024{
1025        struct qman_fq *fq;
1026
1027#ifdef CONFIG_FSL_DPAA_CHECKING
1028        if (WARN_ON(idx >= num_fqids * 2))
1029                return NULL;
1030#endif
1031        fq = fq_table[idx];
1032        DPAA_ASSERT(!fq || idx == fq->idx);
1033
1034        return fq;
1035}
1036
1037/*
1038 * Only returns full-service fq objects, not enqueue-only
1039 * references (QMAN_FQ_FLAG_NO_MODIFY).
1040 */
1041static struct qman_fq *fqid_to_fq(u32 fqid)
1042{
1043        return idx_to_fq(fqid * 2);
1044}
1045
1046static struct qman_fq *tag_to_fq(u32 tag)
1047{
1048#if BITS_PER_LONG == 64
1049        return idx_to_fq(tag);
1050#else
1051        return (struct qman_fq *)tag;
1052#endif
1053}
1054
1055static u32 fq_to_tag(struct qman_fq *fq)
1056{
1057#if BITS_PER_LONG == 64
1058        return fq->idx;
1059#else
1060        return (u32)fq;
1061#endif
1062}
1063
1064static u32 __poll_portal_slow(struct qman_portal *p, u32 is);
1065static inline unsigned int __poll_portal_fast(struct qman_portal *p,
1066                                        unsigned int poll_limit);
1067#ifndef __rtems__
1068static void qm_congestion_task(struct work_struct *work);
1069static void qm_mr_process_task(struct work_struct *work);
1070#endif /* __rtems__ */
1071
1072static irqreturn_t portal_isr(int irq, void *ptr)
1073{
1074        struct qman_portal *p = ptr;
1075
1076        u32 clear = QM_DQAVAIL_MASK;
1077        u32 is = qm_in(&p->p, QM_REG_ISR) & p->irq_sources;
1078
1079        if (unlikely(!is))
1080                return IRQ_NONE;
1081
1082        /* DQRR-handling if it's interrupt-driven */
1083        if (is & QM_PIRQ_DQRI) {
1084                clear |= QM_PIRQ_DQRI;
1085                __poll_portal_fast(p, QMAN_POLL_LIMIT);
1086        }
1087        /* Handling of anything else that's interrupt-driven */
1088        clear |= __poll_portal_slow(p, is);
1089        qm_out(&p->p, QM_REG_ISR, clear);
1090        return IRQ_HANDLED;
1091}
1092
1093static int drain_mr_fqrni(struct qm_portal *p)
1094{
1095        const union qm_mr_entry *msg;
1096loop:
1097        msg = qm_mr_current(p);
1098        if (!msg) {
1099                /*
1100                 * if MR was full and h/w had other FQRNI entries to produce, we
1101                 * need to allow it time to produce those entries once the
1102                 * existing entries are consumed. A worst-case situation
1103                 * (fully-loaded system) means h/w sequencers may have to do 3-4
1104                 * other things before servicing the portal's MR pump, each of
1105                 * which (if slow) may take ~50 qman cycles (which is ~200
1106                 * processor cycles). So rounding up and then multiplying this
1107                 * worst-case estimate by a factor of 10, just to be
1108                 * ultra-paranoid, goes as high as 10,000 cycles. NB, we consume
1109                 * one entry at a time, so h/w has an opportunity to produce new
1110                 * entries well before the ring has been fully consumed, so
1111                 * we're being *really* paranoid here.
1112                 */
1113                u64 now, then = jiffies;
1114
1115                do {
1116                        now = jiffies;
1117                } while ((then + 10000) > now);
1118                msg = qm_mr_current(p);
1119                if (!msg)
1120                        return 0;
1121        }
1122        if ((msg->verb & QM_MR_VERB_TYPE_MASK) != QM_MR_VERB_FQRNI) {
1123                /* We aren't draining anything but FQRNIs */
1124                pr_err("Found verb 0x%x in MR\n", msg->verb);
1125                return -1;
1126        }
1127        qm_mr_next(p);
1128        qm_mr_cci_consume(p, 1);
1129        goto loop;
1130}
1131
1132static int qman_create_portal(struct qman_portal *portal,
1133                              const struct qm_portal_config *c,
1134                              const struct qman_cgrs *cgrs)
1135{
1136        struct qm_portal *p;
1137        int ret;
1138        u32 isdr;
1139
1140        p = &portal->p;
1141
1142#ifdef CONFIG_FSL_PAMU
1143        /* PAMU is required for stashing */
1144        portal->use_eqcr_ci_stashing = ((qman_ip_rev >= QMAN_REV30) ? 1 : 0);
1145#else
1146        portal->use_eqcr_ci_stashing = 0;
1147#endif
1148        /*
1149         * prep the low-level portal struct with the mapped addresses from the
1150         * config, everything that follows depends on it and "config" is more
1151         * for (de)reference
1152         */
1153        p->addr.ce = c->addr_virt[DPAA_PORTAL_CE];
1154        p->addr.ci = c->addr_virt[DPAA_PORTAL_CI];
1155        /*
1156         * If CI-stashing is used, the current defaults use a threshold of 3,
1157         * and stash with high-than-DQRR priority.
1158         */
1159        if (qm_eqcr_init(p, qm_eqcr_pvb,
1160                        portal->use_eqcr_ci_stashing ? 3 : 0, 1)) {
1161                dev_err(c->dev, "EQCR initialisation failed\n");
1162                goto fail_eqcr;
1163        }
1164        if (qm_dqrr_init(p, c, qm_dqrr_dpush, qm_dqrr_pvb,
1165                        qm_dqrr_cdc, DQRR_MAXFILL)) {
1166                dev_err(c->dev, "DQRR initialisation failed\n");
1167                goto fail_dqrr;
1168        }
1169        if (qm_mr_init(p, qm_mr_pvb, qm_mr_cci)) {
1170                dev_err(c->dev, "MR initialisation failed\n");
1171                goto fail_mr;
1172        }
1173        if (qm_mc_init(p)) {
1174                dev_err(c->dev, "MC initialisation failed\n");
1175                goto fail_mc;
1176        }
1177        /* static interrupt-gating controls */
1178        qm_dqrr_set_ithresh(p, QMAN_PIRQ_DQRR_ITHRESH);
1179        qm_mr_set_ithresh(p, QMAN_PIRQ_MR_ITHRESH);
1180        qm_out(p, QM_REG_ITPR, QMAN_PIRQ_IPERIOD);
1181        portal->cgrs = kmalloc(2 * sizeof(*cgrs), GFP_KERNEL);
1182        if (!portal->cgrs)
1183                goto fail_cgrs;
1184        /* initial snapshot is no-depletion */
1185        qman_cgrs_init(&portal->cgrs[1]);
1186        if (cgrs)
1187                portal->cgrs[0] = *cgrs;
1188        else
1189                /* if the given mask is NULL, assume all CGRs can be seen */
1190                qman_cgrs_fill(&portal->cgrs[0]);
1191        INIT_LIST_HEAD(&portal->cgr_cbs);
1192        spin_lock_init(&portal->cgr_lock);
1193#ifndef __rtems__
1194        INIT_WORK(&portal->congestion_work, qm_congestion_task);
1195        INIT_WORK(&portal->mr_work, qm_mr_process_task);
1196#endif /* __rtems__ */
1197        portal->bits = 0;
1198        portal->sdqcr = QM_SDQCR_SOURCE_CHANNELS | QM_SDQCR_COUNT_UPTO3 |
1199                        QM_SDQCR_DEDICATED_PRECEDENCE | QM_SDQCR_TYPE_PRIO_QOS |
1200                        QM_SDQCR_TOKEN_SET(0xab) | QM_SDQCR_CHANNELS_DEDICATED;
1201        isdr = 0xffffffff;
1202        qm_out(p, QM_REG_ISDR, isdr);
1203        portal->irq_sources = 0;
1204        qm_out(p, QM_REG_IER, 0);
1205        qm_out(p, QM_REG_ISR, 0xffffffff);
1206        snprintf(portal->irqname, MAX_IRQNAME, IRQNAME, c->cpu);
1207        if (request_irq(c->irq, portal_isr, 0, portal->irqname, portal)) {
1208                dev_err(c->dev, "request_irq() failed\n");
1209                goto fail_irq;
1210        }
1211#ifndef __rtems__
1212        if (c->cpu != -1 && irq_can_set_affinity(c->irq) &&
1213            irq_set_affinity(c->irq, cpumask_of(c->cpu))) {
1214                dev_err(c->dev, "irq_set_affinity() failed\n");
1215                goto fail_affinity;
1216        }
1217#else /* __rtems__ */
1218        {
1219                rtems_status_code sc;
1220                cpu_set_t cpu;
1221
1222                sc = rtems_interrupt_server_move(
1223                    RTEMS_INTERRUPT_SERVER_DEFAULT, (uint32_t)c->irq,
1224                    (uint32_t)c->cpu);
1225                BSD_ASSERT(sc == RTEMS_SUCCESSFUL);
1226
1227                CPU_ZERO(&cpu);
1228                CPU_SET(c->cpu, &cpu);
1229                sc = rtems_interrupt_set_affinity((uint32_t)c->irq,
1230                    sizeof(cpu), &cpu);
1231                BSD_ASSERT(sc == RTEMS_SUCCESSFUL);
1232        }
1233#endif /* __rtems__ */
1234
1235        /* Need EQCR to be empty before continuing */
1236        isdr &= ~QM_PIRQ_EQCI;
1237        qm_out(p, QM_REG_ISDR, isdr);
1238        ret = qm_eqcr_get_fill(p);
1239        if (ret) {
1240                dev_err(c->dev, "EQCR unclean\n");
1241                goto fail_eqcr_empty;
1242        }
1243        isdr &= ~(QM_PIRQ_DQRI | QM_PIRQ_MRI);
1244        qm_out(p, QM_REG_ISDR, isdr);
1245        if (qm_dqrr_current(p)) {
1246                dev_err(c->dev, "DQRR unclean\n");
1247                qm_dqrr_cdc_consume_n(p, 0xffff);
1248        }
1249        if (qm_mr_current(p) && drain_mr_fqrni(p)) {
1250                /* special handling, drain just in case it's a few FQRNIs */
1251                const union qm_mr_entry *e = qm_mr_current(p);
1252
1253                dev_err(c->dev, "MR dirty, VB 0x%x, rc 0x%x, addr 0x%llx\n",
1254                        e->verb, e->ern.rc, qm_fd_addr_get64(&e->ern.fd));
1255                goto fail_dqrr_mr_empty;
1256        }
1257        /* Success */
1258        portal->config = c;
1259        qm_out(p, QM_REG_ISDR, 0);
1260        qm_out(p, QM_REG_IIR, 0);
1261        /* Write a sane SDQCR */
1262        qm_dqrr_sdqcr_set(p, portal->sdqcr);
1263        return 0;
1264
1265fail_dqrr_mr_empty:
1266fail_eqcr_empty:
1267#ifndef __rtems__
1268fail_affinity:
1269#endif /* __rtems__ */
1270        free_irq(c->irq, portal);
1271fail_irq:
1272        kfree(portal->cgrs);
1273fail_cgrs:
1274        qm_mc_finish(p);
1275fail_mc:
1276        qm_mr_finish(p);
1277fail_mr:
1278        qm_dqrr_finish(p);
1279fail_dqrr:
1280        qm_eqcr_finish(p);
1281fail_eqcr:
1282        return -EIO;
1283}
1284#ifdef __rtems__
1285int
1286qman_portal_get_channel(const struct qman_portal *portal)
1287{
1288
1289        if (portal == NULL) {
1290                return (-1);
1291        }
1292
1293        return (portal->config->channel);
1294}
1295
1296int
1297qman_portal_get_irq(const struct qman_portal *portal)
1298{
1299
1300        if (portal == NULL) {
1301                return (-1);
1302        }
1303
1304        return (portal->config->irq);
1305}
1306
1307struct qman_portal *
1308qman_create_dedicated_portal(const struct qm_portal_config *c,
1309    const struct qman_cgrs *cgrs)
1310{
1311        struct qman_portal *portal;
1312        int err;
1313
1314        portal = kmalloc(sizeof(*portal), GFP_KERNEL);
1315        if (portal == NULL)
1316                return (NULL);
1317
1318        err = qman_create_portal(portal, c, cgrs);
1319        if (err != 0) {
1320                kfree(portal);
1321                return (NULL);
1322        }
1323
1324        return (portal);
1325}
1326#endif /* __rtems__ */
1327
1328struct qman_portal *qman_create_affine_portal(const struct qm_portal_config *c,
1329                                              const struct qman_cgrs *cgrs)
1330{
1331        struct qman_portal *portal;
1332        int err;
1333
1334        portal = &per_cpu(qman_affine_portal, c->cpu);
1335        err = qman_create_portal(portal, c, cgrs);
1336        if (err)
1337                return NULL;
1338
1339#ifndef __rtems__
1340        spin_lock(&affine_mask_lock);
1341        cpumask_set_cpu(c->cpu, &affine_mask);
1342        affine_channels[c->cpu] = c->channel;
1343#endif /* __rtems__ */
1344        affine_portals[c->cpu] = portal;
1345#ifndef __rtems__
1346        spin_unlock(&affine_mask_lock);
1347#endif /* __rtems__ */
1348
1349        return portal;
1350}
1351
1352static void qman_destroy_portal(struct qman_portal *qm)
1353{
1354        const struct qm_portal_config *pcfg;
1355
1356        /* Stop dequeues on the portal */
1357        qm_dqrr_sdqcr_set(&qm->p, 0);
1358
1359        /*
1360         * NB we do this to "quiesce" EQCR. If we add enqueue-completions or
1361         * something related to QM_PIRQ_EQCI, this may need fixing.
1362         * Also, due to the prefetching model used for CI updates in the enqueue
1363         * path, this update will only invalidate the CI cacheline *after*
1364         * working on it, so we need to call this twice to ensure a full update
1365         * irrespective of where the enqueue processing was at when the teardown
1366         * began.
1367         */
1368        qm_eqcr_cce_update(&qm->p);
1369        qm_eqcr_cce_update(&qm->p);
1370        pcfg = qm->config;
1371
1372        free_irq(pcfg->irq, qm);
1373
1374        kfree(qm->cgrs);
1375        qm_mc_finish(&qm->p);
1376        qm_mr_finish(&qm->p);
1377        qm_dqrr_finish(&qm->p);
1378        qm_eqcr_finish(&qm->p);
1379
1380        qm->config = NULL;
1381}
1382
1383const struct qm_portal_config *qman_destroy_affine_portal(void)
1384{
1385        struct qman_portal *qm = get_affine_portal();
1386        const struct qm_portal_config *pcfg;
1387        int cpu;
1388
1389        pcfg = qm->config;
1390        cpu = pcfg->cpu;
1391
1392        qman_destroy_portal(qm);
1393
1394#ifndef __rtems__
1395        spin_lock(&affine_mask_lock);
1396        cpumask_clear_cpu(cpu, &affine_mask);
1397        spin_unlock(&affine_mask_lock);
1398#else /* __rtems__ */
1399        (void)cpu;
1400#endif /* __rtems__ */
1401        put_affine_portal();
1402        return pcfg;
1403}
1404
1405/* Inline helper to reduce nesting in __poll_portal_slow() */
1406static inline void fq_state_change(struct qman_portal *p, struct qman_fq *fq,
1407                                   const union qm_mr_entry *msg, u8 verb)
1408{
1409        switch (verb) {
1410        case QM_MR_VERB_FQRL:
1411                DPAA_ASSERT(fq_isset(fq, QMAN_FQ_STATE_ORL));
1412                fq_clear(fq, QMAN_FQ_STATE_ORL);
1413                break;
1414        case QM_MR_VERB_FQRN:
1415                DPAA_ASSERT(fq->state == qman_fq_state_parked ||
1416                            fq->state == qman_fq_state_sched);
1417                DPAA_ASSERT(fq_isset(fq, QMAN_FQ_STATE_CHANGING));
1418                fq_clear(fq, QMAN_FQ_STATE_CHANGING);
1419                if (msg->fq.fqs & QM_MR_FQS_NOTEMPTY)
1420                        fq_set(fq, QMAN_FQ_STATE_NE);
1421                if (msg->fq.fqs & QM_MR_FQS_ORLPRESENT)
1422                        fq_set(fq, QMAN_FQ_STATE_ORL);
1423                fq->state = qman_fq_state_retired;
1424                break;
1425        case QM_MR_VERB_FQPN:
1426                DPAA_ASSERT(fq->state == qman_fq_state_sched);
1427                DPAA_ASSERT(fq_isclear(fq, QMAN_FQ_STATE_CHANGING));
1428                fq->state = qman_fq_state_parked;
1429        }
1430}
1431
1432#ifndef __rtems__
1433static void qm_congestion_task(struct work_struct *work)
1434{
1435        struct qman_portal *p = container_of(work, struct qman_portal,
1436                                             congestion_work);
1437#else /* __rtems__ */
1438static void qm_congestion_task(struct qman_portal *p)
1439{
1440#endif /* __rtems__ */
1441        struct qman_cgrs rr, c;
1442        union qm_mc_result *mcr;
1443        struct qman_cgr *cgr;
1444
1445        spin_lock(&p->cgr_lock);
1446        qm_mc_start(&p->p);
1447        qm_mc_commit(&p->p, QM_MCC_VERB_QUERYCONGESTION);
1448        if (!qm_mc_result_timeout(&p->p, &mcr)) {
1449                spin_unlock(&p->cgr_lock);
1450                dev_crit(p->config->dev, "QUERYCONGESTION timeout\n");
1451                qman_p_irqsource_add(p, QM_PIRQ_CSCI);
1452                return;
1453        }
1454        /* mask out the ones I'm not interested in */
1455        qman_cgrs_and(&rr, (struct qman_cgrs *)&mcr->querycongestion.state,
1456                      &p->cgrs[0]);
1457        /* check previous snapshot for delta, enter/exit congestion */
1458        qman_cgrs_xor(&c, &rr, &p->cgrs[1]);
1459        /* update snapshot */
1460        qman_cgrs_cp(&p->cgrs[1], &rr);
1461        /* Invoke callback */
1462        list_for_each_entry(cgr, &p->cgr_cbs, node)
1463                if (cgr->cb && qman_cgrs_get(&c, cgr->cgrid))
1464                        cgr->cb(p, cgr, qman_cgrs_get(&rr, cgr->cgrid));
1465        spin_unlock(&p->cgr_lock);
1466        qman_p_irqsource_add(p, QM_PIRQ_CSCI);
1467}
1468
1469#ifndef __rtems__
1470static void qm_mr_process_task(struct work_struct *work)
1471{
1472        struct qman_portal *p = container_of(work, struct qman_portal,
1473                                             mr_work);
1474#else /* __rtems__ */
1475static void qm_mr_process_task(struct qman_portal *p)
1476{
1477#endif /* __rtems__ */
1478        const union qm_mr_entry *msg;
1479        struct qman_fq *fq;
1480        u8 verb, num = 0;
1481
1482#ifndef __rtems__
1483        preempt_disable();
1484#endif /* __rtems__ */
1485
1486        while (1) {
1487                qm_mr_pvb_update(&p->p);
1488                msg = qm_mr_current(&p->p);
1489                if (!msg)
1490                        break;
1491
1492                verb = msg->verb & QM_MR_VERB_TYPE_MASK;
1493                /* The message is a software ERN iff the 0x20 bit is clear */
1494                if (verb & 0x20) {
1495                        switch (verb) {
1496                        case QM_MR_VERB_FQRNI:
1497                                /* nada, we drop FQRNIs on the floor */
1498                                break;
1499                        case QM_MR_VERB_FQRN:
1500                        case QM_MR_VERB_FQRL:
1501                                /* Lookup in the retirement table */
1502                                fq = fqid_to_fq(qm_fqid_get(&msg->fq));
1503                                if (WARN_ON(!fq))
1504                                        break;
1505                                fq_state_change(p, fq, msg, verb);
1506                                if (fq->cb.fqs)
1507                                        fq->cb.fqs(p, fq, msg);
1508                                break;
1509                        case QM_MR_VERB_FQPN:
1510                                /* Parked */
1511                                fq = tag_to_fq(be32_to_cpu(msg->fq.context_b));
1512                                fq_state_change(p, fq, msg, verb);
1513                                if (fq->cb.fqs)
1514                                        fq->cb.fqs(p, fq, msg);
1515                                break;
1516                        case QM_MR_VERB_DC_ERN:
1517                                /* DCP ERN */
1518                                pr_crit_once("Leaking DCP ERNs!\n");
1519                                break;
1520                        default:
1521                                pr_crit("Invalid MR verb 0x%02x\n", verb);
1522                        }
1523                } else {
1524                        /* Its a software ERN */
1525                        fq = tag_to_fq(be32_to_cpu(msg->ern.tag));
1526                        fq->cb.ern(p, fq, msg);
1527                }
1528                num++;
1529                qm_mr_next(&p->p);
1530        }
1531
1532        qm_mr_cci_consume(&p->p, num);
1533        qman_p_irqsource_add(p, QM_PIRQ_MRI);
1534#ifndef __rtems__
1535        preempt_enable();
1536#endif /* __rtems__ */
1537}
1538
1539static u32 __poll_portal_slow(struct qman_portal *p, u32 is)
1540{
1541        if (is & QM_PIRQ_CSCI) {
1542                qman_p_irqsource_remove(p, QM_PIRQ_CSCI);
1543#ifndef __rtems__
1544                queue_work_on(smp_processor_id(), qm_portal_wq,
1545                              &p->congestion_work);
1546#else /* __rtems__ */
1547                qm_congestion_task(p);
1548#endif /* __rtems__ */
1549        }
1550
1551        if (is & QM_PIRQ_EQRI) {
1552                qm_eqcr_cce_update(&p->p);
1553                qm_eqcr_set_ithresh(&p->p, 0);
1554                wake_up(&affine_queue);
1555        }
1556
1557        if (is & QM_PIRQ_MRI) {
1558                qman_p_irqsource_remove(p, QM_PIRQ_MRI);
1559#ifndef __rtems__
1560                queue_work_on(smp_processor_id(), qm_portal_wq,
1561                              &p->mr_work);
1562#else /* __rtems__ */
1563                qm_mr_process_task(p);
1564#endif /* __rtems__ */
1565        }
1566
1567        return is;
1568}
1569
1570/*
1571 * remove some slowish-path stuff from the "fast path" and make sure it isn't
1572 * inlined.
1573 */
1574static noinline void clear_vdqcr(struct qman_portal *p, struct qman_fq *fq)
1575{
1576        p->vdqcr_owned = NULL;
1577        fq_clear(fq, QMAN_FQ_STATE_VDQCR);
1578        wake_up(&affine_queue);
1579}
1580
1581/*
1582 * The only states that would conflict with other things if they ran at the
1583 * same time on the same cpu are:
1584 *
1585 *   (i) setting/clearing vdqcr_owned, and
1586 *  (ii) clearing the NE (Not Empty) flag.
1587 *
1588 * Both are safe. Because;
1589 *
1590 *   (i) this clearing can only occur after qman_volatile_dequeue() has set the
1591 *       vdqcr_owned field (which it does before setting VDQCR), and
1592 *       qman_volatile_dequeue() blocks interrupts and preemption while this is
1593 *       done so that we can't interfere.
1594 *  (ii) the NE flag is only cleared after qman_retire_fq() has set it, and as
1595 *       with (i) that API prevents us from interfering until it's safe.
1596 *
1597 * The good thing is that qman_volatile_dequeue() and qman_retire_fq() run far
1598 * less frequently (ie. per-FQ) than __poll_portal_fast() does, so the nett
1599 * advantage comes from this function not having to "lock" anything at all.
1600 *
1601 * Note also that the callbacks are invoked at points which are safe against the
1602 * above potential conflicts, but that this function itself is not re-entrant
1603 * (this is because the function tracks one end of each FIFO in the portal and
1604 * we do *not* want to lock that). So the consequence is that it is safe for
1605 * user callbacks to call into any QMan API.
1606 */
1607static inline unsigned int __poll_portal_fast(struct qman_portal *p,
1608                                        unsigned int poll_limit)
1609{
1610        const struct qm_dqrr_entry *dq;
1611        struct qman_fq *fq;
1612        enum qman_cb_dqrr_result res;
1613        unsigned int limit = 0;
1614
1615        do {
1616                qm_dqrr_pvb_update(&p->p);
1617                dq = qm_dqrr_current(&p->p);
1618                if (!dq)
1619                        break;
1620
1621                if (dq->stat & QM_DQRR_STAT_UNSCHEDULED) {
1622                        /*
1623                         * VDQCR: don't trust context_b as the FQ may have
1624                         * been configured for h/w consumption and we're
1625                         * draining it post-retirement.
1626                         */
1627                        fq = p->vdqcr_owned;
1628                        /*
1629                         * We only set QMAN_FQ_STATE_NE when retiring, so we
1630                         * only need to check for clearing it when doing
1631                         * volatile dequeues.  It's one less thing to check
1632                         * in the critical path (SDQCR).
1633                         */
1634                        if (dq->stat & QM_DQRR_STAT_FQ_EMPTY)
1635                                fq_clear(fq, QMAN_FQ_STATE_NE);
1636                        /*
1637                         * This is duplicated from the SDQCR code, but we
1638                         * have stuff to do before *and* after this callback,
1639                         * and we don't want multiple if()s in the critical
1640                         * path (SDQCR).
1641                         */
1642                        res = fq->cb.dqrr(p, fq, dq);
1643                        if (res == qman_cb_dqrr_stop)
1644                                break;
1645                        /* Check for VDQCR completion */
1646                        if (dq->stat & QM_DQRR_STAT_DQCR_EXPIRED)
1647                                clear_vdqcr(p, fq);
1648                } else {
1649                        /* SDQCR: context_b points to the FQ */
1650                        fq = tag_to_fq(be32_to_cpu(dq->context_b));
1651                        /* Now let the callback do its stuff */
1652                        res = fq->cb.dqrr(p, fq, dq);
1653                        /*
1654                         * The callback can request that we exit without
1655                         * consuming this entry nor advancing;
1656                         */
1657                        if (res == qman_cb_dqrr_stop)
1658                                break;
1659                }
1660                /* Interpret 'dq' from a driver perspective. */
1661                /*
1662                 * Parking isn't possible unless HELDACTIVE was set. NB,
1663                 * FORCEELIGIBLE implies HELDACTIVE, so we only need to
1664                 * check for HELDACTIVE to cover both.
1665                 */
1666                DPAA_ASSERT((dq->stat & QM_DQRR_STAT_FQ_HELDACTIVE) ||
1667                            (res != qman_cb_dqrr_park));
1668                /* just means "skip it, I'll consume it myself later on" */
1669                if (res != qman_cb_dqrr_defer)
1670                        qm_dqrr_cdc_consume_1ptr(&p->p, dq,
1671                                                 res == qman_cb_dqrr_park);
1672                /* Move forward */
1673                qm_dqrr_next(&p->p);
1674                /*
1675                 * Entry processed and consumed, increment our counter.  The
1676                 * callback can request that we exit after consuming the
1677                 * entry, and we also exit if we reach our processing limit,
1678                 * so loop back only if neither of these conditions is met.
1679                 */
1680        } while (++limit < poll_limit && res != qman_cb_dqrr_consume_stop);
1681
1682        return limit;
1683}
1684
1685void qman_p_irqsource_add(struct qman_portal *p, u32 bits)
1686{
1687        unsigned long irqflags;
1688
1689        local_irq_save(irqflags);
1690        set_bits(bits & QM_PIRQ_VISIBLE, &p->irq_sources);
1691        qm_out(&p->p, QM_REG_IER, p->irq_sources);
1692        local_irq_restore(irqflags);
1693}
1694EXPORT_SYMBOL(qman_p_irqsource_add);
1695
1696void qman_p_irqsource_remove(struct qman_portal *p, u32 bits)
1697{
1698        unsigned long irqflags;
1699        u32 ier;
1700
1701        /*
1702         * Our interrupt handler only processes+clears status register bits that
1703         * are in p->irq_sources. As we're trimming that mask, if one of them
1704         * were to assert in the status register just before we remove it from
1705         * the enable register, there would be an interrupt-storm when we
1706         * release the IRQ lock. So we wait for the enable register update to
1707         * take effect in h/w (by reading it back) and then clear all other bits
1708         * in the status register. Ie. we clear them from ISR once it's certain
1709         * IER won't allow them to reassert.
1710         */
1711        local_irq_save(irqflags);
1712        bits &= QM_PIRQ_VISIBLE;
1713        clear_bits(bits, &p->irq_sources);
1714        qm_out(&p->p, QM_REG_IER, p->irq_sources);
1715        ier = qm_in(&p->p, QM_REG_IER);
1716        /*
1717         * Using "~ier" (rather than "bits" or "~p->irq_sources") creates a
1718         * data-dependency, ie. to protect against re-ordering.
1719         */
1720        qm_out(&p->p, QM_REG_ISR, ~ier);
1721        local_irq_restore(irqflags);
1722}
1723EXPORT_SYMBOL(qman_p_irqsource_remove);
1724
1725#ifndef __rtems__
1726const cpumask_t *qman_affine_cpus(void)
1727{
1728        return &affine_mask;
1729}
1730EXPORT_SYMBOL(qman_affine_cpus);
1731
1732u16 qman_affine_channel(int cpu)
1733{
1734        if (cpu < 0) {
1735                struct qman_portal *portal = get_affine_portal();
1736
1737                cpu = portal->config->cpu;
1738                put_affine_portal();
1739        }
1740        WARN_ON(!cpumask_test_cpu(cpu, &affine_mask));
1741        return affine_channels[cpu];
1742}
1743EXPORT_SYMBOL(qman_affine_channel);
1744#endif /* __rtems__ */
1745
1746struct qman_portal *qman_get_affine_portal(int cpu)
1747{
1748        return affine_portals[cpu];
1749}
1750EXPORT_SYMBOL(qman_get_affine_portal);
1751
1752int qman_p_poll_dqrr(struct qman_portal *p, unsigned int limit)
1753{
1754        return __poll_portal_fast(p, limit);
1755}
1756EXPORT_SYMBOL(qman_p_poll_dqrr);
1757
1758void qman_p_static_dequeue_add(struct qman_portal *p, u32 pools)
1759{
1760        unsigned long irqflags;
1761
1762        local_irq_save(irqflags);
1763        pools &= p->config->pools;
1764        p->sdqcr |= pools;
1765        qm_dqrr_sdqcr_set(&p->p, p->sdqcr);
1766        local_irq_restore(irqflags);
1767}
1768EXPORT_SYMBOL(qman_p_static_dequeue_add);
1769
1770/* Frame queue API */
1771
1772static const char *mcr_result_str(u8 result)
1773{
1774        switch (result) {
1775        case QM_MCR_RESULT_NULL:
1776                return "QM_MCR_RESULT_NULL";
1777        case QM_MCR_RESULT_OK:
1778                return "QM_MCR_RESULT_OK";
1779        case QM_MCR_RESULT_ERR_FQID:
1780                return "QM_MCR_RESULT_ERR_FQID";
1781        case QM_MCR_RESULT_ERR_FQSTATE:
1782                return "QM_MCR_RESULT_ERR_FQSTATE";
1783        case QM_MCR_RESULT_ERR_NOTEMPTY:
1784                return "QM_MCR_RESULT_ERR_NOTEMPTY";
1785        case QM_MCR_RESULT_PENDING:
1786                return "QM_MCR_RESULT_PENDING";
1787        case QM_MCR_RESULT_ERR_BADCOMMAND:
1788                return "QM_MCR_RESULT_ERR_BADCOMMAND";
1789        }
1790        return "<unknown MCR result>";
1791}
1792
1793int qman_create_fq(u32 fqid, u32 flags, struct qman_fq *fq)
1794{
1795        if (flags & QMAN_FQ_FLAG_DYNAMIC_FQID) {
1796                int ret = qman_alloc_fqid(&fqid);
1797
1798                if (ret)
1799                        return ret;
1800        }
1801        fq->fqid = fqid;
1802        fq->flags = flags;
1803        fq->state = qman_fq_state_oos;
1804        fq->cgr_groupid = 0;
1805
1806        /* A context_b of 0 is allegedly special, so don't use that fqid */
1807        if (fqid == 0 || fqid >= num_fqids) {
1808                WARN(1, "bad fqid %d\n", fqid);
1809                return -EINVAL;
1810        }
1811
1812        fq->idx = fqid * 2;
1813        if (flags & QMAN_FQ_FLAG_NO_MODIFY)
1814                fq->idx++;
1815
1816        WARN_ON(fq_table[fq->idx]);
1817        fq_table[fq->idx] = fq;
1818
1819        return 0;
1820}
1821EXPORT_SYMBOL(qman_create_fq);
1822
1823void qman_destroy_fq(struct qman_fq *fq)
1824{
1825        /*
1826         * We don't need to lock the FQ as it is a pre-condition that the FQ be
1827         * quiesced. Instead, run some checks.
1828         */
1829        switch (fq->state) {
1830        case qman_fq_state_parked:
1831        case qman_fq_state_oos:
1832                if (fq_isset(fq, QMAN_FQ_FLAG_DYNAMIC_FQID))
1833                        qman_release_fqid(fq->fqid);
1834
1835                DPAA_ASSERT(fq_table[fq->idx]);
1836                fq_table[fq->idx] = NULL;
1837                return;
1838        default:
1839                break;
1840        }
1841        DPAA_ASSERT(NULL == "qman_free_fq() on unquiesced FQ!");
1842}
1843EXPORT_SYMBOL(qman_destroy_fq);
1844
1845u32 qman_fq_fqid(struct qman_fq *fq)
1846{
1847        return fq->fqid;
1848}
1849EXPORT_SYMBOL(qman_fq_fqid);
1850
1851int qman_init_fq(struct qman_fq *fq, u32 flags, struct qm_mcc_initfq *opts)
1852{
1853        union qm_mc_command *mcc;
1854        union qm_mc_result *mcr;
1855        struct qman_portal *p;
1856        u8 res, myverb;
1857        int ret = 0;
1858
1859        myverb = (flags & QMAN_INITFQ_FLAG_SCHED)
1860                ? QM_MCC_VERB_INITFQ_SCHED : QM_MCC_VERB_INITFQ_PARKED;
1861
1862        if (fq->state != qman_fq_state_oos &&
1863            fq->state != qman_fq_state_parked)
1864                return -EINVAL;
1865#ifdef CONFIG_FSL_DPAA_CHECKING
1866        if (fq_isset(fq, QMAN_FQ_FLAG_NO_MODIFY))
1867                return -EINVAL;
1868#endif
1869        if (opts && (be16_to_cpu(opts->we_mask) & QM_INITFQ_WE_OAC)) {
1870                /* And can't be set at the same time as TDTHRESH */
1871                if (be16_to_cpu(opts->we_mask) & QM_INITFQ_WE_TDTHRESH)
1872                        return -EINVAL;
1873        }
1874        /* Issue an INITFQ_[PARKED|SCHED] management command */
1875        p = get_affine_portal();
1876        if (fq_isset(fq, QMAN_FQ_STATE_CHANGING) ||
1877            (fq->state != qman_fq_state_oos &&
1878             fq->state != qman_fq_state_parked)) {
1879                ret = -EBUSY;
1880                goto out;
1881        }
1882        mcc = qm_mc_start(&p->p);
1883        if (opts)
1884                mcc->initfq = *opts;
1885        qm_fqid_set(&mcc->fq, fq->fqid);
1886        mcc->initfq.count = 0;
1887        /*
1888         * If the FQ does *not* have the TO_DCPORTAL flag, context_b is set as a
1889         * demux pointer. Otherwise, the caller-provided value is allowed to
1890         * stand, don't overwrite it.
1891         */
1892        if (fq_isclear(fq, QMAN_FQ_FLAG_TO_DCPORTAL)) {
1893                dma_addr_t phys_fq;
1894
1895                mcc->initfq.we_mask |= cpu_to_be16(QM_INITFQ_WE_CONTEXTB);
1896                mcc->initfq.fqd.context_b = cpu_to_be32(fq_to_tag(fq));
1897                /*
1898                 *  and the physical address - NB, if the user wasn't trying to
1899                 * set CONTEXTA, clear the stashing settings.
1900                 */
1901                if (!(be16_to_cpu(mcc->initfq.we_mask) &
1902                                  QM_INITFQ_WE_CONTEXTA)) {
1903                        mcc->initfq.we_mask |=
1904                                cpu_to_be16(QM_INITFQ_WE_CONTEXTA);
1905                        memset(&mcc->initfq.fqd.context_a, 0,
1906                                sizeof(mcc->initfq.fqd.context_a));
1907                } else {
1908#ifndef __rtems__
1909                        struct qman_portal *p = qman_dma_portal;
1910
1911                        phys_fq = dma_map_single(p->config->dev, fq,
1912                                                 sizeof(*fq), DMA_TO_DEVICE);
1913                        if (dma_mapping_error(p->config->dev, phys_fq)) {
1914                                dev_err(p->config->dev, "dma_mapping failed\n");
1915                                ret = -EIO;
1916                                goto out;
1917                        }
1918#else /* __rtems__ */
1919                        phys_fq = (dma_addr_t)fq;
1920#endif /* __rtems__ */
1921
1922                        qm_fqd_stashing_set64(&mcc->initfq.fqd, phys_fq);
1923                }
1924        }
1925        if (flags & QMAN_INITFQ_FLAG_LOCAL) {
1926                int wq = 0;
1927
1928                if (!(be16_to_cpu(mcc->initfq.we_mask) &
1929                                  QM_INITFQ_WE_DESTWQ)) {
1930                        mcc->initfq.we_mask |=
1931                                cpu_to_be16(QM_INITFQ_WE_DESTWQ);
1932                        wq = 4;
1933                }
1934                qm_fqd_set_destwq(&mcc->initfq.fqd, p->config->channel, wq);
1935        }
1936        qm_mc_commit(&p->p, myverb);
1937        if (!qm_mc_result_timeout(&p->p, &mcr)) {
1938                dev_err(p->config->dev, "MCR timeout\n");
1939                ret = -ETIMEDOUT;
1940                goto out;
1941        }
1942
1943        DPAA_ASSERT((mcr->verb & QM_MCR_VERB_MASK) == myverb);
1944        res = mcr->result;
1945        if (res != QM_MCR_RESULT_OK) {
1946                ret = -EIO;
1947                goto out;
1948        }
1949        if (opts) {
1950                if (be16_to_cpu(opts->we_mask) & QM_INITFQ_WE_FQCTRL) {
1951                        if (be16_to_cpu(opts->fqd.fq_ctrl) & QM_FQCTRL_CGE)
1952                                fq_set(fq, QMAN_FQ_STATE_CGR_EN);
1953                        else
1954                                fq_clear(fq, QMAN_FQ_STATE_CGR_EN);
1955                }
1956                if (be16_to_cpu(opts->we_mask) & QM_INITFQ_WE_CGID)
1957                        fq->cgr_groupid = opts->fqd.cgid;
1958        }
1959        fq->state = (flags & QMAN_INITFQ_FLAG_SCHED) ?
1960                qman_fq_state_sched : qman_fq_state_parked;
1961
1962out:
1963        put_affine_portal();
1964        return ret;
1965}
1966EXPORT_SYMBOL(qman_init_fq);
1967
1968int qman_schedule_fq(struct qman_fq *fq)
1969{
1970        union qm_mc_command *mcc;
1971        union qm_mc_result *mcr;
1972        struct qman_portal *p;
1973        int ret = 0;
1974
1975        if (fq->state != qman_fq_state_parked)
1976                return -EINVAL;
1977#ifdef CONFIG_FSL_DPAA_CHECKING
1978        if (fq_isset(fq, QMAN_FQ_FLAG_NO_MODIFY))
1979                return -EINVAL;
1980#endif
1981        /* Issue a ALTERFQ_SCHED management command */
1982        p = get_affine_portal();
1983        if (fq_isset(fq, QMAN_FQ_STATE_CHANGING) ||
1984            fq->state != qman_fq_state_parked) {
1985                ret = -EBUSY;
1986                goto out;
1987        }
1988        mcc = qm_mc_start(&p->p);
1989        qm_fqid_set(&mcc->fq, fq->fqid);
1990        qm_mc_commit(&p->p, QM_MCC_VERB_ALTER_SCHED);
1991        if (!qm_mc_result_timeout(&p->p, &mcr)) {
1992                dev_err(p->config->dev, "ALTER_SCHED timeout\n");
1993                ret = -ETIMEDOUT;
1994                goto out;
1995        }
1996
1997        DPAA_ASSERT((mcr->verb & QM_MCR_VERB_MASK) == QM_MCR_VERB_ALTER_SCHED);
1998        if (mcr->result != QM_MCR_RESULT_OK) {
1999                ret = -EIO;
2000                goto out;
2001        }
2002        fq->state = qman_fq_state_sched;
2003out:
2004        put_affine_portal();
2005        return ret;
2006}
2007EXPORT_SYMBOL(qman_schedule_fq);
2008
2009int qman_retire_fq(struct qman_fq *fq, u32 *flags)
2010{
2011        union qm_mc_command *mcc;
2012        union qm_mc_result *mcr;
2013        struct qman_portal *p;
2014        int ret;
2015        u8 res;
2016
2017        if (fq->state != qman_fq_state_parked &&
2018            fq->state != qman_fq_state_sched)
2019                return -EINVAL;
2020#ifdef CONFIG_FSL_DPAA_CHECKING
2021        if (fq_isset(fq, QMAN_FQ_FLAG_NO_MODIFY))
2022                return -EINVAL;
2023#endif
2024        p = get_affine_portal();
2025        if (fq_isset(fq, QMAN_FQ_STATE_CHANGING) ||
2026            fq->state == qman_fq_state_retired ||
2027            fq->state == qman_fq_state_oos) {
2028                ret = -EBUSY;
2029                goto out;
2030        }
2031        mcc = qm_mc_start(&p->p);
2032        qm_fqid_set(&mcc->fq, fq->fqid);
2033        qm_mc_commit(&p->p, QM_MCC_VERB_ALTER_RETIRE);
2034        if (!qm_mc_result_timeout(&p->p, &mcr)) {
2035                dev_crit(p->config->dev, "ALTER_RETIRE timeout\n");
2036                ret = -ETIMEDOUT;
2037                goto out;
2038        }
2039
2040        DPAA_ASSERT((mcr->verb & QM_MCR_VERB_MASK) == QM_MCR_VERB_ALTER_RETIRE);
2041        res = mcr->result;
2042        /*
2043         * "Elegant" would be to treat OK/PENDING the same way; set CHANGING,
2044         * and defer the flags until FQRNI or FQRN (respectively) show up. But
2045         * "Friendly" is to process OK immediately, and not set CHANGING. We do
2046         * friendly, otherwise the caller doesn't necessarily have a fully
2047         * "retired" FQ on return even if the retirement was immediate. However
2048         * this does mean some code duplication between here and
2049         * fq_state_change().
2050         */
2051        if (res == QM_MCR_RESULT_OK) {
2052                ret = 0;
2053                /* Process 'fq' right away, we'll ignore FQRNI */
2054                if (mcr->alterfq.fqs & QM_MCR_FQS_NOTEMPTY)
2055                        fq_set(fq, QMAN_FQ_STATE_NE);
2056                if (mcr->alterfq.fqs & QM_MCR_FQS_ORLPRESENT)
2057                        fq_set(fq, QMAN_FQ_STATE_ORL);
2058                if (flags)
2059                        *flags = fq->flags;
2060                fq->state = qman_fq_state_retired;
2061                if (fq->cb.fqs) {
2062                        /*
2063                         * Another issue with supporting "immediate" retirement
2064                         * is that we're forced to drop FQRNIs, because by the
2065                         * time they're seen it may already be "too late" (the
2066                         * fq may have been OOS'd and free()'d already). But if
2067                         * the upper layer wants a callback whether it's
2068                         * immediate or not, we have to fake a "MR" entry to
2069                         * look like an FQRNI...
2070                         */
2071                        union qm_mr_entry msg;
2072
2073                        msg.verb = QM_MR_VERB_FQRNI;
2074                        msg.fq.fqs = mcr->alterfq.fqs;
2075                        qm_fqid_set(&msg.fq, fq->fqid);
2076                        msg.fq.context_b = cpu_to_be32(fq_to_tag(fq));
2077                        fq->cb.fqs(p, fq, &msg);
2078                }
2079        } else if (res == QM_MCR_RESULT_PENDING) {
2080                ret = 1;
2081                fq_set(fq, QMAN_FQ_STATE_CHANGING);
2082        } else {
2083                ret = -EIO;
2084        }
2085out:
2086        put_affine_portal();
2087        return ret;
2088}
2089EXPORT_SYMBOL(qman_retire_fq);
2090
2091int qman_oos_fq(struct qman_fq *fq)
2092{
2093        union qm_mc_command *mcc;
2094        union qm_mc_result *mcr;
2095        struct qman_portal *p;
2096        int ret = 0;
2097
2098        if (fq->state != qman_fq_state_retired)
2099                return -EINVAL;
2100#ifdef CONFIG_FSL_DPAA_CHECKING
2101        if (fq_isset(fq, QMAN_FQ_FLAG_NO_MODIFY))
2102                return -EINVAL;
2103#endif
2104        p = get_affine_portal();
2105        if (fq_isset(fq, QMAN_FQ_STATE_BLOCKOOS) ||
2106            fq->state != qman_fq_state_retired) {
2107                ret = -EBUSY;
2108                goto out;
2109        }
2110        mcc = qm_mc_start(&p->p);
2111        qm_fqid_set(&mcc->fq, fq->fqid);
2112        qm_mc_commit(&p->p, QM_MCC_VERB_ALTER_OOS);
2113        if (!qm_mc_result_timeout(&p->p, &mcr)) {
2114                ret = -ETIMEDOUT;
2115                goto out;
2116        }
2117        DPAA_ASSERT((mcr->verb & QM_MCR_VERB_MASK) == QM_MCR_VERB_ALTER_OOS);
2118        if (mcr->result != QM_MCR_RESULT_OK) {
2119                ret = -EIO;
2120                goto out;
2121        }
2122        fq->state = qman_fq_state_oos;
2123out:
2124        put_affine_portal();
2125        return ret;
2126}
2127EXPORT_SYMBOL(qman_oos_fq);
2128
2129int qman_query_fq(struct qman_fq *fq, struct qm_fqd *fqd)
2130{
2131        union qm_mc_command *mcc;
2132        union qm_mc_result *mcr;
2133        struct qman_portal *p = get_affine_portal();
2134        int ret = 0;
2135
2136        mcc = qm_mc_start(&p->p);
2137        qm_fqid_set(&mcc->fq, fq->fqid);
2138        qm_mc_commit(&p->p, QM_MCC_VERB_QUERYFQ);
2139        if (!qm_mc_result_timeout(&p->p, &mcr)) {
2140                ret = -ETIMEDOUT;
2141                goto out;
2142        }
2143
2144        DPAA_ASSERT((mcr->verb & QM_MCR_VERB_MASK) == QM_MCR_VERB_QUERYFQ);
2145        if (mcr->result == QM_MCR_RESULT_OK)
2146                *fqd = mcr->queryfq.fqd;
2147        else
2148                ret = -EIO;
2149out:
2150        put_affine_portal();
2151        return ret;
2152}
2153
2154int qman_query_fq_np(struct qman_fq *fq, struct qm_mcr_queryfq_np *np)
2155{
2156        union qm_mc_command *mcc;
2157        union qm_mc_result *mcr;
2158        struct qman_portal *p = get_affine_portal();
2159        int ret = 0;
2160
2161        mcc = qm_mc_start(&p->p);
2162        qm_fqid_set(&mcc->fq, fq->fqid);
2163        qm_mc_commit(&p->p, QM_MCC_VERB_QUERYFQ_NP);
2164        if (!qm_mc_result_timeout(&p->p, &mcr)) {
2165                ret = -ETIMEDOUT;
2166                goto out;
2167        }
2168
2169        DPAA_ASSERT((mcr->verb & QM_MCR_VERB_MASK) == QM_MCR_VERB_QUERYFQ_NP);
2170        if (mcr->result == QM_MCR_RESULT_OK)
2171                *np = mcr->queryfq_np;
2172        else if (mcr->result == QM_MCR_RESULT_ERR_FQID)
2173                ret = -ERANGE;
2174        else
2175                ret = -EIO;
2176out:
2177        put_affine_portal();
2178        return ret;
2179}
2180EXPORT_SYMBOL(qman_query_fq_np);
2181
2182static int qman_query_cgr(struct qman_cgr *cgr,
2183                          struct qm_mcr_querycgr *cgrd)
2184{
2185        union qm_mc_command *mcc;
2186        union qm_mc_result *mcr;
2187        struct qman_portal *p = get_affine_portal();
2188        int ret = 0;
2189
2190        mcc = qm_mc_start(&p->p);
2191        mcc->cgr.cgid = cgr->cgrid;
2192        qm_mc_commit(&p->p, QM_MCC_VERB_QUERYCGR);
2193        if (!qm_mc_result_timeout(&p->p, &mcr)) {
2194                ret = -ETIMEDOUT;
2195                goto out;
2196        }
2197        DPAA_ASSERT((mcr->verb & QM_MCR_VERB_MASK) == QM_MCC_VERB_QUERYCGR);
2198        if (mcr->result == QM_MCR_RESULT_OK)
2199                *cgrd = mcr->querycgr;
2200        else {
2201                dev_err(p->config->dev, "QUERY_CGR failed: %s\n",
2202                        mcr_result_str(mcr->result));
2203                ret = -EIO;
2204        }
2205out:
2206        put_affine_portal();
2207        return ret;
2208}
2209
2210int qman_query_cgr_congested(struct qman_cgr *cgr, bool *result)
2211{
2212        struct qm_mcr_querycgr query_cgr;
2213        int err;
2214
2215        err = qman_query_cgr(cgr, &query_cgr);
2216        if (err)
2217                return err;
2218
2219        *result = !!query_cgr.cgr.cs;
2220        return 0;
2221}
2222EXPORT_SYMBOL(qman_query_cgr_congested);
2223
2224/* internal function used as a wait_event() expression */
2225static int set_p_vdqcr(struct qman_portal *p, struct qman_fq *fq, u32 vdqcr)
2226{
2227        unsigned long irqflags;
2228        int ret = -EBUSY;
2229
2230        local_irq_save(irqflags);
2231        if (p->vdqcr_owned)
2232                goto out;
2233        if (fq_isset(fq, QMAN_FQ_STATE_VDQCR))
2234                goto out;
2235
2236        fq_set(fq, QMAN_FQ_STATE_VDQCR);
2237        p->vdqcr_owned = fq;
2238        qm_dqrr_vdqcr_set(&p->p, vdqcr);
2239        ret = 0;
2240out:
2241        local_irq_restore(irqflags);
2242        return ret;
2243}
2244
2245static int set_vdqcr(struct qman_portal **p, struct qman_fq *fq, u32 vdqcr)
2246{
2247        int ret;
2248
2249        *p = get_affine_portal();
2250        ret = set_p_vdqcr(*p, fq, vdqcr);
2251        put_affine_portal();
2252        return ret;
2253}
2254
2255static int wait_vdqcr_start(struct qman_portal **p, struct qman_fq *fq,
2256                                u32 vdqcr, u32 flags)
2257{
2258        int ret = 0;
2259
2260#ifndef __rtems__
2261        if (flags & QMAN_VOLATILE_FLAG_WAIT_INT)
2262                ret = wait_event_interruptible(affine_queue,
2263                                !set_vdqcr(p, fq, vdqcr));
2264        else
2265#endif /* __rtems__ */
2266                wait_event(affine_queue, !set_vdqcr(p, fq, vdqcr));
2267        return ret;
2268}
2269
2270int qman_volatile_dequeue(struct qman_fq *fq, u32 flags, u32 vdqcr)
2271{
2272        struct qman_portal *p;
2273        int ret;
2274
2275        if (fq->state != qman_fq_state_parked &&
2276            fq->state != qman_fq_state_retired)
2277                return -EINVAL;
2278        if (vdqcr & QM_VDQCR_FQID_MASK)
2279                return -EINVAL;
2280        if (fq_isset(fq, QMAN_FQ_STATE_VDQCR))
2281                return -EBUSY;
2282        vdqcr = (vdqcr & ~QM_VDQCR_FQID_MASK) | fq->fqid;
2283        if (flags & QMAN_VOLATILE_FLAG_WAIT)
2284                ret = wait_vdqcr_start(&p, fq, vdqcr, flags);
2285        else
2286                ret = set_vdqcr(&p, fq, vdqcr);
2287        if (ret)
2288                return ret;
2289        /* VDQCR is set */
2290        if (flags & QMAN_VOLATILE_FLAG_FINISH) {
2291#ifndef __rtems__
2292                if (flags & QMAN_VOLATILE_FLAG_WAIT_INT)
2293                        /*
2294                         * NB: don't propagate any error - the caller wouldn't
2295                         * know whether the VDQCR was issued or not. A signal
2296                         * could arrive after returning anyway, so the caller
2297                         * can check signal_pending() if that's an issue.
2298                         */
2299                        wait_event_interruptible(affine_queue,
2300                                !fq_isset(fq, QMAN_FQ_STATE_VDQCR));
2301                else
2302#endif /* __rtems__ */
2303                        wait_event(affine_queue,
2304                                !fq_isset(fq, QMAN_FQ_STATE_VDQCR));
2305        }
2306        return 0;
2307}
2308EXPORT_SYMBOL(qman_volatile_dequeue);
2309
2310static void update_eqcr_ci(struct qman_portal *p, u8 avail)
2311{
2312        if (avail)
2313                qm_eqcr_cce_prefetch(&p->p);
2314        else
2315                qm_eqcr_cce_update(&p->p);
2316}
2317
2318int qman_enqueue(struct qman_fq *fq, const struct qm_fd *fd)
2319{
2320        struct qman_portal *p;
2321        struct qm_eqcr_entry *eq;
2322        unsigned long irqflags;
2323        u8 avail;
2324
2325        p = get_affine_portal();
2326        local_irq_save(irqflags);
2327
2328        if (p->use_eqcr_ci_stashing) {
2329                /*
2330                 * The stashing case is easy, only update if we need to in
2331                 * order to try and liberate ring entries.
2332                 */
2333                eq = qm_eqcr_start_stash(&p->p);
2334        } else {
2335                /*
2336                 * The non-stashing case is harder, need to prefetch ahead of
2337                 * time.
2338                 */
2339                avail = qm_eqcr_get_avail(&p->p);
2340                if (avail < 2)
2341                        update_eqcr_ci(p, avail);
2342                eq = qm_eqcr_start_no_stash(&p->p);
2343        }
2344
2345        if (unlikely(!eq))
2346                goto out;
2347
2348        qm_fqid_set(eq, fq->fqid);
2349        eq->tag = cpu_to_be32(fq_to_tag(fq));
2350        eq->fd = *fd;
2351
2352        qm_eqcr_pvb_commit(&p->p, QM_EQCR_VERB_CMD_ENQUEUE);
2353out:
2354        local_irq_restore(irqflags);
2355        put_affine_portal();
2356        return 0;
2357}
2358EXPORT_SYMBOL(qman_enqueue);
2359
2360static int qm_modify_cgr(struct qman_cgr *cgr, u32 flags,
2361                         struct qm_mcc_initcgr *opts)
2362{
2363        union qm_mc_command *mcc;
2364        union qm_mc_result *mcr;
2365        struct qman_portal *p = get_affine_portal();
2366        u8 verb = QM_MCC_VERB_MODIFYCGR;
2367        int ret = 0;
2368
2369        mcc = qm_mc_start(&p->p);
2370        if (opts)
2371                mcc->initcgr = *opts;
2372        mcc->initcgr.cgid = cgr->cgrid;
2373        if (flags & QMAN_CGR_FLAG_USE_INIT)
2374                verb = QM_MCC_VERB_INITCGR;
2375        qm_mc_commit(&p->p, verb);
2376        if (!qm_mc_result_timeout(&p->p, &mcr)) {
2377                ret = -ETIMEDOUT;
2378                goto out;
2379        }
2380
2381        DPAA_ASSERT((mcr->verb & QM_MCR_VERB_MASK) == verb);
2382        if (mcr->result != QM_MCR_RESULT_OK)
2383                ret = -EIO;
2384
2385out:
2386        put_affine_portal();
2387        return ret;
2388}
2389
2390#define PORTAL_IDX(n)   (n->config->channel - QM_CHANNEL_SWPORTAL0)
2391
2392/* congestion state change notification target update control */
2393static void qm_cgr_cscn_targ_set(struct __qm_mc_cgr *cgr, int pi, u32 val)
2394{
2395        if (qman_ip_rev >= QMAN_REV30)
2396                cgr->cscn_targ_upd_ctrl = cpu_to_be16(pi |
2397                                        QM_CGR_TARG_UDP_CTRL_WRITE_BIT);
2398        else
2399                cgr->cscn_targ = cpu_to_be32(val | QM_CGR_TARG_PORTAL(pi));
2400}
2401
2402#ifndef __rtems__
2403static void qm_cgr_cscn_targ_clear(struct __qm_mc_cgr *cgr, int pi, u32 val)
2404{
2405        if (qman_ip_rev >= QMAN_REV30)
2406                cgr->cscn_targ_upd_ctrl = cpu_to_be16(pi);
2407        else
2408                cgr->cscn_targ = cpu_to_be32(val & ~QM_CGR_TARG_PORTAL(pi));
2409}
2410#endif /* __rtems__ */
2411
2412static u8 qman_cgr_cpus[CGR_NUM];
2413
2414void qman_init_cgr_all(void)
2415{
2416        struct qman_cgr cgr;
2417        int err_cnt = 0;
2418
2419        for (cgr.cgrid = 0; cgr.cgrid < CGR_NUM; cgr.cgrid++) {
2420                if (qm_modify_cgr(&cgr, QMAN_CGR_FLAG_USE_INIT, NULL))
2421                        err_cnt++;
2422        }
2423
2424        if (err_cnt)
2425                pr_err("Warning: %d error%s while initialising CGR h/w\n",
2426                       err_cnt, (err_cnt > 1) ? "s" : "");
2427}
2428
2429int qman_create_cgr(struct qman_cgr *cgr, u32 flags,
2430                    struct qm_mcc_initcgr *opts)
2431{
2432        struct qm_mcr_querycgr cgr_state;
2433        int ret;
2434        struct qman_portal *p;
2435
2436        /*
2437         * We have to check that the provided CGRID is within the limits of the
2438         * data-structures, for obvious reasons. However we'll let h/w take
2439         * care of determining whether it's within the limits of what exists on
2440         * the SoC.
2441         */
2442        if (cgr->cgrid >= CGR_NUM)
2443                return -EINVAL;
2444
2445        preempt_disable();
2446        p = get_affine_portal();
2447        qman_cgr_cpus[cgr->cgrid] = smp_processor_id();
2448        preempt_enable();
2449
2450        cgr->chan = p->config->channel;
2451        spin_lock(&p->cgr_lock);
2452
2453        if (opts) {
2454                struct qm_mcc_initcgr local_opts = *opts;
2455
2456                ret = qman_query_cgr(cgr, &cgr_state);
2457                if (ret)
2458                        goto out;
2459
2460                qm_cgr_cscn_targ_set(&local_opts.cgr, PORTAL_IDX(p),
2461                                     be32_to_cpu(cgr_state.cgr.cscn_targ));
2462                local_opts.we_mask |= cpu_to_be16(QM_CGR_WE_CSCN_TARG);
2463
2464                /* send init if flags indicate so */
2465                if (flags & QMAN_CGR_FLAG_USE_INIT)
2466                        ret = qm_modify_cgr(cgr, QMAN_CGR_FLAG_USE_INIT,
2467                                            &local_opts);
2468                else
2469                        ret = qm_modify_cgr(cgr, 0, &local_opts);
2470                if (ret)
2471                        goto out;
2472        }
2473
2474        list_add(&cgr->node, &p->cgr_cbs);
2475
2476        /* Determine if newly added object requires its callback to be called */
2477        ret = qman_query_cgr(cgr, &cgr_state);
2478        if (ret) {
2479                /* we can't go back, so proceed and return success */
2480                dev_err(p->config->dev, "CGR HW state partially modified\n");
2481                ret = 0;
2482                goto out;
2483        }
2484        if (cgr->cb && cgr_state.cgr.cscn_en &&
2485            qman_cgrs_get(&p->cgrs[1], cgr->cgrid))
2486                cgr->cb(p, cgr, 1);
2487out:
2488        spin_unlock(&p->cgr_lock);
2489        put_affine_portal();
2490        return ret;
2491}
2492EXPORT_SYMBOL(qman_create_cgr);
2493
2494#ifndef __rtems__
2495int qman_delete_cgr(struct qman_cgr *cgr)
2496{
2497        unsigned long irqflags;
2498        struct qm_mcr_querycgr cgr_state;
2499        struct qm_mcc_initcgr local_opts;
2500        int ret = 0;
2501        struct qman_cgr *i;
2502        struct qman_portal *p = get_affine_portal();
2503
2504        if (cgr->chan != p->config->channel) {
2505                /* attempt to delete from other portal than creator */
2506                dev_err(p->config->dev, "CGR not owned by current portal");
2507                dev_dbg(p->config->dev, " create 0x%x, delete 0x%x\n",
2508                        cgr->chan, p->config->channel);
2509
2510                ret = -EINVAL;
2511                goto put_portal;
2512        }
2513        memset(&local_opts, 0, sizeof(struct qm_mcc_initcgr));
2514        spin_lock_irqsave(&p->cgr_lock, irqflags);
2515        list_del(&cgr->node);
2516        /*
2517         * If there are no other CGR objects for this CGRID in the list,
2518         * update CSCN_TARG accordingly
2519         */
2520        list_for_each_entry(i, &p->cgr_cbs, node)
2521                if (i->cgrid == cgr->cgrid && i->cb)
2522                        goto release_lock;
2523        ret = qman_query_cgr(cgr, &cgr_state);
2524        if (ret)  {
2525                /* add back to the list */
2526                list_add(&cgr->node, &p->cgr_cbs);
2527                goto release_lock;
2528        }
2529
2530        local_opts.we_mask = cpu_to_be16(QM_CGR_WE_CSCN_TARG);
2531        qm_cgr_cscn_targ_clear(&local_opts.cgr, PORTAL_IDX(p),
2532                               be32_to_cpu(cgr_state.cgr.cscn_targ));
2533
2534        ret = qm_modify_cgr(cgr, 0, &local_opts);
2535        if (ret)
2536                /* add back to the list */
2537                list_add(&cgr->node, &p->cgr_cbs);
2538release_lock:
2539        spin_unlock_irqrestore(&p->cgr_lock, irqflags);
2540put_portal:
2541        put_affine_portal();
2542        return ret;
2543}
2544EXPORT_SYMBOL(qman_delete_cgr);
2545
2546struct cgr_comp {
2547        struct qman_cgr *cgr;
2548        struct completion completion;
2549};
2550
2551static int qman_delete_cgr_thread(void *p)
2552{
2553        struct cgr_comp *cgr_comp = (struct cgr_comp *)p;
2554        int ret;
2555
2556        ret = qman_delete_cgr(cgr_comp->cgr);
2557        complete(&cgr_comp->completion);
2558
2559        return ret;
2560}
2561
2562void qman_delete_cgr_safe(struct qman_cgr *cgr)
2563{
2564        struct task_struct *thread;
2565        struct cgr_comp cgr_comp;
2566
2567        preempt_disable();
2568        if (qman_cgr_cpus[cgr->cgrid] != smp_processor_id()) {
2569                init_completion(&cgr_comp.completion);
2570                cgr_comp.cgr = cgr;
2571                thread = kthread_create(qman_delete_cgr_thread, &cgr_comp,
2572                                        "cgr_del");
2573
2574                if (IS_ERR(thread))
2575                        goto out;
2576
2577                kthread_bind(thread, qman_cgr_cpus[cgr->cgrid]);
2578                wake_up_process(thread);
2579                wait_for_completion(&cgr_comp.completion);
2580                preempt_enable();
2581                return;
2582        }
2583out:
2584        qman_delete_cgr(cgr);
2585        preempt_enable();
2586}
2587EXPORT_SYMBOL(qman_delete_cgr_safe);
2588#endif /* __rtems__ */
2589
2590/* Cleanup FQs */
2591
2592static int _qm_mr_consume_and_match_verb(struct qm_portal *p, int v)
2593{
2594        const union qm_mr_entry *msg;
2595        int found = 0;
2596
2597        qm_mr_pvb_update(p);
2598        msg = qm_mr_current(p);
2599        while (msg) {
2600                if ((msg->verb & QM_MR_VERB_TYPE_MASK) == v)
2601                        found = 1;
2602                qm_mr_next(p);
2603                qm_mr_cci_consume_to_current(p);
2604                qm_mr_pvb_update(p);
2605                msg = qm_mr_current(p);
2606        }
2607        return found;
2608}
2609
2610static int _qm_dqrr_consume_and_match(struct qm_portal *p, u32 fqid, int s,
2611                                      bool wait)
2612{
2613        const struct qm_dqrr_entry *dqrr;
2614        int found = 0;
2615
2616        do {
2617                qm_dqrr_pvb_update(p);
2618                dqrr = qm_dqrr_current(p);
2619                if (!dqrr)
2620                        cpu_relax();
2621        } while (wait && !dqrr);
2622
2623        while (dqrr) {
2624                if (qm_fqid_get(dqrr) == fqid && (dqrr->stat & s))
2625                        found = 1;
2626                qm_dqrr_cdc_consume_1ptr(p, dqrr, 0);
2627                qm_dqrr_pvb_update(p);
2628                qm_dqrr_next(p);
2629                dqrr = qm_dqrr_current(p);
2630        }
2631        return found;
2632}
2633
2634#define qm_mr_drain(p, V) \
2635        _qm_mr_consume_and_match_verb(p, QM_MR_VERB_##V)
2636
2637#define qm_dqrr_drain(p, f, S) \
2638        _qm_dqrr_consume_and_match(p, f, QM_DQRR_STAT_##S, false)
2639
2640#define qm_dqrr_drain_wait(p, f, S) \
2641        _qm_dqrr_consume_and_match(p, f, QM_DQRR_STAT_##S, true)
2642
2643#define qm_dqrr_drain_nomatch(p) \
2644        _qm_dqrr_consume_and_match(p, 0, 0, false)
2645
2646static int qman_shutdown_fq(u32 fqid)
2647{
2648        struct qman_portal *p;
2649#ifndef __rtems__
2650        struct device *dev;
2651#endif /* __rtems__ */
2652        union qm_mc_command *mcc;
2653        union qm_mc_result *mcr;
2654        int orl_empty, drain = 0, ret = 0;
2655        u32 channel, wq, res;
2656        u8 state;
2657
2658        p = get_affine_portal();
2659#ifndef __rtems__
2660        dev = p->config->dev;
2661#endif /* __rtems__ */
2662        /* Determine the state of the FQID */
2663        mcc = qm_mc_start(&p->p);
2664        qm_fqid_set(&mcc->fq, fqid);
2665        qm_mc_commit(&p->p, QM_MCC_VERB_QUERYFQ_NP);
2666        if (!qm_mc_result_timeout(&p->p, &mcr)) {
2667                dev_err(dev, "QUERYFQ_NP timeout\n");
2668                ret = -ETIMEDOUT;
2669                goto out;
2670        }
2671
2672        DPAA_ASSERT((mcr->verb & QM_MCR_VERB_MASK) == QM_MCR_VERB_QUERYFQ_NP);
2673        state = mcr->queryfq_np.state & QM_MCR_NP_STATE_MASK;
2674        if (state == QM_MCR_NP_STATE_OOS)
2675                goto out; /* Already OOS, no need to do anymore checks */
2676
2677        /* Query which channel the FQ is using */
2678        mcc = qm_mc_start(&p->p);
2679        qm_fqid_set(&mcc->fq, fqid);
2680        qm_mc_commit(&p->p, QM_MCC_VERB_QUERYFQ);
2681        if (!qm_mc_result_timeout(&p->p, &mcr)) {
2682                dev_err(dev, "QUERYFQ timeout\n");
2683                ret = -ETIMEDOUT;
2684                goto out;
2685        }
2686
2687        DPAA_ASSERT((mcr->verb & QM_MCR_VERB_MASK) == QM_MCR_VERB_QUERYFQ);
2688        /* Need to store these since the MCR gets reused */
2689        channel = qm_fqd_get_chan(&mcr->queryfq.fqd);
2690        wq = qm_fqd_get_wq(&mcr->queryfq.fqd);
2691
2692        switch (state) {
2693        case QM_MCR_NP_STATE_TEN_SCHED:
2694        case QM_MCR_NP_STATE_TRU_SCHED:
2695        case QM_MCR_NP_STATE_ACTIVE:
2696        case QM_MCR_NP_STATE_PARKED:
2697                orl_empty = 0;
2698                mcc = qm_mc_start(&p->p);
2699                qm_fqid_set(&mcc->fq, fqid);
2700                qm_mc_commit(&p->p, QM_MCC_VERB_ALTER_RETIRE);
2701                if (!qm_mc_result_timeout(&p->p, &mcr)) {
2702                        dev_err(dev, "QUERYFQ_NP timeout\n");
2703                        ret = -ETIMEDOUT;
2704                        goto out;
2705                }
2706                DPAA_ASSERT((mcr->verb & QM_MCR_VERB_MASK) ==
2707                            QM_MCR_VERB_ALTER_RETIRE);
2708                res = mcr->result; /* Make a copy as we reuse MCR below */
2709
2710                if (res == QM_MCR_RESULT_PENDING) {
2711                        /*
2712                         * Need to wait for the FQRN in the message ring, which
2713                         * will only occur once the FQ has been drained.  In
2714                         * order for the FQ to drain the portal needs to be set
2715                         * to dequeue from the channel the FQ is scheduled on
2716                         */
2717                        int found_fqrn = 0;
2718                        u16 dequeue_wq = 0;
2719
2720                        /* Flag that we need to drain FQ */
2721                        drain = 1;
2722
2723                        if (channel >= qm_channel_pool1 &&
2724                            channel < qm_channel_pool1 + 15) {
2725                                /* Pool channel, enable the bit in the portal */
2726                                dequeue_wq = (channel -
2727                                              qm_channel_pool1 + 1)<<4 | wq;
2728                        } else if (channel < qm_channel_pool1) {
2729                                /* Dedicated channel */
2730                                dequeue_wq = wq;
2731                        } else {
2732                                dev_err(dev, "Can't recover FQ 0x%x, ch: 0x%x",
2733                                        fqid, channel);
2734                                ret = -EBUSY;
2735                                goto out;
2736                        }
2737#ifdef __rtems__
2738                        (void)dequeue_wq;
2739#endif /* __rtems__ */
2740                        /* Set the sdqcr to drain this channel */
2741                        if (channel < qm_channel_pool1)
2742                                qm_dqrr_sdqcr_set(&p->p,
2743                                                  QM_SDQCR_TYPE_ACTIVE |
2744                                                  QM_SDQCR_CHANNELS_DEDICATED);
2745                        else
2746                                qm_dqrr_sdqcr_set(&p->p,
2747                                                  QM_SDQCR_TYPE_ACTIVE |
2748                                                  QM_SDQCR_CHANNELS_POOL_CONV
2749                                                  (channel));
2750                        do {
2751                                /* Keep draining DQRR while checking the MR*/
2752                                qm_dqrr_drain_nomatch(&p->p);
2753                                /* Process message ring too */
2754                                found_fqrn = qm_mr_drain(&p->p, FQRN);
2755                                cpu_relax();
2756                        } while (!found_fqrn);
2757
2758                }
2759                if (res != QM_MCR_RESULT_OK &&
2760                    res != QM_MCR_RESULT_PENDING) {
2761                        dev_err(dev, "retire_fq failed: FQ 0x%x, res=0x%x\n",
2762                                fqid, res);
2763                        ret = -EIO;
2764                        goto out;
2765                }
2766                if (!(mcr->alterfq.fqs & QM_MCR_FQS_ORLPRESENT)) {
2767                        /*
2768                         * ORL had no entries, no need to wait until the
2769                         * ERNs come in
2770                         */
2771                        orl_empty = 1;
2772                }
2773                /*
2774                 * Retirement succeeded, check to see if FQ needs
2775                 * to be drained
2776                 */
2777                if (drain || mcr->alterfq.fqs & QM_MCR_FQS_NOTEMPTY) {
2778                        /* FQ is Not Empty, drain using volatile DQ commands */
2779                        do {
2780                                u32 vdqcr = fqid | QM_VDQCR_NUMFRAMES_SET(3);
2781
2782                                qm_dqrr_vdqcr_set(&p->p, vdqcr);
2783                                /*
2784                                 * Wait for a dequeue and process the dequeues,
2785                                 * making sure to empty the ring completely
2786                                 */
2787                        } while (qm_dqrr_drain_wait(&p->p, fqid, FQ_EMPTY));
2788                }
2789                qm_dqrr_sdqcr_set(&p->p, 0);
2790
2791                while (!orl_empty) {
2792                        /* Wait for the ORL to have been completely drained */
2793                        orl_empty = qm_mr_drain(&p->p, FQRL);
2794                        cpu_relax();
2795                }
2796                mcc = qm_mc_start(&p->p);
2797                qm_fqid_set(&mcc->fq, fqid);
2798                qm_mc_commit(&p->p, QM_MCC_VERB_ALTER_OOS);
2799                if (!qm_mc_result_timeout(&p->p, &mcr)) {
2800                        ret = -ETIMEDOUT;
2801                        goto out;
2802                }
2803
2804                DPAA_ASSERT((mcr->verb & QM_MCR_VERB_MASK) ==
2805                            QM_MCR_VERB_ALTER_OOS);
2806                if (mcr->result != QM_MCR_RESULT_OK) {
2807                        dev_err(dev, "OOS after drain fail: FQ 0x%x (0x%x)\n",
2808                                fqid, mcr->result);
2809                        ret = -EIO;
2810                        goto out;
2811                }
2812                break;
2813
2814        case QM_MCR_NP_STATE_RETIRED:
2815                /* Send OOS Command */
2816                mcc = qm_mc_start(&p->p);
2817                qm_fqid_set(&mcc->fq, fqid);
2818                qm_mc_commit(&p->p, QM_MCC_VERB_ALTER_OOS);
2819                if (!qm_mc_result_timeout(&p->p, &mcr)) {
2820                        ret = -ETIMEDOUT;
2821                        goto out;
2822                }
2823
2824                DPAA_ASSERT((mcr->verb & QM_MCR_VERB_MASK) ==
2825                            QM_MCR_VERB_ALTER_OOS);
2826                if (mcr->result) {
2827                        dev_err(dev, "OOS fail: FQ 0x%x (0x%x)\n",
2828                                fqid, mcr->result);
2829                        ret = -EIO;
2830                        goto out;
2831                }
2832                break;
2833
2834        case QM_MCR_NP_STATE_OOS:
2835                /*  Done */
2836                break;
2837
2838        default:
2839                ret = -EIO;
2840        }
2841
2842out:
2843        put_affine_portal();
2844        return ret;
2845}
2846
2847const struct qm_portal_config *qman_get_qm_portal_config(
2848                                                struct qman_portal *portal)
2849{
2850        return portal->config;
2851}
2852EXPORT_SYMBOL(qman_get_qm_portal_config);
2853
2854struct gen_pool *qm_fqalloc; /* FQID allocator */
2855struct gen_pool *qm_qpalloc; /* pool-channel allocator */
2856struct gen_pool *qm_cgralloc; /* CGR ID allocator */
2857
2858static int qman_alloc_range(struct gen_pool *p, u32 *result, u32 cnt)
2859{
2860        unsigned long addr;
2861
2862        addr = gen_pool_alloc(p, cnt);
2863        if (!addr)
2864                return -ENOMEM;
2865
2866        *result = addr & ~DPAA_GENALLOC_OFF;
2867
2868        return 0;
2869}
2870
2871int qman_alloc_fqid_range(u32 *result, u32 count)
2872{
2873        return qman_alloc_range(qm_fqalloc, result, count);
2874}
2875EXPORT_SYMBOL(qman_alloc_fqid_range);
2876
2877int qman_alloc_pool_range(u32 *result, u32 count)
2878{
2879        return qman_alloc_range(qm_qpalloc, result, count);
2880}
2881EXPORT_SYMBOL(qman_alloc_pool_range);
2882
2883int qman_alloc_cgrid_range(u32 *result, u32 count)
2884{
2885        return qman_alloc_range(qm_cgralloc, result, count);
2886}
2887EXPORT_SYMBOL(qman_alloc_cgrid_range);
2888
2889int qman_release_fqid(u32 fqid)
2890{
2891        int ret = qman_shutdown_fq(fqid);
2892
2893        if (ret) {
2894                pr_debug("FQID %d leaked\n", fqid);
2895                return ret;
2896        }
2897
2898        gen_pool_free(qm_fqalloc, fqid | DPAA_GENALLOC_OFF, 1);
2899        return 0;
2900}
2901EXPORT_SYMBOL(qman_release_fqid);
2902
2903static int qpool_cleanup(u32 qp)
2904{
2905        /*
2906         * We query all FQDs starting from
2907         * FQID 1 until we get an "invalid FQID" error, looking for non-OOS FQDs
2908         * whose destination channel is the pool-channel being released.
2909         * When a non-OOS FQD is found we attempt to clean it up
2910         */
2911        struct qman_fq fq = {
2912                .fqid = QM_FQID_RANGE_START
2913        };
2914        int err;
2915
2916        do {
2917                struct qm_mcr_queryfq_np np;
2918
2919                err = qman_query_fq_np(&fq, &np);
2920                if (err == -ERANGE)
2921                        /* FQID range exceeded, found no problems */
2922                        return 0;
2923                else if (WARN_ON(err))
2924                        return err;
2925
2926                if ((np.state & QM_MCR_NP_STATE_MASK) != QM_MCR_NP_STATE_OOS) {
2927                        struct qm_fqd fqd;
2928
2929                        err = qman_query_fq(&fq, &fqd);
2930                        if (WARN_ON(err))
2931                                return err;
2932                        if (qm_fqd_get_chan(&fqd) == qp) {
2933                                /* The channel is the FQ's target, clean it */
2934                                err = qman_shutdown_fq(fq.fqid);
2935                                if (err)
2936                                        /*
2937                                         * Couldn't shut down the FQ
2938                                         * so the pool must be leaked
2939                                         */
2940                                        return err;
2941                        }
2942                }
2943                /* Move to the next FQID */
2944                fq.fqid++;
2945        } while (1);
2946}
2947
2948int qman_release_pool(u32 qp)
2949{
2950        int ret;
2951
2952        ret = qpool_cleanup(qp);
2953        if (ret) {
2954                pr_debug("CHID %d leaked\n", qp);
2955                return ret;
2956        }
2957
2958        gen_pool_free(qm_qpalloc, qp | DPAA_GENALLOC_OFF, 1);
2959        return 0;
2960}
2961EXPORT_SYMBOL(qman_release_pool);
2962
2963static int cgr_cleanup(u32 cgrid)
2964{
2965        /*
2966         * query all FQDs starting from FQID 1 until we get an "invalid FQID"
2967         * error, looking for non-OOS FQDs whose CGR is the CGR being released
2968         */
2969        struct qman_fq fq = {
2970                .fqid = QM_FQID_RANGE_START
2971        };
2972        int err;
2973
2974        do {
2975                struct qm_mcr_queryfq_np np;
2976
2977                err = qman_query_fq_np(&fq, &np);
2978                if (err == -ERANGE)
2979                        /* FQID range exceeded, found no problems */
2980                        return 0;
2981                else if (WARN_ON(err))
2982                        return err;
2983
2984                if ((np.state & QM_MCR_NP_STATE_MASK) != QM_MCR_NP_STATE_OOS) {
2985                        struct qm_fqd fqd;
2986
2987                        err = qman_query_fq(&fq, &fqd);
2988                        if (WARN_ON(err))
2989                                return err;
2990                        if (be16_to_cpu(fqd.fq_ctrl) & QM_FQCTRL_CGE &&
2991                            fqd.cgid == cgrid) {
2992                                pr_err("CRGID 0x%x is being used by FQID 0x%x, CGR will be leaked\n",
2993                                       cgrid, fq.fqid);
2994                                return -EIO;
2995                        }
2996                }
2997                /* Move to the next FQID */
2998                fq.fqid++;
2999        } while (1);
3000}
3001
3002int qman_release_cgrid(u32 cgrid)
3003{
3004        int ret;
3005
3006        ret = cgr_cleanup(cgrid);
3007        if (ret) {
3008                pr_debug("CGRID %d leaked\n", cgrid);
3009                return ret;
3010        }
3011
3012        gen_pool_free(qm_cgralloc, cgrid | DPAA_GENALLOC_OFF, 1);
3013        return 0;
3014}
3015EXPORT_SYMBOL(qman_release_cgrid);
Note: See TracBrowser for help on using the repository browser.