1
2
3
4
5
6
7
8
9
10#include <linux/kernel.h>
11#include <linux/errno.h>
12#include <linux/swap.h>
13#include <linux/init.h>
14#include <linux/bootmem.h>
15#include <linux/mman.h>
16#include <linux/export.h>
17#include <linux/nodemask.h>
18#include <linux/initrd.h>
19#include <linux/of_fdt.h>
20#include <linux/highmem.h>
21#include <linux/gfp.h>
22#include <linux/memblock.h>
23#include <linux/dma-contiguous.h>
24#include <linux/sizes.h>
25
26#include <asm/mach-types.h>
27#include <asm/memblock.h>
28#include <asm/prom.h>
29#include <asm/sections.h>
30#include <asm/setup.h>
31#include <asm/tlb.h>
32#include <asm/fixmap.h>
33
34#include <asm/mach/arch.h>
35#include <asm/mach/map.h>
36
37#include "mm.h"
38
39static phys_addr_t phys_initrd_start __initdata = 0;
40static unsigned long phys_initrd_size __initdata = 0;
41
42static int __init early_initrd(char *p)
43{
44 phys_addr_t start;
45 unsigned long size;
46 char *endp;
47
48 start = memparse(p, &endp);
49 if (*endp == ',') {
50 size = memparse(endp + 1, NULL);
51
52 phys_initrd_start = start;
53 phys_initrd_size = size;
54 }
55 return 0;
56}
57early_param("initrd", early_initrd);
58
59static int __init parse_tag_initrd(const struct tag *tag)
60{
61 printk(KERN_WARNING "ATAG_INITRD is deprecated; "
62 "please update your bootloader.\n");
63 phys_initrd_start = __virt_to_phys(tag->u.initrd.start);
64 phys_initrd_size = tag->u.initrd.size;
65 return 0;
66}
67
68__tagtable(ATAG_INITRD, parse_tag_initrd);
69
70static int __init parse_tag_initrd2(const struct tag *tag)
71{
72 phys_initrd_start = tag->u.initrd.start;
73 phys_initrd_size = tag->u.initrd.size;
74 return 0;
75}
76
77__tagtable(ATAG_INITRD2, parse_tag_initrd2);
78
79
80
81
82
83
84struct meminfo meminfo;
85
86void show_mem(unsigned int filter)
87{
88 int free = 0, total = 0, reserved = 0;
89 int shared = 0, cached = 0, slab = 0, i;
90 struct meminfo * mi = &meminfo;
91
92 printk("Mem-info:\n");
93 show_free_areas(filter);
94
95 for_each_bank (i, mi) {
96 struct membank *bank = &mi->bank[i];
97 unsigned int pfn1, pfn2;
98 struct page *page, *end;
99
100 pfn1 = bank_pfn_start(bank);
101 pfn2 = bank_pfn_end(bank);
102
103 page = pfn_to_page(pfn1);
104 end = pfn_to_page(pfn2 - 1) + 1;
105
106 do {
107 total++;
108 if (PageReserved(page))
109 reserved++;
110 else if (PageSwapCache(page))
111 cached++;
112 else if (PageSlab(page))
113 slab++;
114 else if (!page_count(page))
115 free++;
116 else
117 shared += page_count(page) - 1;
118 page++;
119 } while (page < end);
120 }
121
122 printk("%d pages of RAM\n", total);
123 printk("%d free pages\n", free);
124 printk("%d reserved pages\n", reserved);
125 printk("%d slab pages\n", slab);
126 printk("%d pages shared\n", shared);
127 printk("%d pages swap cached\n", cached);
128}
129
130static void __init find_limits(unsigned long *min, unsigned long *max_low,
131 unsigned long *max_high)
132{
133 struct meminfo *mi = &meminfo;
134 int i;
135
136
137 *min = bank_pfn_start(&mi->bank[0]);
138 for_each_bank (i, mi)
139 if (mi->bank[i].highmem)
140 break;
141 *max_low = bank_pfn_end(&mi->bank[i - 1]);
142 *max_high = bank_pfn_end(&mi->bank[mi->nr_banks - 1]);
143}
144
145#ifdef CONFIG_ZONE_DMA
146
147phys_addr_t arm_dma_zone_size __read_mostly;
148EXPORT_SYMBOL(arm_dma_zone_size);
149
150
151
152
153
154
155
156phys_addr_t arm_dma_limit;
157unsigned long arm_dma_pfn_limit;
158
159static void __init arm_adjust_dma_zone(unsigned long *size, unsigned long *hole,
160 unsigned long dma_size)
161{
162 if (size[0] <= dma_size)
163 return;
164
165 size[ZONE_NORMAL] = size[0] - dma_size;
166 size[ZONE_DMA] = dma_size;
167 hole[ZONE_NORMAL] = hole[0];
168 hole[ZONE_DMA] = 0;
169}
170#endif
171
172void __init setup_dma_zone(const struct machine_desc *mdesc)
173{
174#ifdef CONFIG_ZONE_DMA
175 if (mdesc->dma_zone_size) {
176 arm_dma_zone_size = mdesc->dma_zone_size;
177 arm_dma_limit = PHYS_OFFSET + arm_dma_zone_size - 1;
178 } else
179 arm_dma_limit = 0xffffffff;
180 arm_dma_pfn_limit = arm_dma_limit >> PAGE_SHIFT;
181#endif
182}
183
184static void __init zone_sizes_init(unsigned long min, unsigned long max_low,
185 unsigned long max_high)
186{
187 unsigned long zone_size[MAX_NR_ZONES], zhole_size[MAX_NR_ZONES];
188 struct memblock_region *reg;
189
190
191
192
193 memset(zone_size, 0, sizeof(zone_size));
194
195
196
197
198
199
200 zone_size[0] = max_low - min;
201#ifdef CONFIG_HIGHMEM
202 zone_size[ZONE_HIGHMEM] = max_high - max_low;
203#endif
204
205
206
207
208
209 memcpy(zhole_size, zone_size, sizeof(zhole_size));
210 for_each_memblock(memory, reg) {
211 unsigned long start = memblock_region_memory_base_pfn(reg);
212 unsigned long end = memblock_region_memory_end_pfn(reg);
213
214 if (start < max_low) {
215 unsigned long low_end = min(end, max_low);
216 zhole_size[0] -= low_end - start;
217 }
218#ifdef CONFIG_HIGHMEM
219 if (end > max_low) {
220 unsigned long high_start = max(start, max_low);
221 zhole_size[ZONE_HIGHMEM] -= end - high_start;
222 }
223#endif
224 }
225
226#ifdef CONFIG_ZONE_DMA
227
228
229
230
231 if (arm_dma_zone_size)
232 arm_adjust_dma_zone(zone_size, zhole_size,
233 arm_dma_zone_size >> PAGE_SHIFT);
234#endif
235
236 free_area_init_node(0, zone_size, min, zhole_size);
237}
238
239#ifdef CONFIG_HAVE_ARCH_PFN_VALID
240int pfn_valid(unsigned long pfn)
241{
242 return memblock_is_memory(__pfn_to_phys(pfn));
243}
244EXPORT_SYMBOL(pfn_valid);
245#endif
246
247#ifndef CONFIG_SPARSEMEM
248static void __init arm_memory_present(void)
249{
250}
251#else
252static void __init arm_memory_present(void)
253{
254 struct memblock_region *reg;
255
256 for_each_memblock(memory, reg)
257 memory_present(0, memblock_region_memory_base_pfn(reg),
258 memblock_region_memory_end_pfn(reg));
259}
260#endif
261
262static bool arm_memblock_steal_permitted = true;
263
264phys_addr_t __init arm_memblock_steal(phys_addr_t size, phys_addr_t align)
265{
266 phys_addr_t phys;
267
268 BUG_ON(!arm_memblock_steal_permitted);
269
270 phys = memblock_alloc_base(size, align, MEMBLOCK_ALLOC_ANYWHERE);
271 memblock_free(phys, size);
272 memblock_remove(phys, size);
273
274 return phys;
275}
276
277void __init arm_memblock_init(struct meminfo *mi,
278 const struct machine_desc *mdesc)
279{
280 int i;
281
282 for (i = 0; i < mi->nr_banks; i++)
283 memblock_add(mi->bank[i].start, mi->bank[i].size);
284
285
286#ifdef CONFIG_XIP_KERNEL
287 memblock_reserve(__pa(_sdata), _end - _sdata);
288#else
289 memblock_reserve(__pa(_stext), _end - _stext);
290#endif
291#ifdef CONFIG_BLK_DEV_INITRD
292
293 if (initrd_start && !phys_initrd_size) {
294 phys_initrd_start = __virt_to_phys(initrd_start);
295 phys_initrd_size = initrd_end - initrd_start;
296 }
297 initrd_start = initrd_end = 0;
298 if (phys_initrd_size &&
299 !memblock_is_region_memory(phys_initrd_start, phys_initrd_size)) {
300 pr_err("INITRD: 0x%08llx+0x%08lx is not a memory region - disabling initrd\n",
301 (u64)phys_initrd_start, phys_initrd_size);
302 phys_initrd_start = phys_initrd_size = 0;
303 }
304 if (phys_initrd_size &&
305 memblock_is_region_reserved(phys_initrd_start, phys_initrd_size)) {
306 pr_err("INITRD: 0x%08llx+0x%08lx overlaps in-use memory region - disabling initrd\n",
307 (u64)phys_initrd_start, phys_initrd_size);
308 phys_initrd_start = phys_initrd_size = 0;
309 }
310 if (phys_initrd_size) {
311 memblock_reserve(phys_initrd_start, phys_initrd_size);
312
313
314 initrd_start = __phys_to_virt(phys_initrd_start);
315 initrd_end = initrd_start + phys_initrd_size;
316 }
317#endif
318
319 arm_mm_memblock_reserve();
320 arm_dt_memblock_reserve();
321
322
323 if (mdesc->reserve)
324 mdesc->reserve();
325
326
327
328
329
330 dma_contiguous_reserve(min(arm_dma_limit, arm_lowmem_limit));
331
332 arm_memblock_steal_permitted = false;
333 memblock_dump_all();
334}
335
336void __init bootmem_init(void)
337{
338 unsigned long min, max_low, max_high;
339
340 memblock_allow_resize();
341 max_low = max_high = 0;
342
343 find_limits(&min, &max_low, &max_high);
344
345
346
347
348
349 arm_memory_present();
350
351
352
353
354 sparse_init();
355
356
357
358
359
360
361 zone_sizes_init(min, max_low, max_high);
362
363
364
365
366
367
368 min_low_pfn = min;
369 max_low_pfn = max_low;
370 max_pfn = max_high;
371}
372
373
374
375
376
377static inline void poison_init_mem(void *s, size_t count)
378{
379 u32 *p = (u32 *)s;
380 for (; count != 0; count -= 4)
381 *p++ = 0xe7fddef0;
382}
383
384static inline void
385free_memmap(unsigned long start_pfn, unsigned long end_pfn)
386{
387 struct page *start_pg, *end_pg;
388 phys_addr_t pg, pgend;
389
390
391
392
393 start_pg = pfn_to_page(start_pfn - 1) + 1;
394 end_pg = pfn_to_page(end_pfn - 1) + 1;
395
396
397
398
399
400 pg = PAGE_ALIGN(__pa(start_pg));
401 pgend = __pa(end_pg) & PAGE_MASK;
402
403
404
405
406
407 if (pg < pgend)
408 memblock_free_early(pg, pgend - pg);
409}
410
411
412
413
414static void __init free_unused_memmap(struct meminfo *mi)
415{
416 unsigned long bank_start, prev_bank_end = 0;
417 unsigned int i;
418
419
420
421
422
423 for_each_bank(i, mi) {
424 struct membank *bank = &mi->bank[i];
425
426 bank_start = bank_pfn_start(bank);
427
428#ifdef CONFIG_SPARSEMEM
429
430
431
432
433 bank_start = min(bank_start,
434 ALIGN(prev_bank_end, PAGES_PER_SECTION));
435#else
436
437
438
439
440
441 bank_start = round_down(bank_start, MAX_ORDER_NR_PAGES);
442#endif
443
444
445
446
447 if (prev_bank_end && prev_bank_end < bank_start)
448 free_memmap(prev_bank_end, bank_start);
449
450
451
452
453
454
455 prev_bank_end = ALIGN(bank_pfn_end(bank), MAX_ORDER_NR_PAGES);
456 }
457
458#ifdef CONFIG_SPARSEMEM
459 if (!IS_ALIGNED(prev_bank_end, PAGES_PER_SECTION))
460 free_memmap(prev_bank_end,
461 ALIGN(prev_bank_end, PAGES_PER_SECTION));
462#endif
463}
464
465#ifdef CONFIG_HIGHMEM
466static inline void free_area_high(unsigned long pfn, unsigned long end)
467{
468 for (; pfn < end; pfn++)
469 free_highmem_page(pfn_to_page(pfn));
470}
471#endif
472
473static void __init free_highpages(void)
474{
475#ifdef CONFIG_HIGHMEM
476 unsigned long max_low = max_low_pfn;
477 struct memblock_region *mem, *res;
478
479
480 for_each_memblock(memory, mem) {
481 unsigned long start = memblock_region_memory_base_pfn(mem);
482 unsigned long end = memblock_region_memory_end_pfn(mem);
483
484
485 if (end <= max_low)
486 continue;
487
488
489 if (start < max_low)
490 start = max_low;
491
492
493 for_each_memblock(reserved, res) {
494 unsigned long res_start, res_end;
495
496 res_start = memblock_region_reserved_base_pfn(res);
497 res_end = memblock_region_reserved_end_pfn(res);
498
499 if (res_end < start)
500 continue;
501 if (res_start < start)
502 res_start = start;
503 if (res_start > end)
504 res_start = end;
505 if (res_end > end)
506 res_end = end;
507 if (res_start != start)
508 free_area_high(start, res_start);
509 start = res_end;
510 if (start == end)
511 break;
512 }
513
514
515 if (start < end)
516 free_area_high(start, end);
517 }
518#endif
519}
520
521
522
523
524
525
526void __init mem_init(void)
527{
528#ifdef CONFIG_HAVE_TCM
529
530 extern u32 dtcm_end;
531 extern u32 itcm_end;
532#endif
533
534 set_max_mapnr(pfn_to_page(max_pfn) - mem_map);
535
536
537 free_unused_memmap(&meminfo);
538 free_all_bootmem();
539
540#ifdef CONFIG_SA1111
541
542 free_reserved_area(__va(PHYS_OFFSET), swapper_pg_dir, -1, NULL);
543#endif
544
545 free_highpages();
546
547 mem_init_print_info(NULL);
548
549#define MLK(b, t) b, t, ((t) - (b)) >> 10
550#define MLM(b, t) b, t, ((t) - (b)) >> 20
551#define MLK_ROUNDUP(b, t) b, t, DIV_ROUND_UP(((t) - (b)), SZ_1K)
552
553 printk(KERN_NOTICE "Virtual kernel memory layout:\n"
554 " vector : 0x%08lx - 0x%08lx (%4ld kB)\n"
555#ifdef CONFIG_HAVE_TCM
556 " DTCM : 0x%08lx - 0x%08lx (%4ld kB)\n"
557 " ITCM : 0x%08lx - 0x%08lx (%4ld kB)\n"
558#endif
559 " fixmap : 0x%08lx - 0x%08lx (%4ld kB)\n"
560 " vmalloc : 0x%08lx - 0x%08lx (%4ld MB)\n"
561 " lowmem : 0x%08lx - 0x%08lx (%4ld MB)\n"
562#ifdef CONFIG_HIGHMEM
563 " pkmap : 0x%08lx - 0x%08lx (%4ld MB)\n"
564#endif
565#ifdef CONFIG_MODULES
566 " modules : 0x%08lx - 0x%08lx (%4ld MB)\n"
567#endif
568 " .text : 0x%p" " - 0x%p" " (%4d kB)\n"
569 " .init : 0x%p" " - 0x%p" " (%4d kB)\n"
570 " .data : 0x%p" " - 0x%p" " (%4d kB)\n"
571 " .bss : 0x%p" " - 0x%p" " (%4d kB)\n",
572
573 MLK(UL(CONFIG_VECTORS_BASE), UL(CONFIG_VECTORS_BASE) +
574 (PAGE_SIZE)),
575#ifdef CONFIG_HAVE_TCM
576 MLK(DTCM_OFFSET, (unsigned long) dtcm_end),
577 MLK(ITCM_OFFSET, (unsigned long) itcm_end),
578#endif
579 MLK(FIXADDR_START, FIXADDR_TOP),
580 MLM(VMALLOC_START, VMALLOC_END),
581 MLM(PAGE_OFFSET, (unsigned long)high_memory),
582#ifdef CONFIG_HIGHMEM
583 MLM(PKMAP_BASE, (PKMAP_BASE) + (LAST_PKMAP) *
584 (PAGE_SIZE)),
585#endif
586#ifdef CONFIG_MODULES
587 MLM(MODULES_VADDR, MODULES_END),
588#endif
589
590 MLK_ROUNDUP(_text, _etext),
591 MLK_ROUNDUP(__init_begin, __init_end),
592 MLK_ROUNDUP(_sdata, _edata),
593 MLK_ROUNDUP(__bss_start, __bss_stop));
594
595#undef MLK
596#undef MLM
597#undef MLK_ROUNDUP
598
599
600
601
602
603#ifdef CONFIG_MMU
604 BUILD_BUG_ON(TASK_SIZE > MODULES_VADDR);
605 BUG_ON(TASK_SIZE > MODULES_VADDR);
606#endif
607
608#ifdef CONFIG_HIGHMEM
609 BUILD_BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > PAGE_OFFSET);
610 BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > PAGE_OFFSET);
611#endif
612
613 if (PAGE_SIZE >= 16384 && get_num_physpages() <= 128) {
614 extern int sysctl_overcommit_memory;
615
616
617
618
619
620 sysctl_overcommit_memory = OVERCOMMIT_ALWAYS;
621 }
622}
623
624void free_initmem(void)
625{
626#ifdef CONFIG_HAVE_TCM
627 extern char __tcm_start, __tcm_end;
628
629 poison_init_mem(&__tcm_start, &__tcm_end - &__tcm_start);
630 free_reserved_area(&__tcm_start, &__tcm_end, -1, "TCM link");
631#endif
632
633 poison_init_mem(__init_begin, __init_end - __init_begin);
634 if (!machine_is_integrator() && !machine_is_cintegrator())
635 free_initmem_default(-1);
636}
637
638#ifdef CONFIG_BLK_DEV_INITRD
639
640static int keep_initrd;
641
642void free_initrd_mem(unsigned long start, unsigned long end)
643{
644 if (!keep_initrd) {
645 poison_init_mem((void *)start, PAGE_ALIGN(end) - start);
646 free_reserved_area((void *)start, (void *)end, -1, "initrd");
647 }
648}
649
650static int __init keepinitrd_setup(char *__unused)
651{
652 keep_initrd = 1;
653 return 1;
654}
655
656__setup("keepinitrd", keepinitrd_setup);
657#endif
658