![Harvey Harrison](/assets/img/avatar_default.png)
__FUNCTION__ is gcc-specific, use __func__ Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Paul Mundt <lethal@linux-sh.org>
405 lines
9.9 KiB
C
405 lines
9.9 KiB
C
/*
|
|
* arch/sh/mm/ioremap_64.c
|
|
*
|
|
* Copyright (C) 2000, 2001 Paolo Alberelli
|
|
* Copyright (C) 2003 - 2007 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
|
|
*
|
|
* 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/ioport.h>
|
|
#include <linux/module.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/io.h>
|
|
#include <linux/bootmem.h>
|
|
#include <linux/proc_fs.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",
|
|
__func__);
|
|
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;
|
|
pud_t *pudp;
|
|
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)) {
|
|
pudp = (pud_t *)sh64_get_page();
|
|
set_pgd(pgdp, __pgd((unsigned long)pudp | _KERNPG_TABLE));
|
|
}
|
|
|
|
pudp = pud_offset(pgdp, va);
|
|
if (pud_none(*pudp) || !pud_present(*pudp)) {
|
|
pmdp = (pmd_t *)sh64_get_page();
|
|
set_pud(pudp, __pud((unsigned long)pmdp | _KERNPG_TABLE));
|
|
}
|
|
|
|
pmdp = pmd_offset(pudp, 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;
|
|
pud_t *pudp;
|
|
pmd_t *pmdp;
|
|
pte_t *ptep;
|
|
|
|
pgdp = pgd_offset_k(vaddr);
|
|
if (pgd_none(*pgdp) || pgd_bad(*pgdp))
|
|
return;
|
|
|
|
pudp = pud_offset(pgdp, vaddr);
|
|
if (pud_none(*pudp) || pud_bad(*pudp))
|
|
return;
|
|
|
|
pmdp = pmd_offset(pudp, 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",
|
|
__func__, 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);
|