1/*
2 * Copyright 2004-2009 Analog Devices Inc.
3 *
4 * Licensed under the GPL-2 or later.
5 *
6 * Based on: include/asm-m68knommu/uaccess.h
7 */
8
9#ifndef __BLACKFIN_UACCESS_H
10#define __BLACKFIN_UACCESS_H
11
12/*
13 * User space memory access functions
14 */
15#include <linux/sched.h>
16#include <linux/mm.h>
17#include <linux/string.h>
18
19#include <asm/segment.h>
20#include <asm/sections.h>
21
22#define get_ds()        (KERNEL_DS)
23#define get_fs()        (current_thread_info()->addr_limit)
24
25static inline void set_fs(mm_segment_t fs)
26{
27	current_thread_info()->addr_limit = fs;
28}
29
30#define segment_eq(a, b) ((a) == (b))
31
32#define VERIFY_READ	0
33#define VERIFY_WRITE	1
34
35#define access_ok(type, addr, size) _access_ok((unsigned long)(addr), (size))
36
37/*
38 * The fs value determines whether argument validity checking should be
39 * performed or not.  If get_fs() == USER_DS, checking is performed, with
40 * get_fs() == KERNEL_DS, checking is bypassed.
41 */
42
43#ifndef CONFIG_ACCESS_CHECK
44static inline int _access_ok(unsigned long addr, unsigned long size) { return 1; }
45#else
46extern int _access_ok(unsigned long addr, unsigned long size);
47#endif
48
49/*
50 * The exception table consists of pairs of addresses: the first is the
51 * address of an instruction that is allowed to fault, and the second is
52 * the address at which the program should continue.  No registers are
53 * modified, so it is entirely up to the continuation code to figure out
54 * what to do.
55 *
56 * All the routines below use bits of fixup code that are out of line
57 * with the main instruction path.  This means when everything is well,
58 * we don't even have to jump over them.  Further, they do not intrude
59 * on our cache or tlb entries.
60 */
61
62struct exception_table_entry {
63	unsigned long insn, fixup;
64};
65
66/*
67 * These are the main single-value transfer routines.  They automatically
68 * use the right size if we just have the right pointer type.
69 */
70
71#define put_user(x, p)						\
72	({							\
73		int _err = 0;					\
74		typeof(*(p)) _x = (x);				\
75		typeof(*(p)) __user *_p = (p);			\
76		if (!access_ok(VERIFY_WRITE, _p, sizeof(*(_p)))) {\
77			_err = -EFAULT;				\
78		}						\
79		else {						\
80		switch (sizeof (*(_p))) {			\
81		case 1:						\
82			__put_user_asm(_x, _p, B);		\
83			break;					\
84		case 2:						\
85			__put_user_asm(_x, _p, W);		\
86			break;					\
87		case 4:						\
88			__put_user_asm(_x, _p,  );		\
89			break;					\
90		case 8: {					\
91			long _xl, _xh;				\
92			_xl = ((__force long *)&_x)[0];		\
93			_xh = ((__force long *)&_x)[1];		\
94			__put_user_asm(_xl, ((__force long __user *)_p)+0, );\
95			__put_user_asm(_xh, ((__force long __user *)_p)+1, );\
96		} break;					\
97		default:					\
98			_err = __put_user_bad();		\
99			break;					\
100		}						\
101		}						\
102		_err;						\
103	})
104
105#define __put_user(x, p) put_user(x, p)
106static inline int bad_user_access_length(void)
107{
108	panic("bad_user_access_length");
109	return -1;
110}
111
112#define __put_user_bad() (printk(KERN_INFO "put_user_bad %s:%d %s\n",\
113                           __FILE__, __LINE__, __func__),\
114                           bad_user_access_length(), (-EFAULT))
115
116/*
117 * Tell gcc we read from memory instead of writing: this is because
118 * we do not write to any memory gcc knows about, so there are no
119 * aliasing issues.
120 */
121
122#define __ptr(x) ((unsigned long __force *)(x))
123
124#define __put_user_asm(x, p, bhw)			\
125	__asm__ (#bhw"[%1] = %0;\n\t"			\
126		 : /* no outputs */			\
127		 :"d" (x), "a" (__ptr(p)) : "memory")
128
129#define get_user(x, ptr)					\
130({								\
131	int _err = 0;						\
132	unsigned long _val = 0;					\
133	const typeof(*(ptr)) __user *_p = (ptr);		\
134	const size_t ptr_size = sizeof(*(_p));			\
135	if (likely(access_ok(VERIFY_READ, _p, ptr_size))) {	\
136		BUILD_BUG_ON(ptr_size >= 8);			\
137		switch (ptr_size) {				\
138		case 1:						\
139			__get_user_asm(_val, _p, B, (Z));	\
140			break;					\
141		case 2:						\
142			__get_user_asm(_val, _p, W, (Z));	\
143			break;					\
144		case 4:						\
145			__get_user_asm(_val, _p,  , );		\
146			break;					\
147		}						\
148	} else							\
149		_err = -EFAULT;					\
150	x = (__force typeof(*(ptr)))_val;			\
151	_err;							\
152})
153
154#define __get_user(x, p) get_user(x, p)
155
156#define __get_user_bad() (bad_user_access_length(), (-EFAULT))
157
158#define __get_user_asm(x, ptr, bhw, option)	\
159({						\
160	__asm__ __volatile__ (			\
161		"%0 =" #bhw "[%1]" #option ";"	\
162		: "=d" (x)			\
163		: "a" (__ptr(ptr)));		\
164})
165
166#define __copy_from_user(to, from, n) copy_from_user(to, from, n)
167#define __copy_to_user(to, from, n) copy_to_user(to, from, n)
168#define __copy_to_user_inatomic __copy_to_user
169#define __copy_from_user_inatomic __copy_from_user
170
171#define copy_to_user_ret(to, from, n, retval) ({ if (copy_to_user(to, from, n))\
172				                 return retval; })
173
174#define copy_from_user_ret(to, from, n, retval) ({ if (copy_from_user(to, from, n))\
175                                                   return retval; })
176
177static inline unsigned long __must_check
178copy_from_user(void *to, const void __user *from, unsigned long n)
179{
180	if (access_ok(VERIFY_READ, from, n))
181		memcpy(to, (const void __force *)from, n);
182	else
183		return n;
184	return 0;
185}
186
187static inline unsigned long __must_check
188copy_to_user(void __user *to, const void *from, unsigned long n)
189{
190	if (access_ok(VERIFY_WRITE, to, n))
191		memcpy((void __force *)to, from, n);
192	else
193		return n;
194	SSYNC();
195	return 0;
196}
197
198/*
199 * Copy a null terminated string from userspace.
200 */
201
202static inline long __must_check
203strncpy_from_user(char *dst, const char __user *src, long count)
204{
205	char *tmp;
206	if (!access_ok(VERIFY_READ, src, 1))
207		return -EFAULT;
208	strncpy(dst, (const char __force *)src, count);
209	for (tmp = dst; *tmp && count > 0; tmp++, count--) ;
210	return (tmp - dst);
211}
212
213/*
214 * Get the size of a string in user space.
215 *   src: The string to measure
216 *     n: The maximum valid length
217 *
218 * Get the size of a NUL-terminated string in user space.
219 *
220 * Returns the size of the string INCLUDING the terminating NUL.
221 * On exception, returns 0.
222 * If the string is too long, returns a value greater than n.
223 */
224static inline long __must_check strnlen_user(const char __user *src, long n)
225{
226	if (!access_ok(VERIFY_READ, src, 1))
227		return 0;
228	return strnlen((const char __force *)src, n) + 1;
229}
230
231static inline long __must_check strlen_user(const char __user *src)
232{
233	if (!access_ok(VERIFY_READ, src, 1))
234		return 0;
235	return strlen((const char __force *)src) + 1;
236}
237
238/*
239 * Zero Userspace
240 */
241
242static inline unsigned long __must_check
243__clear_user(void __user *to, unsigned long n)
244{
245	if (!access_ok(VERIFY_WRITE, to, n))
246		return n;
247	memset((void __force *)to, 0, n);
248	return 0;
249}
250
251#define clear_user(to, n) __clear_user(to, n)
252
253/* How to interpret these return values:
254 *	CORE:      can be accessed by core load or dma memcpy
255 *	CORE_ONLY: can only be accessed by core load
256 *	DMA:       can only be accessed by dma memcpy
257 *	IDMA:      can only be accessed by interprocessor dma memcpy (BF561)
258 *	ITEST:     can be accessed by isram memcpy or dma memcpy
259 */
260enum {
261	BFIN_MEM_ACCESS_CORE = 0,
262	BFIN_MEM_ACCESS_CORE_ONLY,
263	BFIN_MEM_ACCESS_DMA,
264	BFIN_MEM_ACCESS_IDMA,
265	BFIN_MEM_ACCESS_ITEST,
266};
267/**
268 *	bfin_mem_access_type() - what kind of memory access is required
269 *	@addr:   the address to check
270 *	@size:   number of bytes needed
271 *	@return: <0 is error, >=0 is BFIN_MEM_ACCESS_xxx enum (see above)
272 */
273int bfin_mem_access_type(unsigned long addr, unsigned long size);
274
275#endif				/* _BLACKFIN_UACCESS_H */
276