[POWERPC] Allow hooking of PCI MMIO & PIO accessors on 64 bits

This patch reworks the way iSeries hooks on PCI IO operations (both MMIO
and PIO) and provides a generic way for other platforms to do so (we
have need to do that for various other platforms).

While reworking the IO ops, I ended up doing some spring cleaning in
io.h and eeh.h which I might want to split into 2 or 3 patches (among
others, eeh.h had a lot of useless stuff in it).

A side effect is that EEH for PIO should work now (it used to pass IO
ports down to the eeh address check functions which is bogus).

Also, new are MMIO "repeat" ops, which other archs like ARM already had,
and that we have too now: readsb, readsw, readsl, writesb, writesw,
writesl.

In the long run, I might also make EEH use the hooks instead
of wrapping at the toplevel, which would make things even cleaner and
relegate EEH completely in platforms/iseries, but we have to measure the
performance impact there (though it's really only on MMIO reads)

Since I also need to hook on ioremap, I shuffled the functions a bit
there. I introduced ioremap_flags() to use by drivers who want to pass
explicit flags to ioremap (and it can be hooked). The old __ioremap() is
still there as a low level and cannot be hooked, thus drivers who use it
should migrate unless they know they want the low level version.

The patch "arch provides generic iomap missing accessors" (should be
number 4 in this series) is a pre-requisite to provide full iomap
API support with this patch.

Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>

1 files changed, 27 insertions, 91 deletions

diff --git a/include/asm-powerpc/eeh.h b/include/asm-powerpc/eeh.h
index 6a784396660b..66481bbf270a 100644
--- a/include/asm-powerpc/eeh.h
+++ b/include/asm-powerpc/eeh.h
@@ -120,10 +120,6 @@ static inline u8 eeh_readb(const volatile void __iomem *addr)
                 return eeh_check_failure(addr, val);
         return val;
 }
-static inline void eeh_writeb(u8 val, volatile void __iomem *addr)
-{
-        out_8(addr, val);
-}
 
 static inline u16 eeh_readw(const volatile void __iomem *addr)
 {
@@ -132,21 +128,6 @@ static inline u16 eeh_readw(const volatile void __iomem *addr)
                 return eeh_check_failure(addr, val);
         return val;
 }
-static inline void eeh_writew(u16 val, volatile void __iomem *addr)
-{
-        out_le16(addr, val);
-}
-static inline u16 eeh_raw_readw(const volatile void __iomem *addr)
-{
-        u16 val = in_be16(addr);
-        if (EEH_POSSIBLE_ERROR(val, u16))
-                return eeh_check_failure(addr, val);
-        return val;
-}
-static inline void eeh_raw_writew(u16 val, volatile void __iomem *addr) {
-        volatile u16 __iomem *vaddr = (volatile u16 __iomem *) addr;
-        out_be16(vaddr, val);
-}
 
 static inline u32 eeh_readl(const volatile void __iomem *addr)
 {
@@ -155,44 +136,38 @@ static inline u32 eeh_readl(const volatile void __iomem *addr)
                 return eeh_check_failure(addr, val);
         return val;
 }
-static inline void eeh_writel(u32 val, volatile void __iomem *addr)
-{
-        out_le32(addr, val);
-}
-static inline u32 eeh_raw_readl(const volatile void __iomem *addr)
+
+static inline u64 eeh_readq(const volatile void __iomem *addr)
 {
-        u32 val = in_be32(addr);
-        if (EEH_POSSIBLE_ERROR(val, u32))
+        u64 val = in_le64(addr);
+        if (EEH_POSSIBLE_ERROR(val, u64))
                 return eeh_check_failure(addr, val);
         return val;
 }
-static inline void eeh_raw_writel(u32 val, volatile void __iomem *addr)
-{
-        out_be32(addr, val);
-}
 
-static inline u64 eeh_readq(const volatile void __iomem *addr)
+static inline u16 eeh_readw_be(const volatile void __iomem *addr)
 {
-        u64 val = in_le64(addr);
-        if (EEH_POSSIBLE_ERROR(val, u64))
+        u16 val = in_be16(addr);
+        if (EEH_POSSIBLE_ERROR(val, u16))
                 return eeh_check_failure(addr, val);
         return val;
 }
