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 Fetch and Add Unit.
30 */
31
32 #ifndef __CVMX_FAU_H__
33 #define __CVMX_FAU_H__
34
35 /*
36 * Octeon Fetch and Add Unit (FAU)
37 */
38
39 #define CVMX_FAU_LOAD_IO_ADDRESS cvmx_build_io_address(0x1e, 0)
40 #define CVMX_FAU_BITS_SCRADDR 63, 56
41 #define CVMX_FAU_BITS_LEN 55, 48
42 #define CVMX_FAU_BITS_INEVAL 35, 14
43 #define CVMX_FAU_BITS_TAGWAIT 13, 13
44 #define CVMX_FAU_BITS_NOADD 13, 13
45 #define CVMX_FAU_BITS_SIZE 12, 11
46 #define CVMX_FAU_BITS_REGISTER 10, 0
47
48 typedef enum {
49 CVMX_FAU_OP_SIZE_8 = 0,
50 CVMX_FAU_OP_SIZE_16 = 1,
51 CVMX_FAU_OP_SIZE_32 = 2,
52 CVMX_FAU_OP_SIZE_64 = 3
53 } cvmx_fau_op_size_t;
54
55 /**
56 * Tagwait return definition. If a timeout occurs, the error
57 * bit will be set. Otherwise the value of the register before
58 * the update will be returned.
59 */
60 typedef struct {
61 uint64_t error:1;
62 int64_t value:63;
63 } cvmx_fau_tagwait64_t;
64
65 /**
66 * Tagwait return definition. If a timeout occurs, the error
67 * bit will be set. Otherwise the value of the register before
68 * the update will be returned.
69 */
70 typedef struct {
71 uint64_t error:1;
72 int32_t value:31;
73 } cvmx_fau_tagwait32_t;
74
75 /**
76 * Tagwait return definition. If a timeout occurs, the error
77 * bit will be set. Otherwise the value of the register before
78 * the update will be returned.
79 */
80 typedef struct {
81 uint64_t error:1;
82 int16_t value:15;
83 } cvmx_fau_tagwait16_t;
84
85 /**
86 * Tagwait return definition. If a timeout occurs, the error
87 * bit will be set. Otherwise the value of the register before
88 * the update will be returned.
89 */
90 typedef struct {
91 uint64_t error:1;
92 int8_t value:7;
93 } cvmx_fau_tagwait8_t;
94
95 /**
96 * Asynchronous tagwait return definition. If a timeout occurs,
97 * the error bit will be set. Otherwise the value of the
98 * register before the update will be returned.
99 */
100 typedef union {
101 uint64_t u64;
102 struct {
103 uint64_t invalid:1;
104 uint64_t data:63; /* unpredictable if invalid is set */
105 } s;
106 } cvmx_fau_async_tagwait_result_t;
107
108 #ifdef __BIG_ENDIAN_BITFIELD
109 #define SWIZZLE_8 0
110 #define SWIZZLE_16 0
111 #define SWIZZLE_32 0
112 #else
113 #define SWIZZLE_8 0x7
114 #define SWIZZLE_16 0x6
115 #define SWIZZLE_32 0x4
116 #endif
117
118 /**
119 * Builds a store I/O address for writing to the FAU
120 *
121 * @noadd: 0 = Store value is atomically added to the current value
122 * 1 = Store value is atomically written over the current value
123 * @reg: FAU atomic register to access. 0 <= reg < 2048.
124 * - Step by 2 for 16 bit access.
125 * - Step by 4 for 32 bit access.
126 * - Step by 8 for 64 bit access.
127 * Returns Address to store for atomic update
128 */
129 static inline uint64_t __cvmx_fau_store_address(uint64_t noadd, uint64_t reg)
130 {
131 return CVMX_ADD_IO_SEG(CVMX_FAU_LOAD_IO_ADDRESS) |
132 cvmx_build_bits(CVMX_FAU_BITS_NOADD, noadd) |
133 cvmx_build_bits(CVMX_FAU_BITS_REGISTER, reg);
134 }
135
136 /**
137 * Builds a I/O address for accessing the FAU
138 *
139 * @tagwait: Should the atomic add wait for the current tag switch
140 * operation to complete.
141 * - 0 = Don't wait
142 * - 1 = Wait for tag switch to complete
143 * @reg: FAU atomic register to access. 0 <= reg < 2048.
144 * - Step by 2 for 16 bit access.
145 * - Step by 4 for 32 bit access.
146 * - Step by 8 for 64 bit access.
147 * @value: Signed value to add.
148 * Note: When performing 32 and 64 bit access, only the low
149 * 22 bits are available.
150 * Returns Address to read from for atomic update
151 */
152 static inline uint64_t __cvmx_fau_atomic_address(uint64_t tagwait, uint64_t reg,
153 int64_t value)
154 {
155 return CVMX_ADD_IO_SEG(CVMX_FAU_LOAD_IO_ADDRESS) |
156 cvmx_build_bits(CVMX_FAU_BITS_INEVAL, value) |
157 cvmx_build_bits(CVMX_FAU_BITS_TAGWAIT, tagwait) |
158 cvmx_build_bits(CVMX_FAU_BITS_REGISTER, reg);
159 }
160
161 /**
162 * Perform an atomic 64 bit add
163 *
164 * @reg: FAU atomic register to access. 0 <= reg < 2048.
165 * - Step by 8 for 64 bit access.
166 * @value: Signed value to add.
167 * Note: Only the low 22 bits are available.
168 * Returns Value of the register before the update
169 */
170 static inline int64_t cvmx_fau_fetch_and_add64(cvmx_fau_reg_64_t reg,
171 int64_t value)
172 {
173 return cvmx_read64_int64(__cvmx_fau_atomic_address(0, reg, value));
174 }
175
176 /**
177 * Perform an atomic 32 bit add
178 *
179 * @reg: FAU atomic register to access. 0 <= reg < 2048.
180 * - Step by 4 for 32 bit access.
181 * @value: Signed value to add.
182 * Note: Only the low 22 bits are available.
183 * Returns Value of the register before the update
184 */
185 static inline int32_t cvmx_fau_fetch_and_add32(cvmx_fau_reg_32_t reg,
186 int32_t value)
187 {
188 reg ^= SWIZZLE_32;
189 return cvmx_read64_int32(__cvmx_fau_atomic_address(0, reg, value));
190 }
191
192 /**
193 * Perform an atomic 16 bit add
194 *
195 * @reg: FAU atomic register to access. 0 <= reg < 2048.
196 * - Step by 2 for 16 bit access.
197 * @value: Signed value to add.
198 * Returns Value of the register before the update
199 */
200 static inline int16_t cvmx_fau_fetch_and_add16(cvmx_fau_reg_16_t reg,
201 int16_t value)
202 {
203 reg ^= SWIZZLE_16;
204 return cvmx_read64_int16(__cvmx_fau_atomic_address(0, reg, value));
205 }
206
207 /**
208 * Perform an atomic 8 bit add
209 *
210 * @reg: FAU atomic register to access. 0 <= reg < 2048.
211 * @value: Signed value to add.
212 * Returns Value of the register before the update
213 */
214 static inline int8_t cvmx_fau_fetch_and_add8(cvmx_fau_reg_8_t reg, int8_t value)
215 {
216 reg ^= SWIZZLE_8;
217 return cvmx_read64_int8(__cvmx_fau_atomic_address(0, reg, value));
218 }
219
220 /**
221 * Perform an atomic 64 bit add after the current tag switch
222 * completes
223 *
224 * @reg: FAU atomic register to access. 0 <= reg < 2048.
225 * - Step by 8 for 64 bit access.
226 * @value: Signed value to add.
227 * Note: Only the low 22 bits are available.
228 * Returns If a timeout occurs, the error bit will be set. Otherwise
229 * the value of the register before the update will be
230 * returned
231 */
232 static inline cvmx_fau_tagwait64_t
233 cvmx_fau_tagwait_fetch_and_add64(cvmx_fau_reg_64_t reg, int64_t value)
234 {
235 union {
236 uint64_t i64;
237 cvmx_fau_tagwait64_t t;
238 } result;
239 result.i64 =
240 cvmx_read64_int64(__cvmx_fau_atomic_address(1, reg, value));
241 return result.t;
242 }
243
244 /**
245 * Perform an atomic 32 bit add after the current tag switch
246 * completes
247 *
248 * @reg: FAU atomic register to access. 0 <= reg < 2048.
249 * - Step by 4 for 32 bit access.
250 * @value: Signed value to add.
251 * Note: Only the low 22 bits are available.
252 * Returns If a timeout occurs, the error bit will be set. Otherwise
253 * the value of the register before the update will be
254 * returned
255 */
256 static inline cvmx_fau_tagwait32_t
257 cvmx_fau_tagwait_fetch_and_add32(cvmx_fau_reg_32_t reg, int32_t value)
258 {
259 union {
260 uint64_t i32;
261 cvmx_fau_tagwait32_t t;
262 } result;
263 reg ^= SWIZZLE_32;
264 result.i32 =
265 cvmx_read64_int32(__cvmx_fau_atomic_address(1, reg, value));
266 return result.t;
267 }
268
269 /**
270 * Perform an atomic 16 bit add after the current tag switch
271 * completes
272 *
273 * @reg: FAU atomic register to access. 0 <= reg < 2048.
274 * - Step by 2 for 16 bit access.
275 * @value: Signed value to add.
276 * Returns If a timeout occurs, the error bit will be set. Otherwise
277 * the value of the register before the update will be
278 * returned
279 */
280 static inline cvmx_fau_tagwait16_t
281 cvmx_fau_tagwait_fetch_and_add16(cvmx_fau_reg_16_t reg, int16_t value)
282 {
283 union {
284 uint64_t i16;
285 cvmx_fau_tagwait16_t t;
286 } result;
287 reg ^= SWIZZLE_16;
288 result.i16 =
289 cvmx_read64_int16(__cvmx_fau_atomic_address(1, reg, value));
290 return result.t;
291 }
292
293 /**
294 * Perform an atomic 8 bit add after the current tag switch
295 * completes
296 *
297 * @reg: FAU atomic register to access. 0 <= reg < 2048.
298 * @value: Signed value to add.
299 * Returns If a timeout occurs, the error bit will be set. Otherwise
300 * the value of the register before the update will be
301 * returned
302 */
303 static inline cvmx_fau_tagwait8_t
304 cvmx_fau_tagwait_fetch_and_add8(cvmx_fau_reg_8_t reg, int8_t value)
305 {
306 union {
307 uint64_t i8;
308 cvmx_fau_tagwait8_t t;
309 } result;
310 reg ^= SWIZZLE_8;
311 result.i8 = cvmx_read64_int8(__cvmx_fau_atomic_address(1, reg, value));
312 return result.t;
313 }
314
315 /**
316 * Builds I/O data for async operations
317 *
318 * @scraddr: Scratch pad byte address to write to. Must be 8 byte aligned
319 * @value: Signed value to add.
320 * Note: When performing 32 and 64 bit access, only the low
321 * 22 bits are available.
322 * @tagwait: Should the atomic add wait for the current tag switch
323 * operation to complete.
324 * - 0 = Don't wait
325 * - 1 = Wait for tag switch to complete
326 * @size: The size of the operation:
327 * - CVMX_FAU_OP_SIZE_8 (0) = 8 bits
328 * - CVMX_FAU_OP_SIZE_16 (1) = 16 bits
329 * - CVMX_FAU_OP_SIZE_32 (2) = 32 bits
330 * - CVMX_FAU_OP_SIZE_64 (3) = 64 bits
331 * @reg: FAU atomic register to access. 0 <= reg < 2048.
332 * - Step by 2 for 16 bit access.
333 * - Step by 4 for 32 bit access.
334 * - Step by 8 for 64 bit access.
335 * Returns Data to write using cvmx_send_single
336 */
337 static inline uint64_t __cvmx_fau_iobdma_data(uint64_t scraddr, int64_t value,
338 uint64_t tagwait,
339 cvmx_fau_op_size_t size,
340 uint64_t reg)
341 {
342 return CVMX_FAU_LOAD_IO_ADDRESS |
343 cvmx_build_bits(CVMX_FAU_BITS_SCRADDR, scraddr >> 3) |
344 cvmx_build_bits(CVMX_FAU_BITS_LEN, 1) |
345 cvmx_build_bits(CVMX_FAU_BITS_INEVAL, value) |
346 cvmx_build_bits(CVMX_FAU_BITS_TAGWAIT, tagwait) |
347 cvmx_build_bits(CVMX_FAU_BITS_SIZE, size) |
348 cvmx_build_bits(CVMX_FAU_BITS_REGISTER, reg);
349 }
350
351 /**
352 * Perform an async atomic 64 bit add. The old value is
353 * placed in the scratch memory at byte address scraddr.
354 *
355 * @scraddr: Scratch memory byte address to put response in.
356 * Must be 8 byte aligned.
357 * @reg: FAU atomic register to access. 0 <= reg < 2048.
358 * - Step by 8 for 64 bit access.
359 * @value: Signed value to add.
360 * Note: Only the low 22 bits are available.
361 * Returns Placed in the scratch pad register
362 */
363 static inline void cvmx_fau_async_fetch_and_add64(uint64_t scraddr,
364 cvmx_fau_reg_64_t reg,
365 int64_t value)
366 {
367 cvmx_send_single(__cvmx_fau_iobdma_data
368 (scraddr, value, 0, CVMX_FAU_OP_SIZE_64, reg));
369 }
370
371 /**
372 * Perform an async atomic 32 bit add. The old value is
373 * placed in the scratch memory at byte address scraddr.
374 *
375 * @scraddr: Scratch memory byte address to put response in.
376 * Must be 8 byte aligned.
377 * @reg: FAU atomic register to access. 0 <= reg < 2048.
378 * - Step by 4 for 32 bit access.
379 * @value: Signed value to add.
380 * Note: Only the low 22 bits are available.
381 * Returns Placed in the scratch pad register
382 */
383 static inline void cvmx_fau_async_fetch_and_add32(uint64_t scraddr,
384 cvmx_fau_reg_32_t reg,
385 int32_t value)
386 {
387 cvmx_send_single(__cvmx_fau_iobdma_data
388 (scraddr, value, 0, CVMX_FAU_OP_SIZE_32, reg));
389 }
390
391 /**
392 * Perform an async atomic 16 bit add. The old value is
393 * placed in the scratch memory at byte address scraddr.
394 *
395 * @scraddr: Scratch memory byte address to put response in.
396 * Must be 8 byte aligned.
397 * @reg: FAU atomic register to access. 0 <= reg < 2048.
398 * - Step by 2 for 16 bit access.
399 * @value: Signed value to add.
400 * Returns Placed in the scratch pad register
401 */
402 static inline void cvmx_fau_async_fetch_and_add16(uint64_t scraddr,
403 cvmx_fau_reg_16_t reg,
404 int16_t value)
405 {
406 cvmx_send_single(__cvmx_fau_iobdma_data
407 (scraddr, value, 0, CVMX_FAU_OP_SIZE_16, reg));
408 }
409
410 /**
411 * Perform an async atomic 8 bit add. The old value is
412 * placed in the scratch memory at byte address scraddr.
413 *
414 * @scraddr: Scratch memory byte address to put response in.
415 * Must be 8 byte aligned.
416 * @reg: FAU atomic register to access. 0 <= reg < 2048.
417 * @value: Signed value to add.
418 * Returns Placed in the scratch pad register
419 */
420 static inline void cvmx_fau_async_fetch_and_add8(uint64_t scraddr,
421 cvmx_fau_reg_8_t reg,
422 int8_t value)
423 {
424 cvmx_send_single(__cvmx_fau_iobdma_data
425 (scraddr, value, 0, CVMX_FAU_OP_SIZE_8, reg));
426 }
427
428 /**
429 * Perform an async atomic 64 bit add after the current tag
430 * switch completes.
431 *
432 * @scraddr: Scratch memory byte address to put response in. Must be
433 * 8 byte aligned. If a timeout occurs, the error bit (63)
434 * will be set. Otherwise the value of the register before
435 * the update will be returned
436 *
437 * @reg: FAU atomic register to access. 0 <= reg < 2048.
438 * - Step by 8 for 64 bit access.
439 * @value: Signed value to add.
440 * Note: Only the low 22 bits are available.
441 * Returns Placed in the scratch pad register
442 */
443 static inline void cvmx_fau_async_tagwait_fetch_and_add64(uint64_t scraddr,
444 cvmx_fau_reg_64_t reg,
445 int64_t value)
446 {
447 cvmx_send_single(__cvmx_fau_iobdma_data
448 (scraddr, value, 1, CVMX_FAU_OP_SIZE_64, reg));
449 }
450
451 /**
452 * Perform an async atomic 32 bit add after the current tag
453 * switch completes.
454 *
455 * @scraddr: Scratch memory byte address to put response in. Must be
456 * 8 byte aligned. If a timeout occurs, the error bit (63)
457 * will be set. Otherwise the value of the register before
458 * the update will be returned
459 *
460 * @reg: FAU atomic register to access. 0 <= reg < 2048.
461 * - Step by 4 for 32 bit access.
462 * @value: Signed value to add.
463 * Note: Only the low 22 bits are available.
464 * Returns Placed in the scratch pad register
465 */
466 static inline void cvmx_fau_async_tagwait_fetch_and_add32(uint64_t scraddr,
467 cvmx_fau_reg_32_t reg,
468 int32_t value)
469 {
470 cvmx_send_single(__cvmx_fau_iobdma_data
471 (scraddr, value, 1, CVMX_FAU_OP_SIZE_32, reg));
472 }
473
474 /**
475 * Perform an async atomic 16 bit add after the current tag
476 * switch completes.
477 *
478 * @scraddr: Scratch memory byte address to put response in. Must be
479 * 8 byte aligned. If a timeout occurs, the error bit (63)
480 * will be set. Otherwise the value of the register before
481 * the update will be returned
482 *
483 * @reg: FAU atomic register to access. 0 <= reg < 2048.
484 * - Step by 2 for 16 bit access.
485 * @value: Signed value to add.
486 *
487 * Returns Placed in the scratch pad register
488 */
489 static inline void cvmx_fau_async_tagwait_fetch_and_add16(uint64_t scraddr,
490 cvmx_fau_reg_16_t reg,
491 int16_t value)
492 {
493 cvmx_send_single(__cvmx_fau_iobdma_data
494 (scraddr, value, 1, CVMX_FAU_OP_SIZE_16, reg));
495 }
496
497 /**
498 * Perform an async atomic 8 bit add after the current tag
499 * switch completes.
500 *
501 * @scraddr: Scratch memory byte address to put response in. Must be
502 * 8 byte aligned. If a timeout occurs, the error bit (63)
503 * will be set. Otherwise the value of the register before
504 * the update will be returned
505 *
506 * @reg: FAU atomic register to access. 0 <= reg < 2048.
507 * @value: Signed value to add.
508 *
509 * Returns Placed in the scratch pad register
510 */
511 static inline void cvmx_fau_async_tagwait_fetch_and_add8(uint64_t scraddr,
512 cvmx_fau_reg_8_t reg,
513 int8_t value)
514 {
515 cvmx_send_single(__cvmx_fau_iobdma_data
516 (scraddr, value, 1, CVMX_FAU_OP_SIZE_8, reg));
517 }
518
519 /**
520 * Perform an atomic 64 bit add
521 *
522 * @reg: FAU atomic register to access. 0 <= reg < 2048.
523 * - Step by 8 for 64 bit access.
524 * @value: Signed value to add.
525 */
526 static inline void cvmx_fau_atomic_add64(cvmx_fau_reg_64_t reg, int64_t value)
527 {
528 cvmx_write64_int64(__cvmx_fau_store_address(0, reg), value);
529 }
530
531 /**
532 * Perform an atomic 32 bit add
533 *
534 * @reg: FAU atomic register to access. 0 <= reg < 2048.
535 * - Step by 4 for 32 bit access.
536 * @value: Signed value to add.
537 */
538 static inline void cvmx_fau_atomic_add32(cvmx_fau_reg_32_t reg, int32_t value)
539 {
540 reg ^= SWIZZLE_32;
541 cvmx_write64_int32(__cvmx_fau_store_address(0, reg), value);
542 }
543
544 /**
545 * Perform an atomic 16 bit add
546 *
547 * @reg: FAU atomic register to access. 0 <= reg < 2048.
548 * - Step by 2 for 16 bit access.
549 * @value: Signed value to add.
550 */
551 static inline void cvmx_fau_atomic_add16(cvmx_fau_reg_16_t reg, int16_t value)
552 {
553 reg ^= SWIZZLE_16;
554 cvmx_write64_int16(__cvmx_fau_store_address(0, reg), value);
555 }
556
557 /**
558 * Perform an atomic 8 bit add
559 *
560 * @reg: FAU atomic register to access. 0 <= reg < 2048.
561 * @value: Signed value to add.
562 */
563 static inline void cvmx_fau_atomic_add8(cvmx_fau_reg_8_t reg, int8_t value)
564 {
565 reg ^= SWIZZLE_8;
566 cvmx_write64_int8(__cvmx_fau_store_address(0, reg), value);
567 }
568
569 /**
570 * Perform an atomic 64 bit write
571 *
572 * @reg: FAU atomic register to access. 0 <= reg < 2048.
573 * - Step by 8 for 64 bit access.
574 * @value: Signed value to write.
575 */
576 static inline void cvmx_fau_atomic_write64(cvmx_fau_reg_64_t reg, int64_t value)
577 {
578 cvmx_write64_int64(__cvmx_fau_store_address(1, reg), value);
579 }
580
581 /**
582 * Perform an atomic 32 bit write
583 *
584 * @reg: FAU atomic register to access. 0 <= reg < 2048.
585 * - Step by 4 for 32 bit access.
586 * @value: Signed value to write.
587 */
588 static inline void cvmx_fau_atomic_write32(cvmx_fau_reg_32_t reg, int32_t value)
589 {
590 reg ^= SWIZZLE_32;
591 cvmx_write64_int32(__cvmx_fau_store_address(1, reg), value);
592 }
593
594 /**
595 * Perform an atomic 16 bit write
596 *
597 * @reg: FAU atomic register to access. 0 <= reg < 2048.
598 * - Step by 2 for 16 bit access.
599 * @value: Signed value to write.
600 */
601 static inline void cvmx_fau_atomic_write16(cvmx_fau_reg_16_t reg, int16_t value)
602 {
603 reg ^= SWIZZLE_16;
604 cvmx_write64_int16(__cvmx_fau_store_address(1, reg), value);
605 }
606
607 /**
608 * Perform an atomic 8 bit write
609 *
610 * @reg: FAU atomic register to access. 0 <= reg < 2048.
611 * @value: Signed value to write.
612 */
613 static inline void cvmx_fau_atomic_write8(cvmx_fau_reg_8_t reg, int8_t value)
614 {
615 reg ^= SWIZZLE_8;
616 cvmx_write64_int8(__cvmx_fau_store_address(1, reg), value);
617 }
618
619 #endif /* __CVMX_FAU_H__ */