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