2 * linux/arch/sh/mm/init.c
4 * Copyright (C) 1999 Niibe Yutaka
5 * Copyright (C) 2002 - 2010 Paul Mundt
7 * Based on linux/arch/i386/mm/init.c:
8 * Copyright (C) 1995 Linus Torvalds
11 #include <linux/swap.h>
12 #include <linux/init.h>
13 #include <linux/gfp.h>
14 #include <linux/bootmem.h>
15 #include <linux/proc_fs.h>
16 #include <linux/pagemap.h>
17 #include <linux/percpu.h>
19 #include <linux/memblock.h>
20 #include <linux/dma-mapping.h>
21 #include <asm/mmu_context.h>
22 #include <asm/mmzone.h>
23 #include <asm/kexec.h>
25 #include <asm/cacheflush.h>
26 #include <asm/sections.h>
27 #include <asm/setup.h>
28 #include <asm/cache.h>
29 #include <asm/sizes.h>
31 DEFINE_PER_CPU(struct mmu_gather
, mmu_gathers
);
32 pgd_t swapper_pg_dir
[PTRS_PER_PGD
];
34 void __init
generic_mem_init(void)
36 memblock_add(__MEMORY_START
, __MEMORY_SIZE
);
39 void __init __weak
plat_mem_setup(void)
41 /* Nothing to see here, move along. */
45 static pte_t
*__get_pte_phys(unsigned long addr
)
52 pgd
= pgd_offset_k(addr
);
58 pud
= pud_alloc(NULL
, pgd
, addr
);
64 pmd
= pmd_alloc(NULL
, pud
, addr
);
70 pte
= pte_offset_kernel(pmd
, addr
);
74 static void set_pte_phys(unsigned long addr
, unsigned long phys
, pgprot_t prot
)
78 pte
= __get_pte_phys(addr
);
79 if (!pte_none(*pte
)) {
84 set_pte(pte
, pfn_pte(phys
>> PAGE_SHIFT
, prot
));
85 local_flush_tlb_one(get_asid(), addr
);
87 if (pgprot_val(prot
) & _PAGE_WIRED
)
88 tlb_wire_entry(NULL
, addr
, *pte
);
91 static void clear_pte_phys(unsigned long addr
, pgprot_t prot
)
95 pte
= __get_pte_phys(addr
);
97 if (pgprot_val(prot
) & _PAGE_WIRED
)
100 set_pte(pte
, pfn_pte(0, __pgprot(0)));
101 local_flush_tlb_one(get_asid(), addr
);
104 void __set_fixmap(enum fixed_addresses idx
, unsigned long phys
, pgprot_t prot
)
106 unsigned long address
= __fix_to_virt(idx
);
108 if (idx
>= __end_of_fixed_addresses
) {
113 set_pte_phys(address
, phys
, prot
);
116 void __clear_fixmap(enum fixed_addresses idx
, pgprot_t prot
)
118 unsigned long address
= __fix_to_virt(idx
);
120 if (idx
>= __end_of_fixed_addresses
) {
125 clear_pte_phys(address
, prot
);
128 void __init
page_table_range_init(unsigned long start
, unsigned long end
,
139 i
= __pgd_offset(vaddr
);
140 j
= __pud_offset(vaddr
);
141 k
= __pmd_offset(vaddr
);
144 for ( ; (i
< PTRS_PER_PGD
) && (vaddr
!= end
); pgd
++, i
++) {
146 for ( ; (j
< PTRS_PER_PUD
) && (vaddr
!= end
); pud
++, j
++) {
147 #ifdef __PAGETABLE_PMD_FOLDED
150 pmd
= (pmd_t
*)alloc_bootmem_low_pages(PAGE_SIZE
);
151 pud_populate(&init_mm
, pud
, pmd
);
154 for (; (k
< PTRS_PER_PMD
) && (vaddr
!= end
); pmd
++, k
++) {
155 if (pmd_none(*pmd
)) {
156 pte
= (pte_t
*) alloc_bootmem_low_pages(PAGE_SIZE
);
157 pmd_populate_kernel(&init_mm
, pmd
, pte
);
158 BUG_ON(pte
!= pte_offset_kernel(pmd
, 0));
167 #endif /* CONFIG_MMU */
169 void __init
allocate_pgdat(unsigned int nid
)
171 unsigned long start_pfn
, end_pfn
;
172 #ifdef CONFIG_NEED_MULTIPLE_NODES
176 get_pfn_range_for_nid(nid
, &start_pfn
, &end_pfn
);
178 #ifdef CONFIG_NEED_MULTIPLE_NODES
179 phys
= __memblock_alloc_base(sizeof(struct pglist_data
),
180 SMP_CACHE_BYTES
, end_pfn
<< PAGE_SHIFT
);
181 /* Retry with all of system memory */
183 phys
= __memblock_alloc_base(sizeof(struct pglist_data
),
184 SMP_CACHE_BYTES
, memblock_end_of_DRAM());
186 panic("Can't allocate pgdat for node %d\n", nid
);
188 NODE_DATA(nid
) = __va(phys
);
189 memset(NODE_DATA(nid
), 0, sizeof(struct pglist_data
));
191 NODE_DATA(nid
)->bdata
= &bootmem_node_data
[nid
];
194 NODE_DATA(nid
)->node_start_pfn
= start_pfn
;
195 NODE_DATA(nid
)->node_spanned_pages
= end_pfn
- start_pfn
;
198 static void __init
bootmem_init_one_node(unsigned int nid
)
200 unsigned long total_pages
, paddr
;
201 unsigned long end_pfn
;
202 struct pglist_data
*p
;
206 /* Nothing to do.. */
207 if (!p
->node_spanned_pages
)
210 end_pfn
= p
->node_start_pfn
+ p
->node_spanned_pages
;
212 total_pages
= bootmem_bootmap_pages(p
->node_spanned_pages
);
214 paddr
= memblock_alloc(total_pages
<< PAGE_SHIFT
, PAGE_SIZE
);
216 panic("Can't allocate bootmap for nid[%d]\n", nid
);
218 init_bootmem_node(p
, paddr
>> PAGE_SHIFT
, p
->node_start_pfn
, end_pfn
);
220 free_bootmem_with_active_regions(nid
, end_pfn
);
223 * XXX Handle initial reservations for the system memory node
224 * only for the moment, we'll refactor this later for handling
225 * reservations in other nodes.
228 struct memblock_region
*reg
;
230 /* Reserve the sections we're already using. */
231 for_each_memblock(reserved
, reg
) {
232 reserve_bootmem(reg
->base
, reg
->size
, BOOTMEM_DEFAULT
);
236 sparse_memory_present_with_active_regions(nid
);
239 static void __init
do_init_bootmem(void)
241 struct memblock_region
*reg
;
244 /* Add active regions with valid PFNs. */
245 for_each_memblock(memory
, reg
) {
246 unsigned long start_pfn
, end_pfn
;
247 start_pfn
= memblock_region_memory_base_pfn(reg
);
248 end_pfn
= memblock_region_memory_end_pfn(reg
);
249 __add_active_range(0, start_pfn
, end_pfn
);
252 /* All of system RAM sits in node 0 for the non-NUMA case */
258 for_each_online_node(i
)
259 bootmem_init_one_node(i
);
264 static void __init
early_reserve_mem(void)
266 unsigned long start_pfn
;
269 * Partially used pages are not usable - thus
270 * we are rounding upwards:
272 start_pfn
= PFN_UP(__pa(_end
));
275 * Reserve the kernel text and Reserve the bootmem bitmap. We do
276 * this in two steps (first step was init_bootmem()), because
277 * this catches the (definitely buggy) case of us accidentally
278 * initializing the bootmem allocator with an invalid RAM area.
280 memblock_reserve(__MEMORY_START
+ CONFIG_ZERO_PAGE_OFFSET
,
281 (PFN_PHYS(start_pfn
) + PAGE_SIZE
- 1) -
282 (__MEMORY_START
+ CONFIG_ZERO_PAGE_OFFSET
));
285 * Reserve physical pages below CONFIG_ZERO_PAGE_OFFSET.
287 if (CONFIG_ZERO_PAGE_OFFSET
!= 0)
288 memblock_reserve(__MEMORY_START
, CONFIG_ZERO_PAGE_OFFSET
);
291 * Handle additional early reservations
294 reserve_crashkernel();
297 void __init
paging_init(void)
299 unsigned long max_zone_pfns
[MAX_NR_ZONES
];
300 unsigned long vaddr
, end
;
309 memblock_enforce_memory_limit(memory_limit
);
315 * Determine low and high memory ranges:
317 max_low_pfn
= max_pfn
= memblock_end_of_DRAM() >> PAGE_SHIFT
;
318 min_low_pfn
= __MEMORY_START
>> PAGE_SHIFT
;
320 nodes_clear(node_online_map
);
322 memory_start
= (unsigned long)__va(__MEMORY_START
);
323 memory_end
= memory_start
+ (memory_limit
?: memblock_phys_mem_size());
328 ioremap_fixed_init();
330 /* We don't need to map the kernel through the TLB, as
331 * it is permanatly mapped using P1. So clear the
333 memset(swapper_pg_dir
, 0, sizeof(swapper_pg_dir
));
335 /* Set an initial value for the MMU.TTB so we don't have to
336 * check for a null value. */
337 set_TTB(swapper_pg_dir
);
340 * Populate the relevant portions of swapper_pg_dir so that
341 * we can use the fixmap entries without calling kmalloc.
342 * pte's will be filled in by __set_fixmap().
344 vaddr
= __fix_to_virt(__end_of_fixed_addresses
- 1) & PMD_MASK
;
345 end
= (FIXADDR_TOP
+ PMD_SIZE
- 1) & PMD_MASK
;
346 page_table_range_init(vaddr
, end
, swapper_pg_dir
);
348 kmap_coherent_init();
350 memset(max_zone_pfns
, 0, sizeof(max_zone_pfns
));
352 for_each_online_node(nid
) {
353 pg_data_t
*pgdat
= NODE_DATA(nid
);
354 unsigned long low
, start_pfn
;
356 start_pfn
= pgdat
->bdata
->node_min_pfn
;
357 low
= pgdat
->bdata
->node_low_pfn
;
359 if (max_zone_pfns
[ZONE_NORMAL
] < low
)
360 max_zone_pfns
[ZONE_NORMAL
] = low
;
362 printk("Node %u: start_pfn = 0x%lx, low = 0x%lx\n",
363 nid
, start_pfn
, low
);
366 free_area_init_nodes(max_zone_pfns
);
370 * Early initialization for any I/O MMUs we might have.
372 static void __init
iommu_init(void)
377 unsigned int mem_init_done
= 0;
379 void __init
mem_init(void)
381 int codesize
, datasize
, initsize
;
389 for_each_online_node(nid
) {
390 pg_data_t
*pgdat
= NODE_DATA(nid
);
391 unsigned long node_pages
= 0;
392 void *node_high_memory
;
394 num_physpages
+= pgdat
->node_present_pages
;
396 if (pgdat
->node_spanned_pages
)
397 node_pages
= free_all_bootmem_node(pgdat
);
399 totalram_pages
+= node_pages
;
401 node_high_memory
= (void *)__va((pgdat
->node_start_pfn
+
402 pgdat
->node_spanned_pages
) <<
404 if (node_high_memory
> high_memory
)
405 high_memory
= node_high_memory
;
408 /* Set this up early, so we can take care of the zero page */
411 /* clear the zero-page */
412 memset(empty_zero_page
, 0, PAGE_SIZE
);
413 __flush_wback_region(empty_zero_page
, PAGE_SIZE
);
417 codesize
= (unsigned long) &_etext
- (unsigned long) &_text
;
418 datasize
= (unsigned long) &_edata
- (unsigned long) &_etext
;
419 initsize
= (unsigned long) &__init_end
- (unsigned long) &__init_begin
;
421 printk(KERN_INFO
"Memory: %luk/%luk available (%dk kernel code, "
422 "%dk data, %dk init)\n",
423 nr_free_pages() << (PAGE_SHIFT
-10),
424 num_physpages
<< (PAGE_SHIFT
-10),
429 printk(KERN_INFO
"virtual kernel memory layout:\n"
430 " fixmap : 0x%08lx - 0x%08lx (%4ld kB)\n"
431 #ifdef CONFIG_HIGHMEM
432 " pkmap : 0x%08lx - 0x%08lx (%4ld kB)\n"
434 " vmalloc : 0x%08lx - 0x%08lx (%4ld MB)\n"
435 " lowmem : 0x%08lx - 0x%08lx (%4ld MB) (cached)\n"
436 #ifdef CONFIG_UNCACHED_MAPPING
437 " : 0x%08lx - 0x%08lx (%4ld MB) (uncached)\n"
439 " .init : 0x%08lx - 0x%08lx (%4ld kB)\n"
440 " .data : 0x%08lx - 0x%08lx (%4ld kB)\n"
441 " .text : 0x%08lx - 0x%08lx (%4ld kB)\n",
442 FIXADDR_START
, FIXADDR_TOP
,
443 (FIXADDR_TOP
- FIXADDR_START
) >> 10,
445 #ifdef CONFIG_HIGHMEM
446 PKMAP_BASE
, PKMAP_BASE
+LAST_PKMAP
*PAGE_SIZE
,
447 (LAST_PKMAP
*PAGE_SIZE
) >> 10,
450 (unsigned long)VMALLOC_START
, VMALLOC_END
,
451 (VMALLOC_END
- VMALLOC_START
) >> 20,
453 (unsigned long)memory_start
, (unsigned long)high_memory
,
454 ((unsigned long)high_memory
- (unsigned long)memory_start
) >> 20,
456 #ifdef CONFIG_UNCACHED_MAPPING
457 uncached_start
, uncached_end
, uncached_size
>> 20,
460 (unsigned long)&__init_begin
, (unsigned long)&__init_end
,
461 ((unsigned long)&__init_end
-
462 (unsigned long)&__init_begin
) >> 10,
464 (unsigned long)&_etext
, (unsigned long)&_edata
,
465 ((unsigned long)&_edata
- (unsigned long)&_etext
) >> 10,
467 (unsigned long)&_text
, (unsigned long)&_etext
,
468 ((unsigned long)&_etext
- (unsigned long)&_text
) >> 10);
473 void free_initmem(void)
477 addr
= (unsigned long)(&__init_begin
);
478 for (; addr
< (unsigned long)(&__init_end
); addr
+= PAGE_SIZE
) {
479 ClearPageReserved(virt_to_page(addr
));
480 init_page_count(virt_to_page(addr
));
484 printk("Freeing unused kernel memory: %ldk freed\n",
485 ((unsigned long)&__init_end
-
486 (unsigned long)&__init_begin
) >> 10);
489 #ifdef CONFIG_BLK_DEV_INITRD
490 void free_initrd_mem(unsigned long start
, unsigned long end
)
493 for (p
= start
; p
< end
; p
+= PAGE_SIZE
) {
494 ClearPageReserved(virt_to_page(p
));
495 init_page_count(virt_to_page(p
));
499 printk("Freeing initrd memory: %ldk freed\n", (end
- start
) >> 10);
503 #ifdef CONFIG_MEMORY_HOTPLUG
504 int arch_add_memory(int nid
, u64 start
, u64 size
)
507 unsigned long start_pfn
= start
>> PAGE_SHIFT
;
508 unsigned long nr_pages
= size
>> PAGE_SHIFT
;
511 pgdat
= NODE_DATA(nid
);
513 /* We only have ZONE_NORMAL, so this is easy.. */
514 ret
= __add_pages(nid
, pgdat
->node_zones
+ ZONE_NORMAL
,
515 start_pfn
, nr_pages
);
517 printk("%s: Failed, __add_pages() == %d\n", __func__
, ret
);
521 EXPORT_SYMBOL_GPL(arch_add_memory
);
524 int memory_add_physaddr_to_nid(u64 addr
)
526 /* Node 0 for now.. */
529 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid
);
532 #endif /* CONFIG_MEMORY_HOTPLUG */