[deliverable/linux.git] / arch / arm / mm / ioremap.c

/*
 *  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>

#include <asm/cacheflush.h>
#include <asm/io.h>
#include <asm/tlbflush.h>

static inline void
remap_area_pte(pte_t * pte, unsigned long address, unsigned long size,
	       unsigned long phys_addr, pgprot_t pgprot)
{
	unsigned long end;

	address &= ~PMD_MASK;
	end = address + size;
	if (end > PMD_SIZE)
		end = PMD_SIZE;
	BUG_ON(address >= end);
	do {
		if (!pte_none(*pte))
			goto bad;

		set_pte(pte, pfn_pte(phys_addr >> PAGE_SHIFT, pgprot));
		address += PAGE_SIZE;
		phys_addr += PAGE_SIZE;
		pte++;
	} while (address && (address < end));
	return;

 bad:
	printk("remap_area_pte: page already exists\n");
	BUG();
}

static inline int
remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size,
	       unsigned long phys_addr, unsigned long flags)
{
	unsigned long end;
	pgprot_t pgprot;

	address &= ~PGDIR_MASK;
	end = address + size;

	if (end > PGDIR_SIZE)
		end = PGDIR_SIZE;

	phys_addr -= address;
	BUG_ON(address >= end);

	pgprot = __pgprot(L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY | L_PTE_WRITE | flags);
	do {
		pte_t * pte = pte_alloc_kernel(pmd, address);
		if (!pte)
			return -ENOMEM;
		remap_area_pte(pte, address, end - address, address + phys_addr, pgprot);
		address = (address + PMD_SIZE) & PMD_MASK;
		pmd++;
	} while (address && (address < end));
	return 0;
}

static int
remap_area_pages(unsigned long start, unsigned long pfn,
		 unsigned long size, unsigned long flags)
{
	unsigned long address = start;
	unsigned long end = start + size;
	unsigned long phys_addr = __pfn_to_phys(pfn);
	int err = 0;
	pgd_t * dir;

	phys_addr -= address;
	dir = pgd_offset(&init_mm, address);
	BUG_ON(address >= end);
	do {
		pmd_t *pmd = pmd_alloc(&init_mm, dir, address);
		if (!pmd) {
			err = -ENOMEM;
			break;
		}
		if (remap_area_pmd(pmd, address, end - address,
					 phys_addr + address, flags)) {
			err = -ENOMEM;
			break;
		}

		address = (address + PGDIR_SIZE) & PGDIR_MASK;
		dir++;
	} while (address && (address < end));

	flush_cache_vmap(start, end);
	return err;
}

/*
 * 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.
 *
 * 'flags' are the extra L_PTE_ flags that you want to specify for this
 * mapping.  See include/asm-arm/proc-armv/pgtable.h for more information.
 */
void __iomem *
__ioremap_pfn(unsigned long pfn, unsigned long offset, size_t size,
	      unsigned long flags)
{
	unsigned long addr;
 	struct vm_struct * area;

 	area = get_vm_area(size, VM_IOREMAP);
 	if (!area)
 		return NULL;
 	addr = (unsigned long)area->addr;
 	if (remap_area_pages(addr, pfn, size, flags)) {
 		vfree((void *)addr);
 		return NULL;
 	}
 	return (void __iomem *) (offset + (char *)addr);
}
EXPORT_SYMBOL(__ioremap_pfn);

void __iomem *
__ioremap(unsigned long phys_addr, size_t size, unsigned long flags)
{
	unsigned long last_addr;
 	unsigned long offset = phys_addr & ~PAGE_MASK;
 	unsigned long pfn = __phys_to_pfn(phys_addr);

 	/*
 	 * Don't allow wraparound or zero size
	 */
	last_addr = phys_addr + size - 1;
	if (!size || last_addr < phys_addr)
		return NULL;

	/*
 	 * Page align the mapping size
	 */
	size = PAGE_ALIGN(last_addr + 1) - phys_addr;

 	return __ioremap_pfn(pfn, offset, size, flags);
}
EXPORT_SYMBOL(__ioremap);

void __iounmap(void __iomem *addr)
{
	vfree((void *) (PAGE_MASK & (unsigned long) addr));
}
EXPORT_SYMBOL(__iounmap);

#ifdef __io
void __iomem *ioport_map(unsigned long port, unsigned int nr)
{
	return __io(port);
}
EXPORT_SYMBOL(ioport_map);

void ioport_unmap(void __iomem *addr)
{
}
EXPORT_SYMBOL(ioport_unmap);
#endif

#ifdef CONFIG_PCI
#include <linux/pci.h>
#include <linux/ioport.h>

