1 files changed, 46 insertions, 46 deletions
diff --git a/arch/arm/include/asm/uaccess.h b/arch/arm/include/asm/uaccess.h
index 74fcde756fdb..ce0786efd26c 100644
--- a/arch/arm/include/asm/uaccess.h
+++ b/arch/arm/include/asm/uaccess.h
@@ -73,7 +73,7 @@ static inline void set_fs(mm_segment_t fs)
        modify_domain(DOMAIN_KERNEL, fs ? DOMAIN_CLIENT : DOMAIN_MANAGER);
 }
-#define segment_eq(a,b) ((a) == (b))
+#define segment_eq(a, b)        ((a) == (b))
 #define __addr_ok(addr) ({ \
        unsigned long flag; \
@@ -84,7 +84,7 @@ static inline void set_fs(mm_segment_t fs)
        (flag == 0); })
 /* We use 33-bit arithmetic here... */
-#define __range_ok(addr,size) ({ \
+#define __range_ok(addr, size) ({ \
        unsigned long flag, roksum; \
        __chk_user_ptr(addr);   \
        __asm__("adds %1, %2, %3; sbcccs %1, %1, %0; movcc %0, #0" \
@@ -123,7 +123,7 @@ extern int __get_user_64t_4(void *);
 #define __GUP_CLOBBER_32t_8 "lr", "cc"
 #define __GUP_CLOBBER_8 "lr", "cc"
-#define __get_user_x(__r2,__p,__e,__l,__s)                              \
+#define __get_user_x(__r2, __p, __e, __l, __s)                          \
           __asm__ __volatile__ (                                       \
                __asmeq("%0", "r0") __asmeq("%1", "r2")                 \
                __asmeq("%3", "r1")                                     \
@@ -134,7 +134,7 @@ extern int __get_user_64t_4(void *);
 /* narrowing a double-word get into a single 32bit word register: */
 #ifdef __ARMEB__
-#define __get_user_x_32t(__r2, __p, __e, __l, __s)                              \
+#define __get_user_x_32t(__r2, __p, __e, __l, __s)                      \
        __get_user_x(__r2, __p, __e, __l, 32t_8)
 #else
 #define __get_user_x_32t __get_user_x
@@ -158,7 +158,7 @@ extern int __get_user_64t_4(void *);
 #endif
-#define __get_user_check(x,p)                                                   \
+#define __get_user_check(x, p)                                          \
        ({                                                              \
                unsigned long __limit = current_thread_info()->addr_limit - 1; \
                register const typeof(*(p)) __user *__p asm("r0") = (p);\
@@ -196,10 +196,10 @@ extern int __get_user_64t_4(void *);
                __e;                                                    \
        })
-#define get_user(x,p)                                                   \
+#define get_user(x, p)                                                  \
        ({                                                              \
                might_fault();                                          \
-                __get_user_check(x,p);                                  \
+                __get_user_check(x, p);                                 \
         })
 extern int __put_user_1(void *, unsigned int);
@@ -207,7 +207,7 @@ extern int __put_user_2(void *, unsigned int);
 extern int __put_user_4(void *, unsigned int);
 extern int __put_user_8(void *, unsigned long long);
-#define __put_user_x(__r2,__p,__e,__l,__s)                              \
+#define __put_user_x(__r2, __p, __e, __l, __s)                          \
           __asm__ __volatile__ (                                       \
                __asmeq("%0", "r0") __asmeq("%2", "r2")                 \
                __asmeq("%3", "r1")                                     \
@@ -216,7 +216,7 @@ extern int __put_user_8(void *, unsigned long long);
                : "0" (__p), "r" (__r2), "r" (__l)                      \
                : "ip", "lr", "cc")
-#define __put_user_check(x,p)                                                   \
+#define __put_user_check(x, p)                                          \
        ({                                                              \
                unsigned long __limit = current_thread_info()->addr_limit - 1; \
                const typeof(*(p)) __user *__tmp_p = (p);               \
@@ -242,10 +242,10 @@ extern int __put_user_8(void *, unsigned long long);
                __e;                                                    \
        })
-#define put_user(x,p)                                                   \
+#define put_user(x, p)                                                  \
        ({                                                              \
                might_fault();                                          \
-                __put_user_check(x,p);                                  \
+                __put_user_check(x, p);                                 \
         })
 #else /* CONFIG_MMU */
@@ -255,21 +255,21 @@ extern int __put_user_8(void *, unsigned long long);
 */
 #define USER_DS                 KERNEL_DS
-#define segment_eq(a,b)         (1)
+#define segment_eq(a, b)                (1)
-#define __addr_ok(addr)         ((void)(addr),1)
+#define __addr_ok(addr)         ((void)(addr), 1)
-#define __range_ok(addr,size)   ((void)(addr),0)
+#define __range_ok(addr, size)  ((void)(addr), 0)
 #define get_fs()                (KERNEL_DS)
 static inline void set_fs(mm_segment_t fs)
 {
 }
-#define get_user(x,p)   __get_user(x,p)
+#define get_user(x, p)  __get_user(x, p)
-#define put_user(x,p)   __put_user(x,p)
+#define put_user(x, p)  __put_user(x, p)
 #endif /* CONFIG_MMU */
-#define access_ok(type,addr,size)       (__range_ok(addr,size) == 0)
+#define access_ok(type, addr, size)     (__range_ok(addr, size) == 0)
 #define user_addr_max() \
        (segment_eq(get_fs(), KERNEL_DS) ? ~0UL : get_fs())
@@ -283,35 +283,35 @@ static inline void set_fs(mm_segment_t fs)
 * error occurs, and leave it unchanged on success.  Note that these
 * versions are void (ie, don't return a value as such).
 */
-#define __get_user(x,ptr)                                               \
+#define __get_user(x, ptr)                                              \
 ({                                                                      \
        long __gu_err = 0;                                              \
-        __get_user_err((x),(ptr),__gu_err);                             \
+        __get_user_err((x), (ptr), __gu_err);                           \
        __gu_err;                                                       \
 })
-#define __get_user_error(x,ptr,err)                                     \
+#define __get_user_error(x, ptr, err)                                   \
 ({                                                                      \
-        __get_user_err((x),(ptr),err);                                  \
+        __get_user_err((x), (ptr), err);                                \
        (void) 0;                                                       \
 })
-#define __get_user_err(x,ptr,err)                                       \
+#define __get_user_err(x, ptr, err)                                     \
 do {                                                                    \
        unsigned long __gu_addr = (unsigned long)(ptr);                 \
        unsigned long __gu_val;                                         \
        __chk_user_ptr(ptr);                                            \
        might_fault();                                                  \
        switch (sizeof(*(ptr))) {                                       \
-        case 1: __get_user_asm_byte(__gu_val,__gu_addr,err);    break;  \
+        case 1: __get_user_asm_byte(__gu_val, __gu_addr, err);  break;  \
-        case 2: __get_user_asm_half(__gu_val,__gu_addr,err);    break;  \
+        case 2: __get_user_asm_half(__gu_val, __gu_addr, err);  break;  \
-        case 4: __get_user_asm_word(__gu_val,__gu_addr,err);    break;  \
+        case 4: __get_user_asm_word(__gu_val, __gu_addr, err);  break;  \
        default: (__gu_val) = __get_user_bad();                         \
        }                                                               \
        (x) = (__typeof__(*(ptr)))__gu_val;                             \
 } while (0)
-#define __get_user_asm_byte(x,addr,err)                         \
+#define __get_user_asm_byte(x, addr, err)                       \
        __asm__ __volatile__(                                   \
        "1:     " TUSER(ldrb) " %1,[%2],#0\n"                   \
        "2:\n"                                                  \
@@ -330,7 +330,7 @@ do {									\
        : "cc")
 #ifndef __ARMEB__
-#define __get_user_asm_half(x,__gu_addr,err)                    \
+#define __get_user_asm_half(x, __gu_addr, err)                  \
 ({                                                              \
        unsigned long __b1, __b2;                               \
        __get_user_asm_byte(__b1, __gu_addr, err);              \
@@ -338,7 +338,7 @@ do {									\
        (x) = __b1 | (__b2 << 8);                               \
 })
 #else
-#define __get_user_asm_half(x,__gu_addr,err)                    \
+#define __get_user_asm_half(x, __gu_addr, err)                  \
 ({                                                              \
        unsigned long __b1, __b2;                               \
        __get_user_asm_byte(__b1, __gu_addr, err);              \
@@ -347,7 +347,7 @@ do {									\
 })
 #endif
-#define __get_user_asm_word(x,addr,err)                         \
+#define __get_user_asm_word(x, addr, err)                       \
        __asm__ __volatile__(                                   \
        "1:     " TUSER(ldr) "  %1,[%2],#0\n"                   \
        "2:\n"                                                  \
@@ -365,35 +365,35 @@ do {									\
        : "r" (addr), "i" (-EFAULT)                             \
        : "cc")
-#define __put_user(x,ptr)                                               \
+#define __put_user(x, ptr)                                              \
 ({                                                                      \
        long __pu_err = 0;                                              \
-        __put_user_err((x),(ptr),__pu_err);                             \
+        __put_user_err((x), (ptr), __pu_err);                           \
        __pu_err;                                                       \
 })
-#define __put_user_error(x,ptr,err)                                     \
+#define __put_user_error(x, ptr, err)                                   \
 ({                                                                      \
-        __put_user_err((x),(ptr),err);                                  \
+        __put_user_err((x), (ptr), err);                                \
        (void) 0;                                                       \
 })
-#define __put_user_err(x,ptr,err)                                       \
+#define __put_user_err(x, ptr, err)                                     \
 do {                                                                    \
        unsigned long __pu_addr = (unsigned long)(ptr);                 \
        __typeof__(*(ptr)) __pu_val = (x);                              \
        __chk_user_ptr(ptr);                                            \
        might_fault();                                                  \
        switch (sizeof(*(ptr))) {                                       \
-        case 1: __put_user_asm_byte(__pu_val,__pu_addr,err);    break;  \
+        case 1: __put_user_asm_byte(__pu_val, __pu_addr, err);  break;  \
-        case 2: __put_user_asm_half(__pu_val,__pu_addr,err);    break;  \
+        case 2: __put_user_asm_half(__pu_val, __pu_addr, err);  break;  \
-        case 4: __put_user_asm_word(__pu_val,__pu_addr,err);    break;  \
+        case 4: __put_user_asm_word(__pu_val, __pu_addr, err);  break;  \
-        case 8: __put_user_asm_dword(__pu_val,__pu_addr,err);   break;  \
+        case 8: __put_user_asm_dword(__pu_val, __pu_addr, err); break;  \
        default: __put_user_bad();                                      \
        }                                                               \
 } while (0)
-#define __put_user_asm_byte(x,__pu_addr,err)                    \
+#define __put_user_asm_byte(x, __pu_addr, err)                  \
        __asm__ __volatile__(                                   \
        "1:     " TUSER(strb) " %1,[%2],#0\n"                   \
        "2:\n"                                                  \
@@ -411,14 +411,14 @@ do {									\
        : "cc")
 #ifndef __ARMEB__
-#define __put_user_asm_half(x,__pu_addr,err)                    \
+#define __put_user_asm_half(x, __pu_addr, err)                  \
 ({                                                              \
        unsigned long __temp = (__force unsigned long)(x);      \
        __put_user_asm_byte(__temp, __pu_addr, err);            \
        __put_user_asm_byte(__temp >> 8, __pu_addr + 1, err);   \
 })
 #else
-#define __put_user_asm_half(x,__pu_addr,err)                    \
+#define __put_user_asm_half(x, __pu_addr, err)                  \
 ({                                                              \
        unsigned long __temp = (__force unsigned long)(x);      \
        __put_user_asm_byte(__temp >> 8, __pu_addr, err);       \
@@ -426,7 +426,7 @@ do {									\
 })
 #endif
-#define __put_user_asm_word(x,__pu_addr,err)                    \
+#define __put_user_asm_word(x, __pu_addr, err)                  \
        __asm__ __volatile__(                                   \
        "1:     " TUSER(str) "  %1,[%2],#0\n"                   \
        "2:\n"                                                  \
@@ -451,7 +451,7 @@ do {									\
 #define __reg_oper1     "%R2"
 #endif
-#define __put_user_asm_dword(x,__pu_addr,err)                   \
+#define __put_user_asm_dword(x, __pu_addr, err)                 \
        __asm__ __volatile__(                                   \
 ARM(   "1:     " TUSER(str) "  " __reg_oper1 ", [%1], #4\n"    ) \
 ARM(   "2:     " TUSER(str) "  " __reg_oper0 ", [%1]\n"        ) \
@@ -480,9 +480,9 @@ extern unsigned long __must_check __copy_to_user_std(void __user *to, const void
 extern unsigned long __must_check __clear_user(void __user *addr, unsigned long n);
 extern unsigned long __must_check __clear_user_std(void __user *addr, unsigned long n);
 #else
-#define __copy_from_user(to,from,n)     (memcpy(to, (void __force *)from, n), 0)
+#define __copy_from_user(to, from, n)   (memcpy(to, (void __force *)from, n), 0)
-#define __copy_to_user(to,from,n)       (memcpy((void __force *)to, from, n), 0)
+#define __copy_to_user(to, from, n)     (memcpy((void __force *)to, from, n), 0)
-#define __clear_user(addr,n)            (memset((void __force *)addr, 0, n), 0)
+#define __clear_user(addr, n)           (memset((void __force *)addr, 0, n), 0)
 #endif
 static inline unsigned long __must_check copy_from_user(void *to, const void __user *from, unsigned long n)

diff --git a/arch/arm/include/asm/uaccess.h b/arch/arm/include/asm/uaccess.h index 74fcde756fdb..ce0786efd26c 100644 --- a/arch/arm/include/asm/uaccess.h +++ b/arch/arm/include/asm/uaccess.h
@@ -73,7 +73,7 @@ static inline void set_fs(mm_segment_t fs)
73	modify_domain(DOMAIN_KERNEL, fs ? DOMAIN_CLIENT : DOMAIN_MANAGER);	73	modify_domain(DOMAIN_KERNEL, fs ? DOMAIN_CLIENT : DOMAIN_MANAGER);
74	}	74	}
75		75
76	#define segment_eq(a,b) ((a) == (b))	76	#define segment_eq(a, b) ((a) == (b))
77		77
78	#define __addr_ok(addr) ({ \	78	#define __addr_ok(addr) ({ \
79	unsigned long flag; \	79	unsigned long flag; \
@@ -84,7 +84,7 @@ static inline void set_fs(mm_segment_t fs)
84	(flag == 0); })	84	(flag == 0); })
85		85
86	/* We use 33-bit arithmetic here... */	86	/* We use 33-bit arithmetic here... */
87	#define __range_ok(addr,size) ({ \	87	#define __range_ok(addr, size) ({ \
88	unsigned long flag, roksum; \	88	unsigned long flag, roksum; \
89	__chk_user_ptr(addr); \	89	__chk_user_ptr(addr); \
90	__asm__("adds %1, %2, %3; sbcccs %1, %1, %0; movcc %0, #0" \	90	__asm__("adds %1, %2, %3; sbcccs %1, %1, %0; movcc %0, #0" \
@@ -123,7 +123,7 @@ extern int __get_user_64t_4(void *);
123	#define __GUP_CLOBBER_32t_8 "lr", "cc"	123	#define __GUP_CLOBBER_32t_8 "lr", "cc"
124	#define __GUP_CLOBBER_8 "lr", "cc"	124	#define __GUP_CLOBBER_8 "lr", "cc"
125		125
126	#define __get_user_x(__r2,__p,__e,__l,__s) \	126	#define __get_user_x(__r2, __p, __e, __l, __s) \
127	__asm__ __volatile__ ( \	127	__asm__ __volatile__ ( \
128	__asmeq("%0", "r0") __asmeq("%1", "r2") \	128	__asmeq("%0", "r0") __asmeq("%1", "r2") \
129	__asmeq("%3", "r1") \	129	__asmeq("%3", "r1") \
@@ -134,7 +134,7 @@ extern int __get_user_64t_4(void *);
134		134
135	/* narrowing a double-word get into a single 32bit word register: */	135	/* narrowing a double-word get into a single 32bit word register: */
136	#ifdef __ARMEB__	136	#ifdef __ARMEB__
137	#define __get_user_x_32t(__r2, __p, __e, __l, __s) \	137	#define __get_user_x_32t(__r2, __p, __e, __l, __s) \
138	__get_user_x(__r2, __p, __e, __l, 32t_8)	138	__get_user_x(__r2, __p, __e, __l, 32t_8)
139	#else	139	#else
140	#define __get_user_x_32t __get_user_x	140	#define __get_user_x_32t __get_user_x
@@ -158,7 +158,7 @@ extern int __get_user_64t_4(void *);
158	#endif	158	#endif
159		159
160		160
161	#define __get_user_check(x,p) \	161	#define __get_user_check(x, p) \
162	({ \	162	({ \
163	unsigned long __limit = current_thread_info()->addr_limit - 1; \	163	unsigned long __limit = current_thread_info()->addr_limit - 1; \
164	register const typeof((p)) __user __p asm("r0") = (p);\	164	register const typeof((p)) __user __p asm("r0") = (p);\
@@ -196,10 +196,10 @@ extern int __get_user_64t_4(void *);
196	__e; \	196	__e; \
197	})	197	})
198		198
199	#define get_user(x,p) \	199	#define get_user(x, p) \
200	({ \	200	({ \
201	might_fault(); \	201	might_fault(); \
202	__get_user_check(x,p); \	202	__get_user_check(x, p); \
203	})	203	})
204		204
205	extern int __put_user_1(void *, unsigned int);	205	extern int __put_user_1(void *, unsigned int);
@@ -207,7 +207,7 @@ extern int __put_user_2(void *, unsigned int);
207	extern int __put_user_4(void *, unsigned int);	207	extern int __put_user_4(void *, unsigned int);
208	extern int __put_user_8(void *, unsigned long long);	208	extern int __put_user_8(void *, unsigned long long);
209		209
210	#define __put_user_x(__r2,__p,__e,__l,__s) \	210	#define __put_user_x(__r2, __p, __e, __l, __s) \
211	__asm__ __volatile__ ( \	211	__asm__ __volatile__ ( \
212	__asmeq("%0", "r0") __asmeq("%2", "r2") \	212	__asmeq("%0", "r0") __asmeq("%2", "r2") \
213	__asmeq("%3", "r1") \	213	__asmeq("%3", "r1") \
@@ -216,7 +216,7 @@ extern int __put_user_8(void *, unsigned long long);
216	: "0" (__p), "r" (__r2), "r" (__l) \	216	: "0" (__p), "r" (__r2), "r" (__l) \
217	: "ip", "lr", "cc")	217	: "ip", "lr", "cc")
218		218
219	#define __put_user_check(x,p) \	219	#define __put_user_check(x, p) \
220	({ \	220	({ \
221	unsigned long __limit = current_thread_info()->addr_limit - 1; \	221	unsigned long __limit = current_thread_info()->addr_limit - 1; \
222	const typeof((p)) __user __tmp_p = (p); \	222	const typeof((p)) __user __tmp_p = (p); \
@@ -242,10 +242,10 @@ extern int __put_user_8(void *, unsigned long long);
242	__e; \	242	__e; \
243	})	243	})
244		244
245	#define put_user(x,p) \	245	#define put_user(x, p) \
246	({ \	246	({ \
247	might_fault(); \	247	might_fault(); \
248	__put_user_check(x,p); \	248	__put_user_check(x, p); \
249	})	249	})
250		250
251	#else /* CONFIG_MMU */	251	#else /* CONFIG_MMU */
@@ -255,21 +255,21 @@ extern int __put_user_8(void *, unsigned long long);
255	*/	255	*/
256	#define USER_DS KERNEL_DS	256	#define USER_DS KERNEL_DS
257		257
258	#define segment_eq(a,b) (1)	258	#define segment_eq(a, b) (1)
259	#define __addr_ok(addr) ((void)(addr),1)	259	#define __addr_ok(addr) ((void)(addr), 1)
260	#define __range_ok(addr,size) ((void)(addr),0)	260	#define __range_ok(addr, size) ((void)(addr), 0)
261	#define get_fs() (KERNEL_DS)	261	#define get_fs() (KERNEL_DS)
262		262
263	static inline void set_fs(mm_segment_t fs)	263	static inline void set_fs(mm_segment_t fs)
264	{	264	{
265	}	265	}
266		266
267	#define get_user(x,p) __get_user(x,p)	267	#define get_user(x, p) __get_user(x, p)
268	#define put_user(x,p) __put_user(x,p)	268	#define put_user(x, p) __put_user(x, p)
269		269
270	#endif /* CONFIG_MMU */	270	#endif /* CONFIG_MMU */
271		271
272	#define access_ok(type,addr,size) (__range_ok(addr,size) == 0)	272	#define access_ok(type, addr, size) (__range_ok(addr, size) == 0)
273		273
274	#define user_addr_max() \	274	#define user_addr_max() \
275	(segment_eq(get_fs(), KERNEL_DS) ? ~0UL : get_fs())	275	(segment_eq(get_fs(), KERNEL_DS) ? ~0UL : get_fs())
@@ -283,35 +283,35 @@ static inline void set_fs(mm_segment_t fs)
283	* error occurs, and leave it unchanged on success. Note that these	283	* error occurs, and leave it unchanged on success. Note that these
284	* versions are void (ie, don't return a value as such).	284	* versions are void (ie, don't return a value as such).
285	*/	285	*/
286	#define __get_user(x,ptr) \	286	#define __get_user(x, ptr) \
287	({ \	287	({ \
288	long __gu_err = 0; \	288	long __gu_err = 0; \
289	__get_user_err((x),(ptr),__gu_err); \	289	__get_user_err((x), (ptr), __gu_err); \
290	__gu_err; \	290	__gu_err; \
291	})	291	})
292		292
293	#define __get_user_error(x,ptr,err) \	293	#define __get_user_error(x, ptr, err) \
294	({ \	294	({ \
295	__get_user_err((x),(ptr),err); \	295	__get_user_err((x), (ptr), err); \
296	(void) 0; \	296	(void) 0; \
297	})	297	})
298		298
299	#define __get_user_err(x,ptr,err) \	299	#define __get_user_err(x, ptr, err) \
300	do { \	300	do { \
301	unsigned long __gu_addr = (unsigned long)(ptr); \	301	unsigned long __gu_addr = (unsigned long)(ptr); \
302	unsigned long __gu_val; \	302	unsigned long __gu_val; \
303	__chk_user_ptr(ptr); \	303	__chk_user_ptr(ptr); \
304	might_fault(); \	304	might_fault(); \
305	switch (sizeof(*(ptr))) { \	305	switch (sizeof(*(ptr))) { \
306	case 1: __get_user_asm_byte(__gu_val,__gu_addr,err); break; \	306	case 1: __get_user_asm_byte(__gu_val, __gu_addr, err); break; \
307	case 2: __get_user_asm_half(__gu_val,__gu_addr,err); break; \	307	case 2: __get_user_asm_half(__gu_val, __gu_addr, err); break; \
308	case 4: __get_user_asm_word(__gu_val,__gu_addr,err); break; \	308	case 4: __get_user_asm_word(__gu_val, __gu_addr, err); break; \
309	default: (__gu_val) = __get_user_bad(); \	309	default: (__gu_val) = __get_user_bad(); \
310	} \	310	} \
311	(x) = (__typeof__(*(ptr)))__gu_val; \	311	(x) = (__typeof__(*(ptr)))__gu_val; \
312	} while (0)	312	} while (0)
313		313
314	#define __get_user_asm_byte(x,addr,err) \	314	#define __get_user_asm_byte(x, addr, err) \
315	__asm__ __volatile__( \	315	__asm__ __volatile__( \
316	"1: " TUSER(ldrb) " %1,[%2],#0\n" \	316	"1: " TUSER(ldrb) " %1,[%2],#0\n" \
317	"2:\n" \	317	"2:\n" \
@@ -330,7 +330,7 @@ do { \
330	: "cc")	330	: "cc")
331		331
332	#ifndef __ARMEB__	332	#ifndef __ARMEB__
333	#define __get_user_asm_half(x,__gu_addr,err) \	333	#define __get_user_asm_half(x, __gu_addr, err) \
334	({ \	334	({ \
335	unsigned long __b1, __b2; \	335	unsigned long __b1, __b2; \
336	__get_user_asm_byte(__b1, __gu_addr, err); \	336	__get_user_asm_byte(__b1, __gu_addr, err); \
@@ -338,7 +338,7 @@ do { \
338	(x) = __b1 \| (__b2 << 8); \	338	(x) = __b1 \| (__b2 << 8); \
339	})	339	})
340	#else	340	#else
341	#define __get_user_asm_half(x,__gu_addr,err) \	341	#define __get_user_asm_half(x, __gu_addr, err) \
342	({ \	342	({ \
343	unsigned long __b1, __b2; \	343	unsigned long __b1, __b2; \
344	__get_user_asm_byte(__b1, __gu_addr, err); \	344	__get_user_asm_byte(__b1, __gu_addr, err); \
@@ -347,7 +347,7 @@ do { \
347	})	347	})
348	#endif	348	#endif
349		349
350	#define __get_user_asm_word(x,addr,err) \	350	#define __get_user_asm_word(x, addr, err) \
351	__asm__ __volatile__( \	351	__asm__ __volatile__( \
352	"1: " TUSER(ldr) " %1,[%2],#0\n" \	352	"1: " TUSER(ldr) " %1,[%2],#0\n" \
353	"2:\n" \	353	"2:\n" \
@@ -365,35 +365,35 @@ do { \
365	: "r" (addr), "i" (-EFAULT) \	365	: "r" (addr), "i" (-EFAULT) \
366	: "cc")	366	: "cc")
367		367
368	#define __put_user(x,ptr) \	368	#define __put_user(x, ptr) \
369	({ \	369	({ \
370	long __pu_err = 0; \	370	long __pu_err = 0; \
371	__put_user_err((x),(ptr),__pu_err); \	371	__put_user_err((x), (ptr), __pu_err); \
372	__pu_err; \	372	__pu_err; \
373	})	373	})
374		374
375	#define __put_user_error(x,ptr,err) \	375	#define __put_user_error(x, ptr, err) \
376	({ \	376	({ \
377	__put_user_err((x),(ptr),err); \	377	__put_user_err((x), (ptr), err); \
378	(void) 0; \	378	(void) 0; \
379	})	379	})
380		380
381	#define __put_user_err(x,ptr,err) \	381	#define __put_user_err(x, ptr, err) \
382	do { \	382	do { \
383	unsigned long __pu_addr = (unsigned long)(ptr); \	383	unsigned long __pu_addr = (unsigned long)(ptr); \
384	__typeof__(*(ptr)) __pu_val = (x); \	384	__typeof__(*(ptr)) __pu_val = (x); \
385	__chk_user_ptr(ptr); \	385	__chk_user_ptr(ptr); \
386	might_fault(); \	386	might_fault(); \
387	switch (sizeof(*(ptr))) { \	387	switch (sizeof(*(ptr))) { \
388	case 1: __put_user_asm_byte(__pu_val,__pu_addr,err); break; \	388	case 1: __put_user_asm_byte(__pu_val, __pu_addr, err); break; \
389	case 2: __put_user_asm_half(__pu_val,__pu_addr,err); break; \	389	case 2: __put_user_asm_half(__pu_val, __pu_addr, err); break; \
390	case 4: __put_user_asm_word(__pu_val,__pu_addr,err); break; \	390	case 4: __put_user_asm_word(__pu_val, __pu_addr, err); break; \
391	case 8: __put_user_asm_dword(__pu_val,__pu_addr,err); break; \	391	case 8: __put_user_asm_dword(__pu_val, __pu_addr, err); break; \
392	default: __put_user_bad(); \	392	default: __put_user_bad(); \
393	} \	393	} \
394	} while (0)	394	} while (0)
395		395
396	#define __put_user_asm_byte(x,__pu_addr,err) \	396	#define __put_user_asm_byte(x, __pu_addr, err) \
397	__asm__ __volatile__( \	397	__asm__ __volatile__( \
398	"1: " TUSER(strb) " %1,[%2],#0\n" \	398	"1: " TUSER(strb) " %1,[%2],#0\n" \
399	"2:\n" \	399	"2:\n" \
@@ -411,14 +411,14 @@ do { \
411	: "cc")	411	: "cc")
412		412
413	#ifndef __ARMEB__	413	#ifndef __ARMEB__
414	#define __put_user_asm_half(x,__pu_addr,err) \	414	#define __put_user_asm_half(x, __pu_addr, err) \
415	({ \	415	({ \
416	unsigned long __temp = (__force unsigned long)(x); \	416	unsigned long __temp = (__force unsigned long)(x); \
417	__put_user_asm_byte(__temp, __pu_addr, err); \	417	__put_user_asm_byte(__temp, __pu_addr, err); \
418	__put_user_asm_byte(__temp >> 8, __pu_addr + 1, err); \	418	__put_user_asm_byte(__temp >> 8, __pu_addr + 1, err); \
419	})	419	})
420	#else	420	#else
421	#define __put_user_asm_half(x,__pu_addr,err) \	421	#define __put_user_asm_half(x, __pu_addr, err) \
422	({ \	422	({ \
423	unsigned long __temp = (__force unsigned long)(x); \	423	unsigned long __temp = (__force unsigned long)(x); \
424	__put_user_asm_byte(__temp >> 8, __pu_addr, err); \	424	__put_user_asm_byte(__temp >> 8, __pu_addr, err); \
@@ -426,7 +426,7 @@ do { \
426	})	426	})
427	#endif	427	#endif
428		428
429	#define __put_user_asm_word(x,__pu_addr,err) \	429	#define __put_user_asm_word(x, __pu_addr, err) \
430	__asm__ __volatile__( \	430	__asm__ __volatile__( \
431	"1: " TUSER(str) " %1,[%2],#0\n" \	431	"1: " TUSER(str) " %1,[%2],#0\n" \
432	"2:\n" \	432	"2:\n" \
@@ -451,7 +451,7 @@ do { \
451	#define __reg_oper1 "%R2"	451	#define __reg_oper1 "%R2"
452	#endif	452	#endif
453		453
454	#define __put_user_asm_dword(x,__pu_addr,err) \	454	#define __put_user_asm_dword(x, __pu_addr, err) \
455	__asm__ __volatile__( \	455	__asm__ __volatile__( \
456	ARM( "1: " TUSER(str) " " __reg_oper1 ", [%1], #4\n" ) \	456	ARM( "1: " TUSER(str) " " __reg_oper1 ", [%1], #4\n" ) \
457	ARM( "2: " TUSER(str) " " __reg_oper0 ", [%1]\n" ) \	457	ARM( "2: " TUSER(str) " " __reg_oper0 ", [%1]\n" ) \
@@ -480,9 +480,9 @@ extern unsigned long __must_check __copy_to_user_std(void __user *to, const void
480	extern unsigned long __must_check __clear_user(void __user *addr, unsigned long n);	480	extern unsigned long __must_check __clear_user(void __user *addr, unsigned long n);
481	extern unsigned long __must_check __clear_user_std(void __user *addr, unsigned long n);	481	extern unsigned long __must_check __clear_user_std(void __user *addr, unsigned long n);
482	#else	482	#else
483	#define __copy_from_user(to,from,n) (memcpy(to, (void __force *)from, n), 0)	483	#define __copy_from_user(to, from, n) (memcpy(to, (void __force *)from, n), 0)
484	#define __copy_to_user(to,from,n) (memcpy((void __force *)to, from, n), 0)	484	#define __copy_to_user(to, from, n) (memcpy((void __force *)to, from, n), 0)
485	#define __clear_user(addr,n) (memset((void __force *)addr, 0, n), 0)	485	#define __clear_user(addr, n) (memset((void __force *)addr, 0, n), 0)
486	#endif	486	#endif
487		487
488	static inline unsigned long __must_check copy_from_user(void to, const void __user from, unsigned long n)	488	static inline unsigned long __must_check copy_from_user(void to, const void __user from, unsigned long n)