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 */
__cvmx_bootmem_desc_get(uint64_t base,int offset,int size)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
cvmx_bootmem_phy_set_size(uint64_t addr,uint64_t size)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
cvmx_bootmem_phy_set_next(uint64_t addr,uint64_t next)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
cvmx_bootmem_phy_get_size(uint64_t addr)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
cvmx_bootmem_phy_get_next(uint64_t addr)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 */
cvmx_bootmem_alloc_range(uint64_t size,uint64_t alignment,uint64_t min_addr,uint64_t max_addr)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
cvmx_bootmem_alloc_address(uint64_t size,uint64_t address,uint64_t alignment)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
cvmx_bootmem_alloc_named_range(uint64_t size,uint64_t min_addr,uint64_t max_addr,uint64_t align,char * name)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
cvmx_bootmem_alloc_named(uint64_t size,uint64_t alignment,char * name)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
cvmx_bootmem_lock(void)171 void cvmx_bootmem_lock(void)
172 {
173 cvmx_spinlock_lock((cvmx_spinlock_t *) &(cvmx_bootmem_desc->lock));
174 }
175
cvmx_bootmem_unlock(void)176 void cvmx_bootmem_unlock(void)
177 {
178 cvmx_spinlock_unlock((cvmx_spinlock_t *) &(cvmx_bootmem_desc->lock));
179 }
180
cvmx_bootmem_init(void * mem_desc_ptr)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
cvmx_bootmem_phy_alloc(uint64_t req_size,uint64_t address_min,uint64_t address_max,uint64_t alignment,uint32_t flags)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 * transformation 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 satisfy 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
__cvmx_bootmem_phy_free(uint64_t phy_addr,uint64_t size,uint32_t flags)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 *
cvmx_bootmem_phy_named_block_find(char * name,uint32_t flags)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
cvmx_bootmem_alloc_named_range_once(uint64_t size,uint64_t min_addr,uint64_t max_addr,uint64_t align,char * name,void (* init)(void *))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
cvmx_bootmem_find_named_block(char * name)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 */
cvmx_bootmem_phy_named_block_free(char * name,uint32_t flags)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
cvmx_bootmem_free_named(char * name)713 int cvmx_bootmem_free_named(char *name)
714 {
715 return cvmx_bootmem_phy_named_block_free(name, 0);
716 }
717
cvmx_bootmem_phy_named_block_alloc(uint64_t size,uint64_t min_addr,uint64_t max_addr,uint64_t alignment,char * name,uint32_t flags)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 strscpy(named_block_desc_ptr->name, name,
784 cvmx_bootmem_desc->named_block_name_len);
785 }
786
787 if (!(flags & CVMX_BOOTMEM_FLAG_NO_LOCKING))
788 cvmx_spinlock_unlock((cvmx_spinlock_t *)&(cvmx_bootmem_desc->lock));
789 return addr_allocated;
790 }
791
cvmx_bootmem_get_desc(void)792 struct cvmx_bootmem_desc *cvmx_bootmem_get_desc(void)
793 {
794 return cvmx_bootmem_desc;
795 }
796