[mirror_ubuntu-focal-kernel.git] / arch / microblaze / include / asm / uaccess.h

/*
 * Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
 * Copyright (C) 2008-2009 PetaLogix
 * Copyright (C) 2006 Atmark Techno, Inc.
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License. See the file "COPYING" in the main directory of this archive
 * for more details.
 */

#ifndef _ASM_MICROBLAZE_UACCESS_H
#define _ASM_MICROBLAZE_UACCESS_H

#include <linux/kernel.h>
#include <linux/mm.h>

#include <asm/mmu.h>
#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/extable.h>
#include <linux/string.h>

/*
 * On Microblaze the fs value is actually the top of the corresponding
 * address space.
 *
 * The fs value determines whether argument validity checking should be
 * performed or not. If get_fs() == USER_DS, checking is performed, with
 * get_fs() == KERNEL_DS, checking is bypassed.
 *
 * For historical reasons, these macros are grossly misnamed.
 *
 * For non-MMU arch like Microblaze, KERNEL_DS and USER_DS is equal.
 */
# define MAKE_MM_SEG(s)       ((mm_segment_t) { (s) })

#  ifndef CONFIG_MMU
#  define KERNEL_DS	MAKE_MM_SEG(0)
#  define USER_DS	KERNEL_DS
#  else
#  define KERNEL_DS	MAKE_MM_SEG(0xFFFFFFFF)
#  define USER_DS	MAKE_MM_SEG(TASK_SIZE - 1)
#  endif

# define get_ds()	(KERNEL_DS)
# define get_fs()	(current_thread_info()->addr_limit)
# define set_fs(val)	(current_thread_info()->addr_limit = (val))

# define segment_eq(a, b)	((a).seg == (b).seg)

#ifndef CONFIG_MMU

/* Check against bounds of physical memory */
static inline int ___range_ok(unsigned long addr, unsigned long size)
{
	return ((addr < memory_start) ||
		((addr + size - 1) > (memory_start + memory_size - 1)));
}

#define __range_ok(addr, size) \
		___range_ok((unsigned long)(addr), (unsigned long)(size))

#define access_ok(addr, size) (__range_ok((addr), (size)) == 0)

#else

static inline int access_ok(const void __user *addr, unsigned long size)
{
	if (!size)
		goto ok;

	if ((get_fs().seg < ((unsigned long)addr)) ||
			(get_fs().seg < ((unsigned long)addr + size - 1))) {
		pr_devel("ACCESS fail at 0x%08x (size 0x%x), seg 0x%08x\n",
			(__force u32)addr, (u32)size,
			(u32)get_fs().seg);
		return 0;
	}
ok:
	pr_devel("ACCESS OK at 0x%08x (size 0x%x), seg 0x%08x\n",
			(__force u32)addr, (u32)size,
			(u32)get_fs().seg);
	return 1;
}
#endif

#ifdef CONFIG_MMU
# define __FIXUP_SECTION	".section .fixup,\"ax\"\n"
# define __EX_TABLE_SECTION	".section __ex_table,\"a\"\n"
#else
# define __FIXUP_SECTION	".section .discard,\"ax\"\n"
# define __EX_TABLE_SECTION	".section .discard,\"ax\"\n"
#endif

extern unsigned long __copy_tofrom_user(void __user *to,
		const void __user *from, unsigned long size);

/* Return: number of not copied bytes, i.e. 0 if OK or non-zero if fail. */
static inline unsigned long __must_check __clear_user(void __user *to,
							unsigned long n)
{
	/* normal memset with two words to __ex_table */
	__asm__ __volatile__ (				\
			"1:	sb	r0, %1, r0;"	\
			"	addik	%0, %0, -1;"	\
			"	bneid	%0, 1b;"	\
			"	addik	%1, %1, 1;"	\
			"2:			"	\
			__EX_TABLE_SECTION		\
			".word	1b,2b;"			\
			".previous;"			\
		: "=r"(n), "=r"(to)			\
		: "0"(n), "1"(to)
	);
	return n;
}

