xen/arm: use r12 to pass the hypercall number to the hypervisor

We need a register to pass the hypercall number because we might not
know it at compile time and HVC only takes an immediate argument.

Among the available registers r12 seems to be the best choice because it
is defined as "intra-procedure call scratch register".

Use the ISS to pass an hypervisor specific tag.

Signed-off-by: Stefano Stabellini <stefano.stabellini@eu.citrix.com>
CC: kvm@vger.kernel.org

diff --git a/arch/arm/include/asm/xen/hypercall.h b/arch/arm/include/asm/xen/hypercall.h
index 5abba487ba827711c7d6006b59df7da094574b44..2fe7434467b4b222158512c9dbdf3f5d2df075b7 100644 (file)
--- a/arch/arm/include/asm/xen/hypercall.h
+++ b/arch/arm/include/asm/xen/hypercall.h
@@ -39,7 +39,7 @@
 #define XEN_HYPERCALL_TAG  "0XEA1"
 
 #define __HVC_IMM(tag) "( " tag " & 0xf) + "     \
-                           "((" tag " << 4) & 0xfff00)"
+       "((" tag " << 4) & 0xfff00)"
 #define __HYPERCALL ".word 0xe1400070 + " __HVC_IMM(XEN_HYPERCALL_TAG)
 
 #define __HYPERCALL_RETREG     "r0"
@@ -52,12 +52,12 @@
 
 #define __HYPERCALL_DECLS                                              \
        register unsigned long __res  asm(__HYPERCALL_RETREG);          \
-       register unsigned long __num  asm(__HYPERCALL_NUMBER) = __num; \
-       register unsigned long __arg1 asm(__HYPERCALL_ARG1REG) = __arg1; \
-       register unsigned long __arg2 asm(__HYPERCALL_ARG2REG) = __arg2; \
-       register unsigned long __arg3 asm(__HYPERCALL_ARG3REG) = __arg3; \
-       register unsigned long __arg4 asm(__HYPERCALL_ARG4REG) = __arg4; \
-       register unsigned long __arg5 asm(__HYPERCALL_ARG5REG) = __arg5;
+register unsigned long __num  asm(__HYPERCALL_NUMBER) = __num; \
+register unsigned long __arg1 asm(__HYPERCALL_ARG1REG) = __arg1; \
+register unsigned long __arg2 asm(__HYPERCALL_ARG2REG) = __arg2; \
+register unsigned long __arg3 asm(__HYPERCALL_ARG3REG) = __arg3; \
+register unsigned long __arg4 asm(__HYPERCALL_ARG4REG) = __arg4; \
+register unsigned long __arg5 asm(__HYPERCALL_ARG5REG) = __arg5;
 
 #define __HYPERCALL_0PARAM     "=r" (__res), "+r" (__num)
 #define __HYPERCALL_1PARAM     __HYPERCALL_0PARAM, "+r" (__arg1)
@@ -87,101 +87,101 @@
 #define __HYPERCALL_CLOBBER0   __HYPERCALL_CLOBBER1, __HYPERCALL_ARG1REG
 
 #define _hypercall0(type, hypercall)                                           \
-({                                                                     \
-       __HYPERCALL_DECLS;                                              \
-       __HYPERCALL_0ARG(hypercall);                                            \
-       asm volatile (__HYPERCALL                                       \
-                     : __HYPERCALL_0PARAM                              \
-                     :                                                 \
-                     : __HYPERCALL_CLOBBER0);                          \
-       (type)__res;                                                    \
-})
+       ({                                                                      \
+        __HYPERCALL_DECLS;                                             \
+        __HYPERCALL_0ARG(hypercall);                                           \
+        asm volatile (__HYPERCALL                                      \
+                : __HYPERCALL_0PARAM                           \
+                :                                              \
+                : __HYPERCALL_CLOBBER0);                               \
+        (type)__res;                                                   \
+        })
 
 #define _hypercall1(type, hypercall, a1)                                       \
-({                                                                     \
-       __HYPERCALL_DECLS;                                              \
-       __HYPERCALL_1ARG(hypercall, a1);                                                \
-       asm volatile (__HYPERCALL                                       \
-                     : __HYPERCALL_1PARAM                              \
-                     :                                                 \
-                     : __HYPERCALL_CLOBBER1);                          \
-       (type)__res;                                                    \
-})
+       ({                                                                      \
+        __HYPERCALL_DECLS;                                             \
+        __HYPERCALL_1ARG(hypercall, a1);                                               \
+        asm volatile (__HYPERCALL                                      \
+                : __HYPERCALL_1PARAM                           \
+                :                                              \
+                : __HYPERCALL_CLOBBER1);                               \
+        (type)__res;                                                   \
+        })
 
 #define _hypercall2(type, hypercall, a1, a2)                                   \
