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