2 * arch/sh/mm/ioremap_64.c
4 * Copyright (C) 2000, 2001 Paolo Alberelli
5 * Copyright (C) 2003 - 2007 Paul Mundt
7 * Mostly derived from arch/sh/mm/ioremap.c which, in turn is mostly
8 * derived from arch/i386/mm/ioremap.c .
10 * (C) Copyright 1995 1996 Linus Torvalds
12 * This file is subject to the terms and conditions of the GNU General Public
13 * License. See the file "COPYING" in the main directory of this archive
16 #include <linux/vmalloc.h>
17 #include <linux/ioport.h>
18 #include <linux/module.h>
21 #include <linux/bootmem.h>
22 #include <linux/proc_fs.h>
23 #include <linux/slab.h>
25 #include <asm/pgalloc.h>
26 #include <asm/addrspace.h>
27 #include <asm/cacheflush.h>
28 #include <asm/tlbflush.h>
31 static struct resource shmedia_iomap = {
32 .name = "shmedia_iomap",
33 .start = IOBASE_VADDR + PAGE_SIZE,
34 .end = IOBASE_END - 1,
37 static void shmedia_mapioaddr(unsigned long pa, unsigned long va,
39 static void shmedia_unmapioaddr(unsigned long vaddr);
40 static void __iomem *shmedia_ioremap(struct resource *res, u32 pa,
41 int sz, unsigned long flags);
44 * We have the same problem as the SPARC, so lets have the same comment:
45 * Our mini-allocator...
46 * Boy this is gross! We need it because we must map I/O for
47 * timers and interrupt controller before the kmalloc is available.
54 struct resource xres; /* Must be first */
55 int xflag; /* 1 == used */
59 static struct xresource xresv[XNRES];
61 static struct xresource *xres_alloc(void)
63 struct xresource *xrp;
67 for (n = 0; n < XNRES; n++) {
68 if (xrp->xflag == 0) {
77 static void xres_free(struct xresource *xrp)
82 static struct resource *shmedia_find_resource(struct resource *root,
87 for (res = root->child; res; res = res->sibling)
88 if (res->start <= vaddr && res->end >= vaddr)
94 static void __iomem *shmedia_alloc_io(unsigned long phys, unsigned long size,
95 const char *name, unsigned long flags)
97 struct xresource *xres;
110 printk_once(KERN_NOTICE "%s: done with statics, "
111 "switching to kmalloc\n", __func__);
113 tack = kmalloc(sizeof(struct resource) + tlen + 1, GFP_KERNEL);
116 memset(tack, 0, sizeof(struct resource));
117 res = (struct resource *) tack;
118 tack += sizeof(struct resource);
121 strncpy(tack, name, XNMLN);
125 return shmedia_ioremap(res, phys, size, flags);
128 static void __iomem *shmedia_ioremap(struct resource *res, u32 pa, int sz,
131 unsigned long offset = ((unsigned long) pa) & (~PAGE_MASK);
132 unsigned long round_sz = (offset + sz + PAGE_SIZE-1) & PAGE_MASK;
136 if (allocate_resource(&shmedia_iomap, res, round_sz,
137 shmedia_iomap.start, shmedia_iomap.end,
138 PAGE_SIZE, NULL, NULL) != 0) {
139 panic("alloc_io_res(%s): cannot occupy\n",
140 (res->name != NULL) ? res->name : "???");
146 psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
148 for (psz = res->end - res->start + 1; psz != 0; psz -= PAGE_SIZE) {
149 shmedia_mapioaddr(pa, va, flags);
154 return (void __iomem *)(unsigned long)(res->start + offset);
157 static void shmedia_free_io(struct resource *res)
159 unsigned long len = res->end - res->start + 1;
161 BUG_ON((len & (PAGE_SIZE - 1)) != 0);
165 shmedia_unmapioaddr(res->start + len);
168 release_resource(res);
171 static __init_refok void *sh64_get_page(void)
175 if (slab_is_available())
176 page = (void *)get_zeroed_page(GFP_KERNEL);
178 page = alloc_bootmem_pages(PAGE_SIZE);
180 if (!page || ((unsigned long)page & ~PAGE_MASK))
181 panic("sh64_get_page: Out of memory already?\n");
186 static void shmedia_mapioaddr(unsigned long pa, unsigned long va,
195 pr_debug("shmedia_mapiopage pa %08lx va %08lx\n", pa, va);
198 flags = 1; /* 1 = CB0-1 device */
200 pgdp = pgd_offset_k(va);
201 if (pgd_none(*pgdp) || !pgd_present(*pgdp)) {
202 pudp = (pud_t *)sh64_get_page();
203 set_pgd(pgdp, __pgd((unsigned long)pudp | _KERNPG_TABLE));
206 pudp = pud_offset(pgdp, va);
207 if (pud_none(*pudp) || !pud_present(*pudp)) {
208 pmdp = (pmd_t *)sh64_get_page();
209 set_pud(pudp, __pud((unsigned long)pmdp | _KERNPG_TABLE));
212 pmdp = pmd_offset(pudp, va);
213 if (pmd_none(*pmdp) || !pmd_present(*pmdp)) {
214 ptep = (pte_t *)sh64_get_page();
215 set_pmd(pmdp, __pmd((unsigned long)ptep + _PAGE_TABLE));
218 prot = __pgprot(_PAGE_PRESENT | _PAGE_READ | _PAGE_WRITE |
219 _PAGE_DIRTY | _PAGE_ACCESSED | _PAGE_SHARED | flags);
221 pte = pfn_pte(pa >> PAGE_SHIFT, prot);
222 ptep = pte_offset_kernel(pmdp, va);
224 if (!pte_none(*ptep) &&
225 pte_val(*ptep) != pte_val(pte))
230 flush_tlb_kernel_range(va, PAGE_SIZE);
233 static void shmedia_unmapioaddr(unsigned long vaddr)
240 pgdp = pgd_offset_k(vaddr);
241 if (pgd_none(*pgdp) || pgd_bad(*pgdp))
244 pudp = pud_offset(pgdp, vaddr);
245 if (pud_none(*pudp) || pud_bad(*pudp))
248 pmdp = pmd_offset(pudp, vaddr);
249 if (pmd_none(*pmdp) || pmd_bad(*pmdp))
252 ptep = pte_offset_kernel(pmdp, vaddr);
254 if (pte_none(*ptep) || !pte_present(*ptep))
257 clear_page((void *)ptep);
258 pte_clear(&init_mm, vaddr, ptep);
261 void __iomem *__ioremap(unsigned long offset, unsigned long size,
266 sprintf(name, "phys_%08x", (u32)offset);
267 return shmedia_alloc_io(offset, size, name, flags);
269 EXPORT_SYMBOL(__ioremap);
271 void __iounmap(void __iomem *virtual)
273 unsigned long vaddr = (unsigned long)virtual & PAGE_MASK;
274 struct resource *res;
277 res = shmedia_find_resource(&shmedia_iomap, vaddr);
279 printk(KERN_ERR "%s: Failed to free 0x%08lx\n",
284 psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
286 shmedia_free_io(res);
288 if ((char *)res >= (char *)xresv &&
289 (char *)res < (char *)&xresv[XNRES]) {
290 xres_free((struct xresource *)res);
295 EXPORT_SYMBOL(__iounmap);
298 ioremap_proc_info(char *buf, char **start, off_t fpos, int length, int *eof,
301 char *p = buf, *e = buf + length;
305 for (r = ((struct resource *)data)->child; r != NULL; r = r->sibling) {
306 if (p + 32 >= e) /* Better than nothing */
312 p += sprintf(p, "%08lx-%08lx: %s\n",
313 (unsigned long)r->start,
314 (unsigned long)r->end, nm);
320 static int __init register_proc_onchip(void)
322 create_proc_read_entry("io_map", 0, 0, ioremap_proc_info,
326 late_initcall(register_proc_onchip);