1 files changed, 32 insertions, 181 deletions

diff --git a/include/asm-powerpc/eeh.h b/include/asm-powerpc/eeh.h
index 6a784396660b..b886bec67016 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,205 +136,75 @@ 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)
 
-static inline void eeh_memset_io(volatile void __iomem *addr, int c,
-                                 unsigned long n)
-{
-        void *p = (void __force *)addr;
-        u32 lc = c;
-        lc |= lc << 8;
-        lc |= lc << 16;
-
-        __asm__ __volatile__ ("sync" : : : "memory");
-        while(n && !EEH_CHECK_ALIGN(p, 4)) {
-                *((volatile u8 *)p) = c;
-                p++;
-                n--;
-        }
-        while(n >= 4) {
-                *((volatile u32 *)p) = lc;
-                p += 4;
-                n -= 4;
-        }
-        while(n) {
-                *((volatile u8 *)p) = c;
-                p++;
-                n--;
-        }
-        __asm__ __volatile__ ("sync" : : : "memory");
-}
-static inline void eeh_memcpy_fromio(void *dest, const volatile void __iomem *src,
+static inline void eeh_memcpy_fromio(void *dest, const
+                                     volatile void __iomem *src,
                                      unsigned long n)
 {
-        void *vsrc = (void __force *) src;
-        void *destsave = dest;
-        unsigned long nsave = n;
-
-        __asm__ __volatile__ ("sync" : : : "memory");
-        while(n && (!EEH_CHECK_ALIGN(vsrc, 4) || !EEH_CHECK_ALIGN(dest, 4))) {
-                *((u8 *)dest) = *((volatile u8 *)vsrc);
-                __asm__ __volatile__ ("eieio" : : : "memory");
-                vsrc++;
-                dest++;
-                n--;
-        }
-        while(n > 4) {
-                *((u32 *)dest) = *((volatile u32 *)vsrc);
-                __asm__ __volatile__ ("eieio" : : : "memory");
-                vsrc += 4;
-                dest += 4;
-                n -= 4;
-        }
-        while(n) {
-                *((u8 *)dest) = *((volatile u8 *)vsrc);
-                __asm__ __volatile__ ("eieio" : : : "memory");
-                vsrc++;
-                dest++;
-                n--;
-        }
-        __asm__ __volatile__ ("sync" : : : "memory");
+        _memcpy_fromio(dest, src, n);
 
         /* Look for ffff's here at dest[n].  Assume that at least 4 bytes
          * were copied. Check all four bytes.
          */
-        if ((nsave >= 4) &&
-                (EEH_POSSIBLE_ERROR((*((u32 *) destsave+nsave-4)), u32))) {
-                eeh_check_failure(src, (*((u32 *) destsave+nsave-4)));
-        }
-}
-
-static inline void eeh_memcpy_toio(volatile void __iomem *dest, const void *src,
-                                   unsigned long n)
-{
-        void *vdest = (void __force *) dest;
-
-        __asm__ __volatile__ ("sync" : : : "memory");
-        while(n && (!EEH_CHECK_ALIGN(vdest, 4) || !EEH_CHECK_ALIGN(src, 4))) {
-                *((volatile u8 *)vdest) = *((u8 *)src);
-                src++;
-                vdest++;
-                n--;
-        }
-        while(n > 4) {
-                *((volatile u32 *)vdest) = *((volatile u32 *)src);
-                src += 4;
-                vdest += 4;
-                n-=4;
-        }
-        while(n) {
-                *((volatile u8 *)vdest) = *((u8 *)src);
-                src++;
-                vdest++;
-                n--;
-        }
-        __asm__ __volatile__ ("sync" : : : "memory");
-}
-
-#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);
+        if (n >= 4 && EEH_POSSIBLE_ERROR(*((u32 *)(dest + n - 4)), u32))
+                eeh_check_failure(src, *((u32 *)(dest + n - 4)));
 }
 
 /* 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__ */