-({                                                                     \
-       __HYPERCALL_DECLS;                                              \
-       __HYPERCALL_2ARG(hypercall, a1, a2);                                    \
-       asm volatile (__HYPERCALL                                       \
-                     : __HYPERCALL_2PARAM                              \
-                     :                                                 \
-                     : __HYPERCALL_CLOBBER2);                          \
-       (type)__res;                                                    \
-})
+       ({                                                                      \
+        __HYPERCALL_DECLS;                                             \
+        __HYPERCALL_2ARG(hypercall, a1, a2);                                   \
+        asm volatile (__HYPERCALL                                      \
+                : __HYPERCALL_2PARAM                           \
+                :                                              \
+                : __HYPERCALL_CLOBBER2);                               \
+        (type)__res;                                                   \
+        })
 
 #define _hypercall3(type, hypercall, a1, a2, a3)                               \
-({                                                                     \
-       __HYPERCALL_DECLS;                                              \
-       __HYPERCALL_3ARG(hypercall, a1, a2, a3);                                        \
-       asm volatile (__HYPERCALL                                       \
-                     : __HYPERCALL_3PARAM                              \
-                     :                                                 \
-                     : __HYPERCALL_CLOBBER3);                          \
-       (type)__res;                                                    \
-})
+       ({                                                                      \
+        __HYPERCALL_DECLS;                                             \
+        __HYPERCALL_3ARG(hypercall, a1, a2, a3);                                       \
+        asm volatile (__HYPERCALL                                      \
+                : __HYPERCALL_3PARAM                           \
+                :                                              \
+                : __HYPERCALL_CLOBBER3);                               \
+        (type)__res;                                                   \
+        })
 
 #define _hypercall4(type, hypercall, a1, a2, a3, a4)                           \
-({                                                                     \
-       __HYPERCALL_DECLS;                                              \
-       __HYPERCALL_4ARG(hypercall, a1, a2, a3, a4);                            \
-       asm volatile (__HYPERCALL                                       \
-                     : __HYPERCALL_4PARAM                              \
-                     :                                                 \
-                     : __HYPERCALL_CLOBBER4);                          \
-       (type)__res;                                                    \
-})
+       ({                                                                      \
+        __HYPERCALL_DECLS;                                             \
+        __HYPERCALL_4ARG(hypercall, a1, a2, a3, a4);                           \
+        asm volatile (__HYPERCALL                                      \
+                : __HYPERCALL_4PARAM                           \
+                :                                              \
+                : __HYPERCALL_CLOBBER4);                               \
+        (type)__res;                                                   \
+        })
 
 #define _hypercall5(type, hypercall, a1, a2, a3, a4, a5)                       \
-({                                                                     \
-       __HYPERCALL_DECLS;                                              \
-       __HYPERCALL_5ARG(hypercall, a1, a2, a3, a4, a5);                                \
-       asm volatile (__HYPERCALL                                       \
-                     : __HYPERCALL_5PARAM                              \
-                     :                                                 \
-                     : __HYPERCALL_CLOBBER5);                          \
-       (type)__res;                                                    \
-})
+       ({                                                                      \
+        __HYPERCALL_DECLS;                                             \
+        __HYPERCALL_5ARG(hypercall, a1, a2, a3, a4, a5);                               \
+        asm volatile (__HYPERCALL                                      \
+                : __HYPERCALL_5PARAM                           \
+                :                                              \
+                : __HYPERCALL_CLOBBER5);                               \
+        (type)__res;                                                   \
+        })
 
 #define HYPERCALL(name) \
        (__HYPERVISOR_##name)
 
 /* -- Hypercall definitions go below -- */
 
-static inline int
+       static inline int
 HYPERVISOR_xen_version(int cmd, void *arg)
 {
        return _hypercall2(int, HYPERCALL(xen_version), cmd, arg);
 }
 
-static inline int
+       static inline int
 HYPERVISOR_console_io(int cmd, int count, char *str)
 {
        return _hypercall3(int, HYPERCALL(console_io), cmd, count, str);
 }
 
-static inline int
+       static inline int
 HYPERVISOR_grant_table_op(unsigned int cmd, void *uop, unsigned int count)
 {
        return _hypercall3(int, HYPERCALL(grant_table_op), cmd, uop, count);
 }
 
-static inline int
+       static inline int
 HYPERVISOR_sched_op(int cmd, void *arg)
 {
        return _hypercall2(int, HYPERCALL(sched_op), cmd, arg);
 }
 
-static inline int
+       static inline int
 HYPERVISOR_event_channel_op(int cmd, void *arg)
 {
        return _hypercall2(int, HYPERCALL(event_channel_op), cmd, arg);
@@ -189,10 +189,10 @@ HYPERVISOR_event_channel_op(int cmd, void *arg)
 
 static inline unsigned long HYPERVISOR_hvm_op(int op, void *arg)
 {
-       return -ENOSYS;
+       return -ENOSYS;
 }
 
-static inline int
+       static inline int
 HYPERVISOR_memory_op(unsigned int cmd, void *arg)
 {
        return _hypercall2(int, HYPERCALL(memory_op), cmd, arg);