695 lines
20 KiB
C
695 lines
20 KiB
C
/***********************license start***************
|
|
* Author: Cavium Networks
|
|
*
|
|
* Contact: support@caviumnetworks.com
|
|
* This file is part of the OCTEON SDK
|
|
*
|
|
* Copyright (c) 2003-2008 Cavium Networks
|
|
*
|
|
* This file is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License, Version 2, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This file is distributed in the hope that it will be useful, but
|
|
* AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
|
|
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
|
|
* NONINFRINGEMENT. See the GNU General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this file; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
* or visit http://www.gnu.org/licenses/.
|
|
*
|
|
* This file may also be available under a different license from Cavium.
|
|
* Contact Cavium Networks for more information
|
|
***********************license end**************************************/
|
|
|
|
/*
|
|
* Simple allocate only memory allocator. Used to allocate memory at
|
|
* application start time.
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
|
|
#include <asm/octeon/cvmx.h>
|
|
#include <asm/octeon/cvmx-spinlock.h>
|
|
#include <asm/octeon/cvmx-bootmem.h>
|
|
|
|
/*#define DEBUG */
|
|
|
|
|
|
static struct cvmx_bootmem_desc *cvmx_bootmem_desc;
|
|
|
|
/* See header file for descriptions of functions */
|
|
|
|
/*
|
|
* Wrapper functions are provided for reading/writing the size and
|
|
* next block values as these may not be directly addressible (in 32
|
|
* bit applications, for instance.) Offsets of data elements in
|
|
* bootmem list, must match cvmx_bootmem_block_header_t.
|
|
*/
|
|
#define NEXT_OFFSET 0
|
|
#define SIZE_OFFSET 8
|
|
|
|
static void cvmx_bootmem_phy_set_size(uint64_t addr, uint64_t size)
|
|
{
|
|
cvmx_write64_uint64((addr + SIZE_OFFSET) | (1ull << 63), size);
|
|
}
|
|
|
|
static void cvmx_bootmem_phy_set_next(uint64_t addr, uint64_t next)
|
|
{
|
|
cvmx_write64_uint64((addr + NEXT_OFFSET) | (1ull << 63), next);
|
|
}
|
|
|
|
static uint64_t cvmx_bootmem_phy_get_size(uint64_t addr)
|
|
{
|
|
return cvmx_read64_uint64((addr + SIZE_OFFSET) | (1ull << 63));
|
|
}
|
|
|
|
static uint64_t cvmx_bootmem_phy_get_next(uint64_t addr)
|
|
{
|
|
return cvmx_read64_uint64((addr + NEXT_OFFSET) | (1ull << 63));
|
|
}
|
|
|
|
void *cvmx_bootmem_alloc_range(uint64_t size, uint64_t alignment,
|
|
uint64_t min_addr, uint64_t max_addr)
|
|
{
|
|
int64_t address;
|
|
address =
|
|
cvmx_bootmem_phy_alloc(size, min_addr, max_addr, alignment, 0);
|
|
|
|
if (address > 0)
|
|
return cvmx_phys_to_ptr(address);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
void *cvmx_bootmem_alloc_address(uint64_t size, uint64_t address,
|
|
uint64_t alignment)
|
|
{
|
|
return cvmx_bootmem_alloc_range(size, alignment, address,
|
|
address + size);
|
|
}
|
|
|
|
void *cvmx_bootmem_alloc(uint64_t size, uint64_t alignment)
|
|
{
|
|
return cvmx_bootmem_alloc_range(size, alignment, 0, 0);
|
|
}
|
|
|
|
void *cvmx_bootmem_alloc_named_range(uint64_t size, uint64_t min_addr,
|
|
uint64_t max_addr, uint64_t align,
|
|
char *name)
|
|
{
|
|
int64_t addr;
|
|
|
|
addr = cvmx_bootmem_phy_named_block_alloc(size, min_addr, max_addr,
|
|
align, name, 0);
|
|
if (addr >= 0)
|
|
return cvmx_phys_to_ptr(addr);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
void *cvmx_bootmem_alloc_named_address(uint64_t size, uint64_t address,
|
|
char *name)
|
|
{
|
|
return cvmx_bootmem_alloc_named_range(size, address, address + size,
|
|
0, name);
|
|
}
|
|
|
|
void *cvmx_bootmem_alloc_named(uint64_t size, uint64_t alignment, char *name)
|
|
{
|
|
return cvmx_bootmem_alloc_named_range(size, 0, 0, alignment, name);
|
|
}
|
|
EXPORT_SYMBOL(cvmx_bootmem_alloc_named);
|
|
|
|
int cvmx_bootmem_free_named(char *name)
|
|
{
|
|
return cvmx_bootmem_phy_named_block_free(name, 0);
|
|
}
|
|
|
|
struct cvmx_bootmem_named_block_desc *cvmx_bootmem_find_named_block(char *name)
|
|
{
|
|
return cvmx_bootmem_phy_named_block_find(name, 0);
|
|
}
|
|
EXPORT_SYMBOL(cvmx_bootmem_find_named_block);
|
|
|
|
void cvmx_bootmem_lock(void)
|
|
{
|
|
cvmx_spinlock_lock((cvmx_spinlock_t *) &(cvmx_bootmem_desc->lock));
|
|
}
|
|
|
|
void cvmx_bootmem_unlock(void)
|
|
{
|
|
cvmx_spinlock_unlock((cvmx_spinlock_t *) &(cvmx_bootmem_desc->lock));
|
|
}
|
|
|
|
int cvmx_bootmem_init(void *mem_desc_ptr)
|
|
{
|
|
/* Here we set the global pointer to the bootmem descriptor
|
|
* block. This pointer will be used directly, so we will set
|
|
* it up to be directly usable by the application. It is set
|
|
* up as follows for the various runtime/ABI combinations:
|
|
*
|
|
* Linux 64 bit: Set XKPHYS bit
|
|
* Linux 32 bit: use mmap to create mapping, use virtual address
|
|
* CVMX 64 bit: use physical address directly
|
|
* CVMX 32 bit: use physical address directly
|
|
*
|
|
* Note that the CVMX environment assumes the use of 1-1 TLB
|
|
* mappings so that the physical addresses can be used
|
|
* directly
|
|
*/
|
|
if (!cvmx_bootmem_desc) {
|
|
#if defined(CVMX_ABI_64)
|
|
/* Set XKPHYS bit */
|
|
cvmx_bootmem_desc = cvmx_phys_to_ptr(CAST64(mem_desc_ptr));
|
|
#else
|
|
cvmx_bootmem_desc = (struct cvmx_bootmem_desc *) mem_desc_ptr;
|
|
#endif
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* The cvmx_bootmem_phy* functions below return 64 bit physical
|
|
* addresses, and expose more features that the cvmx_bootmem_functions
|
|
* above. These are required for full memory space access in 32 bit
|
|
* applications, as well as for using some advance features. Most
|
|
* applications should not need to use these.
|
|
*/
|
|
|
|
int64_t cvmx_bootmem_phy_alloc(uint64_t req_size, uint64_t address_min,
|
|
uint64_t address_max, uint64_t alignment,
|
|
uint32_t flags)
|
|
{
|
|
|
|
uint64_t head_addr;
|
|
uint64_t ent_addr;
|
|
/* points to previous list entry, NULL current entry is head of list */
|
|
uint64_t prev_addr = 0;
|
|
uint64_t new_ent_addr = 0;
|
|
uint64_t desired_min_addr;
|
|
|
|
#ifdef DEBUG
|
|
cvmx_dprintf("cvmx_bootmem_phy_alloc: req_size: 0x%llx, "
|
|
"min_addr: 0x%llx, max_addr: 0x%llx, align: 0x%llx\n",
|
|
(unsigned long long)req_size,
|
|
(unsigned long long)address_min,
|
|
(unsigned long long)address_max,
|
|
(unsigned long long)alignment);
|
|
#endif
|
|
|
|
if (cvmx_bootmem_desc->major_version > 3) {
|
|
cvmx_dprintf("ERROR: Incompatible bootmem descriptor "
|
|
"version: %d.%d at addr: %p\n",
|
|
(int)cvmx_bootmem_desc->major_version,
|
|
(int)cvmx_bootmem_desc->minor_version,
|
|
cvmx_bootmem_desc);
|
|
goto error_out;
|
|
}
|
|
|
|
/*
|
|
* Do a variety of checks to validate the arguments. The
|
|
* allocator code will later assume that these checks have
|
|
* been made. We validate that the requested constraints are
|
|
* not self-contradictory before we look through the list of
|
|
* available memory.
|
|
*/
|
|
|
|
/* 0 is not a valid req_size for this allocator */
|
|
if (!req_size)
|
|
goto error_out;
|
|
|
|
/* Round req_size up to mult of minimum alignment bytes */
|
|
req_size = (req_size + (CVMX_BOOTMEM_ALIGNMENT_SIZE - 1)) &
|
|
~(CVMX_BOOTMEM_ALIGNMENT_SIZE - 1);
|
|
|
|
/*
|
|
* Convert !0 address_min and 0 address_max to special case of
|
|
* range that specifies an exact memory block to allocate. Do
|
|
* this before other checks and adjustments so that this
|
|
* tranformation will be validated.
|
|
*/
|
|
if (address_min && !address_max)
|
|
address_max = address_min + req_size;
|
|
else if (!address_min && !address_max)
|
|
address_max = ~0ull; /* If no limits given, use max limits */
|
|
|
|
|
|
/*
|
|
* Enforce minimum alignment (this also keeps the minimum free block
|
|
* req_size the same as the alignment req_size.
|
|
*/
|
|
if (alignment < CVMX_BOOTMEM_ALIGNMENT_SIZE)
|
|
alignment = CVMX_BOOTMEM_ALIGNMENT_SIZE;
|
|
|
|
/*
|
|
* Adjust address minimum based on requested alignment (round
|
|
* up to meet alignment). Do this here so we can reject
|
|
* impossible requests up front. (NOP for address_min == 0)
|
|
*/
|
|
if (alignment)
|
|
address_min = ALIGN(address_min, alignment);
|
|
|
|
/*
|
|
* Reject inconsistent args. We have adjusted these, so this
|
|
* may fail due to our internal changes even if this check
|
|
* would pass for the values the user supplied.
|
|
*/
|
|
if (req_size > address_max - address_min)
|
|
goto error_out;
|
|
|
|
/* Walk through the list entries - first fit found is returned */
|
|
|
|
if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
|
|
cvmx_bootmem_lock();
|
|
head_addr = cvmx_bootmem_desc->head_addr;
|
|
ent_addr = head_addr;
|
|
for (; ent_addr;
|
|
prev_addr = ent_addr,
|
|
ent_addr = cvmx_bootmem_phy_get_next(ent_addr)) {
|
|
uint64_t usable_base, usable_max;
|
|
uint64_t ent_size = cvmx_bootmem_phy_get_size(ent_addr);
|
|
|
|
if (cvmx_bootmem_phy_get_next(ent_addr)
|
|
&& ent_addr > cvmx_bootmem_phy_get_next(ent_addr)) {
|
|
cvmx_dprintf("Internal bootmem_alloc() error: ent: "
|
|
"0x%llx, next: 0x%llx\n",
|
|
(unsigned long long)ent_addr,
|
|
(unsigned long long)
|
|
cvmx_bootmem_phy_get_next(ent_addr));
|
|
goto error_out;
|
|
}
|
|
|
|
/*
|
|
* Determine if this is an entry that can satisify the
|
|
* request Check to make sure entry is large enough to
|
|
* satisfy request.
|
|
*/
|
|
usable_base =
|
|
ALIGN(max(address_min, ent_addr), alignment);
|
|
usable_max = min(address_max, ent_addr + ent_size);
|
|
/*
|
|
* We should be able to allocate block at address
|
|
* usable_base.
|
|
*/
|
|
|
|
desired_min_addr = usable_base;
|
|
/*
|
|
* Determine if request can be satisfied from the
|
|
* current entry.
|
|
*/
|
|
if (!((ent_addr + ent_size) > usable_base
|
|
&& ent_addr < address_max
|
|
&& req_size <= usable_max - usable_base))
|
|
continue;
|
|
/*
|
|
* We have found an entry that has room to satisfy the
|
|
* request, so allocate it from this entry. If end
|
|
* CVMX_BOOTMEM_FLAG_END_ALLOC set, then allocate from
|
|
* the end of this block rather than the beginning.
|
|
*/
|
|
if (flags & CVMX_BOOTMEM_FLAG_END_ALLOC) {
|
|
desired_min_addr = usable_max - req_size;
|
|
/*
|
|
* Align desired address down to required
|
|
* alignment.
|
|
*/
|
|
desired_min_addr &= ~(alignment - 1);
|
|
}
|
|
|
|
/* Match at start of entry */
|
|
if (desired_min_addr == ent_addr) {
|
|
if (req_size < ent_size) {
|
|
/*
|
|
* big enough to create a new block
|
|
* from top portion of block.
|
|
*/
|
|
new_ent_addr = ent_addr + req_size;
|
|
cvmx_bootmem_phy_set_next(new_ent_addr,
|
|
cvmx_bootmem_phy_get_next(ent_addr));
|
|
cvmx_bootmem_phy_set_size(new_ent_addr,
|
|
ent_size -
|
|
req_size);
|
|
|
|
/*
|
|
* Adjust next pointer as following
|
|
* code uses this.
|
|
*/
|
|
cvmx_bootmem_phy_set_next(ent_addr,
|
|
new_ent_addr);
|
|
}
|
|
|
|
/*
|
|
* adjust prev ptr or head to remove this
|
|
* entry from list.
|
|
*/
|
|
if (prev_addr)
|
|
cvmx_bootmem_phy_set_next(prev_addr,
|
|
cvmx_bootmem_phy_get_next(ent_addr));
|
|
else
|
|
/*
|
|
* head of list being returned, so
|
|
* update head ptr.
|
|
*/
|
|
cvmx_bootmem_desc->head_addr =
|
|
cvmx_bootmem_phy_get_next(ent_addr);
|
|
|
|
if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
|
|
cvmx_bootmem_unlock();
|
|
return desired_min_addr;
|
|
}
|
|
/*
|
|
* block returned doesn't start at beginning of entry,
|
|
* so we know that we will be splitting a block off
|
|
* the front of this one. Create a new block from the
|
|
* beginning, add to list, and go to top of loop
|
|
* again.
|
|
*
|
|
* create new block from high portion of
|
|
* block, so that top block starts at desired
|
|
* addr.
|
|
*/
|
|
new_ent_addr = desired_min_addr;
|
|
cvmx_bootmem_phy_set_next(new_ent_addr,
|
|
cvmx_bootmem_phy_get_next
|
|
(ent_addr));
|
|
cvmx_bootmem_phy_set_size(new_ent_addr,
|
|
cvmx_bootmem_phy_get_size
|
|
(ent_addr) -
|
|
(desired_min_addr -
|
|
ent_addr));
|
|
cvmx_bootmem_phy_set_size(ent_addr,
|
|
desired_min_addr - ent_addr);
|
|
cvmx_bootmem_phy_set_next(ent_addr, new_ent_addr);
|
|
/* Loop again to handle actual alloc from new block */
|
|
}
|
|
error_out:
|
|
/* We didn't find anything, so return error */
|
|
if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
|
|
cvmx_bootmem_unlock();
|
|
return -1;
|
|
}
|
|
|
|
int __cvmx_bootmem_phy_free(uint64_t phy_addr, uint64_t size, uint32_t flags)
|
|
{
|
|
uint64_t cur_addr;
|
|
uint64_t prev_addr = 0; /* zero is invalid */
|
|
int retval = 0;
|
|
|
|
#ifdef DEBUG
|
|
cvmx_dprintf("__cvmx_bootmem_phy_free addr: 0x%llx, size: 0x%llx\n",
|
|
(unsigned long long)phy_addr, (unsigned long long)size);
|
|
#endif
|
|
if (cvmx_bootmem_desc->major_version > 3) {
|
|
cvmx_dprintf("ERROR: Incompatible bootmem descriptor "
|
|
"version: %d.%d at addr: %p\n",
|
|
(int)cvmx_bootmem_desc->major_version,
|
|
(int)cvmx_bootmem_desc->minor_version,
|
|
cvmx_bootmem_desc);
|
|
return 0;
|
|
}
|
|
|
|
/* 0 is not a valid size for this allocator */
|
|
if (!size)
|
|
return 0;
|
|
|
|
if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
|
|
cvmx_bootmem_lock();
|
|
cur_addr = cvmx_bootmem_desc->head_addr;
|
|
if (cur_addr == 0 || phy_addr < cur_addr) {
|
|
/* add at front of list - special case with changing head ptr */
|
|
if (cur_addr && phy_addr + size > cur_addr)
|
|
goto bootmem_free_done; /* error, overlapping section */
|
|
else if (phy_addr + size == cur_addr) {
|
|
/* Add to front of existing first block */
|
|
cvmx_bootmem_phy_set_next(phy_addr,
|
|
cvmx_bootmem_phy_get_next
|
|
(cur_addr));
|
|
cvmx_bootmem_phy_set_size(phy_addr,
|
|
cvmx_bootmem_phy_get_size
|
|
(cur_addr) + size);
|
|
cvmx_bootmem_desc->head_addr = phy_addr;
|
|
|
|
} else {
|
|
/* New block before first block. OK if cur_addr is 0 */
|
|
cvmx_bootmem_phy_set_next(phy_addr, cur_addr);
|
|
cvmx_bootmem_phy_set_size(phy_addr, size);
|
|
cvmx_bootmem_desc->head_addr = phy_addr;
|
|
}
|
|
retval = 1;
|
|
goto bootmem_free_done;
|
|
}
|
|
|
|
/* Find place in list to add block */
|
|
while (cur_addr && phy_addr > cur_addr) {
|
|
prev_addr = cur_addr;
|
|
cur_addr = cvmx_bootmem_phy_get_next(cur_addr);
|
|
}
|
|
|
|
if (!cur_addr) {
|
|
/*
|
|
* We have reached the end of the list, add on to end,
|
|
* checking to see if we need to combine with last
|
|
* block
|
|
*/
|
|
if (prev_addr + cvmx_bootmem_phy_get_size(prev_addr) ==
|
|
phy_addr) {
|
|
cvmx_bootmem_phy_set_size(prev_addr,
|
|
cvmx_bootmem_phy_get_size
|
|
(prev_addr) + size);
|
|
} else {
|
|
cvmx_bootmem_phy_set_next(prev_addr, phy_addr);
|
|
cvmx_bootmem_phy_set_size(phy_addr, size);
|
|
cvmx_bootmem_phy_set_next(phy_addr, 0);
|
|
}
|
|
retval = 1;
|
|
goto bootmem_free_done;
|
|
} else {
|
|
/*
|
|
* insert between prev and cur nodes, checking for
|
|
* merge with either/both.
|
|
*/
|
|
if (prev_addr + cvmx_bootmem_phy_get_size(prev_addr) ==
|
|
phy_addr) {
|
|
/* Merge with previous */
|
|
cvmx_bootmem_phy_set_size(prev_addr,
|
|
cvmx_bootmem_phy_get_size
|
|
(prev_addr) + size);
|
|
if (phy_addr + size == cur_addr) {
|
|
/* Also merge with current */
|
|
cvmx_bootmem_phy_set_size(prev_addr,
|
|
cvmx_bootmem_phy_get_size(cur_addr) +
|
|
cvmx_bootmem_phy_get_size(prev_addr));
|
|
cvmx_bootmem_phy_set_next(prev_addr,
|
|
cvmx_bootmem_phy_get_next(cur_addr));
|
|
}
|
|
retval = 1;
|
|
goto bootmem_free_done;
|
|
} else if (phy_addr + size == cur_addr) {
|
|
/* Merge with current */
|
|
cvmx_bootmem_phy_set_size(phy_addr,
|
|
cvmx_bootmem_phy_get_size
|
|
(cur_addr) + size);
|
|
cvmx_bootmem_phy_set_next(phy_addr,
|
|
cvmx_bootmem_phy_get_next
|
|
(cur_addr));
|
|
cvmx_bootmem_phy_set_next(prev_addr, phy_addr);
|
|
retval = 1;
|
|
goto bootmem_free_done;
|
|
}
|
|
|
|
/* It is a standalone block, add in between prev and cur */
|
|
cvmx_bootmem_phy_set_size(phy_addr, size);
|
|
cvmx_bootmem_phy_set_next(phy_addr, cur_addr);
|
|
cvmx_bootmem_phy_set_next(prev_addr, phy_addr);
|
|
|
|
}
|
|
retval = 1;
|
|
|
|
bootmem_free_done:
|
|
if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
|
|
cvmx_bootmem_unlock();
|
|
return retval;
|
|
|
|
}
|
|
|
|
struct cvmx_bootmem_named_block_desc *
|
|
cvmx_bootmem_phy_named_block_find(char *name, uint32_t flags)
|
|
{
|
|
unsigned int i;
|
|
struct cvmx_bootmem_named_block_desc *named_block_array_ptr;
|
|
|
|
#ifdef DEBUG
|
|
cvmx_dprintf("cvmx_bootmem_phy_named_block_find: %s\n", name);
|
|
#endif
|
|
/*
|
|
* Lock the structure to make sure that it is not being
|
|
* changed while we are examining it.
|
|
*/
|
|
if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
|
|
cvmx_bootmem_lock();
|
|
|
|
/* Use XKPHYS for 64 bit linux */
|
|
named_block_array_ptr = (struct cvmx_bootmem_named_block_desc *)
|
|
cvmx_phys_to_ptr(cvmx_bootmem_desc->named_block_array_addr);
|
|
|
|
#ifdef DEBUG
|
|
cvmx_dprintf
|
|
("cvmx_bootmem_phy_named_block_find: named_block_array_ptr: %p\n",
|
|
named_block_array_ptr);
|
|
#endif
|
|
if (cvmx_bootmem_desc->major_version == 3) {
|
|
for (i = 0;
|
|
i < cvmx_bootmem_desc->named_block_num_blocks; i++) {
|
|
if ((name && named_block_array_ptr[i].size
|
|
&& !strncmp(name, named_block_array_ptr[i].name,
|
|
cvmx_bootmem_desc->named_block_name_len
|
|
- 1))
|
|
|| (!name && !named_block_array_ptr[i].size)) {
|
|
if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
|
|
cvmx_bootmem_unlock();
|
|
|
|
return &(named_block_array_ptr[i]);
|
|
}
|
|
}
|
|
} else {
|
|
cvmx_dprintf("ERROR: Incompatible bootmem descriptor "
|
|
"version: %d.%d at addr: %p\n",
|
|
(int)cvmx_bootmem_desc->major_version,
|
|
(int)cvmx_bootmem_desc->minor_version,
|
|
cvmx_bootmem_desc);
|
|
}
|
|
if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
|
|
cvmx_bootmem_unlock();
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int cvmx_bootmem_phy_named_block_free(char *name, uint32_t flags)
|
|
{
|
|
struct cvmx_bootmem_named_block_desc *named_block_ptr;
|
|
|
|
if (cvmx_bootmem_desc->major_version != 3) {
|
|
cvmx_dprintf("ERROR: Incompatible bootmem descriptor version: "
|
|
"%d.%d at addr: %p\n",
|
|
(int)cvmx_bootmem_desc->major_version,
|
|
(int)cvmx_bootmem_desc->minor_version,
|
|
cvmx_bootmem_desc);
|
|
return 0;
|
|
}
|
|
#ifdef DEBUG
|
|
cvmx_dprintf("cvmx_bootmem_phy_named_block_free: %s\n", name);
|
|
#endif
|
|
|
|
/*
|
|
* Take lock here, as name lookup/block free/name free need to
|
|
* be atomic.
|
|
*/
|
|
cvmx_bootmem_lock();
|
|
|
|
named_block_ptr =
|
|
cvmx_bootmem_phy_named_block_find(name,
|
|
CVMX_BOOTMEM_FLAG_NO_LOCKING);
|
|
if (named_block_ptr) {
|
|
#ifdef DEBUG
|
|
cvmx_dprintf("cvmx_bootmem_phy_named_block_free: "
|
|
"%s, base: 0x%llx, size: 0x%llx\n",
|
|
name,
|
|
(unsigned long long)named_block_ptr->base_addr,
|
|
(unsigned long long)named_block_ptr->size);
|
|
#endif
|
|
__cvmx_bootmem_phy_free(named_block_ptr->base_addr,
|
|
named_block_ptr->size,
|
|
CVMX_BOOTMEM_FLAG_NO_LOCKING);
|
|
named_block_ptr->size = 0;
|
|
/* Set size to zero to indicate block not used. */
|
|
}
|
|
|
|
cvmx_bootmem_unlock();
|
|
return named_block_ptr != NULL; /* 0 on failure, 1 on success */
|
|
}
|
|
|
|
int64_t cvmx_bootmem_phy_named_block_alloc(uint64_t size, uint64_t min_addr,
|
|
uint64_t max_addr,
|
|
uint64_t alignment,
|
|
char *name,
|
|
uint32_t flags)
|
|
{
|
|
int64_t addr_allocated;
|
|
struct cvmx_bootmem_named_block_desc *named_block_desc_ptr;
|
|
|
|
#ifdef DEBUG
|
|
cvmx_dprintf("cvmx_bootmem_phy_named_block_alloc: size: 0x%llx, min: "
|
|
"0x%llx, max: 0x%llx, align: 0x%llx, name: %s\n",
|
|
(unsigned long long)size,
|
|
(unsigned long long)min_addr,
|
|
(unsigned long long)max_addr,
|
|
(unsigned long long)alignment,
|
|
name);
|
|
#endif
|
|
if (cvmx_bootmem_desc->major_version != 3) {
|
|
cvmx_dprintf("ERROR: Incompatible bootmem descriptor version: "
|
|
"%d.%d at addr: %p\n",
|
|
(int)cvmx_bootmem_desc->major_version,
|
|
(int)cvmx_bootmem_desc->minor_version,
|
|
cvmx_bootmem_desc);
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Take lock here, as name lookup/block alloc/name add need to
|
|
* be atomic.
|
|
*/
|
|
if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
|
|
cvmx_spinlock_lock((cvmx_spinlock_t *)&(cvmx_bootmem_desc->lock));
|
|
|
|
/* Get pointer to first available named block descriptor */
|
|
named_block_desc_ptr =
|
|
cvmx_bootmem_phy_named_block_find(NULL,
|
|
flags | CVMX_BOOTMEM_FLAG_NO_LOCKING);
|
|
|
|
/*
|
|
* Check to see if name already in use, return error if name
|
|
* not available or no more room for blocks.
|
|
*/
|
|
if (cvmx_bootmem_phy_named_block_find(name,
|
|
flags | CVMX_BOOTMEM_FLAG_NO_LOCKING) || !named_block_desc_ptr) {
|
|
if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
|
|
cvmx_spinlock_unlock((cvmx_spinlock_t *)&(cvmx_bootmem_desc->lock));
|
|
return -1;
|
|
}
|
|
|
|
|
|
/*
|
|
* Round size up to mult of minimum alignment bytes We need
|
|
* the actual size allocated to allow for blocks to be
|
|
* coalesced when they are freed. The alloc routine does the
|
|
* same rounding up on all allocations.
|
|
*/
|
|
size = ALIGN(size, CVMX_BOOTMEM_ALIGNMENT_SIZE);
|
|
|
|
addr_allocated = cvmx_bootmem_phy_alloc(size, min_addr, max_addr,
|
|
alignment,
|
|
flags | CVMX_BOOTMEM_FLAG_NO_LOCKING);
|
|
if (addr_allocated >= 0) {
|
|
named_block_desc_ptr->base_addr = addr_allocated;
|
|
named_block_desc_ptr->size = size;
|
|
strncpy(named_block_desc_ptr->name, name,
|
|
cvmx_bootmem_desc->named_block_name_len);
|
|
named_block_desc_ptr->name[cvmx_bootmem_desc->named_block_name_len - 1] = 0;
|
|
}
|
|
|
|
if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
|
|
cvmx_spinlock_unlock((cvmx_spinlock_t *)&(cvmx_bootmem_desc->lock));
|
|
return addr_allocated;
|
|
}
|
|
|
|
struct cvmx_bootmem_desc *cvmx_bootmem_get_desc(void)
|
|
{
|
|
return cvmx_bootmem_desc;
|
|
}
|