]>
git.proxmox.com Git - mirror_ubuntu-disco-kernel.git/blob - arch/powerpc/mm/pgtable_64.c
2 * This file contains ioremap and related functions for 64-bit machines.
4 * Derived from arch/ppc64/mm/init.c
5 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
7 * Modifications by Paul Mackerras (PowerMac) (paulus@samba.org)
8 * and Cort Dougan (PReP) (cort@cs.nmt.edu)
9 * Copyright (C) 1996 Paul Mackerras
11 * Derived from "arch/i386/mm/init.c"
12 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
14 * Dave Engebretsen <engebret@us.ibm.com>
15 * Rework for PPC64 port.
17 * This program is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU General Public License
19 * as published by the Free Software Foundation; either version
20 * 2 of the License, or (at your option) any later version.
24 #include <linux/signal.h>
25 #include <linux/sched.h>
26 #include <linux/kernel.h>
27 #include <linux/errno.h>
28 #include <linux/string.h>
29 #include <linux/export.h>
30 #include <linux/types.h>
31 #include <linux/mman.h>
33 #include <linux/swap.h>
34 #include <linux/stddef.h>
35 #include <linux/vmalloc.h>
36 #include <linux/slab.h>
37 #include <linux/hugetlb.h>
39 #include <asm/pgalloc.h>
43 #include <asm/mmu_context.h>
44 #include <asm/pgtable.h>
47 #include <asm/machdep.h>
49 #include <asm/processor.h>
50 #include <asm/cputable.h>
51 #include <asm/sections.h>
52 #include <asm/firmware.h>
58 #ifdef CONFIG_PPC_BOOK3S_64
60 * partition table and process table for ISA 3.0
62 struct prtb_entry
*process_tb
;
63 struct patb_entry
*partition_tb
;
67 unsigned long __pte_index_size
;
68 EXPORT_SYMBOL(__pte_index_size
);
69 unsigned long __pmd_index_size
;
70 EXPORT_SYMBOL(__pmd_index_size
);
71 unsigned long __pud_index_size
;
72 EXPORT_SYMBOL(__pud_index_size
);
73 unsigned long __pgd_index_size
;
74 EXPORT_SYMBOL(__pgd_index_size
);
75 unsigned long __pud_cache_index
;
76 EXPORT_SYMBOL(__pud_cache_index
);
77 unsigned long __pte_table_size
;
78 EXPORT_SYMBOL(__pte_table_size
);
79 unsigned long __pmd_table_size
;
80 EXPORT_SYMBOL(__pmd_table_size
);
81 unsigned long __pud_table_size
;
82 EXPORT_SYMBOL(__pud_table_size
);
83 unsigned long __pgd_table_size
;
84 EXPORT_SYMBOL(__pgd_table_size
);
85 unsigned long __pmd_val_bits
;
86 EXPORT_SYMBOL(__pmd_val_bits
);
87 unsigned long __pud_val_bits
;
88 EXPORT_SYMBOL(__pud_val_bits
);
89 unsigned long __pgd_val_bits
;
90 EXPORT_SYMBOL(__pgd_val_bits
);
91 unsigned long __kernel_virt_start
;
92 EXPORT_SYMBOL(__kernel_virt_start
);
93 unsigned long __kernel_virt_size
;
94 EXPORT_SYMBOL(__kernel_virt_size
);
95 unsigned long __vmalloc_start
;
96 EXPORT_SYMBOL(__vmalloc_start
);
97 unsigned long __vmalloc_end
;
98 EXPORT_SYMBOL(__vmalloc_end
);
99 unsigned long __kernel_io_start
;
100 EXPORT_SYMBOL(__kernel_io_start
);
101 struct page
*vmemmap
;
102 EXPORT_SYMBOL(vmemmap
);
103 unsigned long __pte_frag_nr
;
104 EXPORT_SYMBOL(__pte_frag_nr
);
105 unsigned long __pte_frag_size_shift
;
106 EXPORT_SYMBOL(__pte_frag_size_shift
);
107 unsigned long ioremap_bot
;
108 #else /* !CONFIG_PPC_BOOK3S_64 */
109 unsigned long ioremap_bot
= IOREMAP_BASE
;
113 * __ioremap_at - Low level function to establish the page tables
116 void __iomem
*__ioremap_at(phys_addr_t pa
, void *ea
, unsigned long size
, pgprot_t prot
)
120 /* We don't support the 4K PFN hack with ioremap */
121 if (pgprot_val(prot
) & H_PAGE_4K_PFN
)
124 WARN_ON(pa
& ~PAGE_MASK
);
125 WARN_ON(((unsigned long)ea
) & ~PAGE_MASK
);
126 WARN_ON(size
& ~PAGE_MASK
);
128 for (i
= 0; i
< size
; i
+= PAGE_SIZE
)
129 if (map_kernel_page((unsigned long)ea
+ i
, pa
+ i
, prot
))
132 return (void __iomem
*)ea
;
136 * __iounmap_from - Low level function to tear down the page tables
137 * for an IO mapping. This is used for mappings that
138 * are manipulated manually, like partial unmapping of
139 * PCI IOs or ISA space.
141 void __iounmap_at(void *ea
, unsigned long size
)
143 WARN_ON(((unsigned long)ea
) & ~PAGE_MASK
);
144 WARN_ON(size
& ~PAGE_MASK
);
146 unmap_kernel_range((unsigned long)ea
, size
);
149 void __iomem
* __ioremap_caller(phys_addr_t addr
, unsigned long size
,
150 pgprot_t prot
, void *caller
)
152 phys_addr_t paligned
;
156 * Choose an address to map it to.
157 * Once the imalloc system is running, we use it.
158 * Before that, we map using addresses going
159 * up from ioremap_bot. imalloc will use
160 * the addresses from ioremap_bot through
164 paligned
= addr
& PAGE_MASK
;
165 size
= PAGE_ALIGN(addr
+ size
) - paligned
;
167 if ((size
== 0) || (paligned
== 0))
170 if (slab_is_available()) {
171 struct vm_struct
*area
;
173 area
= __get_vm_area_caller(size
, VM_IOREMAP
,
174 ioremap_bot
, IOREMAP_END
,
179 area
->phys_addr
= paligned
;
180 ret
= __ioremap_at(paligned
, area
->addr
, size
, prot
);
184 ret
= __ioremap_at(paligned
, (void *)ioremap_bot
, size
, prot
);
190 ret
+= addr
& ~PAGE_MASK
;
194 void __iomem
* __ioremap(phys_addr_t addr
, unsigned long size
,
197 return __ioremap_caller(addr
, size
, __pgprot(flags
), __builtin_return_address(0));
200 void __iomem
* ioremap(phys_addr_t addr
, unsigned long size
)
202 pgprot_t prot
= pgprot_noncached(PAGE_KERNEL
);
203 void *caller
= __builtin_return_address(0);
206 return ppc_md
.ioremap(addr
, size
, prot
, caller
);
207 return __ioremap_caller(addr
, size
, prot
, caller
);
210 void __iomem
* ioremap_wc(phys_addr_t addr
, unsigned long size
)
212 pgprot_t prot
= pgprot_noncached_wc(PAGE_KERNEL
);
213 void *caller
= __builtin_return_address(0);
216 return ppc_md
.ioremap(addr
, size
, prot
, caller
);
217 return __ioremap_caller(addr
, size
, prot
, caller
);
220 void __iomem
*ioremap_coherent(phys_addr_t addr
, unsigned long size
)
222 pgprot_t prot
= pgprot_cached(PAGE_KERNEL
);
223 void *caller
= __builtin_return_address(0);
226 return ppc_md
.ioremap(addr
, size
, prot
, caller
);
227 return __ioremap_caller(addr
, size
, prot
, caller
);
230 void __iomem
* ioremap_prot(phys_addr_t addr
, unsigned long size
,
233 pte_t pte
= __pte(flags
);
234 void *caller
= __builtin_return_address(0);
236 /* writeable implies dirty for kernel addresses */
238 pte
= pte_mkdirty(pte
);
240 /* we don't want to let _PAGE_EXEC leak out */
241 pte
= pte_exprotect(pte
);
243 * Force kernel mapping.
245 pte
= pte_mkprivileged(pte
);
248 return ppc_md
.ioremap(addr
, size
, pte_pgprot(pte
), caller
);
249 return __ioremap_caller(addr
, size
, pte_pgprot(pte
), caller
);
254 * Unmap an IO region and remove it from imalloc'd list.
255 * Access to IO memory should be serialized by driver.
257 void __iounmap(volatile void __iomem
*token
)
261 if (!slab_is_available())
264 addr
= (void *) ((unsigned long __force
)
265 PCI_FIX_ADDR(token
) & PAGE_MASK
);
266 if ((unsigned long)addr
< ioremap_bot
) {
267 printk(KERN_WARNING
"Attempt to iounmap early bolted mapping"
274 void iounmap(volatile void __iomem
*token
)
277 ppc_md
.iounmap(token
);
282 EXPORT_SYMBOL(ioremap
);
283 EXPORT_SYMBOL(ioremap_wc
);
284 EXPORT_SYMBOL(ioremap_prot
);
285 EXPORT_SYMBOL(__ioremap
);
286 EXPORT_SYMBOL(__ioremap_at
);
287 EXPORT_SYMBOL(iounmap
);
288 EXPORT_SYMBOL(__iounmap
);
289 EXPORT_SYMBOL(__iounmap_at
);
291 #ifndef __PAGETABLE_PUD_FOLDED
292 /* 4 level page table */
293 struct page
*pgd_page(pgd_t pgd
)
296 return pte_page(pgd_pte(pgd
));
297 return virt_to_page(pgd_page_vaddr(pgd
));
301 struct page
*pud_page(pud_t pud
)
304 return pte_page(pud_pte(pud
));
305 return virt_to_page(pud_page_vaddr(pud
));
309 * For hugepage we have pfn in the pmd, we use PTE_RPN_SHIFT bits for flags
310 * For PTE page, we have a PTE_FRAG_SIZE (4K) aligned virtual address.
312 struct page
*pmd_page(pmd_t pmd
)
314 if (pmd_large(pmd
) || pmd_huge(pmd
) || pmd_devmap(pmd
))
315 return pte_page(pmd_pte(pmd
));
316 return virt_to_page(pmd_page_vaddr(pmd
));
319 #ifdef CONFIG_STRICT_KERNEL_RWX
320 void mark_rodata_ro(void)
322 if (!mmu_has_feature(MMU_FTR_KERNEL_RO
)) {
323 pr_warn("Warning: Unable to mark rodata read only on this CPU.\n");
328 radix__mark_rodata_ro();
330 hash__mark_rodata_ro();
333 void mark_initmem_nx(void)
336 radix__mark_initmem_nx();
338 hash__mark_initmem_nx();