xen/arm: hypercall.h fixes and cleanups

- the imm is actually 16 bits not 12 (mask 0xff00 should be 0xfff00);

- we can omit __HYPERVISOR_ in the users of hypercallN so that the
static inline hypercall implementations look like the x86 counterparts;

- do not bother with compat hypercalls.

Signed-off-by: Stefano Stabellini <stefano.stabellini@eu.citrix.com>

diff --git a/arch/arm/include/asm/xen/hypercall.h b/arch/arm/include/asm/xen/hypercall.h
index e2366972d9d054be4509682c775c064d689d4c8f..404e63f0ebd289ee79cca35c554ff3df67c9867b 100644 (file)
--- a/arch/arm/include/asm/xen/hypercall.h
+++ b/arch/arm/include/asm/xen/hypercall.h
@@ -33,9 +33,11 @@
 #ifndef _ASM_ARM_XEN_HYPERCALL_H
 #define _ASM_ARM_XEN_HYPERCALL_H
 
-#define TOSTRING(x) #x
-#define __HYPERCALL(num) ".word 0xe1400070 + ("TOSTRING(num)" & 0xf) + ((" \
-       TOSTRING(num)" << 4) & 0xff00)"
+#define __HVC_IMM(name)        "( " #name " & 0xf) + "   \
+                           "((" #name " << 4) & 0xfff00)"
+
+#define ____HYPERCALL(name) ".word 0xe1400070 + " __HVC_IMM(name)
+#define __HYPERCALL(name) ____HYPERCALL(__HYPERVISOR_##name)
 
 #define __HYPERCALL_RETREG     "r0"
 #define __HYPERCALL_ARG1REG    "r0"
@@ -78,112 +80,102 @@
 #define __HYPERCALL_CLOBBER1   __HYPERCALL_CLOBBER2, __HYPERCALL_ARG2REG
 #define __HYPERCALL_CLOBBER0   __HYPERCALL_CLOBBER1, __HYPERCALL_ARG1REG
 
-#define _hypercall0(type, number)                                              \
+#define _hypercall0(type, name)                                                \
 ({                                                                     \
        __HYPERCALL_DECLS;                                              \
        __HYPERCALL_0ARG();                                             \
-       asm volatile (__HYPERCALL(number)                                       \
+       asm volatile (__HYPERCALL(name)                                 \
                      : __HYPERCALL_0PARAM                              \
-                     :                                 \
+                     :                                                 \
                      : __HYPERCALL_CLOBBER0);                          \
        (type)__res;                                                    \
 })
 
-#define _hypercall1(type, number, a1)                                  \
+#define _hypercall1(type, name, a1)                                    \
 ({                                                                     \
        __HYPERCALL_DECLS;                                              \
        __HYPERCALL_1ARG(a1);                                           \
-       asm volatile (__HYPERCALL(number)                                       \
+       asm volatile (__HYPERCALL(name)                                 \
                      : __HYPERCALL_1PARAM                              \
-                     :                                 \
+                     :                                                 \
                      : __HYPERCALL_CLOBBER1);                          \
        (type)__res;                                                    \
 })
 
-#define _hypercall2(type, number, a1, a2)                                      \
+#define _hypercall2(type, name, a1, a2)                                        \
 ({                                                                     \
        __HYPERCALL_DECLS;                                              \
        __HYPERCALL_2ARG(a1, a2);                                       \
-       asm volatile (__HYPERCALL(number)                                       \
+       asm volatile (__HYPERCALL(name)                                 \
                      : __HYPERCALL_2PARAM                              \
-                     :                                 \
+                     :                                                 \
                      : __HYPERCALL_CLOBBER2);                          \
        (type)__res;                                                    \
 })
 
-#define _hypercall3(type, number, a1, a2, a3)                          \
+#define _hypercall3(type, name, a1, a2, a3)                            \
 ({                                                                     \
        __HYPERCALL_DECLS;                                              \
        __HYPERCALL_3ARG(a1, a2, a3);                                   \
-       asm volatile (__HYPERCALL(number)                                       \
+       asm volatile (__HYPERCALL(name)                                 \
                      : __HYPERCALL_3PARAM                              \
-                     :                                 \
+                     :                                                 \
                      : __HYPERCALL_CLOBBER3);                          \
        (type)__res;                                                    \
 })
 
-#define _hypercall4(type, number, a1, a2, a3, a4)                              \
+#define _hypercall4(type, name, a1, a2, a3, a4)                                \
 ({                                                                     \
        __HYPERCALL_DECLS;                                              \
        __HYPERCALL_4ARG(a1, a2, a3, a4);                               \
-       asm volatile (__HYPERCALL(number)                                       \
+       asm volatile (__HYPERCALL(name)                                 \
                      : __HYPERCALL_4PARAM                              \
-                     :                                 \
+                     :                                                 \
                      : __HYPERCALL_CLOBBER4);                          \
        (type)__res;                                                    \
 })
 
-#define _hypercall5(type, number, a1, a2, a3, a4, a5)                  \
+#define _hypercall5(type, name, a1, a2, a3, a4, a5)                    \
 ({                                                                     \
        __HYPERCALL_DECLS;                                              \
        __HYPERCALL_5ARG(a1, a2, a3, a4, a5);                           \
-       asm volatile (__HYPERCALL(number)                                       \
+       asm volatile (__HYPERCALL(name)                                 \
                      : __HYPERCALL_5PARAM                              \
-                     :                                 \
+                     :                                                 \
                      : __HYPERCALL_CLOBBER5);                          \
        (type)__res;                                                    \
 })
 
-
-
 /* -- Hypercall definitions go below -- */
 
 static inline int
 HYPERVISOR_xen_version(int cmd, void *arg)
 {
-       return _hypercall2(int, __HYPERVISOR_xen_version, cmd, arg);
+       return _hypercall2(int, xen_version, cmd, arg);
 }
 
 static inline int
 HYPERVISOR_console_io(int cmd, int count, char *str)
 {
-       return _hypercall3(int, __HYPERVISOR_console_io, cmd, count, str);
+       return _hypercall3(int, console_io, cmd, count, str);
 }
 
 static inline int
 HYPERVISOR_grant_table_op(unsigned int cmd, void *uop, unsigned int count)
 {
-       return _hypercall3(int, __HYPERVISOR_grant_table_op, cmd, uop, count);
+       return _hypercall3(int, grant_table_op, cmd, uop, count);
 }
 
 static inline int
 HYPERVISOR_sched_op(int cmd, void *arg)
 {
-       return _hypercall2(int, __HYPERVISOR_sched_op, cmd, arg);
+       return _hypercall2(int, sched_op, cmd, arg);
 }
 
 static inline int
 HYPERVISOR_event_channel_op(int cmd, void *arg)
 {
-       int rc = _hypercall2(int, __HYPERVISOR_event_channel_op, cmd, arg);
-       if (unlikely(rc == -ENOSYS)) {
-               struct evtchn_op op;
-               op.cmd = cmd;
-               memcpy(&op.u, arg, sizeof(op.u));
-               rc = _hypercall1(int, __HYPERVISOR_event_channel_op_compat, &op);
-               memcpy(arg, &op.u, sizeof(op.u));
-       }
-       return rc;
+       return _hypercall2(int, event_channel_op, cmd, arg);
 }
 
 #endif /* _ASM_ARM_XEN_HYPERCALL_H */