/***********************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/export.h>
#include <linux/kernel.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 */

/*
 * This macro returns a member of the
 * cvmx_bootmem_named_block_desc_t structure. These members can't
 * be directly addressed as they might be in memory not directly
 * reachable. In the case where bootmem is compiled with
 * LINUX_HOST, the structure itself might be located on a remote
 * Octeon. The argument "field" is the member name of the
 * cvmx_bootmem_named_block_desc_t to read. Regardless of the type
 * of the field, the return type is always a uint64_t. The "addr"
 * parameter is the physical address of the structure.
 */
#define CVMX_BOOTMEM_NAMED_GET_FIELD(addr, field)   \
 __cvmx_bootmem_desc_get(addr,     \
  offsetof(struct cvmx_bootmem_named_block_desc, field), \
  sizeof_field(struct cvmx_bootmem_named_block_desc, field))

/*
 * This function is the implementation of the get macros defined
 * for individual structure members. The argument are generated
 * by the macros inorder to read only the needed memory.
 *
 * @param base   64bit physical address of the complete structure
 * @param offset Offset from the beginning of the structure to the member being
 *               accessed.
 * @param size   Size of the structure member.
 *
 * @return Value of the structure member promoted into a uint64_t.
 */
static inline uint64_t __cvmx_bootmem_desc_get(uint64_t base, int offset,
            int size)
{
 base = (1ull << 63) | (base + offset);
 switch (size) {
 case 4:
  return cvmx_read64_uint32(base);
 case 8:
  return cvmx_read64_uint64(base);
 default:
  return 0;
 }
}

/*
 * 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));
}

/*
 * Allocate a block of memory from the free list that was
 * passed to the application by the bootloader within a specified
 * address range. This is an allocate-only algorithm, so
 * freeing memory is not possible. Allocation will fail if
 * memory cannot be allocated in the requested range.
 *
 * @size:      Size in bytes of block to allocate
 * @min_addr:  defines the minimum address of the range
 * @max_addr:  defines the maximum address of the range
 * @alignment: Alignment required - must be power of 2
 * Returns pointer to block of memory, NULL on error
 */
static 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_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(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);

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
  * transformation 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 satisfy 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;

}

/*
 * Finds a named memory block by name.
 * Also used for finding an unused entry in the named block table.
 *
 * @name: Name of memory block to find.  If NULL pointer given, then
 *   finds unused descriptor, if available.
 *
 * @flags: Flags to control options for the allocation.
 *
 * Returns Pointer to memory block descriptor, NULL if not found.
 *    If NULL returned when name parameter is NULL, then no memory
 *    block descriptors are available.
 */
static 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;
}

void *cvmx_bootmem_alloc_named_range_once(uint64_t size, uint64_t min_addr,
       uint64_t max_addr, uint64_t align,
       char *name,
       void (*init) (void *))
{
 int64_t addr;
 void *ptr;
 uint64_t named_block_desc_addr;

 named_block_desc_addr = (uint64_t)
  cvmx_bootmem_phy_named_block_find(name,
        (uint32_t)CVMX_BOOTMEM_FLAG_NO_LOCKING);

 if (named_block_desc_addr) {
  addr = CVMX_BOOTMEM_NAMED_GET_FIELD(named_block_desc_addr,
          base_addr);
  return cvmx_phys_to_ptr(addr);
 }

 addr = cvmx_bootmem_phy_named_block_alloc(size, min_addr, max_addr,
        align, name,
        (uint32_t)CVMX_BOOTMEM_FLAG_NO_LOCKING);

 if (addr < 0)
  return NULL;
 ptr = cvmx_phys_to_ptr(addr);

 if (init)
  init(ptr);
 else
  memset(ptr, 0, size);

 return ptr;
}
EXPORT_SYMBOL(cvmx_bootmem_alloc_named_range_once);

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);

/*
 * Frees a named block.
 *
 * @name:   name of block to free
 * @flags:  flags for passing options
 *
 * Returns 0 on failure
 *    1 on success
 */
static 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 */
}

int cvmx_bootmem_free_named(char *name)
{
 return cvmx_bootmem_phy_named_block_free(name, 0);
}

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;
  strscpy(named_block_desc_ptr->name, name,
   cvmx_bootmem_desc->named_block_name_len);
 }

 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;
}