Merge branch 'master' of git://www.denx.de/git/u-boot-socfpga
[oweals/u-boot.git] / drivers / net / fsl-mc / dpio / qbman_portal.c
1 /*
2  * Copyright (C) 2014 Freescale Semiconductor
3  *
4  * SPDX-License-Identifier:     GPL-2.0+
5  */
6
7 #include "qbman_portal.h"
8
9 /* QBMan portal management command codes */
10 #define QBMAN_MC_ACQUIRE       0x30
11 #define QBMAN_WQCHAN_CONFIGURE 0x46
12
13 /* CINH register offsets */
14 #define QBMAN_CINH_SWP_EQAR    0x8c0
15 #define QBMAN_CINH_SWP_DCAP    0xac0
16 #define QBMAN_CINH_SWP_SDQCR   0xb00
17 #define QBMAN_CINH_SWP_RAR     0xcc0
18
19 /* CENA register offsets */
20 #define QBMAN_CENA_SWP_EQCR(n) (0x000 + ((uint32_t)(n) << 6))
21 #define QBMAN_CENA_SWP_DQRR(n) (0x200 + ((uint32_t)(n) << 6))
22 #define QBMAN_CENA_SWP_RCR(n)  (0x400 + ((uint32_t)(n) << 6))
23 #define QBMAN_CENA_SWP_CR      0x600
24 #define QBMAN_CENA_SWP_RR(vb)  (0x700 + ((uint32_t)(vb) >> 1))
25 #define QBMAN_CENA_SWP_VDQCR   0x780
26
27 /* Reverse mapping of QBMAN_CENA_SWP_DQRR() */
28 #define QBMAN_IDX_FROM_DQRR(p) (((unsigned long)p & 0xff) >> 6)
29
30 /*******************************/
31 /* Pre-defined attribute codes */
32 /*******************************/
33
34 struct qb_attr_code code_generic_verb = QB_CODE(0, 0, 7);
35 struct qb_attr_code code_generic_rslt = QB_CODE(0, 8, 8);
36
37 /*************************/
38 /* SDQCR attribute codes */
39 /*************************/
40
41 /* we put these here because at least some of them are required by
42  * qbman_swp_init() */
43 struct qb_attr_code code_sdqcr_dct = QB_CODE(0, 24, 2);
44 struct qb_attr_code code_sdqcr_fc = QB_CODE(0, 29, 1);
45 struct qb_attr_code code_sdqcr_tok = QB_CODE(0, 16, 8);
46 #define CODE_SDQCR_DQSRC(n) QB_CODE(0, n, 1)
47 enum qbman_sdqcr_dct {
48         qbman_sdqcr_dct_null = 0,
49         qbman_sdqcr_dct_prio_ics,
50         qbman_sdqcr_dct_active_ics,
51         qbman_sdqcr_dct_active
52 };
53 enum qbman_sdqcr_fc {
54         qbman_sdqcr_fc_one = 0,
55         qbman_sdqcr_fc_up_to_3 = 1
56 };
57
58 /*********************************/
59 /* Portal constructor/destructor */
60 /*********************************/
61
62 /* Software portals should always be in the power-on state when we initialise,
63  * due to the CCSR-based portal reset functionality that MC has. */
64 struct qbman_swp *qbman_swp_init(const struct qbman_swp_desc *d)
65 {
66         int ret;
67         struct qbman_swp *p = kmalloc(sizeof(*p), GFP_KERNEL);
68
69         if (!p)
70                 return NULL;
71         p->desc = d;
72 #ifdef QBMAN_CHECKING
73         p->mc.check = swp_mc_can_start;
74 #endif
75         p->mc.valid_bit = QB_VALID_BIT;
76         p->sdq = 0;
77         qb_attr_code_encode(&code_sdqcr_dct, &p->sdq, qbman_sdqcr_dct_prio_ics);
78         qb_attr_code_encode(&code_sdqcr_fc, &p->sdq, qbman_sdqcr_fc_up_to_3);
79         qb_attr_code_encode(&code_sdqcr_tok, &p->sdq, 0xbb);
80         p->vdq.busy = 0; /* TODO: convert to atomic_t */
81         p->vdq.valid_bit = QB_VALID_BIT;
82         p->dqrr.next_idx = 0;
83         p->dqrr.valid_bit = QB_VALID_BIT;
84         ret = qbman_swp_sys_init(&p->sys, d);
85         if (ret) {
86                 free(p);
87                 printf("qbman_swp_sys_init() failed %d\n", ret);
88                 return NULL;
89         }
90         qbman_cinh_write(&p->sys, QBMAN_CINH_SWP_SDQCR, p->sdq);
91         return p;
92 }
93
94 /***********************/
95 /* Management commands */
96 /***********************/
97
98 /*
99  * Internal code common to all types of management commands.
100  */
101
102 void *qbman_swp_mc_start(struct qbman_swp *p)
103 {
104         void *ret;
105 #ifdef QBMAN_CHECKING
106         BUG_ON(p->mc.check != swp_mc_can_start);
107 #endif
108         ret = qbman_cena_write_start(&p->sys, QBMAN_CENA_SWP_CR);
109 #ifdef QBMAN_CHECKING
110         if (!ret)
111                 p->mc.check = swp_mc_can_submit;
112 #endif
113         return ret;
114 }
115
116 void qbman_swp_mc_submit(struct qbman_swp *p, void *cmd, uint32_t cmd_verb)
117 {
118         uint32_t *v = cmd;
119 #ifdef QBMAN_CHECKING
120         BUG_ON(!p->mc.check != swp_mc_can_submit);
121 #endif
122         lwsync();
123         /* TBD: "|=" is going to hurt performance. Need to move as many fields
124          * out of word zero, and for those that remain, the "OR" needs to occur
125          * at the caller side. This debug check helps to catch cases where the
126          * caller wants to OR but has forgotten to do so. */
127         BUG_ON((*v & cmd_verb) != *v);
128         *v = cmd_verb | p->mc.valid_bit;
129         qbman_cena_write_complete(&p->sys, QBMAN_CENA_SWP_CR, cmd);
130         /* TODO: add prefetch support for GPP */
131 #ifdef QBMAN_CHECKING
132         p->mc.check = swp_mc_can_poll;
133 #endif
134 }
135
136 void *qbman_swp_mc_result(struct qbman_swp *p)
137 {
138         uint32_t *ret, verb;
139 #ifdef QBMAN_CHECKING
140         BUG_ON(p->mc.check != swp_mc_can_poll);
141 #endif
142         ret = qbman_cena_read(&p->sys, QBMAN_CENA_SWP_RR(p->mc.valid_bit));
143         /* Remove the valid-bit - command completed iff the rest is non-zero */
144         verb = ret[0] & ~QB_VALID_BIT;
145         if (!verb)
146                 return NULL;
147 #ifdef QBMAN_CHECKING
148         p->mc.check = swp_mc_can_start;
149 #endif
150         p->mc.valid_bit ^= QB_VALID_BIT;
151         return ret;
152 }
153
154 /***********/
155 /* Enqueue */
156 /***********/
157
158 /* These should be const, eventually */
159 static struct qb_attr_code code_eq_cmd = QB_CODE(0, 0, 2);
160 static struct qb_attr_code code_eq_orp_en = QB_CODE(0, 2, 1);
161 static struct qb_attr_code code_eq_tgt_id = QB_CODE(2, 0, 24);
162 /* static struct qb_attr_code code_eq_tag = QB_CODE(3, 0, 32); */
163 static struct qb_attr_code code_eq_qd_en = QB_CODE(0, 4, 1);
164 static struct qb_attr_code code_eq_qd_bin = QB_CODE(4, 0, 16);
165 static struct qb_attr_code code_eq_qd_pri = QB_CODE(4, 16, 4);
166 static struct qb_attr_code code_eq_rsp_stash = QB_CODE(5, 16, 1);
167 static struct qb_attr_code code_eq_rsp_lo = QB_CODE(6, 0, 32);
168 static struct qb_attr_code code_eq_rsp_hi = QB_CODE(7, 0, 32);
169
170 enum qbman_eq_cmd_e {
171         /* No enqueue, primarily for plugging ORP gaps for dropped frames */
172         qbman_eq_cmd_empty,
173         /* DMA an enqueue response once complete */
174         qbman_eq_cmd_respond,
175         /* DMA an enqueue response only if the enqueue fails */
176         qbman_eq_cmd_respond_reject
177 };
178
179 void qbman_eq_desc_clear(struct qbman_eq_desc *d)
180 {
181         memset(d, 0, sizeof(*d));
182 }
183
184 void qbman_eq_desc_set_no_orp(struct qbman_eq_desc *d, int respond_success)
185 {
186         uint32_t *cl = qb_cl(d);
187
188         qb_attr_code_encode(&code_eq_orp_en, cl, 0);
189         qb_attr_code_encode(&code_eq_cmd, cl,
190                             respond_success ? qbman_eq_cmd_respond :
191                                               qbman_eq_cmd_respond_reject);
192 }
193
194 void qbman_eq_desc_set_response(struct qbman_eq_desc *d,
195                                 dma_addr_t storage_phys,
196                                 int stash)
197 {
198         uint32_t *cl = qb_cl(d);
199
200         qb_attr_code_encode(&code_eq_rsp_lo, cl, lower32(storage_phys));
201         qb_attr_code_encode(&code_eq_rsp_hi, cl, upper32(storage_phys));
202         qb_attr_code_encode(&code_eq_rsp_stash, cl, !!stash);
203 }
204
205
206 void qbman_eq_desc_set_qd(struct qbman_eq_desc *d, uint32_t qdid,
207                           uint32_t qd_bin, uint32_t qd_prio)
208 {
209         uint32_t *cl = qb_cl(d);
210
211         qb_attr_code_encode(&code_eq_qd_en, cl, 1);
212         qb_attr_code_encode(&code_eq_tgt_id, cl, qdid);
213         qb_attr_code_encode(&code_eq_qd_bin, cl, qd_bin);
214         qb_attr_code_encode(&code_eq_qd_pri, cl, qd_prio);
215 }
216
217 #define EQAR_IDX(eqar)     ((eqar) & 0x7)
218 #define EQAR_VB(eqar)      ((eqar) & 0x80)
219 #define EQAR_SUCCESS(eqar) ((eqar) & 0x100)
220
221 int qbman_swp_enqueue(struct qbman_swp *s, const struct qbman_eq_desc *d,
222                       const struct qbman_fd *fd)
223 {
224         uint32_t *p;
225         const uint32_t *cl = qb_cl(d);
226         uint32_t eqar = qbman_cinh_read(&s->sys, QBMAN_CINH_SWP_EQAR);
227         debug("EQAR=%08x\n", eqar);
228         if (!EQAR_SUCCESS(eqar))
229                 return -EBUSY;
230         p = qbman_cena_write_start(&s->sys,
231                                    QBMAN_CENA_SWP_EQCR(EQAR_IDX(eqar)));
232         word_copy(&p[1], &cl[1], 7);
233         word_copy(&p[8], fd, sizeof(*fd) >> 2);
234         lwsync();
235         /* Set the verb byte, have to substitute in the valid-bit */
236         p[0] = cl[0] | EQAR_VB(eqar);
237         qbman_cena_write_complete(&s->sys,
238                                   QBMAN_CENA_SWP_EQCR(EQAR_IDX(eqar)),
239                                   p);
240         return 0;
241 }
242
243 /***************************/
244 /* Volatile (pull) dequeue */
245 /***************************/
246
247 /* These should be const, eventually */
248 static struct qb_attr_code code_pull_dct = QB_CODE(0, 0, 2);
249 static struct qb_attr_code code_pull_dt = QB_CODE(0, 2, 2);
250 static struct qb_attr_code code_pull_rls = QB_CODE(0, 4, 1);
251 static struct qb_attr_code code_pull_stash = QB_CODE(0, 5, 1);
252 static struct qb_attr_code code_pull_numframes = QB_CODE(0, 8, 4);
253 static struct qb_attr_code code_pull_token = QB_CODE(0, 16, 8);
254 static struct qb_attr_code code_pull_dqsource = QB_CODE(1, 0, 24);
255 static struct qb_attr_code code_pull_rsp_lo = QB_CODE(2, 0, 32);
256 static struct qb_attr_code code_pull_rsp_hi = QB_CODE(3, 0, 32);
257
258 enum qb_pull_dt_e {
259         qb_pull_dt_channel,
260         qb_pull_dt_workqueue,
261         qb_pull_dt_framequeue
262 };
263
264 void qbman_pull_desc_clear(struct qbman_pull_desc *d)
265 {
266         memset(d, 0, sizeof(*d));
267 }
268
269 void qbman_pull_desc_set_storage(struct qbman_pull_desc *d,
270                                  struct ldpaa_dq *storage,
271                                  dma_addr_t storage_phys,
272                                  int stash)
273 {
274         uint32_t *cl = qb_cl(d);
275
276         /* Squiggle the pointer 'storage' into the extra 2 words of the
277          * descriptor (which aren't copied to the hw command) */
278         *(void **)&cl[4] = storage;
279         if (!storage) {
280                 qb_attr_code_encode(&code_pull_rls, cl, 0);
281                 return;
282         }
283         qb_attr_code_encode(&code_pull_rls, cl, 1);
284         qb_attr_code_encode(&code_pull_stash, cl, !!stash);
285         qb_attr_code_encode(&code_pull_rsp_lo, cl, lower32(storage_phys));
286         qb_attr_code_encode(&code_pull_rsp_hi, cl, upper32(storage_phys));
287 }
288
289 void qbman_pull_desc_set_numframes(struct qbman_pull_desc *d, uint8_t numframes)
290 {
291         uint32_t *cl = qb_cl(d);
292
293         BUG_ON(!numframes || (numframes > 16));
294         qb_attr_code_encode(&code_pull_numframes, cl,
295                             (uint32_t)(numframes - 1));
296 }
297
298 void qbman_pull_desc_set_token(struct qbman_pull_desc *d, uint8_t token)
299 {
300         uint32_t *cl = qb_cl(d);
301
302         qb_attr_code_encode(&code_pull_token, cl, token);
303 }
304
305 void qbman_pull_desc_set_fq(struct qbman_pull_desc *d, uint32_t fqid)
306 {
307         uint32_t *cl = qb_cl(d);
308
309         qb_attr_code_encode(&code_pull_dct, cl, 1);
310         qb_attr_code_encode(&code_pull_dt, cl, qb_pull_dt_framequeue);
311         qb_attr_code_encode(&code_pull_dqsource, cl, fqid);
312 }
313
314 int qbman_swp_pull(struct qbman_swp *s, struct qbman_pull_desc *d)
315 {
316         uint32_t *p;
317         uint32_t *cl = qb_cl(d);
318
319         /* TODO: convert to atomic_t */
320         if (s->vdq.busy)
321                 return -EBUSY;
322         s->vdq.busy = 1;
323         s->vdq.storage = *(void **)&cl[4];
324         s->vdq.token = qb_attr_code_decode(&code_pull_token, cl);
325         p = qbman_cena_write_start(&s->sys, QBMAN_CENA_SWP_VDQCR);
326         word_copy(&p[1], &cl[1], 3);
327         lwsync();
328         /* Set the verb byte, have to substitute in the valid-bit */
329         p[0] = cl[0] | s->vdq.valid_bit;
330         s->vdq.valid_bit ^= QB_VALID_BIT;
331         qbman_cena_write_complete(&s->sys, QBMAN_CENA_SWP_VDQCR, p);
332         return 0;
333 }
334
335 /****************/
336 /* Polling DQRR */
337 /****************/
338
339 static struct qb_attr_code code_dqrr_verb = QB_CODE(0, 0, 8);
340 static struct qb_attr_code code_dqrr_response = QB_CODE(0, 0, 7);
341 static struct qb_attr_code code_dqrr_stat = QB_CODE(0, 8, 8);
342
343 #define QBMAN_DQRR_RESPONSE_DQ        0x60
344 #define QBMAN_DQRR_RESPONSE_FQRN      0x21
345 #define QBMAN_DQRR_RESPONSE_FQRNI     0x22
346 #define QBMAN_DQRR_RESPONSE_FQPN      0x24
347 #define QBMAN_DQRR_RESPONSE_FQDAN     0x25
348 #define QBMAN_DQRR_RESPONSE_CDAN      0x26
349 #define QBMAN_DQRR_RESPONSE_CSCN_MEM  0x27
350 #define QBMAN_DQRR_RESPONSE_CGCU      0x28
351 #define QBMAN_DQRR_RESPONSE_BPSCN     0x29
352 #define QBMAN_DQRR_RESPONSE_CSCN_WQ   0x2a
353
354
355 /* NULL return if there are no unconsumed DQRR entries. Returns a DQRR entry
356  * only once, so repeated calls can return a sequence of DQRR entries, without
357  * requiring they be consumed immediately or in any particular order. */
358 const struct ldpaa_dq *qbman_swp_dqrr_next(struct qbman_swp *s)
359 {
360         uint32_t verb;
361         uint32_t response_verb;
362         const struct ldpaa_dq *dq = qbman_cena_read(&s->sys,
363                                         QBMAN_CENA_SWP_DQRR(s->dqrr.next_idx));
364         const uint32_t *p = qb_cl(dq);
365
366         verb = qb_attr_code_decode(&code_dqrr_verb, p);
367         /* If the valid-bit isn't of the expected polarity, nothing there */
368         if ((verb & QB_VALID_BIT) != s->dqrr.valid_bit) {
369                 qbman_cena_invalidate_prefetch(&s->sys,
370                                                QBMAN_CENA_SWP_DQRR(
371                                                s->dqrr.next_idx));
372                 return NULL;
373         }
374         /* There's something there. Move "next_idx" attention to the next ring
375          * entry (and prefetch it) before returning what we found. */
376         s->dqrr.next_idx++;
377         s->dqrr.next_idx &= 3; /* Wrap around at 4 */
378         /* TODO: it's possible to do all this without conditionals, optimise it
379          * later. */
380         if (!s->dqrr.next_idx)
381                 s->dqrr.valid_bit ^= QB_VALID_BIT;
382         /* VDQCR "no longer busy" hook - if VDQCR shows "busy" and this is a
383          * VDQCR result, mark it as non-busy. */
384         if (s->vdq.busy) {
385                 uint32_t flags = ldpaa_dq_flags(dq);
386
387                 response_verb = qb_attr_code_decode(&code_dqrr_response, &verb);
388                 if ((response_verb == QBMAN_DQRR_RESPONSE_DQ) &&
389                     (flags & LDPAA_DQ_STAT_VOLATILE))
390                         s->vdq.busy = 0;
391         }
392         qbman_cena_invalidate_prefetch(&s->sys,
393                                        QBMAN_CENA_SWP_DQRR(s->dqrr.next_idx));
394         return dq;
395 }
396
397 /* Consume DQRR entries previously returned from qbman_swp_dqrr_next(). */
398 void qbman_swp_dqrr_consume(struct qbman_swp *s, const struct ldpaa_dq *dq)
399 {
400         qbman_cinh_write(&s->sys, QBMAN_CINH_SWP_DCAP, QBMAN_IDX_FROM_DQRR(dq));
401 }
402
403 /*********************************/
404 /* Polling user-provided storage */
405 /*********************************/
406
407 void qbman_dq_entry_set_oldtoken(struct ldpaa_dq *dq,
408                                  unsigned int num_entries,
409                                  uint8_t oldtoken)
410 {
411         memset(dq, oldtoken, num_entries * sizeof(*dq));
412 }
413
414 int qbman_dq_entry_has_newtoken(struct qbman_swp *s,
415                                 const struct ldpaa_dq *dq,
416                                 uint8_t newtoken)
417 {
418         /* To avoid converting the little-endian DQ entry to host-endian prior
419          * to us knowing whether there is a valid entry or not (and run the
420          * risk of corrupting the incoming hardware LE write), we detect in
421          * hardware endianness rather than host. This means we need a different
422          * "code" depending on whether we are BE or LE in software, which is
423          * where DQRR_TOK_OFFSET comes in... */
424         static struct qb_attr_code code_dqrr_tok_detect =
425                                         QB_CODE(0, DQRR_TOK_OFFSET, 8);
426         /* The user trying to poll for a result treats "dq" as const. It is
427          * however the same address that was provided to us non-const in the
428          * first place, for directing hardware DMA to. So we can cast away the
429          * const because it is mutable from our perspective. */
430         uint32_t *p = qb_cl((struct ldpaa_dq *)dq);
431         uint32_t token;
432
433         token = qb_attr_code_decode(&code_dqrr_tok_detect, &p[1]);
434         if (token != newtoken)
435                 return 0;
436
437         /* Only now do we convert from hardware to host endianness. Also, as we
438          * are returning success, the user has promised not to call us again, so
439          * there's no risk of us converting the endianness twice... */
440         make_le32_n(p, 16);
441
442         /* VDQCR "no longer busy" hook - not quite the same as DQRR, because the
443          * fact "VDQCR" shows busy doesn't mean that the result we're looking at
444          * is from the same command. Eg. we may be looking at our 10th dequeue
445          * result from our first VDQCR command, yet the second dequeue command
446          * could have been kicked off already, after seeing the 1st result. Ie.
447          * the result we're looking at is not necessarily proof that we can
448          * reset "busy".  We instead base the decision on whether the current
449          * result is sitting at the first 'storage' location of the busy
450          * command. */
451         if (s->vdq.busy && (s->vdq.storage == dq))
452                 s->vdq.busy = 0;
453         return 1;
454 }
455
456 /********************************/
457 /* Categorising dequeue entries */
458 /********************************/
459
460 static inline int __qbman_dq_entry_is_x(const struct ldpaa_dq *dq, uint32_t x)
461 {
462         const uint32_t *p = qb_cl(dq);
463         uint32_t response_verb = qb_attr_code_decode(&code_dqrr_response, p);
464
465         return response_verb == x;
466 }
467
468 int qbman_dq_entry_is_DQ(const struct ldpaa_dq *dq)
469 {
470         return __qbman_dq_entry_is_x(dq, QBMAN_DQRR_RESPONSE_DQ);
471 }
472
473 /*********************************/
474 /* Parsing frame dequeue results */
475 /*********************************/
476
477 /* These APIs assume qbman_dq_entry_is_DQ() is TRUE */
478
479 uint32_t ldpaa_dq_flags(const struct ldpaa_dq *dq)
480 {
481         const uint32_t *p = qb_cl(dq);
482
483         return qb_attr_code_decode(&code_dqrr_stat, p);
484 }
485
486 const struct dpaa_fd *ldpaa_dq_fd(const struct ldpaa_dq *dq)
487 {
488         const uint32_t *p = qb_cl(dq);
489
490         return (const struct dpaa_fd *)&p[8];
491 }
492
493 /******************/
494 /* Buffer release */
495 /******************/
496
497 /* These should be const, eventually */
498 /* static struct qb_attr_code code_release_num = QB_CODE(0, 0, 3); */
499 static struct qb_attr_code code_release_set_me = QB_CODE(0, 5, 1);
500 static struct qb_attr_code code_release_bpid = QB_CODE(0, 16, 16);
501
502 void qbman_release_desc_clear(struct qbman_release_desc *d)
503 {
504         uint32_t *cl;
505
506         memset(d, 0, sizeof(*d));
507         cl = qb_cl(d);
508         qb_attr_code_encode(&code_release_set_me, cl, 1);
509 }
510
511 void qbman_release_desc_set_bpid(struct qbman_release_desc *d, uint32_t bpid)
512 {
513         uint32_t *cl = qb_cl(d);
514
515         qb_attr_code_encode(&code_release_bpid, cl, bpid);
516 }
517
518 #define RAR_IDX(rar)     ((rar) & 0x7)
519 #define RAR_VB(rar)      ((rar) & 0x80)
520 #define RAR_SUCCESS(rar) ((rar) & 0x100)
521
522 int qbman_swp_release(struct qbman_swp *s, const struct qbman_release_desc *d,
523                       const uint64_t *buffers, unsigned int num_buffers)
524 {
525         uint32_t *p;
526         const uint32_t *cl = qb_cl(d);
527         uint32_t rar = qbman_cinh_read(&s->sys, QBMAN_CINH_SWP_RAR);
528         debug("RAR=%08x\n", rar);
529         if (!RAR_SUCCESS(rar))
530                 return -EBUSY;
531         BUG_ON(!num_buffers || (num_buffers > 7));
532         /* Start the release command */
533         p = qbman_cena_write_start(&s->sys,
534                                    QBMAN_CENA_SWP_RCR(RAR_IDX(rar)));
535         /* Copy the caller's buffer pointers to the command */
536         u64_to_le32_copy(&p[2], buffers, num_buffers);
537         lwsync();
538         /* Set the verb byte, have to substitute in the valid-bit and the number
539          * of buffers. */
540         p[0] = cl[0] | RAR_VB(rar) | num_buffers;
541         qbman_cena_write_complete(&s->sys,
542                                   QBMAN_CENA_SWP_RCR(RAR_IDX(rar)),
543                                   p);
544         return 0;
545 }
546
547 /*******************/
548 /* Buffer acquires */
549 /*******************/
550
551 /* These should be const, eventually */
552 static struct qb_attr_code code_acquire_bpid = QB_CODE(0, 16, 16);
553 static struct qb_attr_code code_acquire_num = QB_CODE(1, 0, 3);
554 static struct qb_attr_code code_acquire_r_num = QB_CODE(1, 0, 3);
555
556 int qbman_swp_acquire(struct qbman_swp *s, uint32_t bpid, uint64_t *buffers,
557                       unsigned int num_buffers)
558 {
559         uint32_t *p;
560         uint32_t verb, rslt, num;
561
562         BUG_ON(!num_buffers || (num_buffers > 7));
563
564         /* Start the management command */
565         p = qbman_swp_mc_start(s);
566
567         if (!p)
568                 return -EBUSY;
569
570         /* Encode the caller-provided attributes */
571         qb_attr_code_encode(&code_acquire_bpid, p, bpid);
572         qb_attr_code_encode(&code_acquire_num, p, num_buffers);
573
574         /* Complete the management command */
575         p = qbman_swp_mc_complete(s, p, p[0] | QBMAN_MC_ACQUIRE);
576
577         /* Decode the outcome */
578         verb = qb_attr_code_decode(&code_generic_verb, p);
579         rslt = qb_attr_code_decode(&code_generic_rslt, p);
580         num = qb_attr_code_decode(&code_acquire_r_num, p);
581         BUG_ON(verb != QBMAN_MC_ACQUIRE);
582
583         /* Determine success or failure */
584         if (unlikely(rslt != QBMAN_MC_RSLT_OK)) {
585                 printf("Acquire buffers from BPID 0x%x failed, code=0x%02x\n",
586                        bpid, rslt);
587                 return -EIO;
588         }
589         BUG_ON(num > num_buffers);
590         /* Copy the acquired buffers to the caller's array */
591         u64_from_le32_copy(buffers, &p[2], num);
592         return (int)num;
593 }