patch-2.4.2 linux/include/asm-arm/io.h

• Lines: 183
• Date: Thu Feb 8 16:32:44 2001
• Orig file: v2.4.1/linux/include/asm-arm/io.h
• Orig date: Mon Sep 18 15:15:23 2000

diff -u --recursive --new-file v2.4.1/linux/include/asm-arm/io.h linux/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 @@
 #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_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_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 @@
 #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))