cvmx-fau.h revision 210284
1210284Sjmallett/***********************license start*************** 2210284Sjmallett * Copyright (c) 2003-2008 Cavium Networks (support@cavium.com). All rights 3210284Sjmallett * reserved. 4210284Sjmallett * 5210284Sjmallett * 6210284Sjmallett * Redistribution and use in source and binary forms, with or without 7210284Sjmallett * modification, are permitted provided that the following conditions are 8210284Sjmallett * met: 9210284Sjmallett * 10210284Sjmallett * * Redistributions of source code must retain the above copyright 11210284Sjmallett * notice, this list of conditions and the following disclaimer. 12210284Sjmallett * 13210284Sjmallett * * Redistributions in binary form must reproduce the above 14210284Sjmallett * copyright notice, this list of conditions and the following 15210284Sjmallett * disclaimer in the documentation and/or other materials provided 16210284Sjmallett * with the distribution. 17210284Sjmallett * 18210284Sjmallett * * Neither the name of Cavium Networks nor the names of 19210284Sjmallett * its contributors may be used to endorse or promote products 20210284Sjmallett * derived from this software without specific prior written 21210284Sjmallett * permission. 22210284Sjmallett * 23210284Sjmallett * TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS" 24210284Sjmallett * AND WITH ALL FAULTS AND CAVIUM NETWORKS MAKES NO PROMISES, REPRESENTATIONS 25210284Sjmallett * OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH 26210284Sjmallett * RESPECT TO THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY 27210284Sjmallett * REPRESENTATION OR DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT 28210284Sjmallett * DEFECTS, AND CAVIUM SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY) WARRANTIES 29210284Sjmallett * OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR 30210284Sjmallett * PURPOSE, LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET 31210284Sjmallett * POSSESSION OR CORRESPONDENCE TO DESCRIPTION. THE ENTIRE RISK ARISING OUT 32210284Sjmallett * OF USE OR PERFORMANCE OF THE SOFTWARE LIES WITH YOU. 33210284Sjmallett * 34210284Sjmallett * 35210284Sjmallett * For any questions regarding licensing please contact marketing@caviumnetworks.com 36210284Sjmallett * 37210284Sjmallett ***********************license end**************************************/ 38210284Sjmallett 39210284Sjmallett 40210284Sjmallett 41210284Sjmallett 42210284Sjmallett 43210284Sjmallett 44210284Sjmallett/** 45210284Sjmallett * @file 46210284Sjmallett * 47210284Sjmallett * Interface to the hardware Fetch and Add Unit. 48210284Sjmallett * 49210284Sjmallett * <hr>$Revision: 41586 $<hr> 50210284Sjmallett */ 51210284Sjmallett 52210284Sjmallett#ifndef __CVMX_FAU_H__ 53210284Sjmallett#define __CVMX_FAU_H__ 54210284Sjmallett 55210284Sjmallett#ifndef CVMX_DONT_INCLUDE_CONFIG 56210284Sjmallett#include "cvmx-config.h" 57210284Sjmallett#else 58210284Sjmalletttypedef int cvmx_fau_reg_64_t; 59210284Sjmalletttypedef int cvmx_fau_reg_32_t; 60210284Sjmalletttypedef int cvmx_fau_reg_16_t; 61210284Sjmalletttypedef int cvmx_fau_reg_8_t; 62210284Sjmallett#endif 63210284Sjmallett 64210284Sjmallett#ifdef __cplusplus 65210284Sjmallettextern "C" { 66210284Sjmallett#endif 67210284Sjmallett 68210284Sjmallett/* 69210284Sjmallett * Octeon Fetch and Add Unit (FAU) 70210284Sjmallett */ 71210284Sjmallett 72210284Sjmallett#define CVMX_FAU_LOAD_IO_ADDRESS cvmx_build_io_address(0x1e, 0) 73210284Sjmallett#define CVMX_FAU_BITS_SCRADDR 63,56 74210284Sjmallett#define CVMX_FAU_BITS_LEN 55,48 75210284Sjmallett#define CVMX_FAU_BITS_INEVAL 35,14 76210284Sjmallett#define CVMX_FAU_BITS_TAGWAIT 13,13 77210284Sjmallett#define CVMX_FAU_BITS_NOADD 13,13 78210284Sjmallett#define CVMX_FAU_BITS_SIZE 12,11 79210284Sjmallett#define CVMX_FAU_BITS_REGISTER 10,0 80210284Sjmallett 81210284Sjmallett 82210284Sjmalletttypedef enum { 83210284Sjmallett CVMX_FAU_OP_SIZE_8 = 0, 84210284Sjmallett CVMX_FAU_OP_SIZE_16 = 1, 85210284Sjmallett CVMX_FAU_OP_SIZE_32 = 2, 86210284Sjmallett CVMX_FAU_OP_SIZE_64 = 3 87210284Sjmallett} cvmx_fau_op_size_t; 88210284Sjmallett 89210284Sjmallett/** 90210284Sjmallett * Tagwait return definition. If a timeout occurs, the error 91210284Sjmallett * bit will be set. Otherwise the value of the register before 92210284Sjmallett * the update will be returned. 93210284Sjmallett */ 94210284Sjmalletttypedef struct 95210284Sjmallett{ 96210284Sjmallett uint64_t error : 1; 97210284Sjmallett int64_t value : 63; 98210284Sjmallett} cvmx_fau_tagwait64_t; 99210284Sjmallett 100210284Sjmallett/** 101210284Sjmallett * Tagwait return definition. If a timeout occurs, the error 102210284Sjmallett * bit will be set. Otherwise the value of the register before 103210284Sjmallett * the update will be returned. 104210284Sjmallett */ 105210284Sjmalletttypedef struct 106210284Sjmallett{ 107210284Sjmallett uint64_t error : 1; 108210284Sjmallett int32_t value : 31; 109210284Sjmallett} cvmx_fau_tagwait32_t; 110210284Sjmallett 111210284Sjmallett/** 112210284Sjmallett * Tagwait return definition. If a timeout occurs, the error 113210284Sjmallett * bit will be set. Otherwise the value of the register before 114210284Sjmallett * the update will be returned. 115210284Sjmallett */ 116210284Sjmalletttypedef struct 117210284Sjmallett{ 118210284Sjmallett uint64_t error : 1; 119210284Sjmallett int16_t value : 15; 120210284Sjmallett} cvmx_fau_tagwait16_t; 121210284Sjmallett 122210284Sjmallett/** 123210284Sjmallett * Tagwait return definition. If a timeout occurs, the error 124210284Sjmallett * bit will be set. Otherwise the value of the register before 125210284Sjmallett * the update will be returned. 126210284Sjmallett */ 127210284Sjmalletttypedef struct 128210284Sjmallett{ 129210284Sjmallett uint64_t error : 1; 130210284Sjmallett int8_t value : 7; 131210284Sjmallett} cvmx_fau_tagwait8_t; 132210284Sjmallett 133210284Sjmallett/** 134210284Sjmallett * Asynchronous tagwait return definition. If a timeout occurs, 135210284Sjmallett * the error bit will be set. Otherwise the value of the 136210284Sjmallett * register before the update will be returned. 137210284Sjmallett */ 138210284Sjmalletttypedef union { 139210284Sjmallett uint64_t u64; 140210284Sjmallett struct { 141210284Sjmallett uint64_t invalid: 1; 142210284Sjmallett uint64_t data :63; // unpredictable if invalid is set 143210284Sjmallett } s; 144210284Sjmallett} cvmx_fau_async_tagwait_result_t; 145210284Sjmallett 146210284Sjmallett 147210284Sjmallett/** 148210284Sjmallett * @INTERNAL 149210284Sjmallett * Builds a store I/O address for writing to the FAU 150210284Sjmallett * 151210284Sjmallett * @param noadd 0 = Store value is atomically added to the current value 152210284Sjmallett * 1 = Store value is atomically written over the current value 153210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 154210284Sjmallett * - Step by 2 for 16 bit access. 155210284Sjmallett * - Step by 4 for 32 bit access. 156210284Sjmallett * - Step by 8 for 64 bit access. 157210284Sjmallett * @return Address to store for atomic update 158210284Sjmallett */ 159210284Sjmallettstatic inline uint64_t __cvmx_fau_store_address(uint64_t noadd, uint64_t reg) 160210284Sjmallett{ 161210284Sjmallett return (CVMX_ADD_IO_SEG(CVMX_FAU_LOAD_IO_ADDRESS) | 162210284Sjmallett cvmx_build_bits(CVMX_FAU_BITS_NOADD, noadd) | 163210284Sjmallett cvmx_build_bits(CVMX_FAU_BITS_REGISTER, reg)); 164210284Sjmallett} 165210284Sjmallett 166210284Sjmallett 167210284Sjmallett/** 168210284Sjmallett * @INTERNAL 169210284Sjmallett * Builds a I/O address for accessing the FAU 170210284Sjmallett * 171210284Sjmallett * @param tagwait Should the atomic add wait for the current tag switch 172210284Sjmallett * operation to complete. 173210284Sjmallett * - 0 = Don't wait 174210284Sjmallett * - 1 = Wait for tag switch to complete 175210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 176210284Sjmallett * - Step by 2 for 16 bit access. 177210284Sjmallett * - Step by 4 for 32 bit access. 178210284Sjmallett * - Step by 8 for 64 bit access. 179210284Sjmallett * @param value Signed value to add. 180210284Sjmallett * Note: When performing 32 and 64 bit access, only the low 181210284Sjmallett * 22 bits are available. 182210284Sjmallett * @return Address to read from for atomic update 183210284Sjmallett */ 184210284Sjmallettstatic inline uint64_t __cvmx_fau_atomic_address(uint64_t tagwait, uint64_t reg, int64_t value) 185210284Sjmallett{ 186210284Sjmallett return (CVMX_ADD_IO_SEG(CVMX_FAU_LOAD_IO_ADDRESS) | 187210284Sjmallett cvmx_build_bits(CVMX_FAU_BITS_INEVAL, value) | 188210284Sjmallett cvmx_build_bits(CVMX_FAU_BITS_TAGWAIT, tagwait) | 189210284Sjmallett cvmx_build_bits(CVMX_FAU_BITS_REGISTER, reg)); 190210284Sjmallett} 191210284Sjmallett 192210284Sjmallett 193210284Sjmallett/** 194210284Sjmallett * Perform an atomic 64 bit add 195210284Sjmallett * 196210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 197210284Sjmallett * - Step by 8 for 64 bit access. 198210284Sjmallett * @param value Signed value to add. 199210284Sjmallett * Note: Only the low 22 bits are available. 200210284Sjmallett * @return Value of the register before the update 201210284Sjmallett */ 202210284Sjmallettstatic inline int64_t cvmx_fau_fetch_and_add64(cvmx_fau_reg_64_t reg, int64_t value) 203210284Sjmallett{ 204210284Sjmallett return cvmx_read64_int64(__cvmx_fau_atomic_address(0, reg, value)); 205210284Sjmallett} 206210284Sjmallett 207210284Sjmallett 208210284Sjmallett/** 209210284Sjmallett * Perform an atomic 32 bit add 210210284Sjmallett * 211210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 212210284Sjmallett * - Step by 4 for 32 bit access. 213210284Sjmallett * @param value Signed value to add. 214210284Sjmallett * Note: Only the low 22 bits are available. 215210284Sjmallett * @return Value of the register before the update 216210284Sjmallett */ 217210284Sjmallettstatic inline int32_t cvmx_fau_fetch_and_add32(cvmx_fau_reg_32_t reg, int32_t value) 218210284Sjmallett{ 219210284Sjmallett return cvmx_read64_int32(__cvmx_fau_atomic_address(0, reg, value)); 220210284Sjmallett} 221210284Sjmallett 222210284Sjmallett 223210284Sjmallett/** 224210284Sjmallett * Perform an atomic 16 bit add 225210284Sjmallett * 226210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 227210284Sjmallett * - Step by 2 for 16 bit access. 228210284Sjmallett * @param value Signed value to add. 229210284Sjmallett * @return Value of the register before the update 230210284Sjmallett */ 231210284Sjmallettstatic inline int16_t cvmx_fau_fetch_and_add16(cvmx_fau_reg_16_t reg, int16_t value) 232210284Sjmallett{ 233210284Sjmallett return cvmx_read64_int16(__cvmx_fau_atomic_address(0, reg, value)); 234210284Sjmallett} 235210284Sjmallett 236210284Sjmallett 237210284Sjmallett/** 238210284Sjmallett * Perform an atomic 8 bit add 239210284Sjmallett * 240210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 241210284Sjmallett * @param value Signed value to add. 242210284Sjmallett * @return Value of the register before the update 243210284Sjmallett */ 244210284Sjmallettstatic inline int8_t cvmx_fau_fetch_and_add8(cvmx_fau_reg_8_t reg, int8_t value) 245210284Sjmallett{ 246210284Sjmallett return cvmx_read64_int8(__cvmx_fau_atomic_address(0, reg, value)); 247210284Sjmallett} 248210284Sjmallett 249210284Sjmallett 250210284Sjmallett/** 251210284Sjmallett * Perform an atomic 64 bit add after the current tag switch 252210284Sjmallett * completes 253210284Sjmallett * 254210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 255210284Sjmallett * - Step by 8 for 64 bit access. 256210284Sjmallett * @param value Signed value to add. 257210284Sjmallett * Note: Only the low 22 bits are available. 258210284Sjmallett * @return If a timeout occurs, the error bit will be set. Otherwise 259210284Sjmallett * the value of the register before the update will be 260210284Sjmallett * returned 261210284Sjmallett */ 262210284Sjmallettstatic inline cvmx_fau_tagwait64_t cvmx_fau_tagwait_fetch_and_add64(cvmx_fau_reg_64_t reg, int64_t value) 263210284Sjmallett{ 264210284Sjmallett union 265210284Sjmallett { 266210284Sjmallett uint64_t i64; 267210284Sjmallett cvmx_fau_tagwait64_t t; 268210284Sjmallett } result; 269210284Sjmallett result.i64 = cvmx_read64_int64(__cvmx_fau_atomic_address(1, reg, value)); 270210284Sjmallett return result.t; 271210284Sjmallett} 272210284Sjmallett 273210284Sjmallett 274210284Sjmallett/** 275210284Sjmallett * Perform an atomic 32 bit add after the current tag switch 276210284Sjmallett * completes 277210284Sjmallett * 278210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 279210284Sjmallett * - Step by 4 for 32 bit access. 280210284Sjmallett * @param value Signed value to add. 281210284Sjmallett * Note: Only the low 22 bits are available. 282210284Sjmallett * @return If a timeout occurs, the error bit will be set. Otherwise 283210284Sjmallett * the value of the register before the update will be 284210284Sjmallett * returned 285210284Sjmallett */ 286210284Sjmallettstatic inline cvmx_fau_tagwait32_t cvmx_fau_tagwait_fetch_and_add32(cvmx_fau_reg_32_t reg, int32_t value) 287210284Sjmallett{ 288210284Sjmallett union 289210284Sjmallett { 290210284Sjmallett uint64_t i32; 291210284Sjmallett cvmx_fau_tagwait32_t t; 292210284Sjmallett } result; 293210284Sjmallett result.i32 = cvmx_read64_int32(__cvmx_fau_atomic_address(1, reg, value)); 294210284Sjmallett return result.t; 295210284Sjmallett} 296210284Sjmallett 297210284Sjmallett 298210284Sjmallett/** 299210284Sjmallett * Perform an atomic 16 bit add after the current tag switch 300210284Sjmallett * completes 301210284Sjmallett * 302210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 303210284Sjmallett * - Step by 2 for 16 bit access. 304210284Sjmallett * @param value Signed value to add. 305210284Sjmallett * @return If a timeout occurs, the error bit will be set. Otherwise 306210284Sjmallett * the value of the register before the update will be 307210284Sjmallett * returned 308210284Sjmallett */ 309210284Sjmallettstatic inline cvmx_fau_tagwait16_t cvmx_fau_tagwait_fetch_and_add16(cvmx_fau_reg_16_t reg, int16_t value) 310210284Sjmallett{ 311210284Sjmallett union 312210284Sjmallett { 313210284Sjmallett uint64_t i16; 314210284Sjmallett cvmx_fau_tagwait16_t t; 315210284Sjmallett } result; 316210284Sjmallett result.i16 = cvmx_read64_int16(__cvmx_fau_atomic_address(1, reg, value)); 317210284Sjmallett return result.t; 318210284Sjmallett} 319210284Sjmallett 320210284Sjmallett 321210284Sjmallett/** 322210284Sjmallett * Perform an atomic 8 bit add after the current tag switch 323210284Sjmallett * completes 324210284Sjmallett * 325210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 326210284Sjmallett * @param value Signed value to add. 327210284Sjmallett * @return If a timeout occurs, the error bit will be set. Otherwise 328210284Sjmallett * the value of the register before the update will be 329210284Sjmallett * returned 330210284Sjmallett */ 331210284Sjmallettstatic inline cvmx_fau_tagwait8_t cvmx_fau_tagwait_fetch_and_add8(cvmx_fau_reg_8_t reg, int8_t value) 332210284Sjmallett{ 333210284Sjmallett union 334210284Sjmallett { 335210284Sjmallett uint64_t i8; 336210284Sjmallett cvmx_fau_tagwait8_t t; 337210284Sjmallett } result; 338210284Sjmallett result.i8 = cvmx_read64_int8(__cvmx_fau_atomic_address(1, reg, value)); 339210284Sjmallett return result.t; 340210284Sjmallett} 341210284Sjmallett 342210284Sjmallett 343210284Sjmallett/** 344210284Sjmallett * @INTERNAL 345210284Sjmallett * Builds I/O data for async operations 346210284Sjmallett * 347210284Sjmallett * @param scraddr Scratch pad byte addres to write to. Must be 8 byte aligned 348210284Sjmallett * @param value Signed value to add. 349210284Sjmallett * Note: When performing 32 and 64 bit access, only the low 350210284Sjmallett * 22 bits are available. 351210284Sjmallett * @param tagwait Should the atomic add wait for the current tag switch 352210284Sjmallett * operation to complete. 353210284Sjmallett * - 0 = Don't wait 354210284Sjmallett * - 1 = Wait for tag switch to complete 355210284Sjmallett * @param size The size of the operation: 356210284Sjmallett * - CVMX_FAU_OP_SIZE_8 (0) = 8 bits 357210284Sjmallett * - CVMX_FAU_OP_SIZE_16 (1) = 16 bits 358210284Sjmallett * - CVMX_FAU_OP_SIZE_32 (2) = 32 bits 359210284Sjmallett * - CVMX_FAU_OP_SIZE_64 (3) = 64 bits 360210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 361210284Sjmallett * - Step by 2 for 16 bit access. 362210284Sjmallett * - Step by 4 for 32 bit access. 363210284Sjmallett * - Step by 8 for 64 bit access. 364210284Sjmallett * @return Data to write using cvmx_send_single 365210284Sjmallett */ 366210284Sjmallettstatic inline uint64_t __cvmx_fau_iobdma_data(uint64_t scraddr, int64_t value, uint64_t tagwait, 367210284Sjmallett cvmx_fau_op_size_t size, uint64_t reg) 368210284Sjmallett{ 369210284Sjmallett return (CVMX_FAU_LOAD_IO_ADDRESS | 370210284Sjmallett cvmx_build_bits(CVMX_FAU_BITS_SCRADDR, scraddr>>3) | 371210284Sjmallett cvmx_build_bits(CVMX_FAU_BITS_LEN, 1) | 372210284Sjmallett cvmx_build_bits(CVMX_FAU_BITS_INEVAL, value) | 373210284Sjmallett cvmx_build_bits(CVMX_FAU_BITS_TAGWAIT, tagwait) | 374210284Sjmallett cvmx_build_bits(CVMX_FAU_BITS_SIZE, size) | 375210284Sjmallett cvmx_build_bits(CVMX_FAU_BITS_REGISTER, reg)); 376210284Sjmallett} 377210284Sjmallett 378210284Sjmallett 379210284Sjmallett/** 380210284Sjmallett * Perform an async atomic 64 bit add. The old value is 381210284Sjmallett * placed in the scratch memory at byte address scraddr. 382210284Sjmallett * 383210284Sjmallett * @param scraddr Scratch memory byte address to put response in. 384210284Sjmallett * Must be 8 byte aligned. 385210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 386210284Sjmallett * - Step by 8 for 64 bit access. 387210284Sjmallett * @param value Signed value to add. 388210284Sjmallett * Note: Only the low 22 bits are available. 389210284Sjmallett * @return Placed in the scratch pad register 390210284Sjmallett */ 391210284Sjmallettstatic inline void cvmx_fau_async_fetch_and_add64(uint64_t scraddr, cvmx_fau_reg_64_t reg, int64_t value) 392210284Sjmallett{ 393210284Sjmallett cvmx_send_single(__cvmx_fau_iobdma_data(scraddr, value, 0, CVMX_FAU_OP_SIZE_64, reg)); 394210284Sjmallett} 395210284Sjmallett 396210284Sjmallett 397210284Sjmallett/** 398210284Sjmallett * Perform an async atomic 32 bit add. The old value is 399210284Sjmallett * placed in the scratch memory at byte address scraddr. 400210284Sjmallett * 401210284Sjmallett * @param scraddr Scratch memory byte address to put response in. 402210284Sjmallett * Must be 8 byte aligned. 403210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 404210284Sjmallett * - Step by 4 for 32 bit access. 405210284Sjmallett * @param value Signed value to add. 406210284Sjmallett * Note: Only the low 22 bits are available. 407210284Sjmallett * @return Placed in the scratch pad register 408210284Sjmallett */ 409210284Sjmallettstatic inline void cvmx_fau_async_fetch_and_add32(uint64_t scraddr, cvmx_fau_reg_32_t reg, int32_t value) 410210284Sjmallett{ 411210284Sjmallett cvmx_send_single(__cvmx_fau_iobdma_data(scraddr, value, 0, CVMX_FAU_OP_SIZE_32, reg)); 412210284Sjmallett} 413210284Sjmallett 414210284Sjmallett 415210284Sjmallett/** 416210284Sjmallett * Perform an async atomic 16 bit add. The old value is 417210284Sjmallett * placed in the scratch memory at byte address scraddr. 418210284Sjmallett * 419210284Sjmallett * @param scraddr Scratch memory byte address to put response in. 420210284Sjmallett * Must be 8 byte aligned. 421210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 422210284Sjmallett * - Step by 2 for 16 bit access. 423210284Sjmallett * @param value Signed value to add. 424210284Sjmallett * @return Placed in the scratch pad register 425210284Sjmallett */ 426210284Sjmallettstatic inline void cvmx_fau_async_fetch_and_add16(uint64_t scraddr, cvmx_fau_reg_16_t reg, int16_t value) 427210284Sjmallett{ 428210284Sjmallett cvmx_send_single(__cvmx_fau_iobdma_data(scraddr, value, 0, CVMX_FAU_OP_SIZE_16, reg)); 429210284Sjmallett} 430210284Sjmallett 431210284Sjmallett 432210284Sjmallett/** 433210284Sjmallett * Perform an async atomic 8 bit add. The old value is 434210284Sjmallett * placed in the scratch memory at byte address scraddr. 435210284Sjmallett * 436210284Sjmallett * @param scraddr Scratch memory byte address to put response in. 437210284Sjmallett * Must be 8 byte aligned. 438210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 439210284Sjmallett * @param value Signed value to add. 440210284Sjmallett * @return Placed in the scratch pad register 441210284Sjmallett */ 442210284Sjmallettstatic inline void cvmx_fau_async_fetch_and_add8(uint64_t scraddr, cvmx_fau_reg_8_t reg, int8_t value) 443210284Sjmallett{ 444210284Sjmallett cvmx_send_single(__cvmx_fau_iobdma_data(scraddr, value, 0, CVMX_FAU_OP_SIZE_8, reg)); 445210284Sjmallett} 446210284Sjmallett 447210284Sjmallett 448210284Sjmallett/** 449210284Sjmallett * Perform an async atomic 64 bit add after the current tag 450210284Sjmallett * switch completes. 451210284Sjmallett * 452210284Sjmallett * @param scraddr Scratch memory byte address to put response in. 453210284Sjmallett * Must be 8 byte aligned. 454210284Sjmallett * If a timeout occurs, the error bit (63) will be set. Otherwise 455210284Sjmallett * the value of the register before the update will be 456210284Sjmallett * returned 457210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 458210284Sjmallett * - Step by 8 for 64 bit access. 459210284Sjmallett * @param value Signed value to add. 460210284Sjmallett * Note: Only the low 22 bits are available. 461210284Sjmallett * @return Placed in the scratch pad register 462210284Sjmallett */ 463210284Sjmallettstatic inline void cvmx_fau_async_tagwait_fetch_and_add64(uint64_t scraddr, cvmx_fau_reg_64_t reg, int64_t value) 464210284Sjmallett{ 465210284Sjmallett cvmx_send_single(__cvmx_fau_iobdma_data(scraddr, value, 1, CVMX_FAU_OP_SIZE_64, reg)); 466210284Sjmallett} 467210284Sjmallett 468210284Sjmallett 469210284Sjmallett/** 470210284Sjmallett * Perform an async atomic 32 bit add after the current tag 471210284Sjmallett * switch completes. 472210284Sjmallett * 473210284Sjmallett * @param scraddr Scratch memory byte address to put response in. 474210284Sjmallett * Must be 8 byte aligned. 475210284Sjmallett * If a timeout occurs, the error bit (63) will be set. Otherwise 476210284Sjmallett * the value of the register before the update will be 477210284Sjmallett * returned 478210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 479210284Sjmallett * - Step by 4 for 32 bit access. 480210284Sjmallett * @param value Signed value to add. 481210284Sjmallett * Note: Only the low 22 bits are available. 482210284Sjmallett * @return Placed in the scratch pad register 483210284Sjmallett */ 484210284Sjmallettstatic inline void cvmx_fau_async_tagwait_fetch_and_add32(uint64_t scraddr, cvmx_fau_reg_32_t reg, int32_t value) 485210284Sjmallett{ 486210284Sjmallett cvmx_send_single(__cvmx_fau_iobdma_data(scraddr, value, 1, CVMX_FAU_OP_SIZE_32, reg)); 487210284Sjmallett} 488210284Sjmallett 489210284Sjmallett 490210284Sjmallett/** 491210284Sjmallett * Perform an async atomic 16 bit add after the current tag 492210284Sjmallett * switch completes. 493210284Sjmallett * 494210284Sjmallett * @param scraddr Scratch memory byte address to put response in. 495210284Sjmallett * Must be 8 byte aligned. 496210284Sjmallett * If a timeout occurs, the error bit (63) will be set. Otherwise 497210284Sjmallett * the value of the register before the update will be 498210284Sjmallett * returned 499210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 500210284Sjmallett * - Step by 2 for 16 bit access. 501210284Sjmallett * @param value Signed value to add. 502210284Sjmallett * @return Placed in the scratch pad register 503210284Sjmallett */ 504210284Sjmallettstatic inline void cvmx_fau_async_tagwait_fetch_and_add16(uint64_t scraddr, cvmx_fau_reg_16_t reg, int16_t value) 505210284Sjmallett{ 506210284Sjmallett cvmx_send_single(__cvmx_fau_iobdma_data(scraddr, value, 1, CVMX_FAU_OP_SIZE_16, reg)); 507210284Sjmallett} 508210284Sjmallett 509210284Sjmallett 510210284Sjmallett/** 511210284Sjmallett * Perform an async atomic 8 bit add after the current tag 512210284Sjmallett * switch completes. 513210284Sjmallett * 514210284Sjmallett * @param scraddr Scratch memory byte address to put response in. 515210284Sjmallett * Must be 8 byte aligned. 516210284Sjmallett * If a timeout occurs, the error bit (63) will be set. Otherwise 517210284Sjmallett * the value of the register before the update will be 518210284Sjmallett * returned 519210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 520210284Sjmallett * @param value Signed value to add. 521210284Sjmallett * @return Placed in the scratch pad register 522210284Sjmallett */ 523210284Sjmallettstatic inline void cvmx_fau_async_tagwait_fetch_and_add8(uint64_t scraddr, cvmx_fau_reg_8_t reg, int8_t value) 524210284Sjmallett{ 525210284Sjmallett cvmx_send_single(__cvmx_fau_iobdma_data(scraddr, value, 1, CVMX_FAU_OP_SIZE_8, reg)); 526210284Sjmallett} 527210284Sjmallett 528210284Sjmallett 529210284Sjmallett 530210284Sjmallett 531210284Sjmallett/** 532210284Sjmallett * Perform an atomic 64 bit add 533210284Sjmallett * 534210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 535210284Sjmallett * - Step by 8 for 64 bit access. 536210284Sjmallett * @param value Signed value to add. 537210284Sjmallett */ 538210284Sjmallettstatic inline void cvmx_fau_atomic_add64(cvmx_fau_reg_64_t reg, int64_t value) 539210284Sjmallett{ 540210284Sjmallett cvmx_write64_int64(__cvmx_fau_store_address(0, reg), value); 541210284Sjmallett} 542210284Sjmallett 543210284Sjmallett 544210284Sjmallett/** 545210284Sjmallett * Perform an atomic 32 bit add 546210284Sjmallett * 547210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 548210284Sjmallett * - Step by 4 for 32 bit access. 549210284Sjmallett * @param value Signed value to add. 550210284Sjmallett */ 551210284Sjmallettstatic inline void cvmx_fau_atomic_add32(cvmx_fau_reg_32_t reg, int32_t value) 552210284Sjmallett{ 553210284Sjmallett cvmx_write64_int32(__cvmx_fau_store_address(0, reg), value); 554210284Sjmallett} 555210284Sjmallett 556210284Sjmallett 557210284Sjmallett/** 558210284Sjmallett * Perform an atomic 16 bit add 559210284Sjmallett * 560210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 561210284Sjmallett * - Step by 2 for 16 bit access. 562210284Sjmallett * @param value Signed value to add. 563210284Sjmallett */ 564210284Sjmallettstatic inline void cvmx_fau_atomic_add16(cvmx_fau_reg_16_t reg, int16_t value) 565210284Sjmallett{ 566210284Sjmallett cvmx_write64_int16(__cvmx_fau_store_address(0, reg), value); 567210284Sjmallett} 568210284Sjmallett 569210284Sjmallett 570210284Sjmallett/** 571210284Sjmallett * Perform an atomic 8 bit add 572210284Sjmallett * 573210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 574210284Sjmallett * @param value Signed value to add. 575210284Sjmallett */ 576210284Sjmallettstatic inline void cvmx_fau_atomic_add8(cvmx_fau_reg_8_t reg, int8_t value) 577210284Sjmallett{ 578210284Sjmallett cvmx_write64_int8(__cvmx_fau_store_address(0, reg), value); 579210284Sjmallett} 580210284Sjmallett 581210284Sjmallett 582210284Sjmallett/** 583210284Sjmallett * Perform an atomic 64 bit write 584210284Sjmallett * 585210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 586210284Sjmallett * - Step by 8 for 64 bit access. 587210284Sjmallett * @param value Signed value to write. 588210284Sjmallett */ 589210284Sjmallettstatic inline void cvmx_fau_atomic_write64(cvmx_fau_reg_64_t reg, int64_t value) 590210284Sjmallett{ 591210284Sjmallett cvmx_write64_int64(__cvmx_fau_store_address(1, reg), value); 592210284Sjmallett} 593210284Sjmallett 594210284Sjmallett 595210284Sjmallett/** 596210284Sjmallett * Perform an atomic 32 bit write 597210284Sjmallett * 598210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 599210284Sjmallett * - Step by 4 for 32 bit access. 600210284Sjmallett * @param value Signed value to write. 601210284Sjmallett */ 602210284Sjmallettstatic inline void cvmx_fau_atomic_write32(cvmx_fau_reg_32_t reg, int32_t value) 603210284Sjmallett{ 604210284Sjmallett cvmx_write64_int32(__cvmx_fau_store_address(1, reg), value); 605210284Sjmallett} 606210284Sjmallett 607210284Sjmallett 608210284Sjmallett/** 609210284Sjmallett * Perform an atomic 16 bit write 610210284Sjmallett * 611210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 612210284Sjmallett * - Step by 2 for 16 bit access. 613210284Sjmallett * @param value Signed value to write. 614210284Sjmallett */ 615210284Sjmallettstatic inline void cvmx_fau_atomic_write16(cvmx_fau_reg_16_t reg, int16_t value) 616210284Sjmallett{ 617210284Sjmallett cvmx_write64_int16(__cvmx_fau_store_address(1, reg), value); 618210284Sjmallett} 619210284Sjmallett 620210284Sjmallett 621210284Sjmallett/** 622210284Sjmallett * Perform an atomic 8 bit write 623210284Sjmallett * 624210284Sjmallett * @param reg FAU atomic register to access. 0 <= reg < 2048. 625210284Sjmallett * @param value Signed value to write. 626210284Sjmallett */ 627210284Sjmallettstatic inline void cvmx_fau_atomic_write8(cvmx_fau_reg_8_t reg, int8_t value) 628210284Sjmallett{ 629210284Sjmallett cvmx_write64_int8(__cvmx_fau_store_address(1, reg), value); 630210284Sjmallett} 631210284Sjmallett 632210284Sjmallett#ifdef __cplusplus 633210284Sjmallett} 634210284Sjmallett#endif 635210284Sjmallett 636210284Sjmallett#endif /* __CVMX_FAU_H__ */ 637