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