[deliverable/linux.git] / include / asm-m68k / uaccess.h

#ifndef __M68K_UACCESS_H
#define __M68K_UACCESS_H

/*
 * User space memory access functions
 */
#include <linux/compiler.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <asm/segment.h>

#define VERIFY_READ	0
#define VERIFY_WRITE	1

/* We let the MMU do all checking */
static inline int access_ok(int type, const void __user *addr,
			    unsigned long size)
{
	return 1;
}

/*
 * The exception table consists of pairs of addresses: the first is the
 * address of an instruction that is allowed to fault, and the second is
 * the address at which the program should continue.  No registers are
 * modified, so it is entirely up to the continuation code to figure out
 * what to do.
 *
 * All the routines below use bits of fixup code that are out of line
 * with the main instruction path.  This means when everything is well,
 * we don't even have to jump over them.  Further, they do not intrude
 * on our cache or tlb entries.
 */

struct exception_table_entry
{
	unsigned long insn, fixup;
};

extern int __put_user_bad(void);
extern int __get_user_bad(void);

#define __put_user_asm(res, x, ptr, bwl, reg, err)	\
asm volatile ("\n"					\
	"1:	moves."#bwl"	%2,%1\n"		\
	"2:\n"						\
	"	.section .fixup,\"ax\"\n"		\
	"	.even\n"				\
	"10:	moveq.l	%3,%0\n"			\
	"	jra 2b\n"				\
	"	.previous\n"				\
	"\n"						\
	"	.section __ex_table,\"a\"\n"		\
	"	.align	4\n"				\
	"	.long	1b,10b\n"			\
	"	.long	2b,10b\n"			\
	"	.previous"				\
	: "+d" (res), "=m" (*(ptr))			\
	: #reg (x), "i" (err))

/*
 * These are the main single-value transfer routines.  They automatically
 * use the right size if we just have the right pointer type.
 */

#define __put_user(x, ptr)						\
({									\
	typeof(*(ptr)) __pu_val = (x);					\
	int __pu_err = 0;						\
	__chk_user_ptr(ptr);						\
	switch (sizeof (*(ptr))) {					\
	case 1:								\
		__put_user_asm(__pu_err, __pu_val, ptr, b, d, -EFAULT);	\
		break;							\
	case 2:								\
		__put_user_asm(__pu_err, __pu_val, ptr, w, d, -EFAULT);	\
		break;							\
	case 4:								\
		__put_user_asm(__pu_err, __pu_val, ptr, l, r, -EFAULT);	\
		break;							\
	case 8:								\
 	    {								\
 		const void __user *__pu_ptr = (ptr);			\
		asm volatile ("\n"					\
			"1:	moves.l	%2,(%1)+\n"			\
			"2:	moves.l	%R2,(%1)\n"			\
			"3:\n"						\
			"	.section .fixup,\"ax\"\n"		\
			"	.even\n"				\
			"10:	movel %3,%0\n"				\
			"	jra 3b\n"				\
			"	.previous\n"				\
			"\n"						\
			"	.section __ex_table,\"a\"\n"		\
			"	.align 4\n"				\
			"	.long 1b,10b\n"				\
			"	.long 2b,10b\n"				\
			"	.long 3b,10b\n"				\
			"	.previous"				\
			: "+d" (__pu_err), "+a" (__pu_ptr)		\
			: "r" (__pu_val), "i" (-EFAULT)			\
			: "memory");					\
		break;							\
	    }								\
	default:							\
		__pu_err = __put_user_bad();				\
		break;							\
	}								\
	__pu_err;							\
})
#define put_user(x, ptr)	__put_user(x, ptr)


#define __get_user_asm(res, x, ptr, type, bwl, reg, err) ({	\
	type __gu_val;						\
	asm volatile ("\n"					\
		"1:	moves."#bwl"	%2,%1\n"		\
		"2:\n"						\
		"	.section .fixup,\"ax\"\n"		\
		"	.even\n"				\
		"10:	move.l	%3,%0\n"			\
		"	sub."#bwl"	%1,%1\n"		\
		"	jra	2b\n"				\
		"	.previous\n"				\
		"\n"						\
		"	.section __ex_table,\"a\"\n"		\
		"	.align	4\n"				\
		"	.long	1b,10b\n"			\
		"	.previous"				\
		: "+d" (res), "=&" #reg (__gu_val)		\
		: "m" (*(ptr)), "i" (err));			\
	(x) = (typeof(*(ptr)))(unsigned long)__gu_val;		\
})

