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
10 * Amiga/APUS changes by Jesper Skov (jskov@cygnus.co.uk).
12 * Derived from "arch/i386/mm/init.c"
13 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
15 * Dave Engebretsen <engebret@us.ibm.com>
16 * Rework for PPC64 port.
18 * This program is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU General Public License
20 * as published by the Free Software Foundation; either version
21 * 2 of the License, or (at your option) any later version.
25 #include <linux/config.h>
26 #include <linux/signal.h>
27 #include <linux/sched.h>
28 #include <linux/kernel.h>
29 #include <linux/errno.h>
30 #include <linux/string.h>
31 #include <linux/types.h>
32 #include <linux/mman.h>
34 #include <linux/swap.h>
35 #include <linux/stddef.h>
36 #include <linux/vmalloc.h>
37 #include <linux/init.h>
38 #include <linux/delay.h>
39 #include <linux/bootmem.h>
40 #include <linux/highmem.h>
41 #include <linux/idr.h>
42 #include <linux/nodemask.h>
43 #include <linux/module.h>
45 #include <asm/pgalloc.h>
51 #include <asm/mmu_context.h>
52 #include <asm/pgtable.h>
54 #include <asm/uaccess.h>
56 #include <asm/machdep.h>
59 #include <asm/processor.h>
60 #include <asm/mmzone.h>
61 #include <asm/cputable.h>
62 #include <asm/ppcdebug.h>
63 #include <asm/sections.h>
64 #include <asm/system.h>
65 #include <asm/iommu.h>
66 #include <asm/abs_addr.h>
68 #include <asm/imalloc.h>
70 unsigned long ioremap_bot
= IMALLOC_BASE
;
71 static unsigned long phbs_io_bot
= PHBS_IO_BASE
;
73 #ifdef CONFIG_PPC_ISERIES
75 void __iomem
*ioremap(unsigned long addr
, unsigned long size
)
77 return (void __iomem
*)addr
;
80 extern void __iomem
*__ioremap(unsigned long addr
, unsigned long size
,
83 return (void __iomem
*)addr
;
86 void iounmap(volatile void __iomem
*addr
)
94 * map_io_page currently only called by __ioremap
95 * map_io_page adds an entry to the ioremap page table
96 * and adds an entry to the HPT, possibly bolting it
98 static int map_io_page(unsigned long ea
, unsigned long pa
, int flags
)
106 pgdp
= pgd_offset_k(ea
);
107 pudp
= pud_alloc(&init_mm
, pgdp
, ea
);
110 pmdp
= pmd_alloc(&init_mm
, pudp
, ea
);
113 ptep
= pte_alloc_kernel(pmdp
, ea
);
116 set_pte_at(&init_mm
, ea
, ptep
, pfn_pte(pa
>> PAGE_SHIFT
,
120 * If the mm subsystem is not fully up, we cannot create a
121 * linux page table entry for this mapping. Simply bolt an
122 * entry in the hardware page table.
125 if (htab_bolt_mapping(ea
, ea
+ PAGE_SIZE
, pa
, flags
,
127 panic("Can't map bolted IO mapping");
133 static void __iomem
* __ioremap_com(unsigned long addr
, unsigned long pa
,
134 unsigned long ea
, unsigned long size
,
139 if ((flags
& _PAGE_PRESENT
) == 0)
140 flags
|= pgprot_val(PAGE_KERNEL
);
142 for (i
= 0; i
< size
; i
+= PAGE_SIZE
)
143 if (map_io_page(ea
+i
, pa
+i
, flags
))
146 return (void __iomem
*) (ea
+ (addr
& ~PAGE_MASK
));
151 ioremap(unsigned long addr
, unsigned long size
)
153 return __ioremap(addr
, size
, _PAGE_NO_CACHE
| _PAGE_GUARDED
);
156 void __iomem
* __ioremap(unsigned long addr
, unsigned long size
,
159 unsigned long pa
, ea
;
163 * Choose an address to map it to.
164 * Once the imalloc system is running, we use it.
165 * Before that, we map using addresses going
166 * up from ioremap_bot. imalloc will use
167 * the addresses from ioremap_bot through
171 pa
= addr
& PAGE_MASK
;
172 size
= PAGE_ALIGN(addr
+ size
) - pa
;
178 struct vm_struct
*area
;
179 area
= im_get_free_area(size
);
182 ea
= (unsigned long)(area
->addr
);
183 ret
= __ioremap_com(addr
, pa
, ea
, size
, flags
);
188 ret
= __ioremap_com(addr
, pa
, ea
, size
, flags
);
195 #define IS_PAGE_ALIGNED(_val) ((_val) == ((_val) & PAGE_MASK))
197 int __ioremap_explicit(unsigned long pa
, unsigned long ea
,
198 unsigned long size
, unsigned long flags
)
200 struct vm_struct
*area
;
203 /* For now, require page-aligned values for pa, ea, and size */
204 if (!IS_PAGE_ALIGNED(pa
) || !IS_PAGE_ALIGNED(ea
) ||
205 !IS_PAGE_ALIGNED(size
)) {
206 printk(KERN_ERR
"unaligned value in %s\n", __FUNCTION__
);
210 if (!mem_init_done
) {
211 /* Two things to consider in this case:
212 * 1) No records will be kept (imalloc, etc) that the region
214 * 2) It won't be easy to iounmap() the region later (because
219 area
= im_get_area(ea
, size
,
220 IM_REGION_UNUSED
|IM_REGION_SUBSET
|IM_REGION_EXISTS
);
222 /* Expected when PHB-dlpar is in play */
225 if (ea
!= (unsigned long) area
->addr
) {
226 printk(KERN_ERR
"unexpected addr return from "
232 ret
= __ioremap_com(pa
, pa
, ea
, size
, flags
);
234 printk(KERN_ERR
"ioremap_explicit() allocation failure !\n");
237 if (ret
!= (void *) ea
) {
238 printk(KERN_ERR
"__ioremap_com() returned unexpected addr\n");
246 * Unmap an IO region and remove it from imalloc'd list.
247 * Access to IO memory should be serialized by driver.
248 * This code is modeled after vmalloc code - unmap_vm_area()
250 * XXX what about calls before mem_init_done (ie python_countermeasures())
252 void iounmap(volatile void __iomem
*token
)
259 addr
= (void *) ((unsigned long __force
) token
& PAGE_MASK
);
264 static int iounmap_subset_regions(unsigned long addr
, unsigned long size
)
266 struct vm_struct
*area
;
268 /* Check whether subsets of this region exist */
269 area
= im_get_area(addr
, size
, IM_REGION_SUPERSET
);
274 iounmap((void __iomem
*) area
->addr
);
275 area
= im_get_area(addr
, size
,
282 int iounmap_explicit(volatile void __iomem
*start
, unsigned long size
)
284 struct vm_struct
*area
;
288 addr
= (unsigned long __force
) start
& PAGE_MASK
;
290 /* Verify that the region either exists or is a subset of an existing
291 * region. In the latter case, split the parent region to create
294 area
= im_get_area(addr
, size
,
295 IM_REGION_EXISTS
| IM_REGION_SUBSET
);
297 /* Determine whether subset regions exist. If so, unmap */
298 rc
= iounmap_subset_regions(addr
, size
);
301 "%s() cannot unmap nonexistent range 0x%lx\n",
306 iounmap((void __iomem
*) area
->addr
);
309 * FIXME! This can't be right:
311 * Maybe it should be "iounmap(area);"
318 EXPORT_SYMBOL(ioremap
);
319 EXPORT_SYMBOL(__ioremap
);
320 EXPORT_SYMBOL(iounmap
);
322 void __iomem
* reserve_phb_iospace(unsigned long size
)
324 void __iomem
*virt_addr
;
326 if (phbs_io_bot
>= IMALLOC_BASE
)
327 panic("reserve_phb_iospace(): phb io space overflow\n");
329 virt_addr
= (void __iomem
*) phbs_io_bot
;