2 * linux/arch/sh/mm/init.c
4 * Copyright (C) 1999 Niibe Yutaka
5 * Copyright (C) 2002 - 2011 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 <linux/export.h>
22 #include <asm/mmu_context.h>
23 #include <asm/mmzone.h>
24 #include <asm/kexec.h>
26 #include <asm/cacheflush.h>
27 #include <asm/sections.h>
28 #include <asm/setup.h>
29 #include <asm/cache.h>
30 #include <asm/sizes.h>
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
)
51 pgd
= pgd_offset_k(addr
);
57 pud
= pud_alloc(NULL
, pgd
, addr
);
63 pmd
= pmd_alloc(NULL
, pud
, addr
);
69 return pte_offset_kernel(pmd
, addr
);
72 static void set_pte_phys(unsigned long addr
, unsigned long phys
, pgprot_t prot
)
76 pte
= __get_pte_phys(addr
);
77 if (!pte_none(*pte
)) {
82 set_pte(pte
, pfn_pte(phys
>> PAGE_SHIFT
, prot
));
83 local_flush_tlb_one(get_asid(), addr
);
85 if (pgprot_val(prot
) & _PAGE_WIRED
)
86 tlb_wire_entry(NULL
, addr
, *pte
);
89 static void clear_pte_phys(unsigned long addr
, pgprot_t prot
)
93 pte
= __get_pte_phys(addr
);
95 if (pgprot_val(prot
) & _PAGE_WIRED
)
98 set_pte(pte
, pfn_pte(0, __pgprot(0)));
99 local_flush_tlb_one(get_asid(), addr
);
102 void __set_fixmap(enum fixed_addresses idx
, unsigned long phys
, pgprot_t prot
)
104 unsigned long address
= __fix_to_virt(idx
);
106 if (idx
>= __end_of_fixed_addresses
) {
111 set_pte_phys(address
, phys
, prot
);
114 void __clear_fixmap(enum fixed_addresses idx
, pgprot_t prot
)
116 unsigned long address
= __fix_to_virt(idx
);
118 if (idx
>= __end_of_fixed_addresses
) {
123 clear_pte_phys(address
, prot
);
126 static pmd_t
* __init
one_md_table_init(pud_t
*pud
)
128 if (pud_none(*pud
)) {
131 pmd
= alloc_bootmem_pages(PAGE_SIZE
);
132 pud_populate(&init_mm
, pud
, pmd
);
133 BUG_ON(pmd
!= pmd_offset(pud
, 0));
136 return pmd_offset(pud
, 0);
139 static pte_t
* __init
one_page_table_init(pmd_t
*pmd
)
141 if (pmd_none(*pmd
)) {
144 pte
= alloc_bootmem_pages(PAGE_SIZE
);
145 pmd_populate_kernel(&init_mm
, pmd
, pte
);
146 BUG_ON(pte
!= pte_offset_kernel(pmd
, 0));
149 return pte_offset_kernel(pmd
, 0);
152 static pte_t
* __init
page_table_kmap_check(pte_t
*pte
, pmd_t
*pmd
,
153 unsigned long vaddr
, pte_t
*lastpte
)
158 void __init
page_table_range_init(unsigned long start
, unsigned long end
,
169 i
= __pgd_offset(vaddr
);
170 j
= __pud_offset(vaddr
);
171 k
= __pmd_offset(vaddr
);
174 for ( ; (i
< PTRS_PER_PGD
) && (vaddr
!= end
); pgd
++, i
++) {
176 for ( ; (j
< PTRS_PER_PUD
) && (vaddr
!= end
); pud
++, j
++) {
177 pmd
= one_md_table_init(pud
);
178 #ifndef __PAGETABLE_PMD_FOLDED
181 for (; (k
< PTRS_PER_PMD
) && (vaddr
!= end
); pmd
++, k
++) {
182 pte
= page_table_kmap_check(one_page_table_init(pmd
),
191 #endif /* CONFIG_MMU */
193 void __init
allocate_pgdat(unsigned int nid
)
195 unsigned long start_pfn
, end_pfn
;
196 #ifdef CONFIG_NEED_MULTIPLE_NODES
200 get_pfn_range_for_nid(nid
, &start_pfn
, &end_pfn
);
202 #ifdef CONFIG_NEED_MULTIPLE_NODES
203 phys
= __memblock_alloc_base(sizeof(struct pglist_data
),
204 SMP_CACHE_BYTES
, end_pfn
<< PAGE_SHIFT
);
205 /* Retry with all of system memory */
207 phys
= __memblock_alloc_base(sizeof(struct pglist_data
),
208 SMP_CACHE_BYTES
, memblock_end_of_DRAM());
210 panic("Can't allocate pgdat for node %d\n", nid
);
212 NODE_DATA(nid
) = __va(phys
);
213 memset(NODE_DATA(nid
), 0, sizeof(struct pglist_data
));
215 NODE_DATA(nid
)->bdata
= &bootmem_node_data
[nid
];
218 NODE_DATA(nid
)->node_start_pfn
= start_pfn
;
219 NODE_DATA(nid
)->node_spanned_pages
= end_pfn
- start_pfn
;
222 static void __init
bootmem_init_one_node(unsigned int nid
)
224 unsigned long total_pages
, paddr
;
225 unsigned long end_pfn
;
226 struct pglist_data
*p
;
230 /* Nothing to do.. */
231 if (!p
->node_spanned_pages
)
234 end_pfn
= pgdat_end_pfn(p
);
236 total_pages
= bootmem_bootmap_pages(p
->node_spanned_pages
);
238 paddr
= memblock_alloc(total_pages
<< PAGE_SHIFT
, PAGE_SIZE
);
240 panic("Can't allocate bootmap for nid[%d]\n", nid
);
242 init_bootmem_node(p
, paddr
>> PAGE_SHIFT
, p
->node_start_pfn
, end_pfn
);
244 free_bootmem_with_active_regions(nid
, end_pfn
);
247 * XXX Handle initial reservations for the system memory node
248 * only for the moment, we'll refactor this later for handling
249 * reservations in other nodes.
252 struct memblock_region
*reg
;
254 /* Reserve the sections we're already using. */
255 for_each_memblock(reserved
, reg
) {
256 reserve_bootmem(reg
->base
, reg
->size
, BOOTMEM_DEFAULT
);
260 sparse_memory_present_with_active_regions(nid
);
263 static void __init
do_init_bootmem(void)
265 struct memblock_region
*reg
;
268 /* Add active regions with valid PFNs. */
269 for_each_memblock(memory
, reg
) {
270 unsigned long start_pfn
, end_pfn
;
271 start_pfn
= memblock_region_memory_base_pfn(reg
);
272 end_pfn
= memblock_region_memory_end_pfn(reg
);
273 __add_active_range(0, start_pfn
, end_pfn
);
276 /* All of system RAM sits in node 0 for the non-NUMA case */
282 for_each_online_node(i
)
283 bootmem_init_one_node(i
);
288 static void __init
early_reserve_mem(void)
290 unsigned long start_pfn
;
291 u32 zero_base
= (u32
)__MEMORY_START
+ (u32
)PHYSICAL_OFFSET
;
292 u32 start
= zero_base
+ (u32
)CONFIG_ZERO_PAGE_OFFSET
;
295 * Partially used pages are not usable - thus
296 * we are rounding upwards:
298 start_pfn
= PFN_UP(__pa(_end
));
301 * Reserve the kernel text and Reserve the bootmem bitmap. We do
302 * this in two steps (first step was init_bootmem()), because
303 * this catches the (definitely buggy) case of us accidentally
304 * initializing the bootmem allocator with an invalid RAM area.
306 memblock_reserve(start
, (PFN_PHYS(start_pfn
) + PAGE_SIZE
- 1) - start
);
309 * Reserve physical pages below CONFIG_ZERO_PAGE_OFFSET.
311 if (CONFIG_ZERO_PAGE_OFFSET
!= 0)
312 memblock_reserve(zero_base
, CONFIG_ZERO_PAGE_OFFSET
);
315 * Handle additional early reservations
318 reserve_crashkernel();
321 void __init
paging_init(void)
323 unsigned long max_zone_pfns
[MAX_NR_ZONES
];
324 unsigned long vaddr
, end
;
332 * Once the early reservations are out of the way, give the
333 * platforms a chance to kick out some memory.
335 if (sh_mv
.mv_mem_reserve
)
336 sh_mv
.mv_mem_reserve();
338 memblock_enforce_memory_limit(memory_limit
);
339 memblock_allow_resize();
344 * Determine low and high memory ranges:
346 max_low_pfn
= max_pfn
= memblock_end_of_DRAM() >> PAGE_SHIFT
;
347 min_low_pfn
= __MEMORY_START
>> PAGE_SHIFT
;
349 nodes_clear(node_online_map
);
351 memory_start
= (unsigned long)__va(__MEMORY_START
);
352 memory_end
= memory_start
+ (memory_limit
?: memblock_phys_mem_size());
357 ioremap_fixed_init();
359 /* We don't need to map the kernel through the TLB, as
360 * it is permanatly mapped using P1. So clear the
362 memset(swapper_pg_dir
, 0, sizeof(swapper_pg_dir
));
364 /* Set an initial value for the MMU.TTB so we don't have to
365 * check for a null value. */
366 set_TTB(swapper_pg_dir
);
369 * Populate the relevant portions of swapper_pg_dir so that
370 * we can use the fixmap entries without calling kmalloc.
371 * pte's will be filled in by __set_fixmap().
373 vaddr
= __fix_to_virt(__end_of_fixed_addresses
- 1) & PMD_MASK
;
374 end
= (FIXADDR_TOP
+ PMD_SIZE
- 1) & PMD_MASK
;
375 page_table_range_init(vaddr
, end
, swapper_pg_dir
);
377 kmap_coherent_init();
379 memset(max_zone_pfns
, 0, sizeof(max_zone_pfns
));
381 for_each_online_node(nid
) {
382 pg_data_t
*pgdat
= NODE_DATA(nid
);
383 unsigned long low
, start_pfn
;
385 start_pfn
= pgdat
->bdata
->node_min_pfn
;
386 low
= pgdat
->bdata
->node_low_pfn
;
388 if (max_zone_pfns
[ZONE_NORMAL
] < low
)
389 max_zone_pfns
[ZONE_NORMAL
] = low
;
391 printk("Node %u: start_pfn = 0x%lx, low = 0x%lx\n",
392 nid
, start_pfn
, low
);
395 free_area_init_nodes(max_zone_pfns
);
399 * Early initialization for any I/O MMUs we might have.
401 static void __init
iommu_init(void)
406 unsigned int mem_init_done
= 0;
408 void __init
mem_init(void)
415 for_each_online_pgdat(pgdat
)
416 high_memory
= max_t(void *, high_memory
,
417 __va(pgdat_end_pfn(pgdat
) << PAGE_SHIFT
));
421 /* Set this up early, so we can take care of the zero page */
424 /* clear the zero-page */
425 memset(empty_zero_page
, 0, PAGE_SIZE
);
426 __flush_wback_region(empty_zero_page
, PAGE_SIZE
);
430 mem_init_print_info(NULL
);
431 pr_info("virtual kernel memory layout:\n"
432 " fixmap : 0x%08lx - 0x%08lx (%4ld kB)\n"
433 #ifdef CONFIG_HIGHMEM
434 " pkmap : 0x%08lx - 0x%08lx (%4ld kB)\n"
436 " vmalloc : 0x%08lx - 0x%08lx (%4ld MB)\n"
437 " lowmem : 0x%08lx - 0x%08lx (%4ld MB) (cached)\n"
438 #ifdef CONFIG_UNCACHED_MAPPING
439 " : 0x%08lx - 0x%08lx (%4ld MB) (uncached)\n"
441 " .init : 0x%08lx - 0x%08lx (%4ld kB)\n"
442 " .data : 0x%08lx - 0x%08lx (%4ld kB)\n"
443 " .text : 0x%08lx - 0x%08lx (%4ld kB)\n",
444 FIXADDR_START
, FIXADDR_TOP
,
445 (FIXADDR_TOP
- FIXADDR_START
) >> 10,
447 #ifdef CONFIG_HIGHMEM
448 PKMAP_BASE
, PKMAP_BASE
+LAST_PKMAP
*PAGE_SIZE
,
449 (LAST_PKMAP
*PAGE_SIZE
) >> 10,
452 (unsigned long)VMALLOC_START
, VMALLOC_END
,
453 (VMALLOC_END
- VMALLOC_START
) >> 20,
455 (unsigned long)memory_start
, (unsigned long)high_memory
,
456 ((unsigned long)high_memory
- (unsigned long)memory_start
) >> 20,
458 #ifdef CONFIG_UNCACHED_MAPPING
459 uncached_start
, uncached_end
, uncached_size
>> 20,
462 (unsigned long)&__init_begin
, (unsigned long)&__init_end
,
463 ((unsigned long)&__init_end
-
464 (unsigned long)&__init_begin
) >> 10,
466 (unsigned long)&_etext
, (unsigned long)&_edata
,
467 ((unsigned long)&_edata
- (unsigned long)&_etext
) >> 10,
469 (unsigned long)&_text
, (unsigned long)&_etext
,
470 ((unsigned long)&_etext
- (unsigned long)&_text
) >> 10);
475 void free_initmem(void)
477 free_initmem_default(-1);
480 #ifdef CONFIG_BLK_DEV_INITRD
481 void free_initrd_mem(unsigned long start
, unsigned long end
)
483 free_reserved_area((void *)start
, (void *)end
, -1, "initrd");
487 #ifdef CONFIG_MEMORY_HOTPLUG
488 int arch_add_memory(int nid
, u64 start
, u64 size
)
491 unsigned long start_pfn
= start
>> PAGE_SHIFT
;
492 unsigned long nr_pages
= size
>> PAGE_SHIFT
;
495 pgdat
= NODE_DATA(nid
);
497 /* We only have ZONE_NORMAL, so this is easy.. */
498 ret
= __add_pages(nid
, pgdat
->node_zones
+ ZONE_NORMAL
,
499 start_pfn
, nr_pages
);
501 printk("%s: Failed, __add_pages() == %d\n", __func__
, ret
);
505 EXPORT_SYMBOL_GPL(arch_add_memory
);
508 int memory_add_physaddr_to_nid(u64 addr
)
510 /* Node 0 for now.. */
513 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid
);
516 #ifdef CONFIG_MEMORY_HOTREMOVE
517 int arch_remove_memory(u64 start
, u64 size
)
519 unsigned long start_pfn
= start
>> PAGE_SHIFT
;
520 unsigned long nr_pages
= size
>> PAGE_SHIFT
;
524 zone
= page_zone(pfn_to_page(start_pfn
));
525 ret
= __remove_pages(zone
, start_pfn
, nr_pages
);
527 pr_warn("%s: Failed, __remove_pages() == %d\n", __func__
,
533 #endif /* CONFIG_MEMORY_HOTPLUG */