1210284Sjmallett/***********************license start*************** 2232812Sjmallett * Copyright (c) 2003-2010 Cavium Inc. (support@cavium.com). All rights 3215990Sjmallett * reserved. 4210284Sjmallett * 5210284Sjmallett * 6215990Sjmallett * Redistribution and use in source and binary forms, with or without 7215990Sjmallett * modification, are permitted provided that the following conditions are 8215990Sjmallett * met: 9210284Sjmallett * 10215990Sjmallett * * Redistributions of source code must retain the above copyright 11215990Sjmallett * notice, this list of conditions and the following disclaimer. 12210284Sjmallett * 13215990Sjmallett * * Redistributions in binary form must reproduce the above 14215990Sjmallett * copyright notice, this list of conditions and the following 15215990Sjmallett * disclaimer in the documentation and/or other materials provided 16215990Sjmallett * with the distribution. 17215990Sjmallett 18232812Sjmallett * * Neither the name of Cavium Inc. nor the names of 19215990Sjmallett * its contributors may be used to endorse or promote products 20215990Sjmallett * derived from this software without specific prior written 21215990Sjmallett * permission. 22215990Sjmallett 23215990Sjmallett * This Software, including technical data, may be subject to U.S. export control 24215990Sjmallett * laws, including the U.S. Export Administration Act and its associated 25215990Sjmallett * regulations, and may be subject to export or import regulations in other 26215990Sjmallett * countries. 27215990Sjmallett 28215990Sjmallett * TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS" 29232812Sjmallett * AND WITH ALL FAULTS AND CAVIUM INC. MAKES NO PROMISES, REPRESENTATIONS OR 30215990Sjmallett * WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO 31215990Sjmallett * THE SOFTWARE, INCLUDING ITS CONDITION, ITS CONFORMITY TO ANY REPRESENTATION OR 32215990Sjmallett * DESCRIPTION, OR THE EXISTENCE OF ANY LATENT OR PATENT DEFECTS, AND CAVIUM 33215990Sjmallett * SPECIFICALLY DISCLAIMS ALL IMPLIED (IF ANY) WARRANTIES OF TITLE, 34215990Sjmallett * MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF 35215990Sjmallett * VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR 36215990Sjmallett * CORRESPONDENCE TO DESCRIPTION. THE ENTIRE RISK ARISING OUT OF USE OR 37215990Sjmallett * PERFORMANCE OF THE SOFTWARE LIES WITH YOU. 38210284Sjmallett ***********************license end**************************************/ 39210284Sjmallett 40210284Sjmallett 41210284Sjmallett 42210284Sjmallett 43210284Sjmallett 44215990Sjmallett 45210284Sjmallett/** 46210284Sjmallett * @file 47210284Sjmallett * Simple allocate only memory allocator. Used to allocate memory at application 48210284Sjmallett * start time. 49210284Sjmallett * 50232812Sjmallett * <hr>$Revision: 70030 $<hr> 51210284Sjmallett * 52210284Sjmallett */ 53215990Sjmallett#ifdef CVMX_BUILD_FOR_LINUX_KERNEL 54215990Sjmallett#include <linux/module.h> 55215990Sjmallett#include <asm/octeon/cvmx.h> 56215990Sjmallett#include <asm/octeon/cvmx-bootmem.h> 57215990Sjmallett#else 58215990Sjmallett#if !defined(__FreeBSD__) || !defined(_KERNEL) 59215990Sjmallett#include "executive-config.h" 60215990Sjmallett#endif 61210284Sjmallett#include "cvmx.h" 62210284Sjmallett#include "cvmx-bootmem.h" 63215990Sjmallett#endif 64215990Sjmalletttypedef uint32_t cvmx_spinlock_t; 65210284Sjmallett 66210284Sjmallett 67210284Sjmallett//#define DEBUG 68210284Sjmallett 69215990Sjmallett#define ULL unsigned long long 70210284Sjmallett#undef MAX 71210284Sjmallett#define MAX(a, b) (((a) > (b)) ? (a) : (b)) 72210284Sjmallett 73210284Sjmallett#undef MIN 74210284Sjmallett#define MIN(a, b) (((a) < (b)) ? (a) : (b)) 75210284Sjmallett 76210284Sjmallett#define ALIGN_ADDR_UP(addr, align) (((addr) + (~(align))) & (align)) 77210284Sjmallett 78215990Sjmallett/** 79215990Sjmallett * This is the physical location of a cvmx_bootmem_desc_t 80215990Sjmallett * structure in Octeon's memory. Note that dues to addressing 81215990Sjmallett * limits or runtime environment it might not be possible to 82215990Sjmallett * create a C pointer to this structure. 83215990Sjmallett */ 84215990Sjmallettstatic CVMX_SHARED uint64_t cvmx_bootmem_desc_addr = 0; 85210284Sjmallett 86215990Sjmallett/** 87215990Sjmallett * This macro returns the size of a member of a structure. 88215990Sjmallett * Logically it is the same as "sizeof(s::field)" in C++, but 89215990Sjmallett * C lacks the "::" operator. 90215990Sjmallett */ 91215990Sjmallett#define SIZEOF_FIELD(s, field) sizeof(((s*)NULL)->field) 92215990Sjmallett 93215990Sjmallett/** 94215990Sjmallett * This macro returns a member of the cvmx_bootmem_desc_t 95215990Sjmallett * structure. These members can't be directly addressed as 96215990Sjmallett * they might be in memory not directly reachable. In the case 97215990Sjmallett * where bootmem is compiled with LINUX_HOST, the structure 98215990Sjmallett * itself might be located on a remote Octeon. The argument 99215990Sjmallett * "field" is the member name of the cvmx_bootmem_desc_t to read. 100215990Sjmallett * Regardless of the type of the field, the return type is always 101215990Sjmallett * a uint64_t. 102215990Sjmallett */ 103215990Sjmallett#define CVMX_BOOTMEM_DESC_GET_FIELD(field) \ 104215990Sjmallett __cvmx_bootmem_desc_get(cvmx_bootmem_desc_addr, \ 105215990Sjmallett offsetof(cvmx_bootmem_desc_t, field), \ 106215990Sjmallett SIZEOF_FIELD(cvmx_bootmem_desc_t, field)) 107215990Sjmallett 108215990Sjmallett/** 109215990Sjmallett * This macro writes a member of the cvmx_bootmem_desc_t 110215990Sjmallett * structure. These members can't be directly addressed as 111215990Sjmallett * they might be in memory not directly reachable. In the case 112215990Sjmallett * where bootmem is compiled with LINUX_HOST, the structure 113215990Sjmallett * itself might be located on a remote Octeon. The argument 114215990Sjmallett * "field" is the member name of the cvmx_bootmem_desc_t to write. 115215990Sjmallett */ 116215990Sjmallett#define CVMX_BOOTMEM_DESC_SET_FIELD(field, value) \ 117215990Sjmallett __cvmx_bootmem_desc_set(cvmx_bootmem_desc_addr, \ 118215990Sjmallett offsetof(cvmx_bootmem_desc_t, field), \ 119215990Sjmallett SIZEOF_FIELD(cvmx_bootmem_desc_t, field), value) 120215990Sjmallett 121215990Sjmallett/** 122215990Sjmallett * This macro returns a member of the 123215990Sjmallett * cvmx_bootmem_named_block_desc_t structure. These members can't 124215990Sjmallett * be directly addressed as they might be in memory not directly 125215990Sjmallett * reachable. In the case where bootmem is compiled with 126215990Sjmallett * LINUX_HOST, the structure itself might be located on a remote 127215990Sjmallett * Octeon. The argument "field" is the member name of the 128215990Sjmallett * cvmx_bootmem_named_block_desc_t to read. Regardless of the type 129215990Sjmallett * of the field, the return type is always a uint64_t. The "addr" 130215990Sjmallett * parameter is the physical address of the structure. 131215990Sjmallett */ 132215990Sjmallett#define CVMX_BOOTMEM_NAMED_GET_FIELD(addr, field) \ 133215990Sjmallett __cvmx_bootmem_desc_get(addr, \ 134215990Sjmallett offsetof(cvmx_bootmem_named_block_desc_t, field), \ 135215990Sjmallett SIZEOF_FIELD(cvmx_bootmem_named_block_desc_t, field)) 136215990Sjmallett 137215990Sjmallett/** 138215990Sjmallett * This macro writes a member of the cvmx_bootmem_named_block_desc_t 139215990Sjmallett * structure. These members can't be directly addressed as 140215990Sjmallett * they might be in memory not directly reachable. In the case 141215990Sjmallett * where bootmem is compiled with LINUX_HOST, the structure 142215990Sjmallett * itself might be located on a remote Octeon. The argument 143215990Sjmallett * "field" is the member name of the 144215990Sjmallett * cvmx_bootmem_named_block_desc_t to write. The "addr" parameter 145215990Sjmallett * is the physical address of the structure. 146215990Sjmallett */ 147215990Sjmallett#define CVMX_BOOTMEM_NAMED_SET_FIELD(addr, field, value) \ 148215990Sjmallett __cvmx_bootmem_desc_set(addr, \ 149215990Sjmallett offsetof(cvmx_bootmem_named_block_desc_t, field), \ 150215990Sjmallett SIZEOF_FIELD(cvmx_bootmem_named_block_desc_t, field), value) 151215990Sjmallett 152215990Sjmallett/** 153215990Sjmallett * This function is the implementation of the get macros defined 154215990Sjmallett * for individual structure members. The argument are generated 155215990Sjmallett * by the macros inorder to read only the needed memory. 156215990Sjmallett * 157215990Sjmallett * @param base 64bit physical address of the complete structure 158215990Sjmallett * @param offset Offset from the beginning of the structure to the member being 159215990Sjmallett * accessed. 160215990Sjmallett * @param size Size of the structure member. 161215990Sjmallett * 162215990Sjmallett * @return Value of the structure member promoted into a uint64_t. 163215990Sjmallett */ 164215990Sjmallettstatic inline uint64_t __cvmx_bootmem_desc_get(uint64_t base, int offset, int size) 165215990Sjmallett{ 166215990Sjmallett base = (1ull << 63) | (base + offset); 167215990Sjmallett switch (size) 168215990Sjmallett { 169215990Sjmallett case 4: 170215990Sjmallett return cvmx_read64_uint32(base); 171215990Sjmallett case 8: 172215990Sjmallett return cvmx_read64_uint64(base); 173215990Sjmallett default: 174215990Sjmallett return 0; 175215990Sjmallett } 176215990Sjmallett} 177215990Sjmallett 178215990Sjmallett/** 179215990Sjmallett * This function is the implementation of the set macros defined 180215990Sjmallett * for individual structure members. The argument are generated 181215990Sjmallett * by the macros in order to write only the needed memory. 182215990Sjmallett * 183215990Sjmallett * @param base 64bit physical address of the complete structure 184215990Sjmallett * @param offset Offset from the beginning of the structure to the member being 185215990Sjmallett * accessed. 186215990Sjmallett * @param size Size of the structure member. 187215990Sjmallett * @param value Value to write into the structure 188215990Sjmallett */ 189215990Sjmallettstatic inline void __cvmx_bootmem_desc_set(uint64_t base, int offset, int size, uint64_t value) 190215990Sjmallett{ 191215990Sjmallett base = (1ull << 63) | (base + offset); 192215990Sjmallett switch (size) 193215990Sjmallett { 194215990Sjmallett case 4: 195215990Sjmallett cvmx_write64_uint32(base, value); 196215990Sjmallett break; 197215990Sjmallett case 8: 198215990Sjmallett cvmx_write64_uint64(base, value); 199215990Sjmallett break; 200215990Sjmallett default: 201215990Sjmallett break; 202215990Sjmallett } 203215990Sjmallett} 204215990Sjmallett 205215990Sjmallett/** 206215990Sjmallett * This function retrieves the string name of a named block. It is 207215990Sjmallett * more complicated than a simple memcpy() since the named block 208215990Sjmallett * descriptor may not be directly accessable. 209215990Sjmallett * 210215990Sjmallett * @param addr Physical address of the named block descriptor 211215990Sjmallett * @param str String to receive the named block string name 212215990Sjmallett * @param len Length of the string buffer, which must match the length 213215990Sjmallett * stored in the bootmem descriptor. 214215990Sjmallett */ 215215990Sjmallettstatic void CVMX_BOOTMEM_NAMED_GET_NAME(uint64_t addr, char *str, int len) 216215990Sjmallett{ 217215990Sjmallett#ifndef CVMX_BUILD_FOR_LINUX_HOST 218215990Sjmallett int l = len; 219215990Sjmallett char *ptr = str; 220215990Sjmallett addr |= (1ull << 63); 221215990Sjmallett addr += offsetof(cvmx_bootmem_named_block_desc_t, name); 222215990Sjmallett while (l--) 223215990Sjmallett *ptr++ = cvmx_read64_uint8(addr++); 224215990Sjmallett str[len] = 0; 225215990Sjmallett#else 226215990Sjmallett extern void octeon_remote_read_mem(void *buffer, uint64_t physical_address, int length); 227215990Sjmallett addr += offsetof(cvmx_bootmem_named_block_desc_t, name); 228215990Sjmallett octeon_remote_read_mem(str, addr, len); 229215990Sjmallett str[len] = 0; 230215990Sjmallett#endif 231215990Sjmallett} 232215990Sjmallett 233215990Sjmallett/** 234215990Sjmallett * This function stores the string name of a named block. It is 235215990Sjmallett * more complicated than a simple memcpy() since the named block 236215990Sjmallett * descriptor may not be directly accessable. 237215990Sjmallett * 238215990Sjmallett * @param addr Physical address of the named block descriptor 239215990Sjmallett * @param str String to store into the named block string name 240215990Sjmallett * @param len Length of the string buffer, which must match the length 241215990Sjmallett * stored in the bootmem descriptor. 242215990Sjmallett */ 243215990Sjmallettstatic void CVMX_BOOTMEM_NAMED_SET_NAME(uint64_t addr, const char *str, int len) 244215990Sjmallett{ 245215990Sjmallett#ifndef CVMX_BUILD_FOR_LINUX_HOST 246215990Sjmallett int l = len; 247215990Sjmallett addr |= (1ull << 63); 248215990Sjmallett addr += offsetof(cvmx_bootmem_named_block_desc_t, name); 249215990Sjmallett while (l--) 250215990Sjmallett { 251215990Sjmallett if (l) 252215990Sjmallett cvmx_write64_uint8(addr++, *str++); 253215990Sjmallett else 254215990Sjmallett cvmx_write64_uint8(addr++, 0); 255215990Sjmallett } 256215990Sjmallett#else 257215990Sjmallett extern void octeon_remote_write_mem(uint64_t physical_address, const void *buffer, int length); 258215990Sjmallett char zero = 0; 259215990Sjmallett addr += offsetof(cvmx_bootmem_named_block_desc_t, name); 260215990Sjmallett octeon_remote_write_mem(addr, str, len-1); 261215990Sjmallett octeon_remote_write_mem(addr+len-1, &zero, 1); 262215990Sjmallett#endif 263215990Sjmallett} 264215990Sjmallett 265210284Sjmallett/* See header file for descriptions of functions */ 266210284Sjmallett 267210284Sjmallett/* Wrapper functions are provided for reading/writing the size and next block 268210284Sjmallett** values as these may not be directly addressible (in 32 bit applications, for instance.) 269210284Sjmallett*/ 270210284Sjmallett/* Offsets of data elements in bootmem list, must match cvmx_bootmem_block_header_t */ 271210284Sjmallett#define NEXT_OFFSET 0 272210284Sjmallett#define SIZE_OFFSET 8 273210284Sjmallettstatic void cvmx_bootmem_phy_set_size(uint64_t addr, uint64_t size) 274210284Sjmallett{ 275210284Sjmallett cvmx_write64_uint64((addr + SIZE_OFFSET) | (1ull << 63), size); 276210284Sjmallett} 277210284Sjmallettstatic void cvmx_bootmem_phy_set_next(uint64_t addr, uint64_t next) 278210284Sjmallett{ 279210284Sjmallett cvmx_write64_uint64((addr + NEXT_OFFSET) | (1ull << 63), next); 280210284Sjmallett} 281210284Sjmallettstatic uint64_t cvmx_bootmem_phy_get_size(uint64_t addr) 282210284Sjmallett{ 283210284Sjmallett return(cvmx_read64_uint64((addr + SIZE_OFFSET) | (1ull << 63))); 284210284Sjmallett} 285210284Sjmallettstatic uint64_t cvmx_bootmem_phy_get_next(uint64_t addr) 286210284Sjmallett{ 287210284Sjmallett return(cvmx_read64_uint64((addr + NEXT_OFFSET) | (1ull << 63))); 288210284Sjmallett} 289210284Sjmallett 290215990Sjmallett/** 291215990Sjmallett * Check the version information on the bootmem descriptor 292215990Sjmallett * 293215990Sjmallett * @param exact_match 294215990Sjmallett * Exact major version to check against. A zero means 295215990Sjmallett * check that the version supports named blocks. 296215990Sjmallett * 297215990Sjmallett * @return Zero if the version is correct. Negative if the version is 298215990Sjmallett * incorrect. Failures also cause a message to be displayed. 299215990Sjmallett */ 300215990Sjmallettstatic int __cvmx_bootmem_check_version(int exact_match) 301215990Sjmallett{ 302215990Sjmallett int major_version; 303215990Sjmallett#ifdef CVMX_BUILD_FOR_LINUX_HOST 304215990Sjmallett if (!cvmx_bootmem_desc_addr) 305232812Sjmallett cvmx_bootmem_desc_addr = cvmx_read64_uint64(0x48100); 306215990Sjmallett#endif 307215990Sjmallett major_version = CVMX_BOOTMEM_DESC_GET_FIELD(major_version); 308215990Sjmallett if ((major_version > 3) || (exact_match && major_version != exact_match)) 309215990Sjmallett { 310215990Sjmallett cvmx_dprintf("ERROR: Incompatible bootmem descriptor version: %d.%d at addr: 0x%llx\n", 311215990Sjmallett major_version, (int)CVMX_BOOTMEM_DESC_GET_FIELD(minor_version), 312215990Sjmallett (ULL)cvmx_bootmem_desc_addr); 313215990Sjmallett return -1; 314215990Sjmallett } 315215990Sjmallett else 316215990Sjmallett return 0; 317215990Sjmallett} 318210284Sjmallett 319215990Sjmallett/** 320215990Sjmallett * Get the low level bootmem descriptor lock. If no locking 321215990Sjmallett * is specified in the flags, then nothing is done. 322215990Sjmallett * 323215990Sjmallett * @param flags CVMX_BOOTMEM_FLAG_NO_LOCKING means this functions should do 324215990Sjmallett * nothing. This is used to support nested bootmem calls. 325215990Sjmallett */ 326215990Sjmallettstatic inline void __cvmx_bootmem_lock(uint32_t flags) 327215990Sjmallett{ 328215990Sjmallett if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING)) 329215990Sjmallett { 330215990Sjmallett#ifndef CVMX_BUILD_FOR_LINUX_HOST 331215990Sjmallett /* Unfortunately we can't use the normal cvmx-spinlock code as the 332215990Sjmallett memory for the bootmem descriptor may be not accessable by a C 333215990Sjmallett pointer. We use a 64bit XKPHYS address to access the memory 334215990Sjmallett directly */ 335215990Sjmallett uint64_t lock_addr = (1ull << 63) | (cvmx_bootmem_desc_addr + offsetof(cvmx_bootmem_desc_t, lock)); 336215990Sjmallett unsigned int tmp; 337215990Sjmallett 338215990Sjmallett __asm__ __volatile__( 339215990Sjmallett ".set noreorder \n" 340215990Sjmallett "1: ll %[tmp], 0(%[addr])\n" 341215990Sjmallett " bnez %[tmp], 1b \n" 342215990Sjmallett " li %[tmp], 1 \n" 343215990Sjmallett " sc %[tmp], 0(%[addr])\n" 344215990Sjmallett " beqz %[tmp], 1b \n" 345215990Sjmallett " nop \n" 346215990Sjmallett ".set reorder \n" 347215990Sjmallett : [tmp] "=&r" (tmp) 348215990Sjmallett : [addr] "r" (lock_addr) 349215990Sjmallett : "memory"); 350215990Sjmallett#endif 351215990Sjmallett } 352215990Sjmallett} 353215990Sjmallett 354215990Sjmallett/** 355215990Sjmallett * Release the low level bootmem descriptor lock. If no locking 356215990Sjmallett * is specified in the flags, then nothing is done. 357215990Sjmallett * 358215990Sjmallett * @param flags CVMX_BOOTMEM_FLAG_NO_LOCKING means this functions should do 359215990Sjmallett * nothing. This is used to support nested bootmem calls. 360215990Sjmallett */ 361215990Sjmallettstatic inline void __cvmx_bootmem_unlock(uint32_t flags) 362215990Sjmallett{ 363215990Sjmallett if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING)) 364215990Sjmallett { 365215990Sjmallett#ifndef CVMX_BUILD_FOR_LINUX_HOST 366215990Sjmallett /* Unfortunately we can't use the normal cvmx-spinlock code as the 367215990Sjmallett memory for the bootmem descriptor may be not accessable by a C 368215990Sjmallett pointer. We use a 64bit XKPHYS address to access the memory 369215990Sjmallett directly */ 370215990Sjmallett uint64_t lock_addr = (1ull << 63) | (cvmx_bootmem_desc_addr + offsetof(cvmx_bootmem_desc_t, lock)); 371215990Sjmallett 372215990Sjmallett CVMX_SYNCW; 373215990Sjmallett __asm__ __volatile__("sw $0, 0(%[addr])\n" 374215990Sjmallett :: [addr] "r" (lock_addr) 375215990Sjmallett : "memory"); 376215990Sjmallett CVMX_SYNCW; 377215990Sjmallett#endif 378215990Sjmallett } 379215990Sjmallett} 380215990Sjmallett 381215990Sjmallett/* Some of the cvmx-bootmem functions dealing with C pointers are not supported 382215990Sjmallett when we are compiling for CVMX_BUILD_FOR_LINUX_HOST. This ifndef removes 383215990Sjmallett these functions when they aren't needed */ 384215990Sjmallett#ifndef CVMX_BUILD_FOR_LINUX_HOST 385210284Sjmallett/* This functions takes an address range and adjusts it as necessary to 386210284Sjmallett** match the ABI that is currently being used. This is required to ensure 387210284Sjmallett** that bootmem_alloc* functions only return valid pointers for 32 bit ABIs */ 388210284Sjmallettstatic int __cvmx_validate_mem_range(uint64_t *min_addr_ptr, uint64_t *max_addr_ptr) 389210284Sjmallett{ 390210284Sjmallett 391210284Sjmallett#if defined(__linux__) && defined(CVMX_ABI_N32) 392210284Sjmallett { 393210284Sjmallett extern uint64_t linux_mem32_min; 394210284Sjmallett extern uint64_t linux_mem32_max; 395210284Sjmallett /* For 32 bit Linux apps, we need to restrict the allocations to the range 396210284Sjmallett ** of memory configured for access from userspace. Also, we need to add mappings 397210284Sjmallett ** for the data structures that we access.*/ 398210284Sjmallett 399210284Sjmallett /* Narrow range requests to be bounded by the 32 bit limits. octeon_phy_mem_block_alloc() 400210284Sjmallett ** will reject inconsistent req_size/range requests, so we don't repeat those checks here. 401210284Sjmallett ** If max unspecified, set to 32 bit maximum. */ 402210284Sjmallett *min_addr_ptr = MIN(MAX(*min_addr_ptr, linux_mem32_min), linux_mem32_max); 403210284Sjmallett if (!*max_addr_ptr) 404210284Sjmallett *max_addr_ptr = linux_mem32_max; 405210284Sjmallett else 406210284Sjmallett *max_addr_ptr = MAX(MIN(*max_addr_ptr, linux_mem32_max), linux_mem32_min); 407210284Sjmallett } 408210284Sjmallett#elif defined(CVMX_ABI_N32) 409210284Sjmallett { 410210284Sjmallett uint32_t max_phys = 0x0FFFFFFF; /* Max physical address when 1-1 mappings not used */ 411210284Sjmallett#if CVMX_USE_1_TO_1_TLB_MAPPINGS 412210284Sjmallett max_phys = 0x7FFFFFFF; 413210284Sjmallett#endif 414210284Sjmallett /* We are are running standalone simple executive, so we need to limit the range 415210284Sjmallett ** that we allocate from */ 416210284Sjmallett 417210284Sjmallett /* Narrow range requests to be bounded by the 32 bit limits. octeon_phy_mem_block_alloc() 418210284Sjmallett ** will reject inconsistent req_size/range requests, so we don't repeat those checks here. 419210284Sjmallett ** If max unspecified, set to 32 bit maximum. */ 420210284Sjmallett *min_addr_ptr = MIN(MAX(*min_addr_ptr, 0x0), max_phys); 421210284Sjmallett if (!*max_addr_ptr) 422210284Sjmallett *max_addr_ptr = max_phys; 423210284Sjmallett else 424210284Sjmallett *max_addr_ptr = MAX(MIN(*max_addr_ptr, max_phys), 0x0); 425210284Sjmallett } 426210284Sjmallett#endif 427210284Sjmallett 428210284Sjmallett return 0; 429210284Sjmallett} 430210284Sjmallett 431210284Sjmallett 432210284Sjmallettvoid *cvmx_bootmem_alloc_range(uint64_t size, uint64_t alignment, uint64_t min_addr, uint64_t max_addr) 433210284Sjmallett{ 434210284Sjmallett int64_t address; 435210284Sjmallett 436210284Sjmallett __cvmx_validate_mem_range(&min_addr, &max_addr); 437210284Sjmallett address = cvmx_bootmem_phy_alloc(size, min_addr, max_addr, alignment, 0); 438210284Sjmallett 439210284Sjmallett if (address > 0) 440210284Sjmallett return cvmx_phys_to_ptr(address); 441210284Sjmallett else 442210284Sjmallett return NULL; 443210284Sjmallett} 444215990Sjmallett#ifdef CVMX_BUILD_FOR_LINUX_KERNEL 445215990SjmallettEXPORT_SYMBOL(cvmx_bootmem_alloc_range); 446215990Sjmallett#endif 447210284Sjmallett 448210284Sjmallettvoid *cvmx_bootmem_alloc_address(uint64_t size, uint64_t address, uint64_t alignment) 449210284Sjmallett{ 450210284Sjmallett return cvmx_bootmem_alloc_range(size, alignment, address, address + size); 451210284Sjmallett} 452210284Sjmallett 453210284Sjmallett 454210284Sjmallettvoid *cvmx_bootmem_alloc(uint64_t size, uint64_t alignment) 455210284Sjmallett{ 456210284Sjmallett return cvmx_bootmem_alloc_range(size, alignment, 0, 0); 457210284Sjmallett} 458215990Sjmallett#ifdef CVMX_BUILD_FOR_LINUX_KERNEL 459215990SjmallettEXPORT_SYMBOL(cvmx_bootmem_alloc); 460215990Sjmallett#endif 461210284Sjmallett 462232812Sjmallettvoid *cvmx_bootmem_alloc_named_range_once(uint64_t size, uint64_t min_addr, uint64_t max_addr, uint64_t align, const char *name, void (*init)(void*)) 463210284Sjmallett{ 464210284Sjmallett int64_t addr; 465232812Sjmallett void *ptr; 466232812Sjmallett uint64_t named_block_desc_addr; 467210284Sjmallett 468232812Sjmallett __cvmx_bootmem_lock(0); 469232812Sjmallett 470210284Sjmallett __cvmx_validate_mem_range(&min_addr, &max_addr); 471232812Sjmallett named_block_desc_addr = cvmx_bootmem_phy_named_block_find(name, CVMX_BOOTMEM_FLAG_NO_LOCKING); 472232812Sjmallett 473232812Sjmallett if (named_block_desc_addr) 474232812Sjmallett { 475232812Sjmallett addr = CVMX_BOOTMEM_NAMED_GET_FIELD(named_block_desc_addr, base_addr); 476232812Sjmallett __cvmx_bootmem_unlock(0); 477210284Sjmallett return cvmx_phys_to_ptr(addr); 478232812Sjmallett } 479232812Sjmallett 480232812Sjmallett addr = cvmx_bootmem_phy_named_block_alloc(size, min_addr, max_addr, align, name, CVMX_BOOTMEM_FLAG_NO_LOCKING); 481232812Sjmallett 482232812Sjmallett if (addr < 0) 483232812Sjmallett { 484232812Sjmallett __cvmx_bootmem_unlock(0); 485210284Sjmallett return NULL; 486232812Sjmallett } 487232812Sjmallett ptr = cvmx_phys_to_ptr(addr); 488232812Sjmallett init(ptr); 489232812Sjmallett __cvmx_bootmem_unlock(0); 490232812Sjmallett return ptr; 491232812Sjmallett} 492210284Sjmallett 493232812Sjmallettstatic void *cvmx_bootmem_alloc_named_range_flags(uint64_t size, uint64_t min_addr, uint64_t max_addr, uint64_t align, const char *name, uint32_t flags) 494232812Sjmallett{ 495232812Sjmallett int64_t addr; 496232812Sjmallett 497232812Sjmallett __cvmx_validate_mem_range(&min_addr, &max_addr); 498232812Sjmallett addr = cvmx_bootmem_phy_named_block_alloc(size, min_addr, max_addr, align, name, flags); 499232812Sjmallett if (addr >= 0) 500232812Sjmallett return cvmx_phys_to_ptr(addr); 501232812Sjmallett else 502232812Sjmallett return NULL; 503232812Sjmallett 504210284Sjmallett} 505232812Sjmallett 506232812Sjmallettvoid *cvmx_bootmem_alloc_named_range(uint64_t size, uint64_t min_addr, uint64_t max_addr, uint64_t align, const char *name) 507232812Sjmallett{ 508232812Sjmallett return cvmx_bootmem_alloc_named_range_flags(size, min_addr, max_addr, align, name, 0); 509232812Sjmallett} 510232812Sjmallett 511215990Sjmallettvoid *cvmx_bootmem_alloc_named_address(uint64_t size, uint64_t address, const char *name) 512210284Sjmallett{ 513210284Sjmallett return(cvmx_bootmem_alloc_named_range(size, address, address + size, 0, name)); 514210284Sjmallett} 515232812Sjmallett 516215990Sjmallettvoid *cvmx_bootmem_alloc_named(uint64_t size, uint64_t alignment, const char *name) 517210284Sjmallett{ 518210284Sjmallett return(cvmx_bootmem_alloc_named_range(size, 0, 0, alignment, name)); 519210284Sjmallett} 520210284Sjmallett 521232812Sjmallettvoid *cvmx_bootmem_alloc_named_flags(uint64_t size, uint64_t alignment, const char *name, uint32_t flags) 522232812Sjmallett{ 523232812Sjmallett return cvmx_bootmem_alloc_named_range_flags(size, 0, 0, alignment, name, flags); 524232812Sjmallett} 525232812Sjmallett 526215990Sjmallettint cvmx_bootmem_free_named(const char *name) 527210284Sjmallett{ 528210284Sjmallett return(cvmx_bootmem_phy_named_block_free(name, 0)); 529210284Sjmallett} 530215990Sjmallett#endif 531210284Sjmallett 532215990Sjmallettconst cvmx_bootmem_named_block_desc_t *cvmx_bootmem_find_named_block(const char *name) 533210284Sjmallett{ 534215990Sjmallett /* FIXME: Returning a single static object is probably a bad thing */ 535215990Sjmallett static cvmx_bootmem_named_block_desc_t desc; 536215990Sjmallett uint64_t named_addr = cvmx_bootmem_phy_named_block_find(name, 0); 537215990Sjmallett if (named_addr) 538215990Sjmallett { 539215990Sjmallett desc.base_addr = CVMX_BOOTMEM_NAMED_GET_FIELD(named_addr, base_addr); 540215990Sjmallett desc.size = CVMX_BOOTMEM_NAMED_GET_FIELD(named_addr, size); 541215990Sjmallett strncpy(desc.name, name, sizeof(desc.name)); 542215990Sjmallett desc.name[sizeof(desc.name)-1] = 0; 543215990Sjmallett return &desc; 544215990Sjmallett } 545215990Sjmallett else 546215990Sjmallett return NULL; 547210284Sjmallett} 548210284Sjmallett 549210284Sjmallettvoid cvmx_bootmem_print_named(void) 550210284Sjmallett{ 551210284Sjmallett cvmx_bootmem_phy_named_block_print(); 552210284Sjmallett} 553210284Sjmallett 554215990Sjmallettint cvmx_bootmem_init(uint64_t mem_desc_addr) 555210284Sjmallett{ 556210284Sjmallett /* Verify that the size of cvmx_spinlock_t meets our assumptions */ 557210284Sjmallett if (sizeof(cvmx_spinlock_t) != 4) 558210284Sjmallett { 559210284Sjmallett cvmx_dprintf("ERROR: Unexpected size of cvmx_spinlock_t\n"); 560210284Sjmallett return(-1); 561210284Sjmallett } 562215990Sjmallett if (!cvmx_bootmem_desc_addr) 563215990Sjmallett cvmx_bootmem_desc_addr = mem_desc_addr; 564210284Sjmallett return(0); 565210284Sjmallett} 566210284Sjmallett 567210284Sjmallett 568210284Sjmallettuint64_t cvmx_bootmem_available_mem(uint64_t min_block_size) 569210284Sjmallett{ 570210284Sjmallett return(cvmx_bootmem_phy_available_mem(min_block_size)); 571210284Sjmallett} 572210284Sjmallett 573210284Sjmallett 574210284Sjmallett 575210284Sjmallett 576210284Sjmallett 577210284Sjmallett/********************************************************************* 578210284Sjmallett** The cvmx_bootmem_phy* functions below return 64 bit physical addresses, 579210284Sjmallett** and expose more features that the cvmx_bootmem_functions above. These are 580210284Sjmallett** required for full memory space access in 32 bit applications, as well as for 581210284Sjmallett** using some advance features. 582210284Sjmallett** Most applications should not need to use these. 583210284Sjmallett** 584210284Sjmallett**/ 585210284Sjmallett 586210284Sjmallett 587210284Sjmallettint64_t cvmx_bootmem_phy_alloc(uint64_t req_size, uint64_t address_min, uint64_t address_max, uint64_t alignment, uint32_t flags) 588210284Sjmallett{ 589210284Sjmallett 590210284Sjmallett uint64_t head_addr; 591210284Sjmallett uint64_t ent_addr; 592210284Sjmallett uint64_t prev_addr = 0; /* points to previous list entry, NULL current entry is head of list */ 593210284Sjmallett uint64_t new_ent_addr = 0; 594210284Sjmallett uint64_t desired_min_addr; 595210284Sjmallett uint64_t alignment_mask = ~(alignment - 1); 596210284Sjmallett 597210284Sjmallett#ifdef DEBUG 598210284Sjmallett cvmx_dprintf("cvmx_bootmem_phy_alloc: req_size: 0x%llx, min_addr: 0x%llx, max_addr: 0x%llx, align: 0x%llx\n", 599215990Sjmallett (ULL)req_size, (ULL)address_min, (ULL)address_max, (ULL)alignment); 600210284Sjmallett#endif 601210284Sjmallett 602215990Sjmallett if (__cvmx_bootmem_check_version(0)) 603210284Sjmallett goto error_out; 604210284Sjmallett 605210284Sjmallett /* Do a variety of checks to validate the arguments. The allocator code will later assume 606210284Sjmallett ** that these checks have been made. We validate that the requested constraints are not 607210284Sjmallett ** self-contradictory before we look through the list of available memory 608210284Sjmallett */ 609210284Sjmallett 610210284Sjmallett /* 0 is not a valid req_size for this allocator */ 611210284Sjmallett if (!req_size) 612210284Sjmallett goto error_out; 613210284Sjmallett 614210284Sjmallett /* Round req_size up to mult of minimum alignment bytes */ 615210284Sjmallett req_size = (req_size + (CVMX_BOOTMEM_ALIGNMENT_SIZE - 1)) & ~(CVMX_BOOTMEM_ALIGNMENT_SIZE - 1); 616210284Sjmallett 617232812Sjmallett 618210284Sjmallett /* Enforce minimum alignment (this also keeps the minimum free block 619210284Sjmallett ** req_size the same as the alignment req_size */ 620210284Sjmallett if (alignment < CVMX_BOOTMEM_ALIGNMENT_SIZE) 621210284Sjmallett { 622210284Sjmallett alignment = CVMX_BOOTMEM_ALIGNMENT_SIZE; 623210284Sjmallett } 624210284Sjmallett alignment_mask = ~(alignment - 1); 625210284Sjmallett 626210284Sjmallett /* Adjust address minimum based on requested alignment (round up to meet alignment). Do this here so we can 627210284Sjmallett ** reject impossible requests up front. (NOP for address_min == 0) */ 628210284Sjmallett if (alignment) 629210284Sjmallett address_min = (address_min + (alignment - 1)) & ~(alignment - 1); 630210284Sjmallett 631232812Sjmallett /* Convert !0 address_min and 0 address_max to special case of range that specifies an exact 632232812Sjmallett ** memory block to allocate. Do this before other checks and adjustments so that this tranformation will be validated */ 633232812Sjmallett if (address_min && !address_max) 634232812Sjmallett address_max = address_min + req_size; 635232812Sjmallett else if (!address_min && !address_max) 636232812Sjmallett address_max = ~0ull; /* If no limits given, use max limits */ 637210284Sjmallett 638210284Sjmallett /* Reject inconsistent args. We have adjusted these, so this may fail due to our internal changes 639210284Sjmallett ** even if this check would pass for the values the user supplied. */ 640210284Sjmallett if (req_size > address_max - address_min) 641210284Sjmallett goto error_out; 642210284Sjmallett 643210284Sjmallett /* Walk through the list entries - first fit found is returned */ 644210284Sjmallett 645215990Sjmallett __cvmx_bootmem_lock(flags); 646215990Sjmallett head_addr = CVMX_BOOTMEM_DESC_GET_FIELD(head_addr); 647210284Sjmallett ent_addr = head_addr; 648210284Sjmallett while (ent_addr) 649210284Sjmallett { 650210284Sjmallett uint64_t usable_base, usable_max; 651210284Sjmallett uint64_t ent_size = cvmx_bootmem_phy_get_size(ent_addr); 652210284Sjmallett 653210284Sjmallett if (cvmx_bootmem_phy_get_next(ent_addr) && ent_addr > cvmx_bootmem_phy_get_next(ent_addr)) 654210284Sjmallett { 655210284Sjmallett cvmx_dprintf("Internal bootmem_alloc() error: ent: 0x%llx, next: 0x%llx\n", 656215990Sjmallett (ULL)ent_addr, (ULL)cvmx_bootmem_phy_get_next(ent_addr)); 657210284Sjmallett goto error_out; 658210284Sjmallett } 659210284Sjmallett 660210284Sjmallett /* Determine if this is an entry that can satisify the request */ 661210284Sjmallett /* Check to make sure entry is large enough to satisfy request */ 662210284Sjmallett usable_base = ALIGN_ADDR_UP(MAX(address_min, ent_addr), alignment_mask); 663210284Sjmallett usable_max = MIN(address_max, ent_addr + ent_size); 664210284Sjmallett /* We should be able to allocate block at address usable_base */ 665210284Sjmallett 666210284Sjmallett desired_min_addr = usable_base; 667210284Sjmallett 668210284Sjmallett /* Determine if request can be satisfied from the current entry */ 669210284Sjmallett if ((((ent_addr + ent_size) > usable_base && ent_addr < address_max)) 670210284Sjmallett && req_size <= usable_max - usable_base) 671210284Sjmallett { 672210284Sjmallett /* We have found an entry that has room to satisfy the request, so allocate it from this entry */ 673210284Sjmallett 674210284Sjmallett /* If end CVMX_BOOTMEM_FLAG_END_ALLOC set, then allocate from the end of this block 675210284Sjmallett ** rather than the beginning */ 676210284Sjmallett if (flags & CVMX_BOOTMEM_FLAG_END_ALLOC) 677210284Sjmallett { 678210284Sjmallett desired_min_addr = usable_max - req_size; 679210284Sjmallett /* Align desired address down to required alignment */ 680210284Sjmallett desired_min_addr &= alignment_mask; 681210284Sjmallett } 682210284Sjmallett 683210284Sjmallett /* Match at start of entry */ 684210284Sjmallett if (desired_min_addr == ent_addr) 685210284Sjmallett { 686210284Sjmallett if (req_size < ent_size) 687210284Sjmallett { 688210284Sjmallett /* big enough to create a new block from top portion of block */ 689210284Sjmallett new_ent_addr = ent_addr + req_size; 690210284Sjmallett cvmx_bootmem_phy_set_next(new_ent_addr, cvmx_bootmem_phy_get_next(ent_addr)); 691210284Sjmallett cvmx_bootmem_phy_set_size(new_ent_addr, ent_size - req_size); 692210284Sjmallett 693210284Sjmallett /* Adjust next pointer as following code uses this */ 694210284Sjmallett cvmx_bootmem_phy_set_next(ent_addr, new_ent_addr); 695210284Sjmallett } 696210284Sjmallett 697210284Sjmallett /* adjust prev ptr or head to remove this entry from list */ 698210284Sjmallett if (prev_addr) 699210284Sjmallett { 700210284Sjmallett cvmx_bootmem_phy_set_next(prev_addr, cvmx_bootmem_phy_get_next(ent_addr)); 701210284Sjmallett } 702210284Sjmallett else 703210284Sjmallett { 704210284Sjmallett /* head of list being returned, so update head ptr */ 705215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(head_addr, cvmx_bootmem_phy_get_next(ent_addr)); 706210284Sjmallett } 707215990Sjmallett __cvmx_bootmem_unlock(flags); 708210284Sjmallett return(desired_min_addr); 709210284Sjmallett } 710210284Sjmallett 711210284Sjmallett 712210284Sjmallett /* block returned doesn't start at beginning of entry, so we know 713210284Sjmallett ** that we will be splitting a block off the front of this one. Create a new block 714210284Sjmallett ** from the beginning, add to list, and go to top of loop again. 715210284Sjmallett ** 716210284Sjmallett ** create new block from high portion of block, so that top block 717210284Sjmallett ** starts at desired addr 718210284Sjmallett **/ 719210284Sjmallett new_ent_addr = desired_min_addr; 720210284Sjmallett cvmx_bootmem_phy_set_next(new_ent_addr, cvmx_bootmem_phy_get_next(ent_addr)); 721210284Sjmallett cvmx_bootmem_phy_set_size(new_ent_addr, cvmx_bootmem_phy_get_size(ent_addr) - (desired_min_addr - ent_addr)); 722210284Sjmallett cvmx_bootmem_phy_set_size(ent_addr, desired_min_addr - ent_addr); 723210284Sjmallett cvmx_bootmem_phy_set_next(ent_addr, new_ent_addr); 724210284Sjmallett /* Loop again to handle actual alloc from new block */ 725210284Sjmallett } 726210284Sjmallett 727210284Sjmallett prev_addr = ent_addr; 728210284Sjmallett ent_addr = cvmx_bootmem_phy_get_next(ent_addr); 729210284Sjmallett } 730210284Sjmalletterror_out: 731210284Sjmallett /* We didn't find anything, so return error */ 732215990Sjmallett __cvmx_bootmem_unlock(flags); 733210284Sjmallett return(-1); 734210284Sjmallett} 735210284Sjmallett 736210284Sjmallett 737210284Sjmallett 738210284Sjmallettint __cvmx_bootmem_phy_free(uint64_t phy_addr, uint64_t size, uint32_t flags) 739210284Sjmallett{ 740210284Sjmallett uint64_t cur_addr; 741210284Sjmallett uint64_t prev_addr = 0; /* zero is invalid */ 742210284Sjmallett int retval = 0; 743210284Sjmallett 744210284Sjmallett#ifdef DEBUG 745215990Sjmallett cvmx_dprintf("__cvmx_bootmem_phy_free addr: 0x%llx, size: 0x%llx\n", (ULL)phy_addr, (ULL)size); 746210284Sjmallett#endif 747215990Sjmallett if (__cvmx_bootmem_check_version(0)) 748210284Sjmallett return(0); 749210284Sjmallett 750210284Sjmallett /* 0 is not a valid size for this allocator */ 751210284Sjmallett if (!size) 752210284Sjmallett return(0); 753210284Sjmallett 754210284Sjmallett 755215990Sjmallett __cvmx_bootmem_lock(flags); 756215990Sjmallett cur_addr = CVMX_BOOTMEM_DESC_GET_FIELD(head_addr); 757210284Sjmallett if (cur_addr == 0 || phy_addr < cur_addr) 758210284Sjmallett { 759210284Sjmallett /* add at front of list - special case with changing head ptr */ 760210284Sjmallett if (cur_addr && phy_addr + size > cur_addr) 761210284Sjmallett goto bootmem_free_done; /* error, overlapping section */ 762210284Sjmallett else if (phy_addr + size == cur_addr) 763210284Sjmallett { 764210284Sjmallett /* Add to front of existing first block */ 765210284Sjmallett cvmx_bootmem_phy_set_next(phy_addr, cvmx_bootmem_phy_get_next(cur_addr)); 766210284Sjmallett cvmx_bootmem_phy_set_size(phy_addr, cvmx_bootmem_phy_get_size(cur_addr) + size); 767215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(head_addr, phy_addr); 768210284Sjmallett 769210284Sjmallett } 770210284Sjmallett else 771210284Sjmallett { 772210284Sjmallett /* New block before first block */ 773210284Sjmallett cvmx_bootmem_phy_set_next(phy_addr, cur_addr); /* OK if cur_addr is 0 */ 774210284Sjmallett cvmx_bootmem_phy_set_size(phy_addr, size); 775215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(head_addr, phy_addr); 776210284Sjmallett } 777210284Sjmallett retval = 1; 778210284Sjmallett goto bootmem_free_done; 779210284Sjmallett } 780210284Sjmallett 781210284Sjmallett /* Find place in list to add block */ 782210284Sjmallett while (cur_addr && phy_addr > cur_addr) 783210284Sjmallett { 784210284Sjmallett prev_addr = cur_addr; 785210284Sjmallett cur_addr = cvmx_bootmem_phy_get_next(cur_addr); 786210284Sjmallett } 787210284Sjmallett 788210284Sjmallett if (!cur_addr) 789210284Sjmallett { 790210284Sjmallett /* We have reached the end of the list, add on to end, checking 791210284Sjmallett ** to see if we need to combine with last block 792210284Sjmallett **/ 793210284Sjmallett if (prev_addr + cvmx_bootmem_phy_get_size(prev_addr) == phy_addr) 794210284Sjmallett { 795210284Sjmallett cvmx_bootmem_phy_set_size(prev_addr, cvmx_bootmem_phy_get_size(prev_addr) + size); 796210284Sjmallett } 797210284Sjmallett else 798210284Sjmallett { 799210284Sjmallett cvmx_bootmem_phy_set_next(prev_addr, phy_addr); 800210284Sjmallett cvmx_bootmem_phy_set_size(phy_addr, size); 801210284Sjmallett cvmx_bootmem_phy_set_next(phy_addr, 0); 802210284Sjmallett } 803210284Sjmallett retval = 1; 804210284Sjmallett goto bootmem_free_done; 805210284Sjmallett } 806210284Sjmallett else 807210284Sjmallett { 808210284Sjmallett /* insert between prev and cur nodes, checking for merge with either/both */ 809210284Sjmallett 810210284Sjmallett if (prev_addr + cvmx_bootmem_phy_get_size(prev_addr) == phy_addr) 811210284Sjmallett { 812210284Sjmallett /* Merge with previous */ 813210284Sjmallett cvmx_bootmem_phy_set_size(prev_addr, cvmx_bootmem_phy_get_size(prev_addr) + size); 814210284Sjmallett if (phy_addr + size == cur_addr) 815210284Sjmallett { 816210284Sjmallett /* Also merge with current */ 817210284Sjmallett cvmx_bootmem_phy_set_size(prev_addr, cvmx_bootmem_phy_get_size(cur_addr) + cvmx_bootmem_phy_get_size(prev_addr)); 818210284Sjmallett cvmx_bootmem_phy_set_next(prev_addr, cvmx_bootmem_phy_get_next(cur_addr)); 819210284Sjmallett } 820210284Sjmallett retval = 1; 821210284Sjmallett goto bootmem_free_done; 822210284Sjmallett } 823210284Sjmallett else if (phy_addr + size == cur_addr) 824210284Sjmallett { 825210284Sjmallett /* Merge with current */ 826210284Sjmallett cvmx_bootmem_phy_set_size(phy_addr, cvmx_bootmem_phy_get_size(cur_addr) + size); 827210284Sjmallett cvmx_bootmem_phy_set_next(phy_addr, cvmx_bootmem_phy_get_next(cur_addr)); 828210284Sjmallett cvmx_bootmem_phy_set_next(prev_addr, phy_addr); 829210284Sjmallett retval = 1; 830210284Sjmallett goto bootmem_free_done; 831210284Sjmallett } 832210284Sjmallett 833210284Sjmallett /* It is a standalone block, add in between prev and cur */ 834210284Sjmallett cvmx_bootmem_phy_set_size(phy_addr, size); 835210284Sjmallett cvmx_bootmem_phy_set_next(phy_addr, cur_addr); 836210284Sjmallett cvmx_bootmem_phy_set_next(prev_addr, phy_addr); 837210284Sjmallett 838210284Sjmallett 839210284Sjmallett } 840210284Sjmallett retval = 1; 841210284Sjmallett 842210284Sjmallettbootmem_free_done: 843215990Sjmallett __cvmx_bootmem_unlock(flags); 844210284Sjmallett return(retval); 845210284Sjmallett 846210284Sjmallett} 847210284Sjmallett 848210284Sjmallett 849210284Sjmallett 850210284Sjmallettvoid cvmx_bootmem_phy_list_print(void) 851210284Sjmallett{ 852210284Sjmallett uint64_t addr; 853210284Sjmallett 854215990Sjmallett addr = CVMX_BOOTMEM_DESC_GET_FIELD(head_addr); 855215990Sjmallett cvmx_dprintf("\n\n\nPrinting bootmem block list, descriptor: 0x%llx, head is 0x%llx\n", 856215990Sjmallett (ULL)cvmx_bootmem_desc_addr, (ULL)addr); 857215990Sjmallett cvmx_dprintf("Descriptor version: %d.%d\n", 858215990Sjmallett (int)CVMX_BOOTMEM_DESC_GET_FIELD(major_version), 859215990Sjmallett (int)CVMX_BOOTMEM_DESC_GET_FIELD(minor_version)); 860215990Sjmallett if (CVMX_BOOTMEM_DESC_GET_FIELD(major_version) > 3) 861210284Sjmallett { 862210284Sjmallett cvmx_dprintf("Warning: Bootmem descriptor version is newer than expected\n"); 863210284Sjmallett } 864210284Sjmallett if (!addr) 865210284Sjmallett { 866210284Sjmallett cvmx_dprintf("mem list is empty!\n"); 867210284Sjmallett } 868210284Sjmallett while (addr) 869210284Sjmallett { 870232812Sjmallett cvmx_dprintf("Block address: 0x%08llx, size: 0x%08llx, next: 0x%08llx\n", 871215990Sjmallett (ULL)addr, 872215990Sjmallett (ULL)cvmx_bootmem_phy_get_size(addr), 873215990Sjmallett (ULL)cvmx_bootmem_phy_get_next(addr)); 874210284Sjmallett addr = cvmx_bootmem_phy_get_next(addr); 875210284Sjmallett } 876210284Sjmallett cvmx_dprintf("\n\n"); 877210284Sjmallett 878210284Sjmallett} 879210284Sjmallett 880210284Sjmallett 881210284Sjmallettuint64_t cvmx_bootmem_phy_available_mem(uint64_t min_block_size) 882210284Sjmallett{ 883210284Sjmallett uint64_t addr; 884210284Sjmallett 885210284Sjmallett uint64_t available_mem = 0; 886210284Sjmallett 887215990Sjmallett __cvmx_bootmem_lock(0); 888215990Sjmallett addr = CVMX_BOOTMEM_DESC_GET_FIELD(head_addr); 889210284Sjmallett while (addr) 890210284Sjmallett { 891210284Sjmallett if (cvmx_bootmem_phy_get_size(addr) >= min_block_size) 892210284Sjmallett available_mem += cvmx_bootmem_phy_get_size(addr); 893210284Sjmallett addr = cvmx_bootmem_phy_get_next(addr); 894210284Sjmallett } 895215990Sjmallett __cvmx_bootmem_unlock(0); 896210284Sjmallett return(available_mem); 897210284Sjmallett 898210284Sjmallett} 899210284Sjmallett 900210284Sjmallett 901210284Sjmallett 902215990Sjmallettuint64_t cvmx_bootmem_phy_named_block_find(const char *name, uint32_t flags) 903210284Sjmallett{ 904215990Sjmallett uint64_t result = 0; 905210284Sjmallett 906210284Sjmallett#ifdef DEBUG 907210284Sjmallett cvmx_dprintf("cvmx_bootmem_phy_named_block_find: %s\n", name); 908210284Sjmallett#endif 909215990Sjmallett __cvmx_bootmem_lock(flags); 910215990Sjmallett if (!__cvmx_bootmem_check_version(3)) 911210284Sjmallett { 912215990Sjmallett int i; 913215990Sjmallett uint64_t named_block_array_addr = CVMX_BOOTMEM_DESC_GET_FIELD(named_block_array_addr); 914215990Sjmallett int num_blocks = CVMX_BOOTMEM_DESC_GET_FIELD(named_block_num_blocks); 915215990Sjmallett int name_length = CVMX_BOOTMEM_DESC_GET_FIELD(named_block_name_len); 916215990Sjmallett uint64_t named_addr = named_block_array_addr; 917215990Sjmallett for (i = 0; i < num_blocks; i++) 918210284Sjmallett { 919215990Sjmallett uint64_t named_size = CVMX_BOOTMEM_NAMED_GET_FIELD(named_addr, size); 920215990Sjmallett if (name && named_size) 921210284Sjmallett { 922215990Sjmallett char name_tmp[name_length]; 923215990Sjmallett CVMX_BOOTMEM_NAMED_GET_NAME(named_addr, name_tmp, name_length); 924215990Sjmallett if (!strncmp(name, name_tmp, name_length - 1)) 925215990Sjmallett { 926215990Sjmallett result = named_addr; 927215990Sjmallett break; 928215990Sjmallett } 929210284Sjmallett } 930215990Sjmallett else if (!name && !named_size) 931215990Sjmallett { 932215990Sjmallett result = named_addr; 933215990Sjmallett break; 934215990Sjmallett } 935215990Sjmallett named_addr += sizeof(cvmx_bootmem_named_block_desc_t); 936210284Sjmallett } 937210284Sjmallett } 938215990Sjmallett __cvmx_bootmem_unlock(flags); 939215990Sjmallett return result; 940210284Sjmallett} 941210284Sjmallett 942215990Sjmallettint cvmx_bootmem_phy_named_block_free(const char *name, uint32_t flags) 943210284Sjmallett{ 944215990Sjmallett uint64_t named_block_addr; 945210284Sjmallett 946215990Sjmallett if (__cvmx_bootmem_check_version(3)) 947210284Sjmallett return(0); 948210284Sjmallett#ifdef DEBUG 949210284Sjmallett cvmx_dprintf("cvmx_bootmem_phy_named_block_free: %s\n", name); 950210284Sjmallett#endif 951210284Sjmallett 952210284Sjmallett /* Take lock here, as name lookup/block free/name free need to be atomic */ 953215990Sjmallett __cvmx_bootmem_lock(flags); 954210284Sjmallett 955215990Sjmallett named_block_addr = cvmx_bootmem_phy_named_block_find(name, CVMX_BOOTMEM_FLAG_NO_LOCKING); 956215990Sjmallett if (named_block_addr) 957210284Sjmallett { 958215990Sjmallett uint64_t named_addr = CVMX_BOOTMEM_NAMED_GET_FIELD(named_block_addr, base_addr); 959215990Sjmallett uint64_t named_size = CVMX_BOOTMEM_NAMED_GET_FIELD(named_block_addr, size); 960210284Sjmallett#ifdef DEBUG 961215990Sjmallett cvmx_dprintf("cvmx_bootmem_phy_named_block_free: %s, base: 0x%llx, size: 0x%llx\n", 962215990Sjmallett name, (ULL)named_addr, (ULL)named_size); 963210284Sjmallett#endif 964215990Sjmallett __cvmx_bootmem_phy_free(named_addr, named_size, CVMX_BOOTMEM_FLAG_NO_LOCKING); 965210284Sjmallett /* Set size to zero to indicate block not used. */ 966215990Sjmallett CVMX_BOOTMEM_NAMED_SET_FIELD(named_block_addr, size, 0); 967210284Sjmallett } 968215990Sjmallett __cvmx_bootmem_unlock(flags); 969215990Sjmallett return(!!named_block_addr); /* 0 on failure, 1 on success */ 970210284Sjmallett} 971210284Sjmallett 972210284Sjmallett 973210284Sjmallett 974210284Sjmallett 975210284Sjmallett 976215990Sjmallettint64_t cvmx_bootmem_phy_named_block_alloc(uint64_t size, uint64_t min_addr, uint64_t max_addr, uint64_t alignment, const char *name, uint32_t flags) 977210284Sjmallett{ 978210284Sjmallett int64_t addr_allocated; 979215990Sjmallett uint64_t named_block_desc_addr; 980210284Sjmallett 981210284Sjmallett#ifdef DEBUG 982210284Sjmallett cvmx_dprintf("cvmx_bootmem_phy_named_block_alloc: size: 0x%llx, min: 0x%llx, max: 0x%llx, align: 0x%llx, name: %s\n", 983215990Sjmallett (ULL)size, 984215990Sjmallett (ULL)min_addr, 985215990Sjmallett (ULL)max_addr, 986215990Sjmallett (ULL)alignment, 987210284Sjmallett name); 988210284Sjmallett#endif 989215990Sjmallett 990215990Sjmallett if (__cvmx_bootmem_check_version(3)) 991210284Sjmallett return(-1); 992210284Sjmallett 993210284Sjmallett /* Take lock here, as name lookup/block alloc/name add need to be atomic */ 994210284Sjmallett 995215990Sjmallett __cvmx_bootmem_lock(flags); 996210284Sjmallett 997215990Sjmallett named_block_desc_addr = cvmx_bootmem_phy_named_block_find(name, flags | CVMX_BOOTMEM_FLAG_NO_LOCKING); 998215990Sjmallett if (named_block_desc_addr) 999215990Sjmallett { 1000215990Sjmallett __cvmx_bootmem_unlock(flags); 1001215990Sjmallett return(-1); 1002215990Sjmallett } 1003215990Sjmallett 1004210284Sjmallett /* Get pointer to first available named block descriptor */ 1005215990Sjmallett named_block_desc_addr = cvmx_bootmem_phy_named_block_find(NULL, flags | CVMX_BOOTMEM_FLAG_NO_LOCKING); 1006215990Sjmallett if (!named_block_desc_addr) 1007210284Sjmallett { 1008215990Sjmallett __cvmx_bootmem_unlock(flags); 1009210284Sjmallett return(-1); 1010210284Sjmallett } 1011210284Sjmallett 1012210284Sjmallett /* Round size up to mult of minimum alignment bytes 1013210284Sjmallett ** We need the actual size allocated to allow for blocks to be coallesced 1014210284Sjmallett ** when they are freed. The alloc routine does the same rounding up 1015210284Sjmallett ** on all allocations. */ 1016210284Sjmallett size = (size + (CVMX_BOOTMEM_ALIGNMENT_SIZE - 1)) & ~(CVMX_BOOTMEM_ALIGNMENT_SIZE - 1); 1017210284Sjmallett 1018210284Sjmallett addr_allocated = cvmx_bootmem_phy_alloc(size, min_addr, max_addr, alignment, flags | CVMX_BOOTMEM_FLAG_NO_LOCKING); 1019210284Sjmallett if (addr_allocated >= 0) 1020210284Sjmallett { 1021215990Sjmallett CVMX_BOOTMEM_NAMED_SET_FIELD(named_block_desc_addr, base_addr, addr_allocated); 1022215990Sjmallett CVMX_BOOTMEM_NAMED_SET_FIELD(named_block_desc_addr, size, size); 1023215990Sjmallett CVMX_BOOTMEM_NAMED_SET_NAME(named_block_desc_addr, name, CVMX_BOOTMEM_DESC_GET_FIELD(named_block_name_len)); 1024210284Sjmallett } 1025210284Sjmallett 1026215990Sjmallett __cvmx_bootmem_unlock(flags); 1027210284Sjmallett return(addr_allocated); 1028210284Sjmallett} 1029210284Sjmallett 1030210284Sjmallett 1031210284Sjmallett 1032210284Sjmallett 1033210284Sjmallettvoid cvmx_bootmem_phy_named_block_print(void) 1034210284Sjmallett{ 1035215990Sjmallett int i; 1036210284Sjmallett int printed = 0; 1037210284Sjmallett 1038215990Sjmallett uint64_t named_block_array_addr = CVMX_BOOTMEM_DESC_GET_FIELD(named_block_array_addr); 1039215990Sjmallett int num_blocks = CVMX_BOOTMEM_DESC_GET_FIELD(named_block_num_blocks); 1040215990Sjmallett int name_length = CVMX_BOOTMEM_DESC_GET_FIELD(named_block_name_len); 1041215990Sjmallett uint64_t named_block_addr = named_block_array_addr; 1042215990Sjmallett 1043210284Sjmallett#ifdef DEBUG 1044215990Sjmallett cvmx_dprintf("cvmx_bootmem_phy_named_block_print, desc addr: 0x%llx\n", 1045215990Sjmallett (ULL)cvmx_bootmem_desc_addr); 1046210284Sjmallett#endif 1047215990Sjmallett if (__cvmx_bootmem_check_version(3)) 1048210284Sjmallett return; 1049210284Sjmallett cvmx_dprintf("List of currently allocated named bootmem blocks:\n"); 1050215990Sjmallett for (i = 0; i < num_blocks; i++) 1051210284Sjmallett { 1052215990Sjmallett uint64_t named_size = CVMX_BOOTMEM_NAMED_GET_FIELD(named_block_addr, size); 1053215990Sjmallett if (named_size) 1054210284Sjmallett { 1055215990Sjmallett char name_tmp[name_length]; 1056215990Sjmallett uint64_t named_addr = CVMX_BOOTMEM_NAMED_GET_FIELD(named_block_addr, base_addr); 1057215990Sjmallett CVMX_BOOTMEM_NAMED_GET_NAME(named_block_addr, name_tmp, name_length); 1058210284Sjmallett printed++; 1059232812Sjmallett cvmx_dprintf("Name: %s, address: 0x%08llx, size: 0x%08llx, index: %d\n", 1060215990Sjmallett name_tmp, (ULL)named_addr, (ULL)named_size, i); 1061210284Sjmallett } 1062215990Sjmallett named_block_addr += sizeof(cvmx_bootmem_named_block_desc_t); 1063210284Sjmallett } 1064210284Sjmallett if (!printed) 1065210284Sjmallett { 1066210284Sjmallett cvmx_dprintf("No named bootmem blocks exist.\n"); 1067210284Sjmallett } 1068210284Sjmallett 1069210284Sjmallett} 1070210284Sjmallett 1071210284Sjmallett 1072210284Sjmallettint64_t cvmx_bootmem_phy_mem_list_init(uint64_t mem_size, uint32_t low_reserved_bytes, cvmx_bootmem_desc_t *desc_buffer) 1073210284Sjmallett{ 1074210284Sjmallett uint64_t cur_block_addr; 1075210284Sjmallett int64_t addr; 1076215990Sjmallett int i; 1077210284Sjmallett 1078210284Sjmallett#ifdef DEBUG 1079215990Sjmallett cvmx_dprintf("cvmx_bootmem_phy_mem_list_init (arg desc ptr: %p, cvmx_bootmem_desc: 0x%llx)\n", 1080215990Sjmallett desc_buffer, (ULL)cvmx_bootmem_desc_addr); 1081210284Sjmallett#endif 1082210284Sjmallett 1083210284Sjmallett /* Descriptor buffer needs to be in 32 bit addressable space to be compatible with 1084210284Sjmallett ** 32 bit applications */ 1085210284Sjmallett if (!desc_buffer) 1086210284Sjmallett { 1087210284Sjmallett cvmx_dprintf("ERROR: no memory for cvmx_bootmem descriptor provided\n"); 1088210284Sjmallett return 0; 1089210284Sjmallett } 1090210284Sjmallett 1091210284Sjmallett if (mem_size > OCTEON_MAX_PHY_MEM_SIZE) 1092210284Sjmallett { 1093210284Sjmallett mem_size = OCTEON_MAX_PHY_MEM_SIZE; 1094210284Sjmallett cvmx_dprintf("ERROR: requested memory size too large, truncating to maximum size\n"); 1095210284Sjmallett } 1096210284Sjmallett 1097215990Sjmallett if (cvmx_bootmem_desc_addr) 1098210284Sjmallett return 1; 1099210284Sjmallett 1100210284Sjmallett /* Initialize cvmx pointer to descriptor */ 1101215990Sjmallett#ifndef CVMX_BUILD_FOR_LINUX_HOST 1102215990Sjmallett cvmx_bootmem_init(cvmx_ptr_to_phys(desc_buffer)); 1103215990Sjmallett#else 1104215990Sjmallett cvmx_bootmem_init((unsigned long)desc_buffer); 1105215990Sjmallett#endif 1106210284Sjmallett 1107215990Sjmallett /* Fill the bootmem descriptor */ 1108215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(lock, 0); 1109215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(flags, 0); 1110215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(head_addr, 0); 1111215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(major_version, CVMX_BOOTMEM_DESC_MAJ_VER); 1112215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(minor_version, CVMX_BOOTMEM_DESC_MIN_VER); 1113215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(app_data_addr, 0); 1114215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(app_data_size, 0); 1115215990Sjmallett 1116210284Sjmallett /* Set up global pointer to start of list, exclude low 64k for exception vectors, space for global descriptor */ 1117215990Sjmallett cur_block_addr = (OCTEON_DDR0_BASE + low_reserved_bytes); 1118210284Sjmallett 1119210284Sjmallett if (mem_size <= OCTEON_DDR0_SIZE) 1120210284Sjmallett { 1121210284Sjmallett __cvmx_bootmem_phy_free(cur_block_addr, mem_size - low_reserved_bytes, 0); 1122210284Sjmallett goto frees_done; 1123210284Sjmallett } 1124210284Sjmallett 1125210284Sjmallett __cvmx_bootmem_phy_free(cur_block_addr, OCTEON_DDR0_SIZE - low_reserved_bytes, 0); 1126210284Sjmallett 1127210284Sjmallett mem_size -= OCTEON_DDR0_SIZE; 1128210284Sjmallett 1129210284Sjmallett /* Add DDR2 block next if present */ 1130210284Sjmallett if (mem_size > OCTEON_DDR1_SIZE) 1131210284Sjmallett { 1132210284Sjmallett __cvmx_bootmem_phy_free(OCTEON_DDR1_BASE, OCTEON_DDR1_SIZE, 0); 1133210284Sjmallett __cvmx_bootmem_phy_free(OCTEON_DDR2_BASE, mem_size - OCTEON_DDR1_SIZE, 0); 1134210284Sjmallett } 1135210284Sjmallett else 1136210284Sjmallett { 1137210284Sjmallett __cvmx_bootmem_phy_free(OCTEON_DDR1_BASE, mem_size, 0); 1138210284Sjmallett 1139210284Sjmallett } 1140210284Sjmallettfrees_done: 1141210284Sjmallett 1142210284Sjmallett /* Initialize the named block structure */ 1143215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(named_block_name_len, CVMX_BOOTMEM_NAME_LEN); 1144215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(named_block_num_blocks, CVMX_BOOTMEM_NUM_NAMED_BLOCKS); 1145215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(named_block_array_addr, 0); 1146210284Sjmallett 1147210284Sjmallett /* Allocate this near the top of the low 256 MBytes of memory */ 1148210284Sjmallett addr = cvmx_bootmem_phy_alloc(CVMX_BOOTMEM_NUM_NAMED_BLOCKS * sizeof(cvmx_bootmem_named_block_desc_t),0, 0x10000000, 0 ,CVMX_BOOTMEM_FLAG_END_ALLOC); 1149210284Sjmallett if (addr >= 0) 1150215990Sjmallett CVMX_BOOTMEM_DESC_SET_FIELD(named_block_array_addr, addr); 1151210284Sjmallett 1152210284Sjmallett#ifdef DEBUG 1153215990Sjmallett cvmx_dprintf("cvmx_bootmem_phy_mem_list_init: named_block_array_addr: 0x%llx)\n", 1154215990Sjmallett (ULL)addr); 1155210284Sjmallett#endif 1156215990Sjmallett if (!addr) 1157210284Sjmallett { 1158210284Sjmallett cvmx_dprintf("FATAL ERROR: unable to allocate memory for bootmem descriptor!\n"); 1159210284Sjmallett return(0); 1160210284Sjmallett } 1161215990Sjmallett for (i=0; i<CVMX_BOOTMEM_NUM_NAMED_BLOCKS; i++) 1162215990Sjmallett { 1163215990Sjmallett CVMX_BOOTMEM_NAMED_SET_FIELD(addr, base_addr, 0); 1164215990Sjmallett CVMX_BOOTMEM_NAMED_SET_FIELD(addr, size, 0); 1165215990Sjmallett addr += sizeof(cvmx_bootmem_named_block_desc_t); 1166215990Sjmallett } 1167210284Sjmallett 1168210284Sjmallett return(1); 1169210284Sjmallett} 1170210284Sjmallett 1171210284Sjmallett 1172210284Sjmallettvoid cvmx_bootmem_lock(void) 1173210284Sjmallett{ 1174215990Sjmallett __cvmx_bootmem_lock(0); 1175210284Sjmallett} 1176210284Sjmallett 1177210284Sjmallettvoid cvmx_bootmem_unlock(void) 1178210284Sjmallett{ 1179215990Sjmallett __cvmx_bootmem_unlock(0); 1180210284Sjmallett} 1181210284Sjmallett 1182215990Sjmallett#ifndef CVMX_BUILD_FOR_LINUX_HOST 1183210284Sjmallettvoid *__cvmx_bootmem_internal_get_desc_ptr(void) 1184210284Sjmallett{ 1185215990Sjmallett return cvmx_phys_to_ptr(cvmx_bootmem_desc_addr); 1186210284Sjmallett} 1187215990Sjmallett#endif 1188