Merge branch 'core-rseq-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[sfrench/cifs-2.6.git] / arch / powerpc / kernel / entry_64.S
1 /*
2  *  PowerPC version 
3  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
4  *  Rewritten by Cort Dougan (cort@cs.nmt.edu) for PReP
5  *    Copyright (C) 1996 Cort Dougan <cort@cs.nmt.edu>
6  *  Adapted for Power Macintosh by Paul Mackerras.
7  *  Low-level exception handlers and MMU support
8  *  rewritten by Paul Mackerras.
9  *    Copyright (C) 1996 Paul Mackerras.
10  *  MPC8xx modifications Copyright (C) 1997 Dan Malek (dmalek@jlc.net).
11  *
12  *  This file contains the system call entry code, context switch
13  *  code, and exception/interrupt return code for PowerPC.
14  *
15  *  This program is free software; you can redistribute it and/or
16  *  modify it under the terms of the GNU General Public License
17  *  as published by the Free Software Foundation; either version
18  *  2 of the License, or (at your option) any later version.
19  */
20
21 #include <linux/errno.h>
22 #include <linux/err.h>
23 #include <asm/unistd.h>
24 #include <asm/processor.h>
25 #include <asm/page.h>
26 #include <asm/mmu.h>
27 #include <asm/thread_info.h>
28 #include <asm/ppc_asm.h>
29 #include <asm/asm-offsets.h>
30 #include <asm/cputable.h>
31 #include <asm/firmware.h>
32 #include <asm/bug.h>
33 #include <asm/ptrace.h>
34 #include <asm/irqflags.h>
35 #include <asm/hw_irq.h>
36 #include <asm/context_tracking.h>
37 #include <asm/tm.h>
38 #include <asm/ppc-opcode.h>
39 #include <asm/barrier.h>
40 #include <asm/export.h>
41 #ifdef CONFIG_PPC_BOOK3S
42 #include <asm/exception-64s.h>
43 #else
44 #include <asm/exception-64e.h>
45 #endif
46
47 /*
48  * System calls.
49  */
50         .section        ".toc","aw"
51 SYS_CALL_TABLE:
52         .tc sys_call_table[TC],sys_call_table
53
54 /* This value is used to mark exception frames on the stack. */
55 exception_marker:
56         .tc     ID_EXC_MARKER[TC],STACK_FRAME_REGS_MARKER
57
58         .section        ".text"
59         .align 7
60
61         .globl system_call_common
62 system_call_common:
63 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
64 BEGIN_FTR_SECTION
65         extrdi. r10, r12, 1, (63-MSR_TS_T_LG) /* transaction active? */
66         bne     .Ltabort_syscall
67 END_FTR_SECTION_IFSET(CPU_FTR_TM)
68 #endif
69         andi.   r10,r12,MSR_PR
70         mr      r10,r1
71         addi    r1,r1,-INT_FRAME_SIZE
72         beq-    1f
73         ld      r1,PACAKSAVE(r13)
74 1:      std     r10,0(r1)
75         std     r11,_NIP(r1)
76         std     r12,_MSR(r1)
77         std     r0,GPR0(r1)
78         std     r10,GPR1(r1)
79         beq     2f                      /* if from kernel mode */
80         ACCOUNT_CPU_USER_ENTRY(r13, r10, r11)
81 2:      std     r2,GPR2(r1)
82         std     r3,GPR3(r1)
83         mfcr    r2
84         std     r4,GPR4(r1)
85         std     r5,GPR5(r1)
86         std     r6,GPR6(r1)
87         std     r7,GPR7(r1)
88         std     r8,GPR8(r1)
89         li      r11,0
90         std     r11,GPR9(r1)
91         std     r11,GPR10(r1)
92         std     r11,GPR11(r1)
93         std     r11,GPR12(r1)
94         std     r11,_XER(r1)
95         std     r11,_CTR(r1)
96         std     r9,GPR13(r1)
97         mflr    r10
98         /*
99          * This clears CR0.SO (bit 28), which is the error indication on
100          * return from this system call.
101          */
102         rldimi  r2,r11,28,(63-28)
103         li      r11,0xc01
104         std     r10,_LINK(r1)
105         std     r11,_TRAP(r1)
106         std     r3,ORIG_GPR3(r1)
107         std     r2,_CCR(r1)
108         ld      r2,PACATOC(r13)
109         addi    r9,r1,STACK_FRAME_OVERHEAD
110         ld      r11,exception_marker@toc(r2)
111         std     r11,-16(r9)             /* "regshere" marker */
112 #if defined(CONFIG_VIRT_CPU_ACCOUNTING_NATIVE) && defined(CONFIG_PPC_SPLPAR)
113 BEGIN_FW_FTR_SECTION
114         beq     33f
115         /* if from user, see if there are any DTL entries to process */
116         ld      r10,PACALPPACAPTR(r13)  /* get ptr to VPA */
117         ld      r11,PACA_DTL_RIDX(r13)  /* get log read index */
118         addi    r10,r10,LPPACA_DTLIDX
119         LDX_BE  r10,0,r10               /* get log write index */
120         cmpd    cr1,r11,r10
121         beq+    cr1,33f
122         bl      accumulate_stolen_time
123         REST_GPR(0,r1)
124         REST_4GPRS(3,r1)
125         REST_2GPRS(7,r1)
126         addi    r9,r1,STACK_FRAME_OVERHEAD
127 33:
128 END_FW_FTR_SECTION_IFSET(FW_FEATURE_SPLPAR)
129 #endif /* CONFIG_VIRT_CPU_ACCOUNTING_NATIVE && CONFIG_PPC_SPLPAR */
130
131         /*
132          * A syscall should always be called with interrupts enabled
133          * so we just unconditionally hard-enable here. When some kind
134          * of irq tracing is used, we additionally check that condition
135          * is correct
136          */
137 #if defined(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG) && defined(CONFIG_BUG)
138         lbz     r10,PACAIRQSOFTMASK(r13)
139 1:      tdnei   r10,IRQS_ENABLED
140         EMIT_BUG_ENTRY 1b,__FILE__,__LINE__,BUGFLAG_WARNING
141 #endif
142
143 #ifdef CONFIG_PPC_BOOK3E
144         wrteei  1
145 #else
146         li      r11,MSR_RI
147         ori     r11,r11,MSR_EE
148         mtmsrd  r11,1
149 #endif /* CONFIG_PPC_BOOK3E */
150
151 system_call:                    /* label this so stack traces look sane */
152         /* We do need to set SOFTE in the stack frame or the return
153          * from interrupt will be painful
154          */
155         li      r10,IRQS_ENABLED
156         std     r10,SOFTE(r1)
157
158         CURRENT_THREAD_INFO(r11, r1)
159         ld      r10,TI_FLAGS(r11)
160         andi.   r11,r10,_TIF_SYSCALL_DOTRACE
161         bne     .Lsyscall_dotrace               /* does not return */
162         cmpldi  0,r0,NR_syscalls
163         bge-    .Lsyscall_enosys
164
165 .Lsyscall:
166 /*
167  * Need to vector to 32 Bit or default sys_call_table here,
168  * based on caller's run-mode / personality.
169  */
170         ld      r11,SYS_CALL_TABLE@toc(2)
171         andi.   r10,r10,_TIF_32BIT
172         beq     15f
173         addi    r11,r11,8       /* use 32-bit syscall entries */
174         clrldi  r3,r3,32
175         clrldi  r4,r4,32
176         clrldi  r5,r5,32
177         clrldi  r6,r6,32
178         clrldi  r7,r7,32
179         clrldi  r8,r8,32
180 15:
181         slwi    r0,r0,4
182
183         barrier_nospec_asm
184         /*
185          * Prevent the load of the handler below (based on the user-passed
186          * system call number) being speculatively executed until the test
187          * against NR_syscalls and branch to .Lsyscall_enosys above has
188          * committed.
189          */
190
191         ldx     r12,r11,r0      /* Fetch system call handler [ptr] */
192         mtctr   r12
193         bctrl                   /* Call handler */
194
195 .Lsyscall_exit:
196         std     r3,RESULT(r1)
197
198 #ifdef CONFIG_DEBUG_RSEQ
199         /* Check whether the syscall is issued inside a restartable sequence */
200         addi    r3,r1,STACK_FRAME_OVERHEAD
201         bl      rseq_syscall
202         ld      r3,RESULT(r1)
203 #endif
204
205         CURRENT_THREAD_INFO(r12, r1)
206
207         ld      r8,_MSR(r1)
208 #ifdef CONFIG_PPC_BOOK3S
209         /* No MSR:RI on BookE */
210         andi.   r10,r8,MSR_RI
211         beq-    .Lunrecov_restore
212 #endif
213
214 /*
215  * This is a few instructions into the actual syscall exit path (which actually
216  * starts at .Lsyscall_exit) to cater to kprobe blacklisting and to reduce the
217  * number of visible symbols for profiling purposes.
218  *
219  * We can probe from system_call until this point as MSR_RI is set. But once it
220  * is cleared below, we won't be able to take a trap.
221  *
222  * This is blacklisted from kprobes further below with _ASM_NOKPROBE_SYMBOL().
223  */
224 system_call_exit:
225         /*
226          * Disable interrupts so current_thread_info()->flags can't change,
227          * and so that we don't get interrupted after loading SRR0/1.
228          */
229 #ifdef CONFIG_PPC_BOOK3E
230         wrteei  0
231 #else
232         /*
233          * For performance reasons we clear RI the same time that we
234          * clear EE. We only need to clear RI just before we restore r13
235          * below, but batching it with EE saves us one expensive mtmsrd call.
236          * We have to be careful to restore RI if we branch anywhere from
237          * here (eg syscall_exit_work).
238          */
239         li      r11,0
240         mtmsrd  r11,1
241 #endif /* CONFIG_PPC_BOOK3E */
242
243         ld      r9,TI_FLAGS(r12)
244         li      r11,-MAX_ERRNO
245         andi.   r0,r9,(_TIF_SYSCALL_DOTRACE|_TIF_SINGLESTEP|_TIF_USER_WORK_MASK|_TIF_PERSYSCALL_MASK)
246         bne-    .Lsyscall_exit_work
247
248         andi.   r0,r8,MSR_FP
249         beq 2f
250 #ifdef CONFIG_ALTIVEC
251         andis.  r0,r8,MSR_VEC@h
252         bne     3f
253 #endif
254 2:      addi    r3,r1,STACK_FRAME_OVERHEAD
255 #ifdef CONFIG_PPC_BOOK3S
256         li      r10,MSR_RI
257         mtmsrd  r10,1           /* Restore RI */
258 #endif
259         bl      restore_math
260 #ifdef CONFIG_PPC_BOOK3S
261         li      r11,0
262         mtmsrd  r11,1
263 #endif
264         ld      r8,_MSR(r1)
265         ld      r3,RESULT(r1)
266         li      r11,-MAX_ERRNO
267
268 3:      cmpld   r3,r11
269         ld      r5,_CCR(r1)
270         bge-    .Lsyscall_error
271 .Lsyscall_error_cont:
272         ld      r7,_NIP(r1)
273 BEGIN_FTR_SECTION
274         stdcx.  r0,0,r1                 /* to clear the reservation */
275 END_FTR_SECTION_IFCLR(CPU_FTR_STCX_CHECKS_ADDRESS)
276         andi.   r6,r8,MSR_PR
277         ld      r4,_LINK(r1)
278
279         beq-    1f
280         ACCOUNT_CPU_USER_EXIT(r13, r11, r12)
281
282 BEGIN_FTR_SECTION
283         HMT_MEDIUM_LOW
284 END_FTR_SECTION_IFSET(CPU_FTR_HAS_PPR)
285
286         ld      r13,GPR13(r1)   /* only restore r13 if returning to usermode */
287         ld      r2,GPR2(r1)
288         ld      r1,GPR1(r1)
289         mtlr    r4
290         mtcr    r5
291         mtspr   SPRN_SRR0,r7
292         mtspr   SPRN_SRR1,r8
293         RFI_TO_USER
294         b       .       /* prevent speculative execution */
295
296         /* exit to kernel */
297 1:      ld      r2,GPR2(r1)
298         ld      r1,GPR1(r1)
299         mtlr    r4
300         mtcr    r5
301         mtspr   SPRN_SRR0,r7
302         mtspr   SPRN_SRR1,r8
303         RFI_TO_KERNEL
304         b       .       /* prevent speculative execution */
305
306 .Lsyscall_error:
307         oris    r5,r5,0x1000    /* Set SO bit in CR */
308         neg     r3,r3
309         std     r5,_CCR(r1)
310         b       .Lsyscall_error_cont
311
312 /* Traced system call support */
313 .Lsyscall_dotrace:
314         bl      save_nvgprs
315         addi    r3,r1,STACK_FRAME_OVERHEAD
316         bl      do_syscall_trace_enter
317
318         /*
319          * We use the return value of do_syscall_trace_enter() as the syscall
320          * number. If the syscall was rejected for any reason do_syscall_trace_enter()
321          * returns an invalid syscall number and the test below against
322          * NR_syscalls will fail.
323          */
324         mr      r0,r3
325
326         /* Restore argument registers just clobbered and/or possibly changed. */
327         ld      r3,GPR3(r1)
328         ld      r4,GPR4(r1)
329         ld      r5,GPR5(r1)
330         ld      r6,GPR6(r1)
331         ld      r7,GPR7(r1)
332         ld      r8,GPR8(r1)
333
334         /* Repopulate r9 and r10 for the syscall path */
335         addi    r9,r1,STACK_FRAME_OVERHEAD
336         CURRENT_THREAD_INFO(r10, r1)
337         ld      r10,TI_FLAGS(r10)
338
339         cmpldi  r0,NR_syscalls
340         blt+    .Lsyscall
341
342         /* Return code is already in r3 thanks to do_syscall_trace_enter() */
343         b       .Lsyscall_exit
344
345
346 .Lsyscall_enosys:
347         li      r3,-ENOSYS
348         b       .Lsyscall_exit
349         
350 .Lsyscall_exit_work:
351 #ifdef CONFIG_PPC_BOOK3S
352         li      r10,MSR_RI
353         mtmsrd  r10,1           /* Restore RI */
354 #endif
355         /* If TIF_RESTOREALL is set, don't scribble on either r3 or ccr.
356          If TIF_NOERROR is set, just save r3 as it is. */
357
358         andi.   r0,r9,_TIF_RESTOREALL
359         beq+    0f
360         REST_NVGPRS(r1)
361         b       2f
362 0:      cmpld   r3,r11          /* r11 is -MAX_ERRNO */
363         blt+    1f
364         andi.   r0,r9,_TIF_NOERROR
365         bne-    1f
366         ld      r5,_CCR(r1)
367         neg     r3,r3
368         oris    r5,r5,0x1000    /* Set SO bit in CR */
369         std     r5,_CCR(r1)
370 1:      std     r3,GPR3(r1)
371 2:      andi.   r0,r9,(_TIF_PERSYSCALL_MASK)
372         beq     4f
373
374         /* Clear per-syscall TIF flags if any are set.  */
375
376         li      r11,_TIF_PERSYSCALL_MASK
377         addi    r12,r12,TI_FLAGS
378 3:      ldarx   r10,0,r12
379         andc    r10,r10,r11
380         stdcx.  r10,0,r12
381         bne-    3b
382         subi    r12,r12,TI_FLAGS
383
384 4:      /* Anything else left to do? */
385 BEGIN_FTR_SECTION
386         lis     r3,INIT_PPR@highest     /* Set thread.ppr = 3 */
387         ld      r10,PACACURRENT(r13)
388         sldi    r3,r3,32        /* bits 11-13 are used for ppr */
389         std     r3,TASKTHREADPPR(r10)
390 END_FTR_SECTION_IFSET(CPU_FTR_HAS_PPR)
391
392         andi.   r0,r9,(_TIF_SYSCALL_DOTRACE|_TIF_SINGLESTEP)
393         beq     ret_from_except_lite
394
395         /* Re-enable interrupts */
396 #ifdef CONFIG_PPC_BOOK3E
397         wrteei  1
398 #else
399         li      r10,MSR_RI
400         ori     r10,r10,MSR_EE
401         mtmsrd  r10,1
402 #endif /* CONFIG_PPC_BOOK3E */
403
404         bl      save_nvgprs
405         addi    r3,r1,STACK_FRAME_OVERHEAD
406         bl      do_syscall_trace_leave
407         b       ret_from_except
408
409 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
410 .Ltabort_syscall:
411         /* Firstly we need to enable TM in the kernel */
412         mfmsr   r10
413         li      r9, 1
414         rldimi  r10, r9, MSR_TM_LG, 63-MSR_TM_LG
415         mtmsrd  r10, 0
416
417         /* tabort, this dooms the transaction, nothing else */
418         li      r9, (TM_CAUSE_SYSCALL|TM_CAUSE_PERSISTENT)
419         TABORT(R9)
420
421         /*
422          * Return directly to userspace. We have corrupted user register state,
423          * but userspace will never see that register state. Execution will
424          * resume after the tbegin of the aborted transaction with the
425          * checkpointed register state.
426          */
427         li      r9, MSR_RI
428         andc    r10, r10, r9
429         mtmsrd  r10, 1
430         mtspr   SPRN_SRR0, r11
431         mtspr   SPRN_SRR1, r12
432         RFI_TO_USER
433         b       .       /* prevent speculative execution */
434 #endif
435 _ASM_NOKPROBE_SYMBOL(system_call_common);
436 _ASM_NOKPROBE_SYMBOL(system_call_exit);
437
438 /* Save non-volatile GPRs, if not already saved. */
439 _GLOBAL(save_nvgprs)
440         ld      r11,_TRAP(r1)
441         andi.   r0,r11,1
442         beqlr-
443         SAVE_NVGPRS(r1)
444         clrrdi  r0,r11,1
445         std     r0,_TRAP(r1)
446         blr
447 _ASM_NOKPROBE_SYMBOL(save_nvgprs);
448
449         
450 /*
451  * The sigsuspend and rt_sigsuspend system calls can call do_signal
452  * and thus put the process into the stopped state where we might
453  * want to examine its user state with ptrace.  Therefore we need
454  * to save all the nonvolatile registers (r14 - r31) before calling
455  * the C code.  Similarly, fork, vfork and clone need the full
456  * register state on the stack so that it can be copied to the child.
457  */
458
459 _GLOBAL(ppc_fork)
460         bl      save_nvgprs
461         bl      sys_fork
462         b       .Lsyscall_exit
463
464 _GLOBAL(ppc_vfork)
465         bl      save_nvgprs
466         bl      sys_vfork
467         b       .Lsyscall_exit
468
469 _GLOBAL(ppc_clone)
470         bl      save_nvgprs
471         bl      sys_clone
472         b       .Lsyscall_exit
473
474 _GLOBAL(ppc32_swapcontext)
475         bl      save_nvgprs
476         bl      compat_sys_swapcontext
477         b       .Lsyscall_exit
478
479 _GLOBAL(ppc64_swapcontext)
480         bl      save_nvgprs
481         bl      sys_swapcontext
482         b       .Lsyscall_exit
483
484 _GLOBAL(ppc_switch_endian)
485         bl      save_nvgprs
486         bl      sys_switch_endian
487         b       .Lsyscall_exit
488
489 _GLOBAL(ret_from_fork)
490         bl      schedule_tail
491         REST_NVGPRS(r1)
492         li      r3,0
493         b       .Lsyscall_exit
494
495 _GLOBAL(ret_from_kernel_thread)
496         bl      schedule_tail
497         REST_NVGPRS(r1)
498         mtlr    r14
499         mr      r3,r15
500 #ifdef PPC64_ELF_ABI_v2
501         mr      r12,r14
502 #endif
503         blrl
504         li      r3,0
505         b       .Lsyscall_exit
506
507 /*
508  * This routine switches between two different tasks.  The process
509  * state of one is saved on its kernel stack.  Then the state
510  * of the other is restored from its kernel stack.  The memory
511  * management hardware is updated to the second process's state.
512  * Finally, we can return to the second process, via ret_from_except.
513  * On entry, r3 points to the THREAD for the current task, r4
514  * points to the THREAD for the new task.
515  *
516  * Note: there are two ways to get to the "going out" portion
517  * of this code; either by coming in via the entry (_switch)
518  * or via "fork" which must set up an environment equivalent
519  * to the "_switch" path.  If you change this you'll have to change
520  * the fork code also.
521  *
522  * The code which creates the new task context is in 'copy_thread'
523  * in arch/powerpc/kernel/process.c 
524  */
525         .align  7
526 _GLOBAL(_switch)
527         mflr    r0
528         std     r0,16(r1)
529         stdu    r1,-SWITCH_FRAME_SIZE(r1)
530         /* r3-r13 are caller saved -- Cort */
531         SAVE_8GPRS(14, r1)
532         SAVE_10GPRS(22, r1)
533         std     r0,_NIP(r1)     /* Return to switch caller */
534         mfcr    r23
535         std     r23,_CCR(r1)
536         std     r1,KSP(r3)      /* Set old stack pointer */
537
538         /*
539          * On SMP kernels, care must be taken because a task may be
540          * scheduled off CPUx and on to CPUy. Memory ordering must be
541          * considered.
542          *
543          * Cacheable stores on CPUx will be visible when the task is
544          * scheduled on CPUy by virtue of the core scheduler barriers
545          * (see "Notes on Program-Order guarantees on SMP systems." in
546          * kernel/sched/core.c).
547          *
548          * Uncacheable stores in the case of involuntary preemption must
549          * be taken care of. The smp_mb__before_spin_lock() in __schedule()
550          * is implemented as hwsync on powerpc, which orders MMIO too. So
551          * long as there is an hwsync in the context switch path, it will
552          * be executed on the source CPU after the task has performed
553          * all MMIO ops on that CPU, and on the destination CPU before the
554          * task performs any MMIO ops there.
555          */
556
557         /*
558          * The kernel context switch path must contain a spin_lock,
559          * which contains larx/stcx, which will clear any reservation
560          * of the task being switched.
561          */
562 #ifdef CONFIG_PPC_BOOK3S
563 /* Cancel all explict user streams as they will have no use after context
564  * switch and will stop the HW from creating streams itself
565  */
566         DCBT_BOOK3S_STOP_ALL_STREAM_IDS(r6)
567 #endif
568
569         addi    r6,r4,-THREAD   /* Convert THREAD to 'current' */
570         std     r6,PACACURRENT(r13)     /* Set new 'current' */
571
572         ld      r8,KSP(r4)      /* new stack pointer */
573 #ifdef CONFIG_PPC_BOOK3S_64
574 BEGIN_MMU_FTR_SECTION
575         b       2f
576 END_MMU_FTR_SECTION_IFSET(MMU_FTR_TYPE_RADIX)
577 BEGIN_FTR_SECTION
578         clrrdi  r6,r8,28        /* get its ESID */
579         clrrdi  r9,r1,28        /* get current sp ESID */
580 FTR_SECTION_ELSE
581         clrrdi  r6,r8,40        /* get its 1T ESID */
582         clrrdi  r9,r1,40        /* get current sp 1T ESID */
583 ALT_MMU_FTR_SECTION_END_IFCLR(MMU_FTR_1T_SEGMENT)
584         clrldi. r0,r6,2         /* is new ESID c00000000? */
585         cmpd    cr1,r6,r9       /* or is new ESID the same as current ESID? */
586         cror    eq,4*cr1+eq,eq
587         beq     2f              /* if yes, don't slbie it */
588
589         /* Bolt in the new stack SLB entry */
590         ld      r7,KSP_VSID(r4) /* Get new stack's VSID */
591         oris    r0,r6,(SLB_ESID_V)@h
592         ori     r0,r0,(SLB_NUM_BOLTED-1)@l
593 BEGIN_FTR_SECTION
594         li      r9,MMU_SEGSIZE_1T       /* insert B field */
595         oris    r6,r6,(MMU_SEGSIZE_1T << SLBIE_SSIZE_SHIFT)@h
596         rldimi  r7,r9,SLB_VSID_SSIZE_SHIFT,0
597 END_MMU_FTR_SECTION_IFSET(MMU_FTR_1T_SEGMENT)
598
599         /* Update the last bolted SLB.  No write barriers are needed
600          * here, provided we only update the current CPU's SLB shadow
601          * buffer.
602          */
603         ld      r9,PACA_SLBSHADOWPTR(r13)
604         li      r12,0
605         std     r12,SLBSHADOW_STACKESID(r9)     /* Clear ESID */
606         li      r12,SLBSHADOW_STACKVSID
607         STDX_BE r7,r12,r9                       /* Save VSID */
608         li      r12,SLBSHADOW_STACKESID
609         STDX_BE r0,r12,r9                       /* Save ESID */
610
611         /* No need to check for MMU_FTR_NO_SLBIE_B here, since when
612          * we have 1TB segments, the only CPUs known to have the errata
613          * only support less than 1TB of system memory and we'll never
614          * actually hit this code path.
615          */
616
617         isync
618         slbie   r6
619         slbie   r6              /* Workaround POWER5 < DD2.1 issue */
620         slbmte  r7,r0
621         isync
622 2:
623 #endif /* CONFIG_PPC_BOOK3S_64 */
624
625         CURRENT_THREAD_INFO(r7, r8)  /* base of new stack */
626         /* Note: this uses SWITCH_FRAME_SIZE rather than INT_FRAME_SIZE
627            because we don't need to leave the 288-byte ABI gap at the
628            top of the kernel stack. */
629         addi    r7,r7,THREAD_SIZE-SWITCH_FRAME_SIZE
630
631         /*
632          * PMU interrupts in radix may come in here. They will use r1, not
633          * PACAKSAVE, so this stack switch will not cause a problem. They
634          * will store to the process stack, which may then be migrated to
635          * another CPU. However the rq lock release on this CPU paired with
636          * the rq lock acquire on the new CPU before the stack becomes
637          * active on the new CPU, will order those stores.
638          */
639         mr      r1,r8           /* start using new stack pointer */
640         std     r7,PACAKSAVE(r13)
641
642         ld      r6,_CCR(r1)
643         mtcrf   0xFF,r6
644
645         /* r3-r13 are destroyed -- Cort */
646         REST_8GPRS(14, r1)
647         REST_10GPRS(22, r1)
648
649         /* convert old thread to its task_struct for return value */
650         addi    r3,r3,-THREAD
651         ld      r7,_NIP(r1)     /* Return to _switch caller in new task */
652         mtlr    r7
653         addi    r1,r1,SWITCH_FRAME_SIZE
654         blr
655
656         .align  7
657 _GLOBAL(ret_from_except)
658         ld      r11,_TRAP(r1)
659         andi.   r0,r11,1
660         bne     ret_from_except_lite
661         REST_NVGPRS(r1)
662
663 _GLOBAL(ret_from_except_lite)
664         /*
665          * Disable interrupts so that current_thread_info()->flags
666          * can't change between when we test it and when we return
667          * from the interrupt.
668          */
669 #ifdef CONFIG_PPC_BOOK3E
670         wrteei  0
671 #else
672         li      r10,MSR_RI
673         mtmsrd  r10,1             /* Update machine state */
674 #endif /* CONFIG_PPC_BOOK3E */
675
676         CURRENT_THREAD_INFO(r9, r1)
677         ld      r3,_MSR(r1)
678 #ifdef CONFIG_PPC_BOOK3E
679         ld      r10,PACACURRENT(r13)
680 #endif /* CONFIG_PPC_BOOK3E */
681         ld      r4,TI_FLAGS(r9)
682         andi.   r3,r3,MSR_PR
683         beq     resume_kernel
684 #ifdef CONFIG_PPC_BOOK3E
685         lwz     r3,(THREAD+THREAD_DBCR0)(r10)
686 #endif /* CONFIG_PPC_BOOK3E */
687
688         /* Check current_thread_info()->flags */
689         andi.   r0,r4,_TIF_USER_WORK_MASK
690         bne     1f
691 #ifdef CONFIG_PPC_BOOK3E
692         /*
693          * Check to see if the dbcr0 register is set up to debug.
694          * Use the internal debug mode bit to do this.
695          */
696         andis.  r0,r3,DBCR0_IDM@h
697         beq     restore
698         mfmsr   r0
699         rlwinm  r0,r0,0,~MSR_DE /* Clear MSR.DE */
700         mtmsr   r0
701         mtspr   SPRN_DBCR0,r3
702         li      r10, -1
703         mtspr   SPRN_DBSR,r10
704         b       restore
705 #else
706         addi    r3,r1,STACK_FRAME_OVERHEAD
707         bl      restore_math
708         b       restore
709 #endif
710 1:      andi.   r0,r4,_TIF_NEED_RESCHED
711         beq     2f
712         bl      restore_interrupts
713         SCHEDULE_USER
714         b       ret_from_except_lite
715 2:
716 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
717         andi.   r0,r4,_TIF_USER_WORK_MASK & ~_TIF_RESTORE_TM
718         bne     3f              /* only restore TM if nothing else to do */
719         addi    r3,r1,STACK_FRAME_OVERHEAD
720         bl      restore_tm_state
721         b       restore
722 3:
723 #endif
724         bl      save_nvgprs
725         /*
726          * Use a non volatile GPR to save and restore our thread_info flags
727          * across the call to restore_interrupts.
728          */
729         mr      r30,r4
730         bl      restore_interrupts
731         mr      r4,r30
732         addi    r3,r1,STACK_FRAME_OVERHEAD
733         bl      do_notify_resume
734         b       ret_from_except
735
736 resume_kernel:
737         /* check current_thread_info, _TIF_EMULATE_STACK_STORE */
738         andis.  r8,r4,_TIF_EMULATE_STACK_STORE@h
739         beq+    1f
740
741         addi    r8,r1,INT_FRAME_SIZE    /* Get the kprobed function entry */
742
743         ld      r3,GPR1(r1)
744         subi    r3,r3,INT_FRAME_SIZE    /* dst: Allocate a trampoline exception frame */
745         mr      r4,r1                   /* src:  current exception frame */
746         mr      r1,r3                   /* Reroute the trampoline frame to r1 */
747
748         /* Copy from the original to the trampoline. */
749         li      r5,INT_FRAME_SIZE/8     /* size: INT_FRAME_SIZE */
750         li      r6,0                    /* start offset: 0 */
751         mtctr   r5
752 2:      ldx     r0,r6,r4
753         stdx    r0,r6,r3
754         addi    r6,r6,8
755         bdnz    2b
756
757         /* Do real store operation to complete stdu */
758         ld      r5,GPR1(r1)
759         std     r8,0(r5)
760
761         /* Clear _TIF_EMULATE_STACK_STORE flag */
762         lis     r11,_TIF_EMULATE_STACK_STORE@h
763         addi    r5,r9,TI_FLAGS
764 0:      ldarx   r4,0,r5
765         andc    r4,r4,r11
766         stdcx.  r4,0,r5
767         bne-    0b
768 1:
769
770 #ifdef CONFIG_PREEMPT
771         /* Check if we need to preempt */
772         andi.   r0,r4,_TIF_NEED_RESCHED
773         beq+    restore
774         /* Check that preempt_count() == 0 and interrupts are enabled */
775         lwz     r8,TI_PREEMPT(r9)
776         cmpwi   cr0,r8,0
777         bne     restore
778         ld      r0,SOFTE(r1)
779         andi.   r0,r0,IRQS_DISABLED
780         bne     restore
781
782         /*
783          * Here we are preempting the current task. We want to make
784          * sure we are soft-disabled first and reconcile irq state.
785          */
786         RECONCILE_IRQ_STATE(r3,r4)
787 1:      bl      preempt_schedule_irq
788
789         /* Re-test flags and eventually loop */
790         CURRENT_THREAD_INFO(r9, r1)
791         ld      r4,TI_FLAGS(r9)
792         andi.   r0,r4,_TIF_NEED_RESCHED
793         bne     1b
794
795         /*
796          * arch_local_irq_restore() from preempt_schedule_irq above may
797          * enable hard interrupt but we really should disable interrupts
798          * when we return from the interrupt, and so that we don't get
799          * interrupted after loading SRR0/1.
800          */
801 #ifdef CONFIG_PPC_BOOK3E
802         wrteei  0
803 #else
804         li      r10,MSR_RI
805         mtmsrd  r10,1             /* Update machine state */
806 #endif /* CONFIG_PPC_BOOK3E */
807 #endif /* CONFIG_PREEMPT */
808
809         .globl  fast_exc_return_irq
810 fast_exc_return_irq:
811 restore:
812         /*
813          * This is the main kernel exit path. First we check if we
814          * are about to re-enable interrupts
815          */
816         ld      r5,SOFTE(r1)
817         lbz     r6,PACAIRQSOFTMASK(r13)
818         andi.   r5,r5,IRQS_DISABLED
819         bne     .Lrestore_irq_off
820
821         /* We are enabling, were we already enabled ? Yes, just return */
822         andi.   r6,r6,IRQS_DISABLED
823         beq     cr0,.Ldo_restore
824
825         /*
826          * We are about to soft-enable interrupts (we are hard disabled
827          * at this point). We check if there's anything that needs to
828          * be replayed first.
829          */
830         lbz     r0,PACAIRQHAPPENED(r13)
831         cmpwi   cr0,r0,0
832         bne-    .Lrestore_check_irq_replay
833
834         /*
835          * Get here when nothing happened while soft-disabled, just
836          * soft-enable and move-on. We will hard-enable as a side
837          * effect of rfi
838          */
839 .Lrestore_no_replay:
840         TRACE_ENABLE_INTS
841         li      r0,IRQS_ENABLED
842         stb     r0,PACAIRQSOFTMASK(r13);
843
844         /*
845          * Final return path. BookE is handled in a different file
846          */
847 .Ldo_restore:
848 #ifdef CONFIG_PPC_BOOK3E
849         b       exception_return_book3e
850 #else
851         /*
852          * Clear the reservation. If we know the CPU tracks the address of
853          * the reservation then we can potentially save some cycles and use
854          * a larx. On POWER6 and POWER7 this is significantly faster.
855          */
856 BEGIN_FTR_SECTION
857         stdcx.  r0,0,r1         /* to clear the reservation */
858 FTR_SECTION_ELSE
859         ldarx   r4,0,r1
860 ALT_FTR_SECTION_END_IFCLR(CPU_FTR_STCX_CHECKS_ADDRESS)
861
862         /*
863          * Some code path such as load_up_fpu or altivec return directly
864          * here. They run entirely hard disabled and do not alter the
865          * interrupt state. They also don't use lwarx/stwcx. and thus
866          * are known not to leave dangling reservations.
867          */
868         .globl  fast_exception_return
869 fast_exception_return:
870         ld      r3,_MSR(r1)
871         ld      r4,_CTR(r1)
872         ld      r0,_LINK(r1)
873         mtctr   r4
874         mtlr    r0
875         ld      r4,_XER(r1)
876         mtspr   SPRN_XER,r4
877
878         REST_8GPRS(5, r1)
879
880         andi.   r0,r3,MSR_RI
881         beq-    .Lunrecov_restore
882
883         /* Load PPR from thread struct before we clear MSR:RI */
884 BEGIN_FTR_SECTION
885         ld      r2,PACACURRENT(r13)
886         ld      r2,TASKTHREADPPR(r2)
887 END_FTR_SECTION_IFSET(CPU_FTR_HAS_PPR)
888
889         /*
890          * Clear RI before restoring r13.  If we are returning to
891          * userspace and we take an exception after restoring r13,
892          * we end up corrupting the userspace r13 value.
893          */
894         li      r4,0
895         mtmsrd  r4,1
896
897 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
898         /* TM debug */
899         std     r3, PACATMSCRATCH(r13) /* Stash returned-to MSR */
900 #endif
901         /*
902          * r13 is our per cpu area, only restore it if we are returning to
903          * userspace the value stored in the stack frame may belong to
904          * another CPU.
905          */
906         andi.   r0,r3,MSR_PR
907         beq     1f
908 BEGIN_FTR_SECTION
909         mtspr   SPRN_PPR,r2     /* Restore PPR */
910 END_FTR_SECTION_IFSET(CPU_FTR_HAS_PPR)
911         ACCOUNT_CPU_USER_EXIT(r13, r2, r4)
912         REST_GPR(13, r1)
913
914         mtspr   SPRN_SRR1,r3
915
916         ld      r2,_CCR(r1)
917         mtcrf   0xFF,r2
918         ld      r2,_NIP(r1)
919         mtspr   SPRN_SRR0,r2
920
921         ld      r0,GPR0(r1)
922         ld      r2,GPR2(r1)
923         ld      r3,GPR3(r1)
924         ld      r4,GPR4(r1)
925         ld      r1,GPR1(r1)
926         RFI_TO_USER
927         b       .       /* prevent speculative execution */
928
929 1:      mtspr   SPRN_SRR1,r3
930
931         ld      r2,_CCR(r1)
932         mtcrf   0xFF,r2
933         ld      r2,_NIP(r1)
934         mtspr   SPRN_SRR0,r2
935
936         ld      r0,GPR0(r1)
937         ld      r2,GPR2(r1)
938         ld      r3,GPR3(r1)
939         ld      r4,GPR4(r1)
940         ld      r1,GPR1(r1)
941         RFI_TO_KERNEL
942         b       .       /* prevent speculative execution */
943
944 #endif /* CONFIG_PPC_BOOK3E */
945
946         /*
947          * We are returning to a context with interrupts soft disabled.
948          *
949          * However, we may also about to hard enable, so we need to
950          * make sure that in this case, we also clear PACA_IRQ_HARD_DIS
951          * or that bit can get out of sync and bad things will happen
952          */
953 .Lrestore_irq_off:
954         ld      r3,_MSR(r1)
955         lbz     r7,PACAIRQHAPPENED(r13)
956         andi.   r0,r3,MSR_EE
957         beq     1f
958         rlwinm  r7,r7,0,~PACA_IRQ_HARD_DIS
959         stb     r7,PACAIRQHAPPENED(r13)
960 1:
961 #if defined(CONFIG_PPC_IRQ_SOFT_MASK_DEBUG) && defined(CONFIG_BUG)
962         /* The interrupt should not have soft enabled. */
963         lbz     r7,PACAIRQSOFTMASK(r13)
964 1:      tdeqi   r7,IRQS_ENABLED
965         EMIT_BUG_ENTRY 1b,__FILE__,__LINE__,BUGFLAG_WARNING
966 #endif
967         b       .Ldo_restore
968
969         /*
970          * Something did happen, check if a re-emit is needed
971          * (this also clears paca->irq_happened)
972          */
973 .Lrestore_check_irq_replay:
974         /* XXX: We could implement a fast path here where we check
975          * for irq_happened being just 0x01, in which case we can
976          * clear it and return. That means that we would potentially
977          * miss a decrementer having wrapped all the way around.
978          *
979          * Still, this might be useful for things like hash_page
980          */
981         bl      __check_irq_replay
982         cmpwi   cr0,r3,0
983         beq     .Lrestore_no_replay
984  
985         /*
986          * We need to re-emit an interrupt. We do so by re-using our
987          * existing exception frame. We first change the trap value,
988          * but we need to ensure we preserve the low nibble of it
989          */
990         ld      r4,_TRAP(r1)
991         clrldi  r4,r4,60
992         or      r4,r4,r3
993         std     r4,_TRAP(r1)
994
995         /*
996          * Then find the right handler and call it. Interrupts are
997          * still soft-disabled and we keep them that way.
998         */
999         cmpwi   cr0,r3,0x500
1000         bne     1f
1001         addi    r3,r1,STACK_FRAME_OVERHEAD;
1002         bl      do_IRQ
1003         b       ret_from_except
1004 1:      cmpwi   cr0,r3,0xf00
1005         bne     1f
1006         addi    r3,r1,STACK_FRAME_OVERHEAD;
1007         bl      performance_monitor_exception
1008         b       ret_from_except
1009 1:      cmpwi   cr0,r3,0xe60
1010         bne     1f
1011         addi    r3,r1,STACK_FRAME_OVERHEAD;
1012         bl      handle_hmi_exception
1013         b       ret_from_except
1014 1:      cmpwi   cr0,r3,0x900
1015         bne     1f
1016         addi    r3,r1,STACK_FRAME_OVERHEAD;
1017         bl      timer_interrupt
1018         b       ret_from_except
1019 #ifdef CONFIG_PPC_DOORBELL
1020 1:
1021 #ifdef CONFIG_PPC_BOOK3E
1022         cmpwi   cr0,r3,0x280
1023 #else
1024         cmpwi   cr0,r3,0xa00
1025 #endif /* CONFIG_PPC_BOOK3E */
1026         bne     1f
1027         addi    r3,r1,STACK_FRAME_OVERHEAD;
1028         bl      doorbell_exception
1029 #endif /* CONFIG_PPC_DOORBELL */
1030 1:      b       ret_from_except /* What else to do here ? */
1031  
1032 .Lunrecov_restore:
1033         addi    r3,r1,STACK_FRAME_OVERHEAD
1034         bl      unrecoverable_exception
1035         b       .Lunrecov_restore
1036
1037 _ASM_NOKPROBE_SYMBOL(ret_from_except);
1038 _ASM_NOKPROBE_SYMBOL(ret_from_except_lite);
1039 _ASM_NOKPROBE_SYMBOL(resume_kernel);
1040 _ASM_NOKPROBE_SYMBOL(fast_exc_return_irq);
1041 _ASM_NOKPROBE_SYMBOL(restore);
1042 _ASM_NOKPROBE_SYMBOL(fast_exception_return);
1043
1044
1045 #ifdef CONFIG_PPC_RTAS
1046 /*
1047  * On CHRP, the Run-Time Abstraction Services (RTAS) have to be
1048  * called with the MMU off.
1049  *
1050  * In addition, we need to be in 32b mode, at least for now.
1051  * 
1052  * Note: r3 is an input parameter to rtas, so don't trash it...
1053  */
1054 _GLOBAL(enter_rtas)
1055         mflr    r0
1056         std     r0,16(r1)
1057         stdu    r1,-RTAS_FRAME_SIZE(r1) /* Save SP and create stack space. */
1058
1059         /* Because RTAS is running in 32b mode, it clobbers the high order half
1060          * of all registers that it saves.  We therefore save those registers
1061          * RTAS might touch to the stack.  (r0, r3-r13 are caller saved)
1062          */
1063         SAVE_GPR(2, r1)                 /* Save the TOC */
1064         SAVE_GPR(13, r1)                /* Save paca */
1065         SAVE_8GPRS(14, r1)              /* Save the non-volatiles */
1066         SAVE_10GPRS(22, r1)             /* ditto */
1067
1068         mfcr    r4
1069         std     r4,_CCR(r1)
1070         mfctr   r5
1071         std     r5,_CTR(r1)
1072         mfspr   r6,SPRN_XER
1073         std     r6,_XER(r1)
1074         mfdar   r7
1075         std     r7,_DAR(r1)
1076         mfdsisr r8
1077         std     r8,_DSISR(r1)
1078
1079         /* Temporary workaround to clear CR until RTAS can be modified to
1080          * ignore all bits.
1081          */
1082         li      r0,0
1083         mtcr    r0
1084
1085 #ifdef CONFIG_BUG
1086         /* There is no way it is acceptable to get here with interrupts enabled,
1087          * check it with the asm equivalent of WARN_ON
1088          */
1089         lbz     r0,PACAIRQSOFTMASK(r13)
1090 1:      tdeqi   r0,IRQS_ENABLED
1091         EMIT_BUG_ENTRY 1b,__FILE__,__LINE__,BUGFLAG_WARNING
1092 #endif
1093
1094         /* Hard-disable interrupts */
1095         mfmsr   r6
1096         rldicl  r7,r6,48,1
1097         rotldi  r7,r7,16
1098         mtmsrd  r7,1
1099
1100         /* Unfortunately, the stack pointer and the MSR are also clobbered,
1101          * so they are saved in the PACA which allows us to restore
1102          * our original state after RTAS returns.
1103          */
1104         std     r1,PACAR1(r13)
1105         std     r6,PACASAVEDMSR(r13)
1106
1107         /* Setup our real return addr */        
1108         LOAD_REG_ADDR(r4,rtas_return_loc)
1109         clrldi  r4,r4,2                 /* convert to realmode address */
1110         mtlr    r4
1111
1112         li      r0,0
1113         ori     r0,r0,MSR_EE|MSR_SE|MSR_BE|MSR_RI
1114         andc    r0,r6,r0
1115         
1116         li      r9,1
1117         rldicr  r9,r9,MSR_SF_LG,(63-MSR_SF_LG)
1118         ori     r9,r9,MSR_IR|MSR_DR|MSR_FE0|MSR_FE1|MSR_FP|MSR_RI|MSR_LE
1119         andc    r6,r0,r9
1120
1121 __enter_rtas:
1122         sync                            /* disable interrupts so SRR0/1 */
1123         mtmsrd  r0                      /* don't get trashed */
1124
1125         LOAD_REG_ADDR(r4, rtas)
1126         ld      r5,RTASENTRY(r4)        /* get the rtas->entry value */
1127         ld      r4,RTASBASE(r4)         /* get the rtas->base value */
1128         
1129         mtspr   SPRN_SRR0,r5
1130         mtspr   SPRN_SRR1,r6
1131         RFI_TO_KERNEL
1132         b       .       /* prevent speculative execution */
1133
1134 rtas_return_loc:
1135         FIXUP_ENDIAN
1136
1137         /*
1138          * Clear RI and set SF before anything.
1139          */
1140         mfmsr   r6
1141         li      r0,MSR_RI
1142         andc    r6,r6,r0
1143         sldi    r0,r0,(MSR_SF_LG - MSR_RI_LG)
1144         or      r6,r6,r0
1145         sync
1146         mtmsrd  r6
1147
1148         /* relocation is off at this point */
1149         GET_PACA(r4)
1150         clrldi  r4,r4,2                 /* convert to realmode address */
1151
1152         bcl     20,31,$+4
1153 0:      mflr    r3
1154         ld      r3,(1f-0b)(r3)          /* get &rtas_restore_regs */
1155
1156         ld      r1,PACAR1(r4)           /* Restore our SP */
1157         ld      r4,PACASAVEDMSR(r4)     /* Restore our MSR */
1158
1159         mtspr   SPRN_SRR0,r3
1160         mtspr   SPRN_SRR1,r4
1161         RFI_TO_KERNEL
1162         b       .       /* prevent speculative execution */
1163 _ASM_NOKPROBE_SYMBOL(__enter_rtas)
1164 _ASM_NOKPROBE_SYMBOL(rtas_return_loc)
1165
1166         .align  3
1167 1:      .8byte  rtas_restore_regs
1168
1169 rtas_restore_regs:
1170         /* relocation is on at this point */
1171         REST_GPR(2, r1)                 /* Restore the TOC */
1172         REST_GPR(13, r1)                /* Restore paca */
1173         REST_8GPRS(14, r1)              /* Restore the non-volatiles */
1174         REST_10GPRS(22, r1)             /* ditto */
1175
1176         GET_PACA(r13)
1177
1178         ld      r4,_CCR(r1)
1179         mtcr    r4
1180         ld      r5,_CTR(r1)
1181         mtctr   r5
1182         ld      r6,_XER(r1)
1183         mtspr   SPRN_XER,r6
1184         ld      r7,_DAR(r1)
1185         mtdar   r7
1186         ld      r8,_DSISR(r1)
1187         mtdsisr r8
1188
1189         addi    r1,r1,RTAS_FRAME_SIZE   /* Unstack our frame */
1190         ld      r0,16(r1)               /* get return address */
1191
1192         mtlr    r0
1193         blr                             /* return to caller */
1194
1195 #endif /* CONFIG_PPC_RTAS */
1196
1197 _GLOBAL(enter_prom)
1198         mflr    r0
1199         std     r0,16(r1)
1200         stdu    r1,-PROM_FRAME_SIZE(r1) /* Save SP and create stack space */
1201
1202         /* Because PROM is running in 32b mode, it clobbers the high order half
1203          * of all registers that it saves.  We therefore save those registers
1204          * PROM might touch to the stack.  (r0, r3-r13 are caller saved)
1205          */
1206         SAVE_GPR(2, r1)
1207         SAVE_GPR(13, r1)
1208         SAVE_8GPRS(14, r1)
1209         SAVE_10GPRS(22, r1)
1210         mfcr    r10
1211         mfmsr   r11
1212         std     r10,_CCR(r1)
1213         std     r11,_MSR(r1)
1214
1215         /* Put PROM address in SRR0 */
1216         mtsrr0  r4
1217
1218         /* Setup our trampoline return addr in LR */
1219         bcl     20,31,$+4
1220 0:      mflr    r4
1221         addi    r4,r4,(1f - 0b)
1222         mtlr    r4
1223
1224         /* Prepare a 32-bit mode big endian MSR
1225          */
1226 #ifdef CONFIG_PPC_BOOK3E
1227         rlwinm  r11,r11,0,1,31
1228         mtsrr1  r11
1229         rfi
1230 #else /* CONFIG_PPC_BOOK3E */
1231         LOAD_REG_IMMEDIATE(r12, MSR_SF | MSR_ISF | MSR_LE)
1232         andc    r11,r11,r12
1233         mtsrr1  r11
1234         RFI_TO_KERNEL
1235 #endif /* CONFIG_PPC_BOOK3E */
1236
1237 1:      /* Return from OF */
1238         FIXUP_ENDIAN
1239
1240         /* Just make sure that r1 top 32 bits didn't get
1241          * corrupt by OF
1242          */
1243         rldicl  r1,r1,0,32
1244
1245         /* Restore the MSR (back to 64 bits) */
1246         ld      r0,_MSR(r1)
1247         MTMSRD(r0)
1248         isync
1249
1250         /* Restore other registers */
1251         REST_GPR(2, r1)
1252         REST_GPR(13, r1)
1253         REST_8GPRS(14, r1)
1254         REST_10GPRS(22, r1)
1255         ld      r4,_CCR(r1)
1256         mtcr    r4
1257         
1258         addi    r1,r1,PROM_FRAME_SIZE
1259         ld      r0,16(r1)
1260         mtlr    r0
1261         blr