2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* linux/arch/arm/mm/ioremap.c
|
|
|
|
*
|
|
|
|
* Re-map IO memory to kernel address space so that we can access it.
|
|
|
|
*
|
|
|
|
* (C) Copyright 1995 1996 Linus Torvalds
|
|
|
|
*
|
|
|
|
* Hacked for ARM by Phil Blundell <philb@gnu.org>
|
|
|
|
* Hacked to allow all architectures to build, and various cleanups
|
|
|
|
* by Russell King
|
|
|
|
*
|
|
|
|
* This allows a driver to remap an arbitrary region of bus memory into
|
|
|
|
* virtual space. One should *only* use readl, writel, memcpy_toio and
|
|
|
|
* so on with such remapped areas.
|
|
|
|
*
|
|
|
|
* Because the ARM only has a 32-bit address space we can't address the
|
|
|
|
* whole of the (physical) PCI space at once. PCI huge-mode addressing
|
|
|
|
* allows us to circumvent this restriction by splitting PCI space into
|
|
|
|
* two 2GB chunks and mapping only one at a time into processor memory.
|
|
|
|
* We use MMU protection domains to trap any attempt to access the bank
|
|
|
|
* that is not currently mapped. (This isn't fully implemented yet.)
|
|
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/vmalloc.h>
|
2008-09-06 18:10:45 +07:00
|
|
|
#include <linux/io.h>
|
2012-06-24 18:46:26 +07:00
|
|
|
#include <linux/sizes.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2012-03-29 00:30:01 +07:00
|
|
|
#include <asm/cp15.h>
|
2008-08-11 00:08:10 +07:00
|
|
|
#include <asm/cputype.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/cacheflush.h>
|
2006-06-30 02:17:15 +07:00
|
|
|
#include <asm/mmu_context.h>
|
|
|
|
#include <asm/pgalloc.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/tlbflush.h>
|
2012-03-29 00:30:01 +07:00
|
|
|
#include <asm/system_info.h>
|
2006-06-30 02:17:15 +07:00
|
|
|
|
2007-04-21 16:47:29 +07:00
|
|
|
#include <asm/mach/map.h>
|
2012-03-01 07:10:58 +07:00
|
|
|
#include <asm/mach/pci.h>
|
2007-04-21 16:47:29 +07:00
|
|
|
#include "mm.h"
|
|
|
|
|
ARM: 7645/1: ioremap: introduce an infrastructure for static mapped area
In current implementation, we used ARM-specific flag, that is,
VM_ARM_STATIC_MAPPING, for distinguishing ARM specific static mapped area.
The purpose of static mapped area is to re-use static mapped area when
entire physical address range of the ioremap request can be covered
by this area.
This implementation causes needless overhead for some cases.
For example, assume that there is only one static mapped area and
vmlist has 300 areas. Every time we call ioremap, we check 300 areas for
deciding whether it is matched or not. Moreover, even if there is
no static mapped area and vmlist has 300 areas, every time we call
ioremap, we check 300 areas in now.
If we construct a extra list for static mapped area, we can eliminate
above mentioned overhead.
With a extra list, if there is one static mapped area,
we just check only one area and proceed next operation quickly.
In fact, it is not a critical problem, because ioremap is not frequently
used. But reducing overhead is better idea.
Another reason for doing this work is for removing architecture dependency
on vmalloc layer. I think that vmlist and vmlist_lock is internal data
structure for vmalloc layer. Some codes for debugging and stat inevitably
use vmlist and vmlist_lock. But it is preferable that they are used
as least as possible in outside of vmalloc.c
Now, I introduce an ARM-specific infrastructure for static mapped area. In
the following patch, we will use this and resolve above mentioned problem.
Reviewed-by: Nicolas Pitre <nico@linaro.org>
Tested-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2013-02-09 12:28:05 +07:00
|
|
|
|
|
|
|
LIST_HEAD(static_vmlist);
|
|
|
|
|
|
|
|
static struct static_vm *find_static_vm_paddr(phys_addr_t paddr,
|
|
|
|
size_t size, unsigned int mtype)
|
|
|
|
{
|
|
|
|
struct static_vm *svm;
|
|
|
|
struct vm_struct *vm;
|
|
|
|
|
|
|
|
list_for_each_entry(svm, &static_vmlist, list) {
|
|
|
|
vm = &svm->vm;
|
|
|
|
if (!(vm->flags & VM_ARM_STATIC_MAPPING))
|
|
|
|
continue;
|
|
|
|
if ((vm->flags & VM_ARM_MTYPE_MASK) != VM_ARM_MTYPE(mtype))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (vm->phys_addr > paddr ||
|
|
|
|
paddr + size - 1 > vm->phys_addr + vm->size - 1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
return svm;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct static_vm *find_static_vm_vaddr(void *vaddr)
|
|
|
|
{
|
|
|
|
struct static_vm *svm;
|
|
|
|
struct vm_struct *vm;
|
|
|
|
|
|
|
|
list_for_each_entry(svm, &static_vmlist, list) {
|
|
|
|
vm = &svm->vm;
|
|
|
|
|
|
|
|
/* static_vmlist is ascending order */
|
|
|
|
if (vm->addr > vaddr)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (vm->addr <= vaddr && vm->addr + vm->size > vaddr)
|
|
|
|
return svm;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init add_static_vm_early(struct static_vm *svm)
|
|
|
|
{
|
|
|
|
struct static_vm *curr_svm;
|
|
|
|
struct vm_struct *vm;
|
|
|
|
void *vaddr;
|
|
|
|
|
|
|
|
vm = &svm->vm;
|
|
|
|
vm_area_add_early(vm);
|
|
|
|
vaddr = vm->addr;
|
|
|
|
|
|
|
|
list_for_each_entry(curr_svm, &static_vmlist, list) {
|
|
|
|
vm = &curr_svm->vm;
|
|
|
|
|
|
|
|
if (vm->addr > vaddr)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
list_add_tail(&svm->list, &curr_svm->list);
|
|
|
|
}
|
|
|
|
|
2009-01-29 02:32:08 +07:00
|
|
|
int ioremap_page(unsigned long virt, unsigned long phys,
|
|
|
|
const struct mem_type *mtype)
|
|
|
|
{
|
2010-07-26 16:29:13 +07:00
|
|
|
return ioremap_page_range(virt, virt + PAGE_SIZE, phys,
|
|
|
|
__pgprot(mtype->prot_pte));
|
2009-01-29 02:32:08 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ioremap_page);
|
2006-06-30 02:17:15 +07:00
|
|
|
|
2012-11-25 09:24:32 +07:00
|
|
|
void __check_vmalloc_seq(struct mm_struct *mm)
|
2006-06-30 02:17:15 +07:00
|
|
|
{
|
|
|
|
unsigned int seq;
|
|
|
|
|
|
|
|
do {
|
2012-11-25 09:24:32 +07:00
|
|
|
seq = init_mm.context.vmalloc_seq;
|
2006-06-30 02:17:15 +07:00
|
|
|
memcpy(pgd_offset(mm, VMALLOC_START),
|
|
|
|
pgd_offset_k(VMALLOC_START),
|
|
|
|
sizeof(pgd_t) * (pgd_index(VMALLOC_END) -
|
|
|
|
pgd_index(VMALLOC_START)));
|
2012-11-25 09:24:32 +07:00
|
|
|
mm->context.vmalloc_seq = seq;
|
|
|
|
} while (seq != init_mm.context.vmalloc_seq);
|
2006-06-30 02:17:15 +07:00
|
|
|
}
|
|
|
|
|
2011-11-23 00:30:29 +07:00
|
|
|
#if !defined(CONFIG_SMP) && !defined(CONFIG_ARM_LPAE)
|
2006-06-30 02:17:15 +07:00
|
|
|
/*
|
|
|
|
* Section support is unsafe on SMP - If you iounmap and ioremap a region,
|
|
|
|
* the other CPUs will not see this change until their next context switch.
|
|
|
|
* Meanwhile, (eg) if an interrupt comes in on one of those other CPUs
|
|
|
|
* which requires the new ioremap'd region to be referenced, the CPU will
|
|
|
|
* reference the _old_ region.
|
|
|
|
*
|
2009-12-18 18:10:03 +07:00
|
|
|
* Note that get_vm_area_caller() allocates a guard 4K page, so we need to
|
|
|
|
* mask the size back to 1MB aligned or we will overflow in the loop below.
|
2006-06-30 02:17:15 +07:00
|
|
|
*/
|
|
|
|
static void unmap_area_sections(unsigned long virt, unsigned long size)
|
|
|
|
{
|
2009-01-26 00:36:34 +07:00
|
|
|
unsigned long addr = virt, end = virt + (size & ~(SZ_1M - 1));
|
2006-06-30 02:17:15 +07:00
|
|
|
pgd_t *pgd;
|
2011-11-23 00:30:27 +07:00
|
|
|
pud_t *pud;
|
|
|
|
pmd_t *pmdp;
|
2006-06-30 02:17:15 +07:00
|
|
|
|
|
|
|
flush_cache_vunmap(addr, end);
|
|
|
|
pgd = pgd_offset_k(addr);
|
2011-11-23 00:30:27 +07:00
|
|
|
pud = pud_offset(pgd, addr);
|
|
|
|
pmdp = pmd_offset(pud, addr);
|
2006-06-30 02:17:15 +07:00
|
|
|
do {
|
2011-11-23 00:30:27 +07:00
|
|
|
pmd_t pmd = *pmdp;
|
2006-06-30 02:17:15 +07:00
|
|
|
|
|
|
|
if (!pmd_none(pmd)) {
|
|
|
|
/*
|
|
|
|
* Clear the PMD from the page table, and
|
2012-11-25 09:24:32 +07:00
|
|
|
* increment the vmalloc sequence so others
|
2006-06-30 02:17:15 +07:00
|
|
|
* notice this change.
|
|
|
|
*
|
|
|
|
* Note: this is still racy on SMP machines.
|
|
|
|
*/
|
|
|
|
pmd_clear(pmdp);
|
2012-11-25 09:24:32 +07:00
|
|
|
init_mm.context.vmalloc_seq++;
|
2006-06-30 02:17:15 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Free the page table, if there was one.
|
|
|
|
*/
|
|
|
|
if ((pmd_val(pmd) & PMD_TYPE_MASK) == PMD_TYPE_TABLE)
|
2008-02-05 13:29:14 +07:00
|
|
|
pte_free_kernel(&init_mm, pmd_page_vaddr(pmd));
|
2006-06-30 02:17:15 +07:00
|
|
|
}
|
|
|
|
|
2011-11-23 00:30:27 +07:00
|
|
|
addr += PMD_SIZE;
|
|
|
|
pmdp += 2;
|
2006-06-30 02:17:15 +07:00
|
|
|
} while (addr < end);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ensure that the active_mm is up to date - we want to
|
|
|
|
* catch any use-after-iounmap cases.
|
|
|
|
*/
|
2012-11-25 09:24:32 +07:00
|
|
|
if (current->active_mm->context.vmalloc_seq != init_mm.context.vmalloc_seq)
|
|
|
|
__check_vmalloc_seq(current->active_mm);
|
2006-06-30 02:17:15 +07:00
|
|
|
|
|
|
|
flush_tlb_kernel_range(virt, end);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
remap_area_sections(unsigned long virt, unsigned long pfn,
|
2007-04-21 16:47:29 +07:00
|
|
|
size_t size, const struct mem_type *type)
|
2006-06-30 02:17:15 +07:00
|
|
|
{
|
2007-04-21 16:47:29 +07:00
|
|
|
unsigned long addr = virt, end = virt + size;
|
2006-06-30 02:17:15 +07:00
|
|
|
pgd_t *pgd;
|
2011-11-23 00:30:27 +07:00
|
|
|
pud_t *pud;
|
|
|
|
pmd_t *pmd;
|
2006-06-30 02:17:15 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove and free any PTE-based mapping, and
|
|
|
|
* sync the current kernel mapping.
|
|
|
|
*/
|
|
|
|
unmap_area_sections(virt, size);
|
|
|
|
|
|
|
|
pgd = pgd_offset_k(addr);
|
2011-11-23 00:30:27 +07:00
|
|
|
pud = pud_offset(pgd, addr);
|
|
|
|
pmd = pmd_offset(pud, addr);
|
2006-06-30 02:17:15 +07:00
|
|
|
do {
|
2007-04-21 16:47:29 +07:00
|
|
|
pmd[0] = __pmd(__pfn_to_phys(pfn) | type->prot_sect);
|
2006-06-30 02:17:15 +07:00
|
|
|
pfn += SZ_1M >> PAGE_SHIFT;
|
2007-04-21 16:47:29 +07:00
|
|
|
pmd[1] = __pmd(__pfn_to_phys(pfn) | type->prot_sect);
|
2006-06-30 02:17:15 +07:00
|
|
|
pfn += SZ_1M >> PAGE_SHIFT;
|
|
|
|
flush_pmd_entry(pmd);
|
|
|
|
|
2011-11-23 00:30:27 +07:00
|
|
|
addr += PMD_SIZE;
|
|
|
|
pmd += 2;
|
2006-06-30 02:17:15 +07:00
|
|
|
} while (addr < end);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2006-07-02 01:58:20 +07:00
|
|
|
|
|
|
|
static int
|
|
|
|
remap_area_supersections(unsigned long virt, unsigned long pfn,
|
2007-04-21 16:47:29 +07:00
|
|
|
size_t size, const struct mem_type *type)
|
2006-07-02 01:58:20 +07:00
|
|
|
{
|
2007-04-21 16:47:29 +07:00
|
|
|
unsigned long addr = virt, end = virt + size;
|
2006-07-02 01:58:20 +07:00
|
|
|
pgd_t *pgd;
|
2011-11-23 00:30:27 +07:00
|
|
|
pud_t *pud;
|
|
|
|
pmd_t *pmd;
|
2006-07-02 01:58:20 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove and free any PTE-based mapping, and
|
|
|
|
* sync the current kernel mapping.
|
|
|
|
*/
|
|
|
|
unmap_area_sections(virt, size);
|
|
|
|
|
|
|
|
pgd = pgd_offset_k(virt);
|
2011-11-23 00:30:27 +07:00
|
|
|
pud = pud_offset(pgd, addr);
|
|
|
|
pmd = pmd_offset(pud, addr);
|
2006-07-02 01:58:20 +07:00
|
|
|
do {
|
|
|
|
unsigned long super_pmd_val, i;
|
|
|
|
|
2007-04-21 16:47:29 +07:00
|
|
|
super_pmd_val = __pfn_to_phys(pfn) | type->prot_sect |
|
|
|
|
PMD_SECT_SUPER;
|
2006-07-02 01:58:20 +07:00
|
|
|
super_pmd_val |= ((pfn >> (32 - PAGE_SHIFT)) & 0xf) << 20;
|
|
|
|
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
pmd[0] = __pmd(super_pmd_val);
|
|
|
|
pmd[1] = __pmd(super_pmd_val);
|
|
|
|
flush_pmd_entry(pmd);
|
|
|
|
|
2011-11-23 00:30:27 +07:00
|
|
|
addr += PMD_SIZE;
|
|
|
|
pmd += 2;
|
2006-07-02 01:58:20 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
pfn += SUPERSECTION_SIZE >> PAGE_SHIFT;
|
|
|
|
} while (addr < end);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2006-06-30 02:17:15 +07:00
|
|
|
#endif
|
|
|
|
|
2009-12-18 18:10:03 +07:00
|
|
|
void __iomem * __arm_ioremap_pfn_caller(unsigned long pfn,
|
|
|
|
unsigned long offset, size_t size, unsigned int mtype, void *caller)
|
2006-01-10 02:23:11 +07:00
|
|
|
{
|
2007-04-21 16:47:29 +07:00
|
|
|
const struct mem_type *type;
|
2006-06-30 02:17:15 +07:00
|
|
|
int err;
|
2006-01-10 02:23:11 +07:00
|
|
|
unsigned long addr;
|
2013-02-09 12:28:06 +07:00
|
|
|
struct vm_struct *area;
|
|
|
|
phys_addr_t paddr = __pfn_to_phys(pfn);
|
2006-07-02 01:58:20 +07:00
|
|
|
|
2011-11-23 00:30:29 +07:00
|
|
|
#ifndef CONFIG_ARM_LPAE
|
2006-07-02 01:58:20 +07:00
|
|
|
/*
|
|
|
|
* High mappings must be supersection aligned
|
|
|
|
*/
|
2013-02-09 12:28:06 +07:00
|
|
|
if (pfn >= 0x100000 && (paddr & ~SUPERSECTION_MASK))
|
2006-07-02 01:58:20 +07:00
|
|
|
return NULL;
|
2011-11-23 00:30:29 +07:00
|
|
|
#endif
|
2006-01-10 02:23:11 +07:00
|
|
|
|
2007-05-06 02:59:27 +07:00
|
|
|
type = get_mem_type(mtype);
|
|
|
|
if (!type)
|
|
|
|
return NULL;
|
2007-04-21 16:47:29 +07:00
|
|
|
|
2007-06-04 01:26:04 +07:00
|
|
|
/*
|
|
|
|
* Page align the mapping size, taking account of any offset.
|
|
|
|
*/
|
|
|
|
size = PAGE_ALIGN(offset + size);
|
2006-12-18 06:29:57 +07:00
|
|
|
|
2011-09-16 12:14:23 +07:00
|
|
|
/*
|
|
|
|
* Try to reuse one of the static mapping whenever possible.
|
|
|
|
*/
|
2013-02-09 12:28:06 +07:00
|
|
|
if (size && !(sizeof(phys_addr_t) == 4 && pfn >= 0x100000)) {
|
|
|
|
struct static_vm *svm;
|
|
|
|
|
|
|
|
svm = find_static_vm_paddr(paddr, size, mtype);
|
|
|
|
if (svm) {
|
|
|
|
addr = (unsigned long)svm->vm.addr;
|
|
|
|
addr += paddr - svm->vm.phys_addr;
|
|
|
|
return (void __iomem *) (offset + addr);
|
|
|
|
}
|
2011-09-16 12:14:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't allow RAM to be mapped - this causes problems with ARMv6+
|
|
|
|
*/
|
|
|
|
if (WARN_ON(pfn_valid(pfn)))
|
|
|
|
return NULL;
|
|
|
|
|
2009-12-18 18:10:03 +07:00
|
|
|
area = get_vm_area_caller(size, VM_IOREMAP, caller);
|
2006-01-10 02:23:11 +07:00
|
|
|
if (!area)
|
|
|
|
return NULL;
|
|
|
|
addr = (unsigned long)area->addr;
|
2013-02-09 12:28:06 +07:00
|
|
|
area->phys_addr = paddr;
|
2006-06-30 02:17:15 +07:00
|
|
|
|
2011-11-23 00:30:29 +07:00
|
|
|
#if !defined(CONFIG_SMP) && !defined(CONFIG_ARM_LPAE)
|
2007-01-25 20:16:47 +07:00
|
|
|
if (DOMAIN_IO == 0 &&
|
|
|
|
(((cpu_architecture() >= CPU_ARCH_ARMv6) && (get_cr() & CR_XP)) ||
|
2007-04-21 16:16:48 +07:00
|
|
|
cpu_is_xsc3()) && pfn >= 0x100000 &&
|
2013-02-09 12:28:06 +07:00
|
|
|
!((paddr | size | addr) & ~SUPERSECTION_MASK)) {
|
2006-07-02 01:58:20 +07:00
|
|
|
area->flags |= VM_ARM_SECTION_MAPPING;
|
2007-04-21 16:47:29 +07:00
|
|
|
err = remap_area_supersections(addr, pfn, size, type);
|
2013-02-09 12:28:06 +07:00
|
|
|
} else if (!((paddr | size | addr) & ~PMD_MASK)) {
|
2006-06-30 02:17:15 +07:00
|
|
|
area->flags |= VM_ARM_SECTION_MAPPING;
|
2007-04-21 16:47:29 +07:00
|
|
|
err = remap_area_sections(addr, pfn, size, type);
|
2006-06-30 02:17:15 +07:00
|
|
|
} else
|
|
|
|
#endif
|
2013-02-09 12:28:06 +07:00
|
|
|
err = ioremap_page_range(addr, addr + size, paddr,
|
2010-07-26 16:29:13 +07:00
|
|
|
__pgprot(type->prot_pte));
|
2006-06-30 02:17:15 +07:00
|
|
|
|
|
|
|
if (err) {
|
2006-05-16 17:30:26 +07:00
|
|
|
vunmap((void *)addr);
|
2006-01-10 02:23:11 +07:00
|
|
|
return NULL;
|
|
|
|
}
|
2006-06-30 02:17:15 +07:00
|
|
|
|
|
|
|
flush_cache_vmap(addr, addr + size);
|
|
|
|
return (void __iomem *) (offset + addr);
|
2006-01-10 02:23:11 +07:00
|
|
|
}
|
|
|
|
|
2013-05-17 01:40:22 +07:00
|
|
|
void __iomem *__arm_ioremap_caller(phys_addr_t phys_addr, size_t size,
|
2009-12-18 18:10:03 +07:00
|
|
|
unsigned int mtype, void *caller)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2013-05-17 01:40:22 +07:00
|
|
|
phys_addr_t last_addr;
|
2006-01-10 02:23:11 +07:00
|
|
|
unsigned long offset = phys_addr & ~PAGE_MASK;
|
|
|
|
unsigned long pfn = __phys_to_pfn(phys_addr);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-01-10 02:23:11 +07:00
|
|
|
/*
|
|
|
|
* Don't allow wraparound or zero size
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
last_addr = phys_addr + size - 1;
|
|
|
|
if (!size || last_addr < phys_addr)
|
|
|
|
return NULL;
|
|
|
|
|
2009-12-18 18:10:03 +07:00
|
|
|
return __arm_ioremap_pfn_caller(pfn, offset, size, mtype,
|
|
|
|
caller);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 *
|
|
|
|
__arm_ioremap_pfn(unsigned long pfn, unsigned long offset, size_t size,
|
|
|
|
unsigned int mtype)
|
|
|
|
{
|
|
|
|
return __arm_ioremap_pfn_caller(pfn, offset, size, mtype,
|
|
|
|
__builtin_return_address(0));
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__arm_ioremap_pfn);
|
|
|
|
|
2013-05-17 01:40:22 +07:00
|
|
|
void __iomem * (*arch_ioremap_caller)(phys_addr_t, size_t,
|
2012-02-11 06:05:13 +07:00
|
|
|
unsigned int, void *) =
|
|
|
|
__arm_ioremap_caller;
|
|
|
|
|
2009-12-18 18:10:03 +07:00
|
|
|
void __iomem *
|
2013-05-17 01:40:22 +07:00
|
|
|
__arm_ioremap(phys_addr_t phys_addr, size_t size, unsigned int mtype)
|
2009-12-18 18:10:03 +07:00
|
|
|
{
|
2012-02-11 06:05:13 +07:00
|
|
|
return arch_ioremap_caller(phys_addr, size, mtype,
|
|
|
|
__builtin_return_address(0));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-05-06 02:59:27 +07:00
|
|
|
EXPORT_SYMBOL(__arm_ioremap);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-10-12 07:02:50 +07:00
|
|
|
/*
|
|
|
|
* Remap an arbitrary physical address space into the kernel virtual
|
|
|
|
* address space as memory. Needed when the kernel wants to execute
|
|
|
|
* code in external memory. This is needed for reprogramming source
|
|
|
|
* clocks that would affect normal memory for example. Please see
|
|
|
|
* CONFIG_GENERIC_ALLOCATOR for allocating external memory.
|
|
|
|
*/
|
|
|
|
void __iomem *
|
2013-05-17 01:40:22 +07:00
|
|
|
__arm_ioremap_exec(phys_addr_t phys_addr, size_t size, bool cached)
|
2011-10-12 07:02:50 +07:00
|
|
|
{
|
|
|
|
unsigned int mtype;
|
|
|
|
|
|
|
|
if (cached)
|
|
|
|
mtype = MT_MEMORY;
|
|
|
|
else
|
|
|
|
mtype = MT_MEMORY_NONCACHED;
|
|
|
|
|
|
|
|
return __arm_ioremap_caller(phys_addr, size, mtype,
|
|
|
|
__builtin_return_address(0));
|
|
|
|
}
|
|
|
|
|
2008-09-05 20:08:44 +07:00
|
|
|
void __iounmap(volatile void __iomem *io_addr)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-09-05 20:08:44 +07:00
|
|
|
void *addr = (void *)(PAGE_MASK & (unsigned long)io_addr);
|
2013-02-09 12:28:06 +07:00
|
|
|
struct static_vm *svm;
|
|
|
|
|
|
|
|
/* If this is a static mapping, we must leave it alone */
|
|
|
|
svm = find_static_vm_vaddr(addr);
|
|
|
|
if (svm)
|
|
|
|
return;
|
2006-06-30 02:17:15 +07:00
|
|
|
|
2011-12-09 01:02:04 +07:00
|
|
|
#if !defined(CONFIG_SMP) && !defined(CONFIG_ARM_LPAE)
|
2013-02-09 12:28:06 +07:00
|
|
|
{
|
|
|
|
struct vm_struct *vm;
|
|
|
|
|
|
|
|
vm = find_vm_area(addr);
|
|
|
|
|
2011-09-16 12:14:23 +07:00
|
|
|
/*
|
|
|
|
* If this is a section based mapping we need to handle it
|
|
|
|
* specially as the VM subsystem does not know how to handle
|
|
|
|
* such a beast.
|
|
|
|
*/
|
2013-02-09 12:28:06 +07:00
|
|
|
if (vm && (vm->flags & VM_ARM_SECTION_MAPPING))
|
2011-09-16 12:14:23 +07:00
|
|
|
unmap_area_sections((unsigned long)vm->addr, vm->size);
|
2006-06-30 02:17:15 +07:00
|
|
|
}
|
2013-02-09 12:28:06 +07:00
|
|
|
#endif
|
2006-06-30 02:17:15 +07:00
|
|
|
|
2009-01-26 00:36:34 +07:00
|
|
|
vunmap(addr);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2012-02-11 06:05:13 +07:00
|
|
|
|
|
|
|
void (*arch_iounmap)(volatile void __iomem *) = __iounmap;
|
|
|
|
|
|
|
|
void __arm_iounmap(volatile void __iomem *io_addr)
|
|
|
|
{
|
|
|
|
arch_iounmap(io_addr);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__arm_iounmap);
|
2012-03-01 07:10:58 +07:00
|
|
|
|
|
|
|
#ifdef CONFIG_PCI
|
|
|
|
int pci_ioremap_io(unsigned int offset, phys_addr_t phys_addr)
|
|
|
|
{
|
|
|
|
BUG_ON(offset + SZ_64K > IO_SPACE_LIMIT);
|
|
|
|
|
|
|
|
return ioremap_page_range(PCI_IO_VIRT_BASE + offset,
|
|
|
|
PCI_IO_VIRT_BASE + offset + SZ_64K,
|
|
|
|
phys_addr,
|
|
|
|
__pgprot(get_mem_type(MT_DEVICE)->prot_pte));
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pci_ioremap_io);
|
|
|
|
#endif
|