1 files changed, 0 insertions, 184 deletions

diff --git a/include/asm-xtensa/unistd.h b/include/asm-xtensa/unistd.h
index 411f810a55c6..2e1a1b997e7d 100644
--- a/include/asm-xtensa/unistd.h
+++ b/include/asm-xtensa/unistd.h
@@ -218,190 +218,6 @@
 
 #define SYSXTENSA_COUNT            5    /* count of syscall0 functions*/
 
-#ifdef __KERNEL__
-#include <linux/linkage.h>
-
-#define __syscall_return(type, res) return ((type)(res))
-
-/* Tensilica's xt-xcc compiler is much more agressive at code
- * optimization than gcc.  Multiple __asm__ statements are
- * insufficient for xt-xcc because subsequent optimization passes
- * (beyond the front-end that knows of __asm__ statements and other
- * such GNU Extensions to C) can modify the register selection for
- * containment of C variables.
- *
- * xt-xcc cannot modify the contents of a single __asm__ statement, so
- * we create single-asm versions of the syscall macros that are
- * suitable and optimal for both xt-xcc and gcc.
- *
- * Linux takes system-call arguments in registers.  The following
- * design is optimized for user-land apps (e.g., glibc) which
- * typically have a function wrapper around the "syscall" assembly
- * instruction.  It satisfies the Xtensa ABI while minizing argument
- * shifting.
- *
- * The Xtensa ABI and software conventions require the system-call
- * number in a2.  If an argument exists in a2, we move it to the next
- * available register.  Note that for improved efficiency, we do NOT
- * shift all parameters down one register to maintain the original
- * order.
- *
- * At best case (zero arguments), we just write the syscall number to
- * a2.  At worst case (1 to 6 arguments), we move the argument in a2
- * to the next available register, then write the syscall number to
- * a2.
- *
- * For clarity, the following truth table enumerates all possibilities.
- *
- * arguments    syscall number  arg0, arg1, arg2, arg3, arg4, arg5
- * ---------    --------------  ----------------------------------
- *      0             a2
- *      1             a2        a3
- *      2             a2        a4,   a3
- *      3             a2        a5,   a3,   a4
- *      4             a2        a6,   a3,   a4,   a5
- *      5             a2        a7,   a3,   a4,   a5,   a6
- *      6             a2        a8,   a3,   a4,   a5,   a6,   a7
- */
-
-#define _syscall0(type,name) \
-type name(void) \
-{ \
-long __res; \
-__asm__ __volatile__ ( \
-        "  movi  a2, %1 \n" \
-        "  syscall      \n" \
-        "  mov   %0, a2 \n" \
-        : "=a" (__res) \
-        : "i" (__NR_##name) \
-        : "a2" \
-        ); \
-__syscall_return(type,__res); \
-}
-
-#define _syscall1(type,name,type0,arg0) \
-type name(type0 arg0) \
-{ \
-long __res; \
-__asm__ __volatile__ ( \
-        "  mov   a3, %2 \n" \
-        "  movi  a2, %1 \n" \
-        "  syscall      \n" \
-        "  mov   %0, a2 \n" \
-        : "=a" (__res) \
-        : "i" (__NR_##name), "a" (arg0) \
-        : "a2", "a3" \
-        ); \
-__syscall_return(type,__res); \
-}
-
-#define _syscall2(type,name,type0,arg0,type1,arg1) \
-type name(type0 arg0,type1 arg1) \
-{ \
-long __res; \
-__asm__ __volatile__ ( \
-        "  mov   a4, %2 \n" \
-        "  mov   a3, %3 \n" \
-        "  movi  a2, %1 \n" \
-        "  syscall      \n" \
-        "  mov   %0, a2 \n" \
-        : "=a" (__res) \
-        : "i" (__NR_##name), "a" (arg0), "a" (arg1) \
-        : "a2", "a3", "a4" \
-        ); \
-__syscall_return(type,__res); \
-}
-
-#define _syscall3(type,name,type0,arg0,type1,arg1,type2,arg2) \
-type name(type0 arg0,type1 arg1,type2 arg2) \
-{ \
-long __res; \
-__asm__ __volatile__ ( \
-        "  mov   a5, %2 \n" \
-        "  mov   a4, %4 \n" \
-        "  mov   a3, %3 \n" \
-        "  movi  a2, %1 \n" \
-        "  syscall      \n" \
-        "  mov   %0, a2 \n" \
-        : "=a" (__res) \
-        : "i" (__NR_##name), "a" (arg0), "a" (arg1), "a" (arg2) \
-        : "a2", "a3", "a4", "a5" \
-        ); \
-__syscall_return(type,__res); \
-}
-
-#define _syscall4(type,name,type0,arg0,type1,arg1,type2,arg2,type3,arg3) \
-type name(type0 arg0,type1 arg1,type2 arg2,type3 arg3) \
-{ \
-long __res; \
-__asm__ __volatile__ ( \
-        "  mov   a6, %2 \n" \
-        "  mov   a5, %5 \n" \
-        "  mov   a4, %4 \n" \
-        "  mov   a3, %3 \n" \
-        "  movi  a2, %1 \n" \
-        "  syscall      \n" \
-        "  mov   %0, a2 \n" \
-        : "=a" (__res) \
-        : "i" (__NR_##name), "a" (arg0), "a" (arg1), "a" (arg2), "a" (arg3) \
-        : "a2", "a3", "a4", "a5", "a6" \
-        ); \
-__syscall_return(type,__res); \
-}
-
-/* Note that we save and restore the a7 frame pointer.
- * Including a7 in the clobber list doesn't do what you'd expect.
- */
-#define _syscall5(type,name,type0,arg0,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
-type name(type0 arg0,type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
-{ \
-long __res; \
-__asm__ __volatile__ ( \
-        "  mov   a9, a7 \n" \
-        "  mov   a7, %2 \n" \
-        "  mov   a6, %6 \n" \
-        "  mov   a5, %5 \n" \
-        "  mov   a4, %4 \n" \
-        "  mov   a3, %3 \n" \
-        "  movi  a2, %1 \n" \
-        "  syscall      \n" \
-        "  mov   a7, a9 \n" \
-        "  mov   %0, a2 \n" \
-        : "=a" (__res) \
-        : "i" (__NR_##name), "a" (arg0), "a" (arg1), "a" (arg2), \
-                             "a" (arg3), "a" (arg4) \
-        : "a2", "a3", "a4", "a5", "a6", "a9" \
-        ); \
-__syscall_return(type,__res); \
-}
-
-/* Note that we save and restore the a7 frame pointer.
- * Including a7 in the clobber list doesn't do what you'd expect.
- */
-#define _syscall6(type,name,type0,arg0,type1,arg1,type2,arg2,type3,arg3,type4,arg4,type5,arg5) \
-type name(type0 arg0,type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
-{ \
-long __res; \
-__asm__ __volatile__ ( \
-        "  mov   a9, a7 \n" \
-        "  mov   a8, %2 \n" \
-        "  mov   a7, %7 \n" \
-        "  mov   a6, %6 \n" \
-        "  mov   a5, %5 \n" \
-        "  mov   a4, %4 \n" \
-        "  mov   a3, %3 \n" \
-        "  movi  a2, %1 \n" \
-        "  syscall      \n" \
-        "  mov   a7, a9 \n" \
-        "  mov   %0, a2 \n" \
-        : "=a" (__res) \
-        : "i" (__NR_##name), "a" (arg0), "a" (arg1), "a" (arg2), \
-                             "a" (arg3), "a" (arg4), "a" (arg5)  \
-        : "a2", "a3", "a4", "a5", "a6", "a8", "a9" \
-        ); \
-__syscall_return(type,__res); \
-}
-
 /*
  * "Conditional" syscalls
  *