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