#define __get_user(x, ptr)						\
({									\
	int __gu_err = 0;						\
	__chk_user_ptr(ptr);						\
	switch (sizeof(*(ptr))) {					\
	case 1:								\
		__get_user_asm(__gu_err, x, ptr, u8, b, d, -EFAULT);	\
		break;							\
	case 2:								\
		__get_user_asm(__gu_err, x, ptr, u16, w, d, -EFAULT);	\
		break;							\
	case 4:								\
		__get_user_asm(__gu_err, x, ptr, u32, l, r, -EFAULT);	\
		break;							\
/*	case 8:	disabled because gcc-4.1 has a broken typeof		\
 	    {								\
 		const void *__gu_ptr = (ptr);				\
 		u64 __gu_val;						\
		asm volatile ("\n"					\
			"1:	moves.l	(%2)+,%1\n"			\
			"2:	moves.l	(%2),%R1\n"			\
			"3:\n"						\
			"	.section .fixup,\"ax\"\n"		\
			"	.even\n"				\
			"10:	move.l	%3,%0\n"			\
			"	sub.l	%1,%1\n"			\
			"	sub.l	%R1,%R1\n"			\
			"	jra	3b\n"				\
			"	.previous\n"				\
			"\n"						\
			"	.section __ex_table,\"a\"\n"		\
			"	.align	4\n"				\
			"	.long	1b,10b\n"			\
			"	.long	2b,10b\n"			\
			"	.previous"				\
			: "+d" (__gu_err), "=&r" (__gu_val),		\
			  "+a" (__gu_ptr)				\
			: "i" (-EFAULT)					\
			: "memory");					\
		(x) = (typeof(*(ptr)))__gu_val;				\
		break;							\
	    }	*/							\
	default:							\
		__gu_err = __get_user_bad();				\
		break;							\
	}								\
	__gu_err;							\
})
#define get_user(x, ptr) __get_user(x, ptr)

unsigned long __generic_copy_from_user(void *to, const void __user *from, unsigned long n);
unsigned long __generic_copy_to_user(void __user *to, const void *from, unsigned long n);

#define __constant_copy_from_user_asm(res, to, from, tmp, n, s1, s2, s3)\
	asm volatile ("\n"						\
		"1:	moves."#s1"	(%2)+,%3\n"			\
		"	move."#s1"	%3,(%1)+\n"			\
		"2:	moves."#s2"	(%2)+,%3\n"			\
		"	move."#s2"	%3,(%1)+\n"			\
		"	.ifnc	\""#s3"\",\"\"\n"			\
		"3:	moves."#s3"	(%2)+,%3\n"			\
		"	move."#s3"	%3,(%1)+\n"			\
		"	.endif\n"					\
		"4:\n"							\
		"	.section __ex_table,\"a\"\n"			\
		"	.align	4\n"					\
		"	.long	1b,10f\n"				\
		"	.long	2b,20f\n"				\
		"	.ifnc	\""#s3"\",\"\"\n"			\
		"	.long	3b,30f\n"				\
		"	.endif\n"					\
		"	.previous\n"					\
		"\n"							\
		"	.section .fixup,\"ax\"\n"			\
		"	.even\n"					\
		"10:	clr."#s1"	(%1)+\n"			\
		"20:	clr."#s2"	(%1)+\n"			\
		"	.ifnc	\""#s3"\",\"\"\n"			\
		"30:	clr."#s3"	(%1)+\n"			\
		"	.endif\n"					\
		"	moveq.l	#"#n",%0\n"				\
		"	jra	4b\n"					\
		"	.previous\n"					\
		: "+d" (res), "+&a" (to), "+a" (from), "=&d" (tmp)	\
		: : "memory")

