diff options
Diffstat (limited to 'include/asm-arm/io.h')
| -rw-r--r-- | include/asm-arm/io.h | 128 |
1 files changed, 99 insertions, 29 deletions
diff --git a/include/asm-arm/io.h b/include/asm-arm/io.h index 707aa9788..1e1d838b7 100644 --- a/include/asm-arm/io.h +++ b/include/asm-arm/io.h @@ -20,10 +20,43 @@ #ifndef __ASM_ARM_IO_H #define __ASM_ARM_IO_H +#ifdef __KERNEL__ + #include <linux/types.h> +#include <asm/memory.h> #include <asm/arch/hardware.h> + +/* + * Generic virtual read/write. Note that we don't support half-word + * read/writes. We define __arch_*[bl] here, and leave __arch_*w + * to the architecture specific code. + */ +#define __arch_getb(a) (*(volatile unsigned char *)(a)) +#define __arch_getl(a) (*(volatile unsigned int *)(a)) + +#define __arch_putb(v,a) (*(volatile unsigned char *)(a) = (v)) +#define __arch_putl(v,a) (*(volatile unsigned int *)(a) = (v)) + +/* + * Now, pick up the machine-defined IO definitions + */ #include <asm/arch/io.h> +/* + * IO definitions. We define {out,in}[bwl] if __io is defined by + * the machine. Otherwise, these definitions are left for the + * machine specific header files to pick up. + */ +#ifdef __io +#define outb(v,p) __arch_putb(v,__io(p)) +#define outw(v,p) __arch_putw(v,__io(p)) +#define outl(v,p) __arch_putl(v,__io(p)) + +#define inb(p) __arch_getb(__io(p)) +#define inw(p) __arch_getw(__io(p)) +#define inl(p) __arch_getl(__io(p)) +#endif + #define outb_p(val,port) outb((val),(port)) #define outw_p(val,port) outw((val),(port)) #define outl_p(val,port) outl((val),(port)) @@ -45,19 +78,34 @@ extern void insl(unsigned int port, void *from, int len); #define insw_p(port,to,len) insw(port,to,len) #define insl_p(port,to,len) insl(port,to,len) -#ifdef __KERNEL__ - -#include <asm/memory.h> - -/* the following macro is depreciated */ -#define ioaddr(port) __ioaddr((port)) - /* - * ioremap and friends + * ioremap and friends. + * + * ioremap takes a PCI memory address, as specified in + * linux/Documentation/IO-mapping.txt. If you want a + * physical address, use __ioremap instead. */ extern void * __ioremap(unsigned long offset, size_t size, unsigned long flags); extern void __iounmap(void *addr); +/* + * Generic ioremap support. + * + * Define: + * iomem_valid_addr(off,size) + * iomem_to_phys(off) + */ +#ifdef iomem_valid_addr +#define __arch_ioremap(off,sz,nocache) \ + ({ \ + unsigned long _off = (off), _size = (sz); \ + void *_ret = (void *)0; \ + if (iomem_valid_addr(_off, _size)) \ + _ret = __ioremap(iomem_to_phys(_off),_size,0); \ + _ret; \ + }) +#endif + #define ioremap(off,sz) __arch_ioremap((off),(sz),0) #define ioremap_nocache(off,sz) __arch_ioremap((off),(sz),1) #define iounmap(_addr) __iounmap(_addr) @@ -72,7 +120,26 @@ extern void *consistent_alloc(int gfp, size_t size, dma_addr_t *handle); extern void consistent_free(void *vaddr); extern void consistent_sync(void *vaddr, size_t size, int rw); -extern void __readwrite_bug(const char *fn); +#define __raw_writeb(v,a) __arch_putb(v,a) +#define __raw_writew(v,a) __arch_putw(v,a) +#define __raw_writel(v,a) __arch_putl(v,a) + +#define __raw_readb(a) __arch_getb(a) +#define __raw_readw(a) __arch_getw(a) +#define __raw_readl(a) __arch_getl(a) + +/* + * The compiler seems to be incapable of optimising constants + * properly. Spell it out to the compiler in some cases. + * These are only valid for small values of "off" (< 1<<12) + */ +#define __raw_base_writeb(val,base,off) __arch_base_putb(val,base,off) +#define __raw_base_writew(val,base,off) __arch_base_putw(val,base,off) +#define __raw_base_writel(val,base,off) __arch_base_putl(val,base,off) + +#define __raw_base_readb(base,off) __arch_base_getb(base,off) +#define __raw_base_readw(base,off) __arch_base_getw(base,off) +#define __raw_base_readl(base,off) __arch_base_getl(base,off) /* * String version of IO memory access ops: @@ -81,26 +148,21 @@ extern void _memcpy_fromio(void *, unsigned long, size_t); extern void _memcpy_toio(unsigned long, const void *, size_t); extern void _memset_io(unsigned long, int, size_t); -#define __raw_writeb(val,addr) __arch_putb(val,addr) -#define __raw_writew(val,addr) __arch_putw(val,addr) -#define __raw_writel(val,addr) __arch_putl(val,addr) - -#define __raw_readb(addr) __arch_getb(addr) -#define __raw_readw(addr) __arch_getw(addr) -#define __raw_readl(addr) __arch_getl(addr) +extern void __readwrite_bug(const char *fn); /* * If this architecture has PCI memory IO, then define the read/write - * macros. + * macros. These should only be used with the cookie passed from + * ioremap. */ #ifdef __mem_pci -#define readb(addr) __arch_getb(__mem_pci(addr)) -#define readw(addr) __arch_getw(__mem_pci(addr)) -#define readl(addr) __arch_getl(__mem_pci(addr)) -#define writeb(val,addr) __arch_putb(val,__mem_pci(addr)) -#define writew(val,addr) __arch_putw(val,__mem_pci(addr)) -#define writel(val,addr) __arch_putl(val,__mem_pci(addr)) +#define readb(addr) __raw_readb(__mem_pci(addr)) +#define readw(addr) __raw_readw(__mem_pci(addr)) +#define readl(addr) __raw_readl(__mem_pci(addr)) +#define writeb(val,addr) __raw_writeb(val,__mem_pci(addr)) +#define writew(val,addr) __raw_writew(val,__mem_pci(addr)) +#define writel(val,addr) __raw_writel(val,__mem_pci(addr)) #define memset_io(a,b,c) _memset_io(__mem_pci(a),(b),(c)) #define memcpy_fromio(a,b,c) _memcpy_fromio((a),__mem_pci(b),(c)) @@ -142,17 +204,25 @@ out: #endif /* __mem_pci */ /* + * remap a physical address `phys' of size `size' with page protection `prot' + * into virtual address `from' + */ +#define io_remap_page_range(from,phys,size,prot) \ + remap_page_range(from,phys,size,prot) + + +/* * If this architecture has ISA IO, then define the isa_read/isa_write * macros. */ #ifdef __mem_isa -#define isa_readb(addr) __arch_getb(__mem_isa(addr)) -#define isa_readw(addr) __arch_getw(__mem_isa(addr)) -#define isa_readl(addr) __arch_getl(__mem_isa(addr)) -#define isa_writeb(val,addr) __arch_putb(val,__mem_isa(addr)) -#define isa_writew(val,addr) __arch_putw(val,__mem_isa(addr)) -#define isa_writel(val,addr) __arch_putl(val,__mem_isa(addr)) +#define isa_readb(addr) __raw_readb(__mem_isa(addr)) +#define isa_readw(addr) __raw_readw(__mem_isa(addr)) +#define isa_readl(addr) __raw_readl(__mem_isa(addr)) +#define isa_writeb(val,addr) __raw_writeb(val,__mem_isa(addr)) +#define isa_writew(val,addr) __raw_writew(val,__mem_isa(addr)) +#define isa_writel(val,addr) __raw_writel(val,__mem_isa(addr)) #define isa_memset_io(a,b,c) _memset_io(__mem_isa(a),(b),(c)) #define isa_memcpy_fromio(a,b,c) _memcpy_fromio((a),__mem_isa(b),(c)) #define isa_memcpy_toio(a,b,c) _memcpy_toio(__mem_isa((a)),(b),(c)) |