From fc49a434c975a55d6c009771be66fd5a879f5f50 Mon Sep 17 00:00:00 2001 From: "David S. Miller" Date: Tue, 14 Oct 2003 04:10:14 -0700 Subject: [PATCH] [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. --- include/asm-sparc/io.h | 86 ++++++++++++++++++++++++++++-------------- 1 file changed, 58 insertions(+), 28 deletions(-) diff --git a/include/asm-sparc/io.h b/include/asm-sparc/io.h index 47335e03c11a0..72c304cad644a 100644 --- 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; } -- 2.53.0