static __always_inline unsigned long
__constant_copy_from_user(void *to, const void __user *from, unsigned long n)
{
	unsigned long res = 0, tmp;

	switch (n) {
	case 1:
		__get_user_asm(res, *(u8 *)to, (u8 __user *)from, u8, b, d, 1);
		break;
	case 2:
		__get_user_asm(res, *(u16 *)to, (u16 __user *)from, u16, w, d, 2);
		break;
	case 3:
		__constant_copy_from_user_asm(res, to, from, tmp, 3, w, b,);
		break;
	case 4:
		__get_user_asm(res, *(u32 *)to, (u32 __user *)from, u32, l, r, 4);
		break;
	case 5:
		__constant_copy_from_user_asm(res, to, from, tmp, 5, l, b,);
		break;
	case 6:
		__constant_copy_from_user_asm(res, to, from, tmp, 6, l, w,);
		break;
	case 7:
		__constant_copy_from_user_asm(res, to, from, tmp, 7, l, w, b);
		break;
	case 8:
		__constant_copy_from_user_asm(res, to, from, tmp, 8, l, l,);
		break;
	case 9:
		__constant_copy_from_user_asm(res, to, from, tmp, 9, l, l, b);
		break;
	case 10:
		__constant_copy_from_user_asm(res, to, from, tmp, 10, l, l, w);
		break;
	case 12:
		__constant_copy_from_user_asm(res, to, from, tmp, 12, l, l, l);
		break;
	default:
		/* we limit the inlined version to 3 moves */
		return __generic_copy_from_user(to, from, n);
	}

	return res;
}

#define __constant_copy_to_user_asm(res, to, from, tmp, n, s1, s2, s3)	\
	asm volatile ("\n"						\
		"	move."#s1"	(%2)+,%3\n"			\
		"11:	moves."#s1"	%3,(%1)+\n"			\
		"12:	move."#s2"	(%2)+,%3\n"			\
		"21:	moves."#s2"	%3,(%1)+\n"			\
		"22:\n"							\
		"	.ifnc	\""#s3"\",\"\"\n"			\
		"	move."#s3"	(%2)+,%3\n"			\
		"31:	moves."#s3"	%3,(%1)+\n"			\
		"32:\n"							\
		"	.endif\n"					\
		"4:\n"							\
		"\n"							\
		"	.section __ex_table,\"a\"\n"			\
		"	.align	4\n"					\
		"	.long	11b,5f\n"				\
		"	.long	12b,5f\n"				\
		"	.long	21b,5f\n"				\
		"	.long	22b,5f\n"				\
		"	.ifnc	\""#s3"\",\"\"\n"			\
		"	.long	31b,5f\n"				\
		"	.long	32b,5f\n"				\
		"	.endif\n"					\
		"	.previous\n"					\
		"\n"							\
		"	.section .fixup,\"ax\"\n"			\
		"	.even\n"					\
		"5:	moveq.l	#"#n",%0\n"				\
		"	jra	4b\n"					\
		"	.previous\n"					\
		: "+d" (res), "+a" (to), "+a" (from), "=&d" (tmp)	\
		: : "memory")

static __always_inline unsigned long
__constant_copy_to_user(void __user *to, const void *from, unsigned long n)
{
	unsigned long res = 0, tmp;

	switch (n) {
	case 1:
		__put_user_asm(res, *(u8 *)from, (u8 __user *)to, b, d, 1);
		break;
	case 2:
		__put_user_asm(res, *(u16 *)from, (u16 __user *)to, w, d, 2);
		break;
	case 3:
		__constant_copy_to_user_asm(res, to, from, tmp, 3, w, b,);
		break;
	case 4:
		__put_user_asm(res, *(u32 *)from, (u32 __user *)to, l, r, 4);
		break;
	case 5:
		__constant_copy_to_user_asm(res, to, from, tmp, 5, l, b,);
		break;
	case 6:
		__constant_copy_to_user_asm(res, to, from, tmp, 6, l, w,);
		break;
	case 7:
		__constant_copy_to_user_asm(res, to, from, tmp, 7, l, w, b);
		break;
	case 8:
		__constant_copy_to_user_asm(res, to, from, tmp, 8, l, l,);
		break;
	case 9:
		__constant_copy_to_user_asm(res, to, from, tmp, 9, l, l, b);
		break;
	case 10:
		__constant_copy_to_user_asm(res, to, from, tmp, 10, l, l, w);
		break;
	case 12:
		__constant_copy_to_user_asm(res, to, from, tmp, 12, l, l, l);
		break;
	default:
		/* limit the inlined version to 3 moves */
		return __generic_copy_to_user(to, from, n);
	}

	return res;
}

