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