11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/arch/arm/mm/init.c 31da177e4SLinus Torvalds * 490072059SRussell King * Copyright (C) 1995-2005 Russell King 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or modify 71da177e4SLinus Torvalds * it under the terms of the GNU General Public License version 2 as 81da177e4SLinus Torvalds * published by the Free Software Foundation. 91da177e4SLinus Torvalds */ 101da177e4SLinus Torvalds #include <linux/kernel.h> 111da177e4SLinus Torvalds #include <linux/errno.h> 121da177e4SLinus Torvalds #include <linux/swap.h> 131da177e4SLinus Torvalds #include <linux/init.h> 141da177e4SLinus Torvalds #include <linux/bootmem.h> 151da177e4SLinus Torvalds #include <linux/mman.h> 161da177e4SLinus Torvalds #include <linux/nodemask.h> 171da177e4SLinus Torvalds #include <linux/initrd.h> 183835f6cbSNicolas Pitre #include <linux/highmem.h> 195a0e3ad6STejun Heo #include <linux/gfp.h> 202778f620SRussell King #include <linux/memblock.h> 211da177e4SLinus Torvalds 221da177e4SLinus Torvalds #include <asm/mach-types.h> 2337efe642SRussell King #include <asm/sections.h> 241da177e4SLinus Torvalds #include <asm/setup.h> 2574d02fb9SRussell King #include <asm/sizes.h> 261da177e4SLinus Torvalds #include <asm/tlb.h> 27db9ef1afSFenkart/Bostandzhyan #include <asm/fixmap.h> 281da177e4SLinus Torvalds 291da177e4SLinus Torvalds #include <asm/mach/arch.h> 301da177e4SLinus Torvalds #include <asm/mach/map.h> 311da177e4SLinus Torvalds 321b2e2b73SRussell King #include "mm.h" 331b2e2b73SRussell King 34012d1f4aSRussell King static unsigned long phys_initrd_start __initdata = 0; 35012d1f4aSRussell King static unsigned long phys_initrd_size __initdata = 0; 36012d1f4aSRussell King 372b0d8c25SJeremy Kerr static int __init early_initrd(char *p) 38012d1f4aSRussell King { 39012d1f4aSRussell King unsigned long start, size; 402b0d8c25SJeremy Kerr char *endp; 41012d1f4aSRussell King 422b0d8c25SJeremy Kerr start = memparse(p, &endp); 432b0d8c25SJeremy Kerr if (*endp == ',') { 442b0d8c25SJeremy Kerr size = memparse(endp + 1, NULL); 45012d1f4aSRussell King 46012d1f4aSRussell King phys_initrd_start = start; 47012d1f4aSRussell King phys_initrd_size = size; 48012d1f4aSRussell King } 492b0d8c25SJeremy Kerr return 0; 50012d1f4aSRussell King } 512b0d8c25SJeremy Kerr early_param("initrd", early_initrd); 52012d1f4aSRussell King 53012d1f4aSRussell King static int __init parse_tag_initrd(const struct tag *tag) 54012d1f4aSRussell King { 55012d1f4aSRussell King printk(KERN_WARNING "ATAG_INITRD is deprecated; " 56012d1f4aSRussell King "please update your bootloader.\n"); 57012d1f4aSRussell King phys_initrd_start = __virt_to_phys(tag->u.initrd.start); 58012d1f4aSRussell King phys_initrd_size = tag->u.initrd.size; 59012d1f4aSRussell King return 0; 60012d1f4aSRussell King } 61012d1f4aSRussell King 62012d1f4aSRussell King __tagtable(ATAG_INITRD, parse_tag_initrd); 63012d1f4aSRussell King 64012d1f4aSRussell King static int __init parse_tag_initrd2(const struct tag *tag) 65012d1f4aSRussell King { 66012d1f4aSRussell King phys_initrd_start = tag->u.initrd.start; 67012d1f4aSRussell King phys_initrd_size = tag->u.initrd.size; 68012d1f4aSRussell King return 0; 69012d1f4aSRussell King } 70012d1f4aSRussell King 71012d1f4aSRussell King __tagtable(ATAG_INITRD2, parse_tag_initrd2); 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds /* 744b5f32ceSNicolas Pitre * This keeps memory configuration data used by a couple memory 754b5f32ceSNicolas Pitre * initialization functions, as well as show_mem() for the skipping 764b5f32ceSNicolas Pitre * of holes in the memory map. It is populated by arm_add_memory(). 771da177e4SLinus Torvalds */ 784b5f32ceSNicolas Pitre struct meminfo meminfo; 795e709827SRay Lehtiniemi 801da177e4SLinus Torvalds void show_mem(void) 811da177e4SLinus Torvalds { 821da177e4SLinus Torvalds int free = 0, total = 0, reserved = 0; 83be370302SRussell King int shared = 0, cached = 0, slab = 0, i; 845e709827SRay Lehtiniemi struct meminfo * mi = &meminfo; 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds printk("Mem-info:\n"); 871da177e4SLinus Torvalds show_free_areas(); 88be370302SRussell King 89be370302SRussell King for_each_bank (i, mi) { 90d2a38ef9SRussell King struct membank *bank = &mi->bank[i]; 915e709827SRay Lehtiniemi unsigned int pfn1, pfn2; 921da177e4SLinus Torvalds struct page *page, *end; 931da177e4SLinus Torvalds 94d2a38ef9SRussell King pfn1 = bank_pfn_start(bank); 95d2a38ef9SRussell King pfn2 = bank_pfn_end(bank); 965e709827SRay Lehtiniemi 97ea056df7SCatalin Marinas page = pfn_to_page(pfn1); 98ea056df7SCatalin Marinas end = pfn_to_page(pfn2 - 1) + 1; 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds do { 1011da177e4SLinus Torvalds total++; 1021da177e4SLinus Torvalds if (PageReserved(page)) 1031da177e4SLinus Torvalds reserved++; 1041da177e4SLinus Torvalds else if (PageSwapCache(page)) 1051da177e4SLinus Torvalds cached++; 1061da177e4SLinus Torvalds else if (PageSlab(page)) 1071da177e4SLinus Torvalds slab++; 1081da177e4SLinus Torvalds else if (!page_count(page)) 1091da177e4SLinus Torvalds free++; 1101da177e4SLinus Torvalds else 1111da177e4SLinus Torvalds shared += page_count(page) - 1; 1121da177e4SLinus Torvalds page++; 1131da177e4SLinus Torvalds } while (page < end); 1141da177e4SLinus Torvalds } 1151da177e4SLinus Torvalds 1161da177e4SLinus Torvalds printk("%d pages of RAM\n", total); 1171da177e4SLinus Torvalds printk("%d free pages\n", free); 1181da177e4SLinus Torvalds printk("%d reserved pages\n", reserved); 1191da177e4SLinus Torvalds printk("%d slab pages\n", slab); 1201da177e4SLinus Torvalds printk("%d pages shared\n", shared); 1211da177e4SLinus Torvalds printk("%d pages swap cached\n", cached); 1221da177e4SLinus Torvalds } 1231da177e4SLinus Torvalds 124be370302SRussell King static void __init find_limits(struct meminfo *mi, 125dde5828fSRussell King unsigned long *min, unsigned long *max_low, unsigned long *max_high) 126dde5828fSRussell King { 127dde5828fSRussell King int i; 128dde5828fSRussell King 129dde5828fSRussell King *min = -1UL; 130dde5828fSRussell King *max_low = *max_high = 0; 131dde5828fSRussell King 132be370302SRussell King for_each_bank (i, mi) { 133dde5828fSRussell King struct membank *bank = &mi->bank[i]; 134dde5828fSRussell King unsigned long start, end; 135dde5828fSRussell King 136dde5828fSRussell King start = bank_pfn_start(bank); 137dde5828fSRussell King end = bank_pfn_end(bank); 138dde5828fSRussell King 139dde5828fSRussell King if (*min > start) 140dde5828fSRussell King *min = start; 141dde5828fSRussell King if (*max_high < end) 142dde5828fSRussell King *max_high = end; 143dde5828fSRussell King if (bank->highmem) 144dde5828fSRussell King continue; 145dde5828fSRussell King if (*max_low < end) 146dde5828fSRussell King *max_low = end; 147dde5828fSRussell King } 148dde5828fSRussell King } 149dde5828fSRussell King 150be370302SRussell King static void __init arm_bootmem_init(struct meminfo *mi, 151dde5828fSRussell King unsigned long start_pfn, unsigned long end_pfn) 1521da177e4SLinus Torvalds { 153719c1514SBenjamin Herrenschmidt struct memblock_region *reg; 15490072059SRussell King unsigned int boot_pages; 1552778f620SRussell King phys_addr_t bitmap; 15690072059SRussell King pg_data_t *pgdat; 15790072059SRussell King int i; 1581da177e4SLinus Torvalds 15990072059SRussell King /* 1602778f620SRussell King * Allocate the bootmem bitmap page. This must be in a region 1612778f620SRussell King * of memory which has already been mapped. 1621da177e4SLinus Torvalds */ 16390072059SRussell King boot_pages = bootmem_bootmap_pages(end_pfn - start_pfn); 1642778f620SRussell King bitmap = memblock_alloc_base(boot_pages << PAGE_SHIFT, L1_CACHE_BYTES, 1652778f620SRussell King __pfn_to_phys(end_pfn)); 1661da177e4SLinus Torvalds 1671da177e4SLinus Torvalds /* 168be370302SRussell King * Initialise the bootmem allocator, handing the 16990072059SRussell King * memory banks over to bootmem. 1701da177e4SLinus Torvalds */ 171be370302SRussell King node_set_online(0); 172be370302SRussell King pgdat = NODE_DATA(0); 1732778f620SRussell King init_bootmem_node(pgdat, __phys_to_pfn(bitmap), start_pfn, end_pfn); 17490072059SRussell King 175be370302SRussell King for_each_bank(i, mi) { 176d2a38ef9SRussell King struct membank *bank = &mi->bank[i]; 177dde5828fSRussell King if (!bank->highmem) 178be370302SRussell King free_bootmem(bank_phys_start(bank), bank_phys_size(bank)); 179d2a38ef9SRussell King } 1801da177e4SLinus Torvalds 1811da177e4SLinus Torvalds /* 1822778f620SRussell King * Reserve the memblock reserved regions in bootmem. 1831da177e4SLinus Torvalds */ 184719c1514SBenjamin Herrenschmidt for_each_memblock(reserved, reg) { 185c7fc2de0SYinghai Lu phys_addr_t start = memblock_region_reserved_base_pfn(reg); 186c7fc2de0SYinghai Lu phys_addr_t end = memblock_region_reserved_end_pfn(reg); 187719c1514SBenjamin Herrenschmidt if (start >= start_pfn && end <= end_pfn) 1882778f620SRussell King reserve_bootmem_node(pgdat, __pfn_to_phys(start), 189719c1514SBenjamin Herrenschmidt (end - start) << PAGE_SHIFT, 1902778f620SRussell King BOOTMEM_DEFAULT); 191b7a69ac3SRussell King } 192b7a69ac3SRussell King } 193b7a69ac3SRussell King 194a9deb137SRussell King static void __init arm_bootmem_free(struct meminfo *mi, unsigned long min, 195a9deb137SRussell King unsigned long max_low, unsigned long max_high) 196b7a69ac3SRussell King { 197b7a69ac3SRussell King unsigned long zone_size[MAX_NR_ZONES], zhole_size[MAX_NR_ZONES]; 198b7a69ac3SRussell King int i; 199b7a69ac3SRussell King 20090072059SRussell King /* 201be370302SRussell King * initialise the zones. 20290072059SRussell King */ 20390072059SRussell King memset(zone_size, 0, sizeof(zone_size)); 20490072059SRussell King 20590072059SRussell King /* 206be370302SRussell King * The memory size has already been determined. If we need 207be370302SRussell King * to do anything fancy with the allocation of this memory 208be370302SRussell King * to the zones, now is the time to do it. 20990072059SRussell King */ 210dde5828fSRussell King zone_size[0] = max_low - min; 211dde5828fSRussell King #ifdef CONFIG_HIGHMEM 212dde5828fSRussell King zone_size[ZONE_HIGHMEM] = max_high - max_low; 213dde5828fSRussell King #endif 21490072059SRussell King 21590072059SRussell King /* 216be370302SRussell King * Calculate the size of the holes. 217be370302SRussell King * holes = node_size - sum(bank_sizes) 21890072059SRussell King */ 219dde5828fSRussell King memcpy(zhole_size, zone_size, sizeof(zhole_size)); 220be370302SRussell King for_each_bank(i, mi) { 221dde5828fSRussell King int idx = 0; 222dde5828fSRussell King #ifdef CONFIG_HIGHMEM 223dde5828fSRussell King if (mi->bank[i].highmem) 224dde5828fSRussell King idx = ZONE_HIGHMEM; 225dde5828fSRussell King #endif 226dde5828fSRussell King zhole_size[idx] -= bank_pfn_size(&mi->bank[i]); 227dde5828fSRussell King } 22890072059SRussell King 22990072059SRussell King /* 23090072059SRussell King * Adjust the sizes according to any special requirements for 23190072059SRussell King * this machine type. 23290072059SRussell King */ 233b65b4781SRussell King arch_adjust_zones(zone_size, zhole_size); 23490072059SRussell King 235be370302SRussell King free_area_init_node(0, zone_size, min, zhole_size); 23690072059SRussell King } 23790072059SRussell King 238b7cfda9fSRussell King #ifndef CONFIG_SPARSEMEM 239b7cfda9fSRussell King int pfn_valid(unsigned long pfn) 240b7cfda9fSRussell King { 2415e6f6aa1SBenjamin Herrenschmidt return memblock_is_memory(pfn << PAGE_SHIFT); 242b7cfda9fSRussell King } 243b7cfda9fSRussell King EXPORT_SYMBOL(pfn_valid); 244657e12fdSRussell King 245eda2e5dcSRussell King static void arm_memory_present(void) 246657e12fdSRussell King { 247657e12fdSRussell King } 248657e12fdSRussell King #else 249eda2e5dcSRussell King static void arm_memory_present(void) 250657e12fdSRussell King { 251719c1514SBenjamin Herrenschmidt struct memblock_region *reg; 252719c1514SBenjamin Herrenschmidt 2537c996361SYinghai Lu for_each_memblock(memory, reg) 254c7fc2de0SYinghai Lu memory_present(0, memblock_region_memory_base_pfn(reg), 255c7fc2de0SYinghai Lu memblock_region_memory_end_pfn(reg)); 256657e12fdSRussell King } 257b7cfda9fSRussell King #endif 258b7cfda9fSRussell King 2598d717a52SRussell King void __init arm_memblock_init(struct meminfo *mi, struct machine_desc *mdesc) 2602778f620SRussell King { 2612778f620SRussell King int i; 2622778f620SRussell King 2632778f620SRussell King memblock_init(); 2642778f620SRussell King for (i = 0; i < mi->nr_banks; i++) 2652778f620SRussell King memblock_add(mi->bank[i].start, mi->bank[i].size); 2662778f620SRussell King 2672778f620SRussell King /* Register the kernel text, kernel data and initrd with memblock. */ 2682778f620SRussell King #ifdef CONFIG_XIP_KERNEL 2692778f620SRussell King memblock_reserve(__pa(_data), _end - _data); 2702778f620SRussell King #else 2712778f620SRussell King memblock_reserve(__pa(_stext), _end - _stext); 2722778f620SRussell King #endif 2732778f620SRussell King #ifdef CONFIG_BLK_DEV_INITRD 2742778f620SRussell King if (phys_initrd_size) { 2752778f620SRussell King memblock_reserve(phys_initrd_start, phys_initrd_size); 2762778f620SRussell King 2772778f620SRussell King /* Now convert initrd to virtual addresses */ 2782778f620SRussell King initrd_start = __phys_to_virt(phys_initrd_start); 2792778f620SRussell King initrd_end = initrd_start + phys_initrd_size; 2802778f620SRussell King } 2812778f620SRussell King #endif 2822778f620SRussell King 2832778f620SRussell King arm_mm_memblock_reserve(); 2842778f620SRussell King 2858d717a52SRussell King /* reserve any platform specific memblock areas */ 2868d717a52SRussell King if (mdesc->reserve) 2878d717a52SRussell King mdesc->reserve(); 2888d717a52SRussell King 2892778f620SRussell King memblock_analyze(); 2902778f620SRussell King memblock_dump_all(); 2912778f620SRussell King } 2922778f620SRussell King 2938d717a52SRussell King void __init bootmem_init(void) 29490072059SRussell King { 2954b5f32ceSNicolas Pitre struct meminfo *mi = &meminfo; 296dde5828fSRussell King unsigned long min, max_low, max_high; 29790072059SRussell King 298dde5828fSRussell King max_low = max_high = 0; 299dde5828fSRussell King 300be370302SRussell King find_limits(mi, &min, &max_low, &max_high); 301dde5828fSRussell King 302be370302SRussell King arm_bootmem_init(mi, min, max_low); 303dde5828fSRussell King 304b7a69ac3SRussell King /* 305657e12fdSRussell King * Sparsemem tries to allocate bootmem in memory_present(), 306657e12fdSRussell King * so must be done after the fixed reservations 307657e12fdSRussell King */ 308eda2e5dcSRussell King arm_memory_present(); 30990072059SRussell King 310b7a69ac3SRussell King /* 311b7a69ac3SRussell King * sparse_init() needs the bootmem allocator up and running. 312b7a69ac3SRussell King */ 313b7a69ac3SRussell King sparse_init(); 314b7a69ac3SRussell King 315b7a69ac3SRussell King /* 316be370302SRussell King * Now free the memory - free_area_init_node needs 317b7a69ac3SRussell King * the sparse mem_map arrays initialized by sparse_init() 318b7a69ac3SRussell King * for memmap_init_zone(), otherwise all PFNs are invalid. 319b7a69ac3SRussell King */ 320a9deb137SRussell King arm_bootmem_free(mi, min, max_low, max_high); 321b7a69ac3SRussell King 322dde5828fSRussell King high_memory = __va((max_low << PAGE_SHIFT) - 1) + 1; 32390072059SRussell King 32490072059SRussell King /* 32590072059SRussell King * This doesn't seem to be used by the Linux memory manager any 32690072059SRussell King * more, but is used by ll_rw_block. If we can get rid of it, we 32790072059SRussell King * also get rid of some of the stuff above as well. 32890072059SRussell King * 32990072059SRussell King * Note: max_low_pfn and max_pfn reflect the number of _pages_ in 33090072059SRussell King * the system, not the maximum PFN. 33190072059SRussell King */ 332dde5828fSRussell King max_low_pfn = max_low - PHYS_PFN_OFFSET; 333dde5828fSRussell King max_pfn = max_high - PHYS_PFN_OFFSET; 33490072059SRussell King } 33590072059SRussell King 3366db015e4SNicolas Pitre static inline int free_area(unsigned long pfn, unsigned long end, char *s) 3371da177e4SLinus Torvalds { 3386db015e4SNicolas Pitre unsigned int pages = 0, size = (end - pfn) << (PAGE_SHIFT - 10); 3391da177e4SLinus Torvalds 3406db015e4SNicolas Pitre for (; pfn < end; pfn++) { 3416db015e4SNicolas Pitre struct page *page = pfn_to_page(pfn); 3421da177e4SLinus Torvalds ClearPageReserved(page); 3437835e98bSNick Piggin init_page_count(page); 3446db015e4SNicolas Pitre __free_page(page); 3456db015e4SNicolas Pitre pages++; 3461da177e4SLinus Torvalds } 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds if (size && s) 3491da177e4SLinus Torvalds printk(KERN_INFO "Freeing %s memory: %dK\n", s, size); 3506db015e4SNicolas Pitre 3516db015e4SNicolas Pitre return pages; 3521da177e4SLinus Torvalds } 3531da177e4SLinus Torvalds 354a013053dSRussell King static inline void 355be370302SRussell King free_memmap(unsigned long start_pfn, unsigned long end_pfn) 356a013053dSRussell King { 357a013053dSRussell King struct page *start_pg, *end_pg; 358a013053dSRussell King unsigned long pg, pgend; 359a013053dSRussell King 360a013053dSRussell King /* 361a013053dSRussell King * Convert start_pfn/end_pfn to a struct page pointer. 362a013053dSRussell King */ 3633257f43dSCatalin Marinas start_pg = pfn_to_page(start_pfn - 1) + 1; 364a013053dSRussell King end_pg = pfn_to_page(end_pfn); 365a013053dSRussell King 366a013053dSRussell King /* 367a013053dSRussell King * Convert to physical addresses, and 368a013053dSRussell King * round start upwards and end downwards. 369a013053dSRussell King */ 370a013053dSRussell King pg = PAGE_ALIGN(__pa(start_pg)); 371a013053dSRussell King pgend = __pa(end_pg) & PAGE_MASK; 372a013053dSRussell King 373a013053dSRussell King /* 374a013053dSRussell King * If there are free pages between these, 375a013053dSRussell King * free the section of the memmap array. 376a013053dSRussell King */ 377a013053dSRussell King if (pg < pgend) 378be370302SRussell King free_bootmem(pg, pgend - pg); 379a013053dSRussell King } 380a013053dSRussell King 381a013053dSRussell King /* 382a013053dSRussell King * The mem_map array can get very big. Free the unused area of the memory map. 383a013053dSRussell King */ 384be370302SRussell King static void __init free_unused_memmap(struct meminfo *mi) 385a013053dSRussell King { 386a013053dSRussell King unsigned long bank_start, prev_bank_end = 0; 387a013053dSRussell King unsigned int i; 388a013053dSRussell King 389a013053dSRussell King /* 3903260e529SMichael Bohan * This relies on each bank being in address order. 3913260e529SMichael Bohan * The banks are sorted previously in bootmem_init(). 392a013053dSRussell King */ 393be370302SRussell King for_each_bank(i, mi) { 394d2a38ef9SRussell King struct membank *bank = &mi->bank[i]; 395d2a38ef9SRussell King 396d2a38ef9SRussell King bank_start = bank_pfn_start(bank); 397a013053dSRussell King 398a013053dSRussell King /* 399a013053dSRussell King * If we had a previous bank, and there is a space 400a013053dSRussell King * between the current bank and the previous, free it. 401a013053dSRussell King */ 4023260e529SMichael Bohan if (prev_bank_end && prev_bank_end < bank_start) 403be370302SRussell King free_memmap(prev_bank_end, bank_start); 404a013053dSRussell King 4053260e529SMichael Bohan /* 4063260e529SMichael Bohan * Align up here since the VM subsystem insists that the 4073260e529SMichael Bohan * memmap entries are valid from the bank end aligned to 4083260e529SMichael Bohan * MAX_ORDER_NR_PAGES. 4093260e529SMichael Bohan */ 4103260e529SMichael Bohan prev_bank_end = ALIGN(bank_pfn_end(bank), MAX_ORDER_NR_PAGES); 411a013053dSRussell King } 412a013053dSRussell King } 413a013053dSRussell King 4141da177e4SLinus Torvalds /* 4151da177e4SLinus Torvalds * mem_init() marks the free areas in the mem_map and tells us how much 4161da177e4SLinus Torvalds * memory is free. This is done after various parts of the system have 4171da177e4SLinus Torvalds * claimed their memory after the kernel image. 4181da177e4SLinus Torvalds */ 4191da177e4SLinus Torvalds void __init mem_init(void) 4201da177e4SLinus Torvalds { 421db9ef1afSFenkart/Bostandzhyan unsigned long reserved_pages, free_pages; 422be370302SRussell King int i; 4231dbd30e9SLinus Walleij #ifdef CONFIG_HAVE_TCM 4241dbd30e9SLinus Walleij /* These pointers are filled in on TCM detection */ 4251dbd30e9SLinus Walleij extern u32 dtcm_end; 4261dbd30e9SLinus Walleij extern u32 itcm_end; 4271dbd30e9SLinus Walleij #endif 4281da177e4SLinus Torvalds 4293835f6cbSNicolas Pitre max_mapnr = pfn_to_page(max_pfn + PHYS_PFN_OFFSET) - mem_map; 4301da177e4SLinus Torvalds 4311da177e4SLinus Torvalds /* this will put all unused low memory onto the freelists */ 432be370302SRussell King free_unused_memmap(&meminfo); 4331da177e4SLinus Torvalds 434be370302SRussell King totalram_pages += free_all_bootmem(); 4351da177e4SLinus Torvalds 4361da177e4SLinus Torvalds #ifdef CONFIG_SA1111 4371da177e4SLinus Torvalds /* now that our DMA memory is actually so designated, we can free it */ 4386db015e4SNicolas Pitre totalram_pages += free_area(PHYS_PFN_OFFSET, 4396db015e4SNicolas Pitre __phys_to_pfn(__pa(swapper_pg_dir)), NULL); 4401da177e4SLinus Torvalds #endif 4411da177e4SLinus Torvalds 4423835f6cbSNicolas Pitre #ifdef CONFIG_HIGHMEM 4433835f6cbSNicolas Pitre /* set highmem page free */ 444be370302SRussell King for_each_bank (i, &meminfo) { 4453835f6cbSNicolas Pitre unsigned long start = bank_pfn_start(&meminfo.bank[i]); 4463835f6cbSNicolas Pitre unsigned long end = bank_pfn_end(&meminfo.bank[i]); 4473835f6cbSNicolas Pitre if (start >= max_low_pfn + PHYS_PFN_OFFSET) 4483835f6cbSNicolas Pitre totalhigh_pages += free_area(start, end, NULL); 4493835f6cbSNicolas Pitre } 4503835f6cbSNicolas Pitre totalram_pages += totalhigh_pages; 4513835f6cbSNicolas Pitre #endif 4523835f6cbSNicolas Pitre 453db9ef1afSFenkart/Bostandzhyan reserved_pages = free_pages = 0; 454db9ef1afSFenkart/Bostandzhyan 455be370302SRussell King for_each_bank(i, &meminfo) { 456db9ef1afSFenkart/Bostandzhyan struct membank *bank = &meminfo.bank[i]; 457db9ef1afSFenkart/Bostandzhyan unsigned int pfn1, pfn2; 458db9ef1afSFenkart/Bostandzhyan struct page *page, *end; 459db9ef1afSFenkart/Bostandzhyan 460db9ef1afSFenkart/Bostandzhyan pfn1 = bank_pfn_start(bank); 461db9ef1afSFenkart/Bostandzhyan pfn2 = bank_pfn_end(bank); 462db9ef1afSFenkart/Bostandzhyan 463ea056df7SCatalin Marinas page = pfn_to_page(pfn1); 464ea056df7SCatalin Marinas end = pfn_to_page(pfn2 - 1) + 1; 465db9ef1afSFenkart/Bostandzhyan 466db9ef1afSFenkart/Bostandzhyan do { 467db9ef1afSFenkart/Bostandzhyan if (PageReserved(page)) 468db9ef1afSFenkart/Bostandzhyan reserved_pages++; 469db9ef1afSFenkart/Bostandzhyan else if (!page_count(page)) 470db9ef1afSFenkart/Bostandzhyan free_pages++; 471db9ef1afSFenkart/Bostandzhyan page++; 472db9ef1afSFenkart/Bostandzhyan } while (page < end); 473db9ef1afSFenkart/Bostandzhyan } 474db9ef1afSFenkart/Bostandzhyan 4751da177e4SLinus Torvalds /* 4761da177e4SLinus Torvalds * Since our memory may not be contiguous, calculate the 4771da177e4SLinus Torvalds * real number of pages we have in this system 4781da177e4SLinus Torvalds */ 4791da177e4SLinus Torvalds printk(KERN_INFO "Memory:"); 4801da177e4SLinus Torvalds num_physpages = 0; 4811da177e4SLinus Torvalds for (i = 0; i < meminfo.nr_banks; i++) { 482d2a38ef9SRussell King num_physpages += bank_pfn_size(&meminfo.bank[i]); 483d2a38ef9SRussell King printk(" %ldMB", bank_phys_size(&meminfo.bank[i]) >> 20); 4841da177e4SLinus Torvalds } 4851da177e4SLinus Torvalds printk(" = %luMB total\n", num_physpages >> (20 - PAGE_SHIFT)); 4866db015e4SNicolas Pitre 487db9ef1afSFenkart/Bostandzhyan printk(KERN_NOTICE "Memory: %luk/%luk available, %luk reserved, %luK highmem\n", 488db9ef1afSFenkart/Bostandzhyan nr_free_pages() << (PAGE_SHIFT-10), 489db9ef1afSFenkart/Bostandzhyan free_pages << (PAGE_SHIFT-10), 490db9ef1afSFenkart/Bostandzhyan reserved_pages << (PAGE_SHIFT-10), 4914b529401SAndreas Fenkart totalhigh_pages << (PAGE_SHIFT-10)); 4921da177e4SLinus Torvalds 493db9ef1afSFenkart/Bostandzhyan #define MLK(b, t) b, t, ((t) - (b)) >> 10 494db9ef1afSFenkart/Bostandzhyan #define MLM(b, t) b, t, ((t) - (b)) >> 20 495db9ef1afSFenkart/Bostandzhyan #define MLK_ROUNDUP(b, t) b, t, DIV_ROUND_UP(((t) - (b)), SZ_1K) 496db9ef1afSFenkart/Bostandzhyan 497db9ef1afSFenkart/Bostandzhyan printk(KERN_NOTICE "Virtual kernel memory layout:\n" 498db9ef1afSFenkart/Bostandzhyan " vector : 0x%08lx - 0x%08lx (%4ld kB)\n" 49907d2a5c7SLinus Walleij #ifdef CONFIG_HAVE_TCM 50007d2a5c7SLinus Walleij " DTCM : 0x%08lx - 0x%08lx (%4ld kB)\n" 50107d2a5c7SLinus Walleij " ITCM : 0x%08lx - 0x%08lx (%4ld kB)\n" 50207d2a5c7SLinus Walleij #endif 503db9ef1afSFenkart/Bostandzhyan " fixmap : 0x%08lx - 0x%08lx (%4ld kB)\n" 504a7bd08c8SFenkart/Bostandzhyan #ifdef CONFIG_MMU 505a7bd08c8SFenkart/Bostandzhyan " DMA : 0x%08lx - 0x%08lx (%4ld MB)\n" 506a7bd08c8SFenkart/Bostandzhyan #endif 507db9ef1afSFenkart/Bostandzhyan " vmalloc : 0x%08lx - 0x%08lx (%4ld MB)\n" 508db9ef1afSFenkart/Bostandzhyan " lowmem : 0x%08lx - 0x%08lx (%4ld MB)\n" 509db9ef1afSFenkart/Bostandzhyan #ifdef CONFIG_HIGHMEM 510db9ef1afSFenkart/Bostandzhyan " pkmap : 0x%08lx - 0x%08lx (%4ld MB)\n" 511db9ef1afSFenkart/Bostandzhyan #endif 512db9ef1afSFenkart/Bostandzhyan " modules : 0x%08lx - 0x%08lx (%4ld MB)\n" 513db9ef1afSFenkart/Bostandzhyan " .init : 0x%p" " - 0x%p" " (%4d kB)\n" 514db9ef1afSFenkart/Bostandzhyan " .text : 0x%p" " - 0x%p" " (%4d kB)\n" 515db9ef1afSFenkart/Bostandzhyan " .data : 0x%p" " - 0x%p" " (%4d kB)\n", 516db9ef1afSFenkart/Bostandzhyan 517db9ef1afSFenkart/Bostandzhyan MLK(UL(CONFIG_VECTORS_BASE), UL(CONFIG_VECTORS_BASE) + 518db9ef1afSFenkart/Bostandzhyan (PAGE_SIZE)), 51907d2a5c7SLinus Walleij #ifdef CONFIG_HAVE_TCM 5201dbd30e9SLinus Walleij MLK(DTCM_OFFSET, (unsigned long) dtcm_end), 5211dbd30e9SLinus Walleij MLK(ITCM_OFFSET, (unsigned long) itcm_end), 52207d2a5c7SLinus Walleij #endif 523db9ef1afSFenkart/Bostandzhyan MLK(FIXADDR_START, FIXADDR_TOP), 524a7bd08c8SFenkart/Bostandzhyan #ifdef CONFIG_MMU 525a7bd08c8SFenkart/Bostandzhyan MLM(CONSISTENT_BASE, CONSISTENT_END), 526a7bd08c8SFenkart/Bostandzhyan #endif 527c931b4f6SFenkart/Bostandzhyan MLM(VMALLOC_START, VMALLOC_END), 528db9ef1afSFenkart/Bostandzhyan MLM(PAGE_OFFSET, (unsigned long)high_memory), 529db9ef1afSFenkart/Bostandzhyan #ifdef CONFIG_HIGHMEM 530db9ef1afSFenkart/Bostandzhyan MLM(PKMAP_BASE, (PKMAP_BASE) + (LAST_PKMAP) * 531db9ef1afSFenkart/Bostandzhyan (PAGE_SIZE)), 532db9ef1afSFenkart/Bostandzhyan #endif 533db9ef1afSFenkart/Bostandzhyan MLM(MODULES_VADDR, MODULES_END), 534db9ef1afSFenkart/Bostandzhyan 535db9ef1afSFenkart/Bostandzhyan MLK_ROUNDUP(__init_begin, __init_end), 536db9ef1afSFenkart/Bostandzhyan MLK_ROUNDUP(_text, _etext), 537db9ef1afSFenkart/Bostandzhyan MLK_ROUNDUP(_data, _edata)); 538db9ef1afSFenkart/Bostandzhyan 539db9ef1afSFenkart/Bostandzhyan #undef MLK 540db9ef1afSFenkart/Bostandzhyan #undef MLM 541db9ef1afSFenkart/Bostandzhyan #undef MLK_ROUNDUP 542db9ef1afSFenkart/Bostandzhyan 543a1839272SFenkart/Bostandzhyan /* 544a1839272SFenkart/Bostandzhyan * Check boundaries twice: Some fundamental inconsistencies can 545a1839272SFenkart/Bostandzhyan * be detected at build time already. 546a1839272SFenkart/Bostandzhyan */ 547a1839272SFenkart/Bostandzhyan #ifdef CONFIG_MMU 548a1839272SFenkart/Bostandzhyan BUILD_BUG_ON(VMALLOC_END > CONSISTENT_BASE); 549a1839272SFenkart/Bostandzhyan BUG_ON(VMALLOC_END > CONSISTENT_BASE); 550a1839272SFenkart/Bostandzhyan 551a1839272SFenkart/Bostandzhyan BUILD_BUG_ON(TASK_SIZE > MODULES_VADDR); 552a1839272SFenkart/Bostandzhyan BUG_ON(TASK_SIZE > MODULES_VADDR); 553a1839272SFenkart/Bostandzhyan #endif 554a1839272SFenkart/Bostandzhyan 555a1839272SFenkart/Bostandzhyan #ifdef CONFIG_HIGHMEM 556a1839272SFenkart/Bostandzhyan BUILD_BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > PAGE_OFFSET); 557a1839272SFenkart/Bostandzhyan BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > PAGE_OFFSET); 558a1839272SFenkart/Bostandzhyan #endif 559a1839272SFenkart/Bostandzhyan 5601da177e4SLinus Torvalds if (PAGE_SIZE >= 16384 && num_physpages <= 128) { 5611da177e4SLinus Torvalds extern int sysctl_overcommit_memory; 5621da177e4SLinus Torvalds /* 5631da177e4SLinus Torvalds * On a machine this small we won't get 5641da177e4SLinus Torvalds * anywhere without overcommit, so turn 5651da177e4SLinus Torvalds * it on by default. 5661da177e4SLinus Torvalds */ 5671da177e4SLinus Torvalds sysctl_overcommit_memory = OVERCOMMIT_ALWAYS; 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds } 5701da177e4SLinus Torvalds 5711da177e4SLinus Torvalds void free_initmem(void) 5721da177e4SLinus Torvalds { 573bc581770SLinus Walleij #ifdef CONFIG_HAVE_TCM 574ea208f64SLinus Walleij extern char __tcm_start, __tcm_end; 575bc581770SLinus Walleij 576ea208f64SLinus Walleij totalram_pages += free_area(__phys_to_pfn(__pa(&__tcm_start)), 577ea208f64SLinus Walleij __phys_to_pfn(__pa(&__tcm_end)), 578bc581770SLinus Walleij "TCM link"); 579bc581770SLinus Walleij #endif 580bc581770SLinus Walleij 5816db015e4SNicolas Pitre if (!machine_is_integrator() && !machine_is_cintegrator()) 58237efe642SRussell King totalram_pages += free_area(__phys_to_pfn(__pa(__init_begin)), 58337efe642SRussell King __phys_to_pfn(__pa(__init_end)), 5841da177e4SLinus Torvalds "init"); 5851da177e4SLinus Torvalds } 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds #ifdef CONFIG_BLK_DEV_INITRD 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds static int keep_initrd; 5901da177e4SLinus Torvalds 5911da177e4SLinus Torvalds void free_initrd_mem(unsigned long start, unsigned long end) 5921da177e4SLinus Torvalds { 5931da177e4SLinus Torvalds if (!keep_initrd) 5946db015e4SNicolas Pitre totalram_pages += free_area(__phys_to_pfn(__pa(start)), 5956db015e4SNicolas Pitre __phys_to_pfn(__pa(end)), 5966db015e4SNicolas Pitre "initrd"); 5971da177e4SLinus Torvalds } 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds static int __init keepinitrd_setup(char *__unused) 6001da177e4SLinus Torvalds { 6011da177e4SLinus Torvalds keep_initrd = 1; 6021da177e4SLinus Torvalds return 1; 6031da177e4SLinus Torvalds } 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds __setup("keepinitrd", keepinitrd_setup); 6061da177e4SLinus Torvalds #endif 607