static inline unsigned long __must_check clear_user(void __user *to,
							unsigned long n)
{
	might_fault();
	if (unlikely(!access_ok(to, n)))
		return n;

	return __clear_user(to, n);
}

/* put_user and get_user macros */
extern long __user_bad(void);

#define __get_user_asm(insn, __gu_ptr, __gu_val, __gu_err)	\
({								\
	__asm__ __volatile__ (					\
			"1:"	insn	" %1, %2, r0;"		\
			"	addk	%0, r0, r0;"		\
			"2:			"		\
			__FIXUP_SECTION				\
			"3:	brid	2b;"			\
			"	addik	%0, r0, %3;"		\
			".previous;"				\
			__EX_TABLE_SECTION			\
			".word	1b,3b;"				\
			".previous;"				\
		: "=&r"(__gu_err), "=r"(__gu_val)		\
		: "r"(__gu_ptr), "i"(-EFAULT)			\
	);							\
})

/**
 * get_user: - Get a simple variable from user space.
 * @x:   Variable to store result.
 * @ptr: Source address, in user space.
 *
 * Context: User context only. This function may sleep if pagefaults are
 *          enabled.
 *
 * This macro copies a single simple variable from user space to kernel
 * space.  It supports simple types like char and int, but not larger
 * data types like structures or arrays.
 *
 * @ptr must have pointer-to-simple-variable type, and the result of
 * dereferencing @ptr must be assignable to @x without a cast.
 *
 * Returns zero on success, or -EFAULT on error.
 * On error, the variable @x is set to zero.
 */
#define get_user(x, ptr)						\
	__get_user_check((x), (ptr), sizeof(*(ptr)))

#define __get_user_check(x, ptr, size)					\
({									\
	unsigned long __gu_val = 0;					\
	const typeof(*(ptr)) __user *__gu_addr = (ptr);			\
	int __gu_err = 0;						\
									\
	if (access_ok(__gu_addr, size)) {			\
		switch (size) {						\
		case 1:							\
			__get_user_asm("lbu", __gu_addr, __gu_val,	\
				       __gu_err);			\
			break;						\
		case 2:							\
			__get_user_asm("lhu", __gu_addr, __gu_val,	\
				       __gu_err);			\
			break;						\
		case 4:							\
			__get_user_asm("lw", __gu_addr, __gu_val,	\
				       __gu_err);			\
			break;						\
		default:						\
			__gu_err = __user_bad();			\
			break;						\
		}							\
	} else {							\
		__gu_err = -EFAULT;					\
	}								\
	x = (__force typeof(*(ptr)))__gu_val;				\
	__gu_err;							\
})

#define __get_user(x, ptr)						\
({									\
	unsigned long __gu_val = 0;					\
	/*unsigned long __gu_ptr = (unsigned long)(ptr);*/		\
	long __gu_err;							\
	switch (sizeof(*(ptr))) {					\
	case 1:								\
		__get_user_asm("lbu", (ptr), __gu_val, __gu_err);	\
		break;							\
	case 2:								\
		__get_user_asm("lhu", (ptr), __gu_val, __gu_err);	\
		break;							\
	case 4:								\
		__get_user_asm("lw", (ptr), __gu_val, __gu_err);	\
		break;							\
	default:							\
		/* __gu_val = 0; __gu_err = -EINVAL;*/ __gu_err = __user_bad();\
	}								\
	x = (__force __typeof__(*(ptr))) __gu_val;			\
	__gu_err;							\
})


#define __put_user_asm(insn, __gu_ptr, __gu_val, __gu_err)	\
({								\
	__asm__ __volatile__ (					\
			"1:"	insn	" %1, %2, r0;"		\
			"	addk	%0, r0, r0;"		\
			"2:			"		\
			__FIXUP_SECTION				\
			"3:	brid	2b;"			\
			"	addik	%0, r0, %3;"		\
			".previous;"				\
			__EX_TABLE_SECTION			\
			".word	1b,3b;"				\
			".previous;"				\
		: "=&r"(__gu_err)				\
		: "r"(__gu_val), "r"(__gu_ptr), "i"(-EFAULT)	\
	);							\
})

