arch/mips/cavium-octeon/executive/cvmx-bootmem.c

   1 /***********************license start***************
   2  * Author: Cavium Networks
   3  *
   4  * Contact: support@caviumnetworks.com
   5  * This file is part of the OCTEON SDK
   6  *
   7  * Copyright (c) 2003-2008 Cavium Networks
   8  *
   9  * This file is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License, Version 2, as
  11  * published by the Free Software Foundation.
  12  *
  13  * This file is distributed in the hope that it will be useful, but
  14  * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
  15  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
  16  * NONINFRINGEMENT.  See the GNU General Public License for more
  17  * details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this file; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  22  * or visit http://www.gnu.org/licenses/.
  23  *
  24  * This file may also be available under a different license from Cavium.
  25  * Contact Cavium Networks for more information
  26  ***********************license end**************************************/
  27
  28 /*
  29  * Simple allocate only memory allocator.  Used to allocate memory at
  30  * application start time.
  31  */
  32
  33 #include <linux/export.h>
  34 #include <linux/kernel.h>
  35
  36 #include <asm/octeon/cvmx.h>
  37 #include <asm/octeon/cvmx-spinlock.h>
  38 #include <asm/octeon/cvmx-bootmem.h>
  39
  40 /*#define DEBUG */
  41
  42
  43 static struct cvmx_bootmem_desc *cvmx_bootmem_desc;
  44
  45 /* See header file for descriptions of functions */
  46
  47 /**
  48  * This macro returns the size of a member of a structure.
  49  * Logically it is the same as "sizeof(s::field)" in C++, but
  50  * C lacks the "::" operator.
  51  */
  52 #define SIZEOF_FIELD(s, field) sizeof(((s *)NULL)->field)
  53
  54 /**
  55  * This macro returns a member of the
  56  * cvmx_bootmem_named_block_desc_t structure. These members can't
  57  * be directly addressed as they might be in memory not directly
  58  * reachable. In the case where bootmem is compiled with
  59  * LINUX_HOST, the structure itself might be located on a remote
  60  * Octeon. The argument "field" is the member name of the
  61  * cvmx_bootmem_named_block_desc_t to read. Regardless of the type
  62  * of the field, the return type is always a uint64_t. The "addr"
  63  * parameter is the physical address of the structure.
  64  */
  65 #define CVMX_BOOTMEM_NAMED_GET_FIELD(addr, field)                       \
  66         __cvmx_bootmem_desc_get(addr,                                   \
  67                 offsetof(struct cvmx_bootmem_named_block_desc, field),  \
  68                 SIZEOF_FIELD(struct cvmx_bootmem_named_block_desc, field))
  69
  70 /**
  71  * This function is the implementation of the get macros defined
  72  * for individual structure members. The argument are generated
  73  * by the macros inorder to read only the needed memory.
  74  *
  75  * @param base   64bit physical address of the complete structure
  76  * @param offset Offset from the beginning of the structure to the member being
  77  *               accessed.
  78  * @param size   Size of the structure member.
  79  *
  80  * @return Value of the structure member promoted into a uint64_t.
  81  */
  82 static inline uint64_t __cvmx_bootmem_desc_get(uint64_t base, int offset,
  83                                                int size)
  84 {
  85         base = (1ull << 63) | (base + offset);
  86         switch (size) {
  87         case 4:
  88                 return cvmx_read64_uint32(base);
  89         case 8:
  90                 return cvmx_read64_uint64(base);
  91         default:
  92                 return 0;
  93         }
  94 }
  95
  96 /*
  97  * Wrapper functions are provided for reading/writing the size and
  98  * next block values as these may not be directly addressible (in 32
  99  * bit applications, for instance.)  Offsets of data elements in
 100  * bootmem list, must match cvmx_bootmem_block_header_t.
 101  */
 102 #define NEXT_OFFSET 0
 103 #define SIZE_OFFSET 8
 104
 105 static void cvmx_bootmem_phy_set_size(uint64_t addr, uint64_t size)
 106 {
 107         cvmx_write64_uint64((addr + SIZE_OFFSET) | (1ull << 63), size);
 108 }
 109
 110 static void cvmx_bootmem_phy_set_next(uint64_t addr, uint64_t next)
 111 {
 112         cvmx_write64_uint64((addr + NEXT_OFFSET) | (1ull << 63), next);
 113 }
 114
 115 static uint64_t cvmx_bootmem_phy_get_size(uint64_t addr)
 116 {
 117         return cvmx_read64_uint64((addr + SIZE_OFFSET) | (1ull << 63));
 118 }
 119
 120 static uint64_t cvmx_bootmem_phy_get_next(uint64_t addr)
 121 {
 122         return cvmx_read64_uint64((addr + NEXT_OFFSET) | (1ull << 63));
 123 }
 124
 125 void *cvmx_bootmem_alloc_range(uint64_t size, uint64_t alignment,
 126                                uint64_t min_addr, uint64_t max_addr)
 127 {
 128         int64_t address;
 129         address =
 130             cvmx_bootmem_phy_alloc(size, min_addr, max_addr, alignment, 0);
 131
 132         if (address > 0)
 133                 return cvmx_phys_to_ptr(address);
 134         else
 135                 return NULL;
 136 }
 137
 138 void *cvmx_bootmem_alloc_address(uint64_t size, uint64_t address,
 139                                  uint64_t alignment)
 140 {
 141         return cvmx_bootmem_alloc_range(size, alignment, address,
 142                                         address + size);
 143 }
 144
 145 void *cvmx_bootmem_alloc(uint64_t size, uint64_t alignment)
 146 {
 147         return cvmx_bootmem_alloc_range(size, alignment, 0, 0);
 148 }
 149
 150 void *cvmx_bootmem_alloc_named_range_once(uint64_t size, uint64_t min_addr,
 151                                           uint64_t max_addr, uint64_t align,
 152                                           char *name,
 153                                           void (*init) (void *))
 154 {
 155         int64_t addr;
 156         void *ptr;
 157         uint64_t named_block_desc_addr;
 158
 159         named_block_desc_addr = (uint64_t)
 160                 cvmx_bootmem_phy_named_block_find(name,
 161                                                   (uint32_t)CVMX_BOOTMEM_FLAG_NO_LOCKING);
 162
 163         if (named_block_desc_addr) {
 164                 addr = CVMX_BOOTMEM_NAMED_GET_FIELD(named_block_desc_addr,
 165                                                     base_addr);
 166                 return cvmx_phys_to_ptr(addr);
 167         }
 168
 169         addr = cvmx_bootmem_phy_named_block_alloc(size, min_addr, max_addr,
 170                                                   align, name,
 171                                                   (uint32_t)CVMX_BOOTMEM_FLAG_NO_LOCKING);
 172
 173         if (addr < 0)
 174                 return NULL;
 175         ptr = cvmx_phys_to_ptr(addr);
 176
 177         if (init)
 178                 init(ptr);
 179         else
 180                 memset(ptr, 0, size);
 181
 182         return ptr;
 183 }
 184 EXPORT_SYMBOL(cvmx_bootmem_alloc_named_range_once);
 185
 186 void *cvmx_bootmem_alloc_named_range(uint64_t size, uint64_t min_addr,
 187                                      uint64_t max_addr, uint64_t align,
 188                                      char *name)
 189 {
 190         int64_t addr;
 191
 192         addr = cvmx_bootmem_phy_named_block_alloc(size, min_addr, max_addr,
 193                                                   align, name, 0);
 194         if (addr >= 0)
 195                 return cvmx_phys_to_ptr(addr);
 196         else
 197                 return NULL;
 198 }
 199
 200 void *cvmx_bootmem_alloc_named_address(uint64_t size, uint64_t address,
 201                                        char *name)
 202 {
 203     return cvmx_bootmem_alloc_named_range(size, address, address + size,
 204                                           0, name);
 205 }
 206
 207 void *cvmx_bootmem_alloc_named(uint64_t size, uint64_t alignment, char *name)
 208 {
 209     return cvmx_bootmem_alloc_named_range(size, 0, 0, alignment, name);
 210 }
 211 EXPORT_SYMBOL(cvmx_bootmem_alloc_named);
 212
 213 int cvmx_bootmem_free_named(char *name)
 214 {
 215         return cvmx_bootmem_phy_named_block_free(name, 0);
 216 }
 217
 218 struct cvmx_bootmem_named_block_desc *cvmx_bootmem_find_named_block(char *name)
 219 {
 220         return cvmx_bootmem_phy_named_block_find(name, 0);
 221 }
 222 EXPORT_SYMBOL(cvmx_bootmem_find_named_block);
 223
 224 void cvmx_bootmem_lock(void)
 225 {
 226         cvmx_spinlock_lock((cvmx_spinlock_t *) &(cvmx_bootmem_desc->lock));
 227 }
 228
 229 void cvmx_bootmem_unlock(void)
 230 {
 231         cvmx_spinlock_unlock((cvmx_spinlock_t *) &(cvmx_bootmem_desc->lock));
 232 }
 233
 234 int cvmx_bootmem_init(void *mem_desc_ptr)
 235 {
 236         /* Here we set the global pointer to the bootmem descriptor
 237          * block.  This pointer will be used directly, so we will set
 238          * it up to be directly usable by the application.  It is set
 239          * up as follows for the various runtime/ABI combinations:
 240          *
 241          * Linux 64 bit: Set XKPHYS bit
 242          * Linux 32 bit: use mmap to create mapping, use virtual address
 243          * CVMX 64 bit:  use physical address directly
 244          * CVMX 32 bit:  use physical address directly
 245          *
 246          * Note that the CVMX environment assumes the use of 1-1 TLB
 247          * mappings so that the physical addresses can be used
 248          * directly
 249          */
 250         if (!cvmx_bootmem_desc) {
 251 #if   defined(CVMX_ABI_64)
 252                 /* Set XKPHYS bit */
 253                 cvmx_bootmem_desc = cvmx_phys_to_ptr(CAST64(mem_desc_ptr));
 254 #else
 255                 cvmx_bootmem_desc = (struct cvmx_bootmem_desc *) mem_desc_ptr;
 256 #endif
 257         }
 258
 259         return 0;
 260 }
 261
 262 /*
 263  * The cvmx_bootmem_phy* functions below return 64 bit physical
 264  * addresses, and expose more features that the cvmx_bootmem_functions
 265  * above.  These are required for full memory space access in 32 bit
 266  * applications, as well as for using some advance features.  Most
 267  * applications should not need to use these.
 268  */
 269
 270 int64_t cvmx_bootmem_phy_alloc(uint64_t req_size, uint64_t address_min,
 271                                uint64_t address_max, uint64_t alignment,
 272                                uint32_t flags)
 273 {
 274
 275         uint64_t head_addr;
 276         uint64_t ent_addr;
 277         /* points to previous list entry, NULL current entry is head of list */
 278         uint64_t prev_addr = 0;
 279         uint64_t new_ent_addr = 0;
 280         uint64_t desired_min_addr;
 281
 282 #ifdef DEBUG
 283         cvmx_dprintf("cvmx_bootmem_phy_alloc: req_size: 0x%llx, "
 284                      "min_addr: 0x%llx, max_addr: 0x%llx, align: 0x%llx\n",
 285                      (unsigned long long)req_size,
 286                      (unsigned long long)address_min,
 287                      (unsigned long long)address_max,
 288                      (unsigned long long)alignment);
 289 #endif
 290
 291         if (cvmx_bootmem_desc->major_version > 3) {
 292                 cvmx_dprintf("ERROR: Incompatible bootmem descriptor "
 293                              "version: %d.%d at addr: %p\n",
 294                              (int)cvmx_bootmem_desc->major_version,
 295                              (int)cvmx_bootmem_desc->minor_version,
 296                              cvmx_bootmem_desc);
 297                 goto error_out;
 298         }
 299
 300         /*
 301          * Do a variety of checks to validate the arguments.  The
 302          * allocator code will later assume that these checks have
 303          * been made.  We validate that the requested constraints are
 304          * not self-contradictory before we look through the list of
 305          * available memory.
 306          */
 307
 308         /* 0 is not a valid req_size for this allocator */
 309         if (!req_size)
 310                 goto error_out;
 311
 312         /* Round req_size up to mult of minimum alignment bytes */
 313         req_size = (req_size + (CVMX_BOOTMEM_ALIGNMENT_SIZE - 1)) &
 314                 ~(CVMX_BOOTMEM_ALIGNMENT_SIZE - 1);
 315
 316         /*
 317          * Convert !0 address_min and 0 address_max to special case of
 318          * range that specifies an exact memory block to allocate.  Do
 319          * this before other checks and adjustments so that this
 320          * tranformation will be validated.
 321          */
 322         if (address_min && !address_max)
 323                 address_max = address_min + req_size;
 324         else if (!address_min && !address_max)
 325                 address_max = ~0ull;  /* If no limits given, use max limits */
 326
 327
 328         /*
 329          * Enforce minimum alignment (this also keeps the minimum free block
 330          * req_size the same as the alignment req_size.
 331          */
 332         if (alignment < CVMX_BOOTMEM_ALIGNMENT_SIZE)
 333                 alignment = CVMX_BOOTMEM_ALIGNMENT_SIZE;
 334
 335         /*
 336          * Adjust address minimum based on requested alignment (round
 337          * up to meet alignment).  Do this here so we can reject
 338          * impossible requests up front. (NOP for address_min == 0)
 339          */
 340         if (alignment)
 341                 address_min = ALIGN(address_min, alignment);
 342
 343         /*
 344          * Reject inconsistent args.  We have adjusted these, so this
 345          * may fail due to our internal changes even if this check
 346          * would pass for the values the user supplied.
 347          */
 348         if (req_size > address_max - address_min)
 349                 goto error_out;
 350
 351         /* Walk through the list entries - first fit found is returned */
 352
 353         if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
 354                 cvmx_bootmem_lock();
 355         head_addr = cvmx_bootmem_desc->head_addr;
 356         ent_addr = head_addr;
 357         for (; ent_addr;
 358              prev_addr = ent_addr,
 359              ent_addr = cvmx_bootmem_phy_get_next(ent_addr)) {
 360                 uint64_t usable_base, usable_max;
 361                 uint64_t ent_size = cvmx_bootmem_phy_get_size(ent_addr);
 362
 363                 if (cvmx_bootmem_phy_get_next(ent_addr)
 364                     && ent_addr > cvmx_bootmem_phy_get_next(ent_addr)) {
 365                         cvmx_dprintf("Internal bootmem_alloc() error: ent: "
 366                                 "0x%llx, next: 0x%llx\n",
 367                                 (unsigned long long)ent_addr,
 368                                 (unsigned long long)
 369                                 cvmx_bootmem_phy_get_next(ent_addr));
 370                         goto error_out;
 371                 }
 372
 373                 /*
 374                  * Determine if this is an entry that can satisify the
 375                  * request Check to make sure entry is large enough to
 376                  * satisfy request.
 377                  */
 378                 usable_base =
 379                     ALIGN(max(address_min, ent_addr), alignment);
 380                 usable_max = min(address_max, ent_addr + ent_size);
 381                 /*
 382                  * We should be able to allocate block at address
 383                  * usable_base.
 384                  */
 385
 386                 desired_min_addr = usable_base;
 387                 /*
 388                  * Determine if request can be satisfied from the
 389                  * current entry.
 390                  */
 391                 if (!((ent_addr + ent_size) > usable_base
 392                                 && ent_addr < address_max
 393                                 && req_size <= usable_max - usable_base))
 394                         continue;
 395                 /*
 396                  * We have found an entry that has room to satisfy the
 397                  * request, so allocate it from this entry.  If end
 398                  * CVMX_BOOTMEM_FLAG_END_ALLOC set, then allocate from
 399                  * the end of this block rather than the beginning.
 400                  */
 401                 if (flags & CVMX_BOOTMEM_FLAG_END_ALLOC) {
 402                         desired_min_addr = usable_max - req_size;
 403                         /*
 404                          * Align desired address down to required
 405                          * alignment.
 406                          */
 407                         desired_min_addr &= ~(alignment - 1);
 408                 }
 409
 410                 /* Match at start of entry */
 411                 if (desired_min_addr == ent_addr) {
 412                         if (req_size < ent_size) {
 413                                 /*
 414                                  * big enough to create a new block
 415                                  * from top portion of block.
 416                                  */
 417                                 new_ent_addr = ent_addr + req_size;
 418                                 cvmx_bootmem_phy_set_next(new_ent_addr,
 419                                         cvmx_bootmem_phy_get_next(ent_addr));
 420                                 cvmx_bootmem_phy_set_size(new_ent_addr,
 421                                                         ent_size -
 422                                                         req_size);
 423
 424                                 /*
 425                                  * Adjust next pointer as following
 426                                  * code uses this.
 427                                  */
 428                                 cvmx_bootmem_phy_set_next(ent_addr,
 429                                                         new_ent_addr);
 430                         }
 431
 432                         /*
 433                          * adjust prev ptr or head to remove this
 434                          * entry from list.
 435                          */
 436                         if (prev_addr)
 437                                 cvmx_bootmem_phy_set_next(prev_addr,
 438                                         cvmx_bootmem_phy_get_next(ent_addr));
 439                         else
 440                                 /*
 441                                  * head of list being returned, so
 442                                  * update head ptr.
 443                                  */
 444                                 cvmx_bootmem_desc->head_addr =
 445                                         cvmx_bootmem_phy_get_next(ent_addr);
 446
 447                         if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
 448                                 cvmx_bootmem_unlock();
 449                         return desired_min_addr;
 450                 }
 451                 /*
 452                  * block returned doesn't start at beginning of entry,
 453                  * so we know that we will be splitting a block off
 454                  * the front of this one.  Create a new block from the
 455                  * beginning, add to list, and go to top of loop
 456                  * again.
 457                  *
 458                  * create new block from high portion of
 459                  * block, so that top block starts at desired
 460                  * addr.
 461                  */
 462                 new_ent_addr = desired_min_addr;
 463                 cvmx_bootmem_phy_set_next(new_ent_addr,
 464                                         cvmx_bootmem_phy_get_next
 465                                         (ent_addr));
 466                 cvmx_bootmem_phy_set_size(new_ent_addr,
 467                                         cvmx_bootmem_phy_get_size
 468                                         (ent_addr) -
 469                                         (desired_min_addr -
 470                                                 ent_addr));
 471                 cvmx_bootmem_phy_set_size(ent_addr,
 472                                         desired_min_addr - ent_addr);
 473                 cvmx_bootmem_phy_set_next(ent_addr, new_ent_addr);
 474                 /* Loop again to handle actual alloc from new block */
 475         }
 476 error_out:
 477         /* We didn't find anything, so return error */
 478         if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
 479                 cvmx_bootmem_unlock();
 480         return -1;
 481 }
 482
 483 int __cvmx_bootmem_phy_free(uint64_t phy_addr, uint64_t size, uint32_t flags)
 484 {
 485         uint64_t cur_addr;
 486         uint64_t prev_addr = 0; /* zero is invalid */
 487         int retval = 0;
 488
 489 #ifdef DEBUG
 490         cvmx_dprintf("__cvmx_bootmem_phy_free addr: 0x%llx, size: 0x%llx\n",
 491                      (unsigned long long)phy_addr, (unsigned long long)size);
 492 #endif
 493         if (cvmx_bootmem_desc->major_version > 3) {
 494                 cvmx_dprintf("ERROR: Incompatible bootmem descriptor "
 495                              "version: %d.%d at addr: %p\n",
 496                              (int)cvmx_bootmem_desc->major_version,
 497                              (int)cvmx_bootmem_desc->minor_version,
 498                              cvmx_bootmem_desc);
 499                 return 0;
 500         }
 501
 502         /* 0 is not a valid size for this allocator */
 503         if (!size)
 504                 return 0;
 505
 506         if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
 507                 cvmx_bootmem_lock();
 508         cur_addr = cvmx_bootmem_desc->head_addr;
 509         if (cur_addr == 0 || phy_addr < cur_addr) {
 510                 /* add at front of list - special case with changing head ptr */
 511                 if (cur_addr && phy_addr + size > cur_addr)
 512                         goto bootmem_free_done; /* error, overlapping section */
 513                 else if (phy_addr + size == cur_addr) {
 514                         /* Add to front of existing first block */
 515                         cvmx_bootmem_phy_set_next(phy_addr,
 516                                                   cvmx_bootmem_phy_get_next
 517                                                   (cur_addr));
 518                         cvmx_bootmem_phy_set_size(phy_addr,
 519                                                   cvmx_bootmem_phy_get_size
 520                                                   (cur_addr) + size);
 521                         cvmx_bootmem_desc->head_addr = phy_addr;
 522
 523                 } else {
 524                         /* New block before first block.  OK if cur_addr is 0 */
 525                         cvmx_bootmem_phy_set_next(phy_addr, cur_addr);
 526                         cvmx_bootmem_phy_set_size(phy_addr, size);
 527                         cvmx_bootmem_desc->head_addr = phy_addr;
 528                 }
 529                 retval = 1;
 530                 goto bootmem_free_done;
 531         }
 532
 533         /* Find place in list to add block */
 534         while (cur_addr && phy_addr > cur_addr) {
 535                 prev_addr = cur_addr;
 536                 cur_addr = cvmx_bootmem_phy_get_next(cur_addr);
 537         }
 538
 539         if (!cur_addr) {
 540                 /*
 541                  * We have reached the end of the list, add on to end,
 542                  * checking to see if we need to combine with last
 543                  * block
 544                  */
 545                 if (prev_addr + cvmx_bootmem_phy_get_size(prev_addr) ==
 546                     phy_addr) {
 547                         cvmx_bootmem_phy_set_size(prev_addr,
 548                                                   cvmx_bootmem_phy_get_size
 549                                                   (prev_addr) + size);
 550                 } else {
 551                         cvmx_bootmem_phy_set_next(prev_addr, phy_addr);
 552                         cvmx_bootmem_phy_set_size(phy_addr, size);
 553                         cvmx_bootmem_phy_set_next(phy_addr, 0);
 554                 }
 555                 retval = 1;
 556                 goto bootmem_free_done;
 557         } else {
 558                 /*
 559                  * insert between prev and cur nodes, checking for
 560                  * merge with either/both.
 561                  */
 562                 if (prev_addr + cvmx_bootmem_phy_get_size(prev_addr) ==
 563                     phy_addr) {
 564                         /* Merge with previous */
 565                         cvmx_bootmem_phy_set_size(prev_addr,
 566                                                   cvmx_bootmem_phy_get_size
 567                                                   (prev_addr) + size);
 568                         if (phy_addr + size == cur_addr) {
 569                                 /* Also merge with current */
 570                                 cvmx_bootmem_phy_set_size(prev_addr,
 571                                         cvmx_bootmem_phy_get_size(cur_addr) +
 572                                         cvmx_bootmem_phy_get_size(prev_addr));
 573                                 cvmx_bootmem_phy_set_next(prev_addr,
 574                                         cvmx_bootmem_phy_get_next(cur_addr));
 575                         }
 576                         retval = 1;
 577                         goto bootmem_free_done;
 578                 } else if (phy_addr + size == cur_addr) {
 579                         /* Merge with current */
 580                         cvmx_bootmem_phy_set_size(phy_addr,
 581                                                   cvmx_bootmem_phy_get_size
 582                                                   (cur_addr) + size);
 583                         cvmx_bootmem_phy_set_next(phy_addr,
 584                                                   cvmx_bootmem_phy_get_next
 585                                                   (cur_addr));
 586                         cvmx_bootmem_phy_set_next(prev_addr, phy_addr);
 587                         retval = 1;
 588                         goto bootmem_free_done;
 589                 }
 590
 591                 /* It is a standalone block, add in between prev and cur */
 592                 cvmx_bootmem_phy_set_size(phy_addr, size);
 593                 cvmx_bootmem_phy_set_next(phy_addr, cur_addr);
 594                 cvmx_bootmem_phy_set_next(prev_addr, phy_addr);
 595
 596         }
 597         retval = 1;
 598
 599 bootmem_free_done:
 600         if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
 601                 cvmx_bootmem_unlock();
 602         return retval;
 603
 604 }
 605
 606 struct cvmx_bootmem_named_block_desc *
 607         cvmx_bootmem_phy_named_block_find(char *name, uint32_t flags)
 608 {
 609         unsigned int i;
 610         struct cvmx_bootmem_named_block_desc *named_block_array_ptr;
 611
 612 #ifdef DEBUG
 613         cvmx_dprintf("cvmx_bootmem_phy_named_block_find: %s\n", name);
 614 #endif
 615         /*
 616          * Lock the structure to make sure that it is not being
 617          * changed while we are examining it.
 618          */
 619         if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
 620                 cvmx_bootmem_lock();
 621
 622         /* Use XKPHYS for 64 bit linux */
 623         named_block_array_ptr = (struct cvmx_bootmem_named_block_desc *)
 624             cvmx_phys_to_ptr(cvmx_bootmem_desc->named_block_array_addr);
 625
 626 #ifdef DEBUG
 627         cvmx_dprintf
 628             ("cvmx_bootmem_phy_named_block_find: named_block_array_ptr: %p\n",
 629              named_block_array_ptr);
 630 #endif
 631         if (cvmx_bootmem_desc->major_version == 3) {
 632                 for (i = 0;
 633                      i < cvmx_bootmem_desc->named_block_num_blocks; i++) {
 634                         if ((name && named_block_array_ptr[i].size
 635                              && !strncmp(name, named_block_array_ptr[i].name,
 636                                          cvmx_bootmem_desc->named_block_name_len
 637                                          - 1))
 638                             || (!name && !named_block_array_ptr[i].size)) {
 639                                 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
 640                                         cvmx_bootmem_unlock();
 641
 642                                 return &(named_block_array_ptr[i]);
 643                         }
 644                 }
 645         } else {
 646                 cvmx_dprintf("ERROR: Incompatible bootmem descriptor "
 647                              "version: %d.%d at addr: %p\n",
 648                              (int)cvmx_bootmem_desc->major_version,
 649                              (int)cvmx_bootmem_desc->minor_version,
 650                              cvmx_bootmem_desc);
 651         }
 652         if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
 653                 cvmx_bootmem_unlock();
 654
 655         return NULL;
 656 }
 657
 658 int cvmx_bootmem_phy_named_block_free(char *name, uint32_t flags)
 659 {
 660         struct cvmx_bootmem_named_block_desc *named_block_ptr;
 661
 662         if (cvmx_bootmem_desc->major_version != 3) {
 663                 cvmx_dprintf("ERROR: Incompatible bootmem descriptor version: "
 664                              "%d.%d at addr: %p\n",
 665                              (int)cvmx_bootmem_desc->major_version,
 666                              (int)cvmx_bootmem_desc->minor_version,
 667                              cvmx_bootmem_desc);
 668                 return 0;
 669         }
 670 #ifdef DEBUG
 671         cvmx_dprintf("cvmx_bootmem_phy_named_block_free: %s\n", name);
 672 #endif
 673
 674         /*
 675          * Take lock here, as name lookup/block free/name free need to
 676          * be atomic.
 677          */
 678         cvmx_bootmem_lock();
 679
 680         named_block_ptr =
 681             cvmx_bootmem_phy_named_block_find(name,
 682                                               CVMX_BOOTMEM_FLAG_NO_LOCKING);
 683         if (named_block_ptr) {
 684 #ifdef DEBUG
 685                 cvmx_dprintf("cvmx_bootmem_phy_named_block_free: "
 686                              "%s, base: 0x%llx, size: 0x%llx\n",
 687                              name,
 688                              (unsigned long long)named_block_ptr->base_addr,
 689                              (unsigned long long)named_block_ptr->size);
 690 #endif
 691                 __cvmx_bootmem_phy_free(named_block_ptr->base_addr,
 692                                         named_block_ptr->size,
 693                                         CVMX_BOOTMEM_FLAG_NO_LOCKING);
 694                 named_block_ptr->size = 0;
 695                 /* Set size to zero to indicate block not used. */
 696         }
 697
 698         cvmx_bootmem_unlock();
 699         return named_block_ptr != NULL; /* 0 on failure, 1 on success */
 700 }
 701
 702 int64_t cvmx_bootmem_phy_named_block_alloc(uint64_t size, uint64_t min_addr,
 703                                            uint64_t max_addr,
 704                                            uint64_t alignment,
 705                                            char *name,
 706                                            uint32_t flags)
 707 {
 708         int64_t addr_allocated;
 709         struct cvmx_bootmem_named_block_desc *named_block_desc_ptr;
 710
 711 #ifdef DEBUG
 712         cvmx_dprintf("cvmx_bootmem_phy_named_block_alloc: size: 0x%llx, min: "
 713                      "0x%llx, max: 0x%llx, align: 0x%llx, name: %s\n",
 714                      (unsigned long long)size,
 715                      (unsigned long long)min_addr,
 716                      (unsigned long long)max_addr,
 717                      (unsigned long long)alignment,
 718                      name);
 719 #endif
 720         if (cvmx_bootmem_desc->major_version != 3) {
 721                 cvmx_dprintf("ERROR: Incompatible bootmem descriptor version: "
 722                              "%d.%d at addr: %p\n",
 723                              (int)cvmx_bootmem_desc->major_version,
 724                              (int)cvmx_bootmem_desc->minor_version,
 725                              cvmx_bootmem_desc);
 726                 return -1;
 727         }
 728
 729         /*
 730          * Take lock here, as name lookup/block alloc/name add need to
 731          * be atomic.
 732          */
 733         if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
 734                 cvmx_spinlock_lock((cvmx_spinlock_t *)&(cvmx_bootmem_desc->lock));
 735
 736         /* Get pointer to first available named block descriptor */
 737         named_block_desc_ptr =
 738                 cvmx_bootmem_phy_named_block_find(NULL,
 739                                                   flags | CVMX_BOOTMEM_FLAG_NO_LOCKING);
 740
 741         /*
 742          * Check to see if name already in use, return error if name
 743          * not available or no more room for blocks.
 744          */
 745         if (cvmx_bootmem_phy_named_block_find(name,
 746                                               flags | CVMX_BOOTMEM_FLAG_NO_LOCKING) || !named_block_desc_ptr) {
 747                 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
 748                         cvmx_spinlock_unlock((cvmx_spinlock_t *)&(cvmx_bootmem_desc->lock));
 749                 return -1;
 750         }
 751
 752
 753         /*
 754          * Round size up to mult of minimum alignment bytes We need
 755          * the actual size allocated to allow for blocks to be
 756          * coalesced when they are freed. The alloc routine does the
 757          * same rounding up on all allocations.
 758          */
 759         size = ALIGN(size, CVMX_BOOTMEM_ALIGNMENT_SIZE);
 760
 761         addr_allocated = cvmx_bootmem_phy_alloc(size, min_addr, max_addr,
 762                                                 alignment,
 763                                                 flags | CVMX_BOOTMEM_FLAG_NO_LOCKING);
 764         if (addr_allocated >= 0) {
 765                 named_block_desc_ptr->base_addr = addr_allocated;
 766                 named_block_desc_ptr->size = size;
 767                 strncpy(named_block_desc_ptr->name, name,
 768                         cvmx_bootmem_desc->named_block_name_len);
 769                 named_block_desc_ptr->name[cvmx_bootmem_desc->named_block_name_len - 1] = 0;
 770         }
 771
 772         if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
 773                 cvmx_spinlock_unlock((cvmx_spinlock_t *)&(cvmx_bootmem_desc->lock));
 774         return addr_allocated;
 775 }
 776
 777 struct cvmx_bootmem_desc *cvmx_bootmem_get_desc(void)
 778 {
 779         return cvmx_bootmem_desc;
 780 }