#define __copy_from_user(to, from, n)		\
(__builtin_constant_p(n) ?			\
 __constant_copy_from_user(to, from, n) :	\
 __generic_copy_from_user(to, from, n))

#define __copy_to_user(to, from, n)		\
(__builtin_constant_p(n) ?			\
 __constant_copy_to_user(to, from, n) :		\
 __generic_copy_to_user(to, from, n))

#define __copy_to_user_inatomic		__copy_to_user
#define __copy_from_user_inatomic	__copy_from_user

#define copy_from_user(to, from, n)	__copy_from_user(to, from, n)
#define copy_to_user(to, from, n)	__copy_to_user(to, from, n)

long strncpy_from_user(char *dst, const char __user *src, long count);
long strnlen_user(const char __user *src, long n);
unsigned long __clear_user(void __user *to, unsigned long n);

#define clear_user	__clear_user

#define strlen_user(str) strnlen_user(str, 32767)

#endif /* _M68K_UACCESS_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef __M68K_UACCESS_H
	2	#define __M68K_UACCESS_H
	3
	4	/*
	5	* User space memory access functions
	6	*/
d94af931	7	#include <linux/compiler.h>
1da177e4	8	#include <linux/errno.h>
d94af931	9	#include <linux/types.h>
a0f7b67a	10	#include <linux/sched.h>
1da177e4 LT	11	#include <asm/segment.h>
	12
	13	#define VERIFY_READ 0
	14	#define VERIFY_WRITE 1
	15
	16	/* We let the MMU do all checking */
70f9cac5 GU	17	static inline int access_ok(int type, const void __user *addr,
	18	unsigned long size)
	19	{
	20	return 1;
	21	}
1da177e4	22
1da177e4 LT	23	/*
	24	* The exception table consists of pairs of addresses: the first is the
	25	* address of an instruction that is allowed to fault, and the second is
	26	* the address at which the program should continue. No registers are
	27	* modified, so it is entirely up to the continuation code to figure out
	28	* what to do.
	29	*
	30	* All the routines below use bits of fixup code that are out of line
	31	* with the main instruction path. This means when everything is well,
	32	* we don't even have to jump over them. Further, they do not intrude
	33	* on our cache or tlb entries.
	34	*/
	35
	36	struct exception_table_entry
	37	{
	38	unsigned long insn, fixup;
	39	};
	40
