PCI: #if 0 pci_assign_resource_fixed()

[linux-2.6-omap-h63xx.git] / include / asm-generic / unaligned.h

diff --git a/include/asm-generic/unaligned.h b/include/asm-generic/unaligned.h
index 4dc8ddb401c15828797b4a7e21586e4b6d3e3418..2fe1b2e67f0121b96d0a60f129fcc9f14972c937 100644 (file)
--- a/include/asm-generic/unaligned.h
+++ b/include/asm-generic/unaligned.h
@@ -18,7 +18,8 @@
 #define get_unaligned(ptr) \
        __get_unaligned((ptr), sizeof(*(ptr)))
 #define put_unaligned(x,ptr) \
-       __put_unaligned((__u64)(x), (ptr), sizeof(*(ptr)))
+       ((void)sizeof(*(ptr)=(x)),\
+       __put_unaligned((__force __u64)(x), (ptr), sizeof(*(ptr))))
 
 /*
  * This function doesn't actually exist.  The idea is that when
@@ -78,38 +79,38 @@ static inline void __ustw(__u16 val, __u16 *addr)
 
 #define __get_unaligned(ptr, size) ({          \
        const void *__gu_p = ptr;               \
-       __typeof__(*(ptr)) val;                 \
+       __u64 __val;                            \
        switch (size) {                         \
        case 1:                                 \
-               val = *(const __u8 *)__gu_p;    \
+               __val = *(const __u8 *)__gu_p;  \
                break;                          \
        case 2:                                 \
-               val = __uldw(__gu_p);           \
+               __val = __uldw(__gu_p);         \
                break;                          \
        case 4:                                 \
-               val = __uldl(__gu_p);           \
+               __val = __uldl(__gu_p);         \
                break;                          \
        case 8:                                 \
-               val = __uldq(__gu_p);           \
+               __val = __uldq(__gu_p);         \
                break;                          \
        default:                                \
                bad_unaligned_access_length();  \
        };                                      \
-       val;                                    \
+       (__force __typeof__(*(ptr)))__val;      \
 })
 
 #define __put_unaligned(val, ptr, size)                \
-do {                                           \
+({                                             \
        void *__gu_p = ptr;                     \
        switch (size) {                         \
        case 1:                                 \
-               *(__u8 *)__gu_p = val;          \
+               *(__u8 *)__gu_p = (__force __u8)val;            \
                break;                          \
        case 2:                                 \
-               __ustw(val, __gu_p);            \
+               __ustw((__force __u16)val, __gu_p);             \
                break;                          \
        case 4:                                 \
-               __ustl(val, __gu_p);            \
+               __ustl((__force __u32)val, __gu_p);             \
                break;                          \
        case 8:                                 \
                __ustq(val, __gu_p);            \
@@ -117,6 +118,7 @@ do {                                                \
        default:                                \
                bad_unaligned_access_length();  \
        };                                      \
-} while(0)
+       (void)0;                                \
+})
 
 #endif /* _ASM_GENERIC_UNALIGNED_H */