Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 1 | /* |
| 2 | * PowerPC version |
| 3 | * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) |
| 4 | * |
| 5 | * Modifications by Paul Mackerras (PowerMac) (paulus@cs.anu.edu.au) |
| 6 | * and Cort Dougan (PReP) (cort@cs.nmt.edu) |
| 7 | * Copyright (C) 1996 Paul Mackerras |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 8 | * PPC44x/36-bit changes by Matt Porter (mporter@mvista.com) |
| 9 | * |
| 10 | * Derived from "arch/i386/mm/init.c" |
| 11 | * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds |
| 12 | * |
| 13 | * This program is free software; you can redistribute it and/or |
| 14 | * modify it under the terms of the GNU General Public License |
| 15 | * as published by the Free Software Foundation; either version |
| 16 | * 2 of the License, or (at your option) any later version. |
| 17 | * |
| 18 | */ |
| 19 | |
Paul Gortmaker | 4b16f8e | 2011-07-22 18:24:23 -0400 | [diff] [blame] | 20 | #include <linux/export.h> |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 21 | #include <linux/sched.h> |
| 22 | #include <linux/kernel.h> |
| 23 | #include <linux/errno.h> |
| 24 | #include <linux/string.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 25 | #include <linux/gfp.h> |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 26 | #include <linux/types.h> |
| 27 | #include <linux/mm.h> |
| 28 | #include <linux/stddef.h> |
| 29 | #include <linux/init.h> |
| 30 | #include <linux/bootmem.h> |
| 31 | #include <linux/highmem.h> |
| 32 | #include <linux/initrd.h> |
| 33 | #include <linux/pagemap.h> |
Johannes Berg | 4e8ad3e | 2007-05-08 19:25:00 +1000 | [diff] [blame] | 34 | #include <linux/suspend.h> |
Yinghai Lu | 95f72d1 | 2010-07-12 14:36:09 +1000 | [diff] [blame] | 35 | #include <linux/memblock.h> |
David Gibson | 0895ecd | 2009-10-26 19:24:31 +0000 | [diff] [blame] | 36 | #include <linux/hugetlb.h> |
Anton Blanchard | c40dd2f | 2011-11-02 14:56:12 +0000 | [diff] [blame] | 37 | #include <linux/slab.h> |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 38 | |
| 39 | #include <asm/pgalloc.h> |
| 40 | #include <asm/prom.h> |
| 41 | #include <asm/io.h> |
| 42 | #include <asm/mmu_context.h> |
| 43 | #include <asm/pgtable.h> |
| 44 | #include <asm/mmu.h> |
| 45 | #include <asm/smp.h> |
| 46 | #include <asm/machdep.h> |
| 47 | #include <asm/btext.h> |
| 48 | #include <asm/tlb.h> |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 49 | #include <asm/sections.h> |
Tony Breeds | db7f37d | 2008-07-01 11:30:06 +1000 | [diff] [blame] | 50 | #include <asm/sparsemem.h> |
Paul Mackerras | ab1f9da | 2005-10-10 21:58:35 +1000 | [diff] [blame] | 51 | #include <asm/vdso.h> |
Kumar Gala | 2c419bd | 2008-04-23 23:05:20 +1000 | [diff] [blame] | 52 | #include <asm/fixmap.h> |
FUJITA Tomonori | a932729 | 2010-03-16 13:16:25 +0000 | [diff] [blame] | 53 | #include <asm/swiotlb.h> |
sukadev@linux.vnet.ibm.com | 8a3e3d3 | 2011-12-02 12:26:23 +0000 | [diff] [blame] | 54 | #include <asm/rtas.h> |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 55 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 56 | #include "mmu_decl.h" |
| 57 | |
| 58 | #ifndef CPU_FTR_COHERENT_ICACHE |
| 59 | #define CPU_FTR_COHERENT_ICACHE 0 /* XXX for now */ |
| 60 | #define CPU_FTR_NOEXECUTE 0 |
| 61 | #endif |
| 62 | |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 63 | int init_bootmem_done; |
| 64 | int mem_init_done; |
Suzuki Poulose | a84fcd4 | 2012-08-21 01:42:33 +0000 | [diff] [blame] | 65 | unsigned long long memory_limit; |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 66 | |
Kumar Gala | 2c419bd | 2008-04-23 23:05:20 +1000 | [diff] [blame] | 67 | #ifdef CONFIG_HIGHMEM |
| 68 | pte_t *kmap_pte; |
Kumar Gala | 2c419bd | 2008-04-23 23:05:20 +1000 | [diff] [blame] | 69 | EXPORT_SYMBOL(kmap_pte); |
Valentina Manea | 8040bda | 2013-03-10 03:22:39 +0000 | [diff] [blame] | 70 | pgprot_t kmap_prot; |
| 71 | EXPORT_SYMBOL(kmap_prot); |
Kumar Gala | 2c419bd | 2008-04-23 23:05:20 +1000 | [diff] [blame] | 72 | |
| 73 | static inline pte_t *virt_to_kpte(unsigned long vaddr) |
| 74 | { |
| 75 | return pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), |
| 76 | vaddr), vaddr), vaddr); |
| 77 | } |
| 78 | #endif |
| 79 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 80 | int page_is_ram(unsigned long pfn) |
| 81 | { |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 82 | #ifndef CONFIG_PPC64 /* XXX for now */ |
Roland Dreier | a880e76 | 2008-09-15 10:43:35 +0000 | [diff] [blame] | 83 | return pfn < max_pfn; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 84 | #else |
Roland Dreier | a880e76 | 2008-09-15 10:43:35 +0000 | [diff] [blame] | 85 | unsigned long paddr = (pfn << PAGE_SHIFT); |
Benjamin Herrenschmidt | 28be707 | 2010-08-04 13:43:53 +1000 | [diff] [blame] | 86 | struct memblock_region *reg; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 87 | |
Benjamin Herrenschmidt | 28be707 | 2010-08-04 13:43:53 +1000 | [diff] [blame] | 88 | for_each_memblock(memory, reg) |
| 89 | if (paddr >= reg->base && paddr < (reg->base + reg->size)) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 90 | return 1; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 91 | return 0; |
| 92 | #endif |
| 93 | } |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 94 | |
Roland Dreier | 8b15047 | 2005-10-28 17:46:18 -0700 | [diff] [blame] | 95 | pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn, |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 96 | unsigned long size, pgprot_t vma_prot) |
| 97 | { |
| 98 | if (ppc_md.phys_mem_access_prot) |
Roland Dreier | 8b15047 | 2005-10-28 17:46:18 -0700 | [diff] [blame] | 99 | return ppc_md.phys_mem_access_prot(file, pfn, size, vma_prot); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 100 | |
Roland Dreier | 8b15047 | 2005-10-28 17:46:18 -0700 | [diff] [blame] | 101 | if (!page_is_ram(pfn)) |
Benjamin Herrenschmidt | 64b3d0e | 2008-12-18 19:13:51 +0000 | [diff] [blame] | 102 | vma_prot = pgprot_noncached(vma_prot); |
| 103 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 104 | return vma_prot; |
| 105 | } |
| 106 | EXPORT_SYMBOL(phys_mem_access_prot); |
| 107 | |
Paul Mackerras | 23fd077 | 2005-10-31 13:37:12 +1100 | [diff] [blame] | 108 | #ifdef CONFIG_MEMORY_HOTPLUG |
| 109 | |
Yasunori Goto | bc02af9 | 2006-06-27 02:53:30 -0700 | [diff] [blame] | 110 | #ifdef CONFIG_NUMA |
| 111 | int memory_add_physaddr_to_nid(u64 start) |
| 112 | { |
| 113 | return hot_add_scn_to_nid(start); |
| 114 | } |
| 115 | #endif |
| 116 | |
Geert Uytterhoeven | fa90f70 | 2008-03-29 03:10:50 +1100 | [diff] [blame] | 117 | int arch_add_memory(int nid, u64 start, u64 size) |
Paul Mackerras | 23fd077 | 2005-10-31 13:37:12 +1100 | [diff] [blame] | 118 | { |
Mike Kravetz | 237a098 | 2005-12-05 12:06:42 -0800 | [diff] [blame] | 119 | struct pglist_data *pgdata; |
Paul Mackerras | 23fd077 | 2005-10-31 13:37:12 +1100 | [diff] [blame] | 120 | struct zone *zone; |
| 121 | unsigned long start_pfn = start >> PAGE_SHIFT; |
| 122 | unsigned long nr_pages = size >> PAGE_SHIFT; |
| 123 | |
Mike Kravetz | 237a098 | 2005-12-05 12:06:42 -0800 | [diff] [blame] | 124 | pgdata = NODE_DATA(nid); |
| 125 | |
Andrew Morton | 2d0eee1 | 2006-03-21 23:00:05 -0800 | [diff] [blame] | 126 | start = (unsigned long)__va(start); |
Anton Blanchard | a119409 | 2011-08-10 20:44:24 +0000 | [diff] [blame] | 127 | if (create_section_mapping(start, start + size)) |
| 128 | return -EINVAL; |
Mike Kravetz | 54b7924 | 2005-11-07 16:25:48 -0800 | [diff] [blame] | 129 | |
Paul Mackerras | 23fd077 | 2005-10-31 13:37:12 +1100 | [diff] [blame] | 130 | /* this should work for most non-highmem platforms */ |
| 131 | zone = pgdata->node_zones; |
| 132 | |
Gary Hade | c04fc58 | 2009-01-06 14:39:14 -0800 | [diff] [blame] | 133 | return __add_pages(nid, zone, start_pfn, nr_pages); |
Paul Mackerras | 23fd077 | 2005-10-31 13:37:12 +1100 | [diff] [blame] | 134 | } |
Wen Congyang | 24d335c | 2013-02-22 16:32:58 -0800 | [diff] [blame] | 135 | |
| 136 | #ifdef CONFIG_MEMORY_HOTREMOVE |
| 137 | int arch_remove_memory(u64 start, u64 size) |
| 138 | { |
| 139 | unsigned long start_pfn = start >> PAGE_SHIFT; |
| 140 | unsigned long nr_pages = size >> PAGE_SHIFT; |
| 141 | struct zone *zone; |
Nathan Fontenot | 9ac8cde | 2014-01-27 10:54:06 -0600 | [diff] [blame] | 142 | int ret; |
Wen Congyang | 24d335c | 2013-02-22 16:32:58 -0800 | [diff] [blame] | 143 | |
| 144 | zone = page_zone(pfn_to_page(start_pfn)); |
Nathan Fontenot | 9ac8cde | 2014-01-27 10:54:06 -0600 | [diff] [blame] | 145 | ret = __remove_pages(zone, start_pfn, nr_pages); |
| 146 | if (!ret && (ppc_md.remove_memory)) |
| 147 | ret = ppc_md.remove_memory(start, size); |
| 148 | |
| 149 | return ret; |
Wen Congyang | 24d335c | 2013-02-22 16:32:58 -0800 | [diff] [blame] | 150 | } |
| 151 | #endif |
Nathan Lynch | 0d57994 | 2008-06-04 08:30:54 +1000 | [diff] [blame] | 152 | #endif /* CONFIG_MEMORY_HOTPLUG */ |
Badari Pulavarty | a99824f | 2008-02-05 00:10:18 -0800 | [diff] [blame] | 153 | |
| 154 | /* |
| 155 | * walk_memory_resource() needs to make sure there is no holes in a given |
Badari Pulavarty | 9d88a2e | 2008-04-18 13:33:53 -0700 | [diff] [blame] | 156 | * memory range. PPC64 does not maintain the memory layout in /proc/iomem. |
Yinghai Lu | 95f72d1 | 2010-07-12 14:36:09 +1000 | [diff] [blame] | 157 | * Instead it maintains it in memblock.memory structures. Walk through the |
Badari Pulavarty | 9d88a2e | 2008-04-18 13:33:53 -0700 | [diff] [blame] | 158 | * memory regions, find holes and callback for contiguous regions. |
Badari Pulavarty | a99824f | 2008-02-05 00:10:18 -0800 | [diff] [blame] | 159 | */ |
| 160 | int |
KAMEZAWA Hiroyuki | 908eedc | 2009-09-22 16:45:46 -0700 | [diff] [blame] | 161 | walk_system_ram_range(unsigned long start_pfn, unsigned long nr_pages, |
| 162 | void *arg, int (*func)(unsigned long, unsigned long, void *)) |
Badari Pulavarty | a99824f | 2008-02-05 00:10:18 -0800 | [diff] [blame] | 163 | { |
Benjamin Herrenschmidt | 28be707 | 2010-08-04 13:43:53 +1000 | [diff] [blame] | 164 | struct memblock_region *reg; |
| 165 | unsigned long end_pfn = start_pfn + nr_pages; |
| 166 | unsigned long tstart, tend; |
Badari Pulavarty | 9d88a2e | 2008-04-18 13:33:53 -0700 | [diff] [blame] | 167 | int ret = -1; |
| 168 | |
Benjamin Herrenschmidt | 28be707 | 2010-08-04 13:43:53 +1000 | [diff] [blame] | 169 | for_each_memblock(memory, reg) { |
Yinghai Lu | c7fc2de | 2010-10-12 14:07:09 -0700 | [diff] [blame] | 170 | tstart = max(start_pfn, memblock_region_memory_base_pfn(reg)); |
| 171 | tend = min(end_pfn, memblock_region_memory_end_pfn(reg)); |
Benjamin Herrenschmidt | 28be707 | 2010-08-04 13:43:53 +1000 | [diff] [blame] | 172 | if (tstart >= tend) |
| 173 | continue; |
| 174 | ret = (*func)(tstart, tend - tstart, arg); |
Badari Pulavarty | 9d88a2e | 2008-04-18 13:33:53 -0700 | [diff] [blame] | 175 | if (ret) |
| 176 | break; |
Badari Pulavarty | 9d88a2e | 2008-04-18 13:33:53 -0700 | [diff] [blame] | 177 | } |
| 178 | return ret; |
Badari Pulavarty | a99824f | 2008-02-05 00:10:18 -0800 | [diff] [blame] | 179 | } |
KAMEZAWA Hiroyuki | 908eedc | 2009-09-22 16:45:46 -0700 | [diff] [blame] | 180 | EXPORT_SYMBOL_GPL(walk_system_ram_range); |
Badari Pulavarty | a99824f | 2008-02-05 00:10:18 -0800 | [diff] [blame] | 181 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 182 | /* |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 183 | * Initialize the bootmem system and give it all the memory we |
| 184 | * have available. If we are using highmem, we only put the |
| 185 | * lowmem into the bootmem system. |
| 186 | */ |
| 187 | #ifndef CONFIG_NEED_MULTIPLE_NODES |
| 188 | void __init do_init_bootmem(void) |
| 189 | { |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 190 | unsigned long start, bootmap_pages; |
| 191 | unsigned long total_pages; |
Benjamin Herrenschmidt | 28be707 | 2010-08-04 13:43:53 +1000 | [diff] [blame] | 192 | struct memblock_region *reg; |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 193 | int boot_mapsize; |
| 194 | |
Yinghai Lu | 95f72d1 | 2010-07-12 14:36:09 +1000 | [diff] [blame] | 195 | max_low_pfn = max_pfn = memblock_end_of_DRAM() >> PAGE_SHIFT; |
| 196 | total_pages = (memblock_end_of_DRAM() - memstart_addr) >> PAGE_SHIFT; |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 197 | #ifdef CONFIG_HIGHMEM |
| 198 | total_pages = total_lowmem >> PAGE_SHIFT; |
Kumar Gala | d7917ba | 2008-04-16 05:52:22 +1000 | [diff] [blame] | 199 | max_low_pfn = lowmem_end_addr >> PAGE_SHIFT; |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 200 | #endif |
| 201 | |
| 202 | /* |
| 203 | * Find an area to use for the bootmem bitmap. Calculate the size of |
| 204 | * bitmap required as (Total Memory) / PAGE_SIZE / BITS_PER_BYTE. |
| 205 | * Add 1 additional page in case the address isn't page-aligned. |
| 206 | */ |
| 207 | bootmap_pages = bootmem_bootmap_pages(total_pages); |
| 208 | |
Yinghai Lu | 95f72d1 | 2010-07-12 14:36:09 +1000 | [diff] [blame] | 209 | start = memblock_alloc(bootmap_pages << PAGE_SHIFT, PAGE_SIZE); |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 210 | |
Kumar Gala | 37dd2ba | 2008-04-22 04:22:34 +1000 | [diff] [blame] | 211 | min_low_pfn = MEMORY_START >> PAGE_SHIFT; |
| 212 | boot_mapsize = init_bootmem_node(NODE_DATA(0), start >> PAGE_SHIFT, min_low_pfn, max_low_pfn); |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 213 | |
Cody P Schafer | 4e8309b | 2013-01-09 12:40:18 +0000 | [diff] [blame] | 214 | /* Place all memblock_regions in the same node and merge contiguous |
| 215 | * memblock_regions |
| 216 | */ |
Tang Chen | e7e8de5 | 2014-01-21 15:49:26 -0800 | [diff] [blame] | 217 | memblock_set_node(0, (phys_addr_t)ULLONG_MAX, &memblock.memory, 0); |
Mel Gorman | c67c3cb | 2006-09-27 01:49:49 -0700 | [diff] [blame] | 218 | |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 219 | /* Add all physical memory to the bootmem map, mark each area |
| 220 | * present. |
| 221 | */ |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 222 | #ifdef CONFIG_HIGHMEM |
Kumar Gala | d7917ba | 2008-04-16 05:52:22 +1000 | [diff] [blame] | 223 | free_bootmem_with_active_regions(0, lowmem_end_addr >> PAGE_SHIFT); |
Kumar Gala | f98eeb4 | 2008-01-09 11:27:23 -0600 | [diff] [blame] | 224 | |
| 225 | /* reserve the sections we're already using */ |
Benjamin Herrenschmidt | 28be707 | 2010-08-04 13:43:53 +1000 | [diff] [blame] | 226 | for_each_memblock(reserved, reg) { |
| 227 | unsigned long top = reg->base + reg->size - 1; |
| 228 | if (top < lowmem_end_addr) |
| 229 | reserve_bootmem(reg->base, reg->size, BOOTMEM_DEFAULT); |
| 230 | else if (reg->base < lowmem_end_addr) { |
| 231 | unsigned long trunc_size = lowmem_end_addr - reg->base; |
| 232 | reserve_bootmem(reg->base, trunc_size, BOOTMEM_DEFAULT); |
Kumar Gala | f98eeb4 | 2008-01-09 11:27:23 -0600 | [diff] [blame] | 233 | } |
| 234 | } |
Mel Gorman | c67c3cb | 2006-09-27 01:49:49 -0700 | [diff] [blame] | 235 | #else |
| 236 | free_bootmem_with_active_regions(0, max_pfn); |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 237 | |
| 238 | /* reserve the sections we're already using */ |
Benjamin Herrenschmidt | 28be707 | 2010-08-04 13:43:53 +1000 | [diff] [blame] | 239 | for_each_memblock(reserved, reg) |
| 240 | reserve_bootmem(reg->base, reg->size, BOOTMEM_DEFAULT); |
Kumar Gala | f98eeb4 | 2008-01-09 11:27:23 -0600 | [diff] [blame] | 241 | #endif |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 242 | /* XXX need to clip this if using highmem? */ |
Mel Gorman | c67c3cb | 2006-09-27 01:49:49 -0700 | [diff] [blame] | 243 | sparse_memory_present_with_active_regions(0); |
| 244 | |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 245 | init_bootmem_done = 1; |
| 246 | } |
| 247 | |
Johannes Berg | 4e8ad3e | 2007-05-08 19:25:00 +1000 | [diff] [blame] | 248 | /* mark pages that don't exist as nosave */ |
| 249 | static int __init mark_nonram_nosave(void) |
| 250 | { |
Benjamin Herrenschmidt | 28be707 | 2010-08-04 13:43:53 +1000 | [diff] [blame] | 251 | struct memblock_region *reg, *prev = NULL; |
Johannes Berg | 4e8ad3e | 2007-05-08 19:25:00 +1000 | [diff] [blame] | 252 | |
Benjamin Herrenschmidt | 28be707 | 2010-08-04 13:43:53 +1000 | [diff] [blame] | 253 | for_each_memblock(memory, reg) { |
| 254 | if (prev && |
Yinghai Lu | c7fc2de | 2010-10-12 14:07:09 -0700 | [diff] [blame] | 255 | memblock_region_memory_end_pfn(prev) < memblock_region_memory_base_pfn(reg)) |
| 256 | register_nosave_region(memblock_region_memory_end_pfn(prev), |
| 257 | memblock_region_memory_base_pfn(reg)); |
Benjamin Herrenschmidt | 28be707 | 2010-08-04 13:43:53 +1000 | [diff] [blame] | 258 | prev = reg; |
Johannes Berg | 4e8ad3e | 2007-05-08 19:25:00 +1000 | [diff] [blame] | 259 | } |
Johannes Berg | 4e8ad3e | 2007-05-08 19:25:00 +1000 | [diff] [blame] | 260 | return 0; |
| 261 | } |
| 262 | |
Scott Wood | 1c98025 | 2014-08-08 18:40:42 -0500 | [diff] [blame^] | 263 | static bool zone_limits_final; |
| 264 | |
| 265 | static unsigned long max_zone_pfns[MAX_NR_ZONES] = { |
| 266 | [0 ... MAX_NR_ZONES - 1] = ~0UL |
| 267 | }; |
| 268 | |
| 269 | /* |
| 270 | * Restrict the specified zone and all more restrictive zones |
| 271 | * to be below the specified pfn. May not be called after |
| 272 | * paging_init(). |
| 273 | */ |
| 274 | void __init limit_zone_pfn(enum zone_type zone, unsigned long pfn_limit) |
| 275 | { |
| 276 | int i; |
| 277 | |
| 278 | if (WARN_ON(zone_limits_final)) |
| 279 | return; |
| 280 | |
| 281 | for (i = zone; i >= 0; i--) { |
| 282 | if (max_zone_pfns[i] > pfn_limit) |
| 283 | max_zone_pfns[i] = pfn_limit; |
| 284 | } |
| 285 | } |
| 286 | |
| 287 | /* |
| 288 | * Find the least restrictive zone that is entirely below the |
| 289 | * specified pfn limit. Returns < 0 if no suitable zone is found. |
| 290 | * |
| 291 | * pfn_limit must be u64 because it can exceed 32 bits even on 32-bit |
| 292 | * systems -- the DMA limit can be higher than any possible real pfn. |
| 293 | */ |
| 294 | int dma_pfn_limit_to_zone(u64 pfn_limit) |
| 295 | { |
| 296 | enum zone_type top_zone = ZONE_NORMAL; |
| 297 | int i; |
| 298 | |
| 299 | #ifdef CONFIG_HIGHMEM |
| 300 | top_zone = ZONE_HIGHMEM; |
| 301 | #endif |
| 302 | |
| 303 | for (i = top_zone; i >= 0; i--) { |
| 304 | if (max_zone_pfns[i] <= pfn_limit) |
| 305 | return i; |
| 306 | } |
| 307 | |
| 308 | return -EPERM; |
| 309 | } |
| 310 | |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 311 | /* |
| 312 | * paging_init() sets up the page tables - in fact we've already done this. |
| 313 | */ |
| 314 | void __init paging_init(void) |
| 315 | { |
Tony Breeds | f7ba299 | 2011-07-04 18:44:19 +0000 | [diff] [blame] | 316 | unsigned long long total_ram = memblock_phys_mem_size(); |
Yinghai Lu | 95f72d1 | 2010-07-12 14:36:09 +1000 | [diff] [blame] | 317 | phys_addr_t top_of_ram = memblock_end_of_DRAM(); |
Scott Wood | 1c98025 | 2014-08-08 18:40:42 -0500 | [diff] [blame^] | 318 | enum zone_type top_zone; |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 319 | |
Kumar Gala | 2c419bd | 2008-04-23 23:05:20 +1000 | [diff] [blame] | 320 | #ifdef CONFIG_PPC32 |
| 321 | unsigned long v = __fix_to_virt(__end_of_fixed_addresses - 1); |
| 322 | unsigned long end = __fix_to_virt(FIX_HOLE); |
| 323 | |
| 324 | for (; v < end; v += PAGE_SIZE) |
| 325 | map_page(v, 0, 0); /* XXX gross */ |
| 326 | #endif |
| 327 | |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 328 | #ifdef CONFIG_HIGHMEM |
| 329 | map_page(PKMAP_BASE, 0, 0); /* XXX gross */ |
Kumar Gala | 2c419bd | 2008-04-23 23:05:20 +1000 | [diff] [blame] | 330 | pkmap_page_table = virt_to_kpte(PKMAP_BASE); |
| 331 | |
| 332 | kmap_pte = virt_to_kpte(__fix_to_virt(FIX_KMAP_BEGIN)); |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 333 | kmap_prot = PAGE_KERNEL; |
| 334 | #endif /* CONFIG_HIGHMEM */ |
| 335 | |
Tony Breeds | f7ba299 | 2011-07-04 18:44:19 +0000 | [diff] [blame] | 336 | printk(KERN_DEBUG "Top of RAM: 0x%llx, Total RAM: 0x%llx\n", |
Tony Breeds | fb61063 | 2008-07-31 13:51:42 +1000 | [diff] [blame] | 337 | (unsigned long long)top_of_ram, total_ram); |
Olof Johansson | e110b28 | 2006-04-12 15:25:01 -0500 | [diff] [blame] | 338 | printk(KERN_DEBUG "Memory hole size: %ldMB\n", |
Stefan Roese | 2bf3016 | 2008-07-10 01:09:23 +1000 | [diff] [blame] | 339 | (long int)((top_of_ram - total_ram) >> 20)); |
Scott Wood | 1c98025 | 2014-08-08 18:40:42 -0500 | [diff] [blame^] | 340 | |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 341 | #ifdef CONFIG_HIGHMEM |
Scott Wood | 1c98025 | 2014-08-08 18:40:42 -0500 | [diff] [blame^] | 342 | top_zone = ZONE_HIGHMEM; |
| 343 | limit_zone_pfn(ZONE_NORMAL, lowmem_end_addr >> PAGE_SHIFT); |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 344 | #else |
Scott Wood | 1c98025 | 2014-08-08 18:40:42 -0500 | [diff] [blame^] | 345 | top_zone = ZONE_NORMAL; |
Mel Gorman | c67c3cb | 2006-09-27 01:49:49 -0700 | [diff] [blame] | 346 | #endif |
Scott Wood | 1c98025 | 2014-08-08 18:40:42 -0500 | [diff] [blame^] | 347 | |
| 348 | limit_zone_pfn(top_zone, top_of_ram >> PAGE_SHIFT); |
| 349 | zone_limits_final = true; |
Mel Gorman | c67c3cb | 2006-09-27 01:49:49 -0700 | [diff] [blame] | 350 | free_area_init_nodes(max_zone_pfns); |
Johannes Berg | 4e8ad3e | 2007-05-08 19:25:00 +1000 | [diff] [blame] | 351 | |
| 352 | mark_nonram_nosave(); |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 353 | } |
| 354 | #endif /* ! CONFIG_NEED_MULTIPLE_NODES */ |
| 355 | |
Nathan Fontenot | f7e3334 | 2013-09-27 10:18:09 -0500 | [diff] [blame] | 356 | static void __init register_page_bootmem_info(void) |
| 357 | { |
| 358 | int i; |
| 359 | |
| 360 | for_each_online_node(i) |
| 361 | register_page_bootmem_info_node(NODE_DATA(i)); |
| 362 | } |
| 363 | |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 364 | void __init mem_init(void) |
| 365 | { |
Scott Wood | 28efc35 | 2013-10-11 19:22:38 -0500 | [diff] [blame] | 366 | /* |
| 367 | * book3s is limited to 16 page sizes due to encoding this in |
| 368 | * a 4-bit field for slices. |
| 369 | */ |
| 370 | BUILD_BUG_ON(MMU_PAGE_COUNT > 16); |
| 371 | |
FUJITA Tomonori | a932729 | 2010-03-16 13:16:25 +0000 | [diff] [blame] | 372 | #ifdef CONFIG_SWIOTLB |
Jia Hongtao | 688ba1d | 2012-08-03 18:14:10 +0800 | [diff] [blame] | 373 | swiotlb_init(0); |
FUJITA Tomonori | a932729 | 2010-03-16 13:16:25 +0000 | [diff] [blame] | 374 | #endif |
| 375 | |
Nathan Fontenot | f7e3334 | 2013-09-27 10:18:09 -0500 | [diff] [blame] | 376 | register_page_bootmem_info(); |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 377 | high_memory = (void *) __va(max_low_pfn * PAGE_SIZE); |
Jiang Liu | 602ddc7 | 2013-07-03 15:04:32 -0700 | [diff] [blame] | 378 | set_max_mapnr(max_pfn); |
Jiang Liu | 0c98853 | 2013-07-03 15:03:24 -0700 | [diff] [blame] | 379 | free_all_bootmem(); |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 380 | |
| 381 | #ifdef CONFIG_HIGHMEM |
| 382 | { |
| 383 | unsigned long pfn, highmem_mapnr; |
| 384 | |
Kumar Gala | d7917ba | 2008-04-16 05:52:22 +1000 | [diff] [blame] | 385 | highmem_mapnr = lowmem_end_addr >> PAGE_SHIFT; |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 386 | for (pfn = highmem_mapnr; pfn < max_mapnr; ++pfn) { |
Becky Bruce | 3d41e0f | 2011-06-28 09:54:46 +0000 | [diff] [blame] | 387 | phys_addr_t paddr = (phys_addr_t)pfn << PAGE_SHIFT; |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 388 | struct page *page = pfn_to_page(pfn); |
Jiang Liu | 369a9d8 | 2013-07-03 15:04:09 -0700 | [diff] [blame] | 389 | if (!memblock_is_reserved(paddr)) |
| 390 | free_highmem_page(page); |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 391 | } |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 392 | } |
| 393 | #endif /* CONFIG_HIGHMEM */ |
| 394 | |
Becky Bruce | 3160b09 | 2011-06-28 14:54:47 -0500 | [diff] [blame] | 395 | #if defined(CONFIG_PPC_FSL_BOOK3E) && !defined(CONFIG_SMP) |
| 396 | /* |
| 397 | * If smp is enabled, next_tlbcam_idx is initialized in the cpu up |
| 398 | * functions.... do it here for the non-smp case. |
| 399 | */ |
| 400 | per_cpu(next_tlbcam_idx, smp_processor_id()) = |
| 401 | (mfspr(SPRN_TLB1CFG) & TLBnCFG_N_ENTRY) - 1; |
| 402 | #endif |
| 403 | |
Jiang Liu | 369a9d8 | 2013-07-03 15:04:09 -0700 | [diff] [blame] | 404 | mem_init_print_info(NULL); |
Benjamin Herrenschmidt | f637a49 | 2009-05-27 13:44:50 +1000 | [diff] [blame] | 405 | #ifdef CONFIG_PPC32 |
| 406 | pr_info("Kernel virtual memory layout:\n"); |
| 407 | pr_info(" * 0x%08lx..0x%08lx : fixmap\n", FIXADDR_START, FIXADDR_TOP); |
| 408 | #ifdef CONFIG_HIGHMEM |
| 409 | pr_info(" * 0x%08lx..0x%08lx : highmem PTEs\n", |
| 410 | PKMAP_BASE, PKMAP_ADDR(LAST_PKMAP)); |
| 411 | #endif /* CONFIG_HIGHMEM */ |
Benjamin Herrenschmidt | 8b31e49 | 2009-05-27 13:50:33 +1000 | [diff] [blame] | 412 | #ifdef CONFIG_NOT_COHERENT_CACHE |
| 413 | pr_info(" * 0x%08lx..0x%08lx : consistent mem\n", |
| 414 | IOREMAP_TOP, IOREMAP_TOP + CONFIG_CONSISTENT_SIZE); |
| 415 | #endif /* CONFIG_NOT_COHERENT_CACHE */ |
Benjamin Herrenschmidt | f637a49 | 2009-05-27 13:44:50 +1000 | [diff] [blame] | 416 | pr_info(" * 0x%08lx..0x%08lx : early ioremap\n", |
| 417 | ioremap_bot, IOREMAP_TOP); |
| 418 | pr_info(" * 0x%08lx..0x%08lx : vmalloc & ioremap\n", |
| 419 | VMALLOC_START, VMALLOC_END); |
| 420 | #endif /* CONFIG_PPC32 */ |
| 421 | |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 422 | mem_init_done = 1; |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 423 | } |
| 424 | |
Dave Carroll | 2773fcc | 2011-06-18 07:36:39 +0000 | [diff] [blame] | 425 | void free_initmem(void) |
| 426 | { |
Dave Carroll | a9c0f41 | 2011-06-18 07:36:40 +0000 | [diff] [blame] | 427 | ppc_md.progress = ppc_printk_progress; |
Jiang Liu | 5d585e5 | 2013-04-29 15:06:47 -0700 | [diff] [blame] | 428 | free_initmem_default(POISON_FREE_INITMEM); |
Dave Carroll | 2773fcc | 2011-06-18 07:36:39 +0000 | [diff] [blame] | 429 | } |
| 430 | |
Benjamin Herrenschmidt | 307cfe7 | 2011-06-09 16:52:38 +1000 | [diff] [blame] | 431 | #ifdef CONFIG_BLK_DEV_INITRD |
| 432 | void __init free_initrd_mem(unsigned long start, unsigned long end) |
| 433 | { |
Jiang Liu | dbe67df | 2013-07-03 15:02:51 -0700 | [diff] [blame] | 434 | free_reserved_area((void *)start, (void *)end, -1, "initrd"); |
Benjamin Herrenschmidt | 307cfe7 | 2011-06-09 16:52:38 +1000 | [diff] [blame] | 435 | } |
| 436 | #endif |
| 437 | |
Paul Mackerras | 7c8c6b9 | 2005-10-06 12:23:33 +1000 | [diff] [blame] | 438 | /* |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 439 | * This is called when a page has been modified by the kernel. |
| 440 | * It just marks the page as not i-cache clean. We do the i-cache |
| 441 | * flush later when the page is given to a user process, if necessary. |
| 442 | */ |
| 443 | void flush_dcache_page(struct page *page) |
| 444 | { |
| 445 | if (cpu_has_feature(CPU_FTR_COHERENT_ICACHE)) |
| 446 | return; |
| 447 | /* avoid an atomic op if possible */ |
| 448 | if (test_bit(PG_arch_1, &page->flags)) |
| 449 | clear_bit(PG_arch_1, &page->flags); |
| 450 | } |
| 451 | EXPORT_SYMBOL(flush_dcache_page); |
| 452 | |
| 453 | void flush_dcache_icache_page(struct page *page) |
| 454 | { |
David Gibson | 0895ecd | 2009-10-26 19:24:31 +0000 | [diff] [blame] | 455 | #ifdef CONFIG_HUGETLB_PAGE |
| 456 | if (PageCompound(page)) { |
| 457 | flush_dcache_icache_hugepage(page); |
| 458 | return; |
| 459 | } |
| 460 | #endif |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 461 | #ifdef CONFIG_BOOKE |
David Gibson | 0895ecd | 2009-10-26 19:24:31 +0000 | [diff] [blame] | 462 | { |
Cong Wang | 2480b20 | 2011-11-25 23:14:16 +0800 | [diff] [blame] | 463 | void *start = kmap_atomic(page); |
David Gibson | 0895ecd | 2009-10-26 19:24:31 +0000 | [diff] [blame] | 464 | __flush_dcache_icache(start); |
Cong Wang | 2480b20 | 2011-11-25 23:14:16 +0800 | [diff] [blame] | 465 | kunmap_atomic(start); |
David Gibson | 0895ecd | 2009-10-26 19:24:31 +0000 | [diff] [blame] | 466 | } |
Paul Mackerras | ab1f9da | 2005-10-10 21:58:35 +1000 | [diff] [blame] | 467 | #elif defined(CONFIG_8xx) || defined(CONFIG_PPC64) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 468 | /* On 8xx there is no need to kmap since highmem is not supported */ |
| 469 | __flush_dcache_icache(page_address(page)); |
| 470 | #else |
| 471 | __flush_dcache_icache_phys(page_to_pfn(page) << PAGE_SHIFT); |
| 472 | #endif |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 473 | } |
Alexander Graf | 249ba1e | 2012-08-03 13:56:33 +0200 | [diff] [blame] | 474 | EXPORT_SYMBOL(flush_dcache_icache_page); |
David Gibson | 0895ecd | 2009-10-26 19:24:31 +0000 | [diff] [blame] | 475 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 476 | void clear_user_page(void *page, unsigned long vaddr, struct page *pg) |
| 477 | { |
| 478 | clear_page(page); |
| 479 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 480 | /* |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 481 | * We shouldn't have to do this, but some versions of glibc |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 482 | * require it (ld.so assumes zero filled pages are icache clean) |
| 483 | * - Anton |
| 484 | */ |
David Gibson | 09f5dc4 | 2006-02-06 13:24:53 +1100 | [diff] [blame] | 485 | flush_dcache_page(pg); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 486 | } |
| 487 | EXPORT_SYMBOL(clear_user_page); |
| 488 | |
| 489 | void copy_user_page(void *vto, void *vfrom, unsigned long vaddr, |
| 490 | struct page *pg) |
| 491 | { |
| 492 | copy_page(vto, vfrom); |
| 493 | |
| 494 | /* |
| 495 | * We should be able to use the following optimisation, however |
| 496 | * there are two problems. |
| 497 | * Firstly a bug in some versions of binutils meant PLT sections |
| 498 | * were not marked executable. |
| 499 | * Secondly the first word in the GOT section is blrl, used |
| 500 | * to establish the GOT address. Until recently the GOT was |
| 501 | * not marked executable. |
| 502 | * - Anton |
| 503 | */ |
| 504 | #if 0 |
| 505 | if (!vma->vm_file && ((vma->vm_flags & VM_EXEC) == 0)) |
| 506 | return; |
| 507 | #endif |
| 508 | |
David Gibson | 09f5dc4 | 2006-02-06 13:24:53 +1100 | [diff] [blame] | 509 | flush_dcache_page(pg); |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 510 | } |
| 511 | |
| 512 | void flush_icache_user_range(struct vm_area_struct *vma, struct page *page, |
| 513 | unsigned long addr, int len) |
| 514 | { |
| 515 | unsigned long maddr; |
| 516 | |
| 517 | maddr = (unsigned long) kmap(page) + (addr & ~PAGE_MASK); |
| 518 | flush_icache_range(maddr, maddr + len); |
| 519 | kunmap(page); |
| 520 | } |
| 521 | EXPORT_SYMBOL(flush_icache_user_range); |
| 522 | |
| 523 | /* |
| 524 | * This is called at the end of handling a user page fault, when the |
| 525 | * fault has been handled by updating a PTE in the linux page tables. |
| 526 | * We use it to preload an HPTE into the hash table corresponding to |
| 527 | * the updated linux PTE. |
| 528 | * |
Hugh Dickins | 01edcd8 | 2005-11-23 13:37:39 -0800 | [diff] [blame] | 529 | * This must always be called with the pte lock held. |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 530 | */ |
| 531 | void update_mmu_cache(struct vm_area_struct *vma, unsigned long address, |
Russell King | 4b3073e | 2009-12-18 16:40:18 +0000 | [diff] [blame] | 532 | pte_t *ptep) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 533 | { |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 534 | #ifdef CONFIG_PPC_STD_MMU |
Aneesh Kumar K.V | 0ac52dd | 2013-06-20 14:30:22 +0530 | [diff] [blame] | 535 | /* |
| 536 | * We don't need to worry about _PAGE_PRESENT here because we are |
| 537 | * called with either mm->page_table_lock held or ptl lock held |
| 538 | */ |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 539 | unsigned long access = 0, trap; |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 540 | |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 541 | /* We only want HPTEs for linux PTEs that have _PAGE_ACCESSED set */ |
Russell King | 4b3073e | 2009-12-18 16:40:18 +0000 | [diff] [blame] | 542 | if (!pte_young(*ptep) || address >= TASK_SIZE) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 543 | return; |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 544 | |
| 545 | /* We try to figure out if we are coming from an instruction |
| 546 | * access fault and pass that down to __hash_page so we avoid |
| 547 | * double-faulting on execution of fresh text. We have to test |
| 548 | * for regs NULL since init will get here first thing at boot |
| 549 | * |
| 550 | * We also avoid filling the hash if not coming from a fault |
| 551 | */ |
| 552 | if (current->thread.regs == NULL) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 553 | return; |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 554 | trap = TRAP(current->thread.regs); |
| 555 | if (trap == 0x400) |
| 556 | access |= _PAGE_EXEC; |
| 557 | else if (trap != 0x300) |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 558 | return; |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 559 | hash_preload(vma->vm_mm, address, access, trap); |
| 560 | #endif /* CONFIG_PPC_STD_MMU */ |
Becky Bruce | 41151e7 | 2011-06-28 09:54:48 +0000 | [diff] [blame] | 561 | #if (defined(CONFIG_PPC_BOOK3E_64) || defined(CONFIG_PPC_FSL_BOOK3E)) \ |
| 562 | && defined(CONFIG_HUGETLB_PAGE) |
| 563 | if (is_vm_hugetlb_page(vma)) |
Becky Bruce | d93e4d7 | 2011-11-28 14:43:33 +0000 | [diff] [blame] | 564 | book3e_hugetlb_preload(vma, address, *ptep); |
Becky Bruce | 41151e7 | 2011-06-28 09:54:48 +0000 | [diff] [blame] | 565 | #endif |
Paul Mackerras | 14cf11a | 2005-09-26 16:04:21 +1000 | [diff] [blame] | 566 | } |
Anton Blanchard | c40dd2f | 2011-11-02 14:56:12 +0000 | [diff] [blame] | 567 | |
| 568 | /* |
| 569 | * System memory should not be in /proc/iomem but various tools expect it |
| 570 | * (eg kdump). |
| 571 | */ |
Geert Uytterhoeven | 4f77092 | 2013-09-15 11:39:36 +0200 | [diff] [blame] | 572 | static int __init add_system_ram_resources(void) |
Anton Blanchard | c40dd2f | 2011-11-02 14:56:12 +0000 | [diff] [blame] | 573 | { |
| 574 | struct memblock_region *reg; |
| 575 | |
| 576 | for_each_memblock(memory, reg) { |
| 577 | struct resource *res; |
| 578 | unsigned long base = reg->base; |
| 579 | unsigned long size = reg->size; |
| 580 | |
| 581 | res = kzalloc(sizeof(struct resource), GFP_KERNEL); |
| 582 | WARN_ON(!res); |
| 583 | |
| 584 | if (res) { |
| 585 | res->name = "System RAM"; |
| 586 | res->start = base; |
| 587 | res->end = base + size - 1; |
Nathan Fontenot | f748eda | 2013-08-19 21:52:20 -0500 | [diff] [blame] | 588 | res->flags = IORESOURCE_MEM | IORESOURCE_BUSY; |
Anton Blanchard | c40dd2f | 2011-11-02 14:56:12 +0000 | [diff] [blame] | 589 | WARN_ON(request_resource(&iomem_resource, res) < 0); |
| 590 | } |
| 591 | } |
| 592 | |
| 593 | return 0; |
| 594 | } |
| 595 | subsys_initcall(add_system_ram_resources); |
sukadev@linux.vnet.ibm.com | 1d54cf2 | 2011-08-30 09:19:17 +0000 | [diff] [blame] | 596 | |
| 597 | #ifdef CONFIG_STRICT_DEVMEM |
| 598 | /* |
| 599 | * devmem_is_allowed(): check to see if /dev/mem access to a certain address |
| 600 | * is valid. The argument is a physical page number. |
| 601 | * |
| 602 | * Access has to be given to non-kernel-ram areas as well, these contain the |
| 603 | * PCI mmio resources as well as potential bios/acpi data regions. |
| 604 | */ |
| 605 | int devmem_is_allowed(unsigned long pfn) |
| 606 | { |
| 607 | if (iomem_is_exclusive(pfn << PAGE_SHIFT)) |
| 608 | return 0; |
| 609 | if (!page_is_ram(pfn)) |
| 610 | return 1; |
sukadev@linux.vnet.ibm.com | 8a3e3d3 | 2011-12-02 12:26:23 +0000 | [diff] [blame] | 611 | if (page_is_rtas_user_buf(pfn)) |
| 612 | return 1; |
sukadev@linux.vnet.ibm.com | 1d54cf2 | 2011-08-30 09:19:17 +0000 | [diff] [blame] | 613 | return 0; |
| 614 | } |
| 615 | #endif /* CONFIG_STRICT_DEVMEM */ |