x86: MMIO and gcc re-ordering issue
On Tue, 27 May 2008, Linus Torvalds wrote: > > Expecting people to fix up all drivers is simply not going to happen. And > serializing things shouldn't be *that* expensive. People who cannot take > the expense can continue to use the magic __raw_writel() etc stuff. Of course, for non-x86, you kind of have to expect drivers to be well-behaved, so non-x86 can probably avoid this simply because there are less relevant drivers involved. Here's a UNTESTED patch for x86 that may or may not compile and work, and which serializes (on a compiler level) the IO accesses against regular memory accesses. __read[bwlq]()/__write[bwlq]() are not serialized with a :"memory" barrier, although since they still use "asm volatile" I suspect that i practice they are probably serial too. Did not look very closely at any generated code (only did a trivial test to see that the code looks *roughly* correct). Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Linus Torvalds
Ingo Molnar
parent
1beee8dc8c
commit
c1f64a5800
|
|
@ -3,6 +3,62 @@
|
|||
|
||||
#define ARCH_HAS_IOREMAP_WC
|
||||
|
||||
#include <linux/compiler.h>
|
||||
|
||||
#define build_mmio_read(name, size, type, reg, barrier) \
|
||||
static inline type name(const volatile void __iomem *addr) \
|
||||
{ type ret; asm volatile("mov" size " %1,%0":"=" reg (ret) \
|
||||
:"m" (*(volatile type __force *)addr) barrier); return ret; }
|
||||
|
||||
#define build_mmio_write(name, size, type, reg, barrier) \
|
||||
static inline void name(type val, volatile void __iomem *addr) \
|
||||
{ asm volatile("mov" size " %0,%1": :reg (val), \
|
||||
"m" (*(volatile type __force *)addr) barrier); }
|
||||
|
||||
build_mmio_read(readb, "b", unsigned char, "q", :"memory")
|
||||
build_mmio_read(readw, "w", unsigned short, "r", :"memory")
|
||||
build_mmio_read(readl, "l", unsigned int, "r", :"memory")
|
||||
|
||||
build_mmio_read(__readb, "b", unsigned char, "q", )
|
||||
build_mmio_read(__readw, "w", unsigned short, "r", )
|
||||
build_mmio_read(__readl, "l", unsigned int, "r", )
|
||||
|
||||
build_mmio_write(writeb, "b", unsigned char, "q", :"memory")
|
||||
build_mmio_write(writew, "w", unsigned short, "r", :"memory")
|
||||
build_mmio_write(writel, "l", unsigned int, "r", :"memory")
|
||||
|
||||
build_mmio_write(__writeb, "b", unsigned char, "q", )
|
||||
build_mmio_write(__writew, "w", unsigned short, "r", )
|
||||
build_mmio_write(__writel, "l", unsigned int, "r", )
|
||||
|
||||
#define readb_relaxed(a) __readb(a)
|
||||
#define readw_relaxed(a) __readw(a)
|
||||
#define readl_relaxed(a) __readl(a)
|
||||
#define __raw_readb __readb
|
||||
#define __raw_readw __readw
|
||||
#define __raw_readl __readl
|
||||
|
||||
#define __raw_writeb __writeb
|
||||
#define __raw_writew __writew
|
||||
#define __raw_writel __writel
|
||||
|
||||
#define mmiowb() barrier()
|
||||
|
||||
#ifdef CONFIG_X86_64
|
||||
build_mmio_read(readq, "q", unsigned long, "r", :"memory")
|
||||
build_mmio_read(__readq, "q", unsigned long, "r", )
|
||||
build_mmio_write(writeq, "q", unsigned long, "r", :"memory")
|
||||
build_mmio_write(__writeq, "q", unsigned long, "r", )
|
||||
|
||||
#define readq_relaxed(a) __readq(a)
|
||||
#define __raw_readq __readq
|
||||
#define __raw_writeq writeq
|
||||
|
||||
/* Let people know we have them */
|
||||
#define readq readq
|
||||
#define writeq writeq
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_X86_32
|
||||
# include "io_32.h"
|
||||
#else
|
||||
|
|
|
|||
|
|
@ -149,55 +149,6 @@ extern void __iomem *fix_ioremap(unsigned idx, unsigned long phys);
|
|||
#define virt_to_bus virt_to_phys
|
||||
#define bus_to_virt phys_to_virt
|
||||
|
||||
/*
|
||||
* readX/writeX() are used to access memory mapped devices. On some
|
||||
* architectures the memory mapped IO stuff needs to be accessed
|
||||
* differently. On the x86 architecture, we just read/write the
|
||||
* memory location directly.
|
||||
*/
|
||||
|
||||
static inline unsigned char readb(const volatile void __iomem *addr)
|
||||
{
|
||||
return *(volatile unsigned char __force *)addr;
|
||||
}
|
||||
|
||||
static inline unsigned short readw(const volatile void __iomem *addr)
|
||||
{
|
||||
return *(volatile unsigned short __force *)addr;
|
||||
}
|
||||
|
||||
static inline unsigned int readl(const volatile void __iomem *addr)
|
||||
{
|
||||
return *(volatile unsigned int __force *) addr;
|
||||
}
|
||||
|
||||
#define readb_relaxed(addr) readb(addr)
|
||||
#define readw_relaxed(addr) readw(addr)
|
||||
#define readl_relaxed(addr) readl(addr)
|
||||
#define __raw_readb readb
|
||||
#define __raw_readw readw
|
||||
#define __raw_readl readl
|
||||
|
||||
static inline void writeb(unsigned char b, volatile void __iomem *addr)
|
||||
{
|
||||
*(volatile unsigned char __force *)addr = b;
|
||||
}
|
||||
|
||||
static inline void writew(unsigned short b, volatile void __iomem *addr)
|
||||
{
|
||||
*(volatile unsigned short __force *)addr = b;
|
||||
}
|
||||
|
||||
static inline void writel(unsigned int b, volatile void __iomem *addr)
|
||||
{
|
||||
*(volatile unsigned int __force *)addr = b;
|
||||
}
|
||||
#define __raw_writeb writeb
|
||||
#define __raw_writew writew
|
||||
#define __raw_writel writel
|
||||
|
||||
#define mmiowb()
|
||||
|
||||
static inline void
|
||||
memset_io(volatile void __iomem *addr, unsigned char val, int count)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -204,77 +204,6 @@ extern void __iomem *fix_ioremap(unsigned idx, unsigned long phys);
|
|||
#define virt_to_bus virt_to_phys
|
||||
#define bus_to_virt phys_to_virt
|
||||
|
||||
/*
|
||||
* readX/writeX() are used to access memory mapped devices. On some
|
||||
* architectures the memory mapped IO stuff needs to be accessed
|
||||
* differently. On the x86 architecture, we just read/write the
|
||||
* memory location directly.
|
||||
*/
|
||||
|
||||
static inline __u8 __readb(const volatile void __iomem *addr)
|
||||
{
|
||||
return *(__force volatile __u8 *)addr;
|
||||
}
|
||||
|
||||
static inline __u16 __readw(const volatile void __iomem *addr)
|
||||
{
|
||||
return *(__force volatile __u16 *)addr;
|
||||
}
|
||||
|
||||
static __always_inline __u32 __readl(const volatile void __iomem *addr)
|
||||
{
|
||||
return *(__force volatile __u32 *)addr;
|
||||
}
|
||||
|
||||
static inline __u64 __readq(const volatile void __iomem *addr)
|
||||
{
|
||||
return *(__force volatile __u64 *)addr;
|
||||
}
|
||||
|
||||
#define readb(x) __readb(x)
|
||||
#define readw(x) __readw(x)
|
||||
#define readl(x) __readl(x)
|
||||
#define readq(x) __readq(x)
|
||||
#define readb_relaxed(a) readb(a)
|
||||
#define readw_relaxed(a) readw(a)
|
||||
#define readl_relaxed(a) readl(a)
|
||||
#define readq_relaxed(a) readq(a)
|
||||
#define __raw_readb readb
|
||||
#define __raw_readw readw
|
||||
#define __raw_readl readl
|
||||
#define __raw_readq readq
|
||||
|
||||
#define mmiowb()
|
||||
|
||||
static inline void __writel(__u32 b, volatile void __iomem *addr)
|
||||
{
|
||||
*(__force volatile __u32 *)addr = b;
|
||||
}
|
||||
|
||||
static inline void __writeq(__u64 b, volatile void __iomem *addr)
|
||||
{
|
||||
*(__force volatile __u64 *)addr = b;
|
||||
}
|
||||
|
||||
static inline void __writeb(__u8 b, volatile void __iomem *addr)
|
||||
{
|
||||
*(__force volatile __u8 *)addr = b;
|
||||
}
|
||||
|
||||
static inline void __writew(__u16 b, volatile void __iomem *addr)
|
||||
{
|
||||
*(__force volatile __u16 *)addr = b;
|
||||
}
|
||||
|
||||
#define writeq(val, addr) __writeq((val), (addr))
|
||||
#define writel(val, addr) __writel((val), (addr))
|
||||
#define writew(val, addr) __writew((val), (addr))
|
||||
#define writeb(val, addr) __writeb((val), (addr))
|
||||
#define __raw_writeb writeb
|
||||
#define __raw_writew writew
|
||||
#define __raw_writel writel
|
||||
#define __raw_writeq writeq
|
||||
|
||||
void __memcpy_fromio(void *, unsigned long, unsigned);
|
||||
void __memcpy_toio(unsigned long, const void *, unsigned);
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue