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