d94af931 RZ	41	extern int __put_user_bad(void);
	42	extern int __get_user_bad(void);
	43
	44	#define __put_user_asm(res, x, ptr, bwl, reg, err) \
	45	asm volatile ("\n" \
	46	"1: moves."#bwl" %2,%1\n" \
	47	"2:\n" \
	48	" .section .fixup,\"ax\"\n" \
	49	" .even\n" \
	50	"10: moveq.l %3,%0\n" \
	51	" jra 2b\n" \
	52	" .previous\n" \
	53	"\n" \
	54	" .section __ex_table,\"a\"\n" \
	55	" .align 4\n" \
	56	" .long 1b,10b\n" \
	57	" .long 2b,10b\n" \
	58	" .previous" \
	59	: "+d" (res), "=m" (*(ptr)) \
	60	: #reg (x), "i" (err))
1da177e4 LT	61
	62	/*
	63	* These are the main single-value transfer routines. They automatically
	64	* use the right size if we just have the right pointer type.
	65	*/
	66
d94af931 RZ	67	#define __put_user(x, ptr) \
	68	({ \
	69	typeof(*(ptr)) __pu_val = (x); \
	70	int __pu_err = 0; \
	71	__chk_user_ptr(ptr); \
	72	switch (sizeof (*(ptr))) { \
	73	case 1: \
	74	__put_user_asm(__pu_err, __pu_val, ptr, b, d, -EFAULT); \
	75	break; \
	76	case 2: \
	77	__put_user_asm(__pu_err, __pu_val, ptr, w, d, -EFAULT); \
	78	break; \
	79	case 4: \
	80	__put_user_asm(__pu_err, __pu_val, ptr, l, r, -EFAULT); \
	81	break; \
	82	case 8: \
	83	{ \
b971018b	84	const void __user *__pu_ptr = (ptr); \
d94af931 RZ	85	asm volatile ("\n" \
	86	"1: moves.l %2,(%1)+\n" \
	87	"2: moves.l %R2,(%1)\n" \
	88	"3:\n" \
	89	" .section .fixup,\"ax\"\n" \
	90	" .even\n" \
	91	"10: movel %3,%0\n" \
	92	" jra 3b\n" \
	93	" .previous\n" \
	94	"\n" \
	95	" .section __ex_table,\"a\"\n" \
	96	" .align 4\n" \
	97	" .long 1b,10b\n" \
	98	" .long 2b,10b\n" \
	99	" .long 3b,10b\n" \
	100	" .previous" \
	101	: "+d" (__pu_err), "+a" (__pu_ptr) \
	102	: "r" (__pu_val), "i" (-EFAULT) \
	103	: "memory"); \
	104	break; \
	105	} \
	106	default: \
	107	__pu_err = __put_user_bad(); \
	108	break; \
	109	} \
	110	__pu_err; \
1da177e4	111	})
d94af931	112	#define put_user(x, ptr) __put_user(x, ptr)
1da177e4	113
1da177e4	114
d94af931 RZ	115	#define __get_user_asm(res, x, ptr, type, bwl, reg, err) ({ \
	116	type __gu_val; \
	117	asm volatile ("\n" \
	118	"1: moves."#bwl" %2,%1\n" \
	119	"2:\n" \
	120	" .section .fixup,\"ax\"\n" \
	121	" .even\n" \
	122	"10: move.l %3,%0\n" \
	123	" sub."#bwl" %1,%1\n" \
	124	" jra 2b\n" \
	125	" .previous\n" \
	126	"\n" \
	127	" .section __ex_table,\"a\"\n" \
	128	" .align 4\n" \
	129	" .long 1b,10b\n" \
	130	" .previous" \
	131	: "+d" (res), "=&" #reg (__gu_val) \
	132	: "m" (*(ptr)), "i" (err)); \
b971018b	133	(x) = (typeof(*(ptr)))(unsigned long)__gu_val; \
1da177e4	134	})
1da177e4	135
d94af931 RZ	136	#define __get_user(x, ptr) \
	137	({ \
	138	int __gu_err = 0; \
	139	__chk_user_ptr(ptr); \
	140	switch (sizeof(*(ptr))) { \
	141	case 1: \
	142	__get_user_asm(__gu_err, x, ptr, u8, b, d, -EFAULT); \
	143	break; \
	144	case 2: \
	145	__get_user_asm(__gu_err, x, ptr, u16, w, d, -EFAULT); \
	146	break; \
	147	case 4: \
	148	__get_user_asm(__gu_err, x, ptr, u32, l, r, -EFAULT); \
	149	break; \
	150	/* case 8: disabled because gcc-4.1 has a broken typeof \
	151	{ \
	152	const void *__gu_ptr = (ptr); \
	153	u64 __gu_val; \
	154	asm volatile ("\n" \
	155	"1: moves.l (%2)+,%1\n" \
	156	"2: moves.l (%2),%R1\n" \
	157	"3:\n" \
	158	" .section .fixup,\"ax\"\n" \
	159	" .even\n" \
	160	"10: move.l %3,%0\n" \
	161	" sub.l %1,%1\n" \
	162	" sub.l %R1,%R1\n" \
	163	" jra 3b\n" \
	164	" .previous\n" \
	165	"\n" \
	166	" .section __ex_table,\"a\"\n" \
	167	" .align 4\n" \
	168	" .long 1b,10b\n" \
	169	" .long 2b,10b\n" \
	170	" .previous" \
	171	: "+d" (__gu_err), "=&r" (__gu_val), \
	172	"+a" (__gu_ptr) \
	173	: "i" (-EFAULT) \
	174	: "memory"); \
	175	(x) = (typeof(*(ptr)))__gu_val; \
	176	break; \
	177	} */ \
	178	default: \
	179	__gu_err = __get_user_bad(); \
	180	break; \
	181	} \
	182	__gu_err; \
	183	})
	184	#define get_user(x, ptr) __get_user(x, ptr)