#define __put_user_asm_8(__gu_ptr, __gu_val, __gu_err)		\
({								\
	__asm__ __volatile__ ("	lwi	%0, %1, 0;"		\
			"1:	swi	%0, %2, 0;"		\
			"	lwi	%0, %1, 4;"		\
			"2:	swi	%0, %2, 4;"		\
			"	addk	%0, r0, r0;"		\
			"3:			"		\
			__FIXUP_SECTION				\
			"4:	brid	3b;"			\
			"	addik	%0, r0, %3;"		\
			".previous;"				\
			__EX_TABLE_SECTION			\
			".word	1b,4b,2b,4b;"			\
			".previous;"				\
		: "=&r"(__gu_err)				\
		: "r"(&__gu_val), "r"(__gu_ptr), "i"(-EFAULT)	\
		);						\
})

/**
 * put_user: - Write a simple value into user space.
 * @x:   Value to copy to user space.
 * @ptr: Destination address, in user space.
 *
 * Context: User context only. This function may sleep if pagefaults are
 *          enabled.
 *
 * This macro copies a single simple value from kernel space to user
 * space.  It supports simple types like char and int, but not larger
 * data types like structures or arrays.
 *
 * @ptr must have pointer-to-simple-variable type, and @x must be assignable
 * to the result of dereferencing @ptr.
 *
 * Returns zero on success, or -EFAULT on error.
 */
#define put_user(x, ptr)						\
	__put_user_check((x), (ptr), sizeof(*(ptr)))

#define __put_user_check(x, ptr, size)					\
({									\
	typeof(*(ptr)) volatile __pu_val = x;				\
	typeof(*(ptr)) __user *__pu_addr = (ptr);			\
	int __pu_err = 0;						\
									\
	if (access_ok(__pu_addr, size)) {			\
		switch (size) {						\
		case 1:							\
			__put_user_asm("sb", __pu_addr, __pu_val,	\
				       __pu_err);			\
			break;						\
		case 2:							\
			__put_user_asm("sh", __pu_addr, __pu_val,	\
				       __pu_err);			\
			break;						\
		case 4:							\
			__put_user_asm("sw", __pu_addr, __pu_val,	\
				       __pu_err);			\
			break;						\
		case 8:							\
			__put_user_asm_8(__pu_addr, __pu_val, __pu_err);\
			break;						\
		default:						\
			__pu_err = __user_bad();			\
			break;						\
		}							\
	} else {							\
		__pu_err = -EFAULT;					\
	}								\
	__pu_err;							\
})

#define __put_user(x, ptr)						\
({									\
	__typeof__(*(ptr)) volatile __gu_val = (x);			\
	long __gu_err = 0;						\
	switch (sizeof(__gu_val)) {					\
	case 1:								\
		__put_user_asm("sb", (ptr), __gu_val, __gu_err);	\
		break;							\
	case 2:								\
		__put_user_asm("sh", (ptr), __gu_val, __gu_err);	\
		break;							\
	case 4:								\
		__put_user_asm("sw", (ptr), __gu_val, __gu_err);	\
		break;							\
	case 8:								\
		__put_user_asm_8((ptr), __gu_val, __gu_err);		\
		break;							\
	default:							\
		/*__gu_err = -EINVAL;*/	__gu_err = __user_bad();	\
	}								\
	__gu_err;							\
})

static inline unsigned long
raw_copy_from_user(void *to, const void __user *from, unsigned long n)
{
	return __copy_tofrom_user((__force void __user *)to, from, n);
}

static inline unsigned long
raw_copy_to_user(void __user *to, const void *from, unsigned long n)
{
	return __copy_tofrom_user(to, (__force const void __user *)from, n);
}
#define INLINE_COPY_FROM_USER
#define INLINE_COPY_TO_USER

/*
 * Copy a null terminated string from userspace.
 */
extern int __strncpy_user(char *to, const char __user *from, int len);

static inline long
strncpy_from_user(char *dst, const char __user *src, long count)
{
	if (!access_ok(src, 1))
		return -EFAULT;
	return __strncpy_user(dst, src, count);
}

/*
 * Return the size of a string (including the ending 0)
 *
 * Return 0 on exception, a value greater than N if too long
 */
