blob: a453982fdcefbc25511e03d608d8e362c5c7df22 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/arch/arm/mm/init.c
3 *
Russell King90072052005-10-28 14:48:37 +01004 * Copyright (C) 1995-2005 Russell King
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/kernel.h>
11#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/swap.h>
13#include <linux/init.h>
14#include <linux/bootmem.h>
15#include <linux/mman.h>
16#include <linux/nodemask.h>
17#include <linux/initrd.h>
Nicolas Pitre3835f6c2008-09-17 15:21:55 -040018#include <linux/highmem.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090019#include <linux/gfp.h>
Russell King2778f622010-07-09 16:27:52 +010020#include <linux/memblock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
22#include <asm/mach-types.h>
Russell King37efe642008-12-01 11:53:07 +000023#include <asm/sections.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <asm/setup.h>
Russell King74d02fb2006-04-04 21:47:43 +010025#include <asm/sizes.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <asm/tlb.h>
Fenkart/Bostandzhyandb9ef1a2010-02-07 21:45:47 +010027#include <asm/fixmap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29#include <asm/mach/arch.h>
30#include <asm/mach/map.h>
31
Russell King1b2e2b72006-08-21 17:06:38 +010032#include "mm.h"
33
Russell King012d1f42008-09-06 10:57:03 +010034static unsigned long phys_initrd_start __initdata = 0;
35static unsigned long phys_initrd_size __initdata = 0;
36
Jeremy Kerr2b0d8c22010-01-11 23:17:34 +010037static int __init early_initrd(char *p)
Russell King012d1f42008-09-06 10:57:03 +010038{
39 unsigned long start, size;
Jeremy Kerr2b0d8c22010-01-11 23:17:34 +010040 char *endp;
Russell King012d1f42008-09-06 10:57:03 +010041
Jeremy Kerr2b0d8c22010-01-11 23:17:34 +010042 start = memparse(p, &endp);
43 if (*endp == ',') {
44 size = memparse(endp + 1, NULL);
Russell King012d1f42008-09-06 10:57:03 +010045
46 phys_initrd_start = start;
47 phys_initrd_size = size;
48 }
Jeremy Kerr2b0d8c22010-01-11 23:17:34 +010049 return 0;
Russell King012d1f42008-09-06 10:57:03 +010050}
Jeremy Kerr2b0d8c22010-01-11 23:17:34 +010051early_param("initrd", early_initrd);
Russell King012d1f42008-09-06 10:57:03 +010052
53static int __init parse_tag_initrd(const struct tag *tag)
54{
55 printk(KERN_WARNING "ATAG_INITRD is deprecated; "
56 "please update your bootloader.\n");
57 phys_initrd_start = __virt_to_phys(tag->u.initrd.start);
58 phys_initrd_size = tag->u.initrd.size;
59 return 0;
60}
61
62__tagtable(ATAG_INITRD, parse_tag_initrd);
63
64static int __init parse_tag_initrd2(const struct tag *tag)
65{
66 phys_initrd_start = tag->u.initrd.start;
67 phys_initrd_size = tag->u.initrd.size;
68 return 0;
69}
70
71__tagtable(ATAG_INITRD2, parse_tag_initrd2);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
73/*
Nicolas Pitre4b5f32c2008-10-06 13:24:40 -040074 * This keeps memory configuration data used by a couple memory
75 * initialization functions, as well as show_mem() for the skipping
76 * of holes in the memory map. It is populated by arm_add_memory().
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 */
Nicolas Pitre4b5f32c2008-10-06 13:24:40 -040078struct meminfo meminfo;
Ray Lehtiniemi5e709822006-11-07 03:19:15 +010079
Linus Torvalds1da177e2005-04-16 15:20:36 -070080void show_mem(void)
81{
82 int free = 0, total = 0, reserved = 0;
Russell Kingbe370302010-05-07 17:40:33 +010083 int shared = 0, cached = 0, slab = 0, i;
Ray Lehtiniemi5e709822006-11-07 03:19:15 +010084 struct meminfo * mi = &meminfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
86 printk("Mem-info:\n");
87 show_free_areas();
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Russell Kingbe370302010-05-07 17:40:33 +010089 for_each_bank (i, mi) {
90 struct membank *bank = &mi->bank[i];
91 unsigned int pfn1, pfn2;
92 struct page *page, *end;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
Russell Kingbe370302010-05-07 17:40:33 +010094 pfn1 = bank_pfn_start(bank);
95 pfn2 = bank_pfn_end(bank);
Ray Lehtiniemi5e709822006-11-07 03:19:15 +010096
Russell Kingbe370302010-05-07 17:40:33 +010097 page = pfn_to_page(pfn1);
98 end = pfn_to_page(pfn2 - 1) + 1;
99
100 do {
101 total++;
102 if (PageReserved(page))
103 reserved++;
104 else if (PageSwapCache(page))
105 cached++;
106 else if (PageSlab(page))
107 slab++;
108 else if (!page_count(page))
109 free++;
110 else
111 shared += page_count(page) - 1;
112 page++;
113 } while (page < end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 }
115
116 printk("%d pages of RAM\n", total);
117 printk("%d free pages\n", free);
118 printk("%d reserved pages\n", reserved);
119 printk("%d slab pages\n", slab);
120 printk("%d pages shared\n", shared);
121 printk("%d pages swap cached\n", cached);
122}
123
Russell Kingbe370302010-05-07 17:40:33 +0100124static void __init find_limits(struct meminfo *mi,
Russell Kingdde58282009-08-15 12:36:00 +0100125 unsigned long *min, unsigned long *max_low, unsigned long *max_high)
126{
127 int i;
128
129 *min = -1UL;
130 *max_low = *max_high = 0;
131
Russell Kingbe370302010-05-07 17:40:33 +0100132 for_each_bank (i, mi) {
Russell Kingdde58282009-08-15 12:36:00 +0100133 struct membank *bank = &mi->bank[i];
134 unsigned long start, end;
135
136 start = bank_pfn_start(bank);
137 end = bank_pfn_end(bank);
138
139 if (*min > start)
140 *min = start;
141 if (*max_high < end)
142 *max_high = end;
143 if (bank->highmem)
144 continue;
145 if (*max_low < end)
146 *max_low = end;
147 }
148}
149
Russell Kingbe370302010-05-07 17:40:33 +0100150static void __init arm_bootmem_init(struct meminfo *mi,
Russell Kingdde58282009-08-15 12:36:00 +0100151 unsigned long start_pfn, unsigned long end_pfn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152{
Russell King90072052005-10-28 14:48:37 +0100153 unsigned int boot_pages;
Russell King2778f622010-07-09 16:27:52 +0100154 phys_addr_t bitmap;
Russell King90072052005-10-28 14:48:37 +0100155 pg_data_t *pgdat;
156 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 /*
Russell King2778f622010-07-09 16:27:52 +0100159 * Allocate the bootmem bitmap page. This must be in a region
160 * of memory which has already been mapped.
Russell King90072052005-10-28 14:48:37 +0100161 */
162 boot_pages = bootmem_bootmap_pages(end_pfn - start_pfn);
Russell King2778f622010-07-09 16:27:52 +0100163 bitmap = memblock_alloc_base(boot_pages << PAGE_SHIFT, L1_CACHE_BYTES,
164 __pfn_to_phys(end_pfn));
Russell King90072052005-10-28 14:48:37 +0100165
166 /*
Russell Kingbe370302010-05-07 17:40:33 +0100167 * Initialise the bootmem allocator, handing the
Russell King90072052005-10-28 14:48:37 +0100168 * memory banks over to bootmem.
169 */
Russell Kingbe370302010-05-07 17:40:33 +0100170 node_set_online(0);
171 pgdat = NODE_DATA(0);
Russell King2778f622010-07-09 16:27:52 +0100172 init_bootmem_node(pgdat, __phys_to_pfn(bitmap), start_pfn, end_pfn);
Russell King90072052005-10-28 14:48:37 +0100173
Russell Kingbe370302010-05-07 17:40:33 +0100174 for_each_bank(i, mi) {
Russell Kingd2a38ef2008-10-01 16:56:15 +0100175 struct membank *bank = &mi->bank[i];
Russell Kingdde58282009-08-15 12:36:00 +0100176 if (!bank->highmem)
Russell Kingbe370302010-05-07 17:40:33 +0100177 free_bootmem(bank_phys_start(bank), bank_phys_size(bank));
Russell Kingd2a38ef2008-10-01 16:56:15 +0100178 }
Russell King90072052005-10-28 14:48:37 +0100179
180 /*
Russell King2778f622010-07-09 16:27:52 +0100181 * Reserve the memblock reserved regions in bootmem.
Russell King90072052005-10-28 14:48:37 +0100182 */
Russell King2778f622010-07-09 16:27:52 +0100183 for (i = 0; i < memblock.reserved.cnt; i++) {
184 phys_addr_t start = memblock_start_pfn(&memblock.reserved, i);
185 if (start >= start_pfn &&
186 memblock_end_pfn(&memblock.reserved, i) <= end_pfn)
187 reserve_bootmem_node(pgdat, __pfn_to_phys(start),
188 memblock_size_bytes(&memblock.reserved, i),
189 BOOTMEM_DEFAULT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 }
Russell Kingb7a69ac2008-10-01 16:58:32 +0100191}
192
Russell Kingbe370302010-05-07 17:40:33 +0100193static void __init arm_bootmem_free(struct meminfo *mi)
Russell Kingb7a69ac2008-10-01 16:58:32 +0100194{
195 unsigned long zone_size[MAX_NR_ZONES], zhole_size[MAX_NR_ZONES];
Russell Kingdde58282009-08-15 12:36:00 +0100196 unsigned long min, max_low, max_high;
Russell Kingb7a69ac2008-10-01 16:58:32 +0100197 int i;
198
Russell Kingbe370302010-05-07 17:40:33 +0100199 find_limits(mi, &min, &max_low, &max_high);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
Russell King90072052005-10-28 14:48:37 +0100201 /*
Russell Kingbe370302010-05-07 17:40:33 +0100202 * initialise the zones.
Russell King90072052005-10-28 14:48:37 +0100203 */
204 memset(zone_size, 0, sizeof(zone_size));
Russell King90072052005-10-28 14:48:37 +0100205
206 /*
Russell Kingbe370302010-05-07 17:40:33 +0100207 * The memory size has already been determined. If we need
208 * to do anything fancy with the allocation of this memory
209 * to the zones, now is the time to do it.
Russell King90072052005-10-28 14:48:37 +0100210 */
Russell Kingdde58282009-08-15 12:36:00 +0100211 zone_size[0] = max_low - min;
212#ifdef CONFIG_HIGHMEM
213 zone_size[ZONE_HIGHMEM] = max_high - max_low;
214#endif
Russell King90072052005-10-28 14:48:37 +0100215
216 /*
Russell Kingbe370302010-05-07 17:40:33 +0100217 * Calculate the size of the holes.
218 * holes = node_size - sum(bank_sizes)
Russell King90072052005-10-28 14:48:37 +0100219 */
Russell Kingdde58282009-08-15 12:36:00 +0100220 memcpy(zhole_size, zone_size, sizeof(zhole_size));
Russell Kingbe370302010-05-07 17:40:33 +0100221 for_each_bank(i, mi) {
Russell Kingdde58282009-08-15 12:36:00 +0100222 int idx = 0;
223#ifdef CONFIG_HIGHMEM
224 if (mi->bank[i].highmem)
225 idx = ZONE_HIGHMEM;
226#endif
227 zhole_size[idx] -= bank_pfn_size(&mi->bank[i]);
228 }
Russell King90072052005-10-28 14:48:37 +0100229
230 /*
231 * Adjust the sizes according to any special requirements for
232 * this machine type.
233 */
Russell Kingb65b4782010-05-22 20:58:51 +0100234 arch_adjust_zones(zone_size, zhole_size);
Russell King90072052005-10-28 14:48:37 +0100235
Russell Kingbe370302010-05-07 17:40:33 +0100236 free_area_init_node(0, zone_size, min, zhole_size);
Russell King90072052005-10-28 14:48:37 +0100237}
238
Russell Kingb7cfda92009-09-07 15:06:42 +0100239#ifndef CONFIG_SPARSEMEM
240int pfn_valid(unsigned long pfn)
241{
242 struct meminfo *mi = &meminfo;
243 unsigned int left = 0, right = mi->nr_banks;
244
245 do {
246 unsigned int mid = (right + left) / 2;
247 struct membank *bank = &mi->bank[mid];
248
249 if (pfn < bank_pfn_start(bank))
250 right = mid;
251 else if (pfn >= bank_pfn_end(bank))
252 left = mid + 1;
253 else
254 return 1;
255 } while (left < right);
256 return 0;
257}
258EXPORT_SYMBOL(pfn_valid);
Russell King657e12f2009-10-29 17:06:17 +0000259
Russell Kingeda2e5d2010-07-01 12:00:57 +0100260static void arm_memory_present(void)
Russell King657e12f2009-10-29 17:06:17 +0000261{
262}
263#else
Russell Kingeda2e5d2010-07-01 12:00:57 +0100264static void arm_memory_present(void)
Russell King657e12f2009-10-29 17:06:17 +0000265{
266 int i;
Russell Kingeda2e5d2010-07-01 12:00:57 +0100267 for (i = 0; i < memblock.memory.cnt; i++)
268 memory_present(0, memblock_start_pfn(&memblock.memory, i),
269 memblock_end_pfn(&memblock.memory, i));
Russell King657e12f2009-10-29 17:06:17 +0000270}
Russell Kingb7cfda92009-09-07 15:06:42 +0100271#endif
272
Russell King8d717a52010-05-22 19:47:18 +0100273void __init arm_memblock_init(struct meminfo *mi, struct machine_desc *mdesc)
Russell King2778f622010-07-09 16:27:52 +0100274{
275 int i;
276
277 memblock_init();
278 for (i = 0; i < mi->nr_banks; i++)
279 memblock_add(mi->bank[i].start, mi->bank[i].size);
280
281 /* Register the kernel text, kernel data and initrd with memblock. */
282#ifdef CONFIG_XIP_KERNEL
283 memblock_reserve(__pa(_data), _end - _data);
284#else
285 memblock_reserve(__pa(_stext), _end - _stext);
286#endif
287#ifdef CONFIG_BLK_DEV_INITRD
288 if (phys_initrd_size) {
289 memblock_reserve(phys_initrd_start, phys_initrd_size);
290
291 /* Now convert initrd to virtual addresses */
292 initrd_start = __phys_to_virt(phys_initrd_start);
293 initrd_end = initrd_start + phys_initrd_size;
294 }
295#endif
296
297 arm_mm_memblock_reserve();
298
Russell King8d717a52010-05-22 19:47:18 +0100299 /* reserve any platform specific memblock areas */
300 if (mdesc->reserve)
301 mdesc->reserve();
302
Russell King2778f622010-07-09 16:27:52 +0100303 memblock_analyze();
304 memblock_dump_all();
305}
306
Russell King8d717a52010-05-22 19:47:18 +0100307void __init bootmem_init(void)
Russell King90072052005-10-28 14:48:37 +0100308{
Nicolas Pitre4b5f32c2008-10-06 13:24:40 -0400309 struct meminfo *mi = &meminfo;
Russell Kingdde58282009-08-15 12:36:00 +0100310 unsigned long min, max_low, max_high;
Russell King90072052005-10-28 14:48:37 +0100311
Russell Kingdde58282009-08-15 12:36:00 +0100312 max_low = max_high = 0;
313
Russell Kingbe370302010-05-07 17:40:33 +0100314 find_limits(mi, &min, &max_low, &max_high);
315
316 arm_bootmem_init(mi, min, max_low);
317
Russell Kingbe370302010-05-07 17:40:33 +0100318 /*
Russell Kingbe370302010-05-07 17:40:33 +0100319 * Sparsemem tries to allocate bootmem in memory_present(),
320 * so must be done after the fixed reservations
321 */
Russell Kingeda2e5d2010-07-01 12:00:57 +0100322 arm_memory_present();
Russell King90072052005-10-28 14:48:37 +0100323
Russell Kingb7a69ac2008-10-01 16:58:32 +0100324 /*
325 * sparse_init() needs the bootmem allocator up and running.
326 */
327 sparse_init();
328
329 /*
Russell Kingbe370302010-05-07 17:40:33 +0100330 * Now free the memory - free_area_init_node needs
Russell Kingb7a69ac2008-10-01 16:58:32 +0100331 * the sparse mem_map arrays initialized by sparse_init()
332 * for memmap_init_zone(), otherwise all PFNs are invalid.
333 */
Russell Kingbe370302010-05-07 17:40:33 +0100334 arm_bootmem_free(mi);
Russell Kingb7a69ac2008-10-01 16:58:32 +0100335
Russell Kingdde58282009-08-15 12:36:00 +0100336 high_memory = __va((max_low << PAGE_SHIFT) - 1) + 1;
Russell King90072052005-10-28 14:48:37 +0100337
338 /*
339 * This doesn't seem to be used by the Linux memory manager any
340 * more, but is used by ll_rw_block. If we can get rid of it, we
341 * also get rid of some of the stuff above as well.
342 *
343 * Note: max_low_pfn and max_pfn reflect the number of _pages_ in
344 * the system, not the maximum PFN.
345 */
Russell Kingdde58282009-08-15 12:36:00 +0100346 max_low_pfn = max_low - PHYS_PFN_OFFSET;
347 max_pfn = max_high - PHYS_PFN_OFFSET;
Russell King90072052005-10-28 14:48:37 +0100348}
349
Nicolas Pitre6db015e2008-09-17 14:50:42 -0400350static inline int free_area(unsigned long pfn, unsigned long end, char *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351{
Nicolas Pitre6db015e2008-09-17 14:50:42 -0400352 unsigned int pages = 0, size = (end - pfn) << (PAGE_SHIFT - 10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
Nicolas Pitre6db015e2008-09-17 14:50:42 -0400354 for (; pfn < end; pfn++) {
355 struct page *page = pfn_to_page(pfn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 ClearPageReserved(page);
Nick Piggin7835e982006-03-22 00:08:40 -0800357 init_page_count(page);
Nicolas Pitre6db015e2008-09-17 14:50:42 -0400358 __free_page(page);
359 pages++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 }
361
362 if (size && s)
363 printk(KERN_INFO "Freeing %s memory: %dK\n", s, size);
Nicolas Pitre6db015e2008-09-17 14:50:42 -0400364
365 return pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366}
367
Russell Kinga0130532005-06-27 14:16:47 +0100368static inline void
Russell Kingbe370302010-05-07 17:40:33 +0100369free_memmap(unsigned long start_pfn, unsigned long end_pfn)
Russell Kinga0130532005-06-27 14:16:47 +0100370{
371 struct page *start_pg, *end_pg;
372 unsigned long pg, pgend;
373
374 /*
375 * Convert start_pfn/end_pfn to a struct page pointer.
376 */
Catalin Marinas3257f432009-10-06 17:57:22 +0100377 start_pg = pfn_to_page(start_pfn - 1) + 1;
Russell Kinga0130532005-06-27 14:16:47 +0100378 end_pg = pfn_to_page(end_pfn);
379
380 /*
381 * Convert to physical addresses, and
382 * round start upwards and end downwards.
383 */
384 pg = PAGE_ALIGN(__pa(start_pg));
385 pgend = __pa(end_pg) & PAGE_MASK;
386
387 /*
388 * If there are free pages between these,
389 * free the section of the memmap array.
390 */
391 if (pg < pgend)
Russell Kingbe370302010-05-07 17:40:33 +0100392 free_bootmem(pg, pgend - pg);
Russell Kinga0130532005-06-27 14:16:47 +0100393}
394
395/*
396 * The mem_map array can get very big. Free the unused area of the memory map.
397 */
Russell Kingbe370302010-05-07 17:40:33 +0100398static void __init free_unused_memmap(struct meminfo *mi)
Russell Kinga0130532005-06-27 14:16:47 +0100399{
400 unsigned long bank_start, prev_bank_end = 0;
401 unsigned int i;
402
403 /*
404 * [FIXME] This relies on each bank being in address order. This
405 * may not be the case, especially if the user has provided the
406 * information on the command line.
407 */
Russell Kingbe370302010-05-07 17:40:33 +0100408 for_each_bank(i, mi) {
Russell Kingd2a38ef2008-10-01 16:56:15 +0100409 struct membank *bank = &mi->bank[i];
410
411 bank_start = bank_pfn_start(bank);
Russell Kinga0130532005-06-27 14:16:47 +0100412 if (bank_start < prev_bank_end) {
413 printk(KERN_ERR "MEM: unordered memory banks. "
414 "Not freeing memmap.\n");
415 break;
416 }
417
418 /*
419 * If we had a previous bank, and there is a space
420 * between the current bank and the previous, free it.
421 */
422 if (prev_bank_end && prev_bank_end != bank_start)
Russell Kingbe370302010-05-07 17:40:33 +0100423 free_memmap(prev_bank_end, bank_start);
Russell Kinga0130532005-06-27 14:16:47 +0100424
Russell Kingd2a38ef2008-10-01 16:56:15 +0100425 prev_bank_end = bank_pfn_end(bank);
Russell Kinga0130532005-06-27 14:16:47 +0100426 }
427}
428
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429/*
430 * mem_init() marks the free areas in the mem_map and tells us how much
431 * memory is free. This is done after various parts of the system have
432 * claimed their memory after the kernel image.
433 */
434void __init mem_init(void)
435{
Fenkart/Bostandzhyandb9ef1a2010-02-07 21:45:47 +0100436 unsigned long reserved_pages, free_pages;
Russell Kingbe370302010-05-07 17:40:33 +0100437 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
Nicolas Pitre3835f6c2008-09-17 15:21:55 -0400439 max_mapnr = pfn_to_page(max_pfn + PHYS_PFN_OFFSET) - mem_map;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 /* this will put all unused low memory onto the freelists */
Russell Kingbe370302010-05-07 17:40:33 +0100442 free_unused_memmap(&meminfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
Russell Kingbe370302010-05-07 17:40:33 +0100444 totalram_pages += free_all_bootmem();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
446#ifdef CONFIG_SA1111
447 /* now that our DMA memory is actually so designated, we can free it */
Nicolas Pitre6db015e2008-09-17 14:50:42 -0400448 totalram_pages += free_area(PHYS_PFN_OFFSET,
449 __phys_to_pfn(__pa(swapper_pg_dir)), NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450#endif
451
Nicolas Pitre3835f6c2008-09-17 15:21:55 -0400452#ifdef CONFIG_HIGHMEM
453 /* set highmem page free */
Russell Kingbe370302010-05-07 17:40:33 +0100454 for_each_bank (i, &meminfo) {
455 unsigned long start = bank_pfn_start(&meminfo.bank[i]);
456 unsigned long end = bank_pfn_end(&meminfo.bank[i]);
457 if (start >= max_low_pfn + PHYS_PFN_OFFSET)
458 totalhigh_pages += free_area(start, end, NULL);
Nicolas Pitre3835f6c2008-09-17 15:21:55 -0400459 }
460 totalram_pages += totalhigh_pages;
461#endif
462
Fenkart/Bostandzhyandb9ef1a2010-02-07 21:45:47 +0100463 reserved_pages = free_pages = 0;
464
Russell Kingbe370302010-05-07 17:40:33 +0100465 for_each_bank(i, &meminfo) {
466 struct membank *bank = &meminfo.bank[i];
467 unsigned int pfn1, pfn2;
468 struct page *page, *end;
Fenkart/Bostandzhyandb9ef1a2010-02-07 21:45:47 +0100469
Russell Kingbe370302010-05-07 17:40:33 +0100470 pfn1 = bank_pfn_start(bank);
471 pfn2 = bank_pfn_end(bank);
Fenkart/Bostandzhyandb9ef1a2010-02-07 21:45:47 +0100472
Russell Kingbe370302010-05-07 17:40:33 +0100473 page = pfn_to_page(pfn1);
474 end = pfn_to_page(pfn2 - 1) + 1;
Fenkart/Bostandzhyandb9ef1a2010-02-07 21:45:47 +0100475
Russell Kingbe370302010-05-07 17:40:33 +0100476 do {
477 if (PageReserved(page))
478 reserved_pages++;
479 else if (!page_count(page))
480 free_pages++;
481 page++;
482 } while (page < end);
Fenkart/Bostandzhyandb9ef1a2010-02-07 21:45:47 +0100483 }
484
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 /*
486 * Since our memory may not be contiguous, calculate the
487 * real number of pages we have in this system
488 */
489 printk(KERN_INFO "Memory:");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 num_physpages = 0;
491 for (i = 0; i < meminfo.nr_banks; i++) {
Russell Kingd2a38ef2008-10-01 16:56:15 +0100492 num_physpages += bank_pfn_size(&meminfo.bank[i]);
493 printk(" %ldMB", bank_phys_size(&meminfo.bank[i]) >> 20);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 printk(" = %luMB total\n", num_physpages >> (20 - PAGE_SHIFT));
Nicolas Pitre6db015e2008-09-17 14:50:42 -0400496
Fenkart/Bostandzhyandb9ef1a2010-02-07 21:45:47 +0100497 printk(KERN_NOTICE "Memory: %luk/%luk available, %luk reserved, %luK highmem\n",
498 nr_free_pages() << (PAGE_SHIFT-10),
499 free_pages << (PAGE_SHIFT-10),
500 reserved_pages << (PAGE_SHIFT-10),
Andreas Fenkart4b529402010-01-08 14:42:31 -0800501 totalhigh_pages << (PAGE_SHIFT-10));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
Fenkart/Bostandzhyandb9ef1a2010-02-07 21:45:47 +0100503#define MLK(b, t) b, t, ((t) - (b)) >> 10
504#define MLM(b, t) b, t, ((t) - (b)) >> 20
505#define MLK_ROUNDUP(b, t) b, t, DIV_ROUND_UP(((t) - (b)), SZ_1K)
506
507 printk(KERN_NOTICE "Virtual kernel memory layout:\n"
508 " vector : 0x%08lx - 0x%08lx (%4ld kB)\n"
509 " fixmap : 0x%08lx - 0x%08lx (%4ld kB)\n"
Fenkart/Bostandzhyana7bd08c2010-02-07 21:46:33 +0100510#ifdef CONFIG_MMU
511 " DMA : 0x%08lx - 0x%08lx (%4ld MB)\n"
512#endif
Fenkart/Bostandzhyandb9ef1a2010-02-07 21:45:47 +0100513 " vmalloc : 0x%08lx - 0x%08lx (%4ld MB)\n"
514 " lowmem : 0x%08lx - 0x%08lx (%4ld MB)\n"
515#ifdef CONFIG_HIGHMEM
516 " pkmap : 0x%08lx - 0x%08lx (%4ld MB)\n"
517#endif
518 " modules : 0x%08lx - 0x%08lx (%4ld MB)\n"
519 " .init : 0x%p" " - 0x%p" " (%4d kB)\n"
520 " .text : 0x%p" " - 0x%p" " (%4d kB)\n"
521 " .data : 0x%p" " - 0x%p" " (%4d kB)\n",
522
523 MLK(UL(CONFIG_VECTORS_BASE), UL(CONFIG_VECTORS_BASE) +
524 (PAGE_SIZE)),
525 MLK(FIXADDR_START, FIXADDR_TOP),
Fenkart/Bostandzhyana7bd08c2010-02-07 21:46:33 +0100526#ifdef CONFIG_MMU
527 MLM(CONSISTENT_BASE, CONSISTENT_END),
528#endif
Fenkart/Bostandzhyanc931b4f2010-02-07 21:47:17 +0100529 MLM(VMALLOC_START, VMALLOC_END),
Fenkart/Bostandzhyandb9ef1a2010-02-07 21:45:47 +0100530 MLM(PAGE_OFFSET, (unsigned long)high_memory),
531#ifdef CONFIG_HIGHMEM
532 MLM(PKMAP_BASE, (PKMAP_BASE) + (LAST_PKMAP) *
533 (PAGE_SIZE)),
534#endif
535 MLM(MODULES_VADDR, MODULES_END),
536
537 MLK_ROUNDUP(__init_begin, __init_end),
538 MLK_ROUNDUP(_text, _etext),
539 MLK_ROUNDUP(_data, _edata));
540
541#undef MLK
542#undef MLM
543#undef MLK_ROUNDUP
544
Fenkart/Bostandzhyana1839272010-02-07 21:47:58 +0100545 /*
546 * Check boundaries twice: Some fundamental inconsistencies can
547 * be detected at build time already.
548 */
549#ifdef CONFIG_MMU
550 BUILD_BUG_ON(VMALLOC_END > CONSISTENT_BASE);
551 BUG_ON(VMALLOC_END > CONSISTENT_BASE);
552
553 BUILD_BUG_ON(TASK_SIZE > MODULES_VADDR);
554 BUG_ON(TASK_SIZE > MODULES_VADDR);
555#endif
556
557#ifdef CONFIG_HIGHMEM
558 BUILD_BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > PAGE_OFFSET);
559 BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > PAGE_OFFSET);
560#endif
561
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 if (PAGE_SIZE >= 16384 && num_physpages <= 128) {
563 extern int sysctl_overcommit_memory;
564 /*
565 * On a machine this small we won't get
566 * anywhere without overcommit, so turn
567 * it on by default.
568 */
569 sysctl_overcommit_memory = OVERCOMMIT_ALWAYS;
570 }
571}
572
573void free_initmem(void)
574{
Linus Walleijbc581772009-09-15 17:30:37 +0100575#ifdef CONFIG_HAVE_TCM
Linus Walleijea208f62010-05-26 07:37:57 +0100576 extern char __tcm_start, __tcm_end;
Linus Walleijbc581772009-09-15 17:30:37 +0100577
Linus Walleijea208f62010-05-26 07:37:57 +0100578 totalram_pages += free_area(__phys_to_pfn(__pa(&__tcm_start)),
579 __phys_to_pfn(__pa(&__tcm_end)),
Linus Walleijbc581772009-09-15 17:30:37 +0100580 "TCM link");
581#endif
582
Nicolas Pitre6db015e2008-09-17 14:50:42 -0400583 if (!machine_is_integrator() && !machine_is_cintegrator())
Russell King37efe642008-12-01 11:53:07 +0000584 totalram_pages += free_area(__phys_to_pfn(__pa(__init_begin)),
585 __phys_to_pfn(__pa(__init_end)),
Nicolas Pitre6db015e2008-09-17 14:50:42 -0400586 "init");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587}
588
589#ifdef CONFIG_BLK_DEV_INITRD
590
591static int keep_initrd;
592
593void free_initrd_mem(unsigned long start, unsigned long end)
594{
595 if (!keep_initrd)
Nicolas Pitre6db015e2008-09-17 14:50:42 -0400596 totalram_pages += free_area(__phys_to_pfn(__pa(start)),
597 __phys_to_pfn(__pa(end)),
598 "initrd");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599}
600
601static int __init keepinitrd_setup(char *__unused)
602{
603 keep_initrd = 1;
604 return 1;
605}
606
607__setup("keepinitrd", keepinitrd_setup);
608#endif