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 }