extern int __strnlen_user(const char __user *sstr, int len);

static inline long strnlen_user(const char __user *src, long n)
{
	if (!access_ok(src, 1))
		return 0;
	return __strnlen_user(src, n);
}

#endif /* _ASM_MICROBLAZE_UACCESS_H */
Commit	Line	Data
2660663f	1	/*
0d6de953 MS	2	* Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
0d6de953 MS	3	* Copyright (C) 2008-2009 PetaLogix
2660663f MS	4	* Copyright (C) 2006 Atmark Techno, Inc.
	5	*
	6	* This file is subject to the terms and conditions of the GNU General Public
	7	* License. See the file "COPYING" in the main directory of this archive
	8	* for more details.
	9	*/
	10
	11	#ifndef _ASM_MICROBLAZE_UACCESS_H
	12	#define _ASM_MICROBLAZE_UACCESS_H
	13
2660663f	14	#include <linux/kernel.h>
2660663f MS	15	#include <linux/mm.h>
	16
	17	#include <asm/mmu.h>
	18	#include <asm/page.h>
	19	#include <asm/pgtable.h>
730132e7	20	#include <asm/extable.h>
2660663f MS	21	#include <linux/string.h>
2660663f MS	22
40db0834 MS	23	/*
	24	* On Microblaze the fs value is actually the top of the corresponding
	25	* address space.
	26	*
	27	* The fs value determines whether argument validity checking should be
	28	* performed or not. If get_fs() == USER_DS, checking is performed, with
	29	* get_fs() == KERNEL_DS, checking is bypassed.
	30	*
	31	* For historical reasons, these macros are grossly misnamed.
	32	*
	33	* For non-MMU arch like Microblaze, KERNEL_DS and USER_DS is equal.
	34	*/
	35	# define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
	36
	37	# ifndef CONFIG_MMU
	38	# define KERNEL_DS MAKE_MM_SEG(0)
	39	# define USER_DS KERNEL_DS
	40	# else
	41	# define KERNEL_DS MAKE_MM_SEG(0xFFFFFFFF)
	42	# define USER_DS MAKE_MM_SEG(TASK_SIZE - 1)
	43	# endif
	44
	45	# define get_ds() (KERNEL_DS)
	46	# define get_fs() (current_thread_info()->addr_limit)
	47	# define set_fs(val) (current_thread_info()->addr_limit = (val))
	48
	49	# define segment_eq(a, b) ((a).seg == (b).seg)
	50
0d6de953 MS	51	#ifndef CONFIG_MMU
0d6de953 MS	52
60a729f7 MS	53	/* Check against bounds of physical memory */
	54	static inline int ___range_ok(unsigned long addr, unsigned long size)
	55	{
	56	return ((addr < memory_start) \|\|
83a92529	57	((addr + size - 1) > (memory_start + memory_size - 1)));
60a729f7	58	}
2660663f MS	59
	60	#define __range_ok(addr, size) \
	61	___range_ok((unsigned long)(addr), (unsigned long)(size))
	62
96d4f267	63	#define access_ok(addr, size) (__range_ok((addr), (size)) == 0)
40b1156d MS	64
	65	#else
	66
96d4f267	67	static inline int access_ok(const void __user *addr, unsigned long size)
f663b60f MS	68	{
	69	if (!size)
	70	goto ok;
	71
	72	if ((get_fs().seg < ((unsigned long)addr)) \|\|
	73	(get_fs().seg < ((unsigned long)addr + size - 1))) {
96d4f267 LT	74	pr_devel("ACCESS fail at 0x%08x (size 0x%x), seg 0x%08x\n",
96d4f267 LT	75	(__force u32)addr, (u32)size,
f663b60f MS	76	(u32)get_fs().seg);
	77	return 0;
	78	}
	79	ok:
96d4f267 LT	80	pr_devel("ACCESS OK at 0x%08x (size 0x%x), seg 0x%08x\n",
96d4f267 LT	81	(__force u32)addr, (u32)size,
f663b60f MS	82	(u32)get_fs().seg);
	83	return 1;
	84	}
