1/* 2 * linux/arch/arm26/mm/init.c 3 * 4 * Copyright (C) 1995-2002 Russell King 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10#include <linux/signal.h> 11#include <linux/sched.h> 12#include <linux/kernel.h> 13#include <linux/errno.h> 14#include <linux/string.h> 15#include <linux/types.h> 16#include <linux/ptrace.h> 17#include <linux/mman.h> 18#include <linux/mm.h> 19#include <linux/swap.h> 20#include <linux/smp.h> 21#include <linux/init.h> 22#include <linux/initrd.h> 23#include <linux/bootmem.h> 24#include <linux/blkdev.h> 25#include <linux/pfn.h> 26 27#include <asm/segment.h> 28#include <asm/mach-types.h> 29#include <asm/dma.h> 30#include <asm/hardware.h> 31#include <asm/setup.h> 32#include <asm/tlb.h> 33 34#include <asm/map.h> 35 36 37#define TABLE_SIZE PTRS_PER_PTE * sizeof(pte_t)) 38 39struct mmu_gather mmu_gathers[NR_CPUS]; 40 41extern pgd_t swapper_pg_dir[PTRS_PER_PGD]; 42extern char _stext, _text, _etext, _end, __init_begin, __init_end; 43#ifdef CONFIG_XIP_KERNEL 44extern char _endtext, _sdata; 45#endif 46extern unsigned long phys_initrd_start; 47extern unsigned long phys_initrd_size; 48 49/* 50 * The sole use of this is to pass memory configuration 51 * data from paging_init to mem_init. 52 */ 53static struct meminfo meminfo __initdata = { 0, }; 54 55/* 56 * empty_zero_page is a special page that is used for 57 * zero-initialized data and COW. 58 */ 59struct page *empty_zero_page; 60 61void show_mem(void) 62{ 63 int free = 0, total = 0, reserved = 0; 64 int shared = 0, cached = 0, slab = 0; 65 struct page *page, *end; 66 67 printk("Mem-info:\n"); 68 show_free_areas(); 69 printk("Free swap: %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10)); 70 71 72 page = NODE_MEM_MAP(0); 73 end = page + NODE_DATA(0)->node_spanned_pages; 74 75 do { 76 total++; 77 if (PageReserved(page)) 78 reserved++; 79 else if (PageSwapCache(page)) 80 cached++; 81 else if (PageSlab(page)) 82 slab++; 83 else if (!page_count(page)) 84 free++; 85 else 86 shared += page_count(page) - 1; 87 page++; 88 } while (page < end); 89 90 printk("%d pages of RAM\n", total); 91 printk("%d free pages\n", free); 92 printk("%d reserved pages\n", reserved); 93 printk("%d slab pages\n", slab); 94 printk("%d pages shared\n", shared); 95 printk("%d pages swap cached\n", cached); 96} 97 98struct node_info { 99 unsigned int start; 100 unsigned int end; 101 int bootmap_pages; 102}; 103 104static unsigned int __init 105find_bootmap_pfn(struct meminfo *mi, unsigned int bootmap_pages) 106{ 107 unsigned int start_pfn, bootmap_pfn; 108 unsigned int start, end; 109 110 start_pfn = PFN_UP((unsigned long)&_end); 111 bootmap_pfn = 0; 112 113 /* ARM26 machines only have one node */ 114 if (mi->bank->node != 0) 115 BUG(); 116 117 start = PFN_UP(mi->bank->start); 118 end = PFN_DOWN(mi->bank->size + mi->bank->start); 119 120 if (start < start_pfn) 121 start = start_pfn; 122 123 if (end <= start) 124 BUG(); 125 126 if (end - start >= bootmap_pages) 127 bootmap_pfn = start; 128 else 129 BUG(); 130 131 return bootmap_pfn; 132} 133 134/* 135 * Scan the memory info structure and pull out: 136 * - the end of memory 137 * - the number of nodes 138 * - the pfn range of each node 139 * - the number of bootmem bitmap pages 140 */ 141static void __init 142find_memend_and_nodes(struct meminfo *mi, struct node_info *np) 143{ 144 unsigned int memend_pfn = 0; 145 146 nodes_clear(node_online_map); 147 node_set_online(0); 148 149 np->bootmap_pages = 0; 150 151 if (mi->bank->size == 0) { 152 BUG(); 153 } 154 155 /* 156 * Get the start and end pfns for this bank 157 */ 158 np->start = PFN_UP(mi->bank->start); 159 np->end = PFN_DOWN(mi->bank->start + mi->bank->size); 160 161 if (memend_pfn < np->end) 162 memend_pfn = np->end; 163 164 /* 165 * Calculate the number of pages we require to 166 * store the bootmem bitmaps. 167 */ 168 np->bootmap_pages = bootmem_bootmap_pages(np->end - np->start); 169 170 /* 171 * This doesn't seem to be used by the Linux memory 172 * manager any more. If we can get rid of it, we 173 * also get rid of some of the stuff above as well. 174 */ 175 max_low_pfn = memend_pfn - PFN_DOWN(PHYS_OFFSET); 176 max_pfn = memend_pfn - PFN_DOWN(PHYS_OFFSET); 177 mi->end = memend_pfn << PAGE_SHIFT; 178 179} 180 181/* 182 * Initialise the bootmem allocator for all nodes. This is called 183 * early during the architecture specific initialisation. 184 */ 185void __init bootmem_init(struct meminfo *mi) 186{ 187 struct node_info node_info; 188 unsigned int bootmap_pfn; 189 pg_data_t *pgdat = NODE_DATA(0); 190 191 find_memend_and_nodes(mi, &node_info); 192 193 bootmap_pfn = find_bootmap_pfn(mi, node_info.bootmap_pages); 194 195 /* 196 * Note that node 0 must always have some pages. 197 */ 198 if (node_info.end == 0) 199 BUG(); 200 201 /* 202 * Initialise the bootmem allocator. 203 */ 204 init_bootmem_node(pgdat, bootmap_pfn, node_info.start, node_info.end); 205 206 /* 207 * Register all available RAM in this node with the bootmem allocator. 208 */ 209 free_bootmem_node(pgdat, mi->bank->start, mi->bank->size); 210 211 /* 212 * Register the kernel text and data with bootmem. 213 * Note: with XIP we dont register .text since 214 * its in ROM. 215 */ 216#ifdef CONFIG_XIP_KERNEL 217 reserve_bootmem_node(pgdat, __pa(&_sdata), &_end - &_sdata); 218#else 219 reserve_bootmem_node(pgdat, __pa(&_stext), &_end - &_stext); 220#endif 221 222 /* 223 * And don't forget to reserve the allocator bitmap, 224 * which will be freed later. 225 */ 226 reserve_bootmem_node(pgdat, bootmap_pfn << PAGE_SHIFT, 227 node_info.bootmap_pages << PAGE_SHIFT); 228 229 reserve_bootmem_node(pgdat, 0x02000000, 0x00080000); 230 231#ifdef CONFIG_BLK_DEV_INITRD 232 initrd_start = phys_initrd_start; 233 initrd_end = initrd_start + phys_initrd_size; 234 235 /* Achimedes machines only have one node, so initrd is in node 0 */ 236#ifdef CONFIG_XIP_KERNEL 237 /* Only reserve initrd space if it is in RAM */ 238 if(initrd_start && initrd_start < 0x03000000){ 239#else 240 if(initrd_start){ 241#endif 242 reserve_bootmem_node(pgdat, __pa(initrd_start), 243 initrd_end - initrd_start); 244 } 245#endif /* CONFIG_BLK_DEV_INITRD */ 246 247 248} 249 250/* 251 * paging_init() sets up the page tables, initialises the zone memory 252 * maps, and sets up the zero page, bad page and bad page tables. 253 */ 254void __init paging_init(struct meminfo *mi) 255{ 256 void *zero_page; 257 unsigned long zone_size[MAX_NR_ZONES]; 258 unsigned long zhole_size[MAX_NR_ZONES]; 259 struct bootmem_data *bdata; 260 pg_data_t *pgdat; 261 int i; 262 263 memcpy(&meminfo, mi, sizeof(meminfo)); 264 265 /* 266 * allocate the zero page. Note that we count on this going ok. 267 */ 268 zero_page = alloc_bootmem_low_pages(PAGE_SIZE); 269 270 /* 271 * initialise the page tables. 272 */ 273 memtable_init(mi); 274 flush_tlb_all(); 275 276 /* 277 * initialise the zones in node 0 (archimedes have only 1 node) 278 */ 279 280 for (i = 0; i < MAX_NR_ZONES; i++) { 281 zone_size[i] = 0; 282 zhole_size[i] = 0; 283 } 284 285 pgdat = NODE_DATA(0); 286 bdata = pgdat->bdata; 287 zone_size[0] = bdata->node_low_pfn - 288 (bdata->node_boot_start >> PAGE_SHIFT); 289 if (!zone_size[0]) 290 BUG(); 291 pgdat->node_mem_map = NULL; 292 free_area_init_node(0, pgdat, zone_size, 293 bdata->node_boot_start >> PAGE_SHIFT, zhole_size); 294 295 /* 296 * finish off the bad pages once 297 * the mem_map is initialised 298 */ 299 memzero(zero_page, PAGE_SIZE); 300 empty_zero_page = virt_to_page(zero_page); 301} 302 303static inline void free_area(unsigned long addr, unsigned long end, char *s) 304{ 305 unsigned int size = (end - addr) >> 10; 306 307 for (; addr < end; addr += PAGE_SIZE) { 308 struct page *page = virt_to_page(addr); 309 ClearPageReserved(page); 310 init_page_count(page); 311 free_page(addr); 312 totalram_pages++; 313 } 314 315 if (size && s) 316 printk(KERN_INFO "Freeing %s memory: %dK\n", s, size); 317} 318 319/* 320 * mem_init() marks the free areas in the mem_map and tells us how much 321 * memory is free. This is done after various parts of the system have 322 * claimed their memory after the kernel image. 323 */ 324void __init mem_init(void) 325{ 326 unsigned int codepages, datapages, initpages; 327 pg_data_t *pgdat = NODE_DATA(0); 328 extern int sysctl_overcommit_memory; 329 330 331 /* Note: data pages includes BSS */ 332#ifdef CONFIG_XIP_KERNEL 333 codepages = &_endtext - &_text; 334 datapages = &_end - &_sdata; 335#else 336 codepages = &_etext - &_text; 337 datapages = &_end - &_etext; 338#endif 339 initpages = &__init_end - &__init_begin; 340 341 high_memory = (void *)__va(meminfo.end); 342 max_mapnr = virt_to_page(high_memory) - mem_map; 343 344 /* this will put all unused low memory onto the freelists */ 345 if (pgdat->node_spanned_pages != 0) 346 totalram_pages += free_all_bootmem_node(pgdat); 347 348 num_physpages = meminfo.bank[0].size >> PAGE_SHIFT; 349 350 printk(KERN_INFO "Memory: %luMB total\n", num_physpages >> (20 - PAGE_SHIFT)); 351 printk(KERN_NOTICE "Memory: %luKB available (%dK code, " 352 "%dK data, %dK init)\n", 353 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10), 354 codepages >> 10, datapages >> 10, initpages >> 10); 355 356 /* 357 * Turn on overcommit on tiny machines 358 */ 359 if (PAGE_SIZE >= 16384 && num_physpages <= 128) { 360 sysctl_overcommit_memory = OVERCOMMIT_ALWAYS; 361 printk("Turning on overcommit\n"); 362 } 363} 364 365void free_initmem(void){ 366#ifndef CONFIG_XIP_KERNEL 367 free_area((unsigned long)(&__init_begin), 368 (unsigned long)(&__init_end), 369 "init"); 370#endif 371} 372 373#ifdef CONFIG_BLK_DEV_INITRD 374 375static int keep_initrd; 376 377void free_initrd_mem(unsigned long start, unsigned long end) 378{ 379#ifdef CONFIG_XIP_KERNEL 380 /* Only bin initrd if it is in RAM... */ 381 if(!keep_initrd && start < 0x03000000) 382#else 383 if (!keep_initrd) 384#endif 385 free_area(start, end, "initrd"); 386} 387 388static int __init keepinitrd_setup(char *__unused) 389{ 390 keep_initrd = 1; 391 return 1; 392} 393 394__setup("keepinitrd", keepinitrd_setup); 395#endif 396