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 * Simple allocate only memory allocator. Used to allocate memory at 30 * application start time. 31 */ 32 33#ifndef __CVMX_BOOTMEM_H__ 34#define __CVMX_BOOTMEM_H__ 35/* Must be multiple of 8, changing breaks ABI */ 36#define CVMX_BOOTMEM_NAME_LEN 128 37 38/* Can change without breaking ABI */ 39#define CVMX_BOOTMEM_NUM_NAMED_BLOCKS 64 40 41/* minimum alignment of bootmem alloced blocks */ 42#define CVMX_BOOTMEM_ALIGNMENT_SIZE (16ull) 43 44/* Flags for cvmx_bootmem_phy_mem* functions */ 45/* Allocate from end of block instead of beginning */ 46#define CVMX_BOOTMEM_FLAG_END_ALLOC (1 << 0) 47 48/* Don't do any locking. */ 49#define CVMX_BOOTMEM_FLAG_NO_LOCKING (1 << 1) 50 51/* First bytes of each free physical block of memory contain this structure, 52 * which is used to maintain the free memory list. Since the bootloader is 53 * only 32 bits, there is a union providing 64 and 32 bit versions. The 54 * application init code converts addresses to 64 bit addresses before the 55 * application starts. 56 */ 57struct cvmx_bootmem_block_header { 58 /* 59 * Note: these are referenced from assembly routines in the 60 * bootloader, so this structure should not be changed 61 * without changing those routines as well. 62 */ 63 uint64_t next_block_addr; 64 uint64_t size; 65 66}; 67 68/* 69 * Structure for named memory blocks. Number of descriptors available 70 * can be changed without affecting compatibility, but name length 71 * changes require a bump in the bootmem descriptor version Note: This 72 * structure must be naturally 64 bit aligned, as a single memory 73 * image will be used by both 32 and 64 bit programs. 74 */ 75struct cvmx_bootmem_named_block_desc { 76 /* Base address of named block */ 77 uint64_t base_addr; 78 /* 79 * Size actually allocated for named block (may differ from 80 * requested). 81 */ 82 uint64_t size; 83 /* name of named block */ 84 char name[CVMX_BOOTMEM_NAME_LEN]; 85}; 86 87/* Current descriptor versions */ 88/* CVMX bootmem descriptor major version */ 89#define CVMX_BOOTMEM_DESC_MAJ_VER 3 90 91/* CVMX bootmem descriptor minor version */ 92#define CVMX_BOOTMEM_DESC_MIN_VER 0 93 94/* First three members of cvmx_bootmem_desc_t are left in original 95 * positions for backwards compatibility. 96 */ 97struct cvmx_bootmem_desc { 98#if defined(__BIG_ENDIAN_BITFIELD) || defined(CVMX_BUILD_FOR_LINUX_HOST) 99 /* spinlock to control access to list */ 100 uint32_t lock; 101 /* flags for indicating various conditions */ 102 uint32_t flags; 103 uint64_t head_addr; 104 105 /* Incremented when incompatible changes made */ 106 uint32_t major_version; 107 108 /* 109 * Incremented changed when compatible changes made, reset to 110 * zero when major incremented. 111 */ 112 uint32_t minor_version; 113 114 uint64_t app_data_addr; 115 uint64_t app_data_size; 116 117 /* number of elements in named blocks array */ 118 uint32_t named_block_num_blocks; 119 120 /* length of name array in bootmem blocks */ 121 uint32_t named_block_name_len; 122 /* address of named memory block descriptors */ 123 uint64_t named_block_array_addr; 124#else /* __LITTLE_ENDIAN */ 125 uint32_t flags; 126 uint32_t lock; 127 uint64_t head_addr; 128 129 uint32_t minor_version; 130 uint32_t major_version; 131 uint64_t app_data_addr; 132 uint64_t app_data_size; 133 134 uint32_t named_block_name_len; 135 uint32_t named_block_num_blocks; 136 uint64_t named_block_array_addr; 137#endif 138}; 139 140/** 141 * Initialize the boot alloc memory structures. This is 142 * normally called inside of cvmx_user_app_init() 143 * 144 * @mem_desc_ptr: Address of the free memory list 145 */ 146extern int cvmx_bootmem_init(void *mem_desc_ptr); 147 148/** 149 * Allocate a block of memory from the free list that was 150 * passed to the application by the bootloader at a specific 151 * address. This is an allocate-only algorithm, so 152 * freeing memory is not possible. Allocation will fail if 153 * memory cannot be allocated at the specified address. 154 * 155 * @size: Size in bytes of block to allocate 156 * @address: Physical address to allocate memory at. If this memory is not 157 * available, the allocation fails. 158 * @alignment: Alignment required - must be power of 2 159 * Returns pointer to block of memory, NULL on error 160 */ 161extern void *cvmx_bootmem_alloc_address(uint64_t size, uint64_t address, 162 uint64_t alignment); 163 164/** 165 * Frees a previously allocated named bootmem block. 166 * 167 * @name: name of block to free 168 * 169 * Returns 0 on failure, 170 * !0 on success 171 */ 172 173 174/** 175 * Allocate a block of memory from the free list that was passed 176 * to the application by the bootloader, and assign it a name in the 177 * global named block table. (part of the cvmx_bootmem_descriptor_t structure) 178 * Named blocks can later be freed. 179 * 180 * @size: Size in bytes of block to allocate 181 * @alignment: Alignment required - must be power of 2 182 * @name: name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes 183 * 184 * Returns a pointer to block of memory, NULL on error 185 */ 186extern void *cvmx_bootmem_alloc_named(uint64_t size, uint64_t alignment, 187 char *name); 188 189/** 190 * Allocate a block of memory from a specific range of the free list 191 * that was passed to the application by the bootloader, and assign it 192 * a name in the global named block table. (part of the 193 * cvmx_bootmem_descriptor_t structure) Named blocks can later be 194 * freed. If request cannot be satisfied within the address range 195 * specified, NULL is returned 196 * 197 * @size: Size in bytes of block to allocate 198 * @min_addr: minimum address of range 199 * @max_addr: maximum address of range 200 * @align: Alignment of memory to be allocated. (must be a power of 2) 201 * @name: name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes 202 * 203 * Returns a pointer to block of memory, NULL on error 204 */ 205extern void *cvmx_bootmem_alloc_named_range(uint64_t size, uint64_t min_addr, 206 uint64_t max_addr, uint64_t align, 207 char *name); 208 209/** 210 * Allocate if needed a block of memory from a specific range of the 211 * free list that was passed to the application by the bootloader, and 212 * assign it a name in the global named block table. (part of the 213 * cvmx_bootmem_descriptor_t structure) Named blocks can later be 214 * freed. If the requested name block is already allocated, return 215 * the pointer to block of memory. If request cannot be satisfied 216 * within the address range specified, NULL is returned 217 * 218 * @param size Size in bytes of block to allocate 219 * @param min_addr minimum address of range 220 * @param max_addr maximum address of range 221 * @param align Alignment of memory to be allocated. (must be a power of 2) 222 * @param name name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes 223 * @param init Initialization function 224 * 225 * The initialization function is optional, if omitted the named block 226 * is initialized to all zeros when it is created, i.e. once. 227 * 228 * @return pointer to block of memory, NULL on error 229 */ 230void *cvmx_bootmem_alloc_named_range_once(uint64_t size, 231 uint64_t min_addr, 232 uint64_t max_addr, 233 uint64_t align, 234 char *name, 235 void (*init) (void *)); 236 237extern int cvmx_bootmem_free_named(char *name); 238 239/** 240 * Finds a named bootmem block by name. 241 * 242 * @name: name of block to free 243 * 244 * Returns pointer to named block descriptor on success 245 * 0 on failure 246 */ 247struct cvmx_bootmem_named_block_desc *cvmx_bootmem_find_named_block(char *name); 248 249/** 250 * Allocates a block of physical memory from the free list, at 251 * (optional) requested address and alignment. 252 * 253 * @req_size: size of region to allocate. All requests are rounded up 254 * to be a multiple CVMX_BOOTMEM_ALIGNMENT_SIZE bytes size 255 * 256 * @address_min: Minimum address that block can occupy. 257 * 258 * @address_max: Specifies the maximum address_min (inclusive) that 259 * the allocation can use. 260 * 261 * @alignment: Requested alignment of the block. If this alignment 262 * cannot be met, the allocation fails. This must be a 263 * power of 2. (Note: Alignment of 264 * CVMX_BOOTMEM_ALIGNMENT_SIZE bytes is required, and 265 * internally enforced. Requested alignments of less than 266 * CVMX_BOOTMEM_ALIGNMENT_SIZE are set to 267 * CVMX_BOOTMEM_ALIGNMENT_SIZE.) 268 * 269 * @flags: Flags to control options for the allocation. 270 * 271 * Returns physical address of block allocated, or -1 on failure 272 */ 273int64_t cvmx_bootmem_phy_alloc(uint64_t req_size, uint64_t address_min, 274 uint64_t address_max, uint64_t alignment, 275 uint32_t flags); 276 277/** 278 * Allocates a named block of physical memory from the free list, at 279 * (optional) requested address and alignment. 280 * 281 * @param size size of region to allocate. All requests are rounded 282 * up to be a multiple CVMX_BOOTMEM_ALIGNMENT_SIZE 283 * bytes size 284 * @param min_addr Minimum address that block can occupy. 285 * @param max_addr Specifies the maximum address_min (inclusive) that 286 * the allocation can use. 287 * @param alignment Requested alignment of the block. If this 288 * alignment cannot be met, the allocation fails. 289 * This must be a power of 2. (Note: Alignment of 290 * CVMX_BOOTMEM_ALIGNMENT_SIZE bytes is required, and 291 * internally enforced. Requested alignments of less 292 * than CVMX_BOOTMEM_ALIGNMENT_SIZE are set to 293 * CVMX_BOOTMEM_ALIGNMENT_SIZE.) 294 * @param name name to assign to named block 295 * @param flags Flags to control options for the allocation. 296 * 297 * @return physical address of block allocated, or -1 on failure 298 */ 299int64_t cvmx_bootmem_phy_named_block_alloc(uint64_t size, uint64_t min_addr, 300 uint64_t max_addr, 301 uint64_t alignment, 302 char *name, uint32_t flags); 303 304/** 305 * Frees a block to the bootmem allocator list. This must 306 * be used with care, as the size provided must match the size 307 * of the block that was allocated, or the list will become 308 * corrupted. 309 * 310 * IMPORTANT: This is only intended to be used as part of named block 311 * frees and initial population of the free memory list. 312 * * 313 * 314 * @phy_addr: physical address of block 315 * @size: size of block in bytes. 316 * @flags: flags for passing options 317 * 318 * Returns 1 on success, 319 * 0 on failure 320 */ 321int __cvmx_bootmem_phy_free(uint64_t phy_addr, uint64_t size, uint32_t flags); 322 323/** 324 * Locks the bootmem allocator. This is useful in certain situations 325 * where multiple allocations must be made without being interrupted. 326 * This should be used with the CVMX_BOOTMEM_FLAG_NO_LOCKING flag. 327 * 328 */ 329void cvmx_bootmem_lock(void); 330 331/** 332 * Unlocks the bootmem allocator. This is useful in certain situations 333 * where multiple allocations must be made without being interrupted. 334 * This should be used with the CVMX_BOOTMEM_FLAG_NO_LOCKING flag. 335 * 336 */ 337void cvmx_bootmem_unlock(void); 338 339extern struct cvmx_bootmem_desc *cvmx_bootmem_get_desc(void); 340 341#endif /* __CVMX_BOOTMEM_H__ */ 342