1da177e4	185
d94af931 RZ	186	unsigned long __generic_copy_from_user(void to, const void __user from, unsigned long n);
d94af931 RZ	187	unsigned long __generic_copy_to_user(void __user to, const void from, unsigned long n);
1da177e4	188
53617825 RZ	189	#define __constant_copy_from_user_asm(res, to, from, tmp, n, s1, s2, s3)\
	190	asm volatile ("\n" \
	191	"1: moves."#s1" (%2)+,%3\n" \
	192	" move."#s1" %3,(%1)+\n" \
	193	"2: moves."#s2" (%2)+,%3\n" \
	194	" move."#s2" %3,(%1)+\n" \
	195	" .ifnc \""#s3"\",\"\"\n" \
	196	"3: moves."#s3" (%2)+,%3\n" \
	197	" move."#s3" %3,(%1)+\n" \
	198	" .endif\n" \
	199	"4:\n" \
	200	" .section __ex_table,\"a\"\n" \
	201	" .align 4\n" \
	202	" .long 1b,10f\n" \
	203	" .long 2b,20f\n" \
	204	" .ifnc \""#s3"\",\"\"\n" \
	205	" .long 3b,30f\n" \
	206	" .endif\n" \
	207	" .previous\n" \
	208	"\n" \
	209	" .section .fixup,\"ax\"\n" \
	210	" .even\n" \
	211	"10: clr."#s1" (%1)+\n" \
	212	"20: clr."#s2" (%1)+\n" \
	213	" .ifnc \""#s3"\",\"\"\n" \
	214	"30: clr."#s3" (%1)+\n" \
	215	" .endif\n" \
	216	" moveq.l #"#n",%0\n" \
	217	" jra 4b\n" \
	218	" .previous\n" \
	219	: "+d" (res), "+&a" (to), "+a" (from), "=&d" (tmp) \
	220	: : "memory")
	221
d94af931 RZ	222	static __always_inline unsigned long
d94af931 RZ	223	__constant_copy_from_user(void to, const void __user from, unsigned long n)
1da177e4	224	{
d94af931	225	unsigned long res = 0, tmp;
1da177e4	226
d94af931	227	switch (n) {
1da177e4	228	case 1:
b971018b	229	__get_user_asm(res, (u8 )to, (u8 __user *)from, u8, b, d, 1);
53617825	230	break;
1da177e4	231	case 2:
b971018b	232	__get_user_asm(res, (u16 )to, (u16 __user *)from, u16, w, d, 2);
53617825 RZ	233	break;
	234	case 3:
	235	__constant_copy_from_user_asm(res, to, from, tmp, 3, w, b,);
	236	break;
d94af931	237	case 4:
b971018b	238	__get_user_asm(res, (u32 )to, (u32 __user *)from, u32, l, r, 4);
53617825 RZ	239	break;
	240	case 5:
	241	__constant_copy_from_user_asm(res, to, from, tmp, 5, l, b,);
	242	break;
	243	case 6:
	244	__constant_copy_from_user_asm(res, to, from, tmp, 6, l, w,);
	245	break;
	246	case 7:
	247	__constant_copy_from_user_asm(res, to, from, tmp, 7, l, w, b);
	248	break;
	249	case 8:
	250	__constant_copy_from_user_asm(res, to, from, tmp, 8, l, l,);
	251	break;
	252	case 9:
	253	__constant_copy_from_user_asm(res, to, from, tmp, 9, l, l, b);
	254	break;
	255	case 10:
	256	__constant_copy_from_user_asm(res, to, from, tmp, 10, l, l, w);
	257	break;
	258	case 12:
	259	__constant_copy_from_user_asm(res, to, from, tmp, 12, l, l, l);
	260	break;
	261	default:
	262	/* we limit the inlined version to 3 moves */
	263	return __generic_copy_from_user(to, from, n);
1da177e4	264	}
1da177e4	265
d94af931 RZ	266	return res;
d94af931 RZ	267	}
1da177e4	268
53617825 RZ	269	#define __constant_copy_to_user_asm(res, to, from, tmp, n, s1, s2, s3) \
	270	asm volatile ("\n" \
	271	" move."#s1" (%2)+,%3\n" \
	272	"11: moves."#s1" %3,(%1)+\n" \
	273	"12: move."#s2" (%2)+,%3\n" \
	274	"21: moves."#s2" %3,(%1)+\n" \
	275	"22:\n" \
	276	" .ifnc \""#s3"\",\"\"\n" \
	277	" move."#s3" (%2)+,%3\n" \
	278	"31: moves."#s3" %3,(%1)+\n" \
	279	"32:\n" \
	280	" .endif\n" \
	281	"4:\n" \
	282	"\n" \
	283	" .section __ex_table,\"a\"\n" \
	284	" .align 4\n" \
	285	" .long 11b,5f\n" \
	286	" .long 12b,5f\n" \
	287	" .long 21b,5f\n" \
	288	" .long 22b,5f\n" \
	289	" .ifnc \""#s3"\",\"\"\n" \
	290	" .long 31b,5f\n" \
	291	" .long 32b,5f\n" \
	292	" .endif\n" \
	293	" .previous\n" \
	294	"\n" \
	295	" .section .fixup,\"ax\"\n" \
	296	" .even\n" \
	297	"5: moveq.l #"#n",%0\n" \
	298	" jra 4b\n" \
	299	" .previous\n" \
	300	: "+d" (res), "+a" (to), "+a" (from), "=&d" (tmp) \
	301	: : "memory")
	302
