Merge branch 'drm-intel-next' of git://git.kernel.org/pub/scm/linux/kernel/git/anholt...
[linux-2.6] / arch / powerpc / mm / pgtable_64.c
1 /*
2  *  This file contains ioremap and related functions for 64-bit machines.
3  *
4  *  Derived from arch/ppc64/mm/init.c
5  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
6  *
7  *  Modifications by Paul Mackerras (PowerMac) (paulus@samba.org)
8  *  and Cort Dougan (PReP) (cort@cs.nmt.edu)
9  *    Copyright (C) 1996 Paul Mackerras
10  *
11  *  Derived from "arch/i386/mm/init.c"
12  *    Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
13  *
14  *  Dave Engebretsen <engebret@us.ibm.com>
15  *      Rework for PPC64 port.
16  *
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.
21  *
22  */
23
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/types.h>
30 #include <linux/mman.h>
31 #include <linux/mm.h>
32 #include <linux/swap.h>
33 #include <linux/stddef.h>
34 #include <linux/vmalloc.h>
35 #include <linux/init.h>
36
37 #include <asm/pgalloc.h>
38 #include <asm/page.h>
39 #include <asm/prom.h>
40 #include <asm/io.h>
41 #include <asm/mmu_context.h>
42 #include <asm/pgtable.h>
43 #include <asm/mmu.h>
44 #include <asm/smp.h>
45 #include <asm/machdep.h>
46 #include <asm/tlb.h>
47 #include <asm/processor.h>
48 #include <asm/cputable.h>
49 #include <asm/sections.h>
50 #include <asm/system.h>
51 #include <asm/abs_addr.h>
52 #include <asm/firmware.h>
53
54 #include "mmu_decl.h"
55
56 unsigned long ioremap_bot = IOREMAP_BASE;
57
58 /*
59  * map_io_page currently only called by __ioremap
60  * map_io_page adds an entry to the ioremap page table
61  * and adds an entry to the HPT, possibly bolting it
62  */
63 static int map_io_page(unsigned long ea, unsigned long pa, int flags)
64 {
65         pgd_t *pgdp;
66         pud_t *pudp;
67         pmd_t *pmdp;
68         pte_t *ptep;
69
70         if (mem_init_done) {
71                 pgdp = pgd_offset_k(ea);
72                 pudp = pud_alloc(&init_mm, pgdp, ea);
73                 if (!pudp)
74                         return -ENOMEM;
75                 pmdp = pmd_alloc(&init_mm, pudp, ea);
76                 if (!pmdp)
77                         return -ENOMEM;
78                 ptep = pte_alloc_kernel(pmdp, ea);
79                 if (!ptep)
80                         return -ENOMEM;
81                 set_pte_at(&init_mm, ea, ptep, pfn_pte(pa >> PAGE_SHIFT,
82                                                           __pgprot(flags)));
83         } else {
84                 /*
85                  * If the mm subsystem is not fully up, we cannot create a
86                  * linux page table entry for this mapping.  Simply bolt an
87                  * entry in the hardware page table.
88                  *
89                  */
90                 if (htab_bolt_mapping(ea, ea + PAGE_SIZE, pa, flags,
91                                       mmu_io_psize, mmu_kernel_ssize)) {
92                         printk(KERN_ERR "Failed to do bolted mapping IO "
93                                "memory at %016lx !\n", pa);
94                         return -ENOMEM;
95                 }
96         }
97         return 0;
98 }
99
100
101 /**
102  * __ioremap_at - Low level function to establish the page tables
103  *                for an IO mapping
104  */
105 void __iomem * __ioremap_at(phys_addr_t pa, void *ea, unsigned long size,
106                             unsigned long flags)
107 {
108         unsigned long i;
109
110         /* Make sure we have the base flags */
111         if ((flags & _PAGE_PRESENT) == 0)
112                 flags |= pgprot_val(PAGE_KERNEL);
113
114         /* Non-cacheable page cannot be coherent */
115         if (flags & _PAGE_NO_CACHE)
116                 flags &= ~_PAGE_COHERENT;
117
118         /* We don't support the 4K PFN hack with ioremap */
119         if (flags & _PAGE_4K_PFN)
120                 return NULL;
121
122         WARN_ON(pa & ~PAGE_MASK);
123         WARN_ON(((unsigned long)ea) & ~PAGE_MASK);
124         WARN_ON(size & ~PAGE_MASK);
125
126         for (i = 0; i < size; i += PAGE_SIZE)
127                 if (map_io_page((unsigned long)ea+i, pa+i, flags))
128                         return NULL;
129
130         return (void __iomem *)ea;
131 }
132
133 /**
134  * __iounmap_from - Low level function to tear down the page tables
135  *                  for an IO mapping. This is used for mappings that
136  *                  are manipulated manually, like partial unmapping of
137  *                  PCI IOs or ISA space.
138  */
139 void __iounmap_at(void *ea, unsigned long size)
140 {
141         WARN_ON(((unsigned long)ea) & ~PAGE_MASK);
142         WARN_ON(size & ~PAGE_MASK);
143
144         unmap_kernel_range((unsigned long)ea, size);
145 }
146
147 void __iomem * __ioremap_caller(phys_addr_t addr, unsigned long size,
148                                 unsigned long flags, void *caller)
149 {
150         phys_addr_t paligned;
151         void __iomem *ret;
152
153         /*
154          * Choose an address to map it to.
155          * Once the imalloc system is running, we use it.
156          * Before that, we map using addresses going
157          * up from ioremap_bot.  imalloc will use
158          * the addresses from ioremap_bot through
159          * IMALLOC_END
160          * 
161          */
162         paligned = addr & PAGE_MASK;
163         size = PAGE_ALIGN(addr + size) - paligned;
164
165         if ((size == 0) || (paligned == 0))
166                 return NULL;
167
168         if (mem_init_done) {
169                 struct vm_struct *area;
170
171                 area = __get_vm_area_caller(size, VM_IOREMAP,
172                                             ioremap_bot, IOREMAP_END,
173                                             caller);
174                 if (area == NULL)
175                         return NULL;
176                 ret = __ioremap_at(paligned, area->addr, size, flags);
177                 if (!ret)
178                         vunmap(area->addr);
179         } else {
180                 ret = __ioremap_at(paligned, (void *)ioremap_bot, size, flags);
181                 if (ret)
182                         ioremap_bot += size;
183         }
184
185         if (ret)
186                 ret += addr & ~PAGE_MASK;
187         return ret;
188 }
189
190 void __iomem * __ioremap(phys_addr_t addr, unsigned long size,
191                          unsigned long flags)
192 {
193         return __ioremap_caller(addr, size, flags, __builtin_return_address(0));
194 }
195
196 void __iomem * ioremap(phys_addr_t addr, unsigned long size)
197 {
198         unsigned long flags = _PAGE_NO_CACHE | _PAGE_GUARDED;
199         void *caller = __builtin_return_address(0);
200
201         if (ppc_md.ioremap)
202                 return ppc_md.ioremap(addr, size, flags, caller);
203         return __ioremap_caller(addr, size, flags, caller);
204 }
205
206 void __iomem * ioremap_flags(phys_addr_t addr, unsigned long size,
207                              unsigned long flags)
208 {
209         void *caller = __builtin_return_address(0);
210
211         /* writeable implies dirty for kernel addresses */
212         if (flags & _PAGE_RW)
213                 flags |= _PAGE_DIRTY;
214
215         /* we don't want to let _PAGE_USER and _PAGE_EXEC leak out */
216         flags &= ~(_PAGE_USER | _PAGE_EXEC);
217
218         if (ppc_md.ioremap)
219                 return ppc_md.ioremap(addr, size, flags, caller);
220         return __ioremap_caller(addr, size, flags, caller);
221 }
222
223
224 /*  
225  * Unmap an IO region and remove it from imalloc'd list.
226  * Access to IO memory should be serialized by driver.
227  */
228 void __iounmap(volatile void __iomem *token)
229 {
230         void *addr;
231
232         if (!mem_init_done)
233                 return;
234         
235         addr = (void *) ((unsigned long __force)
236                          PCI_FIX_ADDR(token) & PAGE_MASK);
237         if ((unsigned long)addr < ioremap_bot) {
238                 printk(KERN_WARNING "Attempt to iounmap early bolted mapping"
239                        " at 0x%p\n", addr);
240                 return;
241         }
242         vunmap(addr);
243 }
244
245 void iounmap(volatile void __iomem *token)
246 {
247         if (ppc_md.iounmap)
248                 ppc_md.iounmap(token);
249         else
250                 __iounmap(token);
251 }
252
253 EXPORT_SYMBOL(ioremap);
254 EXPORT_SYMBOL(ioremap_flags);
255 EXPORT_SYMBOL(__ioremap);
256 EXPORT_SYMBOL(__ioremap_at);
257 EXPORT_SYMBOL(iounmap);
258 EXPORT_SYMBOL(__iounmap);
259 EXPORT_SYMBOL(__iounmap_at);