2 * This file contains the routines setting up the linux page tables.
4 * Copyright (C) 2008 Michal Simek
5 * Copyright (C) 2008 PetaLogix
7 * Copyright (C) 2007 Xilinx, Inc. All rights reserved.
9 * Derived from arch/ppc/mm/pgtable.c:
12 * Derived from arch/ppc/mm/init.c:
13 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
15 * Modifications by Paul Mackerras (PowerMac) (paulus@cs.anu.edu.au)
16 * and Cort Dougan (PReP) (cort@cs.nmt.edu)
17 * Copyright (C) 1996 Paul Mackerras
18 * Amiga/APUS changes by Jesper Skov (jskov@cygnus.co.uk).
20 * Derived from "arch/i386/mm/init.c"
21 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
23 * This file is subject to the terms and conditions of the GNU General
24 * Public License. See the file COPYING in the main directory of this
25 * archive for more details.
29 #include <linux/export.h>
30 #include <linux/kernel.h>
31 #include <linux/types.h>
32 #include <linux/vmalloc.h>
33 #include <linux/init.h>
34 #include <linux/mm_types.h>
35 #include <linux/pgtable.h>
37 #include <asm/pgalloc.h>
40 #include <asm/sections.h>
41 #include <asm/fixmap.h>
43 unsigned long ioremap_base
;
44 unsigned long ioremap_bot
;
45 EXPORT_SYMBOL(ioremap_bot
);
47 static void __iomem
*__ioremap(phys_addr_t addr
, unsigned long size
,
55 * Choose an address to map it to.
56 * Once the vmalloc system is running, we use it.
57 * Before then, we use space going down from ioremap_base
58 * (ioremap_bot records where we're up to).
61 size
= PAGE_ALIGN(addr
+ size
) - p
;
64 * Don't allow anybody to remap normal RAM that we're using.
65 * mem_init() sets high_memory so only do the check after that.
67 * However, allow remap of rootfs: TBD
71 p
>= memory_start
&& p
< virt_to_phys(high_memory
) &&
72 !(p
>= __virt_to_phys((phys_addr_t
)__bss_stop
) &&
73 p
< __virt_to_phys((phys_addr_t
)__bss_stop
))) {
74 pr_warn("__ioremap(): phys addr "PTE_FMT
" is RAM lr %ps\n",
75 (unsigned long)p
, __builtin_return_address(0));
83 * Is it already mapped? If the whole area is mapped then we're
84 * done, otherwise remap it since we want to keep the virt addrs for
85 * each request contiguous.
87 * We make the assumption here that if the bottom and top
88 * of the range we want are mapped then it's mapped to the
89 * same virt address (and this is contiguous).
94 struct vm_struct
*area
;
95 area
= get_vm_area(size
, VM_IOREMAP
);
98 v
= (unsigned long) area
->addr
;
100 v
= (ioremap_bot
-= size
);
103 if ((flags
& _PAGE_PRESENT
) == 0)
104 flags
|= _PAGE_KERNEL
;
105 if (flags
& _PAGE_NO_CACHE
)
106 flags
|= _PAGE_GUARDED
;
109 for (i
= 0; i
< size
&& err
== 0; i
+= PAGE_SIZE
)
110 err
= map_page(v
+ i
, p
+ i
, flags
);
117 return (void __iomem
*) (v
+ ((unsigned long)addr
& ~PAGE_MASK
));
120 void __iomem
*ioremap(phys_addr_t addr
, unsigned long size
)
122 return __ioremap(addr
, size
, _PAGE_NO_CACHE
);
124 EXPORT_SYMBOL(ioremap
);
126 void iounmap(volatile void __iomem
*addr
)
128 if ((__force
void *)addr
> high_memory
&&
129 (unsigned long) addr
< ioremap_bot
)
130 vfree((void *) (PAGE_MASK
& (unsigned long) addr
));
132 EXPORT_SYMBOL(iounmap
);
135 int map_page(unsigned long va
, phys_addr_t pa
, int flags
)
143 /* Use upper 10 bits of VA to index the first level map */
144 p4d
= p4d_offset(pgd_offset_k(va
), va
);
145 pud
= pud_offset(p4d
, va
);
146 pd
= pmd_offset(pud
, va
);
147 /* Use middle 10 bits of VA to index the second-level map */
148 pg
= pte_alloc_kernel(pd
, va
); /* from powerpc - pgtable.c */
149 /* pg = pte_alloc_kernel(&init_mm, pd, va); */
153 set_pte_at(&init_mm
, va
, pg
, pfn_pte(pa
>> PAGE_SHIFT
,
155 if (unlikely(mem_init_done
))
162 * Map in all of physical memory starting at CONFIG_KERNEL_START.
164 void __init
mapin_ram(void)
166 unsigned long v
, p
, s
, f
;
168 v
= CONFIG_KERNEL_START
;
170 for (s
= 0; s
< lowmem_size
; s
+= PAGE_SIZE
) {
171 f
= _PAGE_PRESENT
| _PAGE_ACCESSED
|
172 _PAGE_SHARED
| _PAGE_HWEXEC
;
173 if ((char *) v
< _stext
|| (char *) v
>= _etext
)
176 /* On the MicroBlaze, no user access
177 forces R/W kernel access */
185 /* is x a power of 2? */
186 #define is_power_of_2(x) ((x) != 0 && (((x) & ((x) - 1)) == 0))
188 /* Scan the real Linux page tables and return a PTE pointer for
189 * a virtual address in a context.
190 * Returns true (1) if PTE was found, zero otherwise. The pointer to
191 * the PTE pointer is unmodified if PTE is not found.
193 static int get_pteptr(struct mm_struct
*mm
, unsigned long addr
, pte_t
**ptep
)
202 pgd
= pgd_offset(mm
, addr
& PAGE_MASK
);
204 p4d
= p4d_offset(pgd
, addr
& PAGE_MASK
);
205 pud
= pud_offset(p4d
, addr
& PAGE_MASK
);
206 pmd
= pmd_offset(pud
, addr
& PAGE_MASK
);
207 if (pmd_present(*pmd
)) {
208 pte
= pte_offset_kernel(pmd
, addr
& PAGE_MASK
);
218 /* Find physical address for this virtual address. Normally used by
219 * I/O functions, but anyone can call it.
221 unsigned long iopa(unsigned long addr
)
226 struct mm_struct
*mm
;
228 /* Allow mapping of user addresses (within the thread)
229 * for DMA if necessary.
231 if (addr
< TASK_SIZE
)
237 if (get_pteptr(mm
, addr
, &pte
))
238 pa
= (pte_val(*pte
) & PAGE_MASK
) | (addr
& ~PAGE_MASK
);
243 __ref pte_t
*pte_alloc_one_kernel(struct mm_struct
*mm
)
247 pte
= (pte_t
*)__get_free_page(GFP_KERNEL
| __GFP_ZERO
);
249 pte
= (pte_t
*)early_get_page();
256 void __set_fixmap(enum fixed_addresses idx
, phys_addr_t phys
, pgprot_t flags
)
258 unsigned long address
= __fix_to_virt(idx
);
260 if (idx
>= __end_of_fixed_addresses
)
263 map_page(address
, phys
, pgprot_val(flags
));