arch/powerpc/kernel/entry_64.S

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