sh: Split out ioremap in to _32 and _64 variants.
authorPaul Mundt <lethal@linux-sh.org>
Sun, 11 Nov 2007 09:43:33 +0000 (18:43 +0900)
committerPaul Mundt <lethal@linux-sh.org>
Mon, 28 Jan 2008 04:18:46 +0000 (13:18 +0900)
Signed-off-by: Paul Mundt <lethal@linux-sh.org>
arch/sh/mm/Makefile_32
arch/sh/mm/Makefile_64
arch/sh/mm/ioremap.c [deleted file]
arch/sh/mm/ioremap_32.c [new file with mode: 0644]
arch/sh/mm/ioremap_64.c [new file with mode: 0644]
arch/sh64/mm/ioremap.c [deleted file]

index cc68b265c025dd9e68def2d3d430016193561de8..b43884269c2a6f53052833e3ed45ce912a54fdf2 100644 (file)
@@ -13,7 +13,7 @@ endif
 
 mmu-y                  := tlb-nommu.o pg-nommu.o
 mmu-$(CONFIG_MMU)      := fault.o clear_page.o copy_page.o tlb-flush.o \
-                          ioremap.o
+                          ioremap_32.o
 
 obj-y                  += $(mmu-y)
 
index de964a1500f499c4d15f97104822211eea5ccc0f..177f92863e4e134e880a7db4e3ecc5b6122b6a6d 100644 (file)
@@ -4,6 +4,11 @@
 
 obj-y                  := init.o extable_64.o consistent.o
 
+mmu-y                  := tlb-nommu.o pg-nommu.o
+mmu-$(CONFIG_MMU)      := ioremap_64.o
+
+obj-y                  += $(mmu-y)
+
 obj-$(CONFIG_HUGETLB_PAGE)     += hugetlbpage.o
 obj-$(CONFIG_PMB)              += pmb.o
 obj-$(CONFIG_NUMA)             += numa.o