void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)
{
	unsigned long start = pci_resource_start(dev, bar);
	unsigned long len   = pci_resource_len(dev, bar);
	unsigned long flags = pci_resource_flags(dev, bar);

	if (!len || !start)
		return NULL;
	if (maxlen && len > maxlen)
		len = maxlen;
	if (flags & IORESOURCE_IO)
		return ioport_map(start, len);
	if (flags & IORESOURCE_MEM) {
		if (flags & IORESOURCE_CACHEABLE)
			return ioremap(start, len);
		return ioremap_nocache(start, len);
	}
	return NULL;
}
EXPORT_SYMBOL(pci_iomap);

void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
{
	if ((unsigned long)addr >= VMALLOC_START &&
	    (unsigned long)addr < VMALLOC_END)
		iounmap(addr);
}
EXPORT_SYMBOL(pci_iounmap);
#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/arch/arm/mm/ioremap.c
	3	*
	4	* Re-map IO memory to kernel address space so that we can access it.
	5	*
	6	* (C) Copyright 1995 1996 Linus Torvalds
	7	*
	8	* Hacked for ARM by Phil Blundell <philb@gnu.org>
	9	* Hacked to allow all architectures to build, and various cleanups
	10	* by Russell King
	11	*
	12	* This allows a driver to remap an arbitrary region of bus memory into
	13	* virtual space. One should only use readl, writel, memcpy_toio and
	14	* so on with such remapped areas.
	15	*
	16	* Because the ARM only has a 32-bit address space we can't address the
	17	* whole of the (physical) PCI space at once. PCI huge-mode addressing
	18	* allows us to circumvent this restriction by splitting PCI space into
	19	* two 2GB chunks and mapping only one at a time into processor memory.
	20	* We use MMU protection domains to trap any attempt to access the bank
	21	* that is not currently mapped. (This isn't fully implemented yet.)
	22	*/
	23	#include <linux/module.h>
	24	#include <linux/errno.h>
	25	#include <linux/mm.h>
	26	#include <linux/vmalloc.h>
	27
	28	#include <asm/cacheflush.h>
	29	#include <asm/io.h>
	30	#include <asm/tlbflush.h>
	31
	32	static inline void
	33	remap_area_pte(pte_t * pte, unsigned long address, unsigned long size,
	34	unsigned long phys_addr, pgprot_t pgprot)
	35	{
	36	unsigned long end;
	37
	38	address &= ~PMD_MASK;
	39	end = address + size;
	40	if (end > PMD_SIZE)
	41	end = PMD_SIZE;
	42	BUG_ON(address >= end);
	43	do {
	44	if (!pte_none(*pte))
	45	goto bad;
	46
	47	set_pte(pte, pfn_pte(phys_addr >> PAGE_SHIFT, pgprot));
	48	address += PAGE_SIZE;
	49	phys_addr += PAGE_SIZE;
	50	pte++;
	51	} while (address && (address < end));
	52	return;
	53
	54	bad:
	55	printk("remap_area_pte: page already exists\n");
	56	BUG();
	57	}
	58
	59	static inline int
	60	remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size,
	61	unsigned long phys_addr, unsigned long flags)
	62	{
	63	unsigned long end;
	64	pgprot_t pgprot;
65
66	address &= ~PGDIR_MASK;
67	end = address + size;
68
69	if (end > PGDIR_SIZE)
70	end = PGDIR_SIZE;
71
72	phys_addr -= address;
73	BUG_ON(address >= end);
74
75	pgprot = __pgprot(L_PTE_PRESENT \| L_PTE_YOUNG \| L_PTE_DIRTY \| L_PTE_WRITE \| flags);
76	do {
872fec16	77	pte_t * pte = pte_alloc_kernel(pmd, address);
1da177e4 LT	78	if (!pte)
	79	return -ENOMEM;
	80	remap_area_pte(pte, address, end - address, address + phys_addr, pgprot);
	81	address = (address + PMD_SIZE) & PMD_MASK;
	82	pmd++;
	83	} while (address && (address < end));
	84	return 0;
	85	}
	86
	87	static int
