void *alloc_bootmem_aligned(unsigned long size, unsigned long alignment)
{
void *unused_addr = NULL;
unsigned long addr, tmp_size, unused_size;
/* Allocate maximum size needed, see where it ends up.
* Then free it -- in this path there are no other allocators
* so we can depend on getting the same address back
* when we allocate a smaller piece that is aligned
* at the end (if necessary) and the piece we really want,
* then free the unused first piece.
*/
tmp_size = size + alignment - PAGE_SIZE;
addr = (unsigned long)alloc_bootmem(tmp_size);
free_bootmem(__pa(addr), tmp_size);
unused_size = alignment - (addr % alignment);
if (unused_size)
unused_addr = alloc_bootmem(unused_size);
addr = (unsigned long)alloc_bootmem(size);
if (unused_size)
free_bootmem(__pa(unused_addr), unused_size);
return (void *)addr;
}
/*
* 3215 console initialization code called from console_init().
* NOTE: This is called before kmalloc is available.
*/
static int __init
con3215_init(void)
{
struct ccw_device *cdev;
struct raw3215_info *raw;
struct raw3215_req *req;
int i;
/* Check if 3215 is to be the console */
if (!CONSOLE_IS_3215)
return -ENODEV;
/* Set the console mode for VM */
if (MACHINE_IS_VM) {
cpcmd("TERM CONMODE 3215", NULL, 0);
cpcmd("TERM AUTOCR OFF", NULL, 0);
}
/* allocate 3215 request structures */
raw3215_freelist = NULL;
spin_lock_init(&raw3215_freelist_lock);
for (i = 0; i < NR_3215_REQ; i++) {
req = (struct raw3215_req *) alloc_bootmem_low(sizeof(struct raw3215_req));
req->next = raw3215_freelist;
raw3215_freelist = req;
}
cdev = ccw_device_probe_console();
if (!cdev)
return -ENODEV;
raw3215[0] = raw = (struct raw3215_info *)
alloc_bootmem_low(sizeof(struct raw3215_info));
memset(raw, 0, sizeof(struct raw3215_info));
raw->buffer = (char *) alloc_bootmem_low(RAW3215_BUFFER_SIZE);
raw->inbuf = (char *) alloc_bootmem_low(RAW3215_INBUF_SIZE);
raw->cdev = cdev;
raw->lock = get_ccwdev_lock(cdev);
cdev->dev.driver_data = raw;
cdev->handler = raw3215_irq;
raw->flags |= RAW3215_FIXED;
tasklet_init(&raw->tasklet,
(void (*)(unsigned long)) raw3215_tasklet,
(unsigned long) raw);
init_waitqueue_head(&raw->empty_wait);
/* Request the console irq */
if (raw3215_startup(raw) != 0) {
free_bootmem((unsigned long) raw->inbuf, RAW3215_INBUF_SIZE);
free_bootmem((unsigned long) raw->buffer, RAW3215_BUFFER_SIZE);
free_bootmem((unsigned long) raw, sizeof(struct raw3215_info));
raw3215[0] = NULL;
printk("Couldn't find a 3215 console device\n");
return -ENODEV;
}
register_console(&con3215);
return 0;
}
/*
* 3215 console initialization code called from console_init().
* NOTE: This is called before kmalloc is available.
*/
void __init con3215_init(void)
{
raw3215_info *raw;
raw3215_req *req;
int irq;
int i;
/* Check if 3215 is to be the console */
if (!CONSOLE_IS_3215)
return;
irq = raw3215_find_dev(0);
/* Set the console mode for VM */
if (MACHINE_IS_VM) {
cpcmd("TERM CONMODE 3215", NULL, 0);
cpcmd("TERM AUTOCR OFF", NULL, 0);
}
/* allocate 3215 request structures */
raw3215_freelist = NULL;
spin_lock_init(&raw3215_freelist_lock);
for (i = 0; i < NR_3215_REQ; i++) {
req = (raw3215_req *) alloc_bootmem_low(sizeof(raw3215_req));
req->next = raw3215_freelist;
raw3215_freelist = req;
}
ctrlchar_init();
#ifdef CONFIG_TN3215_CONSOLE
raw3215[0] = raw = (raw3215_info *)
alloc_bootmem_low(sizeof(raw3215_info));
memset(raw, 0, sizeof(raw3215_info));
raw->buffer = (char *) alloc_bootmem_low(RAW3215_BUFFER_SIZE);
raw->inbuf = (char *) alloc_bootmem_low(RAW3215_INBUF_SIZE);
/* Find the first console */
raw->irq = raw3215_find_dev(0);
raw->flags |= RAW3215_FIXED;
raw->tqueue.routine = raw3215_softint;
raw->tqueue.data = raw;
init_waitqueue_head(&raw->empty_wait);
/* Request the console irq */
if ( raw3215_startup(raw) != 0 )
raw->irq = -1;
if (raw->irq != -1) {
register_console(&con3215);
} else {
free_bootmem((unsigned long) raw->inbuf, RAW3215_INBUF_SIZE);
free_bootmem((unsigned long) raw->buffer, RAW3215_BUFFER_SIZE);
free_bootmem((unsigned long) raw, sizeof(raw3215_info));
raw3215[0] = NULL;
printk("Couldn't find a 3215 console device\n");
}
#endif
}
void __init setup_physmem(unsigned long start, unsigned long reserve_end,
unsigned long len, unsigned long long highmem)
{
unsigned long reserve = reserve_end - start;
int pfn = PFN_UP(__pa(reserve_end));
int delta = (len - reserve) >> PAGE_SHIFT;
int err, offset, bootmap_size;
physmem_fd = create_mem_file(len + highmem);
offset = uml_reserved - uml_physmem;
err = os_map_memory((void *) uml_reserved, physmem_fd, offset,
len - offset, 1, 1, 1);
if (err < 0) {
printf("setup_physmem - mapping %ld bytes of memory at 0x%p "
"failed - errno = %d\n", len - offset,
(void *) uml_reserved, err);
exit(1);
}
/*
* Special kludge - This page will be mapped in to userspace processes
* from physmem_fd, so it needs to be written out there.
*/
os_seek_file(physmem_fd, __pa(&__syscall_stub_start));
os_write_file(physmem_fd, &__syscall_stub_start, PAGE_SIZE);
bootmap_size = init_bootmem(pfn, pfn + delta);
free_bootmem(__pa(reserve_end) + bootmap_size,
len - bootmap_size - reserve);
}
static void __init rx51_alloc_vram(void)
{
unsigned long vram_paddr;
size_t vram_size;
size_t gfx_size;
size_t vid_size;
vid_size = PAGE_ALIGN(rx51_vrfb_min_plane_size(16));
#ifdef GRALLOC_MEMSIZE
gfx_size = PAGE_ALIGN(GRALLOC_MEMSIZE - vid_size);
#else
gfx_size = PAGE_ALIGN(rx51_vrfb_min_phys_size(16));
#endif
pr_info("VRAM: GFX size: %d, VID size:%d", gfx_size, vid_size);
vram_size = gfx_size + vid_size;
vram_paddr = virt_to_phys(alloc_bootmem_pages(vram_size));
BUG_ON(vram_paddr & ~PAGE_MASK);
rx51_add_gfx_fb(vram_paddr, gfx_size, OMAPFB_COLOR_RGB565);
if (omap_vram_add_region(vram_paddr, vram_size) < 0) {
free_bootmem(vram_paddr, vram_size);
pr_err("Can't set VRAM region\n");
return;
}
pr_info("VRAM: %zd bytes at 0x%lx\n", vram_size, vram_paddr);
}
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);
}
static ssize_t __init setup_pcpu_4k(size_t static_size)
{
size_t pages_size;
unsigned int cpu;
int i, j;
ssize_t ret;
pcpu4k_nr_static_pages = PFN_UP(static_size);
/* unaligned allocations can't be freed, round up to page size */
pages_size = PFN_ALIGN(pcpu4k_nr_static_pages * num_possible_cpus()
* sizeof(pcpu4k_pages[0]));
pcpu4k_pages = alloc_bootmem(pages_size);
/* allocate and copy */
j = 0;
for_each_possible_cpu(cpu)
for (i = 0; i < pcpu4k_nr_static_pages; i++) {
void *ptr;
ptr = pcpu_alloc_bootmem(cpu, PAGE_SIZE, PAGE_SIZE);
if (!ptr)
goto enomem;
memcpy(ptr, __per_cpu_load + i * PAGE_SIZE, PAGE_SIZE);
pcpu4k_pages[j++] = virt_to_page(ptr);
}
/* we're ready, commit */
pr_info("PERCPU: Allocated %d 4k pages, static data %zu bytes\n",
pcpu4k_nr_static_pages, static_size);
ret = pcpu_setup_first_chunk(pcpu4k_get_page, static_size,
PERCPU_FIRST_CHUNK_RESERVE, -1,
-1, NULL, pcpu4k_populate_pte);
goto out_free_ar;
enomem:
while (--j >= 0)
free_bootmem(__pa(page_address(pcpu4k_pages[j])), PAGE_SIZE);
ret = -ENOMEM;
out_free_ar:
free_bootmem(__pa(pcpu4k_pages), pages_size);
return ret;
}
static void __ref free_p2m_page(void *p)
{
if (unlikely(!slab_is_available())) {
free_bootmem((unsigned long)p, PAGE_SIZE);
return;
}
free_page((unsigned long)p);
}
void printk_remap_nocache(void)
{
unsigned long long nocache_base = 0;
unsigned *sec_log_mag;
unsigned long flags;
unsigned start;
#if 1
if( 0 == sec_debug_is_enabled() ) {
sec_getlog_supply_kloginfo(log_buf);
return;
}
#endif
pr_err("%s: sec_log_save_size %d at sec_log_save_base 0x%x \n",
__func__, sec_log_save_size, (unsigned int)sec_log_save_base);
pr_err("%s: sec_log_reserve_size %d at sec_log_reserve_base 0x%x \n",
__func__, sec_log_reserve_size, (unsigned int)sec_log_reserve_base);
#if 0
free_bootmem(sec_log_reserve_base, sec_log_reserve_size);
#endif
nocache_base = ioremap_nocache(sec_log_save_base - 4096, sec_log_save_size + 8192);
nocache_base = nocache_base + 4096;
sec_log_mag = nocache_base - 8;
sec_log_ptr = nocache_base - 4;
sec_log_buf = nocache_base;
sec_log_size = sec_log_save_size;
sec_log_irq_en = nocache_base - 0xC ;
#if 0
pr_err("%s: sec_log_save_size %d at sec_log_save_base 0x%x \n",
__func__, sec_log_save_size, (unsigned int)sec_log_save_base);
pr_err("%s: nocache_base %x "
" sec_log_mag:0x%x "
"at sec_log_ptr 0x%x "
"at sec_log_buf 0x%p \n", __func__,
nocache_base, *sec_log_mag, *sec_log_ptr, sec_log_buf);
#endif
spin_lock_irqsave(&logbuf_lock, flags);
if (*sec_log_mag != LOG_MAGIC) {
*sec_log_ptr = 0;
*sec_log_mag = LOG_MAGIC;
}
start = min(con_start, log_start);
while (start != log_end) {
emit_sec_log_char(__log_buf
[start++ & (__LOG_BUF_LEN - 1)]);
}
spin_unlock_irqrestore(&logbuf_lock, flags);
sec_getlog_supply_kloginfo(sec_log_buf);
}
// start_pfn : 뱅크 0 시작 주소의 물리 small page 번호 (0x20000)
// end_pfn : 뱅크 0의 마지막 주소의 물리 small page 번호 (0x4f800)
static void __init arm_bootmem_init(unsigned long start_pfn,
unsigned long end_pfn)
{
struct memblock_region *reg;
unsigned int boot_pages;
phys_addr_t bitmap;
pg_data_t *pgdat;
// pg_data_t : struct pglist_data
/*
* Allocate the bootmem bitmap page. This must be in a region
* of memory which has already been mapped.
*/
boot_pages = bootmem_bootmap_pages(end_pfn - start_pfn);
// boot_pages : 6
// start_pfn ~ end_pfn 까지를 bitmap으로 바꿨을 때 총 프레임의 갯수가 반환됨.
// boot_pages << PAGE_SHIFT : 0x6000, L1_CACHE_BYTES : 64, _pfn_to_phys(end_pfn) : 0x4F800000
bitmap = memblock_alloc_base(boot_pages << PAGE_SHIFT, L1_CACHE_BYTES,
__pfn_to_phys(end_pfn));
// non-reserved 영역에서 비트맵용 영역을 만들어 가져옴
// 영역의 시작 주소가 반환됨(물리)
/*
* Initialise the bootmem allocator, handing the
* memory banks over to bootmem.
*/
node_set_online(0); // 비어 있는 함수임
pgdat = NODE_DATA(0);
//*pgdat = contig_page_data
//
// .bdata = &bootmem_node_data[0]
// 현재는 0으로 되어 있는 값임
//
init_bootmem_node(pgdat, __phys_to_pfn(bitmap), start_pfn, end_pfn);
// bdata_list 에 등록
// bitmap 값을 0xFF로 초기화
/* Free the lowmem regions from memblock into bootmem. */
for_each_memblock(memory, reg) {
// for (reg = memblock.memory.regions; reg < (memblock.memory.regions + memblock.memory.cnt), reg++)
unsigned long start = memblock_region_memory_base_pfn(reg);
unsigned long end = memblock_region_memory_end_pfn(reg);
// start : 0x20000
// end : 0xA0000
if (end >= end_pfn)
end = end_pfn;
if (start >= end)
break;
// start : 0x20000000, (end - start) << PAGE_SHIFT : 0x2F800000
free_bootmem(__pfn_to_phys(start), (end - start) << PAGE_SHIFT);
// start부터 end에 해당하는 bitmap을 전부 0으로 설정
// 일단 전부 FREE로 만듬
}
static void __init pcpu_fc_free(void *ptr, size_t size)
{
#ifdef CONFIG_NO_BOOTMEM
u64 start = __pa(ptr);
u64 end = start + size;
free_early_partial(start, end);
#else
free_bootmem(__pa(ptr), size);
#endif
}
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 free_tce_table(void *tbl)
{
unsigned int size;
if (!tbl)
return;
size = table_size_to_number_of_entries(specified_table_size);
size *= TCE_ENTRY_SIZE;
free_bootmem(__pa(tbl), size);
}
/* Load data from a file called NAME into ram. The address and length
of the data image are returned in ADDR and LEN. */
static int __init
read_file (const char *name,
unsigned long *addr, unsigned long *len,
const char **err)
{
int rval, fd;
unsigned long cur, left;
/* Note this is not a normal stat buffer, it's an ad-hoc
structure defined by the simulator. */
unsigned long stat_buf[10];
/* Stat the file to find out the length. */
rval = V850_SIM_SYSCALL (stat, name, stat_buf);
if (rval < 0) {
if (err) *err = "stat";
return 0;
}
*len = stat_buf[4];
/* Open the file; `0' is O_RDONLY. */
fd = V850_SIM_SYSCALL (open, name, 0);
if (fd < 0) {
if (err) *err = "open";
return 0;
}
*addr = (unsigned long)alloc_bootmem(*len);
if (! *addr) {
V850_SIM_SYSCALL (close, fd);
if (err) *err = "alloc_bootmem";
return 0;
}
cur = *addr;
left = *len;
while (left > 0) {
int chunk = V850_SIM_SYSCALL (read, fd, cur, left);
if (chunk <= 0)
break;
cur += chunk;
left -= chunk;
}
V850_SIM_SYSCALL (close, fd);
if (left > 0) {
/* Some read failed. */
free_bootmem (*addr, *len);
if (err) *err = "read";
return 0;
}
return 1;
}
// ARM10C 20131207
// min: 0x20000, max_low: 0x4f800
static void __init arm_bootmem_init(unsigned long start_pfn,
unsigned long end_pfn)
{
struct memblock_region *reg;
unsigned int boot_pages;
phys_addr_t bitmap;
pg_data_t *pgdat;
/*
* Allocate the bootmem bitmap page. This must be in a region
* of memory which has already been mapped.
*/
// start_pfn: 0x20000, end_pfn: 0x4f800, end_pfn - start_pfn: 0x2f800
// boot_pages: 0x6
boot_pages = bootmem_bootmap_pages(end_pfn - start_pfn);
// boot_pages << PAGE_SHIFT: 0x6000, L1_CACHE_BYTES: 64
// __pfn_to_phys(0x4f800); 0x4f800000
bitmap = memblock_alloc_base(boot_pages << PAGE_SHIFT, L1_CACHE_BYTES,
__pfn_to_phys(end_pfn));
/*
* Initialise the bootmem allocator, handing the
* memory banks over to bootmem.
*/
node_set_online(0);
// pglist_data.bdata 의 bootmem_node_data 주소로 설정
pgdat = NODE_DATA(0);
// pgdat: ?, __phys_to_pfn(bitmap): ?, start_pfn: 0x20000, end_pfn: 0x4f800
init_bootmem_node(pgdat, __phys_to_pfn(bitmap), start_pfn, end_pfn);
/* Free the lowmem regions from memblock into bootmem. */
for_each_memblock(memory, reg) {
// start: 0x20000
unsigned long start = memblock_region_memory_base_pfn(reg);
// end: 0xA0000
unsigned long end = memblock_region_memory_end_pfn(reg);
// end: 0xA0000, end_pfn: 0x4f800
if (end >= end_pfn)
// end: 0x4f800
end = end_pfn;
// start: 0x20000, end: 0x4f800
if (start >= end)
break;
// __pfn_to_phys(0x20000): 0x20000000, (end - start) << PAGE_SHIFT: 0x2f800000
free_bootmem(__pfn_to_phys(start), (end - start) << PAGE_SHIFT);
}
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 mem_init(void)
{
int codek = 0, datak = 0, initk = 0;
unsigned long tmp, ram_start, ram_end, len;
extern char _etext, _stext, _sdata, _ebss, __init_begin, __init_end;
unsigned long start_mem = memory_start; /* DAVIDM - these must start at end of kernel */
unsigned long end_mem = memory_end; /* DAVIDM - this must not include kernel stack at top */
processor_dram(&ram_start, &ram_end);
len = (ram_end - ram_start) + OCMSIZE;
#ifdef DEBUG
printk(KERN_DEBUG "Mem_init: start=%lx, end=%lx\n", start_mem, end_mem);
#endif
end_mem &= PAGE_MASK;
high_memory = (void *) end_mem;
start_mem = PAGE_ALIGN(start_mem);
max_mapnr = num_physpages = (((unsigned long) high_memory) - PAGE_OFFSET) >> PAGE_SHIFT;
/* this will put all memory onto the freelists */
#ifdef CONFIG_ZONE_DMA
{
unsigned long ocm_free_begin = (unsigned long)&__ocm_free_begin;
unsigned long ocm_free_end = (unsigned long)&__ocm_free_end;
unsigned long zone_dma_begin = (ocm_free_begin + PAGE_SIZE - 1) & PAGE_MASK;
unsigned long zone_dma_end = ocm_free_end & PAGE_MASK;
if (zone_dma_end > zone_dma_begin)
free_bootmem(zone_dma_begin, zone_dma_end-zone_dma_begin);
}
#endif
totalram_pages = free_all_bootmem();
codek = (&_etext - &_stext) >> 10;
datak = (&_ebss - &_sdata) >> 10;
initk = (&__init_begin - &__init_end) >> 10;
tmp = nr_free_pages() << PAGE_SHIFT;
printk(KERN_INFO "Memory available: %luk/%luk RAM, (%dk kernel code, %dk data)\n",
tmp >> 10,
len >> 10,
codek,
datak
);
}
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();
/* free the space reserved for the dt blob */
free_bootmem(base, size);
}
static void __init rx51_detect_vram(void)
{
unsigned long vram_paddr;
size_t vram_size;
unsigned long gfx_paddr;
size_t gfx_size;
size_t vid_size;
enum omapfb_color_format format;
gfx_paddr = dss_boottime_get_plane_base(0);
if (gfx_paddr == -1UL)
return;
gfx_size = PAGE_ALIGN(rx51_vrfb_min_phys_size(dss_boottime_get_plane_bpp(0)));
#ifdef GRALLOC_MEMSIZE
vid_size = PAGE_ALIGN( GRALLOC_MEMSIZE - gfx_size );
#else
vid_size = rx51_vrfb_min_plane_size(16);
#endif
pr_debug("VRAM: GFX size: %d, VID size:%d", gfx_size, vid_size);
vram_size = gfx_size + vid_size;
vram_paddr = gfx_paddr - vid_size;
format = dss_boottime_get_plane_format(0);
rx51_add_gfx_fb(gfx_paddr, gfx_size, format);
if (reserve_bootmem(vram_paddr, vram_size, BOOTMEM_EXCLUSIVE) < 0) {
pr_err("FB: can't reserve VRAM region\n");
return;
}
if (omap_vram_add_region(vram_paddr, vram_size) < 0) {
free_bootmem(vram_paddr, vram_size);
pr_err("Can't set VRAM region\n");
return;
}
pr_info("VRAM: %zd bytes at 0x%lx. (Detected %zd at %#lx)\n",
vram_size, vram_paddr, gfx_size, gfx_paddr);
}
void __init bootmem_init(void)
{
struct memblock_region *reg;
unsigned long bootmap_size;
unsigned long free_pfn, end_pfn, start_pfn;
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)_end;
memblock_init();
memblock_add(memory_start, memory_end);
if(((unsigned long)__pa(_end) < memory_start) || ((unsigned long)__pa(_end) > memory_end))
printk("BUG: your kernel is not located in the ddr sdram");
start_pfn = PFN_UP(memory_start);
free_pfn = PFN_UP(__pa((unsigned long)_end));
end_pfn = PFN_DOWN(memory_end);
//memblock_reserve(PFN_PHYS(start_pfn), PFN_PHYS(free_pfn - start_pfn));
memblock_reserve(__pa(_stext), _end - _stext);
#ifdef CONFIG_BLK_DEV_INITRD
if (initrd_start && initrd_end && initrd_start < initrd_end) {
memblock_reserve(initrd_start, initrd_end - initrd_start);
}
#endif
bootmap_size = init_bootmem(free_pfn, end_pfn);
memblock_reserve(PFN_PHYS(free_pfn), bootmap_size);
free_bootmem(PFN_PHYS(free_pfn), PFN_PHYS(end_pfn - free_pfn));
for_each_memblock(reserved, reg)
reserve_bootmem(reg->base, reg->size, BOOTMEM_DEFAULT);
memory_start += PAGE_OFFSET;
memory_end += PAGE_OFFSET;
memblock_analyze();
memblock_dump_all();
}
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 void __init arm_bootmem_init(struct meminfo *mi,
unsigned long start_pfn, unsigned long end_pfn)
{
unsigned int boot_pages;
phys_addr_t bitmap;
pg_data_t *pgdat;
int i;
/*
* Allocate the bootmem bitmap page. This must be in a region
* of memory which has already been mapped.
*/
boot_pages = bootmem_bootmap_pages(end_pfn - start_pfn);
bitmap = memblock_alloc_base(boot_pages << PAGE_SHIFT, L1_CACHE_BYTES,
__pfn_to_phys(end_pfn));
/*
* Initialise the bootmem allocator, handing the
* memory banks over to bootmem.
*/
node_set_online(0);
pgdat = NODE_DATA(0);
init_bootmem_node(pgdat, __phys_to_pfn(bitmap), start_pfn, end_pfn);
for_each_bank(i, mi) {
struct membank *bank = &mi->bank[i];
if (!bank->highmem)
free_bootmem(bank_phys_start(bank), bank_phys_size(bank));
}
/*
* Reserve the memblock reserved regions in bootmem.
*/
for (i = 0; i < memblock.reserved.cnt; i++) {
phys_addr_t start = memblock_start_pfn(&memblock.reserved, i);
if (start >= start_pfn &&
memblock_end_pfn(&memblock.reserved, i) <= end_pfn)
reserve_bootmem_node(pgdat, __pfn_to_phys(start),
memblock_size_bytes(&memblock.reserved, i),
BOOTMEM_DEFAULT);
}
}
/*
* Register fully available low RAM pages with the bootmem allocator.
*/
static void __init register_bootmem_low_pages(void)
{
unsigned long curr_pfn, last_pfn, pages;
/*
* We are rounding up the start address of usable memory:
*/
curr_pfn = PFN_UP(__MEMORY_START);
/*
* ... and at the end of the usable range downwards:
*/
last_pfn = PFN_DOWN(__pa(memory_end));
if (last_pfn > max_low_pfn)
last_pfn = max_low_pfn;
pages = last_pfn - curr_pfn;
free_bootmem(PFN_PHYS(curr_pfn), PFN_PHYS(pages));
}
int orion_sysinit(void)
{
unsigned long mem_size, free_start, free_end, start_pfn, bootmap_size;
mips_machgroup = MACH_GROUP_ORION;
/* 64 MB non-upgradable */
mem_size = 32 << 20;
free_start = PHYSADDR(PFN_ALIGN(&_end));
free_end = mem_size;
start_pfn = PFN_UP((unsigned long)&_end);
/* Register all the contiguous memory with the bootmem allocator
and free it. Be careful about the bootmem freemap. */
bootmap_size = init_bootmem(start_pfn, mem_size >> PAGE_SHIFT);
/* Free the entire available memory after the _end symbol. */
free_start += bootmap_size;
free_bootmem(free_start, free_end-free_start);
}
static unsigned long __init setup_memory(void)
{
unsigned long bootmap_size, start_pfn, max_low_pfn;
#define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
#define PFN_DOWN(x) ((x) >> PAGE_SHIFT)
#define PFN_PHYS(x) ((x) << PAGE_SHIFT)
#ifndef CONFIG_FB_OC_SHMEM_SIZE
#define CONFIG_FB_OC_SHMEM_SIZE 0
#endif /* CONFIG_FB_OC_SHMEM_SIZE */
/* min_low_pfn points to the start of DRAM, start_pfn points
* to the first DRAM pages after the kernel, and max_low_pfn
* to the end of DRAM. Partial pages are not useful, so round it
* down.
*/
start_pfn = PFN_UP(__pa(&_end));
max_low_pfn = PFN_DOWN(CONFIG_OR32_MEMORY_SIZE
-CONFIG_FB_OC_SHMEM_SIZE
-CONFIG_OR32_RESERVED_MEM_SIZE);
min_low_pfn = PAGE_OFFSET >> PAGE_SHIFT;
#undef CONFIG_FB_OC_SHMEM_SIZE
/*
* set the beginning of frame buffer
*/
fb_mem_start = PFN_PHYS(max_low_pfn);
/*
* initialize the boot-time allocator (with low memory only)
*/
bootmap_size = init_bootmem(start_pfn, max_low_pfn);
free_bootmem(PFN_PHYS(start_pfn), PFN_PHYS(max_low_pfn - start_pfn));
reserve_bootmem(PFN_PHYS(start_pfn), bootmap_size);
return(max_low_pfn);
}
static u32 __init allocate_aperture(void)
{
u32 aper_size;
void *p;
if (fallback_aper_order > 7)
fallback_aper_order = 7;
aper_size = (32 * 1024 * 1024) << fallback_aper_order;
/*
* Aperture has to be naturally aligned. This means an 2GB aperture won't
* have much chances to find a place in the lower 4GB of memory.
* Unfortunately we cannot move it up because that would make the
* IOMMU useless.
*/
p = __alloc_bootmem_nopanic(aper_size, aper_size, 0);
if (!p || __pa(p)+aper_size > 0xffffffff) {
printk("Cannot allocate aperture memory hole (%p,%uK)\n",
p, aper_size>>10);
if (p)
free_bootmem(__pa(p), aper_size);
return 0;
}
static void __init arm_bootmem_init(unsigned long start_pfn,
unsigned long end_pfn)
{
struct memblock_region *reg;
unsigned int boot_pages;
phys_addr_t bitmap;
pg_data_t *pgdat;
/*
* Allocate the bootmem bitmap page. This must be in a region
* of memory which has already been mapped.
*/
boot_pages = bootmem_bootmap_pages(end_pfn - start_pfn);
bitmap = memblock_alloc_base(boot_pages << PAGE_SHIFT, L1_CACHE_BYTES,
__pfn_to_phys(end_pfn));
/*
* Initialise the bootmem allocator, handing the
* memory banks over to bootmem.
*/
node_set_online(0);
pgdat = NODE_DATA(0);
init_bootmem_node(pgdat, __phys_to_pfn(bitmap), start_pfn, end_pfn);
/* Free the lowmem regions from memblock into bootmem. */
for_each_memblock(memory, reg) {
unsigned long start = memblock_region_memory_base_pfn(reg);
unsigned long end = memblock_region_memory_end_pfn(reg);
if (end >= end_pfn)
end = end_pfn;
if (start >= end)
break;
free_bootmem(__pfn_to_phys(start), (end - start) << PAGE_SHIFT);
}
static void __init bootmem_init(void)
{
unsigned long reserved_end;
unsigned long mapstart = ~0UL;
unsigned long bootmap_size;
int i;
/*
* Init any data related to initrd. It's a nop if INITRD is
* not selected. Once that done we can determine the low bound
* of usable memory.
*/
reserved_end = max(init_initrd(),
(unsigned long) PFN_UP(__pa_symbol(&_end)));
/*
* max_low_pfn is not a number of pages. The number of pages
* of the system is given by 'max_low_pfn - min_low_pfn'.
*/
min_low_pfn = ~0UL;
max_low_pfn = 0;
/*
* Find the highest page frame number we have available.
*/
for (i = 0; i < boot_mem_map.nr_map; i++) {
unsigned long start, end;
if (boot_mem_map.map[i].type != BOOT_MEM_RAM)
continue;
start = PFN_UP(boot_mem_map.map[i].addr);
end = PFN_DOWN(boot_mem_map.map[i].addr
+ boot_mem_map.map[i].size);
if (end > max_low_pfn)
max_low_pfn = end;
if (start < min_low_pfn)
min_low_pfn = start;
if (end <= reserved_end)
continue;
if (start >= mapstart)
continue;
mapstart = max(reserved_end, start);
}
if (min_low_pfn >= max_low_pfn)
panic("Incorrect memory mapping !!!");
if (min_low_pfn > ARCH_PFN_OFFSET) {
pr_info("Wasting %lu bytes for tracking %lu unused pages\n",
(min_low_pfn - ARCH_PFN_OFFSET) * sizeof(struct page),
min_low_pfn - ARCH_PFN_OFFSET);
} else if (min_low_pfn < ARCH_PFN_OFFSET) {
pr_info("%lu free pages won't be used\n",
ARCH_PFN_OFFSET - min_low_pfn);
}
min_low_pfn = ARCH_PFN_OFFSET;
/*
* Determine low and high memory ranges
*/
max_pfn = max_low_pfn;
if (max_low_pfn > PFN_DOWN(HIGHMEM_START)) {
#ifdef CONFIG_HIGHMEM
highstart_pfn = PFN_DOWN(HIGHMEM_START);
highend_pfn = max_low_pfn;
#endif
max_low_pfn = PFN_DOWN(HIGHMEM_START);
}
/*
* Initialize the boot-time allocator with low memory only.
*/
bootmap_size = init_bootmem_node(NODE_DATA(0), mapstart,
min_low_pfn, max_low_pfn);
for (i = 0; i < boot_mem_map.nr_map; i++) {
unsigned long start, end;
start = PFN_UP(boot_mem_map.map[i].addr);
end = PFN_DOWN(boot_mem_map.map[i].addr
+ boot_mem_map.map[i].size);
if (start <= min_low_pfn)
start = min_low_pfn;
if (start >= end)
continue;
#ifndef CONFIG_HIGHMEM
if (end > max_low_pfn)
end = max_low_pfn;
/*
* ... finally, is the area going away?
*/
if (end <= start)
continue;
#endif
add_active_range(0, start, end);
}
/*
* Register fully available low RAM pages with the bootmem allocator.
*/
for (i = 0; i < boot_mem_map.nr_map; i++) {
unsigned long start, end, size;
/*
* Reserve usable memory.
*/
if (boot_mem_map.map[i].type != BOOT_MEM_RAM)
continue;
start = PFN_UP(boot_mem_map.map[i].addr);
end = PFN_DOWN(boot_mem_map.map[i].addr
+ boot_mem_map.map[i].size);
/*
* We are rounding up the start address of usable memory
* and at the end of the usable range downwards.
*/
if (start >= max_low_pfn)
continue;
if (start < reserved_end)
start = reserved_end;
if (end > max_low_pfn)
end = max_low_pfn;
/*
* ... finally, is the area going away?
*/
if (end <= start)
continue;
size = end - start;
/* Register lowmem ranges */
#ifdef CONFIG_BRCMSTB
/* carve out space for bmem */
brcm_free_bootmem(PFN_PHYS(start), size << PAGE_SHIFT);
#else
free_bootmem(PFN_PHYS(start), size << PAGE_SHIFT);
#endif
}
/*
* Reserve the bootmap memory.
*/
reserve_bootmem(PFN_PHYS(mapstart), bootmap_size, BOOTMEM_DEFAULT);
/*
* Reserve initrd memory if needed.
*/
finalize_initrd();
/*
* Call memory_present() on all valid ranges, for SPARSEMEM.
* This must be done after setting up bootmem, since memory_present()
* may allocate bootmem.
*/
for (i = 0; i < boot_mem_map.nr_map; i++) {
unsigned long start, end;
if (boot_mem_map.map[i].type != BOOT_MEM_RAM)
continue;
start = PFN_UP(boot_mem_map.map[i].addr);
end = PFN_DOWN(boot_mem_map.map[i].addr
+ boot_mem_map.map[i].size);
memory_present(0, start, end);
}
}
void __init setup_arch(char **cmdline_p)
{
int bootmap_size;
memory_start = PAGE_ALIGN(_ramstart);
memory_end = _ramend;
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;
config_BSP(&command_line[0], sizeof(command_line));
#if defined(CONFIG_BOOTPARAM)
strncpy(&command_line[0], CONFIG_BOOTPARAM_STRING, sizeof(command_line));
command_line[sizeof(command_line) - 1] = 0;
#endif
printk(KERN_INFO "\x0F\r\n\nuClinux/" CPU "\n");
#ifdef CONFIG_UCDIMM
printk(KERN_INFO "uCdimm by Lineo, Inc. <www.lineo.com>\n");
#endif
#ifdef CONFIG_M68VZ328
printk(KERN_INFO "M68VZ328 support by Evan Stawnyczy <*****@*****.**>\n");
#endif
#ifdef CONFIG_COLDFIRE
printk(KERN_INFO "COLDFIRE port done by Greg Ungerer, [email protected]\n");
#ifdef CONFIG_M5307
printk(KERN_INFO "Modified for M5307 by Dave Miller, [email protected]\n");
#endif
#ifdef CONFIG_ELITE
printk(KERN_INFO "Modified for M5206eLITE by Rob Scott, [email protected]\n");
#endif
#endif
printk(KERN_INFO "Flat model support (C) 1998,1999 Kenneth Albanowski, D. Jeff Dionne\n");
#if defined( CONFIG_PILOT ) && defined( CONFIG_M68328 )
printk(KERN_INFO "TRG SuperPilot FLASH card support <*****@*****.**>\n");
#endif
#if defined( CONFIG_PILOT ) && defined( CONFIG_M68EZ328 )
printk(KERN_INFO "PalmV support by Lineo Inc. <*****@*****.**>\n");
#endif
#if defined (CONFIG_M68360)
printk(KERN_INFO "QUICC port done by SED Systems <*****@*****.**>,\n");
printk(KERN_INFO "based on 2.0.38 port by Lineo Inc. <*****@*****.**>.\n");
#endif
#ifdef CONFIG_DRAGEN2
printk(KERN_INFO "DragonEngine II board support by Georges Menie\n");
#endif
#ifdef CONFIG_M5235EVB
printk(KERN_INFO "Motorola M5235EVB support (C)2005 Syn-tech Systems, Inc. (Jate Sujjavanich)\n");
#endif
#ifdef DEBUG
printk(KERN_DEBUG "KERNEL -> TEXT=0x%06x-0x%06x DATA=0x%06x-0x%06x "
"BSS=0x%06x-0x%06x\n", (int) &_stext, (int) &_etext,
(int) &_sdata, (int) &_edata,
(int) &_sbss, (int) &_ebss);
printk(KERN_DEBUG "MEMORY -> ROMFS=0x%06x-0x%06x MEM=0x%06x-0x%06x\n ",
(int) &_ebss, (int) memory_start,
(int) memory_start, (int) memory_end);
#endif
/* Keep a copy of command line */
*cmdline_p = &command_line[0];
memcpy(boot_command_line, command_line, COMMAND_LINE_SIZE);
boot_command_line[COMMAND_LINE_SIZE-1] = 0;
#ifdef DEBUG
if (strlen(*cmdline_p))
printk(KERN_DEBUG "Command line: '%s'\n", *cmdline_p);
#endif
#if defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_DUMMY_CONSOLE)
conswitchp = &dummy_con;
#endif
/*
* 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, /* 0 on coldfire */
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, BOOTMEM_DEFAULT);
/*
* Get kmalloc into gear.
*/
paging_init();
}
static void __init pcpu_fc_free(void *ptr, size_t size)
{
free_bootmem(__pa(ptr), size);
}
