1 /***********************license start***************
2 * Author: Cavium Networks
3 *
4 * Contact: support@caviumnetworks.com
5 * This file is part of the OCTEON SDK
6 *
7 * Copyright (c) 2003-2008 Cavium Networks
8 *
9 * This file is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License, Version 2, as
11 * published by the Free Software Foundation.
12 *
13 * This file is distributed in the hope that it will be useful, but
14 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
15 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
16 * NONINFRINGEMENT. See the GNU General Public License for more
17 * details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this file; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 * or visit http://www.gnu.org/licenses/.
23 *
24 * This file may also be available under a different license from Cavium.
25 * Contact Cavium Networks for more information
26 ***********************license end**************************************/
27
28 /**
29 * Interface to the hardware Packet Order / Work unit.
30 *
31 * New, starting with SDK 1.7.0, cvmx-pow supports a number of
32 * extended consistency checks. The define
33 * CVMX_ENABLE_POW_CHECKS controls the runtime insertion of POW
34 * internal state checks to find common programming errors. If
35 * CVMX_ENABLE_POW_CHECKS is not defined, checks are by default
36 * enabled. For example, cvmx-pow will check for the following
37 * program errors or POW state inconsistency.
38 * - Requesting a POW operation with an active tag switch in
39 * progress.
40 * - Waiting for a tag switch to complete for an excessively
41 * long period. This is normally a sign of an error in locking
42 * causing deadlock.
43 * - Illegal tag switches from NULL_NULL.
44 * - Illegal tag switches from NULL.
45 * - Illegal deschedule request.
46 * - WQE pointer not matching the one attached to the core by
47 * the POW.
48 *
49 */
50
51 #ifndef __CVMX_POW_H__
52 #define __CVMX_POW_H__
53
54 #include <asm/octeon/cvmx-pow-defs.h>
55
56 #include <asm/octeon/cvmx-scratch.h>
57 #include <asm/octeon/cvmx-wqe.h>
58
59 /* Default to having all POW constancy checks turned on */
60 #ifndef CVMX_ENABLE_POW_CHECKS
61 #define CVMX_ENABLE_POW_CHECKS 1
62 #endif
63
64 enum cvmx_pow_tag_type {
65 /* Tag ordering is maintained */
66 CVMX_POW_TAG_TYPE_ORDERED = 0L,
67 /* Tag ordering is maintained, and at most one PP has the tag */
68 CVMX_POW_TAG_TYPE_ATOMIC = 1L,
69 /*
70 * The work queue entry from the order - NEVER tag switch from
71 * NULL to NULL
72 */
73 CVMX_POW_TAG_TYPE_NULL = 2L,
74 /* A tag switch to NULL, and there is no space reserved in POW
75 * - NEVER tag switch to NULL_NULL
76 * - NEVER tag switch from NULL_NULL
77 * - NULL_NULL is entered at the beginning of time and on a deschedule.
78 * - NULL_NULL can be exited by a new work request. A NULL_SWITCH
79 * load can also switch the state to NULL
80 */
81 CVMX_POW_TAG_TYPE_NULL_NULL = 3L
82 };
83
84 /**
85 * Wait flag values for pow functions.
86 */
87 typedef enum {
88 CVMX_POW_WAIT = 1,
89 CVMX_POW_NO_WAIT = 0,
90 } cvmx_pow_wait_t;
91
92 /**
93 * POW tag operations. These are used in the data stored to the POW.
94 */
95 typedef enum {
96 /*
97 * switch the tag (only) for this PP
98 * - the previous tag should be non-NULL in this case
99 * - tag switch response required
100 * - fields used: op, type, tag
101 */
102 CVMX_POW_TAG_OP_SWTAG = 0L,
103 /*
104 * switch the tag for this PP, with full information
105 * - this should be used when the previous tag is NULL
106 * - tag switch response required
107 * - fields used: address, op, grp, type, tag
108 */
109 CVMX_POW_TAG_OP_SWTAG_FULL = 1L,
110 /*
111 * switch the tag (and/or group) for this PP and de-schedule
112 * - OK to keep the tag the same and only change the group
113 * - fields used: op, no_sched, grp, type, tag
114 */
115 CVMX_POW_TAG_OP_SWTAG_DESCH = 2L,
116 /*
117 * just de-schedule
118 * - fields used: op, no_sched
119 */
120 CVMX_POW_TAG_OP_DESCH = 3L,
121 /*
122 * create an entirely new work queue entry
123 * - fields used: address, op, qos, grp, type, tag
124 */
125 CVMX_POW_TAG_OP_ADDWQ = 4L,
126 /*
127 * just update the work queue pointer and grp for this PP
128 * - fields used: address, op, grp
129 */
130 CVMX_POW_TAG_OP_UPDATE_WQP_GRP = 5L,
131 /*
132 * set the no_sched bit on the de-schedule list
133 *
134 * - does nothing if the selected entry is not on the
135 * de-schedule list
136 *
137 * - does nothing if the stored work queue pointer does not
138 * match the address field
139 *
140 * - fields used: address, index, op
141 *
142 * Before issuing a *_NSCHED operation, SW must guarantee
143 * that all prior deschedules and set/clr NSCHED operations
144 * are complete and all prior switches are complete. The
145 * hardware provides the opsdone bit and swdone bit for SW
146 * polling. After issuing a *_NSCHED operation, SW must
147 * guarantee that the set/clr NSCHED is complete before any
148 * subsequent operations.
149 */
150 CVMX_POW_TAG_OP_SET_NSCHED = 6L,
151 /*
152 * clears the no_sched bit on the de-schedule list
153 *
154 * - does nothing if the selected entry is not on the
155 * de-schedule list
156 *
157 * - does nothing if the stored work queue pointer does not
158 * match the address field
159 *
160 * - fields used: address, index, op
161 *
162 * Before issuing a *_NSCHED operation, SW must guarantee that
163 * all prior deschedules and set/clr NSCHED operations are
164 * complete and all prior switches are complete. The hardware
165 * provides the opsdone bit and swdone bit for SW
166 * polling. After issuing a *_NSCHED operation, SW must
167 * guarantee that the set/clr NSCHED is complete before any
168 * subsequent operations.
169 */
170 CVMX_POW_TAG_OP_CLR_NSCHED = 7L,
171 /* do nothing */
172 CVMX_POW_TAG_OP_NOP = 15L
173 } cvmx_pow_tag_op_t;
174
175 /**
176 * This structure defines the store data on a store to POW
177 */
178 typedef union {
179 uint64_t u64;
180 struct {
181 #ifdef __BIG_ENDIAN_BITFIELD
182 /*
183 * Don't reschedule this entry. no_sched is used for
184 * CVMX_POW_TAG_OP_SWTAG_DESCH and
185 * CVMX_POW_TAG_OP_DESCH
186 */
187 uint64_t no_sched:1;
188 uint64_t unused:2;
189 /* Tontains index of entry for a CVMX_POW_TAG_OP_*_NSCHED */
190 uint64_t index:13;
191 /* The operation to perform */
192 cvmx_pow_tag_op_t op:4;
193 uint64_t unused2:2;
194 /*
195 * The QOS level for the packet. qos is only used for
196 * CVMX_POW_TAG_OP_ADDWQ
197 */
198 uint64_t qos:3;
199 /*
200 * The group that the work queue entry will be
201 * scheduled to grp is used for CVMX_POW_TAG_OP_ADDWQ,
202 * CVMX_POW_TAG_OP_SWTAG_FULL,
203 * CVMX_POW_TAG_OP_SWTAG_DESCH, and
204 * CVMX_POW_TAG_OP_UPDATE_WQP_GRP
205 */
206 uint64_t grp:4;
207 /*
208 * The type of the tag. type is used for everything
209 * except CVMX_POW_TAG_OP_DESCH,
210 * CVMX_POW_TAG_OP_UPDATE_WQP_GRP, and
211 * CVMX_POW_TAG_OP_*_NSCHED
212 */
213 uint64_t type:3;
214 /*
215 * The actual tag. tag is used for everything except
216 * CVMX_POW_TAG_OP_DESCH,
217 * CVMX_POW_TAG_OP_UPDATE_WQP_GRP, and
218 * CVMX_POW_TAG_OP_*_NSCHED
219 */
220 uint64_t tag:32;
221 #else
222 uint64_t tag:32;
223 uint64_t type:3;
224 uint64_t grp:4;
225 uint64_t qos:3;
226 uint64_t unused2:2;
227 cvmx_pow_tag_op_t op:4;
228 uint64_t index:13;
229 uint64_t unused:2;
230 uint64_t no_sched:1;
231 #endif
232 } s;
233 } cvmx_pow_tag_req_t;
234
235 /**
236 * This structure describes the address to load stuff from POW
237 */
238 typedef union {
239 uint64_t u64;
240
241 /**
242 * Address for new work request loads (did<2:0> == 0)
243 */
244 struct {
245 #ifdef __BIG_ENDIAN_BITFIELD
246 /* Mips64 address region. Should be CVMX_IO_SEG */
247 uint64_t mem_region:2;
248 /* Must be zero */
249 uint64_t reserved_49_61:13;
250 /* Must be one */
251 uint64_t is_io:1;
252 /* the ID of POW -- did<2:0> == 0 in this case */
253 uint64_t did:8;
254 /* Must be zero */
255 uint64_t reserved_4_39:36;
256 /*
257 * If set, don't return load response until work is
258 * available.
259 */
260 uint64_t wait:1;
261 /* Must be zero */
262 uint64_t reserved_0_2:3;
263 #else
264 uint64_t reserved_0_2:3;
265 uint64_t wait:1;
266 uint64_t reserved_4_39:36;
267 uint64_t did:8;
268 uint64_t is_io:1;
269 uint64_t reserved_49_61:13;
270 uint64_t mem_region:2;
271 #endif
272 } swork;
273
274 /**
275 * Address for loads to get POW internal status
276 */
277 struct {
278 #ifdef __BIG_ENDIAN_BITFIELD
279 /* Mips64 address region. Should be CVMX_IO_SEG */
280 uint64_t mem_region:2;
281 /* Must be zero */
282 uint64_t reserved_49_61:13;
283 /* Must be one */
284 uint64_t is_io:1;
285 /* the ID of POW -- did<2:0> == 1 in this case */
286 uint64_t did:8;
287 /* Must be zero */
288 uint64_t reserved_10_39:30;
289 /* The core id to get status for */
290 uint64_t coreid:4;
291 /*
292 * If set and get_cur is set, return reverse tag-list
293 * pointer rather than forward tag-list pointer.
294 */
295 uint64_t get_rev:1;
296 /*
297 * If set, return current status rather than pending
298 * status.
299 */
300 uint64_t get_cur:1;
301 /*
302 * If set, get the work-queue pointer rather than
303 * tag/type.
304 */
305 uint64_t get_wqp:1;
306 /* Must be zero */
307 uint64_t reserved_0_2:3;
308 #else
309 uint64_t reserved_0_2:3;
310 uint64_t get_wqp:1;
311 uint64_t get_cur:1;
312 uint64_t get_rev:1;
313 uint64_t coreid:4;
314 uint64_t reserved_10_39:30;
315 uint64_t did:8;
316 uint64_t is_io:1;
317 uint64_t reserved_49_61:13;
318 uint64_t mem_region:2;
319 #endif
320 } sstatus;
321
322 /**
323 * Address for memory loads to get POW internal state
324 */
325 struct {
326 #ifdef __BIG_ENDIAN_BITFIELD
327 /* Mips64 address region. Should be CVMX_IO_SEG */
328 uint64_t mem_region:2;
329 /* Must be zero */
330 uint64_t reserved_49_61:13;
331 /* Must be one */
332 uint64_t is_io:1;
333 /* the ID of POW -- did<2:0> == 2 in this case */
334 uint64_t did:8;
335 /* Must be zero */
336 uint64_t reserved_16_39:24;
337 /* POW memory index */
338 uint64_t index:11;
339 /*
340 * If set, return deschedule information rather than
341 * the standard response for work-queue index (invalid
342 * if the work-queue entry is not on the deschedule
343 * list).
344 */
345 uint64_t get_des:1;
346 /*
347 * If set, get the work-queue pointer rather than
348 * tag/type (no effect when get_des set).
349 */
350 uint64_t get_wqp:1;
351 /* Must be zero */
352 uint64_t reserved_0_2:3;
353 #else
354 uint64_t reserved_0_2:3;
355 uint64_t get_wqp:1;
356 uint64_t get_des:1;
357 uint64_t index:11;
358 uint64_t reserved_16_39:24;
359 uint64_t did:8;
360 uint64_t is_io:1;
361 uint64_t reserved_49_61:13;
362 uint64_t mem_region:2;
363 #endif
364 } smemload;
365
366 /**
367 * Address for index/pointer loads
368 */
369 struct {
370 #ifdef __BIG_ENDIAN_BITFIELD
371 /* Mips64 address region. Should be CVMX_IO_SEG */
372 uint64_t mem_region:2;
373 /* Must be zero */
374 uint64_t reserved_49_61:13;
375 /* Must be one */
376 uint64_t is_io:1;
377 /* the ID of POW -- did<2:0> == 3 in this case */
378 uint64_t did:8;
379 /* Must be zero */
380 uint64_t reserved_9_39:31;
381 /*
382 * when {get_rmt ==0 AND get_des_get_tail == 0}, this
383 * field selects one of eight POW internal-input
384 * queues (0-7), one per QOS level; values 8-15 are
385 * illegal in this case; when {get_rmt ==0 AND
386 * get_des_get_tail == 1}, this field selects one of
387 * 16 deschedule lists (per group); when get_rmt ==1,
388 * this field selects one of 16 memory-input queue
389 * lists. The two memory-input queue lists associated
390 * with each QOS level are:
391 *
392 * - qosgrp = 0, qosgrp = 8: QOS0
393 * - qosgrp = 1, qosgrp = 9: QOS1
394 * - qosgrp = 2, qosgrp = 10: QOS2
395 * - qosgrp = 3, qosgrp = 11: QOS3
396 * - qosgrp = 4, qosgrp = 12: QOS4
397 * - qosgrp = 5, qosgrp = 13: QOS5
398 * - qosgrp = 6, qosgrp = 14: QOS6
399 * - qosgrp = 7, qosgrp = 15: QOS7
400 */
401 uint64_t qosgrp:4;
402 /*
403 * If set and get_rmt is clear, return deschedule list
404 * indexes rather than indexes for the specified qos
405 * level; if set and get_rmt is set, return the tail
406 * pointer rather than the head pointer for the
407 * specified qos level.
408 */
409 uint64_t get_des_get_tail:1;
410 /*
411 * If set, return remote pointers rather than the
412 * local indexes for the specified qos level.
413 */
414 uint64_t get_rmt:1;
415 /* Must be zero */
416 uint64_t reserved_0_2:3;
417 #else
418 uint64_t reserved_0_2:3;
419 uint64_t get_rmt:1;
420 uint64_t get_des_get_tail:1;
421 uint64_t qosgrp:4;
422 uint64_t reserved_9_39:31;
423 uint64_t did:8;
424 uint64_t is_io:1;
425 uint64_t reserved_49_61:13;
426 uint64_t mem_region:2;
427 #endif
428 } sindexload;
429
430 /**
431 * address for NULL_RD request (did<2:0> == 4) when this is read,
432 * HW attempts to change the state to NULL if it is NULL_NULL (the
433 * hardware cannot switch from NULL_NULL to NULL if a POW entry is
434 * not available - software may need to recover by finishing
435 * another piece of work before a POW entry can ever become
436 * available.)
437 */
438 struct {
439 #ifdef __BIG_ENDIAN_BITFIELD
440 /* Mips64 address region. Should be CVMX_IO_SEG */
441 uint64_t mem_region:2;
442 /* Must be zero */
443 uint64_t reserved_49_61:13;
444 /* Must be one */
445 uint64_t is_io:1;
446 /* the ID of POW -- did<2:0> == 4 in this case */
447 uint64_t did:8;
448 /* Must be zero */
449 uint64_t reserved_0_39:40;
450 #else
451 uint64_t reserved_0_39:40;
452 uint64_t did:8;
453 uint64_t is_io:1;
454 uint64_t reserved_49_61:13;
455 uint64_t mem_region:2;
456 #endif
457 } snull_rd;
458 } cvmx_pow_load_addr_t;
459
460 /**
461 * This structure defines the response to a load/SENDSINGLE to POW
462 * (except CSR reads)
463 */
464 typedef union {
465 uint64_t u64;
466
467 /**
468 * Response to new work request loads
469 */
470 struct {
471 #ifdef __BIG_ENDIAN_BITFIELD
472 /*
473 * Set when no new work queue entry was returned. *
474 * If there was de-scheduled work, the HW will
475 * definitely return it. When this bit is set, it
476 * could mean either mean:
477 *
478 * - There was no work, or
479 *
480 * - There was no work that the HW could find. This
481 * case can happen, regardless of the wait bit value
482 * in the original request, when there is work in
483 * the IQ's that is too deep down the list.
484 */
485 uint64_t no_work:1;
486 /* Must be zero */
487 uint64_t reserved_40_62:23;
488 /* 36 in O1 -- the work queue pointer */
489 uint64_t addr:40;
490 #else
491 uint64_t addr:40;
492 uint64_t reserved_40_62:23;
493 uint64_t no_work:1;
494 #endif
495 } s_work;
496
497 /**
498 * Result for a POW Status Load (when get_cur==0 and get_wqp==0)
499 */
500 struct {
501 #ifdef __BIG_ENDIAN_BITFIELD
502 uint64_t reserved_62_63:2;
503 /* Set when there is a pending non-NULL SWTAG or
504 * SWTAG_FULL, and the POW entry has not left the list
505 * for the original tag. */
506 uint64_t pend_switch:1;
507 /* Set when SWTAG_FULL and pend_switch is set. */
508 uint64_t pend_switch_full:1;
509 /*
510 * Set when there is a pending NULL SWTAG, or an
511 * implicit switch to NULL.
512 */
513 uint64_t pend_switch_null:1;
514 /* Set when there is a pending DESCHED or SWTAG_DESCHED. */
515 uint64_t pend_desched:1;
516 /*
517 * Set when there is a pending SWTAG_DESCHED and
518 * pend_desched is set.
519 */
520 uint64_t pend_desched_switch:1;
521 /* Set when nosched is desired and pend_desched is set. */
522 uint64_t pend_nosched:1;
523 /* Set when there is a pending GET_WORK. */
524 uint64_t pend_new_work:1;
525 /*
526 * When pend_new_work is set, this bit indicates that
527 * the wait bit was set.
528 */
529 uint64_t pend_new_work_wait:1;
530 /* Set when there is a pending NULL_RD. */
531 uint64_t pend_null_rd:1;
532 /* Set when there is a pending CLR_NSCHED. */
533 uint64_t pend_nosched_clr:1;
534 uint64_t reserved_51:1;
535 /* This is the index when pend_nosched_clr is set. */
536 uint64_t pend_index:11;
537 /*
538 * This is the new_grp when (pend_desched AND
539 * pend_desched_switch) is set.
540 */
541 uint64_t pend_grp:4;
542 uint64_t reserved_34_35:2;
543 /*
544 * This is the tag type when pend_switch or
545 * (pend_desched AND pend_desched_switch) are set.
546 */
547 uint64_t pend_type:2;
548 /*
549 * - this is the tag when pend_switch or (pend_desched
550 * AND pend_desched_switch) are set.
551 */
552 uint64_t pend_tag:32;
553 #else
554 uint64_t pend_tag:32;
555 uint64_t pend_type:2;
556 uint64_t reserved_34_35:2;
557 uint64_t pend_grp:4;
558 uint64_t pend_index:11;
559 uint64_t reserved_51:1;
560 uint64_t pend_nosched_clr:1;
561 uint64_t pend_null_rd:1;
562 uint64_t pend_new_work_wait:1;
563 uint64_t pend_new_work:1;
564 uint64_t pend_nosched:1;
565 uint64_t pend_desched_switch:1;
566 uint64_t pend_desched:1;
567 uint64_t pend_switch_null:1;
568 uint64_t pend_switch_full:1;
569 uint64_t pend_switch:1;
570 uint64_t reserved_62_63:2;
571 #endif
572 } s_sstatus0;
573
574 /**
575 * Result for a POW Status Load (when get_cur==0 and get_wqp==1)
576 */
577 struct {
578 #ifdef __BIG_ENDIAN_BITFIELD
579 uint64_t reserved_62_63:2;
580 /*
581 * Set when there is a pending non-NULL SWTAG or
582 * SWTAG_FULL, and the POW entry has not left the list
583 * for the original tag.
584 */
585 uint64_t pend_switch:1;
586 /* Set when SWTAG_FULL and pend_switch is set. */
587 uint64_t pend_switch_full:1;
588 /*
589 * Set when there is a pending NULL SWTAG, or an
590 * implicit switch to NULL.
591 */
592 uint64_t pend_switch_null:1;
593 /*
594 * Set when there is a pending DESCHED or
595 * SWTAG_DESCHED.
596 */
597 uint64_t pend_desched:1;
598 /*
599 * Set when there is a pending SWTAG_DESCHED and
600 * pend_desched is set.
601 */
602 uint64_t pend_desched_switch:1;
603 /* Set when nosched is desired and pend_desched is set. */
604 uint64_t pend_nosched:1;
605 /* Set when there is a pending GET_WORK. */
606 uint64_t pend_new_work:1;
607 /*
608 * When pend_new_work is set, this bit indicates that
609 * the wait bit was set.
610 */
611 uint64_t pend_new_work_wait:1;
612 /* Set when there is a pending NULL_RD. */
613 uint64_t pend_null_rd:1;
614 /* Set when there is a pending CLR_NSCHED. */
615 uint64_t pend_nosched_clr:1;
616 uint64_t reserved_51:1;
617 /* This is the index when pend_nosched_clr is set. */
618 uint64_t pend_index:11;
619 /*
620 * This is the new_grp when (pend_desched AND
621 * pend_desched_switch) is set.
622 */
623 uint64_t pend_grp:4;
624 /* This is the wqp when pend_nosched_clr is set. */
625 uint64_t pend_wqp:36;
626 #else
627 uint64_t pend_wqp:36;
628 uint64_t pend_grp:4;
629 uint64_t pend_index:11;
630 uint64_t reserved_51:1;
631 uint64_t pend_nosched_clr:1;
632 uint64_t pend_null_rd:1;
633 uint64_t pend_new_work_wait:1;
634 uint64_t pend_new_work:1;
635 uint64_t pend_nosched:1;
636 uint64_t pend_desched_switch:1;
637 uint64_t pend_desched:1;
638 uint64_t pend_switch_null:1;
639 uint64_t pend_switch_full:1;
640 uint64_t pend_switch:1;
641 uint64_t reserved_62_63:2;
642 #endif
643 } s_sstatus1;
644
645 /**
646 * Result for a POW Status Load (when get_cur==1, get_wqp==0, and
647 * get_rev==0)
648 */
649 struct {
650 #ifdef __BIG_ENDIAN_BITFIELD
651 uint64_t reserved_62_63:2;
652 /*
653 * Points to the next POW entry in the tag list when
654 * tail == 0 (and tag_type is not NULL or NULL_NULL).
655 */
656 uint64_t link_index:11;
657 /* The POW entry attached to the core. */
658 uint64_t index:11;
659 /*
660 * The group attached to the core (updated when new
661 * tag list entered on SWTAG_FULL).
662 */
663 uint64_t grp:4;
664 /*
665 * Set when this POW entry is at the head of its tag
666 * list (also set when in the NULL or NULL_NULL
667 * state).
668 */
669 uint64_t head:1;
670 /*
671 * Set when this POW entry is at the tail of its tag
672 * list (also set when in the NULL or NULL_NULL
673 * state).
674 */
675 uint64_t tail:1;
676 /*
677 * The tag type attached to the core (updated when new
678 * tag list entered on SWTAG, SWTAG_FULL, or
679 * SWTAG_DESCHED).
680 */
681 uint64_t tag_type:2;
682 /*
683 * The tag attached to the core (updated when new tag
684 * list entered on SWTAG, SWTAG_FULL, or
685 * SWTAG_DESCHED).
686 */
687 uint64_t tag:32;
688 #else
689 uint64_t tag:32;
690 uint64_t tag_type:2;
691 uint64_t tail:1;
692 uint64_t head:1;
693 uint64_t grp:4;
694 uint64_t index:11;
695 uint64_t link_index:11;
696 uint64_t reserved_62_63:2;
697 #endif
698 } s_sstatus2;
699
700 /**
701 * Result for a POW Status Load (when get_cur==1, get_wqp==0, and get_rev==1)
702 */
703 struct {
704 #ifdef __BIG_ENDIAN_BITFIELD
705 uint64_t reserved_62_63:2;
706 /*
707 * Points to the prior POW entry in the tag list when
708 * head == 0 (and tag_type is not NULL or
709 * NULL_NULL). This field is unpredictable when the
710 * core's state is NULL or NULL_NULL.
711 */
712 uint64_t revlink_index:11;
713 /* The POW entry attached to the core. */
714 uint64_t index:11;
715 /*
716 * The group attached to the core (updated when new
717 * tag list entered on SWTAG_FULL).
718 */
719 uint64_t grp:4;
720 /* Set when this POW entry is at the head of its tag
721 * list (also set when in the NULL or NULL_NULL
722 * state).
723 */
724 uint64_t head:1;
725 /*
726 * Set when this POW entry is at the tail of its tag
727 * list (also set when in the NULL or NULL_NULL
728 * state).
729 */
730 uint64_t tail:1;
731 /*
732 * The tag type attached to the core (updated when new
733 * tag list entered on SWTAG, SWTAG_FULL, or
734 * SWTAG_DESCHED).
735 */
736 uint64_t tag_type:2;
737 /*
738 * The tag attached to the core (updated when new tag
739 * list entered on SWTAG, SWTAG_FULL, or
740 * SWTAG_DESCHED).
741 */
742 uint64_t tag:32;
743 #else
744 uint64_t tag:32;
745 uint64_t tag_type:2;
746 uint64_t tail:1;
747 uint64_t head:1;
748 uint64_t grp:4;
749 uint64_t index:11;
750 uint64_t revlink_index:11;
751 uint64_t reserved_62_63:2;
752 #endif
753 } s_sstatus3;
754
755 /**
756 * Result for a POW Status Load (when get_cur==1, get_wqp==1, and
757 * get_rev==0)
758 */
759 struct {
760 #ifdef __BIG_ENDIAN_BITFIELD
761 uint64_t reserved_62_63:2;
762 /*
763 * Points to the next POW entry in the tag list when
764 * tail == 0 (and tag_type is not NULL or NULL_NULL).
765 */
766 uint64_t link_index:11;
767 /* The POW entry attached to the core. */
768 uint64_t index:11;
769 /*
770 * The group attached to the core (updated when new
771 * tag list entered on SWTAG_FULL).
772 */
773 uint64_t grp:4;
774 /*
775 * The wqp attached to the core (updated when new tag
776 * list entered on SWTAG_FULL).
777 */
778 uint64_t wqp:36;
779 #else
780 uint64_t wqp:36;
781 uint64_t grp:4;
782 uint64_t index:11;
783 uint64_t link_index:11;
784 uint64_t reserved_62_63:2;
785 #endif
786 } s_sstatus4;
787
788 /**
789 * Result for a POW Status Load (when get_cur==1, get_wqp==1, and
790 * get_rev==1)
791 */
792 struct {
793 #ifdef __BIG_ENDIAN_BITFIELD
794 uint64_t reserved_62_63:2;
795 /*
796 * Points to the prior POW entry in the tag list when
797 * head == 0 (and tag_type is not NULL or
798 * NULL_NULL). This field is unpredictable when the
799 * core's state is NULL or NULL_NULL.
800 */
801 uint64_t revlink_index:11;
802 /* The POW entry attached to the core. */
803 uint64_t index:11;
804 /*
805 * The group attached to the core (updated when new
806 * tag list entered on SWTAG_FULL).
807 */
808 uint64_t grp:4;
809 /*
810 * The wqp attached to the core (updated when new tag
811 * list entered on SWTAG_FULL).
812 */
813 uint64_t wqp:36;
814 #else
815 uint64_t wqp:36;
816 uint64_t grp:4;
817 uint64_t index:11;
818 uint64_t revlink_index:11;
819 uint64_t reserved_62_63:2;
820 #endif
821 } s_sstatus5;
822
823 /**
824 * Result For POW Memory Load (get_des == 0 and get_wqp == 0)
825 */
826 struct {
827 #ifdef __BIG_ENDIAN_BITFIELD
828 uint64_t reserved_51_63:13;
829 /*
830 * The next entry in the input, free, descheduled_head
831 * list (unpredictable if entry is the tail of the
832 * list).
833 */
834 uint64_t next_index:11;
835 /* The group of the POW entry. */
836 uint64_t grp:4;
837 uint64_t reserved_35:1;
838 /*
839 * Set when this POW entry is at the tail of its tag
840 * list (also set when in the NULL or NULL_NULL
841 * state).
842 */
843 uint64_t tail:1;
844 /* The tag type of the POW entry. */
845 uint64_t tag_type:2;
846 /* The tag of the POW entry. */
847 uint64_t tag:32;
848 #else
849 uint64_t tag:32;
850 uint64_t tag_type:2;
851 uint64_t tail:1;
852 uint64_t reserved_35:1;
853 uint64_t grp:4;
854 uint64_t next_index:11;
855 uint64_t reserved_51_63:13;
856 #endif
857 } s_smemload0;
858
859 /**
860 * Result For POW Memory Load (get_des == 0 and get_wqp == 1)
861 */
862 struct {
863 #ifdef __BIG_ENDIAN_BITFIELD
864 uint64_t reserved_51_63:13;
865 /*
866 * The next entry in the input, free, descheduled_head
867 * list (unpredictable if entry is the tail of the
868 * list).
869 */
870 uint64_t next_index:11;
871 /* The group of the POW entry. */
872 uint64_t grp:4;
873 /* The WQP held in the POW entry. */
874 uint64_t wqp:36;
875 #else
876 uint64_t wqp:36;
877 uint64_t grp:4;
878 uint64_t next_index:11;
879 uint64_t reserved_51_63:13;
880 #endif
881 } s_smemload1;
882
883 /**
884 * Result For POW Memory Load (get_des == 1)
885 */
886 struct {
887 #ifdef __BIG_ENDIAN_BITFIELD
888 uint64_t reserved_51_63:13;
889 /*
890 * The next entry in the tag list connected to the
891 * descheduled head.
892 */
893 uint64_t fwd_index:11;
894 /* The group of the POW entry. */
895 uint64_t grp:4;
896 /* The nosched bit for the POW entry. */
897 uint64_t nosched:1;
898 /* There is a pending tag switch */
899 uint64_t pend_switch:1;
900 /*
901 * The next tag type for the new tag list when
902 * pend_switch is set.
903 */
904 uint64_t pend_type:2;
905 /*
906 * The next tag for the new tag list when pend_switch
907 * is set.
908 */
909 uint64_t pend_tag:32;
910 #else
911 uint64_t pend_tag:32;
912 uint64_t pend_type:2;
913 uint64_t pend_switch:1;
914 uint64_t nosched:1;
915 uint64_t grp:4;
916 uint64_t fwd_index:11;
917 uint64_t reserved_51_63:13;
918 #endif
919 } s_smemload2;
920
921 /**
922 * Result For POW Index/Pointer Load (get_rmt == 0/get_des_get_tail == 0)
923 */
924 struct {
925 #ifdef __BIG_ENDIAN_BITFIELD
926 uint64_t reserved_52_63:12;
927 /*
928 * set when there is one or more POW entries on the
929 * free list.
930 */
931 uint64_t free_val:1;
932 /*
933 * set when there is exactly one POW entry on the free
934 * list.
935 */
936 uint64_t free_one:1;
937 uint64_t reserved_49:1;
938 /*
939 * when free_val is set, indicates the first entry on
940 * the free list.
941 */
942 uint64_t free_head:11;
943 uint64_t reserved_37:1;
944 /*
945 * when free_val is set, indicates the last entry on
946 * the free list.
947 */
948 uint64_t free_tail:11;
949 /*
950 * set when there is one or more POW entries on the
951 * input Q list selected by qosgrp.
952 */
953 uint64_t loc_val:1;
954 /*
955 * set when there is exactly one POW entry on the
956 * input Q list selected by qosgrp.
957 */
958 uint64_t loc_one:1;
959 uint64_t reserved_23:1;
960 /*
961 * when loc_val is set, indicates the first entry on
962 * the input Q list selected by qosgrp.
963 */
964 uint64_t loc_head:11;
965 uint64_t reserved_11:1;
966 /*
967 * when loc_val is set, indicates the last entry on
968 * the input Q list selected by qosgrp.
969 */
970 uint64_t loc_tail:11;
971 #else
972 uint64_t loc_tail:11;
973 uint64_t reserved_11:1;
974 uint64_t loc_head:11;
975 uint64_t reserved_23:1;
976 uint64_t loc_one:1;
977 uint64_t loc_val:1;
978 uint64_t free_tail:11;
979 uint64_t reserved_37:1;
980 uint64_t free_head:11;
981 uint64_t reserved_49:1;
982 uint64_t free_one:1;
983 uint64_t free_val:1;
984 uint64_t reserved_52_63:12;
985 #endif
986 } sindexload0;
987
988 /**
989 * Result For POW Index/Pointer Load (get_rmt == 0/get_des_get_tail == 1)
990 */
991 struct {
992 #ifdef __BIG_ENDIAN_BITFIELD
993 uint64_t reserved_52_63:12;
994 /*
995 * set when there is one or more POW entries on the
996 * nosched list.
997 */
998 uint64_t nosched_val:1;
999 /*
1000 * set when there is exactly one POW entry on the
1001 * nosched list.
1002 */
1003 uint64_t nosched_one:1;
1004 uint64_t reserved_49:1;
1005 /*
1006 * when nosched_val is set, indicates the first entry
1007 * on the nosched list.
1008 */
1009 uint64_t nosched_head:11;
1010 uint64_t reserved_37:1;
1011 /*
1012 * when nosched_val is set, indicates the last entry
1013 * on the nosched list.
1014 */
1015 uint64_t nosched_tail:11;
1016 /*
1017 * set when there is one or more descheduled heads on
1018 * the descheduled list selected by qosgrp.
1019 */
1020 uint64_t des_val:1;
1021 /*
1022 * set when there is exactly one descheduled head on
1023 * the descheduled list selected by qosgrp.
1024 */
1025 uint64_t des_one:1;
1026 uint64_t reserved_23:1;
1027 /*
1028 * when des_val is set, indicates the first
1029 * descheduled head on the descheduled list selected
1030 * by qosgrp.
1031 */
1032 uint64_t des_head:11;
1033 uint64_t reserved_11:1;
1034 /*
1035 * when des_val is set, indicates the last descheduled
1036 * head on the descheduled list selected by qosgrp.
1037 */
1038 uint64_t des_tail:11;
1039 #else
1040 uint64_t des_tail:11;
1041 uint64_t reserved_11:1;
1042 uint64_t des_head:11;
1043 uint64_t reserved_23:1;
1044 uint64_t des_one:1;
1045 uint64_t des_val:1;
1046 uint64_t nosched_tail:11;
1047 uint64_t reserved_37:1;
1048 uint64_t nosched_head:11;
1049 uint64_t reserved_49:1;
1050 uint64_t nosched_one:1;
1051 uint64_t nosched_val:1;
1052 uint64_t reserved_52_63:12;
1053 #endif
1054 } sindexload1;
1055
1056 /**
1057 * Result For POW Index/Pointer Load (get_rmt == 1/get_des_get_tail == 0)
1058 */
1059 struct {
1060 #ifdef __BIG_ENDIAN_BITFIELD
1061 uint64_t reserved_39_63:25;
1062 /*
1063 * Set when this DRAM list is the current head
1064 * (i.e. is the next to be reloaded when the POW
1065 * hardware reloads a POW entry from DRAM). The POW
1066 * hardware alternates between the two DRAM lists
1067 * associated with a QOS level when it reloads work
1068 * from DRAM into the POW unit.
1069 */
1070 uint64_t rmt_is_head:1;
1071 /*
1072 * Set when the DRAM portion of the input Q list
1073 * selected by qosgrp contains one or more pieces of
1074 * work.
1075 */
1076 uint64_t rmt_val:1;
1077 /*
1078 * Set when the DRAM portion of the input Q list
1079 * selected by qosgrp contains exactly one piece of
1080 * work.
1081 */
1082 uint64_t rmt_one:1;
1083 /*
1084 * When rmt_val is set, indicates the first piece of
1085 * work on the DRAM input Q list selected by
1086 * qosgrp.
1087 */
1088 uint64_t rmt_head:36;
1089 #else
1090 uint64_t rmt_head:36;
1091 uint64_t rmt_one:1;
1092 uint64_t rmt_val:1;
1093 uint64_t rmt_is_head:1;
1094 uint64_t reserved_39_63:25;
1095 #endif
1096 } sindexload2;
1097
1098 /**
1099 * Result For POW Index/Pointer Load (get_rmt ==
1100 * 1/get_des_get_tail == 1)
1101 */
1102 struct {
1103 #ifdef __BIG_ENDIAN_BITFIELD
1104 uint64_t reserved_39_63:25;
1105 /*
1106 * set when this DRAM list is the current head
1107 * (i.e. is the next to be reloaded when the POW
1108 * hardware reloads a POW entry from DRAM). The POW
1109 * hardware alternates between the two DRAM lists
1110 * associated with a QOS level when it reloads work
1111 * from DRAM into the POW unit.
1112 */
1113 uint64_t rmt_is_head:1;
1114 /*
1115 * set when the DRAM portion of the input Q list
1116 * selected by qosgrp contains one or more pieces of
1117 * work.
1118 */
1119 uint64_t rmt_val:1;
1120 /*
1121 * set when the DRAM portion of the input Q list
1122 * selected by qosgrp contains exactly one piece of
1123 * work.
1124 */
1125 uint64_t rmt_one:1;
1126 /*
1127 * when rmt_val is set, indicates the last piece of
1128 * work on the DRAM input Q list selected by
1129 * qosgrp.
1130 */
1131 uint64_t rmt_tail:36;
1132 #else
1133 uint64_t rmt_tail:36;
1134 uint64_t rmt_one:1;
1135 uint64_t rmt_val:1;
1136 uint64_t rmt_is_head:1;
1137 uint64_t reserved_39_63:25;
1138 #endif
1139 } sindexload3;
1140
1141 /**
1142 * Response to NULL_RD request loads
1143 */
1144 struct {
1145 #ifdef __BIG_ENDIAN_BITFIELD
1146 uint64_t unused:62;
1147 /* of type cvmx_pow_tag_type_t. state is one of the
1148 * following:
1149 *
1150 * - CVMX_POW_TAG_TYPE_ORDERED
1151 * - CVMX_POW_TAG_TYPE_ATOMIC
1152 * - CVMX_POW_TAG_TYPE_NULL
1153 * - CVMX_POW_TAG_TYPE_NULL_NULL
1154 */
1155 uint64_t state:2;
1156 #else
1157 uint64_t state:2;
1158 uint64_t unused:62;
1159 #endif
1160 } s_null_rd;
1161
1162 } cvmx_pow_tag_load_resp_t;
1163
1164 /**
1165 * This structure describes the address used for stores to the POW.
1166 * The store address is meaningful on stores to the POW. The
1167 * hardware assumes that an aligned 64-bit store was used for all
1168 * these stores. Note the assumption that the work queue entry is
1169 * aligned on an 8-byte boundary (since the low-order 3 address bits
1170 * must be zero). Note that not all fields are used by all
1171 * operations.
1172 *
1173 * NOTE: The following is the behavior of the pending switch bit at the PP
1174 * for POW stores (i.e. when did<7:3> == 0xc)
1175 * - did<2:0> == 0 => pending switch bit is set
1176 * - did<2:0> == 1 => no affect on the pending switch bit
1177 * - did<2:0> == 3 => pending switch bit is cleared
1178 * - did<2:0> == 7 => no affect on the pending switch bit
1179 * - did<2:0> == others => must not be used
1180 * - No other loads/stores have an affect on the pending switch bit
1181 * - The switch bus from POW can clear the pending switch bit
1182 *
1183 * NOTE: did<2:0> == 2 is used by the HW for a special single-cycle
1184 * ADDWQ command that only contains the pointer). SW must never use
1185 * did<2:0> == 2.
1186 */
1187 typedef union {
1188 /**
1189 * Unsigned 64 bit integer representation of store address
1190 */
1191 uint64_t u64;
1192
1193 struct {
1194 #ifdef __BIG_ENDIAN_BITFIELD
1195 /* Memory region. Should be CVMX_IO_SEG in most cases */
1196 uint64_t mem_reg:2;
1197 uint64_t reserved_49_61:13; /* Must be zero */
1198 uint64_t is_io:1; /* Must be one */
1199 /* Device ID of POW. Note that different sub-dids are used. */
1200 uint64_t did:8;
1201 uint64_t reserved_36_39:4; /* Must be zero */
1202 /* Address field. addr<2:0> must be zero */
1203 uint64_t addr:36;
1204 #else
1205 uint64_t addr:36;
1206 uint64_t reserved_36_39:4;
1207 uint64_t did:8;
1208 uint64_t is_io:1;
1209 uint64_t reserved_49_61:13;
1210 uint64_t mem_reg:2;
1211 #endif
1212 } stag;
1213 } cvmx_pow_tag_store_addr_t;
1214
1215 /**
1216 * decode of the store data when an IOBDMA SENDSINGLE is sent to POW
1217 */
1218 typedef union {
1219 uint64_t u64;
1220
1221 struct {
1222 #ifdef __BIG_ENDIAN_BITFIELD
1223 /*
1224 * the (64-bit word) location in scratchpad to write
1225 * to (if len != 0)
1226 */
1227 uint64_t scraddr:8;
1228 /* the number of words in the response (0 => no response) */
1229 uint64_t len:8;
1230 /* the ID of the device on the non-coherent bus */
1231 uint64_t did:8;
1232 uint64_t unused:36;
1233 /* if set, don't return load response until work is available */
1234 uint64_t wait:1;
1235 uint64_t unused2:3;
1236 #else
1237 uint64_t unused2:3;
1238 uint64_t wait:1;
1239 uint64_t unused:36;
1240 uint64_t did:8;
1241 uint64_t len:8;
1242 uint64_t scraddr:8;
1243 #endif
1244 } s;
1245
1246 } cvmx_pow_iobdma_store_t;
1247
1248 /* CSR typedefs have been moved to cvmx-csr-*.h */
1249
1250 /**
1251 * Get the POW tag for this core. This returns the current
1252 * tag type, tag, group, and POW entry index associated with
1253 * this core. Index is only valid if the tag type isn't NULL_NULL.
1254 * If a tag switch is pending this routine returns the tag before
1255 * the tag switch, not after.
1256 *
1257 * Returns Current tag
1258 */
1259 static inline cvmx_pow_tag_req_t cvmx_pow_get_current_tag(void)
1260 {
1261 cvmx_pow_load_addr_t load_addr;
1262 cvmx_pow_tag_load_resp_t load_resp;
1263 cvmx_pow_tag_req_t result;
1264
1265 load_addr.u64 = 0;
1266 load_addr.sstatus.mem_region = CVMX_IO_SEG;
1267 load_addr.sstatus.is_io = 1;
1268 load_addr.sstatus.did = CVMX_OCT_DID_TAG_TAG1;
1269 load_addr.sstatus.coreid = cvmx_get_core_num();
1270 load_addr.sstatus.get_cur = 1;
1271 load_resp.u64 = cvmx_read_csr(load_addr.u64);
1272 result.u64 = 0;
1273 result.s.grp = load_resp.s_sstatus2.grp;
1274 result.s.index = load_resp.s_sstatus2.index;
1275 result.s.type = load_resp.s_sstatus2.tag_type;
1276 result.s.tag = load_resp.s_sstatus2.tag;
1277 return result;
1278 }
1279
1280 /**
1281 * Get the POW WQE for this core. This returns the work queue
1282 * entry currently associated with this core.
1283 *
1284 * Returns WQE pointer
1285 */
1286 static inline struct cvmx_wqe *cvmx_pow_get_current_wqp(void)
1287 {
1288 cvmx_pow_load_addr_t load_addr;
1289 cvmx_pow_tag_load_resp_t load_resp;
1290
1291 load_addr.u64 = 0;
1292 load_addr.sstatus.mem_region = CVMX_IO_SEG;
1293 load_addr.sstatus.is_io = 1;
1294 load_addr.sstatus.did = CVMX_OCT_DID_TAG_TAG1;
1295 load_addr.sstatus.coreid = cvmx_get_core_num();
1296 load_addr.sstatus.get_cur = 1;
1297 load_addr.sstatus.get_wqp = 1;
1298 load_resp.u64 = cvmx_read_csr(load_addr.u64);
1299 return (struct cvmx_wqe *) cvmx_phys_to_ptr(load_resp.s_sstatus4.wqp);
1300 }
1301
1302 #ifndef CVMX_MF_CHORD
1303 #define CVMX_MF_CHORD(dest) CVMX_RDHWR(dest, 30)
1304 #endif
1305
1306 /**
1307 * Print a warning if a tag switch is pending for this core
1308 *
1309 * @function: Function name checking for a pending tag switch
1310 */
1311 static inline void __cvmx_pow_warn_if_pending_switch(const char *function)
1312 {
1313 uint64_t switch_complete;
1314 CVMX_MF_CHORD(switch_complete);
1315 if (!switch_complete)
1316 pr_warn("%s called with tag switch in progress\n", function);
1317 }
1318
1319 /**
1320 * Waits for a tag switch to complete by polling the completion bit.
1321 * Note that switches to NULL complete immediately and do not need
1322 * to be waited for.
1323 */
1324 static inline void cvmx_pow_tag_sw_wait(void)
1325 {
1326 const uint64_t MAX_CYCLES = 1ull << 31;
1327 uint64_t switch_complete;
1328 uint64_t start_cycle = cvmx_get_cycle();
1329 while (1) {
1330 CVMX_MF_CHORD(switch_complete);
1331 if (unlikely(switch_complete))
1332 break;
1333 if (unlikely(cvmx_get_cycle() > start_cycle + MAX_CYCLES)) {
1334 pr_warn("Tag switch is taking a long time, possible deadlock\n");
1335 start_cycle = -MAX_CYCLES - 1;
1336 }
1337 }
1338 }
1339
1340 /**
1341 * Synchronous work request. Requests work from the POW.
1342 * This function does NOT wait for previous tag switches to complete,
1343 * so the caller must ensure that there is not a pending tag switch.
1344 *
1345 * @wait: When set, call stalls until work becomes available, or times out.
1346 * If not set, returns immediately.
1347 *
1348 * Returns: the WQE pointer from POW. Returns NULL if no work
1349 * was available.
1350 */
1351 static inline struct cvmx_wqe *cvmx_pow_work_request_sync_nocheck(cvmx_pow_wait_t
1352 wait)
1353 {
1354 cvmx_pow_load_addr_t ptr;
1355 cvmx_pow_tag_load_resp_t result;
1356
1357 if (CVMX_ENABLE_POW_CHECKS)
1358 __cvmx_pow_warn_if_pending_switch(__func__);
1359
1360 ptr.u64 = 0;
1361 ptr.swork.mem_region = CVMX_IO_SEG;
1362 ptr.swork.is_io = 1;
1363 ptr.swork.did = CVMX_OCT_DID_TAG_SWTAG;
1364 ptr.swork.wait = wait;
1365
1366 result.u64 = cvmx_read_csr(ptr.u64);
1367
1368 if (result.s_work.no_work)
1369 return NULL;
1370 else
1371 return (struct cvmx_wqe *) cvmx_phys_to_ptr(result.s_work.addr);
1372 }
1373
1374 /**
1375 * Synchronous work request. Requests work from the POW.
1376 * This function waits for any previous tag switch to complete before
1377 * requesting the new work.
1378 *
1379 * @wait: When set, call stalls until work becomes available, or times out.
1380 * If not set, returns immediately.
1381 *
1382 * Returns: the WQE pointer from POW. Returns NULL if no work
1383 * was available.
1384 */
1385 static inline struct cvmx_wqe *cvmx_pow_work_request_sync(cvmx_pow_wait_t wait)
1386 {
1387 if (CVMX_ENABLE_POW_CHECKS)
1388 __cvmx_pow_warn_if_pending_switch(__func__);
1389
1390 /* Must not have a switch pending when requesting work */
1391 cvmx_pow_tag_sw_wait();
1392 return cvmx_pow_work_request_sync_nocheck(wait);
1393
1394 }
1395
1396 /**
1397 * Synchronous null_rd request. Requests a switch out of NULL_NULL POW state.
1398 * This function waits for any previous tag switch to complete before
1399 * requesting the null_rd.
1400 *
1401 * Returns: the POW state of type cvmx_pow_tag_type_t.
1402 */
1403 static inline enum cvmx_pow_tag_type cvmx_pow_work_request_null_rd(void)
1404 {
1405 cvmx_pow_load_addr_t ptr;
1406 cvmx_pow_tag_load_resp_t result;
1407
1408 if (CVMX_ENABLE_POW_CHECKS)
1409 __cvmx_pow_warn_if_pending_switch(__func__);
1410
1411 /* Must not have a switch pending when requesting work */
1412 cvmx_pow_tag_sw_wait();
1413
1414 ptr.u64 = 0;
1415 ptr.snull_rd.mem_region = CVMX_IO_SEG;
1416 ptr.snull_rd.is_io = 1;
1417 ptr.snull_rd.did = CVMX_OCT_DID_TAG_NULL_RD;
1418
1419 result.u64 = cvmx_read_csr(ptr.u64);
1420
1421 return (enum cvmx_pow_tag_type) result.s_null_rd.state;
1422 }
1423
1424 /**
1425 * Asynchronous work request. Work is requested from the POW unit,
1426 * and should later be checked with function
1427 * cvmx_pow_work_response_async. This function does NOT wait for
1428 * previous tag switches to complete, so the caller must ensure that
1429 * there is not a pending tag switch.
1430 *
1431 * @scr_addr: Scratch memory address that response will be returned
1432 * to, which is either a valid WQE, or a response with the
1433 * invalid bit set. Byte address, must be 8 byte aligned.
1434 *
1435 * @wait: 1 to cause response to wait for work to become available (or
1436 * timeout), 0 to cause response to return immediately
1437 */
1438 static inline void cvmx_pow_work_request_async_nocheck(int scr_addr,
1439 cvmx_pow_wait_t wait)
1440 {
1441 cvmx_pow_iobdma_store_t data;
1442
1443 if (CVMX_ENABLE_POW_CHECKS)
1444 __cvmx_pow_warn_if_pending_switch(__func__);
1445
1446 /* scr_addr must be 8 byte aligned */
1447 data.s.scraddr = scr_addr >> 3;
1448 data.s.len = 1;
1449 data.s.did = CVMX_OCT_DID_TAG_SWTAG;
1450 data.s.wait = wait;
1451 cvmx_send_single(data.u64);
1452 }
1453
1454 /**
1455 * Asynchronous work request. Work is requested from the POW unit,
1456 * and should later be checked with function
1457 * cvmx_pow_work_response_async. This function waits for any previous
1458 * tag switch to complete before requesting the new work.
1459 *
1460 * @scr_addr: Scratch memory address that response will be returned
1461 * to, which is either a valid WQE, or a response with the
1462 * invalid bit set. Byte address, must be 8 byte aligned.
1463 *
1464 * @wait: 1 to cause response to wait for work to become available (or
1465 * timeout), 0 to cause response to return immediately
1466 */
1467 static inline void cvmx_pow_work_request_async(int scr_addr,
1468 cvmx_pow_wait_t wait)
1469 {
1470 if (CVMX_ENABLE_POW_CHECKS)
1471 __cvmx_pow_warn_if_pending_switch(__func__);
1472
1473 /* Must not have a switch pending when requesting work */
1474 cvmx_pow_tag_sw_wait();
1475 cvmx_pow_work_request_async_nocheck(scr_addr, wait);
1476 }
1477
1478 /**
1479 * Gets result of asynchronous work request. Performs a IOBDMA sync
1480 * to wait for the response.
1481 *
1482 * @scr_addr: Scratch memory address to get result from Byte address,
1483 * must be 8 byte aligned.
1484 *
1485 * Returns: the WQE from the scratch register, or NULL if no
1486 * work was available.
1487 */
1488 static inline struct cvmx_wqe *cvmx_pow_work_response_async(int scr_addr)
1489 {
1490 cvmx_pow_tag_load_resp_t result;
1491
1492 CVMX_SYNCIOBDMA;
1493 result.u64 = cvmx_scratch_read64(scr_addr);
1494
1495 if (result.s_work.no_work)
1496 return NULL;
1497 else
1498 return (struct cvmx_wqe *) cvmx_phys_to_ptr(result.s_work.addr);
1499 }
1500
1501 /**
1502 * Checks if a work queue entry pointer returned by a work
1503 * request is valid. It may be invalid due to no work
1504 * being available or due to a timeout.
1505 *
1506 * @wqe_ptr: pointer to a work queue entry returned by the POW
1507 *
1508 * Returns 0 if pointer is valid
1509 * 1 if invalid (no work was returned)
1510 */
1511 static inline uint64_t cvmx_pow_work_invalid(struct cvmx_wqe *wqe_ptr)
1512 {
1513 return wqe_ptr == NULL;
1514 }
1515
1516 /**
1517 * Starts a tag switch to the provided tag value and tag type.
1518 * Completion for the tag switch must be checked for separately. This
1519 * function does NOT update the work queue entry in dram to match tag
1520 * value and type, so the application must keep track of these if they
1521 * are important to the application. This tag switch command must not
1522 * be used for switches to NULL, as the tag switch pending bit will be
1523 * set by the switch request, but never cleared by the hardware.
1524 *
1525 * NOTE: This should not be used when switching from a NULL tag. Use
1526 * cvmx_pow_tag_sw_full() instead.
1527 *
1528 * This function does no checks, so the caller must ensure that any
1529 * previous tag switch has completed.
1530 *
1531 * @tag: new tag value
1532 * @tag_type: new tag type (ordered or atomic)
1533 */
1534 static inline void cvmx_pow_tag_sw_nocheck(uint32_t tag,
1535 enum cvmx_pow_tag_type tag_type)
1536 {
1537 cvmx_addr_t ptr;
1538 cvmx_pow_tag_req_t tag_req;
1539
1540 if (CVMX_ENABLE_POW_CHECKS) {
1541 cvmx_pow_tag_req_t current_tag;
1542 __cvmx_pow_warn_if_pending_switch(__func__);
1543 current_tag = cvmx_pow_get_current_tag();
1544 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL_NULL)
1545 pr_warn("%s called with NULL_NULL tag\n", __func__);
1546 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL)
1547 pr_warn("%s called with NULL tag\n", __func__);
1548 if ((current_tag.s.type == tag_type)
1549 && (current_tag.s.tag == tag))
1550 pr_warn("%s called to perform a tag switch to the same tag\n",
1551 __func__);
1552 if (tag_type == CVMX_POW_TAG_TYPE_NULL)
1553 pr_warn("%s called to perform a tag switch to NULL. Use cvmx_pow_tag_sw_null() instead\n",
1554 __func__);
1555 }
1556
1557 /*
1558 * Note that WQE in DRAM is not updated here, as the POW does
1559 * not read from DRAM once the WQE is in flight. See hardware
1560 * manual for complete details. It is the application's
1561 * responsibility to keep track of the current tag value if
1562 * that is important.
1563 */
1564
1565 tag_req.u64 = 0;
1566 tag_req.s.op = CVMX_POW_TAG_OP_SWTAG;
1567 tag_req.s.tag = tag;
1568 tag_req.s.type = tag_type;
1569
1570 ptr.u64 = 0;
1571 ptr.sio.mem_region = CVMX_IO_SEG;
1572 ptr.sio.is_io = 1;
1573 ptr.sio.did = CVMX_OCT_DID_TAG_SWTAG;
1574
1575 /* once this store arrives at POW, it will attempt the switch
1576 software must wait for the switch to complete separately */
1577 cvmx_write_io(ptr.u64, tag_req.u64);
1578 }
1579
1580 /**
1581 * Starts a tag switch to the provided tag value and tag type.
1582 * Completion for the tag switch must be checked for separately. This
1583 * function does NOT update the work queue entry in dram to match tag
1584 * value and type, so the application must keep track of these if they
1585 * are important to the application. This tag switch command must not
1586 * be used for switches to NULL, as the tag switch pending bit will be
1587 * set by the switch request, but never cleared by the hardware.
1588 *
1589 * NOTE: This should not be used when switching from a NULL tag. Use
1590 * cvmx_pow_tag_sw_full() instead.
1591 *
1592 * This function waits for any previous tag switch to complete, and also
1593 * displays an error on tag switches to NULL.
1594 *
1595 * @tag: new tag value
1596 * @tag_type: new tag type (ordered or atomic)
1597 */
1598 static inline void cvmx_pow_tag_sw(uint32_t tag,
1599 enum cvmx_pow_tag_type tag_type)
1600 {
1601 if (CVMX_ENABLE_POW_CHECKS)
1602 __cvmx_pow_warn_if_pending_switch(__func__);
1603
1604 /*
1605 * Note that WQE in DRAM is not updated here, as the POW does
1606 * not read from DRAM once the WQE is in flight. See hardware
1607 * manual for complete details. It is the application's
1608 * responsibility to keep track of the current tag value if
1609 * that is important.
1610 */
1611
1612 /*
1613 * Ensure that there is not a pending tag switch, as a tag
1614 * switch cannot be started if a previous switch is still
1615 * pending.
1616 */
1617 cvmx_pow_tag_sw_wait();
1618 cvmx_pow_tag_sw_nocheck(tag, tag_type);
1619 }
1620
1621 /**
1622 * Starts a tag switch to the provided tag value and tag type.
1623 * Completion for the tag switch must be checked for separately. This
1624 * function does NOT update the work queue entry in dram to match tag
1625 * value and type, so the application must keep track of these if they
1626 * are important to the application. This tag switch command must not
1627 * be used for switches to NULL, as the tag switch pending bit will be
1628 * set by the switch request, but never cleared by the hardware.
1629 *
1630 * This function must be used for tag switches from NULL.
1631 *
1632 * This function does no checks, so the caller must ensure that any
1633 * previous tag switch has completed.
1634 *
1635 * @wqp: pointer to work queue entry to submit. This entry is
1636 * updated to match the other parameters
1637 * @tag: tag value to be assigned to work queue entry
1638 * @tag_type: type of tag
1639 * @group: group value for the work queue entry.
1640 */
1641 static inline void cvmx_pow_tag_sw_full_nocheck(struct cvmx_wqe *wqp, uint32_t tag,
1642 enum cvmx_pow_tag_type tag_type,
1643 uint64_t group)
1644 {
1645 cvmx_addr_t ptr;
1646 cvmx_pow_tag_req_t tag_req;
1647
1648 if (CVMX_ENABLE_POW_CHECKS) {
1649 cvmx_pow_tag_req_t current_tag;
1650 __cvmx_pow_warn_if_pending_switch(__func__);
1651 current_tag = cvmx_pow_get_current_tag();
1652 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL_NULL)
1653 pr_warn("%s called with NULL_NULL tag\n", __func__);
1654 if ((current_tag.s.type == tag_type)
1655 && (current_tag.s.tag == tag))
1656 pr_warn("%s called to perform a tag switch to the same tag\n",
1657 __func__);
1658 if (tag_type == CVMX_POW_TAG_TYPE_NULL)
1659 pr_warn("%s called to perform a tag switch to NULL. Use cvmx_pow_tag_sw_null() instead\n",
1660 __func__);
1661 if (wqp != cvmx_phys_to_ptr(0x80))
1662 if (wqp != cvmx_pow_get_current_wqp())
1663 pr_warn("%s passed WQE(%p) doesn't match the address in the POW(%p)\n",
1664 __func__, wqp,
1665 cvmx_pow_get_current_wqp());
1666 }
1667
1668 /*
1669 * Note that WQE in DRAM is not updated here, as the POW does
1670 * not read from DRAM once the WQE is in flight. See hardware
1671 * manual for complete details. It is the application's
1672 * responsibility to keep track of the current tag value if
1673 * that is important.
1674 */
1675
1676 tag_req.u64 = 0;
1677 tag_req.s.op = CVMX_POW_TAG_OP_SWTAG_FULL;
1678 tag_req.s.tag = tag;
1679 tag_req.s.type = tag_type;
1680 tag_req.s.grp = group;
1681
1682 ptr.u64 = 0;
1683 ptr.sio.mem_region = CVMX_IO_SEG;
1684 ptr.sio.is_io = 1;
1685 ptr.sio.did = CVMX_OCT_DID_TAG_SWTAG;
1686 ptr.sio.offset = CAST64(wqp);
1687
1688 /*
1689 * once this store arrives at POW, it will attempt the switch
1690 * software must wait for the switch to complete separately.
1691 */
1692 cvmx_write_io(ptr.u64, tag_req.u64);
1693 }
1694
1695 /**
1696 * Starts a tag switch to the provided tag value and tag type.
1697 * Completion for the tag switch must be checked for separately. This
1698 * function does NOT update the work queue entry in dram to match tag
1699 * value and type, so the application must keep track of these if they
1700 * are important to the application. This tag switch command must not
1701 * be used for switches to NULL, as the tag switch pending bit will be
1702 * set by the switch request, but never cleared by the hardware.
1703 *
1704 * This function must be used for tag switches from NULL.
1705 *
1706 * This function waits for any pending tag switches to complete
1707 * before requesting the tag switch.
1708 *
1709 * @wqp: pointer to work queue entry to submit. This entry is updated
1710 * to match the other parameters
1711 * @tag: tag value to be assigned to work queue entry
1712 * @tag_type: type of tag
1713 * @group: group value for the work queue entry.
1714 */
1715 static inline void cvmx_pow_tag_sw_full(struct cvmx_wqe *wqp, uint32_t tag,
1716 enum cvmx_pow_tag_type tag_type,
1717 uint64_t group)
1718 {
1719 if (CVMX_ENABLE_POW_CHECKS)
1720 __cvmx_pow_warn_if_pending_switch(__func__);
1721
1722 /*
1723 * Ensure that there is not a pending tag switch, as a tag
1724 * switch cannot be started if a previous switch is still
1725 * pending.
1726 */
1727 cvmx_pow_tag_sw_wait();
1728 cvmx_pow_tag_sw_full_nocheck(wqp, tag, tag_type, group);
1729 }
1730
1731 /**
1732 * Switch to a NULL tag, which ends any ordering or
1733 * synchronization provided by the POW for the current
1734 * work queue entry. This operation completes immediately,
1735 * so completion should not be waited for.
1736 * This function does NOT wait for previous tag switches to complete,
1737 * so the caller must ensure that any previous tag switches have completed.
1738 */
1739 static inline void cvmx_pow_tag_sw_null_nocheck(void)
1740 {
1741 cvmx_addr_t ptr;
1742 cvmx_pow_tag_req_t tag_req;
1743
1744 if (CVMX_ENABLE_POW_CHECKS) {
1745 cvmx_pow_tag_req_t current_tag;
1746 __cvmx_pow_warn_if_pending_switch(__func__);
1747 current_tag = cvmx_pow_get_current_tag();
1748 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL_NULL)
1749 pr_warn("%s called with NULL_NULL tag\n", __func__);
1750 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL)
1751 pr_warn("%s called when we already have a NULL tag\n",
1752 __func__);
1753 }
1754
1755 tag_req.u64 = 0;
1756 tag_req.s.op = CVMX_POW_TAG_OP_SWTAG;
1757 tag_req.s.type = CVMX_POW_TAG_TYPE_NULL;
1758
1759 ptr.u64 = 0;
1760 ptr.sio.mem_region = CVMX_IO_SEG;
1761 ptr.sio.is_io = 1;
1762 ptr.sio.did = CVMX_OCT_DID_TAG_TAG1;
1763
1764 cvmx_write_io(ptr.u64, tag_req.u64);
1765
1766 /* switch to NULL completes immediately */
1767 }
1768
1769 /**
1770 * Switch to a NULL tag, which ends any ordering or
1771 * synchronization provided by the POW for the current
1772 * work queue entry. This operation completes immediately,
1773 * so completion should not be waited for.
1774 * This function waits for any pending tag switches to complete
1775 * before requesting the switch to NULL.
1776 */
1777 static inline void cvmx_pow_tag_sw_null(void)
1778 {
1779 if (CVMX_ENABLE_POW_CHECKS)
1780 __cvmx_pow_warn_if_pending_switch(__func__);
1781
1782 /*
1783 * Ensure that there is not a pending tag switch, as a tag
1784 * switch cannot be started if a previous switch is still
1785 * pending.
1786 */
1787 cvmx_pow_tag_sw_wait();
1788 cvmx_pow_tag_sw_null_nocheck();
1789
1790 /* switch to NULL completes immediately */
1791 }
1792
1793 /**
1794 * Submits work to an input queue. This function updates the work
1795 * queue entry in DRAM to match the arguments given. Note that the
1796 * tag provided is for the work queue entry submitted, and is
1797 * unrelated to the tag that the core currently holds.
1798 *
1799 * @wqp: pointer to work queue entry to submit. This entry is
1800 * updated to match the other parameters
1801 * @tag: tag value to be assigned to work queue entry
1802 * @tag_type: type of tag
1803 * @qos: Input queue to add to.
1804 * @grp: group value for the work queue entry.
1805 */
1806 static inline void cvmx_pow_work_submit(struct cvmx_wqe *wqp, uint32_t tag,
1807 enum cvmx_pow_tag_type tag_type,
1808 uint64_t qos, uint64_t grp)
1809 {
1810 cvmx_addr_t ptr;
1811 cvmx_pow_tag_req_t tag_req;
1812
1813 wqp->word1.tag = tag;
1814 wqp->word1.tag_type = tag_type;
1815
1816 cvmx_wqe_set_qos(wqp, qos);
1817 cvmx_wqe_set_grp(wqp, grp);
1818
1819 tag_req.u64 = 0;
1820 tag_req.s.op = CVMX_POW_TAG_OP_ADDWQ;
1821 tag_req.s.type = tag_type;
1822 tag_req.s.tag = tag;
1823 tag_req.s.qos = qos;
1824 tag_req.s.grp = grp;
1825
1826 ptr.u64 = 0;
1827 ptr.sio.mem_region = CVMX_IO_SEG;
1828 ptr.sio.is_io = 1;
1829 ptr.sio.did = CVMX_OCT_DID_TAG_TAG1;
1830 ptr.sio.offset = cvmx_ptr_to_phys(wqp);
1831
1832 /*
1833 * SYNC write to memory before the work submit. This is
1834 * necessary as POW may read values from DRAM at this time.
1835 */
1836 CVMX_SYNCWS;
1837 cvmx_write_io(ptr.u64, tag_req.u64);
1838 }
1839
1840 /**
1841 * This function sets the group mask for a core. The group mask
1842 * indicates which groups each core will accept work from. There are
1843 * 16 groups.
1844 *
1845 * @core_num: core to apply mask to
1846 * @mask: Group mask. There are 16 groups, so only bits 0-15 are valid,
1847 * representing groups 0-15.
1848 * Each 1 bit in the mask enables the core to accept work from
1849 * the corresponding group.
1850 */
1851 static inline void cvmx_pow_set_group_mask(uint64_t core_num, uint64_t mask)
1852 {
1853 union cvmx_pow_pp_grp_mskx grp_msk;
1854
1855 grp_msk.u64 = cvmx_read_csr(CVMX_POW_PP_GRP_MSKX(core_num));
1856 grp_msk.s.grp_msk = mask;
1857 cvmx_write_csr(CVMX_POW_PP_GRP_MSKX(core_num), grp_msk.u64);
1858 }
1859
1860 /**
1861 * This function sets POW static priorities for a core. Each input queue has
1862 * an associated priority value.
1863 *
1864 * @core_num: core to apply priorities to
1865 * @priority: Vector of 8 priorities, one per POW Input Queue (0-7).
1866 * Highest priority is 0 and lowest is 7. A priority value
1867 * of 0xF instructs POW to skip the Input Queue when
1868 * scheduling to this specific core.
1869 * NOTE: priorities should not have gaps in values, meaning
1870 * {0,1,1,1,1,1,1,1} is a valid configuration while
1871 * {0,2,2,2,2,2,2,2} is not.
1872 */
1873 static inline void cvmx_pow_set_priority(uint64_t core_num,
1874 const uint8_t priority[])
1875 {
1876 /* POW priorities are supported on CN5xxx and later */
1877 if (!OCTEON_IS_MODEL(OCTEON_CN3XXX)) {
1878 union cvmx_pow_pp_grp_mskx grp_msk;
1879
1880 grp_msk.u64 = cvmx_read_csr(CVMX_POW_PP_GRP_MSKX(core_num));
1881 grp_msk.s.qos0_pri = priority[0];
1882 grp_msk.s.qos1_pri = priority[1];
1883 grp_msk.s.qos2_pri = priority[2];
1884 grp_msk.s.qos3_pri = priority[3];
1885 grp_msk.s.qos4_pri = priority[4];
1886 grp_msk.s.qos5_pri = priority[5];
1887 grp_msk.s.qos6_pri = priority[6];
1888 grp_msk.s.qos7_pri = priority[7];
1889
1890 /* Detect gaps between priorities and flag error */
1891 {
1892 int i;
1893 uint32_t prio_mask = 0;
1894
1895 for (i = 0; i < 8; i++)
1896 if (priority[i] != 0xF)
1897 prio_mask |= 1 << priority[i];
1898
1899 if (prio_mask ^ ((1 << cvmx_pop(prio_mask)) - 1)) {
1900 pr_err("POW static priorities should be "
1901 "contiguous (0x%llx)\n",
1902 (unsigned long long)prio_mask);
1903 return;
1904 }
1905 }
1906
1907 cvmx_write_csr(CVMX_POW_PP_GRP_MSKX(core_num), grp_msk.u64);
1908 }
1909 }
1910
1911 /**
1912 * Performs a tag switch and then an immediate deschedule. This completes
1913 * immediately, so completion must not be waited for. This function does NOT
1914 * update the wqe in DRAM to match arguments.
1915 *
1916 * This function does NOT wait for any prior tag switches to complete, so the
1917 * calling code must do this.
1918 *
1919 * Note the following CAVEAT of the Octeon HW behavior when
1920 * re-scheduling DE-SCHEDULEd items whose (next) state is
1921 * ORDERED:
1922 * - If there are no switches pending at the time that the
1923 * HW executes the de-schedule, the HW will only re-schedule
1924 * the head of the FIFO associated with the given tag. This
1925 * means that in many respects, the HW treats this ORDERED
1926 * tag as an ATOMIC tag. Note that in the SWTAG_DESCH
1927 * case (to an ORDERED tag), the HW will do the switch
1928 * before the deschedule whenever it is possible to do
1929 * the switch immediately, so it may often look like
1930 * this case.
1931 * - If there is a pending switch to ORDERED at the time
1932 * the HW executes the de-schedule, the HW will perform
1933 * the switch at the time it re-schedules, and will be
1934 * able to reschedule any/all of the entries with the
1935 * same tag.
1936 * Due to this behavior, the RECOMMENDATION to software is
1937 * that they have a (next) state of ATOMIC when they
1938 * DE-SCHEDULE. If an ORDERED tag is what was really desired,
1939 * SW can choose to immediately switch to an ORDERED tag
1940 * after the work (that has an ATOMIC tag) is re-scheduled.
1941 * Note that since there are never any tag switches pending
1942 * when the HW re-schedules, this switch can be IMMEDIATE upon
1943 * the reception of the pointer during the re-schedule.
1944 *
1945 * @tag: New tag value
1946 * @tag_type: New tag type
1947 * @group: New group value
1948 * @no_sched: Control whether this work queue entry will be rescheduled.
1949 * - 1 : don't schedule this work
1950 * - 0 : allow this work to be scheduled.
1951 */
1952 static inline void cvmx_pow_tag_sw_desched_nocheck(
1953 uint32_t tag,
1954 enum cvmx_pow_tag_type tag_type,
1955 uint64_t group,
1956 uint64_t no_sched)
1957 {
1958 cvmx_addr_t ptr;
1959 cvmx_pow_tag_req_t tag_req;
1960
1961 if (CVMX_ENABLE_POW_CHECKS) {
1962 cvmx_pow_tag_req_t current_tag;
1963 __cvmx_pow_warn_if_pending_switch(__func__);
1964 current_tag = cvmx_pow_get_current_tag();
1965 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL_NULL)
1966 pr_warn("%s called with NULL_NULL tag\n", __func__);
1967 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL)
1968 pr_warn("%s called with NULL tag. Deschedule not allowed from NULL state\n",
1969 __func__);
1970 if ((current_tag.s.type != CVMX_POW_TAG_TYPE_ATOMIC)
1971 && (tag_type != CVMX_POW_TAG_TYPE_ATOMIC))
1972 pr_warn("%s called where neither the before or after tag is ATOMIC\n",
1973 __func__);
1974 }
1975
1976 tag_req.u64 = 0;
1977 tag_req.s.op = CVMX_POW_TAG_OP_SWTAG_DESCH;
1978 tag_req.s.tag = tag;
1979 tag_req.s.type = tag_type;
1980 tag_req.s.grp = group;
1981 tag_req.s.no_sched = no_sched;
1982
1983 ptr.u64 = 0;
1984 ptr.sio.mem_region = CVMX_IO_SEG;
1985 ptr.sio.is_io = 1;
1986 ptr.sio.did = CVMX_OCT_DID_TAG_TAG3;
1987 /*
1988 * since TAG3 is used, this store will clear the local pending
1989 * switch bit.
1990 */
1991 cvmx_write_io(ptr.u64, tag_req.u64);
1992 }
1993
1994 /**
1995 * Performs a tag switch and then an immediate deschedule. This completes
1996 * immediately, so completion must not be waited for. This function does NOT
1997 * update the wqe in DRAM to match arguments.
1998 *
1999 * This function waits for any prior tag switches to complete, so the
2000 * calling code may call this function with a pending tag switch.
2001 *
2002 * Note the following CAVEAT of the Octeon HW behavior when
2003 * re-scheduling DE-SCHEDULEd items whose (next) state is
2004 * ORDERED:
2005 * - If there are no switches pending at the time that the
2006 * HW executes the de-schedule, the HW will only re-schedule
2007 * the head of the FIFO associated with the given tag. This
2008 * means that in many respects, the HW treats this ORDERED
2009 * tag as an ATOMIC tag. Note that in the SWTAG_DESCH
2010 * case (to an ORDERED tag), the HW will do the switch
2011 * before the deschedule whenever it is possible to do
2012 * the switch immediately, so it may often look like
2013 * this case.
2014 * - If there is a pending switch to ORDERED at the time
2015 * the HW executes the de-schedule, the HW will perform
2016 * the switch at the time it re-schedules, and will be
2017 * able to reschedule any/all of the entries with the
2018 * same tag.
2019 * Due to this behavior, the RECOMMENDATION to software is
2020 * that they have a (next) state of ATOMIC when they
2021 * DE-SCHEDULE. If an ORDERED tag is what was really desired,
2022 * SW can choose to immediately switch to an ORDERED tag
2023 * after the work (that has an ATOMIC tag) is re-scheduled.
2024 * Note that since there are never any tag switches pending
2025 * when the HW re-schedules, this switch can be IMMEDIATE upon
2026 * the reception of the pointer during the re-schedule.
2027 *
2028 * @tag: New tag value
2029 * @tag_type: New tag type
2030 * @group: New group value
2031 * @no_sched: Control whether this work queue entry will be rescheduled.
2032 * - 1 : don't schedule this work
2033 * - 0 : allow this work to be scheduled.
2034 */
2035 static inline void cvmx_pow_tag_sw_desched(uint32_t tag,
2036 enum cvmx_pow_tag_type tag_type,
2037 uint64_t group, uint64_t no_sched)
2038 {
2039 if (CVMX_ENABLE_POW_CHECKS)
2040 __cvmx_pow_warn_if_pending_switch(__func__);
2041
2042 /* Need to make sure any writes to the work queue entry are complete */
2043 CVMX_SYNCWS;
2044 /*
2045 * Ensure that there is not a pending tag switch, as a tag
2046 * switch cannot be started if a previous switch is still
2047 * pending.
2048 */
2049 cvmx_pow_tag_sw_wait();
2050 cvmx_pow_tag_sw_desched_nocheck(tag, tag_type, group, no_sched);
2051 }
2052
2053 /**
2054 * Deschedules the current work queue entry.
2055 *
2056 * @no_sched: no schedule flag value to be set on the work queue
2057 * entry. If this is set the entry will not be
2058 * rescheduled.
2059 */
2060 static inline void cvmx_pow_desched(uint64_t no_sched)
2061 {
2062 cvmx_addr_t ptr;
2063 cvmx_pow_tag_req_t tag_req;
2064
2065 if (CVMX_ENABLE_POW_CHECKS) {
2066 cvmx_pow_tag_req_t current_tag;
2067 __cvmx_pow_warn_if_pending_switch(__func__);
2068 current_tag = cvmx_pow_get_current_tag();
2069 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL_NULL)
2070 pr_warn("%s called with NULL_NULL tag\n", __func__);
2071 if (current_tag.s.type == CVMX_POW_TAG_TYPE_NULL)
2072 pr_warn("%s called with NULL tag. Deschedule not expected from NULL state\n",
2073 __func__);
2074 }
2075
2076 /* Need to make sure any writes to the work queue entry are complete */
2077 CVMX_SYNCWS;
2078
2079 tag_req.u64 = 0;
2080 tag_req.s.op = CVMX_POW_TAG_OP_DESCH;
2081 tag_req.s.no_sched = no_sched;
2082
2083 ptr.u64 = 0;
2084 ptr.sio.mem_region = CVMX_IO_SEG;
2085 ptr.sio.is_io = 1;
2086 ptr.sio.did = CVMX_OCT_DID_TAG_TAG3;
2087 /*
2088 * since TAG3 is used, this store will clear the local pending
2089 * switch bit.
2090 */
2091 cvmx_write_io(ptr.u64, tag_req.u64);
2092 }
2093
2094 /****************************************************
2095 * Define usage of bits within the 32 bit tag values.
2096 *****************************************************/
2097
2098 /*
2099 * Number of bits of the tag used by software. The SW bits are always
2100 * a contiguous block of the high starting at bit 31. The hardware
2101 * bits are always the low bits. By default, the top 8 bits of the
2102 * tag are reserved for software, and the low 24 are set by the IPD
2103 * unit.
2104 */
2105 #define CVMX_TAG_SW_BITS (8)
2106 #define CVMX_TAG_SW_SHIFT (32 - CVMX_TAG_SW_BITS)
2107
2108 /* Below is the list of values for the top 8 bits of the tag. */
2109 /*
2110 * Tag values with top byte of this value are reserved for internal
2111 * executive uses.
2112 */
2113 #define CVMX_TAG_SW_BITS_INTERNAL 0x1
2114 /* The executive divides the remaining 24 bits as follows:
2115 * - the upper 8 bits (bits 23 - 16 of the tag) define a subgroup
2116 *
2117 * - the lower 16 bits (bits 15 - 0 of the tag) define are the value
2118 * with the subgroup
2119 *
2120 * Note that this section describes the format of tags generated by
2121 * software - refer to the hardware documentation for a description of
2122 * the tags values generated by the packet input hardware. Subgroups
2123 * are defined here.
2124 */
2125 /* Mask for the value portion of the tag */
2126 #define CVMX_TAG_SUBGROUP_MASK 0xFFFF
2127 #define CVMX_TAG_SUBGROUP_SHIFT 16
2128 #define CVMX_TAG_SUBGROUP_PKO 0x1
2129
2130 /* End of executive tag subgroup definitions */
2131
2132 /*
2133 * The remaining values software bit values 0x2 - 0xff are available
2134 * for application use.
2135 */
2136
2137 /**
2138 * This function creates a 32 bit tag value from the two values provided.
2139 *
2140 * @sw_bits: The upper bits (number depends on configuration) are set
2141 * to this value. The remainder of bits are set by the
2142 * hw_bits parameter.
2143 *
2144 * @hw_bits: The lower bits (number depends on configuration) are set
2145 * to this value. The remainder of bits are set by the
2146 * sw_bits parameter.
2147 *
2148 * Returns 32 bit value of the combined hw and sw bits.
2149 */
2150 static inline uint32_t cvmx_pow_tag_compose(uint64_t sw_bits, uint64_t hw_bits)
2151 {
2152 return ((sw_bits & cvmx_build_mask(CVMX_TAG_SW_BITS)) <<
2153 CVMX_TAG_SW_SHIFT) |
2154 (hw_bits & cvmx_build_mask(32 - CVMX_TAG_SW_BITS));
2155 }
2156
2157 /**
2158 * Extracts the bits allocated for software use from the tag
2159 *
2160 * @tag: 32 bit tag value
2161 *
2162 * Returns N bit software tag value, where N is configurable with the
2163 * CVMX_TAG_SW_BITS define
2164 */
2165 static inline uint32_t cvmx_pow_tag_get_sw_bits(uint64_t tag)
2166 {
2167 return (tag >> (32 - CVMX_TAG_SW_BITS)) &
2168 cvmx_build_mask(CVMX_TAG_SW_BITS);
2169 }
2170
2171 /**
2172 *
2173 * Extracts the bits allocated for hardware use from the tag
2174 *
2175 * @tag: 32 bit tag value
2176 *
2177 * Returns (32 - N) bit software tag value, where N is configurable
2178 * with the CVMX_TAG_SW_BITS define
2179 */
2180 static inline uint32_t cvmx_pow_tag_get_hw_bits(uint64_t tag)
2181 {
2182 return tag & cvmx_build_mask(32 - CVMX_TAG_SW_BITS);
2183 }
2184
2185 /**
2186 * Store the current POW internal state into the supplied
2187 * buffer. It is recommended that you pass a buffer of at least
2188 * 128KB. The format of the capture may change based on SDK
2189 * version and Octeon chip.
2190 *
2191 * @buffer: Buffer to store capture into
2192 * @buffer_size:
2193 * The size of the supplied buffer
2194 *
2195 * Returns Zero on success, negative on failure
2196 */
2197 extern int cvmx_pow_capture(void *buffer, int buffer_size);
2198
2199 /**
2200 * Dump a POW capture to the console in a human readable format.
2201 *
2202 * @buffer: POW capture from cvmx_pow_capture()
2203 * @buffer_size:
2204 * Size of the buffer
2205 */
2206 extern void cvmx_pow_display(void *buffer, int buffer_size);
2207
2208 /**
2209 * Return the number of POW entries supported by this chip
2210 *
2211 * Returns Number of POW entries
2212 */
2213 extern int cvmx_pow_get_num_entries(void);
2214
2215 #endif /* __CVMX_POW_H__ */
2216
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.