9d4ae727	88	remap_area_pages(unsigned long start, unsigned long pfn,
1da177e4 LT	89	unsigned long size, unsigned long flags)
	90	{
	91	unsigned long address = start;
	92	unsigned long end = start + size;
9d4ae727	93	unsigned long phys_addr = __pfn_to_phys(pfn);
1da177e4 LT	94	int err = 0;
	95	pgd_t * dir;
	96
	97	phys_addr -= address;
	98	dir = pgd_offset(&init_mm, address);
	99	BUG_ON(address >= end);
1da177e4 LT	100	do {
	101	pmd_t *pmd = pmd_alloc(&init_mm, dir, address);
	102	if (!pmd) {
	103	err = -ENOMEM;
	104	break;
	105	}
	106	if (remap_area_pmd(pmd, address, end - address,
	107	phys_addr + address, flags)) {
	108	err = -ENOMEM;
	109	break;
	110	}
	111
	112	address = (address + PGDIR_SIZE) & PGDIR_MASK;
	113	dir++;
	114	} while (address && (address < end));
	115
1da177e4 LT	116	flush_cache_vmap(start, end);
	117	return err;
	118	}
	119
	120	/*
	121	* Remap an arbitrary physical address space into the kernel virtual
	122	* address space. Needed when the kernel wants to access high addresses
	123	* directly.
	124	*
	125	* NOTE! We need to allow non-page-aligned mappings too: we will obviously
	126	* have to convert them into an offset in a page-aligned mapping, but the
	127	* caller shouldn't need to know that small detail.
	128	*
	129	* 'flags' are the extra L_PTE_ flags that you want to specify for this
	130	* mapping. See include/asm-arm/proc-armv/pgtable.h for more information.
	131	*/
9d4ae727 DS	132	void __iomem *
	133	__ioremap_pfn(unsigned long pfn, unsigned long offset, size_t size,
	134	unsigned long flags)
	135	{
	136	unsigned long addr;
	137	struct vm_struct * area;
	138
	139	area = get_vm_area(size, VM_IOREMAP);
	140	if (!area)
	141	return NULL;
	142	addr = (unsigned long)area->addr;
	143	if (remap_area_pages(addr, pfn, size, flags)) {
20a2c88f	144	vfree((void *)addr);
9d4ae727 DS	145	return NULL;
	146	}
	147	return (void __iomem ) (offset + (char )addr);
	148	}
	149	EXPORT_SYMBOL(__ioremap_pfn);
	150
1da177e4	151	void __iomem *
67a1901f	152	__ioremap(unsigned long phys_addr, size_t size, unsigned long flags)
1da177e4	153	{
9d4ae727 DS	154	unsigned long last_addr;
	155	unsigned long offset = phys_addr & ~PAGE_MASK;
	156	unsigned long pfn = __phys_to_pfn(phys_addr);
1da177e4	157
9d4ae727 DS	158	/*
	159	* Don't allow wraparound or zero size
	160	*/
1da177e4 LT	161	last_addr = phys_addr + size - 1;
	162	if (!size \|\| last_addr < phys_addr)
	163	return NULL;
	164
	165	/*
9d4ae727	166	* Page align the mapping size
1da177e4	167	*/
1da177e4 LT	168	size = PAGE_ALIGN(last_addr + 1) - phys_addr;
1da177e4 LT	169
9d4ae727	170	return __ioremap_pfn(pfn, offset, size, flags);
1da177e4 LT	171	}
	172	EXPORT_SYMBOL(__ioremap);
	173
	174	void __iounmap(void __iomem *addr)
	175	{
	176	vfree((void *) (PAGE_MASK & (unsigned long) addr));
	177	}
	178	EXPORT_SYMBOL(__iounmap);
09f0551d RK	179
	180	#ifdef __io
	181	void __iomem *ioport_map(unsigned long port, unsigned int nr)
	182	{
	183	return __io(port);
	184	}
	185	EXPORT_SYMBOL(ioport_map);
	186
	187	void ioport_unmap(void __iomem *addr)
	188	{
	189	}
	190	EXPORT_SYMBOL(ioport_unmap);
	191	#endif
	192
	193	#ifdef CONFIG_PCI
	194	#include <linux/pci.h>
	195	#include <linux/ioport.h>
	196
	197	void __iomem pci_iomap(struct pci_dev dev, int bar, unsigned long maxlen)
	198	{
	199	unsigned long start = pci_resource_start(dev, bar);
	200	unsigned long len = pci_resource_len(dev, bar);
	201	unsigned long flags = pci_resource_flags(dev, bar);
	202
	203	if (!len \|\| !start)
	204	return NULL;
	205	if (maxlen && len > maxlen)
	206	len = maxlen;
	207	if (flags & IORESOURCE_IO)
	208	return ioport_map(start, len);
	209	if (flags & IORESOURCE_MEM) {
	210	if (flags & IORESOURCE_CACHEABLE)
	211	return ioremap(start, len);
	212	return ioremap_nocache(start, len);
	213	}
	214	return NULL;
	215	}
	216	EXPORT_SYMBOL(pci_iomap);
	217
	218	void pci_iounmap(struct pci_dev dev, void __iomem addr)
	219	{
	220	if ((unsigned long)addr >= VMALLOC_START &&
	221	(unsigned long)addr < VMALLOC_END)
	222	iounmap(addr);
	223	}
	224	EXPORT_SYMBOL(pci_iounmap);
	225	#endif