40b1156d MS	85	#endif
	86
	87	#ifdef CONFIG_MMU
	88	# define __FIXUP_SECTION ".section .fixup,\"ax\"\n"
	89	# define __EX_TABLE_SECTION ".section __ex_table,\"a\"\n"
	90	#else
	91	# define __FIXUP_SECTION ".section .discard,\"ax\"\n"
7e278157	92	# define __EX_TABLE_SECTION ".section .discard,\"ax\"\n"
40b1156d MS	93	#endif
40b1156d MS	94
94804a9b MS	95	extern unsigned long __copy_tofrom_user(void __user *to,
	96	const void __user *from, unsigned long size);
	97
527bdb52 MS	98	/* Return: number of not copied bytes, i.e. 0 if OK or non-zero if fail. */
	99	static inline unsigned long __must_check __clear_user(void __user *to,
	100	unsigned long n)
	101	{
	102	/* normal memset with two words to __ex_table */
	103	__asm__ __volatile__ ( \
6f3946b4	104	"1: sb r0, %1, r0;" \
527bdb52 MS	105	" addik %0, %0, -1;" \
527bdb52 MS	106	" bneid %0, 1b;" \
6f3946b4	107	" addik %1, %1, 1;" \
527bdb52 MS	108	"2: " \
	109	__EX_TABLE_SECTION \
	110	".word 1b,2b;" \
	111	".previous;" \
6f3946b4 SM	112	: "=r"(n), "=r"(to) \
6f3946b4 SM	113	: "0"(n), "1"(to)
527bdb52 MS	114	);
	115	return n;
	116	}
	117
	118	static inline unsigned long __must_check clear_user(void __user *to,
	119	unsigned long n)
	120	{
ac093f8d	121	might_fault();
96d4f267	122	if (unlikely(!access_ok(to, n)))
527bdb52 MS	123	return n;
	124
	125	return __clear_user(to, n);
	126	}
	127
cca79120	128	/* put_user and get_user macros */
3a6d7724 MS	129	extern long __user_bad(void);
	130
	131	#define __get_user_asm(insn, __gu_ptr, __gu_val, __gu_err) \
	132	({ \
	133	__asm__ __volatile__ ( \
	134	"1:" insn " %1, %2, r0;" \
	135	" addk %0, r0, r0;" \
	136	"2: " \
	137	__FIXUP_SECTION \
	138	"3: brid 2b;" \
	139	" addik %0, r0, %3;" \
	140	".previous;" \
	141	__EX_TABLE_SECTION \
	142	".word 1b,3b;" \
	143	".previous;" \
	144	: "=&r"(__gu_err), "=r"(__gu_val) \
	145	: "r"(__gu_ptr), "i"(-EFAULT) \
	146	); \
	147	})
	148
	149	/**
	150	* get_user: - Get a simple variable from user space.
	151	* @x: Variable to store result.
	152	* @ptr: Source address, in user space.
	153	*
b3c395ef DH	154	* Context: User context only. This function may sleep if pagefaults are
b3c395ef DH	155	* enabled.
3a6d7724 MS	156	*
	157	* This macro copies a single simple variable from user space to kernel
	158	* space. It supports simple types like char and int, but not larger
	159	* data types like structures or arrays.
	160	*
	161	* @ptr must have pointer-to-simple-variable type, and the result of
	162	* dereferencing @ptr must be assignable to @x without a cast.
	163	*
	164	* Returns zero on success, or -EFAULT on error.
	165	* On error, the variable @x is set to zero.
	166	*/