diff --git a/arch/sh/mm/ioremap.c b/arch/sh/mm/ioremap.c
deleted file mode 100644 (file)
index 0c7b7e3..0000000
+++ /dev/null
@@ -1,150 +0,0 @@
-/*
- * arch/sh/mm/ioremap.c
- *
- * Re-map IO memory to kernel address space so that we can access it.
- * This is needed for high PCI addresses that aren't mapped in the
- * 640k-1MB IO memory area on PC's
- *
- * (C) Copyright 1995 1996 Linus Torvalds
- * (C) Copyright 2005, 2006 Paul Mundt
- *
- * This file is subject to the terms and conditions of the GNU General
- * Public License. See the file "COPYING" in the main directory of this
- * archive for more details.
- */
-#include <linux/vmalloc.h>
-#include <linux/module.h>
-#include <linux/mm.h>
-#include <linux/pci.h>
-#include <linux/io.h>
-#include <asm/page.h>
-#include <asm/pgalloc.h>
-#include <asm/addrspace.h>
-#include <asm/cacheflush.h>
-#include <asm/tlbflush.h>
-#include <asm/mmu.h>
-
-/*
- * Remap an arbitrary physical address space into the kernel virtual
- * address space. Needed when the kernel wants to access high addresses
- * directly.
- *
- * NOTE! We need to allow non-page-aligned mappings too: we will obviously
- * have to convert them into an offset in a page-aligned mapping, but the
- * caller shouldn't need to know that small detail.
- */
-void __iomem *__ioremap(unsigned long phys_addr, unsigned long size,
-                       unsigned long flags)
-{
-       struct vm_struct * area;
-       unsigned long offset, last_addr, addr, orig_addr;
-       pgprot_t pgprot;
-
-       /* Don't allow wraparound or zero size */
-       last_addr = phys_addr + size - 1;
-       if (!size || last_addr < phys_addr)
-               return NULL;
-
-       /*
-        * If we're on an SH7751 or SH7780 PCI controller, PCI memory is
-        * mapped at the end of the address space (typically 0xfd000000)
-        * in a non-translatable area, so mapping through page tables for
-        * this area is not only pointless, but also fundamentally
-        * broken. Just return the physical address instead.
-        *
-        * For boards that map a small PCI memory aperture somewhere in
-        * P1/P2 space, ioremap() will already do the right thing,
-        * and we'll never get this far.
-        */
-       if (is_pci_memaddr(phys_addr) && is_pci_memaddr(last_addr))
-               return (void __iomem *)phys_addr;
-
-       /*
-        * Don't allow anybody to remap normal RAM that we're using..
-        */
-       if (phys_addr < virt_to_phys(high_memory))
-               return NULL;
-
-       /*
-        * Mappings have to be page-aligned
-        */
-       offset = phys_addr & ~PAGE_MASK;
-       phys_addr &= PAGE_MASK;
-       size = PAGE_ALIGN(last_addr+1) - phys_addr;
-
-       /*
-        * Ok, go for it..
-        */
-       area = get_vm_area(size, VM_IOREMAP);
-       if (!area)
-               return NULL;
-       area->phys_addr = phys_addr;
-       orig_addr = addr = (unsigned long)area->addr;
-
-#ifdef CONFIG_32BIT
-       /*
-        * First try to remap through the PMB once a valid VMA has been
-        * established. Smaller allocations (or the rest of the size
-        * remaining after a PMB mapping due to the size not being
-        * perfectly aligned on a PMB size boundary) are then mapped
-        * through the UTLB using conventional page tables.
-        *
-        * PMB entries are all pre-faulted.
-        */
-       if (unlikely(size >= 0x1000000)) {
-               unsigned long mapped = pmb_remap(addr, phys_addr, size, flags);
-
-               if (likely(mapped)) {
-                       addr            += mapped;
-                       phys_addr       += mapped;
-                       size            -= mapped;
-               }
-       }
-#endif
-
-       pgprot = __pgprot(pgprot_val(PAGE_KERNEL_NOCACHE) | flags);
-       if (likely(size))
-               if (ioremap_page_range(addr, addr + size, phys_addr, pgprot)) {
-                       vunmap((void *)orig_addr);
-                       return NULL;
-               }
-
-       return (void __iomem *)(offset + (char *)orig_addr);
-}
-EXPORT_SYMBOL(__ioremap);
-
-void __iounmap(void __iomem *addr)
-{
-       unsigned long vaddr = (unsigned long __force)addr;
-       struct vm_struct *p;
-
-       if (PXSEG(vaddr) < P3SEG || is_pci_memaddr(vaddr))
-               return;
-
-#ifdef CONFIG_32BIT
-       /*
-        * Purge any PMB entries that may have been established for this
-        * mapping, then proceed with conventional VMA teardown.
-        *
-        * XXX: Note that due to the way that remove_vm_area() does
-        * matching of the resultant VMA, we aren't able to fast-forward
-        * the address past the PMB space until the end of the VMA where
-        * the page tables reside. As such, unmap_vm_area() will be
-        * forced to linearly scan over the area until it finds the page
-        * tables where PTEs that need to be unmapped actually reside,
-        * which is far from optimal. Perhaps we need to use a separate
-        * VMA for the PMB mappings?
-        *                                      -- PFM.
-        */
-       pmb_unmap(vaddr);
-#endif
-
-       p = remove_vm_area((void *)(vaddr & PAGE_MASK));
-       if (!p) {
-               printk(KERN_ERR "%s: bad address %p\n", __FUNCTION__, addr);
-               return;
-       }
-
-       kfree(p);
-}
-EXPORT_SYMBOL(__iounmap);
diff --git a/arch/sh/mm/ioremap_32.c b/arch/sh/mm/ioremap_32.c
new file mode 100644 (file)
index 0000000..0c7b7e3
--- /dev/null
@@ -0,0 +1,150 @@
+/*
+ * arch/sh/mm/ioremap.c
+ *
+ * Re-map IO memory to kernel address space so that we can access it.
+ * This is needed for high PCI addresses that aren't mapped in the
+ * 640k-1MB IO memory area on PC's
+ *
+ * (C) Copyright 1995 1996 Linus Torvalds
+ * (C) Copyright 2005, 2006 Paul Mundt
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License. See the file "COPYING" in the main directory of this
+ * archive for more details.
+ */
+#include <linux/vmalloc.h>
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/pci.h>
+#include <linux/io.h>
+#include <asm/page.h>
+#include <asm/pgalloc.h>
+#include <asm/addrspace.h>
+#include <asm/cacheflush.h>
+#include <asm/tlbflush.h>
+#include <asm/mmu.h>
+
+/*
+ * Remap an arbitrary physical address space into the kernel virtual
+ * address space. Needed when the kernel wants to access high addresses
+ * directly.
+ *
+ * NOTE! We need to allow non-page-aligned mappings too: we will obviously
+ * have to convert them into an offset in a page-aligned mapping, but the
+ * caller shouldn't need to know that small detail.
+ */
+void __iomem *__ioremap(unsigned long phys_addr, unsigned long size,
+                       unsigned long flags)
+{
+       struct vm_struct * area;
+       unsigned long offset, last_addr, addr, orig_addr;
+       pgprot_t pgprot;
+
+       /* Don't allow wraparound or zero size */
+       last_addr = phys_addr + size - 1;
+       if (!size || last_addr < phys_addr)
+               return NULL;
+
+       /*
+        * If we're on an SH7751 or SH7780 PCI controller, PCI memory is
+        * mapped at the end of the address space (typically 0xfd000000)
+        * in a non-translatable area, so mapping through page tables for
+        * this area is not only pointless, but also fundamentally
+        * broken. Just return the physical address instead.
+        *
+        * For boards that map a small PCI memory aperture somewhere in
+        * P1/P2 space, ioremap() will already do the right thing,
+        * and we'll never get this far.
+        */
+       if (is_pci_memaddr(phys_addr) && is_pci_memaddr(last_addr))
+               return (void __iomem *)phys_addr;
+
+       /*
+        * Don't allow anybody to remap normal RAM that we're using..
+        */
+       if (phys_addr < virt_to_phys(high_memory))
+               return NULL;
+
+       /*
+        * Mappings have to be page-aligned
+        */
+       offset = phys_addr & ~PAGE_MASK;
+       phys_addr &= PAGE_MASK;
+       size = PAGE_ALIGN(last_addr+1) - phys_addr;
+
+       /*
+        * Ok, go for it..
+        */
+       area = get_vm_area(size, VM_IOREMAP);
+       if (!area)
+               return NULL;
+       area->phys_addr = phys_addr;
+       orig_addr = addr = (unsigned long)area->addr;
+
+#ifdef CONFIG_32BIT
+       /*
+        * First try to remap through the PMB once a valid VMA has been
+        * established. Smaller allocations (or the rest of the size
+        * remaining after a PMB mapping due to the size not being
+        * perfectly aligned on a PMB size boundary) are then mapped
+        * through the UTLB using conventional page tables.
+        *
+        * PMB entries are all pre-faulted.
+        */
+       if (unlikely(size >= 0x1000000)) {
+               unsigned long mapped = pmb_remap(addr, phys_addr, size, flags);
+
+               if (likely(mapped)) {
+                       addr            += mapped;
+                       phys_addr       += mapped;
+                       size            -= mapped;
+               }
+       }
+#endif
+
+       pgprot = __pgprot(pgprot_val(PAGE_KERNEL_NOCACHE) | flags);
+       if (likely(size))
+               if (ioremap_page_range(addr, addr + size, phys_addr, pgprot)) {
+                       vunmap((void *)orig_addr);
+                       return NULL;
+               }
+
+       return (void __iomem *)(offset + (char *)orig_addr);
+}
+EXPORT_SYMBOL(__ioremap);
+
+void __iounmap(void __iomem *addr)
+{
+       unsigned long vaddr = (unsigned long __force)addr;
+       struct vm_struct *p;
+
+       if (PXSEG(vaddr) < P3SEG || is_pci_memaddr(vaddr))
+               return;
+
+#ifdef CONFIG_32BIT
+       /*
+        * Purge any PMB entries that may have been established for this
+        * mapping, then proceed with conventional VMA teardown.
+        *
+        * XXX: Note that due to the way that remove_vm_area() does
+        * matching of the resultant VMA, we aren't able to fast-forward
+        * the address past the PMB space until the end of the VMA where
+        * the page tables reside. As such, unmap_vm_area() will be
+        * forced to linearly scan over the area until it finds the page
+        * tables where PTEs that need to be unmapped actually reside,
+        * which is far from optimal. Perhaps we need to use a separate
+        * VMA for the PMB mappings?
+        *                                      -- PFM.
+        */
+       pmb_unmap(vaddr);
+#endif
+
+       p = remove_vm_area((void *)(vaddr & PAGE_MASK));
+       if (!p) {
+               printk(KERN_ERR "%s: bad address %p\n", __FUNCTION__, addr);
+               return;
+       }
+
+       kfree(p);
+}
+EXPORT_SYMBOL(__iounmap);
diff --git a/arch/sh/mm/ioremap_64.c b/arch/sh/mm/ioremap_64.c
new file mode 100644 (file)
index 0000000..95c85e2
--- /dev/null
@@ -0,0 +1,387 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * arch/sh64/mm/ioremap.c
+ *
+ * Copyright (C) 2000, 2001  Paolo Alberelli
+ * Copyright (C) 2003, 2004  Paul Mundt
+ *
+ * Mostly derived from arch/sh/mm/ioremap.c which, in turn is mostly
+ * derived from arch/i386/mm/ioremap.c .
+ *
+ *   (C) Copyright 1995 1996 Linus Torvalds
+ */
+#include <linux/vmalloc.h>
+#include <linux/ioport.h>
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/io.h>
+#include <asm/page.h>
+#include <asm/pgalloc.h>
+#include <asm/addrspace.h>
+#include <asm/cacheflush.h>
+#include <asm/tlbflush.h>
+#include <asm/mmu.h>
+
+static void shmedia_mapioaddr(unsigned long, unsigned long);
+static unsigned long shmedia_ioremap(struct resource *, u32, int);
+
+/*
+ * Generic mapping function (not visible outside):
+ */
+
+/*
+ * Remap an arbitrary physical address space into the kernel virtual
+ * address space. Needed when the kernel wants to access high addresses
+ * directly.
+ *
+ * NOTE! We need to allow non-page-aligned mappings too: we will obviously
+ * have to convert them into an offset in a page-aligned mapping, but the
+ * caller shouldn't need to know that small detail.
+ */
+void * __ioremap(unsigned long phys_addr, unsigned long size, unsigned long flags)
+{
+       void * addr;
+       struct vm_struct * area;
+       unsigned long offset, last_addr;
+       pgprot_t pgprot;
+
+       /* Don't allow wraparound or zero size */
+       last_addr = phys_addr + size - 1;
+       if (!size || last_addr < phys_addr)
+               return NULL;
+
+       pgprot = __pgprot(_PAGE_PRESENT  | _PAGE_READ   |
+                         _PAGE_WRITE    | _PAGE_DIRTY  |
+                         _PAGE_ACCESSED | _PAGE_SHARED | flags);
+
+       /*
+        * Mappings have to be page-aligned
+        */
+       offset = phys_addr & ~PAGE_MASK;
+       phys_addr &= PAGE_MASK;
+       size = PAGE_ALIGN(last_addr + 1) - phys_addr;
+
+       /*
+        * Ok, go for it..
+        */
+       area = get_vm_area(size, VM_IOREMAP);
+       pr_debug("Get vm_area returns %p addr %p\n",area,area->addr);
+       if (!area)
+               return NULL;
+       area->phys_addr = phys_addr;
+       addr = area->addr;
+       if (ioremap_page_range((unsigned long)addr, (unsigned long)addr + size,
+                              phys_addr, pgprot)) {
+               vunmap(addr);
+               return NULL;
+       }
+       return (void *) (offset + (char *)addr);
+}
+EXPORT_SYMBOL(__ioremap);
+
+void iounmap(void *addr)
+{
+       struct vm_struct *area;
+
+       vfree((void *) (PAGE_MASK & (unsigned long) addr));
+       area = remove_vm_area((void *) (PAGE_MASK & (unsigned long) addr));
+       if (!area) {
+               printk(KERN_ERR "iounmap: bad address %p\n", addr);
+               return;
+       }
+
+       kfree(area);
+}
+EXPORT_SYMBOL(iounmap);
+
+static struct resource shmedia_iomap = {
+       .name   = "shmedia_iomap",
+       .start  = IOBASE_VADDR + PAGE_SIZE,
+       .end    = IOBASE_END - 1,
+};
+
+static void shmedia_mapioaddr(unsigned long pa, unsigned long va);
+static void shmedia_unmapioaddr(unsigned long vaddr);
+static unsigned long shmedia_ioremap(struct resource *res, u32 pa, int sz);
+
+/*
+ * We have the same problem as the SPARC, so lets have the same comment:
+ * Our mini-allocator...
+ * Boy this is gross! We need it because we must map I/O for
+ * timers and interrupt controller before the kmalloc is available.
+ */
+
+#define XNMLN  15
+#define XNRES  10
+
+struct xresource {
+       struct resource xres;   /* Must be first */
+       int xflag;              /* 1 == used */
+       char xname[XNMLN+1];
+};
+
+static struct xresource xresv[XNRES];
+
+static struct xresource *xres_alloc(void)
+{
+        struct xresource *xrp;
+        int n;
+
+        xrp = xresv;
+        for (n = 0; n < XNRES; n++) {
+                if (xrp->xflag == 0) {
+                        xrp->xflag = 1;
+                        return xrp;
+                }
+                xrp++;
+        }
+        return NULL;
+}
+
+static void xres_free(struct xresource *xrp)
+{
+       xrp->xflag = 0;
+}
+
+static struct resource *shmedia_find_resource(struct resource *root,
+                                             unsigned long vaddr)
+{
+       struct resource *res;
+
+       for (res = root->child; res; res = res->sibling)
+               if (res->start <= vaddr && res->end >= vaddr)
+                       return res;
+
+       return NULL;
+}
+
+static unsigned long shmedia_alloc_io(unsigned long phys, unsigned long size,
+                                     const char *name)
+{
+        static int printed_full = 0;
+        struct xresource *xres;
+        struct resource *res;
+        char *tack;
+        int tlen;
+
+        if (name == NULL) name = "???";
+
+        if ((xres = xres_alloc()) != 0) {
+                tack = xres->xname;
+                res = &xres->xres;
+        } else {
+                if (!printed_full) {
+                        printk("%s: done with statics, switching to kmalloc\n",
+                              __FUNCTION__);
+                        printed_full = 1;
+                }
+                tlen = strlen(name);
+                tack = kmalloc(sizeof (struct resource) + tlen + 1, GFP_KERNEL);
+                if (!tack)
+                       return -ENOMEM;
+                memset(tack, 0, sizeof(struct resource));
+                res = (struct resource *) tack;
+                tack += sizeof (struct resource);
+        }
+
+        strncpy(tack, name, XNMLN);
+        tack[XNMLN] = 0;
+        res->name = tack;
+
+        return shmedia_ioremap(res, phys, size);
+}
+
+static unsigned long shmedia_ioremap(struct resource *res, u32 pa, int sz)
+{
+        unsigned long offset = ((unsigned long) pa) & (~PAGE_MASK);
+       unsigned long round_sz = (offset + sz + PAGE_SIZE-1) & PAGE_MASK;
+        unsigned long va;
+        unsigned int psz;
+
+        if (allocate_resource(&shmedia_iomap, res, round_sz,
+                             shmedia_iomap.start, shmedia_iomap.end,
+                             PAGE_SIZE, NULL, NULL) != 0) {
+                panic("alloc_io_res(%s): cannot occupy\n",
+                    (res->name != NULL)? res->name: "???");
+        }
+
+        va = res->start;
+        pa &= PAGE_MASK;
+
+       psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
+
+       /* log at boot time ... */
+       printk("mapioaddr: %6s  [%2d page%s]  va 0x%08lx   pa 0x%08x\n",
+              ((res->name != NULL) ? res->name : "???"),
+              psz, psz == 1 ? " " : "s", va, pa);
+
+        for (psz = res->end - res->start + 1; psz != 0; psz -= PAGE_SIZE) {
+                shmedia_mapioaddr(pa, va);
+                va += PAGE_SIZE;
+                pa += PAGE_SIZE;
+        }
+
+        res->start += offset;
+        res->end = res->start + sz - 1;         /* not strictly necessary.. */
+
+        return res->start;
+}
+
+static void shmedia_free_io(struct resource *res)
+{
+       unsigned long len = res->end - res->start + 1;
+
+       BUG_ON((len & (PAGE_SIZE - 1)) != 0);
+
+       while (len) {
+               len -= PAGE_SIZE;
+               shmedia_unmapioaddr(res->start + len);
+       }
+
+       release_resource(res);
+}
+
+static __init_refok void *sh64_get_page(void)
+{
+       extern int after_bootmem;
+       void *page;
+
+       if (after_bootmem) {
+               page = (void *)get_zeroed_page(GFP_ATOMIC);
+       } else {
+               page = alloc_bootmem_pages(PAGE_SIZE);
+       }
+
+       if (!page || ((unsigned long)page & ~PAGE_MASK))
+               panic("sh64_get_page: Out of memory already?\n");
+
+       return page;
+}
+
+static void shmedia_mapioaddr(unsigned long pa, unsigned long va)
+{
+       pgd_t *pgdp;
+       pmd_t *pmdp;
+       pte_t *ptep, pte;
+       pgprot_t prot;
+       unsigned long flags = 1; /* 1 = CB0-1 device */
+
+       pr_debug("shmedia_mapiopage pa %08lx va %08lx\n",  pa, va);
+
+       pgdp = pgd_offset_k(va);
+       if (pgd_none(*pgdp) || !pgd_present(*pgdp)) {
+               pmdp = (pmd_t *)sh64_get_page();
+               set_pgd(pgdp, __pgd((unsigned long)pmdp | _KERNPG_TABLE));
+       }
+
+       pmdp = pmd_offset(pgdp, va);
+       if (pmd_none(*pmdp) || !pmd_present(*pmdp) ) {
+               ptep = (pte_t *)sh64_get_page();
+               set_pmd(pmdp, __pmd((unsigned long)ptep + _PAGE_TABLE));
+       }
+
+       prot = __pgprot(_PAGE_PRESENT | _PAGE_READ     | _PAGE_WRITE  |
+                       _PAGE_DIRTY   | _PAGE_ACCESSED | _PAGE_SHARED | flags);
+
+       pte = pfn_pte(pa >> PAGE_SHIFT, prot);
+       ptep = pte_offset_kernel(pmdp, va);
+
+       if (!pte_none(*ptep) &&
+           pte_val(*ptep) != pte_val(pte))
+               pte_ERROR(*ptep);
+
+       set_pte(ptep, pte);
+
+       flush_tlb_kernel_range(va, PAGE_SIZE);
+}
+
+static void shmedia_unmapioaddr(unsigned long vaddr)
+{
+       pgd_t *pgdp;
+       pmd_t *pmdp;
+       pte_t *ptep;
+
+       pgdp = pgd_offset_k(vaddr);
+       pmdp = pmd_offset(pgdp, vaddr);
+
+       if (pmd_none(*pmdp) || pmd_bad(*pmdp))
+               return;
+
+       ptep = pte_offset_kernel(pmdp, vaddr);
+
+       if (pte_none(*ptep) || !pte_present(*ptep))
+               return;
+
+       clear_page((void *)ptep);
+       pte_clear(&init_mm, vaddr, ptep);
+}
+
+unsigned long onchip_remap(unsigned long phys, unsigned long size, const char *name)
+{
+       if (size < PAGE_SIZE)
+               size = PAGE_SIZE;
+
+       return shmedia_alloc_io(phys, size, name);
+}
+
+void onchip_unmap(unsigned long vaddr)
+{
+       struct resource *res;
+       unsigned int psz;
+
+       res = shmedia_find_resource(&shmedia_iomap, vaddr);
+       if (!res) {
+               printk(KERN_ERR "%s: Failed to free 0x%08lx\n",
+                      __FUNCTION__, vaddr);
+               return;
+       }
+
+        psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
+
+        printk(KERN_DEBUG "unmapioaddr: %6s  [%2d page%s] freed\n",
+              res->name, psz, psz == 1 ? " " : "s");
+
+       shmedia_free_io(res);
+
+       if ((char *)res >= (char *)xresv &&
+           (char *)res <  (char *)&xresv[XNRES]) {
+               xres_free((struct xresource *)res);
+       } else {
+               kfree(res);
+       }
+}
+
+#ifdef CONFIG_PROC_FS
+static int
+ioremap_proc_info(char *buf, char **start, off_t fpos, int length, int *eof,
+                 void *data)
+{
+       char *p = buf, *e = buf + length;
+       struct resource *r;
+       const char *nm;
+
+       for (r = ((struct resource *)data)->child; r != NULL; r = r->sibling) {
+               if (p + 32 >= e)        /* Better than nothing */
+                       break;
+               if ((nm = r->name) == 0) nm = "???";
+               p += sprintf(p, "%08lx-%08lx: %s\n",
+                            (unsigned long)r->start,
+                            (unsigned long)r->end, nm);
+       }
+
+       return p-buf;
+}
+#endif /* CONFIG_PROC_FS */
+
+static int __init register_proc_onchip(void)
+{
+#ifdef CONFIG_PROC_FS
+       create_proc_read_entry("io_map",0,0, ioremap_proc_info, &shmedia_iomap);
+#endif
+       return 0;
+}
+
+__initcall(register_proc_onchip);
diff --git a/arch/sh64/mm/ioremap.c b/arch/sh64/mm/ioremap.c
deleted file mode 100644 (file)
index 535304e..0000000
+++ /dev/null
@@ -1,388 +0,0 @@
-/*
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file "COPYING" in the main directory of this archive
- * for more details.
- *
- * arch/sh64/mm/ioremap.c
- *
- * Copyright (C) 2000, 2001  Paolo Alberelli
- * Copyright (C) 2003, 2004  Paul Mundt
- *
- * Mostly derived from arch/sh/mm/ioremap.c which, in turn is mostly
- * derived from arch/i386/mm/ioremap.c .
- *
- *   (C) Copyright 1995 1996 Linus Torvalds
- */
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/vmalloc.h>
-#include <linux/sched.h>
-#include <linux/string.h>
-#include <linux/io.h>
-#include <linux/ioport.h>
-#include <linux/bootmem.h>
-#include <linux/proc_fs.h>
-#include <linux/module.h>
-#include <asm/pgalloc.h>
-#include <asm/tlbflush.h>
-
-static void shmedia_mapioaddr(unsigned long, unsigned long);
-static unsigned long shmedia_ioremap(struct resource *, u32, int);
-
-/*
- * Generic mapping function (not visible outside):
- */
-
-/*
- * Remap an arbitrary physical address space into the kernel virtual
- * address space. Needed when the kernel wants to access high addresses
- * directly.
- *
- * NOTE! We need to allow non-page-aligned mappings too: we will obviously
- * have to convert them into an offset in a page-aligned mapping, but the
- * caller shouldn't need to know that small detail.
- */
-void * __ioremap(unsigned long phys_addr, unsigned long size, unsigned long flags)
-{
-       void * addr;
-       struct vm_struct * area;
-       unsigned long offset, last_addr;
-       pgprot_t pgprot;
-
-       /* Don't allow wraparound or zero size */
-       last_addr = phys_addr + size - 1;
-       if (!size || last_addr < phys_addr)
-               return NULL;
-
-       pgprot = __pgprot(_PAGE_PRESENT  | _PAGE_READ   |
-                         _PAGE_WRITE    | _PAGE_DIRTY  |
-                         _PAGE_ACCESSED | _PAGE_SHARED | flags);
-
-       /*
-        * Mappings have to be page-aligned
-        */
-       offset = phys_addr & ~PAGE_MASK;
-       phys_addr &= PAGE_MASK;
-       size = PAGE_ALIGN(last_addr + 1) - phys_addr;
-
-       /*
-        * Ok, go for it..
-        */
-       area = get_vm_area(size, VM_IOREMAP);
-       pr_debug("Get vm_area returns %p addr %p\n",area,area->addr);
-       if (!area)
-               return NULL;
-       area->phys_addr = phys_addr;
-       addr = area->addr;
-       if (ioremap_page_range((unsigned long)addr, (unsigned long)addr + size,
-                              phys_addr, pgprot)) {
-               vunmap(addr);
-               return NULL;
-       }
-       return (void *) (offset + (char *)addr);
-}
-EXPORT_SYMBOL(__ioremap);
-
-void iounmap(void *addr)
-{
-       struct vm_struct *area;
-
-       vfree((void *) (PAGE_MASK & (unsigned long) addr));
-       area = remove_vm_area((void *) (PAGE_MASK & (unsigned long) addr));
-       if (!area) {
-               printk(KERN_ERR "iounmap: bad address %p\n", addr);
-               return;
-       }
-
-       kfree(area);
-}
-EXPORT_SYMBOL(iounmap);
-
-static struct resource shmedia_iomap = {
-       .name   = "shmedia_iomap",
-       .start  = IOBASE_VADDR + PAGE_SIZE,
-       .end    = IOBASE_END - 1,
-};
-
-static void shmedia_mapioaddr(unsigned long pa, unsigned long va);
-static void shmedia_unmapioaddr(unsigned long vaddr);
-static unsigned long shmedia_ioremap(struct resource *res, u32 pa, int sz);
-
-/*
- * We have the same problem as the SPARC, so lets have the same comment:
- * Our mini-allocator...
- * Boy this is gross! We need it because we must map I/O for
- * timers and interrupt controller before the kmalloc is available.
- */
-
-#define XNMLN  15
-#define XNRES  10
-
-struct xresource {
-       struct resource xres;   /* Must be first */
-       int xflag;              /* 1 == used */
-       char xname[XNMLN+1];
-};
-
-static struct xresource xresv[XNRES];
-
-static struct xresource *xres_alloc(void)
-{
-        struct xresource *xrp;
-        int n;
-
-        xrp = xresv;
-        for (n = 0; n < XNRES; n++) {
-                if (xrp->xflag == 0) {
-                        xrp->xflag = 1;
-                        return xrp;
-                }
-                xrp++;
-        }
-        return NULL;
-}
-
-static void xres_free(struct xresource *xrp)
-{
-       xrp->xflag = 0;
-}
-
-static struct resource *shmedia_find_resource(struct resource *root,
-                                             unsigned long vaddr)
-{
-       struct resource *res;
-
-       for (res = root->child; res; res = res->sibling)
-               if (res->start <= vaddr && res->end >= vaddr)
-                       return res;
-
-       return NULL;
-}
-
-static unsigned long shmedia_alloc_io(unsigned long phys, unsigned long size,
-                                     const char *name)
-{
-        static int printed_full = 0;
-        struct xresource *xres;
-        struct resource *res;
-        char *tack;
-        int tlen;
-
-        if (name == NULL) name = "???";
-
-        if ((xres = xres_alloc()) != 0) {
-                tack = xres->xname;
-                res = &xres->xres;
-        } else {
-                if (!printed_full) {
-                        printk("%s: done with statics, switching to kmalloc\n",
-                              __FUNCTION__);
-                        printed_full = 1;
-                }
-                tlen = strlen(name);
-                tack = kmalloc(sizeof (struct resource) + tlen + 1, GFP_KERNEL);
-                if (!tack)
-                       return -ENOMEM;
-                memset(tack, 0, sizeof(struct resource));
-                res = (struct resource *) tack;
-                tack += sizeof (struct resource);
-        }
-
-        strncpy(tack, name, XNMLN);
-        tack[XNMLN] = 0;
-        res->name = tack;
-
-        return shmedia_ioremap(res, phys, size);
-}
-
-static unsigned long shmedia_ioremap(struct resource *res, u32 pa, int sz)
-{
-        unsigned long offset = ((unsigned long) pa) & (~PAGE_MASK);
-       unsigned long round_sz = (offset + sz + PAGE_SIZE-1) & PAGE_MASK;
-        unsigned long va;
-        unsigned int psz;
-
-        if (allocate_resource(&shmedia_iomap, res, round_sz,
-                             shmedia_iomap.start, shmedia_iomap.end,
-                             PAGE_SIZE, NULL, NULL) != 0) {
-                panic("alloc_io_res(%s): cannot occupy\n",
-                    (res->name != NULL)? res->name: "???");
-        }
-
-        va = res->start;
-        pa &= PAGE_MASK;
-
-       psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
-
-       /* log at boot time ... */
-       printk("mapioaddr: %6s  [%2d page%s]  va 0x%08lx   pa 0x%08x\n",
-              ((res->name != NULL) ? res->name : "???"),
-              psz, psz == 1 ? " " : "s", va, pa);
-
-        for (psz = res->end - res->start + 1; psz != 0; psz -= PAGE_SIZE) {
-                shmedia_mapioaddr(pa, va);
-                va += PAGE_SIZE;
-                pa += PAGE_SIZE;
-        }
-
-        res->start += offset;
-        res->end = res->start + sz - 1;         /* not strictly necessary.. */
-
-        return res->start;
-}
-
-static void shmedia_free_io(struct resource *res)
-{
-       unsigned long len = res->end - res->start + 1;
-
-       BUG_ON((len & (PAGE_SIZE - 1)) != 0);
-
-       while (len) {
-               len -= PAGE_SIZE;
-               shmedia_unmapioaddr(res->start + len);
-       }
-
-       release_resource(res);
-}
-
-static __init_refok void *sh64_get_page(void)
-{
-       extern int after_bootmem;
-       void *page;
-
-       if (after_bootmem) {
-               page = (void *)get_zeroed_page(GFP_ATOMIC);
-       } else {
-               page = alloc_bootmem_pages(PAGE_SIZE);
-       }
-
-       if (!page || ((unsigned long)page & ~PAGE_MASK))
-               panic("sh64_get_page: Out of memory already?\n");
-
-       return page;
-}
-
-static void shmedia_mapioaddr(unsigned long pa, unsigned long va)
-{
-       pgd_t *pgdp;
-       pmd_t *pmdp;
-       pte_t *ptep, pte;
-       pgprot_t prot;
-       unsigned long flags = 1; /* 1 = CB0-1 device */
-
-       pr_debug("shmedia_mapiopage pa %08lx va %08lx\n",  pa, va);
-
-       pgdp = pgd_offset_k(va);
-       if (pgd_none(*pgdp) || !pgd_present(*pgdp)) {
-               pmdp = (pmd_t *)sh64_get_page();
-               set_pgd(pgdp, __pgd((unsigned long)pmdp | _KERNPG_TABLE));
-       }
-
-       pmdp = pmd_offset(pgdp, va);
-       if (pmd_none(*pmdp) || !pmd_present(*pmdp) ) {
-               ptep = (pte_t *)sh64_get_page();
-               set_pmd(pmdp, __pmd((unsigned long)ptep + _PAGE_TABLE));
-       }
-
-       prot = __pgprot(_PAGE_PRESENT | _PAGE_READ     | _PAGE_WRITE  |
-                       _PAGE_DIRTY   | _PAGE_ACCESSED | _PAGE_SHARED | flags);
-
-       pte = pfn_pte(pa >> PAGE_SHIFT, prot);
-       ptep = pte_offset_kernel(pmdp, va);
-
-       if (!pte_none(*ptep) &&
-           pte_val(*ptep) != pte_val(pte))
-               pte_ERROR(*ptep);
-
-       set_pte(ptep, pte);
-
-       flush_tlb_kernel_range(va, PAGE_SIZE);
-}
-
-static void shmedia_unmapioaddr(unsigned long vaddr)
-{
-       pgd_t *pgdp;
-       pmd_t *pmdp;
-       pte_t *ptep;
-
-       pgdp = pgd_offset_k(vaddr);
-       pmdp = pmd_offset(pgdp, vaddr);
-
-       if (pmd_none(*pmdp) || pmd_bad(*pmdp))
-               return;
-
-       ptep = pte_offset_kernel(pmdp, vaddr);
-
-       if (pte_none(*ptep) || !pte_present(*ptep))
-               return;
-
-       clear_page((void *)ptep);
-       pte_clear(&init_mm, vaddr, ptep);
-}
-
-unsigned long onchip_remap(unsigned long phys, unsigned long size, const char *name)
-{
-       if (size < PAGE_SIZE)
-               size = PAGE_SIZE;
-
-       return shmedia_alloc_io(phys, size, name);
-}
-
-void onchip_unmap(unsigned long vaddr)
-{
-       struct resource *res;
-       unsigned int psz;
-
-       res = shmedia_find_resource(&shmedia_iomap, vaddr);
-       if (!res) {
-               printk(KERN_ERR "%s: Failed to free 0x%08lx\n",
-                      __FUNCTION__, vaddr);
-               return;
-       }
-
-        psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
-
-        printk(KERN_DEBUG "unmapioaddr: %6s  [%2d page%s] freed\n",
-              res->name, psz, psz == 1 ? " " : "s");
-
-       shmedia_free_io(res);
-
-       if ((char *)res >= (char *)xresv &&
-           (char *)res <  (char *)&xresv[XNRES]) {
-               xres_free((struct xresource *)res);
-       } else {
-               kfree(res);
-       }
-}
-
-#ifdef CONFIG_PROC_FS
-static int
-ioremap_proc_info(char *buf, char **start, off_t fpos, int length, int *eof,
-                 void *data)
-{
-       char *p = buf, *e = buf + length;
-       struct resource *r;
-       const char *nm;
-
-       for (r = ((struct resource *)data)->child; r != NULL; r = r->sibling) {
-               if (p + 32 >= e)        /* Better than nothing */
-                       break;
-               if ((nm = r->name) == 0) nm = "???";
-               p += sprintf(p, "%08lx-%08lx: %s\n",
-                            (unsigned long)r->start,
-                            (unsigned long)r->end, nm);
-       }
-
-       return p-buf;
-}
-#endif /* CONFIG_PROC_FS */
-
-static int __init register_proc_onchip(void)
-{
-#ifdef CONFIG_PROC_FS
-       create_proc_read_entry("io_map",0,0, ioremap_proc_info, &shmedia_iomap);
-#endif
-       return 0;
-}
-
-__initcall(register_proc_onchip);