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 /** 126 * Allocate a block of memory from the free list that was 127 * passed to the application by the bootloader within a specified 128 * address range. This is an allocate-only algorithm, so 129 * freeing memory is not possible. Allocation will fail if 130 * memory cannot be allocated in the requested range. 131 * 132 * @size: Size in bytes of block to allocate 133 * @min_addr: defines the minimum address of the range 134 * @max_addr: defines the maximum address of the range 135 * @alignment: Alignment required - must be power of 2 136 * Returns pointer to block of memory, NULL on error 137 */ 138 static void *cvmx_bootmem_alloc_range(uint64_t size, uint64_t alignment, 139 uint64_t min_addr, uint64_t max_addr) 140 { 141 int64_t address; 142 address = 143 cvmx_bootmem_phy_alloc(size, min_addr, max_addr, alignment, 0); 144 145 if (address > 0) 146 return cvmx_phys_to_ptr(address); 147 else 148 return NULL; 149 } 150 151 void *cvmx_bootmem_alloc_address(uint64_t size, uint64_t address, 152 uint64_t alignment) 153 { 154 return cvmx_bootmem_alloc_range(size, alignment, address, 155 address + size); 156 } 157 158 void *cvmx_bootmem_alloc_named_range(uint64_t size, uint64_t min_addr, 159 uint64_t max_addr, uint64_t align, 160 char *name) 161 { 162 int64_t addr; 163 164 addr = cvmx_bootmem_phy_named_block_alloc(size, min_addr, max_addr, 165 align, name, 0); 166 if (addr >= 0) 167 return cvmx_phys_to_ptr(addr); 168 else 169 return NULL; 170 } 171 172 void *cvmx_bootmem_alloc_named(uint64_t size, uint64_t alignment, char *name) 173 { 174 return cvmx_bootmem_alloc_named_range(size, 0, 0, alignment, name); 175 } 176 EXPORT_SYMBOL(cvmx_bootmem_alloc_named); 177 178 void cvmx_bootmem_lock(void) 179 { 180 cvmx_spinlock_lock((cvmx_spinlock_t *) &(cvmx_bootmem_desc->lock)); 181 } 182 183 void cvmx_bootmem_unlock(void) 184 { 185 cvmx_spinlock_unlock((cvmx_spinlock_t *) &(cvmx_bootmem_desc->lock)); 186 } 187 188 int cvmx_bootmem_init(void *mem_desc_ptr) 189 { 190 /* Here we set the global pointer to the bootmem descriptor 191 * block. This pointer will be used directly, so we will set 192 * it up to be directly usable by the application. It is set 193 * up as follows for the various runtime/ABI combinations: 194 * 195 * Linux 64 bit: Set XKPHYS bit 196 * Linux 32 bit: use mmap to create mapping, use virtual address 197 * CVMX 64 bit: use physical address directly 198 * CVMX 32 bit: use physical address directly 199 * 200 * Note that the CVMX environment assumes the use of 1-1 TLB 201 * mappings so that the physical addresses can be used 202 * directly 203 */ 204 if (!cvmx_bootmem_desc) { 205 #if defined(CVMX_ABI_64) 206 /* Set XKPHYS bit */ 207 cvmx_bootmem_desc = cvmx_phys_to_ptr(CAST64(mem_desc_ptr)); 208 #else 209 cvmx_bootmem_desc = (struct cvmx_bootmem_desc *) mem_desc_ptr; 210 #endif 211 } 212 213 return 0; 214 } 215 216 /* 217 * The cvmx_bootmem_phy* functions below return 64 bit physical 218 * addresses, and expose more features that the cvmx_bootmem_functions 219 * above. These are required for full memory space access in 32 bit 220 * applications, as well as for using some advance features. Most 221 * applications should not need to use these. 222 */ 223 224 int64_t cvmx_bootmem_phy_alloc(uint64_t req_size, uint64_t address_min, 225 uint64_t address_max, uint64_t alignment, 226 uint32_t flags) 227 { 228 229 uint64_t head_addr; 230 uint64_t ent_addr; 231 /* points to previous list entry, NULL current entry is head of list */ 232 uint64_t prev_addr = 0; 233 uint64_t new_ent_addr = 0; 234 uint64_t desired_min_addr; 235 236 #ifdef DEBUG 237 cvmx_dprintf("cvmx_bootmem_phy_alloc: req_size: 0x%llx, " 238 "min_addr: 0x%llx, max_addr: 0x%llx, align: 0x%llx\n", 239 (unsigned long long)req_size, 240 (unsigned long long)address_min, 241 (unsigned long long)address_max, 242 (unsigned long long)alignment); 243 #endif 244 245 if (cvmx_bootmem_desc->major_version > 3) { 246 cvmx_dprintf("ERROR: Incompatible bootmem descriptor " 247 "version: %d.%d at addr: %p\n", 248 (int)cvmx_bootmem_desc->major_version, 249 (int)cvmx_bootmem_desc->minor_version, 250 cvmx_bootmem_desc); 251 goto error_out; 252 } 253 254 /* 255 * Do a variety of checks to validate the arguments. The 256 * allocator code will later assume that these checks have 257 * been made. We validate that the requested constraints are 258 * not self-contradictory before we look through the list of 259 * available memory. 260 */ 261 262 /* 0 is not a valid req_size for this allocator */ 263 if (!req_size) 264 goto error_out; 265 266 /* Round req_size up to mult of minimum alignment bytes */ 267 req_size = (req_size + (CVMX_BOOTMEM_ALIGNMENT_SIZE - 1)) & 268 ~(CVMX_BOOTMEM_ALIGNMENT_SIZE - 1); 269 270 /* 271 * Convert !0 address_min and 0 address_max to special case of 272 * range that specifies an exact memory block to allocate. Do 273 * this before other checks and adjustments so that this 274 * tranformation will be validated. 275 */ 276 if (address_min && !address_max) 277 address_max = address_min + req_size; 278 else if (!address_min && !address_max) 279 address_max = ~0ull; /* If no limits given, use max limits */ 280 281 282 /* 283 * Enforce minimum alignment (this also keeps the minimum free block 284 * req_size the same as the alignment req_size. 285 */ 286 if (alignment < CVMX_BOOTMEM_ALIGNMENT_SIZE) 287 alignment = CVMX_BOOTMEM_ALIGNMENT_SIZE; 288 289 /* 290 * Adjust address minimum based on requested alignment (round 291 * up to meet alignment). Do this here so we can reject 292 * impossible requests up front. (NOP for address_min == 0) 293 */ 294 if (alignment) 295 address_min = ALIGN(address_min, alignment); 296 297 /* 298 * Reject inconsistent args. We have adjusted these, so this 299 * may fail due to our internal changes even if this check 300 * would pass for the values the user supplied. 301 */ 302 if (req_size > address_max - address_min) 303 goto error_out; 304 305 /* Walk through the list entries - first fit found is returned */ 306 307 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING)) 308 cvmx_bootmem_lock(); 309 head_addr = cvmx_bootmem_desc->head_addr; 310 ent_addr = head_addr; 311 for (; ent_addr; 312 prev_addr = ent_addr, 313 ent_addr = cvmx_bootmem_phy_get_next(ent_addr)) { 314 uint64_t usable_base, usable_max; 315 uint64_t ent_size = cvmx_bootmem_phy_get_size(ent_addr); 316 317 if (cvmx_bootmem_phy_get_next(ent_addr) 318 && ent_addr > cvmx_bootmem_phy_get_next(ent_addr)) { 319 cvmx_dprintf("Internal bootmem_alloc() error: ent: " 320 "0x%llx, next: 0x%llx\n", 321 (unsigned long long)ent_addr, 322 (unsigned long long) 323 cvmx_bootmem_phy_get_next(ent_addr)); 324 goto error_out; 325 } 326 327 /* 328 * Determine if this is an entry that can satisify the 329 * request Check to make sure entry is large enough to 330 * satisfy request. 331 */ 332 usable_base = 333 ALIGN(max(address_min, ent_addr), alignment); 334 usable_max = min(address_max, ent_addr + ent_size); 335 /* 336 * We should be able to allocate block at address 337 * usable_base. 338 */ 339 340 desired_min_addr = usable_base; 341 /* 342 * Determine if request can be satisfied from the 343 * current entry. 344 */ 345 if (!((ent_addr + ent_size) > usable_base 346 && ent_addr < address_max 347 && req_size <= usable_max - usable_base)) 348 continue; 349 /* 350 * We have found an entry that has room to satisfy the 351 * request, so allocate it from this entry. If end 352 * CVMX_BOOTMEM_FLAG_END_ALLOC set, then allocate from 353 * the end of this block rather than the beginning. 354 */ 355 if (flags & CVMX_BOOTMEM_FLAG_END_ALLOC) { 356 desired_min_addr = usable_max - req_size; 357 /* 358 * Align desired address down to required 359 * alignment. 360 */ 361 desired_min_addr &= ~(alignment - 1); 362 } 363 364 /* Match at start of entry */ 365 if (desired_min_addr == ent_addr) { 366 if (req_size < ent_size) { 367 /* 368 * big enough to create a new block 369 * from top portion of block. 370 */ 371 new_ent_addr = ent_addr + req_size; 372 cvmx_bootmem_phy_set_next(new_ent_addr, 373 cvmx_bootmem_phy_get_next(ent_addr)); 374 cvmx_bootmem_phy_set_size(new_ent_addr, 375 ent_size - 376 req_size); 377 378 /* 379 * Adjust next pointer as following 380 * code uses this. 381 */ 382 cvmx_bootmem_phy_set_next(ent_addr, 383 new_ent_addr); 384 } 385 386 /* 387 * adjust prev ptr or head to remove this 388 * entry from list. 389 */ 390 if (prev_addr) 391 cvmx_bootmem_phy_set_next(prev_addr, 392 cvmx_bootmem_phy_get_next(ent_addr)); 393 else 394 /* 395 * head of list being returned, so 396 * update head ptr. 397 */ 398 cvmx_bootmem_desc->head_addr = 399 cvmx_bootmem_phy_get_next(ent_addr); 400 401 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING)) 402 cvmx_bootmem_unlock(); 403 return desired_min_addr; 404 } 405 /* 406 * block returned doesn't start at beginning of entry, 407 * so we know that we will be splitting a block off 408 * the front of this one. Create a new block from the 409 * beginning, add to list, and go to top of loop 410 * again. 411 * 412 * create new block from high portion of 413 * block, so that top block starts at desired 414 * addr. 415 */ 416 new_ent_addr = desired_min_addr; 417 cvmx_bootmem_phy_set_next(new_ent_addr, 418 cvmx_bootmem_phy_get_next 419 (ent_addr)); 420 cvmx_bootmem_phy_set_size(new_ent_addr, 421 cvmx_bootmem_phy_get_size 422 (ent_addr) - 423 (desired_min_addr - 424 ent_addr)); 425 cvmx_bootmem_phy_set_size(ent_addr, 426 desired_min_addr - ent_addr); 427 cvmx_bootmem_phy_set_next(ent_addr, new_ent_addr); 428 /* Loop again to handle actual alloc from new block */ 429 } 430 error_out: 431 /* We didn't find anything, so return error */ 432 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING)) 433 cvmx_bootmem_unlock(); 434 return -1; 435 } 436 437 int __cvmx_bootmem_phy_free(uint64_t phy_addr, uint64_t size, uint32_t flags) 438 { 439 uint64_t cur_addr; 440 uint64_t prev_addr = 0; /* zero is invalid */ 441 int retval = 0; 442 443 #ifdef DEBUG 444 cvmx_dprintf("__cvmx_bootmem_phy_free addr: 0x%llx, size: 0x%llx\n", 445 (unsigned long long)phy_addr, (unsigned long long)size); 446 #endif 447 if (cvmx_bootmem_desc->major_version > 3) { 448 cvmx_dprintf("ERROR: Incompatible bootmem descriptor " 449 "version: %d.%d at addr: %p\n", 450 (int)cvmx_bootmem_desc->major_version, 451 (int)cvmx_bootmem_desc->minor_version, 452 cvmx_bootmem_desc); 453 return 0; 454 } 455 456 /* 0 is not a valid size for this allocator */ 457 if (!size) 458 return 0; 459 460 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING)) 461 cvmx_bootmem_lock(); 462 cur_addr = cvmx_bootmem_desc->head_addr; 463 if (cur_addr == 0 || phy_addr < cur_addr) { 464 /* add at front of list - special case with changing head ptr */ 465 if (cur_addr && phy_addr + size > cur_addr) 466 goto bootmem_free_done; /* error, overlapping section */ 467 else if (phy_addr + size == cur_addr) { 468 /* Add to front of existing first block */ 469 cvmx_bootmem_phy_set_next(phy_addr, 470 cvmx_bootmem_phy_get_next 471 (cur_addr)); 472 cvmx_bootmem_phy_set_size(phy_addr, 473 cvmx_bootmem_phy_get_size 474 (cur_addr) + size); 475 cvmx_bootmem_desc->head_addr = phy_addr; 476 477 } else { 478 /* New block before first block. OK if cur_addr is 0 */ 479 cvmx_bootmem_phy_set_next(phy_addr, cur_addr); 480 cvmx_bootmem_phy_set_size(phy_addr, size); 481 cvmx_bootmem_desc->head_addr = phy_addr; 482 } 483 retval = 1; 484 goto bootmem_free_done; 485 } 486 487 /* Find place in list to add block */ 488 while (cur_addr && phy_addr > cur_addr) { 489 prev_addr = cur_addr; 490 cur_addr = cvmx_bootmem_phy_get_next(cur_addr); 491 } 492 493 if (!cur_addr) { 494 /* 495 * We have reached the end of the list, add on to end, 496 * checking to see if we need to combine with last 497 * block 498 */ 499 if (prev_addr + cvmx_bootmem_phy_get_size(prev_addr) == 500 phy_addr) { 501 cvmx_bootmem_phy_set_size(prev_addr, 502 cvmx_bootmem_phy_get_size 503 (prev_addr) + size); 504 } else { 505 cvmx_bootmem_phy_set_next(prev_addr, phy_addr); 506 cvmx_bootmem_phy_set_size(phy_addr, size); 507 cvmx_bootmem_phy_set_next(phy_addr, 0); 508 } 509 retval = 1; 510 goto bootmem_free_done; 511 } else { 512 /* 513 * insert between prev and cur nodes, checking for 514 * merge with either/both. 515 */ 516 if (prev_addr + cvmx_bootmem_phy_get_size(prev_addr) == 517 phy_addr) { 518 /* Merge with previous */ 519 cvmx_bootmem_phy_set_size(prev_addr, 520 cvmx_bootmem_phy_get_size 521 (prev_addr) + size); 522 if (phy_addr + size == cur_addr) { 523 /* Also merge with current */ 524 cvmx_bootmem_phy_set_size(prev_addr, 525 cvmx_bootmem_phy_get_size(cur_addr) + 526 cvmx_bootmem_phy_get_size(prev_addr)); 527 cvmx_bootmem_phy_set_next(prev_addr, 528 cvmx_bootmem_phy_get_next(cur_addr)); 529 } 530 retval = 1; 531 goto bootmem_free_done; 532 } else if (phy_addr + size == cur_addr) { 533 /* Merge with current */ 534 cvmx_bootmem_phy_set_size(phy_addr, 535 cvmx_bootmem_phy_get_size 536 (cur_addr) + size); 537 cvmx_bootmem_phy_set_next(phy_addr, 538 cvmx_bootmem_phy_get_next 539 (cur_addr)); 540 cvmx_bootmem_phy_set_next(prev_addr, phy_addr); 541 retval = 1; 542 goto bootmem_free_done; 543 } 544 545 /* It is a standalone block, add in between prev and cur */ 546 cvmx_bootmem_phy_set_size(phy_addr, size); 547 cvmx_bootmem_phy_set_next(phy_addr, cur_addr); 548 cvmx_bootmem_phy_set_next(prev_addr, phy_addr); 549 550 } 551 retval = 1; 552 553 bootmem_free_done: 554 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING)) 555 cvmx_bootmem_unlock(); 556 return retval; 557 558 } 559 560 /** 561 * Finds a named memory block by name. 562 * Also used for finding an unused entry in the named block table. 563 * 564 * @name: Name of memory block to find. If NULL pointer given, then 565 * finds unused descriptor, if available. 566 * 567 * @flags: Flags to control options for the allocation. 568 * 569 * Returns Pointer to memory block descriptor, NULL if not found. 570 * If NULL returned when name parameter is NULL, then no memory 571 * block descriptors are available. 572 */ 573 static struct cvmx_bootmem_named_block_desc * 574 cvmx_bootmem_phy_named_block_find(char *name, uint32_t flags) 575 { 576 unsigned int i; 577 struct cvmx_bootmem_named_block_desc *named_block_array_ptr; 578 579 #ifdef DEBUG 580 cvmx_dprintf("cvmx_bootmem_phy_named_block_find: %s\n", name); 581 #endif 582 /* 583 * Lock the structure to make sure that it is not being 584 * changed while we are examining it. 585 */ 586 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING)) 587 cvmx_bootmem_lock(); 588 589 /* Use XKPHYS for 64 bit linux */ 590 named_block_array_ptr = (struct cvmx_bootmem_named_block_desc *) 591 cvmx_phys_to_ptr(cvmx_bootmem_desc->named_block_array_addr); 592 593 #ifdef DEBUG 594 cvmx_dprintf 595 ("cvmx_bootmem_phy_named_block_find: named_block_array_ptr: %p\n", 596 named_block_array_ptr); 597 #endif 598 if (cvmx_bootmem_desc->major_version == 3) { 599 for (i = 0; 600 i < cvmx_bootmem_desc->named_block_num_blocks; i++) { 601 if ((name && named_block_array_ptr[i].size 602 && !strncmp(name, named_block_array_ptr[i].name, 603 cvmx_bootmem_desc->named_block_name_len 604 - 1)) 605 || (!name && !named_block_array_ptr[i].size)) { 606 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING)) 607 cvmx_bootmem_unlock(); 608 609 return &(named_block_array_ptr[i]); 610 } 611 } 612 } else { 613 cvmx_dprintf("ERROR: Incompatible bootmem descriptor " 614 "version: %d.%d at addr: %p\n", 615 (int)cvmx_bootmem_desc->major_version, 616 (int)cvmx_bootmem_desc->minor_version, 617 cvmx_bootmem_desc); 618 } 619 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING)) 620 cvmx_bootmem_unlock(); 621 622 return NULL; 623 } 624 625 void *cvmx_bootmem_alloc_named_range_once(uint64_t size, uint64_t min_addr, 626 uint64_t max_addr, uint64_t align, 627 char *name, 628 void (*init) (void *)) 629 { 630 int64_t addr; 631 void *ptr; 632 uint64_t named_block_desc_addr; 633 634 named_block_desc_addr = (uint64_t) 635 cvmx_bootmem_phy_named_block_find(name, 636 (uint32_t)CVMX_BOOTMEM_FLAG_NO_LOCKING); 637 638 if (named_block_desc_addr) { 639 addr = CVMX_BOOTMEM_NAMED_GET_FIELD(named_block_desc_addr, 640 base_addr); 641 return cvmx_phys_to_ptr(addr); 642 } 643 644 addr = cvmx_bootmem_phy_named_block_alloc(size, min_addr, max_addr, 645 align, name, 646 (uint32_t)CVMX_BOOTMEM_FLAG_NO_LOCKING); 647 648 if (addr < 0) 649 return NULL; 650 ptr = cvmx_phys_to_ptr(addr); 651 652 if (init) 653 init(ptr); 654 else 655 memset(ptr, 0, size); 656 657 return ptr; 658 } 659 EXPORT_SYMBOL(cvmx_bootmem_alloc_named_range_once); 660 661 struct cvmx_bootmem_named_block_desc *cvmx_bootmem_find_named_block(char *name) 662 { 663 return cvmx_bootmem_phy_named_block_find(name, 0); 664 } 665 EXPORT_SYMBOL(cvmx_bootmem_find_named_block); 666 667 /** 668 * Frees a named block. 669 * 670 * @name: name of block to free 671 * @flags: flags for passing options 672 * 673 * Returns 0 on failure 674 * 1 on success 675 */ 676 static int cvmx_bootmem_phy_named_block_free(char *name, uint32_t flags) 677 { 678 struct cvmx_bootmem_named_block_desc *named_block_ptr; 679 680 if (cvmx_bootmem_desc->major_version != 3) { 681 cvmx_dprintf("ERROR: Incompatible bootmem descriptor version: " 682 "%d.%d at addr: %p\n", 683 (int)cvmx_bootmem_desc->major_version, 684 (int)cvmx_bootmem_desc->minor_version, 685 cvmx_bootmem_desc); 686 return 0; 687 } 688 #ifdef DEBUG 689 cvmx_dprintf("cvmx_bootmem_phy_named_block_free: %s\n", name); 690 #endif 691 692 /* 693 * Take lock here, as name lookup/block free/name free need to 694 * be atomic. 695 */ 696 cvmx_bootmem_lock(); 697 698 named_block_ptr = 699 cvmx_bootmem_phy_named_block_find(name, 700 CVMX_BOOTMEM_FLAG_NO_LOCKING); 701 if (named_block_ptr) { 702 #ifdef DEBUG 703 cvmx_dprintf("cvmx_bootmem_phy_named_block_free: " 704 "%s, base: 0x%llx, size: 0x%llx\n", 705 name, 706 (unsigned long long)named_block_ptr->base_addr, 707 (unsigned long long)named_block_ptr->size); 708 #endif 709 __cvmx_bootmem_phy_free(named_block_ptr->base_addr, 710 named_block_ptr->size, 711 CVMX_BOOTMEM_FLAG_NO_LOCKING); 712 named_block_ptr->size = 0; 713 /* Set size to zero to indicate block not used. */ 714 } 715 716 cvmx_bootmem_unlock(); 717 return named_block_ptr != NULL; /* 0 on failure, 1 on success */ 718 } 719 720 int cvmx_bootmem_free_named(char *name) 721 { 722 return cvmx_bootmem_phy_named_block_free(name, 0); 723 } 724 725 int64_t cvmx_bootmem_phy_named_block_alloc(uint64_t size, uint64_t min_addr, 726 uint64_t max_addr, 727 uint64_t alignment, 728 char *name, 729 uint32_t flags) 730 { 731 int64_t addr_allocated; 732 struct cvmx_bootmem_named_block_desc *named_block_desc_ptr; 733 734 #ifdef DEBUG 735 cvmx_dprintf("cvmx_bootmem_phy_named_block_alloc: size: 0x%llx, min: " 736 "0x%llx, max: 0x%llx, align: 0x%llx, name: %s\n", 737 (unsigned long long)size, 738 (unsigned long long)min_addr, 739 (unsigned long long)max_addr, 740 (unsigned long long)alignment, 741 name); 742 #endif 743 if (cvmx_bootmem_desc->major_version != 3) { 744 cvmx_dprintf("ERROR: Incompatible bootmem descriptor version: " 745 "%d.%d at addr: %p\n", 746 (int)cvmx_bootmem_desc->major_version, 747 (int)cvmx_bootmem_desc->minor_version, 748 cvmx_bootmem_desc); 749 return -1; 750 } 751 752 /* 753 * Take lock here, as name lookup/block alloc/name add need to 754 * be atomic. 755 */ 756 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING)) 757 cvmx_spinlock_lock((cvmx_spinlock_t *)&(cvmx_bootmem_desc->lock)); 758 759 /* Get pointer to first available named block descriptor */ 760 named_block_desc_ptr = 761 cvmx_bootmem_phy_named_block_find(NULL, 762 flags | CVMX_BOOTMEM_FLAG_NO_LOCKING); 763 764 /* 765 * Check to see if name already in use, return error if name 766 * not available or no more room for blocks. 767 */ 768 if (cvmx_bootmem_phy_named_block_find(name, 769 flags | CVMX_BOOTMEM_FLAG_NO_LOCKING) || !named_block_desc_ptr) { 770 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING)) 771 cvmx_spinlock_unlock((cvmx_spinlock_t *)&(cvmx_bootmem_desc->lock)); 772 return -1; 773 } 774 775 776 /* 777 * Round size up to mult of minimum alignment bytes We need 778 * the actual size allocated to allow for blocks to be 779 * coalesced when they are freed. The alloc routine does the 780 * same rounding up on all allocations. 781 */ 782 size = ALIGN(size, CVMX_BOOTMEM_ALIGNMENT_SIZE); 783 784 addr_allocated = cvmx_bootmem_phy_alloc(size, min_addr, max_addr, 785 alignment, 786 flags | CVMX_BOOTMEM_FLAG_NO_LOCKING); 787 if (addr_allocated >= 0) { 788 named_block_desc_ptr->base_addr = addr_allocated; 789 named_block_desc_ptr->size = size; 790 strncpy(named_block_desc_ptr->name, name, 791 cvmx_bootmem_desc->named_block_name_len); 792 named_block_desc_ptr->name[cvmx_bootmem_desc->named_block_name_len - 1] = 0; 793 } 794 795 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING)) 796 cvmx_spinlock_unlock((cvmx_spinlock_t *)&(cvmx_bootmem_desc->lock)); 797 return addr_allocated; 798 } 799 800 struct cvmx_bootmem_desc *cvmx_bootmem_get_desc(void) 801 { 802 return cvmx_bootmem_desc; 803 } 804