538722ca SM	167	#define get_user(x, ptr) \
	168	__get_user_check((x), (ptr), sizeof(*(ptr)))
	169
	170	#define __get_user_check(x, ptr, size) \
	171	({ \
	172	unsigned long __gu_val = 0; \
	173	const typeof((ptr)) __user __gu_addr = (ptr); \
	174	int __gu_err = 0; \
	175	\
96d4f267	176	if (access_ok(__gu_addr, size)) { \
538722ca SM	177	switch (size) { \
	178	case 1: \
	179	__get_user_asm("lbu", __gu_addr, __gu_val, \
	180	__gu_err); \
	181	break; \
	182	case 2: \
	183	__get_user_asm("lhu", __gu_addr, __gu_val, \
	184	__gu_err); \
	185	break; \
	186	case 4: \
	187	__get_user_asm("lw", __gu_addr, __gu_val, \
	188	__gu_err); \
	189	break; \
	190	default: \
	191	__gu_err = __user_bad(); \
	192	break; \
	193	} \
	194	} else { \
	195	__gu_err = -EFAULT; \
	196	} \
0774bf6a	197	x = (__force typeof(*(ptr)))__gu_val; \
538722ca SM	198	__gu_err; \
538722ca SM	199	})
838d2406	200
3a6d7724 MS	201	#define __get_user(x, ptr) \
3a6d7724 MS	202	({ \
e98b9e37	203	unsigned long __gu_val = 0; \
3a6d7724 MS	204	/unsigned long __gu_ptr = (unsigned long)(ptr);/ \
	205	long __gu_err; \
	206	switch (sizeof(*(ptr))) { \
	207	case 1: \
	208	__get_user_asm("lbu", (ptr), __gu_val, __gu_err); \
	209	break; \
	210	case 2: \
	211	__get_user_asm("lhu", (ptr), __gu_val, __gu_err); \
	212	break; \
	213	case 4: \
	214	__get_user_asm("lw", (ptr), __gu_val, __gu_err); \
	215	break; \
	216	default: \
	217	/* __gu_val = 0; __gu_err = -EINVAL;*/ __gu_err = __user_bad();\
	218	} \
0774bf6a	219	x = (__force __typeof__(*(ptr))) __gu_val; \
3a6d7724	220	__gu_err; \
0d6de953	221	})
2660663f	222
3a6d7724	223
ef4e277b MS	224	#define __put_user_asm(insn, __gu_ptr, __gu_val, __gu_err) \
	225	({ \
	226	__asm__ __volatile__ ( \
	227	"1:" insn " %1, %2, r0;" \
	228	" addk %0, r0, r0;" \
	229	"2: " \
	230	__FIXUP_SECTION \
	231	"3: brid 2b;" \
	232	" addik %0, r0, %3;" \
	233	".previous;" \
	234	__EX_TABLE_SECTION \
	235	".word 1b,3b;" \
	236	".previous;" \
	237	: "=&r"(__gu_err) \
	238	: "r"(__gu_val), "r"(__gu_ptr), "i"(-EFAULT) \
	239	); \
	240	})
2660663f	241
ef4e277b	242	#define __put_user_asm_8(__gu_ptr, __gu_val, __gu_err) \
0d6de953	243	({ \
ef4e277b MS	244	__asm__ __volatile__ (" lwi %0, %1, 0;" \
	245	"1: swi %0, %2, 0;" \
	246	" lwi %0, %1, 4;" \
	247	"2: swi %0, %2, 4;" \
	248	" addk %0, r0, r0;" \
	249	"3: " \
	250	__FIXUP_SECTION \
	251	"4: brid 3b;" \
	252	" addik %0, r0, %3;" \
	253	".previous;" \
	254	__EX_TABLE_SECTION \
	255	".word 1b,4b,2b,4b;" \
	256	".previous;" \
	257	: "=&r"(__gu_err) \
	258	: "r"(&__gu_val), "r"(__gu_ptr), "i"(-EFAULT) \
	259	); \
0d6de953	260	})
2660663f	261
cca79120 MS	262	/**
	263	* put_user: - Write a simple value into user space.
	264	* @x: Value to copy to user space.
	265	* @ptr: Destination address, in user space.
	266	*
b3c395ef DH	267	* Context: User context only. This function may sleep if pagefaults are
b3c395ef DH	268	* enabled.
cca79120 MS	269	*
	270	* This macro copies a single simple value from kernel space to user
	271	* space. It supports simple types like char and int, but not larger
	272	* data types like structures or arrays.
	273	*
	274	* @ptr must have pointer-to-simple-variable type, and @x must be assignable
	275	* to the result of dereferencing @ptr.
	276	*
	277	* Returns zero on success, or -EFAULT on error.
	278	*/