d94af931	303	static __always_inline unsigned long
11c40f8a	304	__constant_copy_to_user(void __user to, const void from, unsigned long n)
1da177e4	305	{
d94af931 RZ	306	unsigned long res = 0, tmp;
d94af931 RZ	307
d94af931	308	switch (n) {
1da177e4	309	case 1:
b971018b	310	__put_user_asm(res, (u8 )from, (u8 __user *)to, b, d, 1);
53617825	311	break;
1da177e4	312	case 2:
b971018b	313	__put_user_asm(res, (u16 )from, (u16 __user *)to, w, d, 2);
53617825 RZ	314	break;
	315	case 3:
	316	__constant_copy_to_user_asm(res, to, from, tmp, 3, w, b,);
	317	break;
d94af931	318	case 4:
b971018b	319	__put_user_asm(res, (u32 )from, (u32 __user *)to, l, r, 4);
53617825 RZ	320	break;
	321	case 5:
	322	__constant_copy_to_user_asm(res, to, from, tmp, 5, l, b,);
	323	break;
	324	case 6:
	325	__constant_copy_to_user_asm(res, to, from, tmp, 6, l, w,);
	326	break;
	327	case 7:
	328	__constant_copy_to_user_asm(res, to, from, tmp, 7, l, w, b);
	329	break;
	330	case 8:
	331	__constant_copy_to_user_asm(res, to, from, tmp, 8, l, l,);
	332	break;
	333	case 9:
	334	__constant_copy_to_user_asm(res, to, from, tmp, 9, l, l, b);
	335	break;
	336	case 10:
	337	__constant_copy_to_user_asm(res, to, from, tmp, 10, l, l, w);
	338	break;
	339	case 12:
	340	__constant_copy_to_user_asm(res, to, from, tmp, 12, l, l, l);
	341	break;
	342	default:
	343	/* limit the inlined version to 3 moves */
	344	return __generic_copy_to_user(to, from, n);
1da177e4	345	}
d94af931	346
d94af931	347	return res;
1da177e4 LT	348	}
1da177e4 LT	349
d94af931	350	#define __copy_from_user(to, from, n) \
1da177e4 LT	351	(__builtin_constant_p(n) ? \
	352	__constant_copy_from_user(to, from, n) : \
	353	__generic_copy_from_user(to, from, n))
	354
d94af931	355	#define __copy_to_user(to, from, n) \
1da177e4 LT	356	(__builtin_constant_p(n) ? \
	357	__constant_copy_to_user(to, from, n) : \
	358	__generic_copy_to_user(to, from, n))
	359
d94af931 RZ	360	#define __copy_to_user_inatomic __copy_to_user
d94af931 RZ	361	#define __copy_from_user_inatomic __copy_from_user
1da177e4	362
d94af931 RZ	363	#define copy_from_user(to, from, n) __copy_from_user(to, from, n)
d94af931 RZ	364	#define copy_to_user(to, from, n) __copy_to_user(to, from, n)
1da177e4	365
d94af931 RZ	366	long strncpy_from_user(char dst, const char __user src, long count);
d94af931 RZ	367	long strnlen_user(const char __user *src, long n);
3c46bdca GU	368	unsigned long __clear_user(void __user *to, unsigned long n);
	369
	370	#define clear_user __clear_user
1da177e4 LT	371
	372	#define strlen_user(str) strnlen_user(str, 32767)
	373
1da177e4	374	#endif /* _M68K_UACCESS_H */