2 * linux/arch/arm/mm/init.c
4 * Copyright (C) 1995-2005 Russell King
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.
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>
26 #include <asm/mach-types.h>
27 #include <asm/memblock.h>
29 #include <asm/sections.h>
30 #include <asm/setup.h>
32 #include <asm/fixmap.h>
34 #include <asm/mach/arch.h>
35 #include <asm/mach/map.h>
36 #include <mach/mtk_memcfg.h>
40 static unsigned long phys_initrd_start __initdata
= 0;
41 static unsigned long phys_initrd_size __initdata
= 0;
43 static int __init
early_initrd(char *p
)
45 unsigned long start
, size
;
48 start
= memparse(p
, &endp
);
50 size
= memparse(endp
+ 1, NULL
);
52 phys_initrd_start
= start
;
53 phys_initrd_size
= size
;
57 early_param("initrd", early_initrd
);
59 static int __init
parse_tag_initrd(const struct tag
*tag
)
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
;
68 __tagtable(ATAG_INITRD
, parse_tag_initrd
);
70 static int __init
parse_tag_initrd2(const struct tag
*tag
)
72 phys_initrd_start
= tag
->u
.initrd
.start
;
73 phys_initrd_size
= tag
->u
.initrd
.size
;
77 __tagtable(ATAG_INITRD2
, parse_tag_initrd2
);
79 #ifdef CONFIG_OF_FLATTREE
80 void __init
early_init_dt_setup_initrd_arch(unsigned long start
, unsigned long end
)
82 phys_initrd_start
= start
;
83 phys_initrd_size
= end
- start
;
85 #endif /* CONFIG_OF_FLATTREE */
88 * This keeps memory configuration data used by a couple memory
89 * initialization functions, as well as show_mem() for the skipping
90 * of holes in the memory map. It is populated by arm_add_memory().
92 struct meminfo meminfo
;
94 void show_mem(unsigned int filter
)
96 int free
= 0, total
= 0, reserved
= 0;
97 int shared
= 0, cached
= 0, slab
= 0, i
;
98 struct meminfo
* mi
= &meminfo
;
100 printk("Mem-info:\n");
101 show_free_areas(filter
);
103 if (filter
& SHOW_MEM_FILTER_PAGE_COUNT
)
106 for_each_bank (i
, mi
) {
107 struct membank
*bank
= &mi
->bank
[i
];
108 unsigned int pfn1
, pfn2
;
109 struct page
*page
, *end
;
111 pfn1
= bank_pfn_start(bank
);
112 pfn2
= bank_pfn_end(bank
);
114 page
= pfn_to_page(pfn1
);
115 end
= pfn_to_page(pfn2
- 1) + 1;
119 if (PageReserved(page
))
121 else if (PageSwapCache(page
))
123 else if (PageSlab(page
))
125 else if (!page_count(page
))
128 shared
+= page_count(page
) - 1;
130 } while (page
< end
);
133 printk("%d pages of RAM\n", total
);
134 printk("%d free pages\n", free
);
135 printk("%d reserved pages\n", reserved
);
136 printk("%d slab pages\n", slab
);
137 printk("%d pages shared\n", shared
);
138 printk("%d pages swap cached\n", cached
);
141 static void __init
find_limits(unsigned long *min
, unsigned long *max_low
,
142 unsigned long *max_high
)
144 struct meminfo
*mi
= &meminfo
;
147 /* This assumes the meminfo array is properly sorted */
148 *min
= bank_pfn_start(&mi
->bank
[0]);
149 for_each_bank (i
, mi
)
150 if (mi
->bank
[i
].highmem
)
152 *max_low
= bank_pfn_end(&mi
->bank
[i
- 1]);
153 *max_high
= bank_pfn_end(&mi
->bank
[mi
->nr_banks
- 1]);
156 static void __init
arm_bootmem_init(unsigned long start_pfn
,
157 unsigned long end_pfn
)
159 struct memblock_region
*reg
;
160 unsigned int boot_pages
;
165 * Allocate the bootmem bitmap page. This must be in a region
166 * of memory which has already been mapped.
168 boot_pages
= bootmem_bootmap_pages(end_pfn
- start_pfn
);
169 bitmap
= memblock_alloc_base(boot_pages
<< PAGE_SHIFT
, L1_CACHE_BYTES
,
170 __pfn_to_phys(end_pfn
));
173 * Initialise the bootmem allocator, handing the
174 * memory banks over to bootmem.
177 pgdat
= NODE_DATA(0);
178 init_bootmem_node(pgdat
, __phys_to_pfn(bitmap
), start_pfn
, end_pfn
);
180 /* Free the lowmem regions from memblock into bootmem. */
181 for_each_memblock(memory
, reg
) {
182 unsigned long start
= memblock_region_memory_base_pfn(reg
);
183 unsigned long end
= memblock_region_memory_end_pfn(reg
);
190 free_bootmem(__pfn_to_phys(start
), (end
- start
) << PAGE_SHIFT
);
193 /* Reserve the lowmem memblock reserved regions in bootmem. */
194 for_each_memblock(reserved
, reg
) {
195 unsigned long start
= memblock_region_reserved_base_pfn(reg
);
196 unsigned long end
= memblock_region_reserved_end_pfn(reg
);
203 reserve_bootmem(__pfn_to_phys(start
),
204 (end
- start
) << PAGE_SHIFT
, BOOTMEM_DEFAULT
);
208 #ifdef CONFIG_ZONE_DMA
210 phys_addr_t arm_dma_zone_size __read_mostly
;
211 EXPORT_SYMBOL(arm_dma_zone_size
);
214 * The DMA mask corresponding to the maximum bus address allocatable
215 * using GFP_DMA. The default here places no restriction on DMA
216 * allocations. This must be the smallest DMA mask in the system,
217 * so a successful GFP_DMA allocation will always satisfy this.
219 phys_addr_t arm_dma_limit
;
221 static void __init
arm_adjust_dma_zone(unsigned long *size
, unsigned long *hole
,
222 unsigned long dma_size
)
224 if (size
[0] <= dma_size
)
227 size
[ZONE_NORMAL
] = size
[0] - dma_size
;
228 size
[ZONE_DMA
] = dma_size
;
229 hole
[ZONE_NORMAL
] = hole
[0];
234 void __init
setup_dma_zone(struct machine_desc
*mdesc
)
236 #ifdef CONFIG_ZONE_DMA
237 if (mdesc
->dma_zone_size
) {
238 arm_dma_zone_size
= mdesc
->dma_zone_size
;
239 arm_dma_limit
= PHYS_OFFSET
+ arm_dma_zone_size
- 1;
241 arm_dma_limit
= 0xffffffff;
245 static void __init
arm_bootmem_free(unsigned long min
, unsigned long max_low
,
246 unsigned long max_high
)
248 unsigned long zone_size
[MAX_NR_ZONES
], zhole_size
[MAX_NR_ZONES
];
249 struct memblock_region
*reg
;
252 * initialise the zones.
254 memset(zone_size
, 0, sizeof(zone_size
));
257 * The memory size has already been determined. If we need
258 * to do anything fancy with the allocation of this memory
259 * to the zones, now is the time to do it.
261 zone_size
[0] = max_low
- min
;
262 #ifdef CONFIG_HIGHMEM
263 zone_size
[ZONE_HIGHMEM
] = max_high
- max_low
;
267 * Calculate the size of the holes.
268 * holes = node_size - sum(bank_sizes)
270 memcpy(zhole_size
, zone_size
, sizeof(zhole_size
));
271 for_each_memblock(memory
, reg
) {
272 unsigned long start
= memblock_region_memory_base_pfn(reg
);
273 unsigned long end
= memblock_region_memory_end_pfn(reg
);
275 if (start
< max_low
) {
276 unsigned long low_end
= min(end
, max_low
);
277 zhole_size
[0] -= low_end
- start
;
279 #ifdef CONFIG_HIGHMEM
281 unsigned long high_start
= max(start
, max_low
);
282 zhole_size
[ZONE_HIGHMEM
] -= end
- high_start
;
287 #ifdef CONFIG_ZONE_DMA
289 * Adjust the sizes according to any special requirements for
292 if (arm_dma_zone_size
)
293 arm_adjust_dma_zone(zone_size
, zhole_size
,
294 arm_dma_zone_size
>> PAGE_SHIFT
);
297 free_area_init_node(0, zone_size
, min
, zhole_size
);
300 #ifdef CONFIG_HAVE_ARCH_PFN_VALID
301 int pfn_valid(unsigned long pfn
)
303 return memblock_is_memory(__pfn_to_phys(pfn
));
305 EXPORT_SYMBOL(pfn_valid
);
308 #ifndef CONFIG_SPARSEMEM
309 static void __init
arm_memory_present(void)
313 static void __init
arm_memory_present(void)
315 struct memblock_region
*reg
;
317 for_each_memblock(memory
, reg
)
318 memory_present(0, memblock_region_memory_base_pfn(reg
),
319 memblock_region_memory_end_pfn(reg
));
323 static bool arm_memblock_steal_permitted
= true;
325 phys_addr_t __init
arm_memblock_steal(phys_addr_t size
, phys_addr_t align
)
329 BUG_ON(!arm_memblock_steal_permitted
);
331 phys
= memblock_alloc_base(size
, align
, MEMBLOCK_ALLOC_NOPASR
);
332 memblock_free(phys
, size
);
333 memblock_remove(phys
, size
);
335 MTK_MEMCFG_LOG_AND_PRINTK(KERN_ALERT
"[PHY layout]%ps : 0x%08llx - 0x%08llx (0x%08llx)\n",
336 __builtin_return_address(0), (unsigned long long)phys
,
337 (unsigned long long)phys
+ size
- 1,
338 (unsigned long long)size
);
344 __attribute__((weak
)) extern struct ion_platform_data ion_drv_platform_data
;
345 __attribute__((weak
)) extern void __init
ion_reserve(struct ion_platform_data
*data
);
347 void __init
arm_memblock_init(struct meminfo
*mi
, struct machine_desc
*mdesc
)
351 for (i
= 0; i
< mi
->nr_banks
; i
++)
352 memblock_add(mi
->bank
[i
].start
, mi
->bank
[i
].size
);
354 /* Register the kernel text, kernel data and initrd with memblock. */
355 #ifdef CONFIG_XIP_KERNEL
356 memblock_reserve(__pa(_sdata
), _end
- _sdata
);
358 memblock_reserve(__pa(_stext
), _end
- _stext
);
360 #ifdef CONFIG_BLK_DEV_INITRD
361 if (phys_initrd_size
&&
362 !memblock_is_region_memory(phys_initrd_start
, phys_initrd_size
)) {
363 pr_err("INITRD: 0x%08lx+0x%08lx is not a memory region - disabling initrd\n",
364 phys_initrd_start
, phys_initrd_size
);
365 phys_initrd_start
= phys_initrd_size
= 0;
367 if (phys_initrd_size
&&
368 memblock_is_region_reserved(phys_initrd_start
, phys_initrd_size
)) {
369 pr_err("INITRD: 0x%08lx+0x%08lx overlaps in-use memory region - disabling initrd\n",
370 phys_initrd_start
, phys_initrd_size
);
371 phys_initrd_start
= phys_initrd_size
= 0;
373 if (phys_initrd_size
) {
374 memblock_reserve(phys_initrd_start
, phys_initrd_size
);
376 /* Now convert initrd to virtual addresses */
377 initrd_start
= __phys_to_virt(phys_initrd_start
);
378 initrd_end
= initrd_start
+ phys_initrd_size
;
382 arm_mm_memblock_reserve();
383 arm_dt_memblock_reserve();
385 /* reserve any platform specific memblock areas */
389 early_init_fdt_scan_reserved_mem();
391 //reserve for ion_carveout_heap
392 if(ion_reserve
&& (&ion_drv_platform_data
))
393 ion_reserve(&ion_drv_platform_data
);
395 * reserve memory for DMA contigouos allocations,
396 * must come from DMA area inside low memory
398 dma_contiguous_reserve(min(arm_dma_limit
, arm_lowmem_limit
));
400 arm_memblock_steal_permitted
= false;
401 memblock_allow_resize();
405 void __init
bootmem_init(void)
407 unsigned long min
, max_low
, max_high
;
409 max_low
= max_high
= 0;
411 find_limits(&min
, &max_low
, &max_high
);
413 arm_bootmem_init(min
, max_low
);
416 * Sparsemem tries to allocate bootmem in memory_present(),
417 * so must be done after the fixed reservations
419 arm_memory_present();
422 * sparse_init() needs the bootmem allocator up and running.
427 * Now free the memory - free_area_init_node needs
428 * the sparse mem_map arrays initialized by sparse_init()
429 * for memmap_init_zone(), otherwise all PFNs are invalid.
431 arm_bootmem_free(min
, max_low
, max_high
);
434 * This doesn't seem to be used by the Linux memory manager any
435 * more, but is used by ll_rw_block. If we can get rid of it, we
436 * also get rid of some of the stuff above as well.
438 * Note: max_low_pfn and max_pfn reflect the number of _pages_ in
439 * the system, not the maximum PFN.
441 max_low_pfn
= max_low
- PHYS_PFN_OFFSET
;
442 max_pfn
= max_high
- PHYS_PFN_OFFSET
;
446 * Poison init memory with an undefined instruction (ARM) or a branch to an
447 * undefined instruction (Thumb).
449 static inline void poison_init_mem(void *s
, size_t count
)
452 for (; count
!= 0; count
-= 4)
457 free_memmap(unsigned long start_pfn
, unsigned long end_pfn
)
459 struct page
*start_pg
, *end_pg
;
460 unsigned long pg
, pgend
;
463 * Convert start_pfn/end_pfn to a struct page pointer.
465 start_pg
= pfn_to_page(start_pfn
- 1) + 1;
466 end_pg
= pfn_to_page(end_pfn
- 1) + 1;
469 * Convert to physical addresses, and
470 * round start upwards and end downwards.
472 pg
= (unsigned long)PAGE_ALIGN(__pa(start_pg
));
473 pgend
= (unsigned long)__pa(end_pg
) & PAGE_MASK
;
476 * If there are free pages between these,
477 * free the section of the memmap array.
480 free_bootmem(pg
, pgend
- pg
);
484 * The mem_map array can get very big. Free the unused area of the memory map.
486 static void __init
free_unused_memmap(struct meminfo
*mi
)
488 unsigned long bank_start
, prev_bank_end
= 0;
492 * This relies on each bank being in address order.
493 * The banks are sorted previously in bootmem_init().
495 for_each_bank(i
, mi
) {
496 struct membank
*bank
= &mi
->bank
[i
];
498 bank_start
= bank_pfn_start(bank
);
500 #ifdef CONFIG_SPARSEMEM
502 * Take care not to free memmap entries that don't exist
503 * due to SPARSEMEM sections which aren't present.
505 bank_start
= min(bank_start
,
506 ALIGN(prev_bank_end
, PAGES_PER_SECTION
));
509 * Align down here since the VM subsystem insists that the
510 * memmap entries are valid from the bank start aligned to
511 * MAX_ORDER_NR_PAGES.
513 bank_start
= round_down(bank_start
, MAX_ORDER_NR_PAGES
);
516 * If we had a previous bank, and there is a space
517 * between the current bank and the previous, free it.
519 if (prev_bank_end
&& prev_bank_end
< bank_start
)
520 free_memmap(prev_bank_end
, bank_start
);
523 * Align up here since the VM subsystem insists that the
524 * memmap entries are valid from the bank end aligned to
525 * MAX_ORDER_NR_PAGES.
527 prev_bank_end
= ALIGN(bank_pfn_end(bank
), MAX_ORDER_NR_PAGES
);
530 #ifdef CONFIG_SPARSEMEM
531 if (!IS_ALIGNED(prev_bank_end
, PAGES_PER_SECTION
))
532 free_memmap(prev_bank_end
,
533 ALIGN(prev_bank_end
, PAGES_PER_SECTION
));
537 #ifdef CONFIG_HIGHMEM
538 static inline void free_area_high(unsigned long pfn
, unsigned long end
)
540 for (; pfn
< end
; pfn
++)
541 free_highmem_page(pfn_to_page(pfn
));
545 static void __init
free_highpages(void)
547 #ifdef CONFIG_HIGHMEM
548 unsigned long max_low
= max_low_pfn
+ PHYS_PFN_OFFSET
;
549 struct memblock_region
*mem
, *res
;
551 /* set highmem page free */
552 for_each_memblock(memory
, mem
) {
553 unsigned long start
= memblock_region_memory_base_pfn(mem
);
554 unsigned long end
= memblock_region_memory_end_pfn(mem
);
556 /* Ignore complete lowmem entries */
560 /* Truncate partial highmem entries */
564 /* Find and exclude any reserved regions */
565 for_each_memblock(reserved
, res
) {
566 unsigned long res_start
, res_end
;
568 res_start
= memblock_region_reserved_base_pfn(res
);
569 res_end
= memblock_region_reserved_end_pfn(res
);
573 if (res_start
< start
)
579 if (res_start
!= start
)
580 free_area_high(start
, res_start
);
586 /* And now free anything which remains */
588 free_area_high(start
, end
);
594 * mem_init() marks the free areas in the mem_map and tells us how much
595 * memory is free. This is done after various parts of the system have
596 * claimed their memory after the kernel image.
598 void __init
mem_init(void)
600 unsigned long reserved_pages
, free_pages
;
601 struct memblock_region
*reg
;
603 #ifdef CONFIG_HAVE_TCM
604 /* These pointers are filled in on TCM detection */
609 max_mapnr
= pfn_to_page(max_pfn
+ PHYS_PFN_OFFSET
) - mem_map
;
611 /* this will put all unused low memory onto the freelists */
612 free_unused_memmap(&meminfo
);
614 totalram_pages
+= free_all_bootmem();
617 /* now that our DMA memory is actually so designated, we can free it */
618 free_reserved_area(__va(PHYS_OFFSET
), swapper_pg_dir
, 0, NULL
);
623 reserved_pages
= free_pages
= 0;
625 for_each_bank(i
, &meminfo
) {
626 struct membank
*bank
= &meminfo
.bank
[i
];
627 unsigned int pfn1
, pfn2
;
628 struct page
*page
, *end
;
630 pfn1
= bank_pfn_start(bank
);
631 pfn2
= bank_pfn_end(bank
);
633 page
= pfn_to_page(pfn1
);
634 end
= pfn_to_page(pfn2
- 1) + 1;
637 if (PageReserved(page
))
639 else if (!page_count(page
))
642 } while (page
< end
);
646 * Since our memory may not be contiguous, calculate the
647 * real number of pages we have in this system
649 printk(KERN_INFO
"Memory:");
651 for_each_memblock(memory
, reg
) {
652 unsigned long pages
= memblock_region_memory_end_pfn(reg
) -
653 memblock_region_memory_base_pfn(reg
);
654 num_physpages
+= pages
;
655 printk(" %ldMB", pages
>> (20 - PAGE_SHIFT
));
657 printk(" = %luMB total\n", num_physpages
>> (20 - PAGE_SHIFT
));
659 printk(KERN_NOTICE
"Memory: %luk/%luk available, %luk reserved, %luK highmem\n",
660 nr_free_pages() << (PAGE_SHIFT
-10),
661 free_pages
<< (PAGE_SHIFT
-10),
662 reserved_pages
<< (PAGE_SHIFT
-10),
663 totalhigh_pages
<< (PAGE_SHIFT
-10));
665 #define MLK(b, t) b, t, ((t) - (b)) >> 10
666 #define MLM(b, t) b, t, ((t) - (b)) >> 20
667 #define MLK_ROUNDUP(b, t) b, t, DIV_ROUND_UP(((t) - (b)), SZ_1K)
669 MTK_MEMCFG_LOG_AND_PRINTK(KERN_NOTICE
"Virtual kernel memory layout:\n"
670 " vector : 0x%08lx - 0x%08lx (%4ld kB)\n"
671 #ifdef CONFIG_HAVE_TCM
672 " DTCM : 0x%08lx - 0x%08lx (%4ld kB)\n"
673 " ITCM : 0x%08lx - 0x%08lx (%4ld kB)\n"
675 " fixmap : 0x%08lx - 0x%08lx (%4ld kB)\n"
676 " vmalloc : 0x%08lx - 0x%08lx (%4ld MB)\n"
677 " lowmem : 0x%08lx - 0x%08lx (%4ld MB)\n"
678 #ifdef CONFIG_HIGHMEM
679 " pkmap : 0x%08lx - 0x%08lx (%4ld MB)\n"
681 #ifdef CONFIG_MODULES
682 " modules : 0x%08lx - 0x%08lx (%4ld MB)\n"
684 " .text : 0x%p" " - 0x%p" " (%4d kB)\n"
685 " .init : 0x%p" " - 0x%p" " (%4d kB)\n"
686 " .data : 0x%p" " - 0x%p" " (%4d kB)\n"
687 " .bss : 0x%p" " - 0x%p" " (%4d kB)\n",
689 MLK(UL(CONFIG_VECTORS_BASE
), UL(CONFIG_VECTORS_BASE
) +
691 #ifdef CONFIG_HAVE_TCM
692 MLK(DTCM_OFFSET
, (unsigned long) dtcm_end
),
693 MLK(ITCM_OFFSET
, (unsigned long) itcm_end
),
695 MLK(FIXADDR_START
, FIXADDR_TOP
),
696 MLM(VMALLOC_START
, VMALLOC_END
),
697 MLM(PAGE_OFFSET
, (unsigned long)high_memory
),
698 #ifdef CONFIG_HIGHMEM
699 MLM(PKMAP_BASE
, (PKMAP_BASE
) + (LAST_PKMAP
) *
702 #ifdef CONFIG_MODULES
703 MLM(MODULES_VADDR
, MODULES_END
),
706 MLK_ROUNDUP(_text
, _etext
),
707 MLK_ROUNDUP(__init_begin
, __init_end
),
708 MLK_ROUNDUP(_sdata
, _edata
),
709 MLK_ROUNDUP(__bss_start
, __bss_stop
));
716 * Check boundaries twice: Some fundamental inconsistencies can
717 * be detected at build time already.
720 BUILD_BUG_ON(TASK_SIZE
> MODULES_VADDR
);
721 BUG_ON(TASK_SIZE
> MODULES_VADDR
);
724 #ifdef CONFIG_HIGHMEM
725 BUILD_BUG_ON(PKMAP_BASE
+ LAST_PKMAP
* PAGE_SIZE
> PAGE_OFFSET
);
726 BUG_ON(PKMAP_BASE
+ LAST_PKMAP
* PAGE_SIZE
> PAGE_OFFSET
);
729 if (PAGE_SIZE
>= 16384 && num_physpages
<= 128) {
730 extern int sysctl_overcommit_memory
;
732 * On a machine this small we won't get
733 * anywhere without overcommit, so turn
736 sysctl_overcommit_memory
= OVERCOMMIT_ALWAYS
;
740 void free_initmem(void)
742 #ifdef CONFIG_HAVE_TCM
743 extern char __tcm_start
, __tcm_end
;
745 poison_init_mem(&__tcm_start
, &__tcm_end
- &__tcm_start
);
746 free_reserved_area(&__tcm_start
, &__tcm_end
, 0, "TCM link");
749 poison_init_mem(__init_begin
, __init_end
- __init_begin
);
750 if (!machine_is_integrator() && !machine_is_cintegrator())
751 free_initmem_default(0);
754 #ifdef CONFIG_BLK_DEV_INITRD
756 static int keep_initrd
;
758 void free_initrd_mem(unsigned long start
, unsigned long end
)
761 poison_init_mem((void *)start
, PAGE_ALIGN(end
) - start
);
762 free_reserved_area(start
, end
, 0, "initrd");
766 static int __init
keepinitrd_setup(char *__unused
)
772 __setup("keepinitrd", keepinitrd_setup
);