b920de1b77
Add architecture support for the MN10300/AM33 CPUs produced by MEI to the kernel. This patch also adds board support for the ASB2303 with the ASB2308 daughter board, and the ASB2305. The only processor supported is the MN103E010, which is an AM33v2 core plus on-chip devices. [akpm@linux-foundation.org: nuke cvs control strings] Signed-off-by: Masakazu Urade <urade.masakazu@jp.panasonic.com> Signed-off-by: Koichi Yasutake <yasutake.koichi@jp.panasonic.com> Signed-off-by: David Howells <dhowells@redhat.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
490 lines
13 KiB
C
490 lines
13 KiB
C
/* MN10300 userspace access functions
|
|
*
|
|
* Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
|
|
* Written by David Howells (dhowells@redhat.com)
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public Licence
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the Licence, or (at your option) any later version.
|
|
*/
|
|
#ifndef _ASM_UACCESS_H
|
|
#define _ASM_UACCESS_H
|
|
|
|
/*
|
|
* User space memory access functions
|
|
*/
|
|
#include <linux/sched.h>
|
|
#include <asm/page.h>
|
|
#include <asm/pgtable.h>
|
|
#include <asm/errno.h>
|
|
|
|
#define VERIFY_READ 0
|
|
#define VERIFY_WRITE 1
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
|
|
#define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
|
|
|
|
#define KERNEL_XDS MAKE_MM_SEG(0xBFFFFFFF)
|
|
#define KERNEL_DS MAKE_MM_SEG(0x9FFFFFFF)
|
|
#define USER_DS MAKE_MM_SEG(TASK_SIZE)
|
|
|
|
#define get_ds() (KERNEL_DS)
|
|
#define get_fs() (current_thread_info()->addr_limit)
|
|
#define set_fs(x) (current_thread_info()->addr_limit = (x))
|
|
#define __kernel_ds_p() (current_thread_info()->addr_limit.seg == 0x9FFFFFFF)
|
|
|
|
#define segment_eq(a, b) ((a).seg == (b).seg)
|
|
|
|
#define __addr_ok(addr) \
|
|
((unsigned long)(addr) < (current_thread_info()->addr_limit.seg))
|
|
|
|
/*
|
|
* check that a range of addresses falls within the current address limit
|
|
*/
|
|
static inline int ___range_ok(unsigned long addr, unsigned int size)
|
|
{
|
|
int flag = 1, tmp;
|
|
|
|
asm(" add %3,%1 \n" /* set C-flag if addr + size > 4Gb */
|
|
" bcs 0f \n"
|
|
" cmp %4,%1 \n" /* jump if addr+size>limit (error) */
|
|
" bhi 0f \n"
|
|
" clr %0 \n" /* mark okay */
|
|
"0: \n"
|
|
: "=r"(flag), "=&r"(tmp)
|
|
: "1"(addr), "ir"(size),
|
|
"r"(current_thread_info()->addr_limit.seg), "0"(flag)
|
|
: "cc"
|
|
);
|
|
|
|
return flag;
|
|
}
|
|
|
|
#define __range_ok(addr, size) ___range_ok((unsigned long)(addr), (u32)(size))
|
|
|
|
#define access_ok(type, addr, size) (__range_ok((addr), (size)) == 0)
|
|
#define __access_ok(addr, size) (__range_ok((addr), (size)) == 0)
|
|
|
|
static inline int verify_area(int type, const void *addr, unsigned long size)
|
|
{
|
|
return access_ok(type, addr, size) ? 0 : -EFAULT;
|
|
}
|
|
|
|
|
|
/*
|
|
* 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;
|
|
};
|
|
|
|
/* Returns 0 if exception not found and fixup otherwise. */
|
|
extern int fixup_exception(struct pt_regs *regs);
|
|
|
|
#define put_user(x, ptr) __put_user_check((x), (ptr), sizeof(*(ptr)))
|
|
#define get_user(x, ptr) __get_user_check((x), (ptr), sizeof(*(ptr)))
|
|
|
|
/*
|
|
* The "__xxx" versions do not do address space checking, useful when
|
|
* doing multiple accesses to the same area (the user has to do the
|
|
* checks by hand with "access_ok()")
|
|
*/
|
|
#define __put_user(x, ptr) __put_user_nocheck((x), (ptr), sizeof(*(ptr)))
|
|
#define __get_user(x, ptr) __get_user_nocheck((x), (ptr), sizeof(*(ptr)))
|
|
|
|
/*
|
|
* The "xxx_ret" versions return constant specified in third argument, if
|
|
* something bad happens. These macros can be optimized for the
|
|
* case of just returning from the function xxx_ret is used.
|
|
*/
|
|
|
|
#define put_user_ret(x, ptr, ret) \
|
|
({ if (put_user((x), (ptr))) return (ret); })
|
|
#define get_user_ret(x, ptr, ret) \
|
|
({ if (get_user((x), (ptr))) return (ret); })
|
|
#define __put_user_ret(x, ptr, ret) \
|
|
({ if (__put_user((x), (ptr))) return (ret); })
|
|
#define __get_user_ret(x, ptr, ret) \
|
|
({ if (__get_user((x), (ptr))) return (ret); })
|
|
|
|
struct __large_struct { unsigned long buf[100]; };
|
|
#define __m(x) (*(struct __large_struct *)(x))
|
|
|
|
#define __get_user_nocheck(x, ptr, size) \
|
|
({ \
|
|
__typeof(*(ptr)) __gu_val; \
|
|
unsigned long __gu_addr; \
|
|
int __gu_err; \
|
|
__gu_addr = (unsigned long) (ptr); \
|
|
switch (size) { \
|
|
case 1: __get_user_asm("bu"); break; \
|
|
case 2: __get_user_asm("hu"); break; \
|
|
case 4: __get_user_asm("" ); break; \
|
|
default: __get_user_unknown(); break; \
|
|
} \
|
|
x = (__typeof__(*(ptr))) __gu_val; \
|
|
__gu_err; \
|
|
})
|
|
|
|
#define __get_user_check(x, ptr, size) \
|
|
({ \
|
|
__typeof__(*(ptr)) __gu_val; \
|
|
unsigned long __gu_addr; \
|
|
int __gu_err; \
|
|
__gu_addr = (unsigned long) (ptr); \
|
|
if (likely(__access_ok(__gu_addr,size))) { \
|
|
switch (size) { \
|
|
case 1: __get_user_asm("bu"); break; \
|
|
case 2: __get_user_asm("hu"); break; \
|
|
case 4: __get_user_asm("" ); break; \
|
|
default: __get_user_unknown(); break; \
|
|
} \
|
|
} \
|
|
else { \
|
|
__gu_err = -EFAULT; \
|
|
__gu_val = 0; \
|
|
} \
|
|
x = (__typeof__(*(ptr))) __gu_val; \
|
|
__gu_err; \
|
|
})
|
|
|
|
#define __get_user_asm(INSN) \
|
|
({ \
|
|
asm volatile( \
|
|
"1:\n" \
|
|
" mov"INSN" %2,%1\n" \
|
|
" mov 0,%0\n" \
|
|
"2:\n" \
|
|
" .section .fixup,\"ax\"\n" \
|
|
"3:\n\t" \
|
|
" mov %3,%0\n" \
|
|
" jmp 2b\n" \
|
|
" .previous\n" \
|
|
" .section __ex_table,\"a\"\n" \
|
|
" .balign 4\n" \
|
|
" .long 1b, 3b\n" \
|
|
" .previous" \
|
|
: "=&r" (__gu_err), "=&r" (__gu_val) \
|
|
: "m" (__m(__gu_addr)), "i" (-EFAULT)); \
|
|
})
|
|
|
|
extern int __get_user_unknown(void);
|
|
|
|
#define __put_user_nocheck(x, ptr, size) \
|
|
({ \
|
|
union { \
|
|
__typeof__(*(ptr)) val; \
|
|
u32 bits[2]; \
|
|
} __pu_val; \
|
|
unsigned long __pu_addr; \
|
|
int __pu_err; \
|
|
__pu_val.val = (x); \
|
|
__pu_addr = (unsigned long) (ptr); \
|
|
switch (size) { \
|
|
case 1: __put_user_asm("bu"); break; \
|
|
case 2: __put_user_asm("hu"); break; \
|
|
case 4: __put_user_asm("" ); break; \
|
|
case 8: __put_user_asm8(); break; \
|
|
default: __pu_err = __put_user_unknown(); break; \
|
|
} \
|
|
__pu_err; \
|
|
})
|
|
|
|
#define __put_user_check(x, ptr, size) \
|
|
({ \
|
|
union { \
|
|
__typeof__(*(ptr)) val; \
|
|
u32 bits[2]; \
|
|
} __pu_val; \
|
|
unsigned long __pu_addr; \
|
|
int __pu_err; \
|
|
__pu_val.val = (x); \
|
|
__pu_addr = (unsigned long) (ptr); \
|
|
if (likely(__access_ok(__pu_addr, size))) { \
|
|
switch (size) { \
|
|
case 1: __put_user_asm("bu"); break; \
|
|
case 2: __put_user_asm("hu"); break; \
|
|
case 4: __put_user_asm("" ); break; \
|
|
case 8: __put_user_asm8(); break; \
|
|
default: __pu_err = __put_user_unknown(); break; \
|
|
} \
|
|
} \
|
|
else { \
|
|
__pu_err = -EFAULT; \
|
|
} \
|
|
__pu_err; \
|
|
})
|
|
|
|
#define __put_user_asm(INSN) \
|
|
({ \
|
|
asm volatile( \
|
|
"1:\n" \
|
|
" mov"INSN" %1,%2\n" \
|
|
" mov 0,%0\n" \
|
|
"2:\n" \
|
|
" .section .fixup,\"ax\"\n" \
|
|
"3:\n" \
|
|
" mov %3,%0\n" \
|
|
" jmp 2b\n" \
|
|
" .previous\n" \
|
|
" .section __ex_table,\"a\"\n" \
|
|
" .balign 4\n" \
|
|
" .long 1b, 3b\n" \
|
|
" .previous" \
|
|
: "=&r" (__pu_err) \
|
|
: "r" (__pu_val.val), "m" (__m(__pu_addr)), \
|
|
"i" (-EFAULT) \
|
|
); \
|
|
})
|
|
|
|
#define __put_user_asm8() \
|
|
({ \
|
|
asm volatile( \
|
|
"1: mov %1,%3 \n" \
|
|
"2: mov %2,%4 \n" \
|
|
" mov 0,%0 \n" \
|
|
"3: \n" \
|
|
" .section .fixup,\"ax\" \n" \
|
|
"4: \n" \
|
|
" mov %5,%0 \n" \
|
|
" jmp 2b \n" \
|
|
" .previous \n" \
|
|
" .section __ex_table,\"a\"\n" \
|
|
" .balign 4 \n" \
|
|
" .long 1b, 4b \n" \
|
|
" .long 2b, 4b \n" \
|
|
" .previous \n" \
|
|
: "=&r" (__pu_err) \
|
|
: "r" (__pu_val.bits[0]), "r" (__pu_val.bits[1]), \
|
|
"m" (__m(__pu_addr)), "m" (__m(__pu_addr+4)), \
|
|
"i" (-EFAULT) \
|
|
); \
|
|
})
|
|
|
|
extern int __put_user_unknown(void);
|
|
|
|
|
|
/*
|
|
* Copy To/From Userspace
|
|
*/
|
|
/* Generic arbitrary sized copy. */
|
|
#define __copy_user(to, from, size) \
|
|
do { \
|
|
if (size) { \
|
|
void *__to = to; \
|
|
const void *__from = from; \
|
|
int w; \
|
|
asm volatile( \
|
|
"0: movbu (%0),%3;\n" \
|
|
"1: movbu %3,(%1);\n" \
|
|
" inc %0;\n" \
|
|
" inc %1;\n" \
|
|
" add -1,%2;\n" \
|
|
" bne 0b;\n" \
|
|
"2:\n" \
|
|
" .section .fixup,\"ax\"\n" \
|
|
"3: jmp 2b\n" \
|
|
" .previous\n" \
|
|
" .section __ex_table,\"a\"\n" \
|
|
" .balign 4\n" \
|
|
" .long 0b,3b\n" \
|
|
" .long 1b,3b\n" \
|
|
" .previous\n" \
|
|
: "=a"(__from), "=a"(__to), "=r"(size), "=&r"(w)\
|
|
: "0"(__from), "1"(__to), "2"(size) \
|
|
: "memory"); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define __copy_user_zeroing(to, from, size) \
|
|
do { \
|
|
if (size) { \
|
|
void *__to = to; \
|
|
const void *__from = from; \
|
|
int w; \
|
|
asm volatile( \
|
|
"0: movbu (%0),%3;\n" \
|
|
"1: movbu %3,(%1);\n" \
|
|
" inc %0;\n" \
|
|
" inc %1;\n" \
|
|
" add -1,%2;\n" \
|
|
" bne 0b;\n" \
|
|
"2:\n" \
|
|
" .section .fixup,\"ax\"\n" \
|
|
"3:\n" \
|
|
" mov %2,%0\n" \
|
|
" clr %3\n" \
|
|
"4: movbu %3,(%1);\n" \
|
|
" inc %1;\n" \
|
|
" add -1,%2;\n" \
|
|
" bne 4b;\n" \
|
|
" mov %0,%2\n" \
|
|
" jmp 2b\n" \
|
|
" .previous\n" \
|
|
" .section __ex_table,\"a\"\n" \
|
|
" .balign 4\n" \
|
|
" .long 0b,3b\n" \
|
|
" .long 1b,3b\n" \
|
|
" .previous\n" \
|
|
: "=a"(__from), "=a"(__to), "=r"(size), "=&r"(w)\
|
|
: "0"(__from), "1"(__to), "2"(size) \
|
|
: "memory"); \
|
|
} \
|
|
} while (0)
|
|
|
|
/* We let the __ versions of copy_from/to_user inline, because they're often
|
|
* used in fast paths and have only a small space overhead.
|
|
*/
|
|
static inline
|
|
unsigned long __generic_copy_from_user_nocheck(void *to, const void *from,
|
|
unsigned long n)
|
|
{
|
|
__copy_user_zeroing(to, from, n);
|
|
return n;
|
|
}
|
|
|
|
static inline
|
|
unsigned long __generic_copy_to_user_nocheck(void *to, const void *from,
|
|
unsigned long n)
|
|
{
|
|
__copy_user(to, from, n);
|
|
return n;
|
|
}
|
|
|
|
|
|
#if 0
|
|
#error don't use - these macros don't increment to & from pointers
|
|
/* Optimize just a little bit when we know the size of the move. */
|
|
#define __constant_copy_user(to, from, size) \
|
|
do { \
|
|
asm volatile( \
|
|
" mov %0,a0;\n" \
|
|
"0: movbu (%1),d3;\n" \
|
|
"1: movbu d3,(%2);\n" \
|
|
" add -1,a0;\n" \
|
|
" bne 0b;\n" \
|
|
"2:;" \
|
|
".section .fixup,\"ax\"\n" \
|
|
"3: jmp 2b\n" \
|
|
".previous\n" \
|
|
".section __ex_table,\"a\"\n" \
|
|
" .balign 4\n" \
|
|
" .long 0b,3b\n" \
|
|
" .long 1b,3b\n" \
|
|
".previous" \
|
|
: \
|
|
: "d"(size), "d"(to), "d"(from) \
|
|
: "d3", "a0"); \
|
|
} while (0)
|
|
|
|
/* Optimize just a little bit when we know the size of the move. */
|
|
#define __constant_copy_user_zeroing(to, from, size) \
|
|
do { \
|
|
asm volatile( \
|
|
" mov %0,a0;\n" \
|
|
"0: movbu (%1),d3;\n" \
|
|
"1: movbu d3,(%2);\n" \
|
|
" add -1,a0;\n" \
|
|
" bne 0b;\n" \
|
|
"2:;" \
|
|
".section .fixup,\"ax\"\n" \
|
|
"3: jmp 2b\n" \
|
|
".previous\n" \
|
|
".section __ex_table,\"a\"\n" \
|
|
" .balign 4\n" \
|
|
" .long 0b,3b\n" \
|
|
" .long 1b,3b\n" \
|
|
".previous" \
|
|
: \
|
|
: "d"(size), "d"(to), "d"(from) \
|
|
: "d3", "a0"); \
|
|
} while (0)
|
|
|
|
static inline
|
|
unsigned long __constant_copy_to_user(void *to, const void *from,
|
|
unsigned long n)
|
|
{
|
|
if (access_ok(VERIFY_WRITE, to, n))
|
|
__constant_copy_user(to, from, n);
|
|
return n;
|
|
}
|
|
|
|
static inline
|
|
unsigned long __constant_copy_from_user(void *to, const void *from,
|
|
unsigned long n)
|
|
{
|
|
if (access_ok(VERIFY_READ, from, n))
|
|
__constant_copy_user_zeroing(to, from, n);
|
|
return n;
|
|
}
|
|
|
|
static inline
|
|
unsigned long __constant_copy_to_user_nocheck(void *to, const void *from,
|
|
unsigned long n)
|
|
{
|
|
__constant_copy_user(to, from, n);
|
|
return n;
|
|
}
|
|
|
|
static inline
|
|
unsigned long __constant_copy_from_user_nocheck(void *to, const void *from,
|
|
unsigned long n)
|
|
{
|
|
__constant_copy_user_zeroing(to, from, n);
|
|
return n;
|
|
}
|
|
#endif
|
|
|
|
extern unsigned long __generic_copy_to_user(void __user *, const void *,
|
|
unsigned long);
|
|
extern unsigned long __generic_copy_from_user(void *, const void __user *,
|
|
unsigned long);
|
|
|
|
#define __copy_to_user_inatomic(to, from, n) \
|
|
__generic_copy_to_user_nocheck((to), (from), (n))
|
|
#define __copy_from_user_inatomic(to, from, n) \
|
|
__generic_copy_from_user_nocheck((to), (from), (n))
|
|
|
|
#define __copy_to_user(to, from, n) \
|
|
({ \
|
|
might_sleep(); \
|
|
__copy_to_user_inatomic((to), (from), (n)); \
|
|
})
|
|
|
|
#define __copy_from_user(to, from, n) \
|
|
({ \
|
|
might_sleep(); \
|
|
__copy_from_user_inatomic((to), (from), (n)); \
|
|
})
|
|
|
|
|
|
#define copy_to_user(to, from, n) __generic_copy_to_user((to), (from), (n))
|
|
#define copy_from_user(to, from, n) __generic_copy_from_user((to), (from), (n))
|
|
|
|
extern long strncpy_from_user(char *dst, const char __user *src, long count);
|
|
extern long __strncpy_from_user(char *dst, const char __user *src, long count);
|
|
extern long strnlen_user(const char __user *str, long n);
|
|
#define strlen_user(str) strnlen_user(str, ~0UL >> 1)
|
|
extern unsigned long clear_user(void __user *mem, unsigned long len);
|
|
extern unsigned long __clear_user(void __user *mem, unsigned long len);
|
|
|
|
#endif /* _ASM_UACCESS_H */
|