void __init bootmem_init(void)
{
unsigned long bootmap_size;
/*
* Init memory
*/
physical_memory_start = sdram_start;
physical_memory_end = sdram_start+sdram_size;
if( ((unsigned long)_end < physical_memory_start) || ((unsigned long)_end > physical_memory_end) )
printk("BUG: your kernel is not located in the ddr sdram");
/* start after kernel code */
memory_start = PAGE_ALIGN((unsigned long)_end);
memory_end = physical_memory_end;
#ifdef DEBUG
printk("memory from %lx - %lx\n", memory_start, memory_end);
#endif
init_mm.start_code = (unsigned long)_stext;
init_mm.end_code = (unsigned long)_etext;
init_mm.end_data = (unsigned long)_edata;
init_mm.brk = (unsigned long)0;
/*
* Give all the memory to the bootmap allocator, tell it to put the
* boot mem_map at the start of memory.
*/
bootmap_size = init_bootmem_node(
NODE_DATA(0),
memory_start >> PAGE_SHIFT, /* map goes here */
PAGE_OFFSET >> PAGE_SHIFT,
memory_end >> PAGE_SHIFT);
/*
* Free the usable memory, we have to make sure we do not free
* the bootmem bitmap so we then reserve it after freeing it :-)
*/
free_bootmem(memory_start, memory_end - memory_start);
reserve_bootmem(memory_start, bootmap_size);
/*
* reserve initrd boot memory
*/
#ifdef CONFIG_BLK_DEV_INITRD
if(_kernel_arg_initrd_start) {
unsigned long reserve_start = _kernel_arg_initrd_start & PAGE_MASK;
unsigned long reserve_end = (_kernel_arg_initrd_end + PAGE_SIZE-1) & PAGE_MASK;
initrd_start = _kernel_arg_initrd_start;
initrd_end = _kernel_arg_initrd_end;
printk("reserving initrd memory: %lx size %lx\n", reserve_start, reserve_end-reserve_start);
reserve_bootmem(reserve_start, reserve_end-reserve_start);
}
#endif
}
void __init mach_reserve_bootmem ()
{
#ifdef CONFIG_RTE_CB_MULTI
/* Prevent the kernel from touching the monitor's scratch RAM. */
reserve_bootmem (MON_SCRATCH_ADDR, MON_SCRATCH_SIZE);
#endif
/* The space between SRAM and SDRAM is filled with duplicate
images of SRAM. Prevent the kernel from using them. */
reserve_bootmem (SRAM_ADDR + SRAM_SIZE,
SDRAM_ADDR - (SRAM_ADDR + SRAM_SIZE));
}
static int __init sec_log_setup(char *str)
{
unsigned size=memparse(str, &str);
unsigned long base = 0;
unsigned alloc_size=0;
unsigned size_of_struct_sec_log_buffer=0;
if (!size /*|| size != roundup_pow_of_two(size)*/ || *str != '@'
|| kstrtoul(str + 1, 0, &base))
return -1;
sec_logbuf_base_addr = base;
sec_logbuf_size = size;
#ifdef CONFIG_SEC_LOG_BUF_NOCACHE
sec_log_buf_nocache_enable=1;
#else
size_of_struct_sec_log_buffer = ((sizeof(struct sec_log_buffer)+4)/4)*4;
// sec_logbuf_size(1M) + sec_log_buffer(16B) + sec_log_ptr(4B) + sec_log_mag(4B)
alloc_size = sec_logbuf_size + size_of_struct_sec_log_buffer + 4 + 4;
if(reserve_bootmem(sec_logbuf_base_addr,alloc_size, BOOTMEM_EXCLUSIVE))
{
printk("%s: fail to reserve memory\n",__func__);
return -1;
}
else {
printk("%s: success to reserve memory, base_phys=%x, size=%x\n",__func__,sec_logbuf_base_addr, alloc_size);
}
sec_log_buf_nocache_enable=0;
#endif
return 0;
}
void __init mach_reserve_bootmem(void)
{
unsigned *vmem_reg_addr;
void *vram_mem;
/* Reserve memory for the framebuffer */
//#ifdef CONFIG_XILINX_TFT_CNTLR_REF_0_INSTANCE
#if 0
/* Get address of DCR across the OPB->DCR bridge */
vmem_reg_addr = (unsigned *)
(CONFIG_XILINX_TFT_CNTLR_REF_0_DCR_BASEADDR*4 +
0xD0000000);
/* Let's take 2MB off the top of RAM */
vram_mem=CONFIG_XILINX_ERAM_START+CONFIG_XILINX_ERAM_SIZE;
vram_mem-=0x200000;
printk("Reserving 2MB for video memory (0x%08x-0x%08x)\n",
(vram_mem), vram_mem + 0x1fffff);
reserve_bootmem(__pa(vram_mem),0x200000);
/* Set the vmem address on the controller */
*vmem_reg_addr = vram_mem;
/* Tell the video driver where to find the video mem */
__vram_start = vram_mem;
#endif
}
void __init mach_reserve_bootmem ()
{
if (SDRAM_ADDR < RAM_END && SDRAM_ADDR > RAM_START)
/* We can't use the space between SRAM and SDRAM, so
prevent the kernel from trying. */
reserve_bootmem (SRAM_END, SDRAM_ADDR - SRAM_END);
}
static int __init sec_tsp_log_setup(char *str)
{
unsigned size = memparse(str, &str);
unsigned long base = 0;
unsigned *sec_tsp_log_mag;
/* If we encounter any problem parsing str ... */
if (!size || size != roundup_pow_of_two(size) || *str != '@'
|| kstrtoul(str + 1, 0, &base))
goto out;
if (reserve_bootmem(base - 8 , size + 8, BOOTMEM_EXCLUSIVE)) {
pr_err("%s: failed reserving size %d " \
"at base 0x%lx\n", __func__, size, base);
goto out;
}
sec_tsp_log_mag = phys_to_virt(base) - 8;
sec_tsp_log_ptr = phys_to_virt(base) - 4;
sec_tsp_log_buf = phys_to_virt(base);
sec_tsp_log_size = size;
pr_info("%s: *sec_tsp_log_ptr:%x " \
"sec_tsp_log_buf:%p sec_tsp_log_size:0x%x\n",
__func__, *sec_tsp_log_ptr, sec_tsp_log_buf,
sec_tsp_log_size);
if (*sec_tsp_log_mag != LOG_MAGIC) {
pr_info("%s: no old log found\n", __func__);
*sec_tsp_log_ptr = 0;
*sec_tsp_log_mag = LOG_MAGIC;
}
return 1;
out:
return 0;
}
void __init mach_reserve_bootmem ()
{
/* The space between SRAM and SDRAM is filled with duplicate
images of SRAM. Prevent the kernel from using them. */
reserve_bootmem (SRAM_ADDR + SRAM_SIZE,
SDRAM_ADDR - (SRAM_ADDR + SRAM_SIZE));
}
/*
* Allocates/reserves the Platform memory resources early in the boot process.
* This ignores any resources that are designated IORESOURCE_IO
*/
void __init platform_alloc_bootmem(void)
{
int i;
int total = 0;
/* Get persistent memory data from command line before allocating
* resources. This need to happen before normal command line parsing
* has been done */
pmem_setup_resource();
/* Loop through looking for resources that want a particular address */
for (i = 0; gp_resources[i].flags != 0; i++) {
int size = resource_size(&gp_resources[i]);
if ((gp_resources[i].start != 0) &&
((gp_resources[i].flags & IORESOURCE_MEM) != 0)) {
reserve_bootmem(dma_to_phys(gp_resources[i].start),
size, 0);
total += resource_size(&gp_resources[i]);
pr_info("reserve resource %s at %08x (%u bytes)\n",
gp_resources[i].name, gp_resources[i].start,
resource_size(&gp_resources[i]));
}
}
/* Loop through assigning addresses for those that are left */
for (i = 0; gp_resources[i].flags != 0; i++) {
int size = resource_size(&gp_resources[i]);
if ((gp_resources[i].start == 0) &&
((gp_resources[i].flags & IORESOURCE_MEM) != 0)) {
void *mem = alloc_bootmem_pages(size);
if (mem == NULL)
pr_err("Unable to allocate bootmem pages "
"for %s\n", gp_resources[i].name);
else {
gp_resources[i].start =
phys_to_dma(virt_to_phys(mem));
gp_resources[i].end =
gp_resources[i].start + size - 1;
total += size;
pr_info("allocate resource %s at %08x "
"(%u bytes)\n",
gp_resources[i].name,
gp_resources[i].start, size);
}
}
}
pr_info("Total Platform driver memory allocation: 0x%08x\n", total);
/* indicate resources that are platform I/O related */
for (i = 0; gp_resources[i].flags != 0; i++) {
if ((gp_resources[i].start != 0) &&
((gp_resources[i].flags & IORESOURCE_IO) != 0)) {
pr_info("reserved platform resource %s at %08x\n",
gp_resources[i].name, gp_resources[i].start);
}
}
}
void __init reserve_bootmem_generic(unsigned long phys, unsigned len)
{
#ifdef CONFIG_NUMA
int nid = phys_to_nid(phys);
#endif
unsigned long pfn = phys >> PAGE_SHIFT;
if (pfn >= end_pfn) {
/* This can happen with kdump kernels when accessing firmware
tables. */
if (pfn < end_pfn_map)
return;
printk(KERN_ERR "reserve_bootmem: illegal reserve %lx %u\n",
phys, len);
return;
}
/* Should check here against the e820 map to avoid double free */
#ifdef CONFIG_NUMA
reserve_bootmem_node(NODE_DATA(nid), phys, len);
#else
reserve_bootmem(phys, len);
#endif
if (phys+len <= MAX_DMA_PFN*PAGE_SIZE) {
dma_reserve += len / PAGE_SIZE;
set_dma_reserve(dma_reserve);
}
}
void __init device_tree_init(void)
{
unsigned long base, size;
void *fdt_copy;
if (!initial_boot_params)
return;
base = virt_to_phys((void *)initial_boot_params);
size = be32_to_cpu(initial_boot_params->totalsize);
/* Before we do anything, lets reserve the dt blob */
reserve_bootmem(base, size, BOOTMEM_DEFAULT);
/* The strings in the flattened tree are referenced directly by the
* device tree, so copy the flattened device tree from init memory
* to regular memory.
*/
fdt_copy = alloc_bootmem(size);
memcpy(fdt_copy, initial_boot_params, size);
initial_boot_params = fdt_copy;
unflatten_device_tree();
/* free the space reserved for the dt blob */
free_bootmem(base, size);
}
/*
* This function is called from setup_arch() to reserve the pages needed for
* ST-RAM management.
*/
void __init atari_stram_reserve_pages(void *start_mem)
{
/* always reserve first page of ST-RAM, the first 2 kB are
* supervisor-only! */
if (!kernel_in_stram)
reserve_bootmem (0, PAGE_SIZE);
}
void __init platform_alloc_bootmem(void)
{
int i;
int total = 0;
pmem_setup_resource();
for (i = 0; gp_resources[i].flags != 0; i++) {
int size = resource_size(&gp_resources[i]);
if ((gp_resources[i].start != 0) &&
((gp_resources[i].flags & IORESOURCE_MEM) != 0)) {
reserve_bootmem(dma_to_phys(gp_resources[i].start),
size, 0);
total += resource_size(&gp_resources[i]);
pr_info("reserve resource %s at %08x (%u bytes)\n",
gp_resources[i].name, gp_resources[i].start,
resource_size(&gp_resources[i]));
}
}
for (i = 0; gp_resources[i].flags != 0; i++) {
int size = resource_size(&gp_resources[i]);
if ((gp_resources[i].start == 0) &&
((gp_resources[i].flags & IORESOURCE_MEM) != 0)) {
void *mem = alloc_bootmem_pages(size);
if (mem == NULL)
pr_err("Unable to allocate bootmem pages "
"for %s\n", gp_resources[i].name);
else {
gp_resources[i].start =
phys_to_dma(virt_to_phys(mem));
gp_resources[i].end =
gp_resources[i].start + size - 1;
total += size;
pr_info("allocate resource %s at %08x "
"(%u bytes)\n",
gp_resources[i].name,
gp_resources[i].start, size);
}
}
}
pr_info("Total Platform driver memory allocation: 0x%08x\n", total);
for (i = 0; gp_resources[i].flags != 0; i++) {
if ((gp_resources[i].start != 0) &&
((gp_resources[i].flags & IORESOURCE_IO) != 0)) {
pr_info("reserved platform resource %s at %08x\n",
gp_resources[i].name, gp_resources[i].start);
}
}
}
static void __init omap_boxer_map_io(void)
{
#ifdef CONFIG_ANDROID_RAM_CONSOLE
reserve_bootmem(BOXER_RAM_CONSOLE_START, BOXER_RAM_CONSOLE_SIZE, 0);
#endif /* CONFIG_ANDROID_RAM_CONSOLE */
omap2_set_globals_343x();
iotable_init(boxer_io_desc, ARRAY_SIZE(boxer_io_desc));
omap2_map_common_io();
}
static void __init bootmem_init(void)
{
unsigned long start_pfn, bootmap_size;
unsigned long size = initrd_end - initrd_start;
start_pfn = PFN_UP(__pa(&_end));
min_low_pfn = PFN_UP(MEMORY_START);
max_low_pfn = PFN_UP(MEMORY_START + MEMORY_SIZE);
/* Initialize the boot-time allocator with low memory only. */
bootmap_size = init_bootmem_node(NODE_DATA(0), start_pfn,
min_low_pfn, max_low_pfn);
add_active_range(0, min_low_pfn, max_low_pfn);
free_bootmem(PFN_PHYS(start_pfn),
(max_low_pfn - start_pfn) << PAGE_SHIFT);
memory_present(0, start_pfn, max_low_pfn);
/* Reserve space for the bootmem bitmap. */
reserve_bootmem(PFN_PHYS(start_pfn), bootmap_size, BOOTMEM_DEFAULT);
if (size == 0) {
printk(KERN_INFO "Initrd not found or empty");
goto disable;
}
if (__pa(initrd_end) > PFN_PHYS(max_low_pfn)) {
printk(KERN_ERR "Initrd extends beyond end of memory");
goto disable;
}
/* Reserve space for the initrd bitmap. */
reserve_bootmem(__pa(initrd_start), size, BOOTMEM_DEFAULT);
initrd_below_start_ok = 1;
pr_info("Initial ramdisk at: 0x%lx (%lu bytes)\n",
initrd_start, size);
return;
disable:
printk(KERN_CONT " - disabling initrd\n");
initrd_start = 0;
initrd_end = 0;
}
static int tima_setup_rkp_mem(void){
if(reserve_bootmem(TIMA_DEBUG_LOG_START, TIMA_DEBUG_LOG_SIZE, BOOTMEM_EXCLUSIVE)){
pr_err("%s: RKP failed reserving size %d " \
"at base 0x%x\n", __func__, TIMA_DEBUG_LOG_SIZE, TIMA_DEBUG_LOG_START);
goto out;
}
pr_info("RKP :%s, base:%x, size:%x \n", __func__,TIMA_DEBUG_LOG_START, TIMA_DEBUG_LOG_SIZE);
if(reserve_bootmem(TIMA_SEC_TO_PGT, TIMA_SEC_TO_PGT_SIZE, BOOTMEM_EXCLUSIVE)){
pr_err("%s: RKP failed reserving size %d " \
"at base 0x%x\n", __func__, TIMA_SEC_TO_PGT_SIZE, TIMA_SEC_TO_PGT);
goto out;
}
pr_info("RKP :%s, base:%x, size:%x \n", __func__,TIMA_SEC_TO_PGT, TIMA_SEC_TO_PGT_SIZE);
if(reserve_bootmem(TIMA_SEC_LOG, TIMA_SEC_LOG_SIZE, BOOTMEM_EXCLUSIVE)){
pr_err("%s: RKP failed reserving size %d " \
"at base 0x%x\n", __func__, TIMA_SEC_LOG_SIZE, TIMA_SEC_LOG);
goto out;
}
pr_info("RKP :%s, base:%x, size:%x \n", __func__,TIMA_SEC_LOG, TIMA_SEC_LOG_SIZE);
if(reserve_bootmem(TIMA_PHYS_MAP, TIMA_PHYS_MAP_SIZE, BOOTMEM_EXCLUSIVE)){
pr_err("%s: RKP failed reserving size %d " \
"at base 0x%x\n", __func__, TIMA_PHYS_MAP_SIZE, TIMA_PHYS_MAP);
goto out;
}
pr_info("RKP :%s, base:%x, size:%x \n", __func__,TIMA_PHYS_MAP, TIMA_PHYS_MAP_SIZE);
if(reserve_bootmem(TIMA_DASHBOARD_START, TIMA_DASHBOARD_SIZE, BOOTMEM_EXCLUSIVE)){
pr_err("%s: RKP failed reserving size %d " \
"at base 0x%x\n", __func__, TIMA_DASHBOARD_SIZE, TIMA_DASHBOARD_START);
goto out;
}
pr_info("RKP :%s, base:%x, size:%x \n", __func__,TIMA_DASHBOARD_START, TIMA_DASHBOARD_SIZE);
return 1;
out:
return 0;
}
void __init mt_init_early(void)
{
int ret;
ret = reserve_bootmem(__pa(BOOT_SHARE_BASE), 0x1000, BOOTMEM_EXCLUSIVE);
if (ret < 0)
{
printk(KERN_WARNING "reserve_bootmem BOOT_SHARE_BASE failed %d\n", ret);
}
}
void __init mach_reserve_bootmem ()
{
extern char _root_fs_image_start, _root_fs_image_end;
u32 root_fs_image_start = (u32)&_root_fs_image_start;
u32 root_fs_image_end = (u32)&_root_fs_image_end;
/* The space between SRAM and SDRAM is filled with duplicate
images of SRAM. Prevent the kernel from using them. */
reserve_bootmem (SRAM_ADDR + SRAM_SIZE,
SDRAM_ADDR - (SRAM_ADDR + SRAM_SIZE));
/* Reserve the memory used by the root filesystem image if it's
in RAM. */
if (root_fs_image_end > root_fs_image_start
&& root_fs_image_start >= RAM_START
&& root_fs_image_start < RAM_END)
reserve_bootmem (root_fs_image_start,
root_fs_image_end - root_fs_image_start);
}
static int __init sec_log_setup(char *str)
{
unsigned size = memparse(str, &str);
unsigned long base = 0;
unsigned *sec_log_mag;
if (!size || size != roundup_pow_of_two(size) || *str != '@'
|| kstrtoul(str + 1, 0, &base))
goto out;
base = 0x46000000;
size = 0x200000;
/* If we encounter any problem parsing str ... */
if (reserve_bootmem(base - 8, size + 8, BOOTMEM_EXCLUSIVE)) {
pr_err("%s: failed reserving size %d + 8 " \
"at base 0x%lx - 8\n", __func__, size, base);
goto out;
}
#ifdef CONFIG_SEC_LOG_NONCACHED
log_buf_iodesc[0].pfn = __phys_to_pfn((unsigned long)base - 0x100000);
log_buf_iodesc[0].length = (unsigned long)(size + 0x100000);
iotable_init(log_buf_iodesc, ARRAY_SIZE(log_buf_iodesc));
flush_tlb_all();
sec_log_mag = (S3C_VA_KLOG_BUF + 0x100000) - 8;
sec_log_ptr = (S3C_VA_KLOG_BUF + 0x100000) - 4;
sec_log_buf = S3C_VA_KLOG_BUF + 0x100000;
#else
sec_log_mag = phys_to_virt(base) - 8;
sec_log_ptr = phys_to_virt(base) - 4;
sec_log_buf = phys_to_virt(base);
#endif
sec_log_size = size;
pr_info("%s: *sec_log_mag:%x *sec_log_ptr:%x " \
"sec_log_buf:%p sec_log_size:%d\n",
__func__, *sec_log_mag, *sec_log_ptr, sec_log_buf,
sec_log_size);
if (*sec_log_mag != LOG_MAGIC) {
pr_info("%s: no old log found\n", __func__);
*sec_log_ptr = 0;
*sec_log_mag = LOG_MAGIC;
} else
sec_log_save_old();
register_log_char_hook(emit_sec_log_char);
sec_getlog_supply_kloginfo(phys_to_virt(base));
out:
return 0;
}
static void __init contig_initmem_init(void)
{
unsigned long bootmap_size, bootmap;
bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size);
if (bootmap == -1L)
panic("Cannot find bootmem map of size %ld\n",bootmap_size);
bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
e820_bootmem_free(&contig_page_data, 0, end_pfn << PAGE_SHIFT);
reserve_bootmem(bootmap, bootmap_size);
}
/* Reserve the lowmem memblock reserved regions in bootmem. */
for_each_memblock(reserved, reg) {
unsigned long start = memblock_region_reserved_base_pfn(reg);
unsigned long end = memblock_region_reserved_end_pfn(reg);
if (end >= end_pfn)
end = end_pfn;
if (start >= end)
break;
reserve_bootmem(__pfn_to_phys(start),
(end - start) << PAGE_SHIFT, BOOTMEM_DEFAULT);
}
static void __init bootmem_init_one_node(unsigned int nid)
{
unsigned long total_pages, paddr;
unsigned long end_pfn;
struct pglist_data *p;
p = NODE_DATA(nid);
/* Nothing to do.. */
if (!p->node_spanned_pages)
return;
end_pfn = p->node_start_pfn + p->node_spanned_pages;
#ifdef CONFIG_HIGHMEM
if (end_pfn > max_low_pfn)
end_pfn = max_low_pfn;
#endif
total_pages = bootmem_bootmap_pages(end_pfn - p->node_start_pfn);
paddr = memblock_alloc(total_pages << PAGE_SHIFT, PAGE_SIZE);
if (!paddr)
panic("Can't allocate bootmap for nid[%d]\n", nid);
init_bootmem_node(p, paddr >> PAGE_SHIFT, p->node_start_pfn, end_pfn);
free_bootmem_with_active_regions(nid, end_pfn);
/*
* XXX Handle initial reservations for the system memory node
* only for the moment, we'll refactor this later for handling
* reservations in other nodes.
*/
if (nid == 0) {
struct memblock_region *reg;
/* Reserve the sections we're already using. */
for_each_memblock(reserved, reg) {
unsigned long size = reg->size;
#ifdef CONFIG_HIGHMEM
/* ...but not highmem */
if (PFN_DOWN(reg->base) >= highstart_pfn)
continue;
if (PFN_UP(reg->base + size) > highstart_pfn)
size = (highstart_pfn - PFN_DOWN(reg->base))
<< PAGE_SHIFT;
#endif
reserve_bootmem(reg->base, size, BOOTMEM_DEFAULT);
}
}
static void __init
contig_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
{
unsigned long bootmap_size, bootmap;
bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size);
if (bootmap == -1L)
panic("Cannot find bootmem map of size %ld\n",bootmap_size);
bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
e820_bootmem_free(NODE_DATA(0), 0, end_pfn << PAGE_SHIFT);
reserve_bootmem(bootmap, bootmap_size, BOOTMEM_DEFAULT);
}
/*
* Init functions from here on
*/
static void __init htcoxygen_map_io(void)
{
omap1_map_common_io();
printk("htcoxygen_map_io done.\n");
#ifdef CONFIG_EFB_DEBUG
efb_enable();
#endif
htcoxygen_lcd_init();
/* Reserve GSM Memory */
reserve_bootmem(WIZARD_GSM_PHYS_START, WIZARD_GSM_PHYS_SIZE, 0);
}
void __init do_init_bootmem(void)
{
unsigned long i;
unsigned long start, bootmap_pages;
unsigned long total_pages;
int boot_mapsize;
max_pfn = total_pages = lmb_end_of_DRAM() >> PAGE_SHIFT;
#ifdef CONFIG_HIGHMEM
total_pages = total_lowmem >> PAGE_SHIFT;
#endif
/*
* Find an area to use for the bootmem bitmap. Calculate the size of
* bitmap required as (Total Memory) / PAGE_SIZE / BITS_PER_BYTE.
* Add 1 additional page in case the address isn't page-aligned.
*/
bootmap_pages = bootmem_bootmap_pages(total_pages);
start = lmb_alloc(bootmap_pages << PAGE_SHIFT, PAGE_SIZE);
boot_mapsize = init_bootmem(start >> PAGE_SHIFT, total_pages);
/* Add active regions with valid PFNs */
for (i = 0; i < lmb.memory.cnt; i++) {
unsigned long start_pfn, end_pfn;
start_pfn = lmb.memory.region[i].base >> PAGE_SHIFT;
end_pfn = start_pfn + lmb_size_pages(&lmb.memory, i);
add_active_range(0, start_pfn, end_pfn);
}
/* Add all physical memory to the bootmem map, mark each area
* present.
*/
#ifdef CONFIG_HIGHMEM
free_bootmem_with_active_regions(0, total_lowmem >> PAGE_SHIFT);
#else
free_bootmem_with_active_regions(0, max_pfn);
#endif
/* reserve the sections we're already using */
for (i = 0; i < lmb.reserved.cnt; i++)
reserve_bootmem(lmb.reserved.region[i].base,
lmb_size_bytes(&lmb.reserved, i));
/* XXX need to clip this if using highmem? */
sparse_memory_present_with_active_regions(0);
init_bootmem_done = 1;
}
void __init do_init_bootmem(void)
{
unsigned long i;
unsigned long start, bootmap_pages;
unsigned long total_pages;
int boot_mapsize;
max_pfn = total_pages = lmb_end_of_DRAM() >> PAGE_SHIFT;
#ifdef CONFIG_HIGHMEM
total_pages = total_lowmem >> PAGE_SHIFT;
#endif
/*
* Find an area to use for the bootmem bitmap. Calculate the size of
* bitmap required as (Total Memory) / PAGE_SIZE / BITS_PER_BYTE.
* Add 1 additional page in case the address isn't page-aligned.
*/
bootmap_pages = bootmem_bootmap_pages(total_pages);
start = lmb_alloc(bootmap_pages << PAGE_SHIFT, PAGE_SIZE);
BUG_ON(!start);
boot_mapsize = init_bootmem(start >> PAGE_SHIFT, total_pages);
/* Add all physical memory to the bootmem map, mark each area
* present.
*/
for (i = 0; i < lmb.memory.cnt; i++) {
unsigned long base = lmb.memory.region[i].base;
unsigned long size = lmb_size_bytes(&lmb.memory, i);
#ifdef CONFIG_HIGHMEM
if (base >= total_lowmem)
continue;
if (base + size > total_lowmem)
size = total_lowmem - base;
#endif
free_bootmem(base, size);
}
/* reserve the sections we're already using */
for (i = 0; i < lmb.reserved.cnt; i++)
reserve_bootmem(lmb.reserved.region[i].base,
lmb_size_bytes(&lmb.reserved, i));
/* XXX need to clip this if using highmem? */
for (i = 0; i < lmb.memory.cnt; i++)
memory_present(0, lmb_start_pfn(&lmb.memory, i),
lmb_end_pfn(&lmb.memory, i));
init_bootmem_done = 1;
}
void __init mach_reserve_bootmem ()
{
extern char _root_fs_image_start, _root_fs_image_end;
u32 root_fs_image_start = (u32)&_root_fs_image_start;
u32 root_fs_image_end = (u32)&_root_fs_image_end;
/* Reserve the memory used by the root filesystem image if it's
in SDRAM. */
if (root_fs_image_end > root_fs_image_start
&& root_fs_image_start >= SDRAM_ADDR
&& root_fs_image_start < (SDRAM_ADDR + SDRAM_SIZE))
reserve_bootmem (root_fs_image_start,
root_fs_image_end - root_fs_image_start);
}
static void __init __sec_omap_reserve_sdram(void)
{
u32 paddr;
u32 size = 0x80000;
paddr = 0x95000000;
paddr -= size;
if (reserve_bootmem(paddr, size, BOOTMEM_EXCLUSIVE) < 0)
pr_err("FB: failed to reserve VRAM\n");
#ifdef CONFIG_SAMSUNG_USE_SEC_LOG_BUF
sec_log_buf_reserve_mem();
#endif
}
/* Reserve the lowmem memblock reserved regions in bootmem. */
for_each_memblock(reserved, reg) {
// for (reg = memblock.reserved.regions; reg < (memblock.reserved.regions + memblock.reserved.cnt), reg++)
unsigned long start = memblock_region_reserved_base_pfn(reg);
unsigned long end = memblock_region_reserved_end_pfn(reg);
if (end >= end_pfn)
end = end_pfn;
if (start >= end)
break;
// start : 0x20000000, (end - start) << PAGE_SHIFT : 0x2F800000
reserve_bootmem(__pfn_to_phys(start),
(end - start) << PAGE_SHIFT, BOOTMEM_DEFAULT);
// start부터 end에 해당하는 bitmap 중 reserved 영역을 1로 설정
}
void __init crashlog_init_mem(bootmem_data_t *bdata)
{
unsigned long addr;
if (crashlog_addr)
return;
addr = PFN_PHYS(bdata->node_low_pfn) - CRASHLOG_OFFSET;
if (reserve_bootmem(addr, CRASHLOG_SIZE, BOOTMEM_EXCLUSIVE) < 0) {
printk("Crashlog failed to allocate RAM at address 0x%lx\n", addr);
bdata->node_low_pfn -= CRASHLOG_PAGES;
addr = PFN_PHYS(bdata->node_low_pfn);
}
crashlog_addr = addr;
}
void __init device_tree_init(void)
{
unsigned long base, size;
if (!initial_boot_params)
return;
base = virt_to_phys((void *)initial_boot_params);
size = be32_to_cpu(initial_boot_params->totalsize);
/* Before we do anything, lets reserve the dt blob */
reserve_bootmem(base, size, BOOTMEM_DEFAULT);
unflatten_device_tree();
}
