1 /* SPDX-License-Identifier: BSD-3-Clause
2 *
3 * Copyright (C) 2014 Freescale Semiconductor, Inc.
4 * Copyright 2015-2020 NXP
5 *
6 */
7 #ifndef _FSL_QBMAN_PORTAL_H
8 #define _FSL_QBMAN_PORTAL_H
9
10 #include <rte_compat.h>
11 #include <fsl_qbman_base.h>
12
13 #define SVR_LS1080A 0x87030000
14 #define SVR_LS2080A 0x87010000
15 #define SVR_LS2088A 0x87090000
16 #define SVR_LX2160A 0x87360000
17
18 /* Variable to store DPAA2 platform type */
19 extern uint32_t dpaa2_svr_family;
20
21 /**
22 * DOC - QBMan portal APIs to implement the following functions:
23 * - Initialize and destroy Software portal object.
24 * - Read and write Software portal interrupt registers.
25 * - Enqueue, including setting the enqueue descriptor, and issuing enqueue
26 * command etc.
27 * - Dequeue, including setting the dequeue descriptor, issuing dequeue command,
28 * parsing the dequeue response in DQRR and memory, parsing the state change
29 * notifications etc.
30 * - Release, including setting the release descriptor, and issuing the buffer
31 * release command.
32 * - Acquire, acquire the buffer from the given buffer pool.
33 * - FQ management.
34 * - Channel management, enable/disable CDAN with or without context.
35 */
36
37 /**
38 * qbman_swp_init() - Create a functional object representing the given
39 * QBMan portal descriptor.
40 * @d: the given qbman swp descriptor
41 *
42 * Return qbman_swp portal object for success, NULL if the object cannot
43 * be created.
44 */
45 struct qbman_swp *qbman_swp_init(const struct qbman_swp_desc *d);
46
47 /**
48 * qbman_swp_update() - Update portal cacheability attributes.
49 * @p: the given qbman swp portal
50 */
51 int qbman_swp_update(struct qbman_swp *p, int stash_off);
52
53 /**
54 * qbman_swp_finish() - Create and destroy a functional object representing
55 * the given QBMan portal descriptor.
56 * @p: the qbman_swp object to be destroyed.
57 *
58 */
59 void qbman_swp_finish(struct qbman_swp *p);
60
61 /**
62 * qbman_swp_invalidate() - Invalidate the cache enabled area of the QBMan
63 * portal. This is required to be called if a portal moved to another core
64 * because the QBMan portal area is non coherent
65 * @p: the qbman_swp object to be invalidated
66 *
67 */
68 void qbman_swp_invalidate(struct qbman_swp *p);
69
70 /**
71 * qbman_swp_get_desc() - Get the descriptor of the given portal object.
72 * @p: the given portal object.
73 *
74 * Return the descriptor for this portal.
75 */
76 const struct qbman_swp_desc *qbman_swp_get_desc(struct qbman_swp *p);
77
78 /**************/
79 /* Interrupts */
80 /**************/
81
82 /* EQCR ring interrupt */
83 #define QBMAN_SWP_INTERRUPT_EQRI ((uint32_t)0x00000001)
84 /* Enqueue command dispatched interrupt */
85 #define QBMAN_SWP_INTERRUPT_EQDI ((uint32_t)0x00000002)
86 /* DQRR non-empty interrupt */
87 #define QBMAN_SWP_INTERRUPT_DQRI ((uint32_t)0x00000004)
88 /* RCR ring interrupt */
89 #define QBMAN_SWP_INTERRUPT_RCRI ((uint32_t)0x00000008)
90 /* Release command dispatched interrupt */
91 #define QBMAN_SWP_INTERRUPT_RCDI ((uint32_t)0x00000010)
92 /* Volatile dequeue command interrupt */
93 #define QBMAN_SWP_INTERRUPT_VDCI ((uint32_t)0x00000020)
94
95 /**
96 * qbman_swp_interrupt_get_vanish() - Get the data in software portal
97 * interrupt status disable register.
98 * @p: the given software portal object.
99 *
100 * Return the settings in SWP_ISDR register.
101 */
102 uint32_t qbman_swp_interrupt_get_vanish(struct qbman_swp *p);
103
104 /**
105 * qbman_swp_interrupt_set_vanish() - Set the data in software portal
106 * interrupt status disable register.
107 * @p: the given software portal object.
108 * @mask: The value to set in SWP_IDSR register.
109 */
110 void qbman_swp_interrupt_set_vanish(struct qbman_swp *p, uint32_t mask);
111
112 /**
113 * qbman_swp_interrupt_read_status() - Get the data in software portal
114 * interrupt status register.
115 * @p: the given software portal object.
116 *
117 * Return the settings in SWP_ISR register.
118 */
119 uint32_t qbman_swp_interrupt_read_status(struct qbman_swp *p);
120
121 /**
122 * qbman_swp_interrupt_clear_status() - Set the data in software portal
123 * interrupt status register.
124 * @p: the given software portal object.
125 * @mask: The value to set in SWP_ISR register.
126 */
127 __rte_internal
128 void qbman_swp_interrupt_clear_status(struct qbman_swp *p, uint32_t mask);
129
130 /**
131 * qbman_swp_dqrr_thrshld_read_status() - Get the data in software portal
132 * DQRR interrupt threshold register.
133 * @p: the given software portal object.
134 */
135 uint32_t qbman_swp_dqrr_thrshld_read_status(struct qbman_swp *p);
136
137 /**
138 * qbman_swp_dqrr_thrshld_write() - Set the data in software portal
139 * DQRR interrupt threshold register.
140 * @p: the given software portal object.
141 * @mask: The value to set in SWP_DQRR_ITR register.
142 */
143 void qbman_swp_dqrr_thrshld_write(struct qbman_swp *p, uint32_t mask);
144
145 /**
146 * qbman_swp_intr_timeout_read_status() - Get the data in software portal
147 * Interrupt Time-Out period register.
148 * @p: the given software portal object.
149 */
150 uint32_t qbman_swp_intr_timeout_read_status(struct qbman_swp *p);
151
152 /**
153 * qbman_swp_intr_timeout_write() - Set the data in software portal
154 * Interrupt Time-Out period register.
155 * @p: the given software portal object.
156 * @mask: The value to set in SWP_ITPR register.
157 */
158 void qbman_swp_intr_timeout_write(struct qbman_swp *p, uint32_t mask);
159
160 /**
161 * qbman_swp_interrupt_get_trigger() - Get the data in software portal
162 * interrupt enable register.
163 * @p: the given software portal object.
164 *
165 * Return the settings in SWP_IER register.
166 */
167 uint32_t qbman_swp_interrupt_get_trigger(struct qbman_swp *p);
168
169 /**
170 * qbman_swp_interrupt_set_trigger() - Set the data in software portal
171 * interrupt enable register.
172 * @p: the given software portal object.
173 * @mask: The value to set in SWP_IER register.
174 */
175 void qbman_swp_interrupt_set_trigger(struct qbman_swp *p, uint32_t mask);
176
177 /**
178 * qbman_swp_interrupt_get_inhibit() - Get the data in software portal
179 * interrupt inhibit register.
180 * @p: the given software portal object.
181 *
182 * Return the settings in SWP_IIR register.
183 */
184 int qbman_swp_interrupt_get_inhibit(struct qbman_swp *p);
185
186 /**
187 * qbman_swp_interrupt_set_inhibit() - Set the data in software portal
188 * interrupt inhibit register.
189 * @p: the given software portal object.
190 * @mask: The value to set in SWP_IIR register.
191 */
192 void qbman_swp_interrupt_set_inhibit(struct qbman_swp *p, int inhibit);
193
194 /************/
195 /* Dequeues */
196 /************/
197
198 /**
199 * struct qbman_result - structure for qbman dequeue response and/or
200 * notification.
201 * @dont_manipulate_directly: the 16 32bit data to represent the whole
202 * possible qbman dequeue result.
203 */
204 struct qbman_result {
205 union {
206 struct common {
207 uint8_t verb;
208 uint8_t reserved[63];
209 } common;
210 struct dq {
211 uint8_t verb;
212 uint8_t stat;
213 __le16 seqnum;
214 __le16 oprid;
215 uint8_t reserved;
216 uint8_t tok;
217 __le32 fqid;
218 uint32_t reserved2;
219 __le32 fq_byte_cnt;
220 __le32 fq_frm_cnt;
221 __le64 fqd_ctx;
222 uint8_t fd[32];
223 } dq;
224 struct scn {
225 uint8_t verb;
226 uint8_t stat;
227 uint8_t state;
228 uint8_t reserved;
229 __le32 rid_tok;
230 __le64 ctx;
231 } scn;
232 struct eq_resp {
233 uint8_t verb;
234 uint8_t dca;
235 __le16 seqnum;
236 __le16 oprid;
237 uint8_t reserved;
238 uint8_t rc;
239 __le32 tgtid;
240 __le32 tag;
241 uint16_t qdbin;
242 uint8_t qpri;
243 uint8_t reserved1;
244 __le32 fqid:24;
245 __le32 rspid:8;
246 __le64 rsp_addr;
247 uint8_t fd[32];
248 } eq_resp;
249 };
250 };
251
252 /* TODO:
253 *A DQRI interrupt can be generated when there are dequeue results on the
254 * portal's DQRR (this mechanism does not deal with "pull" dequeues to
255 * user-supplied 'storage' addresses). There are two parameters to this
256 * interrupt source, one is a threshold and the other is a timeout. The
257 * interrupt will fire if either the fill-level of the ring exceeds 'thresh', or
258 * if the ring has been non-empty for been longer than 'timeout' nanoseconds.
259 * For timeout, an approximation to the desired nanosecond-granularity value is
260 * made, so there are get and set APIs to allow the user to see what actual
261 * timeout is set (compared to the timeout that was requested).
262 */
263 int qbman_swp_dequeue_thresh(struct qbman_swp *s, unsigned int thresh);
264 int qbman_swp_dequeue_set_timeout(struct qbman_swp *s, unsigned int timeout);
265 int qbman_swp_dequeue_get_timeout(struct qbman_swp *s, unsigned int *timeout);
266
267 /* ------------------- */
268 /* Push-mode dequeuing */
269 /* ------------------- */
270
271 /* The user of a portal can enable and disable push-mode dequeuing of up to 16
272 * channels independently. It does not specify this toggling by channel IDs, but
273 * rather by specifying the index (from 0 to 15) that has been mapped to the
274 * desired channel.
275 */
276
277 /**
278 * qbman_swp_push_get() - Get the push dequeue setup.
279 * @s: the software portal object.
280 * @channel_idx: the channel index to query.
281 * @enabled: returned boolean to show whether the push dequeue is enabled for
282 * the given channel.
283 */
284 void qbman_swp_push_get(struct qbman_swp *s, uint8_t channel_idx, int *enabled);
285
286 /**
287 * qbman_swp_push_set() - Enable or disable push dequeue.
288 * @s: the software portal object.
289 * @channel_idx: the channel index..
290 * @enable: enable or disable push dequeue.
291 *
292 * The user of a portal can enable and disable push-mode dequeuing of up to 16
293 * channels independently. It does not specify this toggling by channel IDs, but
294 * rather by specifying the index (from 0 to 15) that has been mapped to the
295 * desired channel.
296 */
297 __rte_internal
298 void qbman_swp_push_set(struct qbman_swp *s, uint8_t channel_idx, int enable);
299
300 /* ------------------- */
301 /* Pull-mode dequeuing */
302 /* ------------------- */
303
304 /**
305 * struct qbman_pull_desc - the structure for pull dequeue descriptor
306 */
307 struct qbman_pull_desc {
308 union {
309 uint32_t dont_manipulate_directly[16];
310 struct pull {
311 uint8_t verb;
312 uint8_t numf;
313 uint8_t tok;
314 uint8_t reserved;
315 uint32_t dq_src;
316 uint64_t rsp_addr;
317 uint64_t rsp_addr_virt;
318 uint8_t padding[40];
319 } pull;
320 };
321 };
322
323 enum qbman_pull_type_e {
324 /* dequeue with priority precedence, respect intra-class scheduling */
325 qbman_pull_type_prio = 1,
326 /* dequeue with active FQ precedence, respect ICS */
327 qbman_pull_type_active,
328 /* dequeue with active FQ precedence, no ICS */
329 qbman_pull_type_active_noics
330 };
331
332 /**
333 * qbman_pull_desc_clear() - Clear the contents of a descriptor to
334 * default/starting state.
335 * @d: the pull dequeue descriptor to be cleared.
336 */
337 __rte_internal
338 void qbman_pull_desc_clear(struct qbman_pull_desc *d);
339
340 /**
341 * qbman_pull_desc_set_storage()- Set the pull dequeue storage
342 * @d: the pull dequeue descriptor to be set.
343 * @storage: the pointer of the memory to store the dequeue result.
344 * @storage_phys: the physical address of the storage memory.
345 * @stash: to indicate whether write allocate is enabled.
346 *
347 * If not called, or if called with 'storage' as NULL, the result pull dequeues
348 * will produce results to DQRR. If 'storage' is non-NULL, then results are
349 * produced to the given memory location (using the physical/DMA address which
350 * the caller provides in 'storage_phys'), and 'stash' controls whether or not
351 * those writes to main-memory express a cache-warming attribute.
352 */
353 __rte_internal
354 void qbman_pull_desc_set_storage(struct qbman_pull_desc *d,
355 struct qbman_result *storage,
356 uint64_t storage_phys,
357 int stash);
358 /**
359 * qbman_pull_desc_set_numframes() - Set the number of frames to be dequeued.
360 * @d: the pull dequeue descriptor to be set.
361 * @numframes: number of frames to be set, must be between 1 and 16, inclusive.
362 */
363 __rte_internal
364 void qbman_pull_desc_set_numframes(struct qbman_pull_desc *d,
365 uint8_t numframes);
366 /**
367 * qbman_pull_desc_set_token() - Set dequeue token for pull command
368 * @d: the dequeue descriptor
369 * @token: the token to be set
370 *
371 * token is the value that shows up in the dequeue response that can be used to
372 * detect when the results have been published. The easiest technique is to zero
373 * result "storage" before issuing a dequeue, and use any non-zero 'token' value
374 */
375 void qbman_pull_desc_set_token(struct qbman_pull_desc *d, uint8_t token);
376
377 /* Exactly one of the following descriptor "actions" should be set. (Calling any
378 * one of these will replace the effect of any prior call to one of these.)
379 * - pull dequeue from the given frame queue (FQ)
380 * - pull dequeue from any FQ in the given work queue (WQ)
381 * - pull dequeue from any FQ in any WQ in the given channel
382 */
383 /**
384 * qbman_pull_desc_set_fq() - Set fqid from which the dequeue command dequeues.
385 * @fqid: the frame queue index of the given FQ.
386 */
387 __rte_internal
388 void qbman_pull_desc_set_fq(struct qbman_pull_desc *d, uint32_t fqid);
389
390 /**
391 * qbman_pull_desc_set_wq() - Set wqid from which the dequeue command dequeues.
392 * @wqid: composed of channel id and wqid within the channel.
393 * @dct: the dequeue command type.
394 */
395 void qbman_pull_desc_set_wq(struct qbman_pull_desc *d, uint32_t wqid,
396 enum qbman_pull_type_e dct);
397
398 /* qbman_pull_desc_set_channel() - Set channelid from which the dequeue command
399 * dequeues.
400 * @chid: the channel id to be dequeued.
401 * @dct: the dequeue command type.
402 */
403 void qbman_pull_desc_set_channel(struct qbman_pull_desc *d, uint32_t chid,
404 enum qbman_pull_type_e dct);
405
406 /**
407 * qbman_pull_desc_set_rad() - Decide whether reschedule the fq after dequeue
408 *
409 * @rad: 1 = Reschedule the FQ after dequeue.
410 * 0 = Allow the FQ to remain active after dequeue.
411 */
412 void qbman_pull_desc_set_rad(struct qbman_pull_desc *d, int rad);
413
414 /**
415 * qbman_swp_pull() - Issue the pull dequeue command
416 * @s: the software portal object.
417 * @d: the software portal descriptor which has been configured with
418 * the set of qbman_pull_desc_set_*() calls.
419 *
420 * Return 0 for success, and -EBUSY if the software portal is not ready
421 * to do pull dequeue.
422 */
423 __rte_internal
424 int qbman_swp_pull(struct qbman_swp *s, struct qbman_pull_desc *d);
425
426 /* -------------------------------- */
427 /* Polling DQRR for dequeue results */
428 /* -------------------------------- */
429
430 /**
431 * qbman_swp_dqrr_next() - Get an valid DQRR entry.
432 * @s: the software portal object.
433 *
434 * Return NULL if there are no unconsumed DQRR entries. Return a DQRR entry
435 * only once, so repeated calls can return a sequence of DQRR entries, without
436 * requiring they be consumed immediately or in any particular order.
437 */
438 __rte_internal
439 const struct qbman_result *qbman_swp_dqrr_next(struct qbman_swp *p);
440
441 /**
442 * qbman_swp_prefetch_dqrr_next() - prefetch the next DQRR entry.
443 * @s: the software portal object.
444 */
445 __rte_internal
446 void qbman_swp_prefetch_dqrr_next(struct qbman_swp *s);
447
448 /**
449 * qbman_swp_dqrr_consume() - Consume DQRR entries previously returned from
450 * qbman_swp_dqrr_next().
451 * @s: the software portal object.
452 * @dq: the DQRR entry to be consumed.
453 */
454 __rte_internal
455 void qbman_swp_dqrr_consume(struct qbman_swp *s, const struct qbman_result *dq);
456
457 /**
458 * qbman_swp_dqrr_idx_consume() - Given the DQRR index consume the DQRR entry
459 * @s: the software portal object.
460 * @dqrr_index: the DQRR index entry to be consumed.
461 */
462 __rte_internal
463 void qbman_swp_dqrr_idx_consume(struct qbman_swp *s, uint8_t dqrr_index);
464
465 /**
466 * qbman_get_dqrr_idx() - Get dqrr index from the given dqrr
467 * @dqrr: the given dqrr object.
468 *
469 * Return dqrr index.
470 */
471 __rte_internal
472 uint8_t qbman_get_dqrr_idx(const struct qbman_result *dqrr);
473
474 /**
475 * qbman_get_dqrr_from_idx() - Use index to get the dqrr entry from the
476 * given portal
477 * @s: the given portal.
478 * @idx: the dqrr index.
479 *
480 * Return dqrr entry object.
481 */
482 __rte_internal
483 struct qbman_result *qbman_get_dqrr_from_idx(struct qbman_swp *s, uint8_t idx);
484
485 /* ------------------------------------------------- */
486 /* Polling user-provided storage for dequeue results */
487 /* ------------------------------------------------- */
488
489 /**
490 * qbman_result_has_new_result() - Check and get the dequeue response from the
491 * dq storage memory set in pull dequeue command
492 * @s: the software portal object.
493 * @dq: the dequeue result read from the memory.
494 *
495 * Only used for user-provided storage of dequeue results, not DQRR. For
496 * efficiency purposes, the driver will perform any required endianness
497 * conversion to ensure that the user's dequeue result storage is in host-endian
498 * format (whether or not that is the same as the little-endian format that
499 * hardware DMA'd to the user's storage). As such, once the user has called
500 * qbman_result_has_new_result() and been returned a valid dequeue result,
501 * they should not call it again on the same memory location (except of course
502 * if another dequeue command has been executed to produce a new result to that
503 * location).
504 *
505 * Return 1 for getting a valid dequeue result, or 0 for not getting a valid
506 * dequeue result.
507 */
508 __rte_internal
509 int qbman_result_has_new_result(struct qbman_swp *s,
510 struct qbman_result *dq);
511
512 /**
513 * qbman_check_command_complete() - Check if the previous issued dq command
514 * is completed and results are available in memory.
515 * @s: the software portal object.
516 * @dq: the dequeue result read from the memory.
517 *
518 * Return 1 for getting a valid dequeue result, or 0 for not getting a valid
519 * dequeue result.
520 */
521 __rte_internal
522 int qbman_check_command_complete(struct qbman_result *dq);
523
524 __rte_internal
525 int qbman_check_new_result(struct qbman_result *dq);
526
527 /* -------------------------------------------------------- */
528 /* Parsing dequeue entries (DQRR and user-provided storage) */
529 /* -------------------------------------------------------- */
530
531 /**
532 * qbman_result_is_DQ() - check the dequeue result is a dequeue response or not
533 * @dq: the dequeue result to be checked.
534 *
535 * DQRR entries may contain non-dequeue results, ie. notifications
536 */
537 int qbman_result_is_DQ(const struct qbman_result *dq);
538
539 /**
540 * qbman_result_is_SCN() - Check the dequeue result is notification or not
541 * @dq: the dequeue result to be checked.
542 *
543 * All the non-dequeue results (FQDAN/CDAN/CSCN/...) are "state change
544 * notifications" of one type or another. Some APIs apply to all of them, of the
545 * form qbman_result_SCN_***().
546 */
qbman_result_is_SCN(const struct qbman_result * dq)547 static inline int qbman_result_is_SCN(const struct qbman_result *dq)
548 {
549 return !qbman_result_is_DQ(dq);
550 }
551
552 /* Recognise different notification types, only required if the user allows for
553 * these to occur, and cares about them when they do.
554 */
555
556 /**
557 * qbman_result_is_FQDAN() - Check for FQ Data Availability
558 * @dq: the qbman_result object.
559 *
560 * Return 1 if this is FQDAN.
561 */
562 int qbman_result_is_FQDAN(const struct qbman_result *dq);
563
564 /**
565 * qbman_result_is_CDAN() - Check for Channel Data Availability
566 * @dq: the qbman_result object to check.
567 *
568 * Return 1 if this is CDAN.
569 */
570 int qbman_result_is_CDAN(const struct qbman_result *dq);
571
572 /**
573 * qbman_result_is_CSCN() - Check for Congestion State Change
574 * @dq: the qbman_result object to check.
575 *
576 * Return 1 if this is CSCN.
577 */
578 int qbman_result_is_CSCN(const struct qbman_result *dq);
579
580 /**
581 * qbman_result_is_BPSCN() - Check for Buffer Pool State Change.
582 * @dq: the qbman_result object to check.
583 *
584 * Return 1 if this is BPSCN.
585 */
586 int qbman_result_is_BPSCN(const struct qbman_result *dq);
587
588 /**
589 * qbman_result_is_CGCU() - Check for Congestion Group Count Update.
590 * @dq: the qbman_result object to check.
591 *
592 * Return 1 if this is CGCU.
593 */
594 int qbman_result_is_CGCU(const struct qbman_result *dq);
595
596 /* Frame queue state change notifications; (FQDAN in theory counts too as it
597 * leaves a FQ parked, but it is primarily a data availability notification)
598 */
599
600 /**
601 * qbman_result_is_FQRN() - Check for FQ Retirement Notification.
602 * @dq: the qbman_result object to check.
603 *
604 * Return 1 if this is FQRN.
605 */
606 int qbman_result_is_FQRN(const struct qbman_result *dq);
607
608 /**
609 * qbman_result_is_FQRNI() - Check for FQ Retirement Immediate
610 * @dq: the qbman_result object to check.
611 *
612 * Return 1 if this is FQRNI.
613 */
614 int qbman_result_is_FQRNI(const struct qbman_result *dq);
615
616 /**
617 * qbman_result_is_FQPN() - Check for FQ Park Notification
618 * @dq: the qbman_result object to check.
619 *
620 * Return 1 if this is FQPN.
621 */
622 int qbman_result_is_FQPN(const struct qbman_result *dq);
623
624 /* Parsing frame dequeue results (qbman_result_is_DQ() must be TRUE)
625 */
626 /* FQ empty */
627 #define QBMAN_DQ_STAT_FQEMPTY 0x80
628 /* FQ held active */
629 #define QBMAN_DQ_STAT_HELDACTIVE 0x40
630 /* FQ force eligible */
631 #define QBMAN_DQ_STAT_FORCEELIGIBLE 0x20
632 /* Valid frame */
633 #define QBMAN_DQ_STAT_VALIDFRAME 0x10
634 /* FQ ODP enable */
635 #define QBMAN_DQ_STAT_ODPVALID 0x04
636 /* Volatile dequeue */
637 #define QBMAN_DQ_STAT_VOLATILE 0x02
638 /* volatile dequeue command is expired */
639 #define QBMAN_DQ_STAT_EXPIRED 0x01
640
641 #define QBMAN_EQCR_DCA_IDXMASK 0x0f
642 #define QBMAN_ENQUEUE_FLAG_DCA (1ULL << 31)
643
644 /**
645 * qbman_result_DQ_flags() - Get the STAT field of dequeue response
646 * @dq: the dequeue result.
647 *
648 * Return the state field.
649 */
650 __rte_internal
651 uint8_t qbman_result_DQ_flags(const struct qbman_result *dq);
652
653 /**
654 * qbman_result_DQ_is_pull() - Check whether the dq response is from a pull
655 * command.
656 * @dq: the dequeue result.
657 *
658 * Return 1 for volatile(pull) dequeue, 0 for static dequeue.
659 */
qbman_result_DQ_is_pull(const struct qbman_result * dq)660 static inline int qbman_result_DQ_is_pull(const struct qbman_result *dq)
661 {
662 return (int)(qbman_result_DQ_flags(dq) & QBMAN_DQ_STAT_VOLATILE);
663 }
664
665 /**
666 * qbman_result_DQ_is_pull_complete() - Check whether the pull command is
667 * completed.
668 * @dq: the dequeue result.
669 *
670 * Return boolean.
671 */
qbman_result_DQ_is_pull_complete(const struct qbman_result * dq)672 static inline int qbman_result_DQ_is_pull_complete(
673 const struct qbman_result *dq)
674 {
675 return (int)(qbman_result_DQ_flags(dq) & QBMAN_DQ_STAT_EXPIRED);
676 }
677
678 /**
679 * qbman_result_DQ_seqnum() - Get the seqnum field in dequeue response
680 * seqnum is valid only if VALIDFRAME flag is TRUE
681 * @dq: the dequeue result.
682 *
683 * Return seqnum.
684 */
685 __rte_internal
686 uint16_t qbman_result_DQ_seqnum(const struct qbman_result *dq);
687
688 /**
689 * qbman_result_DQ_odpid() - Get the seqnum field in dequeue response
690 * odpid is valid only if ODPVALID flag is TRUE.
691 * @dq: the dequeue result.
692 *
693 * Return odpid.
694 */
695 __rte_internal
696 uint16_t qbman_result_DQ_odpid(const struct qbman_result *dq);
697
698 /**
699 * qbman_result_DQ_fqid() - Get the fqid in dequeue response
700 * @dq: the dequeue result.
701 *
702 * Return fqid.
703 */
704 uint32_t qbman_result_DQ_fqid(const struct qbman_result *dq);
705
706 /**
707 * qbman_result_DQ_byte_count() - Get the byte count in dequeue response
708 * @dq: the dequeue result.
709 *
710 * Return the byte count remaining in the FQ.
711 */
712 uint32_t qbman_result_DQ_byte_count(const struct qbman_result *dq);
713
714 /**
715 * qbman_result_DQ_frame_count - Get the frame count in dequeue response
716 * @dq: the dequeue result.
717 *
718 * Return the frame count remaining in the FQ.
719 */
720 uint32_t qbman_result_DQ_frame_count(const struct qbman_result *dq);
721
722 /**
723 * qbman_result_DQ_fqd_ctx() - Get the frame queue context in dequeue response
724 * @dq: the dequeue result.
725 *
726 * Return the frame queue context.
727 */
728 __rte_internal
729 uint64_t qbman_result_DQ_fqd_ctx(const struct qbman_result *dq);
730
731 /**
732 * qbman_result_DQ_fd() - Get the frame descriptor in dequeue response
733 * @dq: the dequeue result.
734 *
735 * Return the frame descriptor.
736 */
737 __rte_internal
738 const struct qbman_fd *qbman_result_DQ_fd(const struct qbman_result *dq);
739
740 /* State-change notifications (FQDAN/CDAN/CSCN/...). */
741
742 /**
743 * qbman_result_SCN_state() - Get the state field in State-change notification
744 * @scn: the state change notification.
745 *
746 * Return the state in the notification.
747 */
748 __rte_internal
749 uint8_t qbman_result_SCN_state(const struct qbman_result *scn);
750
751 /**
752 * qbman_result_SCN_rid() - Get the resource id from the notification
753 * @scn: the state change notification.
754 *
755 * Return the resource id.
756 */
757 uint32_t qbman_result_SCN_rid(const struct qbman_result *scn);
758
759 /**
760 * qbman_result_SCN_ctx() - get the context from the notification
761 * @scn: the state change notification.
762 *
763 * Return the context.
764 */
765 uint64_t qbman_result_SCN_ctx(const struct qbman_result *scn);
766
767 /* Type-specific "resource IDs". Mainly for illustration purposes, though it
768 * also gives the appropriate type widths.
769 */
770 /* Get the FQID from the FQDAN */
771 #define qbman_result_FQDAN_fqid(dq) qbman_result_SCN_rid(dq)
772 /* Get the FQID from the FQRN */
773 #define qbman_result_FQRN_fqid(dq) qbman_result_SCN_rid(dq)
774 /* Get the FQID from the FQRNI */
775 #define qbman_result_FQRNI_fqid(dq) qbman_result_SCN_rid(dq)
776 /* Get the FQID from the FQPN */
777 #define qbman_result_FQPN_fqid(dq) qbman_result_SCN_rid(dq)
778 /* Get the channel ID from the CDAN */
779 #define qbman_result_CDAN_cid(dq) ((uint16_t)qbman_result_SCN_rid(dq))
780 /* Get the CGID from the CSCN */
781 #define qbman_result_CSCN_cgid(dq) ((uint16_t)qbman_result_SCN_rid(dq))
782
783 /**
784 * qbman_result_bpscn_bpid() - Get the bpid from BPSCN
785 * @scn: the state change notification.
786 *
787 * Return the buffer pool id.
788 */
789 uint16_t qbman_result_bpscn_bpid(const struct qbman_result *scn);
790
791 /**
792 * qbman_result_bpscn_has_free_bufs() - Check whether there are free
793 * buffers in the pool from BPSCN.
794 * @scn: the state change notification.
795 *
796 * Return the number of free buffers.
797 */
798 int qbman_result_bpscn_has_free_bufs(const struct qbman_result *scn);
799
800 /**
801 * qbman_result_bpscn_is_depleted() - Check BPSCN to see whether the
802 * buffer pool is depleted.
803 * @scn: the state change notification.
804 *
805 * Return the status of buffer pool depletion.
806 */
807 int qbman_result_bpscn_is_depleted(const struct qbman_result *scn);
808
809 /**
810 * qbman_result_bpscn_is_surplus() - Check BPSCN to see whether the buffer
811 * pool is surplus or not.
812 * @scn: the state change notification.
813 *
814 * Return the status of buffer pool surplus.
815 */
816 int qbman_result_bpscn_is_surplus(const struct qbman_result *scn);
817
818 /**
819 * qbman_result_bpscn_ctx() - Get the BPSCN CTX from BPSCN message
820 * @scn: the state change notification.
821 *
822 * Return the BPSCN context.
823 */
824 uint64_t qbman_result_bpscn_ctx(const struct qbman_result *scn);
825
826 /* Parsing CGCU */
827 /**
828 * qbman_result_cgcu_cgid() - Check CGCU resource id, i.e. cgid
829 * @scn: the state change notification.
830 *
831 * Return the CGCU resource id.
832 */
833 uint16_t qbman_result_cgcu_cgid(const struct qbman_result *scn);
834
835 /**
836 * qbman_result_cgcu_icnt() - Get the I_CNT from CGCU
837 * @scn: the state change notification.
838 *
839 * Return instantaneous count in the CGCU notification.
840 */
841 uint64_t qbman_result_cgcu_icnt(const struct qbman_result *scn);
842
843 /************/
844 /* Enqueues */
845 /************/
846 /* struct qbman_eq_desc - structure of enqueue descriptor */
847 struct qbman_eq_desc {
848 union {
849 uint32_t dont_manipulate_directly[8];
850 struct eq {
851 uint8_t verb;
852 uint8_t dca;
853 uint16_t seqnum;
854 uint16_t orpid;
855 uint16_t reserved1;
856 uint32_t tgtid;
857 uint32_t tag;
858 uint16_t qdbin;
859 uint8_t qpri;
860 uint8_t reserved[3];
861 uint8_t wae;
862 uint8_t rspid;
863 uint64_t rsp_addr;
864 } eq;
865 };
866 };
867
868 /**
869 * struct qbman_eq_response - structure of enqueue response
870 * @dont_manipulate_directly: the 16 32bit data to represent the whole
871 * enqueue response.
872 */
873 struct qbman_eq_response {
874 uint32_t dont_manipulate_directly[16];
875 };
876
877 /**
878 * qbman_eq_desc_clear() - Clear the contents of a descriptor to
879 * default/starting state.
880 * @d: the given enqueue descriptor.
881 */
882 __rte_internal
883 void qbman_eq_desc_clear(struct qbman_eq_desc *d);
884
885 /* Exactly one of the following descriptor "actions" should be set. (Calling
886 * any one of these will replace the effect of any prior call to one of these.)
887 * - enqueue without order-restoration
888 * - enqueue with order-restoration
889 * - fill a hole in the order-restoration sequence, without any enqueue
890 * - advance NESN (Next Expected Sequence Number), without any enqueue
891 * 'respond_success' indicates whether an enqueue response should be DMA'd
892 * after success (otherwise a response is DMA'd only after failure).
893 * 'incomplete' indicates that other fragments of the same 'seqnum' are yet to
894 * be enqueued.
895 */
896
897 /**
898 * qbman_eq_desc_set_no_orp() - Set enqueue descriptor without orp
899 * @d: the enqueue descriptor.
900 * @response_success: 1 = enqueue with response always; 0 = enqueue with
901 * rejections returned on a FQ.
902 */
903 __rte_internal
904 void qbman_eq_desc_set_no_orp(struct qbman_eq_desc *d, int respond_success);
905 /**
906 * qbman_eq_desc_set_orp() - Set order-restoration in the enqueue descriptor
907 * @d: the enqueue descriptor.
908 * @response_success: 1 = enqueue with response always; 0 = enqueue with
909 * rejections returned on a FQ.
910 * @opr_id: the order point record id.
911 * @seqnum: the order restoration sequence number.
912 * @incomplete: indicates whether this is the last fragments using the same
913 * sequence number.
914 */
915 __rte_internal
916 void qbman_eq_desc_set_orp(struct qbman_eq_desc *d, int respond_success,
917 uint16_t opr_id, uint16_t seqnum, int incomplete);
918
919 /**
920 * qbman_eq_desc_set_orp_hole() - fill a hole in the order-restoration sequence
921 * without any enqueue
922 * @d: the enqueue descriptor.
923 * @opr_id: the order point record id.
924 * @seqnum: the order restoration sequence number.
925 */
926 void qbman_eq_desc_set_orp_hole(struct qbman_eq_desc *d, uint16_t opr_id,
927 uint16_t seqnum);
928
929 /**
930 * qbman_eq_desc_set_orp_nesn() - advance NESN (Next Expected Sequence Number)
931 * without any enqueue
932 * @d: the enqueue descriptor.
933 * @opr_id: the order point record id.
934 * @seqnum: the order restoration sequence number.
935 */
936 void qbman_eq_desc_set_orp_nesn(struct qbman_eq_desc *d, uint16_t opr_id,
937 uint16_t seqnum);
938 /**
939 * qbman_eq_desc_set_response() - Set the enqueue response info.
940 * @d: the enqueue descriptor
941 * @storage_phys: the physical address of the enqueue response in memory.
942 * @stash: indicate that the write allocation enabled or not.
943 *
944 * In the case where an enqueue response is DMA'd, this determines where that
945 * response should go. (The physical/DMA address is given for hardware's
946 * benefit, but software should interpret it as a "struct qbman_eq_response"
947 * data structure.) 'stash' controls whether or not the write to main-memory
948 * expresses a cache-warming attribute.
949 */
950 __rte_internal
951 void qbman_eq_desc_set_response(struct qbman_eq_desc *d,
952 uint64_t storage_phys,
953 int stash);
954
955 /**
956 * qbman_eq_desc_set_token() - Set token for the enqueue command
957 * @d: the enqueue descriptor
958 * @token: the token to be set.
959 *
960 * token is the value that shows up in an enqueue response that can be used to
961 * detect when the results have been published. The easiest technique is to zero
962 * result "storage" before issuing an enqueue, and use any non-zero 'token'
963 * value.
964 */
965 __rte_internal
966 void qbman_eq_desc_set_token(struct qbman_eq_desc *d, uint8_t token);
967
968 /**
969 * Exactly one of the following descriptor "targets" should be set. (Calling any
970 * one of these will replace the effect of any prior call to one of these.)
971 * - enqueue to a frame queue
972 * - enqueue to a queuing destination
973 * Note, that none of these will have any affect if the "action" type has been
974 * set to "orp_hole" or "orp_nesn".
975 */
976 /**
977 * qbman_eq_desc_set_fq() - Set Frame Queue id for the enqueue command
978 * @d: the enqueue descriptor
979 * @fqid: the id of the frame queue to be enqueued.
980 */
981 __rte_internal
982 void qbman_eq_desc_set_fq(struct qbman_eq_desc *d, uint32_t fqid);
983
984 /**
985 * qbman_eq_desc_set_qd() - Set Queuing Destination for the enqueue command.
986 * @d: the enqueue descriptor
987 * @qdid: the id of the queuing destination to be enqueued.
988 * @qd_bin: the queuing destination bin
989 * @qd_prio: the queuing destination priority.
990 */
991 __rte_internal
992 void qbman_eq_desc_set_qd(struct qbman_eq_desc *d, uint32_t qdid,
993 uint16_t qd_bin, uint8_t qd_prio);
994
995 /**
996 * qbman_eq_desc_set_eqdi() - enable/disable EQDI interrupt
997 * @d: the enqueue descriptor
998 * @enable: boolean to enable/disable EQDI
999 *
1000 * Determines whether or not the portal's EQDI interrupt source should be
1001 * asserted after the enqueue command is completed.
1002 */
1003 void qbman_eq_desc_set_eqdi(struct qbman_eq_desc *d, int enable);
1004
1005 /**
1006 * qbman_eq_desc_set_dca() - Set DCA mode in the enqueue command.
1007 * @d: the enqueue descriptor.
1008 * @enable: enabled/disable DCA mode.
1009 * @dqrr_idx: DCAP_CI, the DCAP consumer index.
1010 * @park: determine the whether park the FQ or not
1011 *
1012 * Determines whether or not a portal DQRR entry should be consumed once the
1013 * enqueue command is completed. (And if so, and the DQRR entry corresponds to a
1014 * held-active (order-preserving) FQ, whether the FQ should be parked instead of
1015 * being rescheduled.)
1016 */
1017 __rte_internal
1018 void qbman_eq_desc_set_dca(struct qbman_eq_desc *d, int enable,
1019 uint8_t dqrr_idx, int park);
1020
1021 /**
1022 * qbman_result_eqresp_fd() - Get fd from enqueue response.
1023 * @eqresp: enqueue response.
1024 *
1025 * Return the fd pointer.
1026 */
1027 __rte_internal
1028 struct qbman_fd *qbman_result_eqresp_fd(struct qbman_result *eqresp);
1029
1030 /**
1031 * qbman_result_eqresp_set_rspid() - Set the response id in enqueue response.
1032 * @eqresp: enqueue response.
1033 * @val: values to set into the response id.
1034 *
1035 * This value is set into the response id before the enqueue command, which,
1036 * get overwritten by qbman once the enqueue command is complete.
1037 */
1038 __rte_internal
1039 void qbman_result_eqresp_set_rspid(struct qbman_result *eqresp, uint8_t val);
1040
1041 /**
1042 * qbman_result_eqresp_rspid() - Get the response id.
1043 * @eqresp: enqueue response.
1044 *
1045 * Return the response id.
1046 *
1047 * At the time of enqueue user provides the response id. Response id gets
1048 * copied into the enqueue response to determine if the command has been
1049 * completed, and response has been updated.
1050 */
1051 __rte_internal
1052 uint8_t qbman_result_eqresp_rspid(struct qbman_result *eqresp);
1053
1054 /**
1055 * qbman_result_eqresp_rc() - determines if enqueue command is successful.
1056 * @eqresp: enqueue response.
1057 *
1058 * Return 0 when command is successful.
1059 */
1060 __rte_internal
1061 uint8_t qbman_result_eqresp_rc(struct qbman_result *eqresp);
1062
1063 /**
1064 * qbman_swp_enqueue() - Issue an enqueue command.
1065 * @s: the software portal used for enqueue.
1066 * @d: the enqueue descriptor.
1067 * @fd: the frame descriptor to be enqueued.
1068 *
1069 * Please note that 'fd' should only be NULL if the "action" of the
1070 * descriptor is "orp_hole" or "orp_nesn".
1071 *
1072 * Return 0 for a successful enqueue, -EBUSY if the EQCR is not ready.
1073 */
1074 int qbman_swp_enqueue(struct qbman_swp *s, const struct qbman_eq_desc *d,
1075 const struct qbman_fd *fd);
1076 /**
1077 * qbman_swp_enqueue_multiple() - Enqueue multiple frames with same
1078 eq descriptor
1079 * @s: the software portal used for enqueue.
1080 * @d: the enqueue descriptor.
1081 * @fd: the frame descriptor to be enqueued.
1082 * @flags: bit-mask of QBMAN_ENQUEUE_FLAG_*** options
1083 * @num_frames: the number of the frames to be enqueued.
1084 *
1085 * Return the number of enqueued frames, -EBUSY if the EQCR is not ready.
1086 */
1087 __rte_internal
1088 int qbman_swp_enqueue_multiple(struct qbman_swp *s,
1089 const struct qbman_eq_desc *d,
1090 const struct qbman_fd *fd,
1091 uint32_t *flags,
1092 int num_frames);
1093
1094 /**
1095 * qbman_swp_enqueue_multiple_fd() - Enqueue multiple frames with same
1096 eq descriptor
1097 * @s: the software portal used for enqueue.
1098 * @d: the enqueue descriptor.
1099 * @fd: the frame descriptor to be enqueued.
1100 * @flags: bit-mask of QBMAN_ENQUEUE_FLAG_*** options
1101 * @num_frames: the number of the frames to be enqueued.
1102 *
1103 * Return the number of enqueued frames, -EBUSY if the EQCR is not ready.
1104 */
1105 __rte_internal
1106 int qbman_swp_enqueue_multiple_fd(struct qbman_swp *s,
1107 const struct qbman_eq_desc *d,
1108 struct qbman_fd **fd,
1109 uint32_t *flags,
1110 int num_frames);
1111
1112 /**
1113 * qbman_swp_enqueue_multiple_desc() - Enqueue multiple frames with
1114 * individual eq descriptor.
1115 * @s: the software portal used for enqueue.
1116 * @d: the enqueue descriptor.
1117 * @fd: the frame descriptor to be enqueued.
1118 * @num_frames: the number of the frames to be enqueued.
1119 *
1120 * Return the number of enqueued frames, -EBUSY if the EQCR is not ready.
1121 */
1122 __rte_internal
1123 int qbman_swp_enqueue_multiple_desc(struct qbman_swp *s,
1124 const struct qbman_eq_desc *d,
1125 const struct qbman_fd *fd,
1126 int num_frames);
1127
1128 /* TODO:
1129 * qbman_swp_enqueue_thresh() - Set threshold for EQRI interrupt.
1130 * @s: the software portal.
1131 * @thresh: the threshold to trigger the EQRI interrupt.
1132 *
1133 * An EQRI interrupt can be generated when the fill-level of EQCR falls below
1134 * the 'thresh' value set here. Setting thresh==0 (the default) disables.
1135 */
1136 int qbman_swp_enqueue_thresh(struct qbman_swp *s, unsigned int thresh);
1137
1138 /*******************/
1139 /* Buffer releases */
1140 /*******************/
1141 /**
1142 * struct qbman_release_desc - The structure for buffer release descriptor
1143 * @dont_manipulate_directly: the 32bit data to represent the whole
1144 * possible settings of qbman release descriptor.
1145 */
1146 struct qbman_release_desc {
1147 union {
1148 uint32_t dont_manipulate_directly[16];
1149 struct br {
1150 uint8_t verb;
1151 uint8_t reserved;
1152 uint16_t bpid;
1153 uint32_t reserved2;
1154 uint64_t buf[7];
1155 } br;
1156 };
1157 };
1158
1159 /**
1160 * qbman_release_desc_clear() - Clear the contents of a descriptor to
1161 * default/starting state.
1162 * @d: the qbman release descriptor.
1163 */
1164 __rte_internal
1165 void qbman_release_desc_clear(struct qbman_release_desc *d);
1166
1167 /**
1168 * qbman_release_desc_set_bpid() - Set the ID of the buffer pool to release to
1169 * @d: the qbman release descriptor.
1170 */
1171 __rte_internal
1172 void qbman_release_desc_set_bpid(struct qbman_release_desc *d, uint16_t bpid);
1173
1174 /**
1175 * qbman_release_desc_set_rcdi() - Determines whether or not the portal's RCDI
1176 * interrupt source should be asserted after the release command is completed.
1177 * @d: the qbman release descriptor.
1178 */
1179 void qbman_release_desc_set_rcdi(struct qbman_release_desc *d, int enable);
1180
1181 /**
1182 * qbman_swp_release() - Issue a buffer release command.
1183 * @s: the software portal object.
1184 * @d: the release descriptor.
1185 * @buffers: a pointer pointing to the buffer address to be released.
1186 * @num_buffers: number of buffers to be released, must be less than 8.
1187 *
1188 * Return 0 for success, -EBUSY if the release command ring is not ready.
1189 */
1190 __rte_internal
1191 int qbman_swp_release(struct qbman_swp *s, const struct qbman_release_desc *d,
1192 const uint64_t *buffers, unsigned int num_buffers);
1193
1194 /* TODO:
1195 * qbman_swp_release_thresh() - Set threshold for RCRI interrupt
1196 * @s: the software portal.
1197 * @thresh: the threshold.
1198 * An RCRI interrupt can be generated when the fill-level of RCR falls below
1199 * the 'thresh' value set here. Setting thresh==0 (the default) disables.
1200 */
1201 int qbman_swp_release_thresh(struct qbman_swp *s, unsigned int thresh);
1202
1203 /*******************/
1204 /* Buffer acquires */
1205 /*******************/
1206 /**
1207 * qbman_swp_acquire() - Issue a buffer acquire command.
1208 * @s: the software portal object.
1209 * @bpid: the buffer pool index.
1210 * @buffers: a pointer pointing to the acquired buffer address|es.
1211 * @num_buffers: number of buffers to be acquired, must be less than 8.
1212 *
1213 * Return 0 for success, or negative error code if the acquire command
1214 * fails.
1215 */
1216 __rte_internal
1217 int qbman_swp_acquire(struct qbman_swp *s, uint16_t bpid, uint64_t *buffers,
1218 unsigned int num_buffers);
1219
1220 /*****************/
1221 /* FQ management */
1222 /*****************/
1223 /**
1224 * qbman_swp_fq_schedule() - Move the fq to the scheduled state.
1225 * @s: the software portal object.
1226 * @fqid: the index of frame queue to be scheduled.
1227 *
1228 * There are a couple of different ways that a FQ can end up parked state,
1229 * This schedules it.
1230 *
1231 * Return 0 for success, or negative error code for failure.
1232 */
1233 int qbman_swp_fq_schedule(struct qbman_swp *s, uint32_t fqid);
1234
1235 /**
1236 * qbman_swp_fq_force() - Force the FQ to fully scheduled state.
1237 * @s: the software portal object.
1238 * @fqid: the index of frame queue to be forced.
1239 *
1240 * Force eligible will force a tentatively-scheduled FQ to be fully-scheduled
1241 * and thus be available for selection by any channel-dequeuing behaviour (push
1242 * or pull). If the FQ is subsequently "dequeued" from the channel and is still
1243 * empty at the time this happens, the resulting dq_entry will have no FD.
1244 * (qbman_result_DQ_fd() will return NULL.)
1245 *
1246 * Return 0 for success, or negative error code for failure.
1247 */
1248 int qbman_swp_fq_force(struct qbman_swp *s, uint32_t fqid);
1249
1250 /**
1251 * These functions change the FQ flow-control stuff between XON/XOFF. (The
1252 * default is XON.) This setting doesn't affect enqueues to the FQ, just
1253 * dequeues. XOFF FQs will remain in the tentatively-scheduled state, even when
1254 * non-empty, meaning they won't be selected for scheduled dequeuing. If a FQ is
1255 * changed to XOFF after it had already become truly-scheduled to a channel, and
1256 * a pull dequeue of that channel occurs that selects that FQ for dequeuing,
1257 * then the resulting dq_entry will have no FD. (qbman_result_DQ_fd() will
1258 * return NULL.)
1259 */
1260 /**
1261 * qbman_swp_fq_xon() - XON the frame queue.
1262 * @s: the software portal object.
1263 * @fqid: the index of frame queue.
1264 *
1265 * Return 0 for success, or negative error code for failure.
1266 */
1267 int qbman_swp_fq_xon(struct qbman_swp *s, uint32_t fqid);
1268 /**
1269 * qbman_swp_fq_xoff() - XOFF the frame queue.
1270 * @s: the software portal object.
1271 * @fqid: the index of frame queue.
1272 *
1273 * Return 0 for success, or negative error code for failure.
1274 */
1275 int qbman_swp_fq_xoff(struct qbman_swp *s, uint32_t fqid);
1276
1277 /**********************/
1278 /* Channel management */
1279 /**********************/
1280
1281 /**
1282 * If the user has been allocated a channel object that is going to generate
1283 * CDANs to another channel, then these functions will be necessary.
1284 * CDAN-enabled channels only generate a single CDAN notification, after which
1285 * it they need to be reenabled before they'll generate another. (The idea is
1286 * that pull dequeuing will occur in reaction to the CDAN, followed by a
1287 * reenable step.) Each function generates a distinct command to hardware, so a
1288 * combination function is provided if the user wishes to modify the "context"
1289 * (which shows up in each CDAN message) each time they reenable, as a single
1290 * command to hardware.
1291 */
1292
1293 /**
1294 * qbman_swp_CDAN_set_context() - Set CDAN context
1295 * @s: the software portal object.
1296 * @channelid: the channel index.
1297 * @ctx: the context to be set in CDAN.
1298 *
1299 * Return 0 for success, or negative error code for failure.
1300 */
1301 int qbman_swp_CDAN_set_context(struct qbman_swp *s, uint16_t channelid,
1302 uint64_t ctx);
1303
1304 /**
1305 * qbman_swp_CDAN_enable() - Enable CDAN for the channel.
1306 * @s: the software portal object.
1307 * @channelid: the index of the channel to generate CDAN.
1308 *
1309 * Return 0 for success, or negative error code for failure.
1310 */
1311 int qbman_swp_CDAN_enable(struct qbman_swp *s, uint16_t channelid);
1312
1313 /**
1314 * qbman_swp_CDAN_disable() - disable CDAN for the channel.
1315 * @s: the software portal object.
1316 * @channelid: the index of the channel to generate CDAN.
1317 *
1318 * Return 0 for success, or negative error code for failure.
1319 */
1320 int qbman_swp_CDAN_disable(struct qbman_swp *s, uint16_t channelid);
1321
1322 /**
1323 * qbman_swp_CDAN_set_context_enable() - Set CDAN contest and enable CDAN
1324 * @s: the software portal object.
1325 * @channelid: the index of the channel to generate CDAN.
1326 * @ctx: the context set in CDAN.
1327 *
1328 * Return 0 for success, or negative error code for failure.
1329 */
1330 int qbman_swp_CDAN_set_context_enable(struct qbman_swp *s, uint16_t channelid,
1331 uint64_t ctx);
1332 #endif /* !_FSL_QBMAN_PORTAL_H */
1333