| /* cfe_mem.c -- Replaceable memory management hooks for MIPS boards |
| running CFE. */ |
| |
| /* |
| * Copyright 2003 |
| * Broadcom Corporation. All rights reserved. |
| * |
| * This software is furnished under license and may be used and copied only |
| * in accordance with the following terms and conditions. Subject to these |
| * conditions, you may download, copy, install, use, modify and distribute |
| * modified or unmodified copies of this software in source and/or binary |
| * form. No title or ownership is transferred hereby. |
| * |
| * 1) Any source code used, modified or distributed must reproduce and |
| * retain this copyright notice and list of conditions as they appear in |
| * the source file. |
| * |
| * 2) No right is granted to use any trade name, trademark, or logo of |
| * Broadcom Corporation. The "Broadcom Corporation" name may not be |
| * used to endorse or promote products derived from this software |
| * without the prior written permission of Broadcom Corporation. |
| * |
| * 3) THIS SOFTWARE IS PROVIDED "AS-IS" AND ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING BUT NOT LIMITED TO, ANY IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR |
| * NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL BROADCOM BE LIABLE |
| * FOR ANY DAMAGES WHATSOEVER, AND IN PARTICULAR, BROADCOM SHALL NOT BE |
| * LIABLE FOR DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| */ |
| |
| #include "cfe_api.h" |
| |
| /* Structure filled in by get_mem_info. Only the size field is |
| actually used (by sbrk), so the others aren't even filled in. |
| Note that 'size' is the __size__ of the heap starting at _end! */ |
| struct s_mem { |
| unsigned int size; |
| unsigned int icsize; |
| unsigned int dcsize; |
| }; |
| |
| void *get_mem_info (struct s_mem *); |
| |
| extern char _end[]; |
| |
| /* Address immediately after available memory. */ |
| static unsigned long memtop; |
| |
| /* Program stack size. */ |
| static unsigned long stack_size; |
| |
| void |
| __libcfe_meminit (void) |
| { |
| /* If the user has provided a memory-limit function, use it to |
| determine the end of usable memory. */ |
| if (&__libcfe_mem_limit != NULL) |
| memtop = __libcfe_mem_limit (); |
| else |
| { |
| uint64_t start, length, type; |
| int i, rv; |
| long end_segbits, end_pa; |
| |
| /* Note that this only works if _end and the program live in kseg0 |
| or kseg1. Not a problem with the default linker script, but |
| if you're writing your own, keep it in mind. For more complex |
| memory allocation needs, you're encouraged to copy this file |
| and syscalls.c (for sbrk()), and reimplement as appropriate. */ |
| end_segbits = (long)_end & ~ 0x1fffffffL; |
| end_pa = (long)_end & 0x1fffffffL; |
| |
| for (i = 0; ; i++) |
| { |
| rv = cfe_enummem(i, 0, &start, &length, &type); |
| if (rv < 0) |
| { |
| /* Did not find an available entry containing _end. |
| Assume a minimal amount of memory (1MB). */ |
| memtop = _end + (1 * 1024 * 1024); |
| break; |
| } |
| |
| /* If not available, try the next. */ |
| if (type != CFE_MI_AVAILABLE) |
| continue; |
| |
| /* If end_pa is between start and (start + length) then we have |
| a winner. */ |
| if (end_pa >= start && end_pa < (start + length)) |
| { |
| memtop = (start + length) | end_segbits; |
| break; |
| } |
| } |
| } |
| |
| /* If the user has provided a memory-limit function, use it to |
| determine the end of usable memory. */ |
| if (&__libcfe_stack_size != NULL) |
| stack_size = __libcfe_stack_size (); |
| else |
| stack_size = (32 * 1024); /* Default = 32KB. */ |
| |
| /* Chop the top of memory to a 32-byte aligned location, and |
| round the stack size up to a 32-byte multiple. */ |
| memtop = memtop & ~(unsigned long)31; |
| stack_size = (stack_size + 31) & ~(unsigned long)31; |
| } |
| |
| void * |
| __libcfe_stack_top (void) |
| { |
| /* Grow down from the top of available memory. Obviously, if |
| code writes above this limit, problems could result! */ |
| return (void *) memtop; |
| } |
| |
| /* For compatibility, get_mem_info returns the top of memory |
| (i.e., the stack address). Nothing actually uses that, |
| though. */ |
| void * |
| get_mem_info (struct s_mem *meminfo) |
| { |
| meminfo->size = (char *)(memtop - stack_size) - _end; |
| return (void *) memtop; |
| } |