-static inline void eeh_writeq(u64 val, volatile void __iomem *addr)
+
+static inline u32 eeh_readl_be(const volatile void __iomem *addr)
 {
-        out_le64(addr, val);
+        u32 val = in_be32(addr);
+        if (EEH_POSSIBLE_ERROR(val, u32))
+                return eeh_check_failure(addr, val);
+        return val;
 }
-static inline u64 eeh_raw_readq(const volatile void __iomem *addr)
+
+static inline u64 eeh_readq_be(const volatile void __iomem *addr)
 {
         u64 val = in_be64(addr);
         if (EEH_POSSIBLE_ERROR(val, u64))
                 return eeh_check_failure(addr, val);
         return val;
 }
-static inline void eeh_raw_writeq(u64 val, volatile void __iomem *addr)
-{
-        out_be64(addr, val);
-}
 
 #define EEH_CHECK_ALIGN(v,a) \
         ((((unsigned long)(v)) & ((a) - 1)) == 0)
@@ -292,68 +267,29 @@ static inline void eeh_memcpy_toio(volatile void __iomem *dest, const void *src,
 
 #undef EEH_CHECK_ALIGN
 
-static inline u8 eeh_inb(unsigned long port)
-{
-        u8 val;
-        val = in_8((u8 __iomem *)(port+pci_io_base));
-        if (EEH_POSSIBLE_ERROR(val, u8))
-                return eeh_check_failure((void __iomem *)(port), val);
-        return val;
-}
-
-static inline void eeh_outb(u8 val, unsigned long port)
-{
-        out_8((u8 __iomem *)(port+pci_io_base), val);
-}
-
-static inline u16 eeh_inw(unsigned long port)
-{
-        u16 val;
-        val = in_le16((u16 __iomem *)(port+pci_io_base));
-        if (EEH_POSSIBLE_ERROR(val, u16))
-                return eeh_check_failure((void __iomem *)(port), val);
-        return val;
-}
-
-static inline void eeh_outw(u16 val, unsigned long port)
-{
-        out_le16((u16 __iomem *)(port+pci_io_base), val);
-}
-
-static inline u32 eeh_inl(unsigned long port)
-{
-        u32 val;
-        val = in_le32((u32 __iomem *)(port+pci_io_base));
-        if (EEH_POSSIBLE_ERROR(val, u32))
-                return eeh_check_failure((void __iomem *)(port), val);
-        return val;
-}
-
-static inline void eeh_outl(u32 val, unsigned long port)
-{
-        out_le32((u32 __iomem *)(port+pci_io_base), val);
-}
-
 /* in-string eeh macros */
-static inline void eeh_insb(unsigned long port, void * buf, int ns)
+static inline void eeh_readsb(const volatile void __iomem *addr, void * buf,
+                              int ns)
 {
-        _insb((u8 __iomem *)(port+pci_io_base), buf, ns);
+        _insb(addr, buf, ns);
         if (EEH_POSSIBLE_ERROR((*(((u8*)buf)+ns-1)), u8))
-                eeh_check_failure((void __iomem *)(port), *(u8*)buf);
+                eeh_check_failure(addr, *(u8*)buf);
 }
 
-static inline void eeh_insw_ns(unsigned long port, void * buf, int ns)
+static inline void eeh_readsw(const volatile void __iomem *addr, void * buf,
+                              int ns)
 {
-        _insw_ns((u16 __iomem *)(port+pci_io_base), buf, ns);
+        _insw(addr, buf, ns);
         if (EEH_POSSIBLE_ERROR((*(((u16*)buf)+ns-1)), u16))
-                eeh_check_failure((void __iomem *)(port), *(u16*)buf);
+                eeh_check_failure(addr, *(u16*)buf);
 }
 
-static inline void eeh_insl_ns(unsigned long port, void * buf, int nl)
+static inline void eeh_readsl(const volatile void __iomem *addr, void * buf,
+                              int nl)
 {
-        _insl_ns((u32 __iomem *)(port+pci_io_base), buf, nl);
+        _insl(addr, buf, nl);
         if (EEH_POSSIBLE_ERROR((*(((u32*)buf)+nl-1)), u32))
-                eeh_check_failure((void __iomem *)(port), *(u32*)buf);
+                eeh_check_failure(addr, *(u32*)buf);
 }
 
 #endif /* __KERNEL__ */