Merge branches 'acpi-apei', 'acpi-processor', 'acpi-tables', 'acpi-pci' and 'acpi...
[linux-2.6-block.git] / arch / hexagon / kernel / vm_entry.S
1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /*
3  * Event entry/exit for Hexagon
4  *
5  * Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.
6  */
7
8 #include <asm/asm-offsets.h>  /*  assembly-safer versions of C defines */
9 #include <asm/mem-layout.h>   /*  sigh, except for page_offset  */
10 #include <asm/hexagon_vm.h>
11 #include <asm/thread_info.h>
12
13 /*
14  * Entry into guest-mode Linux under Hexagon Virtual Machine.
15  * Stack pointer points to event record - build pt_regs on top of it,
16  * set up a plausible C stack frame, and dispatch to the C handler.
17  * On return, do vmrte virtual instruction with SP where we started.
18  *
19  * VM Spec 0.5 uses a trap to fetch HVM record now.
20  */
21
22 /*
23  * Save full register state, while setting up thread_info struct
24  * pointer derived from kernel stack pointer in THREADINFO_REG
25  * register, putting prior thread_info.regs pointer in a callee-save
26  * register (R24, which had better not ever be assigned to THREADINFO_REG),
27  * and updating thread_info.regs to point to current stack frame,
28  * so as to support nested events in kernel mode.
29  *
30  * As this is common code, we set the pt_regs system call number
31  * to -1 for all events.  It will be replaced with the system call
32  * number in the case where we decode a system call (trap0(#1)).
33  */
34
35 #if CONFIG_HEXAGON_ARCH_VERSION < 4
36 #define save_pt_regs()\
37  memd(R0 + #_PT_R3130) = R31:30; \
38  { memw(R0 + #_PT_R2928) = R28; \
39    R31 = memw(R0 + #_PT_ER_VMPSP); }\
40  { memw(R0 + #(_PT_R2928 + 4)) = R31; \
41    R31 = ugp; } \
42  { memd(R0 + #_PT_R2726) = R27:26; \
43    R30 = gp ; } \
44  memd(R0 + #_PT_R2524) = R25:24; \
45  memd(R0 + #_PT_R2322) = R23:22; \
46  memd(R0 + #_PT_R2120) = R21:20; \
47  memd(R0 + #_PT_R1918) = R19:18; \
48  memd(R0 + #_PT_R1716) = R17:16; \
49  memd(R0 + #_PT_R1514) = R15:14; \
50  memd(R0 + #_PT_R1312) = R13:12; \
51  { memd(R0 + #_PT_R1110) = R11:10; \
52    R15 = lc0; } \
53  { memd(R0 + #_PT_R0908) = R9:8; \
54    R14 = sa0; } \
55  { memd(R0 + #_PT_R0706) = R7:6; \
56    R13 = lc1; } \
57  { memd(R0 + #_PT_R0504) = R5:4; \
58    R12 = sa1; } \
59  { memd(R0 + #_PT_GPUGP) = R31:30; \
60    R11 = m1; \
61    R2.H = #HI(_THREAD_SIZE); } \
62  { memd(R0 + #_PT_LC0SA0) = R15:14; \
63    R10 = m0; \
64    R2.L = #LO(_THREAD_SIZE); } \
65  { memd(R0 + #_PT_LC1SA1) = R13:12; \
66    R15 = p3:0; \
67    R2 = neg(R2); } \
68  { memd(R0 + #_PT_M1M0) = R11:10; \
69    R14  = usr; \
70    R2 = and(R0,R2); } \
71  { memd(R0 + #_PT_PREDSUSR) =  R15:14; \
72    THREADINFO_REG = R2; } \
73  { r24 = memw(THREADINFO_REG + #_THREAD_INFO_PT_REGS); \
74    memw(THREADINFO_REG + #_THREAD_INFO_PT_REGS) = R0; \
75    R2 = #-1; } \
76  { memw(R0 + #_PT_SYSCALL_NR) = R2; \
77    R30 = #0; }
78 #else
79 /* V4+ */
80 /* the # ## # syntax inserts a literal ## */
81 #define save_pt_regs()\
82         { memd(R0 + #_PT_R3130) = R31:30; \
83                 R30 = memw(R0 + #_PT_ER_VMPSP); }\
84         { memw(R0 + #_PT_R2928) = R28; \
85                 memw(R0 + #(_PT_R2928 + 4)) = R30; }\
86         { R31:30 = C11:10; \
87                 memd(R0 + #_PT_R2726) = R27:26; \
88                 memd(R0 + #_PT_R2524) = R25:24; }\
89         { memd(R0 + #_PT_R2322) = R23:22; \
90                 memd(R0 + #_PT_R2120) = R21:20; }\
91         { memd(R0 + #_PT_R1918) = R19:18; \
92                 memd(R0 + #_PT_R1716) = R17:16; }\
93         { memd(R0 + #_PT_R1514) = R15:14; \
94                 memd(R0 + #_PT_R1312) = R13:12; \
95                 R17:16 = C13:12; }\
96         { memd(R0 + #_PT_R1110) = R11:10; \
97                 memd(R0 + #_PT_R0908) = R9:8; \
98           R15:14 = C1:0; } \
99         { memd(R0 + #_PT_R0706) = R7:6; \
100                 memd(R0 + #_PT_R0504) = R5:4; \
101     R13:12 = C3:2; } \
102         { memd(R0 + #_PT_GPUGP) = R31:30; \
103                 memd(R0 + #_PT_LC0SA0) = R15:14; \
104           R11:10 = C7:6; }\
105         {       THREADINFO_REG = and(R0, # ## #-_THREAD_SIZE); \
106                 memd(R0 + #_PT_LC1SA1) = R13:12; \
107           R15 = p3:0; }\
108         { memd(R0 + #_PT_M1M0) = R11:10; \
109                 memw(R0 + #_PT_PREDSUSR + 4) =  R15; }\
110         { r24 = memw(THREADINFO_REG + #_THREAD_INFO_PT_REGS); \
111           memw(THREADINFO_REG + #_THREAD_INFO_PT_REGS) = R0; \
112           R2 = #-1; } \
113         { memw(R0 + #_PT_SYSCALL_NR) = R2; \
114                 memd(R0 + #_PT_CS1CS0) = R17:16; \
115           R30 = #0; }
116 #endif
117
118 /*
119  * Restore registers and thread_info.regs state. THREADINFO_REG
120  * is assumed to still be sane, and R24 to have been correctly
121  * preserved. Don't restore R29 (SP) until later.
122  */
123
124 #if CONFIG_HEXAGON_ARCH_VERSION < 4
125 #define restore_pt_regs() \
126         { memw(THREADINFO_REG + #_THREAD_INFO_PT_REGS) = R24; \
127           R15:14 = memd(R0 + #_PT_PREDSUSR); } \
128         { R11:10 = memd(R0 + #_PT_M1M0); \
129           p3:0 = R15; } \
130         { R13:12 = memd(R0 + #_PT_LC1SA1); \
131           usr = R14; } \
132         { R15:14 = memd(R0 + #_PT_LC0SA0); \
133           m1 = R11; } \
134         { R3:2 = memd(R0 + #_PT_R0302); \
135           m0 = R10; } \
136         { R5:4 = memd(R0 + #_PT_R0504); \
137           lc1 = R13; } \
138         { R7:6 = memd(R0 + #_PT_R0706); \
139           sa1 = R12; } \
140         { R9:8 = memd(R0 + #_PT_R0908); \
141           lc0 = R15; } \
142         { R11:10 = memd(R0 + #_PT_R1110); \
143           sa0 = R14; } \
144         { R13:12 = memd(R0 + #_PT_R1312); \
145           R15:14 = memd(R0 + #_PT_R1514); } \
146         { R17:16 = memd(R0 + #_PT_R1716); \
147           R19:18 = memd(R0 + #_PT_R1918); } \
148         { R21:20 = memd(R0 + #_PT_R2120); \
149           R23:22 = memd(R0 + #_PT_R2322); } \
150         { R25:24 = memd(R0 + #_PT_R2524); \
151           R27:26 = memd(R0 + #_PT_R2726); } \
152         R31:30 = memd(R0 + #_PT_GPUGP); \
153         { R28 = memw(R0 + #_PT_R2928); \
154           ugp = R31; } \
155         { R31:30 = memd(R0 + #_PT_R3130); \
156           gp = R30; }
157 #else
158 /* V4+ */
159 #define restore_pt_regs() \
160         { memw(THREADINFO_REG + #_THREAD_INFO_PT_REGS) = R24; \
161           R15:14 = memd(R0 + #_PT_PREDSUSR); } \
162         { R11:10 = memd(R0 + #_PT_M1M0); \
163                 R13:12 = memd(R0 + #_PT_LC1SA1); \
164                 p3:0 = R15; } \
165         { R15:14 = memd(R0 + #_PT_LC0SA0); \
166                 R3:2 = memd(R0 + #_PT_R0302); \
167                 usr = R14; } \
168         { R5:4 = memd(R0 + #_PT_R0504); \
169                 R7:6 = memd(R0 + #_PT_R0706); \
170                 C7:6 = R11:10; }\
171         { R9:8 = memd(R0 + #_PT_R0908); \
172                 R11:10 = memd(R0 + #_PT_R1110); \
173     C3:2 = R13:12; }\
174         { R13:12 = memd(R0 + #_PT_R1312); \
175           R15:14 = memd(R0 + #_PT_R1514); \
176                 C1:0 = R15:14; }\
177         { R17:16 = memd(R0 + #_PT_R1716); \
178           R19:18 = memd(R0 + #_PT_R1918); } \
179         { R21:20 = memd(R0 + #_PT_R2120); \
180           R23:22 = memd(R0 + #_PT_R2322); } \
181         { R25:24 = memd(R0 + #_PT_R2524); \
182           R27:26 = memd(R0 + #_PT_R2726); } \
183         R31:30 = memd(R0 + #_PT_CS1CS0); \
184         { C13:12 = R31:30; \
185                 R31:30 = memd(R0 + #_PT_GPUGP) ; \
186                 R28 = memw(R0 + #_PT_R2928); }\
187         { C11:10 = R31:30; \
188                 R31:30 = memd(R0 + #_PT_R3130); }
189 #endif
190
191         /*
192          * Clears off enough space for the rest of pt_regs; evrec is a part
193          * of pt_regs in HVM mode.  Save R0/R1, set handler's address in R1.
194          * R0 is the address of pt_regs and is the parameter to save_pt_regs.
195          */
196
197 /*
198  * Since the HVM isn't automagically pushing the EVREC onto the stack anymore,
199  * we'll subract the entire size out and then fill it in ourselves.
200  * Need to save off R0, R1, R2, R3 immediately.
201  */
202
203 #if CONFIG_HEXAGON_ARCH_VERSION < 4
204 #define vm_event_entry(CHandler) \
205         { \
206                 R29 = add(R29, #-(_PT_REGS_SIZE)); \
207                 memd(R29 + #(_PT_R0100 + -_PT_REGS_SIZE)) = R1:0; \
208         } \
209         { \
210                 memd(R29 +#_PT_R0302) = R3:2; \
211         } \
212         trap1(#HVM_TRAP1_VMGETREGS); \
213         { \
214                 memd(R29 + #_PT_ER_VMEL) = R1:0; \
215                 R0 = R29; \
216                 R1.L = #LO(CHandler); \
217         } \
218         { \
219                 memd(R29 + #_PT_ER_VMPSP) = R3:2; \
220                 R1.H = #HI(CHandler); \
221                 jump event_dispatch; \
222         }
223 #else
224 /* V4+ */
225 /* turn on I$ prefetch early */
226 /* the # ## # syntax inserts a literal ## */
227 #define vm_event_entry(CHandler) \
228         { \
229                 R29 = add(R29, #-(_PT_REGS_SIZE)); \
230                 memd(R29 + #(_PT_R0100 + -_PT_REGS_SIZE)) = R1:0; \
231                 memd(R29 + #(_PT_R0302 + -_PT_REGS_SIZE)) = R3:2; \
232                 R0 = usr; \
233         } \
234         { \
235                 memw(R29 + #_PT_PREDSUSR) = R0; \
236                 R0 = setbit(R0, #16); \
237         } \
238         usr = R0; \
239         R1:0 = G1:0; \
240         { \
241                 memd(R29 + #_PT_ER_VMEL) = R1:0; \
242                 R1 = # ## #(CHandler); \
243                 R3:2 = G3:2; \
244         } \
245         { \
246                 R0 = R29; \
247                 memd(R29 + #_PT_ER_VMPSP) = R3:2; \
248                 jump event_dispatch; \
249         }
250 #endif
251
252 .text
253         /*
254          * Do bulk save/restore in one place.
255          * Adds a jump to dispatch latency, but
256          * saves hundreds of bytes.
257          */
258
259 event_dispatch:
260         save_pt_regs()
261         callr   r1
262
263         /*
264          * Coming back from the C-world, our thread info pointer
265          * should be in the designated register (usually R19)
266          *
267          * If we were in kernel mode, we don't need to check scheduler
268          * or signals if CONFIG_PREEMPT is not set.  If set, then it has
269          * to jump to a need_resched kind of block.
270          * BTW, CONFIG_PREEMPT is not supported yet.
271          */
272
273 #ifdef CONFIG_PREEMPT
274         R0 = #VM_INT_DISABLE
275         trap1(#HVM_TRAP1_VMSETIE)
276 #endif
277
278         /*  "Nested control path" -- if the previous mode was kernel  */
279         {
280                 R0 = memw(R29 + #_PT_ER_VMEST);
281                 R26.L = #LO(do_work_pending);
282         }
283         {
284                 P0 = tstbit(R0, #HVM_VMEST_UM_SFT);
285                 if (!P0.new) jump:nt restore_all;
286                 R26.H = #HI(do_work_pending);
287                 R0 = #VM_INT_DISABLE;
288         }
289
290         /*
291          * Check also the return from fork/system call, normally coming back from
292          * user mode
293          *
294          * R26 needs to have do_work_pending, and R0 should have VM_INT_DISABLE
295          */
296
297 check_work_pending:
298         /*  Disable interrupts while checking TIF  */
299         trap1(#HVM_TRAP1_VMSETIE)
300         {
301                 R0 = R29;  /*  regs should still be at top of stack  */
302                 R1 = memw(THREADINFO_REG + #_THREAD_INFO_FLAGS);
303                 callr R26;
304         }
305
306         {
307                 P0 = cmp.eq(R0, #0); if (!P0.new) jump:nt check_work_pending;
308                 R0 = #VM_INT_DISABLE;
309         }
310
311 restore_all:
312         /*
313          * Disable interrupts, if they weren't already, before reg restore.
314          * R0 gets preloaded with #VM_INT_DISABLE before we get here.
315          */
316         trap1(#HVM_TRAP1_VMSETIE)
317
318         /*  do the setregs here for VM 0.5  */
319         /*  R29 here should already be pointing at pt_regs  */
320         {
321                 R1:0 = memd(R29 + #_PT_ER_VMEL);
322                 R3:2 = memd(R29 + #_PT_ER_VMPSP);
323         }
324 #if CONFIG_HEXAGON_ARCH_VERSION < 4
325         trap1(#HVM_TRAP1_VMSETREGS);
326 #else
327         G1:0 = R1:0;
328         G3:2 = R3:2;
329 #endif
330
331         R0 = R29
332         restore_pt_regs()
333         {
334                 R1:0 = memd(R29 + #_PT_R0100);
335                 R29 = add(R29, #_PT_REGS_SIZE);
336         }
337         trap1(#HVM_TRAP1_VMRTE)
338         /* Notreached */
339
340
341         .globl _K_enter_genex
342 _K_enter_genex:
343         vm_event_entry(do_genex)
344
345         .globl _K_enter_interrupt
346 _K_enter_interrupt:
347         vm_event_entry(arch_do_IRQ)
348
349         .globl _K_enter_trap0
350 _K_enter_trap0:
351         vm_event_entry(do_trap0)
352
353         .globl _K_enter_machcheck
354 _K_enter_machcheck:
355         vm_event_entry(do_machcheck)
356
357         .globl _K_enter_debug
358 _K_enter_debug:
359         vm_event_entry(do_debug_exception)
360
361         .globl ret_from_fork
362 ret_from_fork:
363         {
364                 call schedule_tail
365                 R26.H = #HI(do_work_pending);
366         }
367         {
368                 P0 = cmp.eq(R24, #0);
369                 R26.L = #LO(do_work_pending);
370                 R0 = #VM_INT_DISABLE;
371         }
372         if P0 jump check_work_pending
373         {
374                 R0 = R25;
375                 callr R24
376         }
377         {
378                 jump check_work_pending
379                 R0 = #VM_INT_DISABLE;
380         }