Merge tag 'perf-core-for-mingo' of git://git.kernel.org/pub/scm/linux/kernel/git...
[firefly-linux-kernel-4.4.55.git] / arch / arm64 / mm / init.c
1 /*
2  * Based on arch/arm/mm/init.c
3  *
4  * Copyright (C) 1995-2005 Russell King
5  * Copyright (C) 2012 ARM Ltd.
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <linux/kernel.h>
21 #include <linux/export.h>
22 #include <linux/errno.h>
23 #include <linux/swap.h>
24 #include <linux/init.h>
25 #include <linux/bootmem.h>
26 #include <linux/mman.h>
27 #include <linux/nodemask.h>
28 #include <linux/initrd.h>
29 #include <linux/gfp.h>
30 #include <linux/memblock.h>
31 #include <linux/sort.h>
32 #include <linux/of_fdt.h>
33
34 #include <asm/prom.h>
35 #include <asm/sections.h>
36 #include <asm/setup.h>
37 #include <asm/sizes.h>
38 #include <asm/tlb.h>
39
40 #include "mm.h"
41
42 static unsigned long phys_initrd_start __initdata = 0;
43 static unsigned long phys_initrd_size __initdata = 0;
44
45 phys_addr_t memstart_addr __read_mostly = 0;
46
47 void __init early_init_dt_setup_initrd_arch(u64 start, u64 end)
48 {
49         phys_initrd_start = start;
50         phys_initrd_size = end - start;
51 }
52
53 static int __init early_initrd(char *p)
54 {
55         unsigned long start, size;
56         char *endp;
57
58         start = memparse(p, &endp);
59         if (*endp == ',') {
60                 size = memparse(endp + 1, NULL);
61
62                 phys_initrd_start = start;
63                 phys_initrd_size = size;
64         }
65         return 0;
66 }
67 early_param("initrd", early_initrd);
68
69 #define MAX_DMA32_PFN ((4UL * 1024 * 1024 * 1024) >> PAGE_SHIFT)
70
71 static void __init zone_sizes_init(unsigned long min, unsigned long max)
72 {
73         struct memblock_region *reg;
74         unsigned long zone_size[MAX_NR_ZONES], zhole_size[MAX_NR_ZONES];
75         unsigned long max_dma32 = min;
76
77         memset(zone_size, 0, sizeof(zone_size));
78
79 #ifdef CONFIG_ZONE_DMA32
80         /* 4GB maximum for 32-bit only capable devices */
81         max_dma32 = max(min, min(max, MAX_DMA32_PFN));
82         zone_size[ZONE_DMA32] = max_dma32 - min;
83 #endif
84         zone_size[ZONE_NORMAL] = max - max_dma32;
85
86         memcpy(zhole_size, zone_size, sizeof(zhole_size));
87
88         for_each_memblock(memory, reg) {
89                 unsigned long start = memblock_region_memory_base_pfn(reg);
90                 unsigned long end = memblock_region_memory_end_pfn(reg);
91
92                 if (start >= max)
93                         continue;
94 #ifdef CONFIG_ZONE_DMA32
95                 if (start < max_dma32) {
96                         unsigned long dma_end = min(end, max_dma32);
97                         zhole_size[ZONE_DMA32] -= dma_end - start;
98                 }
99 #endif
100                 if (end > max_dma32) {
101                         unsigned long normal_end = min(end, max);
102                         unsigned long normal_start = max(start, max_dma32);
103                         zhole_size[ZONE_NORMAL] -= normal_end - normal_start;
104                 }
105         }
106
107         free_area_init_node(0, zone_size, min, zhole_size);
108 }
109
110 #ifdef CONFIG_HAVE_ARCH_PFN_VALID
111 int pfn_valid(unsigned long pfn)
112 {
113         return memblock_is_memory(pfn << PAGE_SHIFT);
114 }
115 EXPORT_SYMBOL(pfn_valid);
116 #endif
117
118 #ifndef CONFIG_SPARSEMEM
119 static void arm64_memory_present(void)
120 {
121 }
122 #else
123 static void arm64_memory_present(void)
124 {
125         struct memblock_region *reg;
126
127         for_each_memblock(memory, reg)
128                 memory_present(0, memblock_region_memory_base_pfn(reg),
129                                memblock_region_memory_end_pfn(reg));
130 }
131 #endif
132
133 void __init arm64_memblock_init(void)
134 {
135         u64 *reserve_map, base, size;
136
137         /* Register the kernel text, kernel data and initrd with memblock */
138         memblock_reserve(__pa(_text), _end - _text);
139 #ifdef CONFIG_BLK_DEV_INITRD
140         if (phys_initrd_size) {
141                 memblock_reserve(phys_initrd_start, phys_initrd_size);
142
143                 /* Now convert initrd to virtual addresses */
144                 initrd_start = __phys_to_virt(phys_initrd_start);
145                 initrd_end = initrd_start + phys_initrd_size;
146         }
147 #endif
148
149         /*
150          * Reserve the page tables.  These are already in use,
151          * and can only be in node 0.
152          */
153         memblock_reserve(__pa(swapper_pg_dir), SWAPPER_DIR_SIZE);
154         memblock_reserve(__pa(idmap_pg_dir), IDMAP_DIR_SIZE);
155
156         /* Reserve the dtb region */
157         memblock_reserve(virt_to_phys(initial_boot_params),
158                          be32_to_cpu(initial_boot_params->totalsize));
159
160         /*
161          * Process the reserve map.  This will probably overlap the initrd
162          * and dtb locations which are already reserved, but overlapping
163          * doesn't hurt anything
164          */
165         reserve_map = ((void*)initial_boot_params) +
166                         be32_to_cpu(initial_boot_params->off_mem_rsvmap);
167         while (1) {
168                 base = be64_to_cpup(reserve_map++);
169                 size = be64_to_cpup(reserve_map++);
170                 if (!size)
171                         break;
172                 memblock_reserve(base, size);
173         }
174
175         memblock_allow_resize();
176         memblock_dump_all();
177 }
178
179 void __init bootmem_init(void)
180 {
181         unsigned long min, max;
182
183         min = PFN_UP(memblock_start_of_DRAM());
184         max = PFN_DOWN(memblock_end_of_DRAM());
185
186         /*
187          * Sparsemem tries to allocate bootmem in memory_present(), so must be
188          * done after the fixed reservations.
189          */
190         arm64_memory_present();
191
192         sparse_init();
193         zone_sizes_init(min, max);
194
195         high_memory = __va((max << PAGE_SHIFT) - 1) + 1;
196         max_pfn = max_low_pfn = max;
197 }
198
199 #ifndef CONFIG_SPARSEMEM_VMEMMAP
200 static inline void free_memmap(unsigned long start_pfn, unsigned long end_pfn)
201 {
202         struct page *start_pg, *end_pg;
203         unsigned long pg, pgend;
204
205         /*
206          * Convert start_pfn/end_pfn to a struct page pointer.
207          */
208         start_pg = pfn_to_page(start_pfn - 1) + 1;
209         end_pg = pfn_to_page(end_pfn - 1) + 1;
210
211         /*
212          * Convert to physical addresses, and round start upwards and end
213          * downwards.
214          */
215         pg = (unsigned long)PAGE_ALIGN(__pa(start_pg));
216         pgend = (unsigned long)__pa(end_pg) & PAGE_MASK;
217
218         /*
219          * If there are free pages between these, free the section of the
220          * memmap array.
221          */
222         if (pg < pgend)
223                 free_bootmem(pg, pgend - pg);
224 }
225
226 /*
227  * The mem_map array can get very big. Free the unused area of the memory map.
228  */
229 static void __init free_unused_memmap(void)
230 {
231         unsigned long start, prev_end = 0;
232         struct memblock_region *reg;
233
234         for_each_memblock(memory, reg) {
235                 start = __phys_to_pfn(reg->base);
236
237 #ifdef CONFIG_SPARSEMEM
238                 /*
239                  * Take care not to free memmap entries that don't exist due
240                  * to SPARSEMEM sections which aren't present.
241                  */
242                 start = min(start, ALIGN(prev_end, PAGES_PER_SECTION));
243 #endif
244                 /*
245                  * If we had a previous bank, and there is a space between the
246                  * current bank and the previous, free it.
247                  */
248                 if (prev_end && prev_end < start)
249                         free_memmap(prev_end, start);
250
251                 /*
252                  * Align up here since the VM subsystem insists that the
253                  * memmap entries are valid from the bank end aligned to
254                  * MAX_ORDER_NR_PAGES.
255                  */
256                 prev_end = ALIGN(start + __phys_to_pfn(reg->size),
257                                  MAX_ORDER_NR_PAGES);
258         }
259
260 #ifdef CONFIG_SPARSEMEM
261         if (!IS_ALIGNED(prev_end, PAGES_PER_SECTION))
262                 free_memmap(prev_end, ALIGN(prev_end, PAGES_PER_SECTION));
263 #endif
264 }
265 #endif  /* !CONFIG_SPARSEMEM_VMEMMAP */
266
267 /*
268  * mem_init() marks the free areas in the mem_map and tells us how much memory
269  * is free.  This is done after various parts of the system have claimed their
270  * memory after the kernel image.
271  */
272 void __init mem_init(void)
273 {
274         arm64_swiotlb_init();
275
276         max_mapnr   = pfn_to_page(max_pfn + PHYS_PFN_OFFSET) - mem_map;
277
278 #ifndef CONFIG_SPARSEMEM_VMEMMAP
279         free_unused_memmap();
280 #endif
281         /* this will put all unused low memory onto the freelists */
282         free_all_bootmem();
283
284         mem_init_print_info(NULL);
285
286 #define MLK(b, t) b, t, ((t) - (b)) >> 10
287 #define MLM(b, t) b, t, ((t) - (b)) >> 20
288 #define MLK_ROUNDUP(b, t) b, t, DIV_ROUND_UP(((t) - (b)), SZ_1K)
289
290         pr_notice("Virtual kernel memory layout:\n"
291                   "    vmalloc : 0x%16lx - 0x%16lx   (%6ld MB)\n"
292 #ifdef CONFIG_SPARSEMEM_VMEMMAP
293                   "    vmemmap : 0x%16lx - 0x%16lx   (%6ld MB)\n"
294 #endif
295                   "    modules : 0x%16lx - 0x%16lx   (%6ld MB)\n"
296                   "    memory  : 0x%16lx - 0x%16lx   (%6ld MB)\n"
297                   "      .init : 0x%p" " - 0x%p" "   (%6ld kB)\n"
298                   "      .text : 0x%p" " - 0x%p" "   (%6ld kB)\n"
299                   "      .data : 0x%p" " - 0x%p" "   (%6ld kB)\n",
300                   MLM(VMALLOC_START, VMALLOC_END),
301 #ifdef CONFIG_SPARSEMEM_VMEMMAP
302                   MLM((unsigned long)virt_to_page(PAGE_OFFSET),
303                       (unsigned long)virt_to_page(high_memory)),
304 #endif
305                   MLM(MODULES_VADDR, MODULES_END),
306                   MLM(PAGE_OFFSET, (unsigned long)high_memory),
307
308                   MLK_ROUNDUP(__init_begin, __init_end),
309                   MLK_ROUNDUP(_text, _etext),
310                   MLK_ROUNDUP(_sdata, _edata));
311
312 #undef MLK
313 #undef MLM
314 #undef MLK_ROUNDUP
315
316         /*
317          * Check boundaries twice: Some fundamental inconsistencies can be
318          * detected at build time already.
319          */
320 #ifdef CONFIG_COMPAT
321         BUILD_BUG_ON(TASK_SIZE_32                       > TASK_SIZE_64);
322 #endif
323         BUILD_BUG_ON(TASK_SIZE_64                       > MODULES_VADDR);
324         BUG_ON(TASK_SIZE_64                             > MODULES_VADDR);
325
326         if (PAGE_SIZE >= 16384 && get_num_physpages() <= 128) {
327                 extern int sysctl_overcommit_memory;
328                 /*
329                  * On a machine this small we won't get anywhere without
330                  * overcommit, so turn it on by default.
331                  */
332                 sysctl_overcommit_memory = OVERCOMMIT_ALWAYS;
333         }
334 }
335
336 void free_initmem(void)
337 {
338         free_initmem_default(0);
339 }
340
341 #ifdef CONFIG_BLK_DEV_INITRD
342
343 static int keep_initrd;
344
345 void free_initrd_mem(unsigned long start, unsigned long end)
346 {
347         if (!keep_initrd)
348                 free_reserved_area((void *)start, (void *)end, 0, "initrd");
349 }
350
351 static int __init keepinitrd_setup(char *__unused)
352 {
353         keep_initrd = 1;
354         return 1;
355 }
356
357 __setup("keepinitrd", keepinitrd_setup);
358 #endif