arch/powerpc/kernel/entry_64.S

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