sys/contrib/octeon-sdk/cvmx-fpa.h

   1 /***********************license start***************
   2  *  Copyright (c) 2003-2008 Cavium Networks (support@cavium.com). All rights
   3  *  reserved.
   4  *
   5  *
   6  *  Redistribution and use in source and binary forms, with or without
   7  *  modification, are permitted provided that the following conditions are
   8  *  met:
   9  *
  10  *      * Redistributions of source code must retain the above copyright
  11  *        notice, this list of conditions and the following disclaimer.
  12  *
  13  *      * Redistributions in binary form must reproduce the above
  14  *        copyright notice, this list of conditions and the following
  15  *        disclaimer in the documentation and/or other materials provided
  16  *        with the distribution.
  17  *
  18  *      * Neither the name of Cavium Networks nor the names of
  19  *        its contributors may be used to endorse or promote products
  20  *        derived from this software without specific prior written
  21  *        permission.
  22  *
  23  *  TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
  24  *  AND WITH ALL FAULTS AND CAVIUM NETWORKS MAKES NO PROMISES, REPRESENTATIONS
  25  *  OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH
  26  *  RESPECT TO THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY
  27  *  REPRESENTATION OR DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT
  28  *  DEFECTS, AND CAVIUM SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY) WARRANTIES
  29  *  OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR
  30  *  PURPOSE, LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET
  31  *  POSSESSION OR CORRESPONDENCE TO DESCRIPTION.  THE ENTIRE RISK ARISING OUT
  32  *  OF USE OR PERFORMANCE OF THE SOFTWARE LIES WITH YOU.
  33  *
  34  *
  35  *  For any questions regarding licensing please contact marketing@caviumnetworks.com
  36  *
  37  ***********************license end**************************************/
  38
  39
  40
  41
  42
  43
  44 /**
  45  * @file
  46  *
  47  * Interface to the hardware Free Pool Allocator.
  48  *
  49  * <hr>$Revision: 41586 $<hr>
  50  *
  51  */
  52
  53 #ifndef __CVMX_FPA_H__
  54 #define __CVMX_FPA_H__
  55
  56 #ifdef  __cplusplus
  57 extern "C" {
  58 #endif
  59
  60 #define CVMX_FPA_NUM_POOLS      8
  61 #define CVMX_FPA_MIN_BLOCK_SIZE 128
  62 #define CVMX_FPA_ALIGNMENT      128
  63
  64 /**
  65  * Structure describing the data format used for stores to the FPA.
  66  */
  67 typedef union
  68 {
  69     uint64_t        u64;
  70     struct {
  71         uint64_t    scraddr : 8;    /**< the (64-bit word) location in scratchpad to write to (if len != 0) */
  72         uint64_t    len     : 8;    /**< the number of words in the response (0 => no response) */
  73         uint64_t    did     : 8;    /**< the ID of the device on the non-coherent bus */
  74         uint64_t    addr    :40;    /**< the address that will appear in the first tick on the NCB bus */
  75     } s;
  76 } cvmx_fpa_iobdma_data_t;
  77
  78 /**
  79  * Structure describing the current state of a FPA pool.
  80  */
  81 typedef struct
  82 {
  83     const char *name;                   /**< Name it was created under */
  84     uint64_t    size;                   /**< Size of each block */
  85     void *      base;                   /**< The base memory address of whole block */
  86     uint64_t    starting_element_count; /**< The number of elements in the pool at creation */
  87 } cvmx_fpa_pool_info_t;
  88
  89 /**
  90  * Current state of all the pools. Use access functions
  91  * instead of using it directly.
  92  */
  93 extern cvmx_fpa_pool_info_t cvmx_fpa_pool_info[CVMX_FPA_NUM_POOLS];
  94
  95 /* CSR typedefs have been moved to cvmx-csr-*.h */
  96
  97 /**
  98  * Return the name of the pool
  99  *
 100  * @param pool   Pool to get the name of
 101  * @return The name
 102  */
 103 static inline const char *cvmx_fpa_get_name(uint64_t pool)
 104 {
 105     return cvmx_fpa_pool_info[pool].name;
 106 }
 107
 108 /**
 109  * Return the base of the pool
 110  *
 111  * @param pool   Pool to get the base of
 112  * @return The base
 113  */
 114 static inline void *cvmx_fpa_get_base(uint64_t pool)
 115 {
 116     return cvmx_fpa_pool_info[pool].base;
 117 }
 118
 119 /**
 120  * Check if a pointer belongs to an FPA pool. Return non-zero
 121  * if the supplied pointer is inside the memory controlled by
 122  * an FPA pool.
 123  *
 124  * @param pool   Pool to check
 125  * @param ptr    Pointer to check
 126  * @return Non-zero if pointer is in the pool. Zero if not
 127  */
 128 static inline int cvmx_fpa_is_member(uint64_t pool, void *ptr)
 129 {
 130     return ((ptr >= cvmx_fpa_pool_info[pool].base) &&
 131             ((char*)ptr < ((char*)(cvmx_fpa_pool_info[pool].base)) + cvmx_fpa_pool_info[pool].size * cvmx_fpa_pool_info[pool].starting_element_count));
 132 }
 133
 134
 135
 136 /**
 137  * Enable the FPA for use. Must be performed after any CSR
 138  * configuration but before any other FPA functions.
 139  */
 140 static inline void cvmx_fpa_enable(void)
 141 {
 142     cvmx_fpa_ctl_status_t status;
 143
 144     status.u64 = cvmx_read_csr(CVMX_FPA_CTL_STATUS);
 145     if (status.s.enb)
 146     {
 147         cvmx_dprintf("Warning: Enabling FPA when FPA already enabled.\n");
 148     }
 149
 150     /* Do runtime check as we allow pass1 compiled code to run on pass2 chips */
 151     if (cvmx_octeon_is_pass1())
 152     {
 153         cvmx_fpa_fpf_marks_t marks;
 154         int i;
 155         for (i=1; i<8; i++)
 156         {
 157             marks.u64 = cvmx_read_csr(CVMX_FPA_FPF1_MARKS + (i-1)*8ull);
 158             marks.s.fpf_wr = 0xe0;
 159             cvmx_write_csr(CVMX_FPA_FPF1_MARKS + (i-1)*8ull, marks.u64);
 160         }
 161
 162         /* Enforce a 10 cycle delay between config and enable */
 163         cvmx_wait(10);
 164     }
 165
 166     status.u64 = 0; /* FIXME: CVMX_FPA_CTL_STATUS read is unmodelled */
 167     status.s.enb = 1;
 168     cvmx_write_csr(CVMX_FPA_CTL_STATUS, status.u64);
 169 }
 170
 171
 172 /**
 173  * Get a new block from the FPA
 174  *
 175  * @param pool   Pool to get the block from
 176  * @return Pointer to the block or NULL on failure
 177  */
 178 static inline void *cvmx_fpa_alloc(uint64_t pool)
 179 {
 180     uint64_t address = cvmx_read_csr(CVMX_ADDR_DID(CVMX_FULL_DID(CVMX_OCT_DID_FPA,pool)));
 181     if (address)
 182         return cvmx_phys_to_ptr(address);
 183     else
 184         return NULL;
 185 }
 186
 187
 188 /**
 189  * Asynchronously get a new block from the FPA
 190  *
 191  * @param scr_addr Local scratch address to put response in.  This is a byte address,
 192  *                  but must be 8 byte aligned.
 193  * @param pool      Pool to get the block from
 194  */
 195 static inline void cvmx_fpa_async_alloc(uint64_t scr_addr, uint64_t pool)
 196 {
 197    cvmx_fpa_iobdma_data_t data;
 198
 199    /* Hardware only uses 64 bit alligned locations, so convert from byte address
 200    ** to 64-bit index
 201    */
 202    data.s.scraddr = scr_addr >> 3;
 203    data.s.len = 1;
 204    data.s.did = CVMX_FULL_DID(CVMX_OCT_DID_FPA,pool);
 205    data.s.addr = 0;
 206    cvmx_send_single(data.u64);
 207 }
 208
 209
 210 /**
 211  * Free a block allocated with a FPA pool.
 212  * Does NOT provide memory ordering in cases where the memory block was modified by the core.
 213  *
 214  * @param ptr    Block to free
 215  * @param pool   Pool to put it in
 216  * @param num_cache_lines
 217  *               Cache lines to invalidate
 218  */
 219 static inline void cvmx_fpa_free_nosync(void *ptr, uint64_t pool, uint64_t num_cache_lines)
 220 {
 221     cvmx_addr_t newptr;
 222     newptr.u64 = cvmx_ptr_to_phys(ptr);
 223     newptr.sfilldidspace.didspace = CVMX_ADDR_DIDSPACE(CVMX_FULL_DID(CVMX_OCT_DID_FPA,pool));
 224     asm volatile ("" : : : "memory");  /* Prevent GCC from reordering around free */
 225     /* value written is number of cache lines not written back */
 226     cvmx_write_io(newptr.u64, num_cache_lines);
 227 }
 228
 229 /**
 230  * Free a block allocated with a FPA pool.  Provides required memory
 231  * ordering in cases where memory block was modified by core.
 232  *
 233  * @param ptr    Block to free
 234  * @param pool   Pool to put it in
 235  * @param num_cache_lines
 236  *               Cache lines to invalidate
 237  */
 238 static inline void cvmx_fpa_free(void *ptr, uint64_t pool, uint64_t num_cache_lines)
 239 {
 240     cvmx_addr_t newptr;
 241     newptr.u64 = cvmx_ptr_to_phys(ptr);
 242     newptr.sfilldidspace.didspace = CVMX_ADDR_DIDSPACE(CVMX_FULL_DID(CVMX_OCT_DID_FPA,pool));
 243     /* Make sure that any previous writes to memory go out before we free this buffer.
 244     ** This also serves as a barrier to prevent GCC from reordering operations to after
 245     ** the free. */
 246     CVMX_SYNCWS;
 247     /* value written is number of cache lines not written back */
 248     cvmx_write_io(newptr.u64, num_cache_lines);
 249 }
 250
 251
 252 /**
 253  * Setup a FPA pool to control a new block of memory.
 254  * This can only be called once per pool. Make sure proper
 255  * locking enforces this.
 256  *
 257  * @param pool       Pool to initialize
 258  *                   0 <= pool < 8
 259  * @param name       Constant character string to name this pool.
 260  *                   String is not copied.
 261  * @param buffer     Pointer to the block of memory to use. This must be
 262  *                   accessable by all processors and external hardware.
 263  * @param block_size Size for each block controlled by the FPA
 264  * @param num_blocks Number of blocks
 265  *
 266  * @return 0 on Success,
 267  *         -1 on failure
 268  */
 269 extern int cvmx_fpa_setup_pool(uint64_t pool, const char *name, void *buffer,
 270                                 uint64_t block_size, uint64_t num_blocks);
 271
 272
 273 /**
 274  * Shutdown a Memory pool and validate that it had all of
 275  * the buffers originally placed in it. This should only be
 276  * called by one processor after all hardware has finished
 277  * using the pool.
 278  *
 279  * @param pool   Pool to shutdown
 280  * @return Zero on success
 281  *         - Positive is count of missing buffers
 282  *         - Negative is too many buffers or corrupted pointers
 283  */
 284 extern uint64_t cvmx_fpa_shutdown_pool(uint64_t pool);
 285
 286
 287 /**
 288  * Get the size of blocks controlled by the pool
 289  * This is resolved to a constant at compile time.
 290  *
 291  * @param pool   Pool to access
 292  * @return Size of the block in bytes
 293  */
 294 uint64_t cvmx_fpa_get_block_size(uint64_t pool);
 295
 296 #ifdef  __cplusplus
 297 }
 298 #endif
 299
 300 #endif //  __CVM_FPA_H__