[SPARC]: Make io.h macros more resiliant.

Several drivers do things like undefine inb et al. in order
to switch between using I/O and MEM operations.  The Sparc
io.h macros did not cope with this well, so fix that up.

diff --git a/include/asm-sparc/io.h b/include/asm-sparc/io.h
index 47335e03c11a0df2a78c82a2f257176d466c38cf..72c304cad644a8c9b2cfd25e2265e6439b9b05f8 100644 (file)
--- a/include/asm-sparc/io.h
+++ b/include/asm-sparc/io.h
@@ -13,12 +13,12 @@
 
 #define page_to_phys(page)     ((page - mem_map) << PAGE_SHIFT)
 
-static __inline__ u32 flip_dword (u32 d)
+static inline u32 flip_dword (u32 d)
 {
        return ((d&0xff)<<24) | (((d>>8)&0xff)<<16) | (((d>>16)&0xff)<<8)| ((d>>24)&0xff);
 }
 
-static __inline__ u16 flip_word (u16 d)
+static inline u16 flip_word (u16 d)
 {
        return ((d&0xff) << 8) | ((d>>8)&0xff);
 }
@@ -36,43 +36,73 @@ static __inline__ u16 flip_word (u16 d)
  * The offshot is, we must cast readb et. al. arguments with a #define.
  */
 
-static __inline__ u8 __raw_readb(unsigned long addr)
+static inline u8 __raw_readb(unsigned long addr)
 {
        return *(volatile u8 *)addr;
 }
 
-static __inline__ u16 __raw_readw(unsigned long addr)
+static inline u16 __raw_readw(unsigned long addr)
 {
        return *(volatile u16 *)addr;
 }
 
-static __inline__ u32 __raw_readl(unsigned long addr)
+static inline u32 __raw_readl(unsigned long addr)
 {
        return *(volatile u32 *)addr;
 }
 
-static __inline__ void __raw_writeb(u8 b, unsigned long addr)
+static inline void __raw_writeb(u8 b, unsigned long addr)
 {
        *(volatile u8 *)addr = b;
 }
 
-static __inline__ void __raw_writew(u16 b, unsigned long addr)
+static inline void __raw_writew(u16 b, unsigned long addr)
 {
        *(volatile u16 *)addr = b;
 }
 
-static __inline__ void __raw_writel(u32 b, unsigned long addr)
+static inline void __raw_writel(u32 b, unsigned long addr)
 {
        *(volatile u32 *)addr = b;
 }
 
-#define readb(addr)    (*(volatile u8 *)(addr))
-#define readw(addr)    flip_word(*(volatile u16 *)(addr))
-#define readl(addr)    flip_dword(*(volatile u32 *)(addr))
+static inline u8 __readb(unsigned long addr)
+{
+       return *(volatile u8 *)addr;
+}
+
+static inline u16 __readw(unsigned long addr)
+{
+       return flip_word(*(volatile u16 *)addr);
+}
+
+static inline u32 __readl(unsigned long addr)
+{
+       return flip_dword(*(volatile u32 *)addr);
+}
+
+static inline void __writeb(u8 b, unsigned long addr)
+{
+       *(volatile u8 *)addr = b;
+}
+
+static inline void __writew(u16 b, unsigned long addr)
+{
+       *(volatile u16 *)addr = flip_word(b);
+}
+
+static inline void __writel(u32 b, unsigned long addr)
+{
+       *(volatile u32 *)addr = flip_dword(b);
+}
+
+#define readb(addr)    __readb((unsigned long)(addr))
+#define readw(addr)    __readw((unsigned long)(addr))
+#define readl(addr)    __readl((unsigned long)(addr))
 
-#define writeb(b, a)   (*(volatile u8 *)(a) = b)
-#define writew(b, a)   (*(volatile u16 *)(a) = flip_word(b))
-#define writel(b, a)   (*(volatile u32 *)(a) = flip_dword(b))
+#define writeb(b, addr)        __writeb((b),(unsigned long)(addr))
+#define writew(b, addr)        __writew((b),(unsigned long)(addr))
+#define writel(b, addr)        __writel((b),(unsigned long)(addr))
 
 /*
  * I/O space operations
@@ -91,15 +121,15 @@ static __inline__ void __raw_writel(u32 b, unsigned long addr)
  * mapped somewhere into virtual kernel space and we
  * can use inb/outb again.
  */
-#define inb_local(addr)                readb(addr)
-#define inb(addr)              readb(addr)
-#define inw(addr)              readw(addr)
-#define inl(addr)              readl(addr)
+#define inb_local(addr)                __readb(addr)
+#define inb(addr)              __readb(addr)
+#define inw(addr)              __readw(addr)
+#define inl(addr)              __readl(addr)
 
-#define outb_local(b, addr)    writeb(b, addr)
-#define outb(b, addr)          writeb(b, addr)
-#define outw(b, addr)          writew(b, addr)
-#define outl(b, addr)          writel(b, addr)
+#define outb_local(b, addr)    __writeb(b, addr)
+#define outb(b, addr)          __writeb(b, addr)
+#define outw(b, addr)          __writew(b, addr)
+#define outl(b, addr)          __writel(b, addr)
 
 #define inb_p inb
 #define outb_p outb
@@ -123,32 +153,32 @@ extern void insl(unsigned long addr, void *dst, unsigned long count);
  * SBus has only one, memory mapped, I/O space.
  * We do not need to flip bytes for SBus of course.
  */
-static __inline__ u8 _sbus_readb(unsigned long addr)
+static inline u8 _sbus_readb(unsigned long addr)
 {
        return *(volatile u8 *)addr;
 }
 
-static __inline__ u16 _sbus_readw(unsigned long addr)
+static inline u16 _sbus_readw(unsigned long addr)
 {
        return *(volatile u16 *)addr;
 }
 
-static __inline__ u32 _sbus_readl(unsigned long addr)
+static inline u32 _sbus_readl(unsigned long addr)
 {
        return *(volatile u32 *)addr;
 }
 
-static __inline__ void _sbus_writeb(u8 b, unsigned long addr)
+static inline void _sbus_writeb(u8 b, unsigned long addr)
 {
        *(volatile u8 *)addr = b;
 }
 
-static __inline__ void _sbus_writew(u16 b, unsigned long addr)
+static inline void _sbus_writew(u16 b, unsigned long addr)
 {
        *(volatile u16 *)addr = b;
 }
 
-static __inline__ void _sbus_writel(u32 b, unsigned long addr)
+static inline void _sbus_writel(u32 b, unsigned long addr)
 {
        *(volatile u32 *)addr = b;
 }