538722ca SM	279	#define put_user(x, ptr) \
	280	__put_user_check((x), (ptr), sizeof(*(ptr)))
	281
	282	#define __put_user_check(x, ptr, size) \
	283	({ \
132d5dfc	284	typeof(*(ptr)) volatile __pu_val = x; \
538722ca SM	285	typeof((ptr)) __user __pu_addr = (ptr); \
	286	int __pu_err = 0; \
	287	\
96d4f267	288	if (access_ok(__pu_addr, size)) { \
538722ca SM	289	switch (size) { \
	290	case 1: \
	291	__put_user_asm("sb", __pu_addr, __pu_val, \
	292	__pu_err); \
	293	break; \
	294	case 2: \
	295	__put_user_asm("sh", __pu_addr, __pu_val, \
	296	__pu_err); \
	297	break; \
	298	case 4: \
	299	__put_user_asm("sw", __pu_addr, __pu_val, \
	300	__pu_err); \
	301	break; \
	302	case 8: \
	303	__put_user_asm_8(__pu_addr, __pu_val, __pu_err);\
	304	break; \
	305	default: \
	306	__pu_err = __user_bad(); \
	307	break; \
	308	} \
	309	} else { \
	310	__pu_err = -EFAULT; \
	311	} \
	312	__pu_err; \
	313	})
cca79120	314
ef4e277b MS	315	#define __put_user(x, ptr) \
	316	({ \
	317	__typeof__(*(ptr)) volatile __gu_val = (x); \
	318	long __gu_err = 0; \
	319	switch (sizeof(__gu_val)) { \
	320	case 1: \
	321	__put_user_asm("sb", (ptr), __gu_val, __gu_err); \
	322	break; \
	323	case 2: \
	324	__put_user_asm("sh", (ptr), __gu_val, __gu_err); \
	325	break; \
	326	case 4: \
	327	__put_user_asm("sw", (ptr), __gu_val, __gu_err); \
	328	break; \
	329	case 8: \
	330	__put_user_asm_8((ptr), __gu_val, __gu_err); \
	331	break; \
	332	default: \
	333	/__gu_err = -EINVAL;/ __gu_err = __user_bad(); \
	334	} \
	335	__gu_err; \
	336	})
2660663f	337
d491afb8 AV	338	static inline unsigned long
d491afb8 AV	339	raw_copy_from_user(void to, const void __user from, unsigned long n)
4270690b	340	{
d491afb8	341	return __copy_tofrom_user((__force void __user *)to, from, n);
4270690b MS	342	}
4270690b MS	343
d491afb8 AV	344	static inline unsigned long
d491afb8 AV	345	raw_copy_to_user(void __user to, const void from, unsigned long n)
cc5a428b	346	{
d491afb8	347	return __copy_tofrom_user(to, (__force const void __user *)from, n);
89ae9753	348	}
d491afb8 AV	349	#define INLINE_COPY_FROM_USER
d491afb8 AV	350	#define INLINE_COPY_TO_USER
89ae9753 MS	351
	352	/*
	353	* Copy a null terminated string from userspace.
	354	*/
	355	extern int __strncpy_user(char to, const char __user from, int len);
	356
89ae9753 MS	357	static inline long
	358	strncpy_from_user(char dst, const char __user src, long count)
	359	{
96d4f267	360	if (!access_ok(src, 1))
89ae9753	361	return -EFAULT;
10503bf9	362	return __strncpy_user(dst, src, count);
89ae9753 MS	363	}
	364
	365	/*
	366	* Return the size of a string (including the ending 0)
	367	*
	368	* Return 0 on exception, a value greater than N if too long
	369	*/
	370	extern int __strnlen_user(const char __user *sstr, int len);
	371
	372	static inline long strnlen_user(const char __user *src, long n)
	373	{
96d4f267	374	if (!access_ok(src, 1))
89ae9753 MS	375	return 0;
89ae9753 MS	376	return __strnlen_user(src, n);
cc5a428b MS	377	}
cc5a428b MS	378
2660663f	379	#endif /* _ASM_MICROBLAZE_UACCESS_H */