arch/powerpc/kernel/entry_32.S

   1 /*
   2  *  PowerPC version
   3  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
   4  *  Rewritten by Cort Dougan (cort@fsmlabs.com) for PReP
   5  *    Copyright (C) 1996 Cort Dougan <cort@fsmlabs.com>
   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
  22 #include <linux/errno.h>
  23 #include <linux/err.h>
  24 #include <linux/sys.h>
  25 #include <linux/threads.h>
  26 #include <asm/reg.h>
  27 #include <asm/page.h>
  28 #include <asm/mmu.h>
  29 #include <asm/cputable.h>
  30 #include <asm/thread_info.h>
  31 #include <asm/ppc_asm.h>
  32 #include <asm/asm-offsets.h>
  33 #include <asm/unistd.h>
  34 #include <asm/ftrace.h>
  35 #include <asm/ptrace.h>
  36 #include <asm/export.h>
  37 #include <asm/barrier.h>
  38
  39 /*
  40  * MSR_KERNEL is > 0x10000 on 4xx/Book-E since it include MSR_CE.
  41  */
  42 #if MSR_KERNEL >= 0x10000
  43 #define LOAD_MSR_KERNEL(r, x)   lis r,(x)@h; ori r,r,(x)@l
  44 #else
  45 #define LOAD_MSR_KERNEL(r, x)   li r,(x)
  46 #endif
  47
  48 #ifdef CONFIG_BOOKE
  49         .globl  mcheck_transfer_to_handler
  50 mcheck_transfer_to_handler:
  51         mfspr   r0,SPRN_DSRR0
  52         stw     r0,_DSRR0(r11)
  53         mfspr   r0,SPRN_DSRR1
  54         stw     r0,_DSRR1(r11)
  55         /* fall through */
  56
  57         .globl  debug_transfer_to_handler
  58 debug_transfer_to_handler:
  59         mfspr   r0,SPRN_CSRR0
  60         stw     r0,_CSRR0(r11)
  61         mfspr   r0,SPRN_CSRR1
  62         stw     r0,_CSRR1(r11)
  63         /* fall through */
  64
  65         .globl  crit_transfer_to_handler
  66 crit_transfer_to_handler:
  67 #ifdef CONFIG_PPC_BOOK3E_MMU
  68         mfspr   r0,SPRN_MAS0
  69         stw     r0,MAS0(r11)
  70         mfspr   r0,SPRN_MAS1
  71         stw     r0,MAS1(r11)
  72         mfspr   r0,SPRN_MAS2
  73         stw     r0,MAS2(r11)
  74         mfspr   r0,SPRN_MAS3
  75         stw     r0,MAS3(r11)
  76         mfspr   r0,SPRN_MAS6
  77         stw     r0,MAS6(r11)
  78 #ifdef CONFIG_PHYS_64BIT
  79         mfspr   r0,SPRN_MAS7
  80         stw     r0,MAS7(r11)
  81 #endif /* CONFIG_PHYS_64BIT */
  82 #endif /* CONFIG_PPC_BOOK3E_MMU */
  83 #ifdef CONFIG_44x
  84         mfspr   r0,SPRN_MMUCR
  85         stw     r0,MMUCR(r11)
  86 #endif
  87         mfspr   r0,SPRN_SRR0
  88         stw     r0,_SRR0(r11)
  89         mfspr   r0,SPRN_SRR1
  90         stw     r0,_SRR1(r11)
  91
  92         /* set the stack limit to the current stack
  93          * and set the limit to protect the thread_info
  94          * struct
  95          */
  96         mfspr   r8,SPRN_SPRG_THREAD
  97         lwz     r0,KSP_LIMIT(r8)
  98         stw     r0,SAVED_KSP_LIMIT(r11)
  99         rlwimi  r0,r1,0,0,(31-THREAD_SHIFT)
 100         stw     r0,KSP_LIMIT(r8)
 101         /* fall through */
 102 #endif
 103
 104 #ifdef CONFIG_40x
 105         .globl  crit_transfer_to_handler
 106 crit_transfer_to_handler:
 107         lwz     r0,crit_r10@l(0)
 108         stw     r0,GPR10(r11)
 109         lwz     r0,crit_r11@l(0)
 110         stw     r0,GPR11(r11)
 111         mfspr   r0,SPRN_SRR0
 112         stw     r0,crit_srr0@l(0)
 113         mfspr   r0,SPRN_SRR1
 114         stw     r0,crit_srr1@l(0)
 115
 116         /* set the stack limit to the current stack
 117          * and set the limit to protect the thread_info
 118          * struct
 119          */
 120         mfspr   r8,SPRN_SPRG_THREAD
 121         lwz     r0,KSP_LIMIT(r8)
 122         stw     r0,saved_ksp_limit@l(0)
 123         rlwimi  r0,r1,0,0,(31-THREAD_SHIFT)
 124         stw     r0,KSP_LIMIT(r8)
 125         /* fall through */
 126 #endif
 127
 128 /*
 129  * This code finishes saving the registers to the exception frame
 130  * and jumps to the appropriate handler for the exception, turning
 131  * on address translation.
 132  * Note that we rely on the caller having set cr0.eq iff the exception
 133  * occurred in kernel mode (i.e. MSR:PR = 0).
 134  */
 135         .globl  transfer_to_handler_full
 136 transfer_to_handler_full:
 137         SAVE_NVGPRS(r11)
 138         /* fall through */
 139
 140         .globl  transfer_to_handler
 141 transfer_to_handler:
 142         stw     r2,GPR2(r11)
 143         stw     r12,_NIP(r11)
 144         stw     r9,_MSR(r11)
 145         andi.   r2,r9,MSR_PR
 146         mfctr   r12
 147         mfspr   r2,SPRN_XER
 148         stw     r12,_CTR(r11)
 149         stw     r2,_XER(r11)
 150         mfspr   r12,SPRN_SPRG_THREAD
 151         addi    r2,r12,-THREAD
 152         tovirt(r2,r2)                   /* set r2 to current */
 153         beq     2f                      /* if from user, fix up THREAD.regs */
 154         addi    r11,r1,STACK_FRAME_OVERHEAD
 155         stw     r11,PT_REGS(r12)
 156 #if defined(CONFIG_40x) || defined(CONFIG_BOOKE)
 157         /* Check to see if the dbcr0 register is set up to debug.  Use the
 158            internal debug mode bit to do this. */
 159         lwz     r12,THREAD_DBCR0(r12)
 160         andis.  r12,r12,DBCR0_IDM@h
 161         beq+    3f
 162         /* From user and task is ptraced - load up global dbcr0 */
 163         li      r12,-1                  /* clear all pending debug events */
 164         mtspr   SPRN_DBSR,r12
 165         lis     r11,global_dbcr0@ha
 166         tophys(r11,r11)
 167         addi    r11,r11,global_dbcr0@l
 168 #ifdef CONFIG_SMP
 169         CURRENT_THREAD_INFO(r9, r1)
 170         lwz     r9,TI_CPU(r9)
 171         slwi    r9,r9,3
 172         add     r11,r11,r9
 173 #endif
 174         lwz     r12,0(r11)
 175         mtspr   SPRN_DBCR0,r12
 176         lwz     r12,4(r11)
 177         addi    r12,r12,-1
 178         stw     r12,4(r11)
 179 #endif
 180 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
 181         CURRENT_THREAD_INFO(r9, r1)
 182         tophys(r9, r9)
 183         ACCOUNT_CPU_USER_ENTRY(r9, r11, r12)
 184 #endif
 185
 186         b       3f
 187
 188 2:      /* if from kernel, check interrupted DOZE/NAP mode and
 189          * check for stack overflow
 190          */
 191         lwz     r9,KSP_LIMIT(r12)
 192         cmplw   r1,r9                   /* if r1 <= ksp_limit */
 193         ble-    stack_ovf               /* then the kernel stack overflowed */
 194 5:
 195 #if defined(CONFIG_6xx) || defined(CONFIG_E500)
 196         CURRENT_THREAD_INFO(r9, r1)
 197         tophys(r9,r9)                   /* check local flags */
 198         lwz     r12,TI_LOCAL_FLAGS(r9)
 199         mtcrf   0x01,r12
 200         bt-     31-TLF_NAPPING,4f
 201         bt-     31-TLF_SLEEPING,7f
 202 #endif /* CONFIG_6xx || CONFIG_E500 */
 203         .globl transfer_to_handler_cont
 204 transfer_to_handler_cont:
 205 3:
 206         mflr    r9
 207         lwz     r11,0(r9)               /* virtual address of handler */
 208         lwz     r9,4(r9)                /* where to go when done */
 209 #ifdef CONFIG_TRACE_IRQFLAGS
 210         lis     r12,reenable_mmu@h
 211         ori     r12,r12,reenable_mmu@l
 212         mtspr   SPRN_SRR0,r12
 213         mtspr   SPRN_SRR1,r10
 214         SYNC
 215         RFI
 216 reenable_mmu:                           /* re-enable mmu so we can */
 217         mfmsr   r10
 218         lwz     r12,_MSR(r1)
 219         xor     r10,r10,r12
 220         andi.   r10,r10,MSR_EE          /* Did EE change? */
 221         beq     1f
 222
 223         /*
 224          * The trace_hardirqs_off will use CALLER_ADDR0 and CALLER_ADDR1.
 225          * If from user mode there is only one stack frame on the stack, and
 226          * accessing CALLER_ADDR1 will cause oops. So we need create a dummy
 227          * stack frame to make trace_hardirqs_off happy.
 228          *
 229          * This is handy because we also need to save a bunch of GPRs,
 230          * r3 can be different from GPR3(r1) at this point, r9 and r11
 231          * contains the old MSR and handler address respectively,
 232          * r4 & r5 can contain page fault arguments that need to be passed
 233          * along as well. r12, CCR, CTR, XER etc... are left clobbered as
 234          * they aren't useful past this point (aren't syscall arguments),
 235          * the rest is restored from the exception frame.
 236          */
 237         stwu    r1,-32(r1)
 238         stw     r9,8(r1)
 239         stw     r11,12(r1)
 240         stw     r3,16(r1)
 241         stw     r4,20(r1)
 242         stw     r5,24(r1)
 243         bl      trace_hardirqs_off
 244         lwz     r5,24(r1)
 245         lwz     r4,20(r1)
 246         lwz     r3,16(r1)
 247         lwz     r11,12(r1)
 248         lwz     r9,8(r1)
 249         addi    r1,r1,32
 250         lwz     r0,GPR0(r1)
 251         lwz     r6,GPR6(r1)
 252         lwz     r7,GPR7(r1)
 253         lwz     r8,GPR8(r1)
 254 1:      mtctr   r11
 255         mtlr    r9
 256         bctr                            /* jump to handler */
 257 #else /* CONFIG_TRACE_IRQFLAGS */
 258         mtspr   SPRN_SRR0,r11
 259         mtspr   SPRN_SRR1,r10
 260         mtlr    r9
 261         SYNC
 262         RFI                             /* jump to handler, enable MMU */
 263 #endif /* CONFIG_TRACE_IRQFLAGS */
 264
 265 #if defined (CONFIG_6xx) || defined(CONFIG_E500)
 266 4:      rlwinm  r12,r12,0,~_TLF_NAPPING
 267         stw     r12,TI_LOCAL_FLAGS(r9)
 268         b       power_save_ppc32_restore
 269
 270 7:      rlwinm  r12,r12,0,~_TLF_SLEEPING
 271         stw     r12,TI_LOCAL_FLAGS(r9)
 272         lwz     r9,_MSR(r11)            /* if sleeping, clear MSR.EE */
 273         rlwinm  r9,r9,0,~MSR_EE
 274         lwz     r12,_LINK(r11)          /* and return to address in LR */
 275         b       fast_exception_return
 276 #endif
 277
 278 /*
 279  * On kernel stack overflow, load up an initial stack pointer
 280  * and call StackOverflow(regs), which should not return.
 281  */
 282 stack_ovf:
 283         /* sometimes we use a statically-allocated stack, which is OK. */
 284         lis     r12,_end@h
 285         ori     r12,r12,_end@l
 286         cmplw   r1,r12
 287         ble     5b                      /* r1 <= &_end is OK */
 288         SAVE_NVGPRS(r11)
 289         addi    r3,r1,STACK_FRAME_OVERHEAD
 290         lis     r1,init_thread_union@ha
 291         addi    r1,r1,init_thread_union@l
 292         addi    r1,r1,THREAD_SIZE-STACK_FRAME_OVERHEAD
 293         lis     r9,StackOverflow@ha
 294         addi    r9,r9,StackOverflow@l
 295         LOAD_MSR_KERNEL(r10,MSR_KERNEL)
 296         FIX_SRR1(r10,r12)
 297         mtspr   SPRN_SRR0,r9
 298         mtspr   SPRN_SRR1,r10
 299         SYNC
 300         RFI
 301
 302 /*
 303  * Handle a system call.
 304  */
 305         .stabs  "arch/powerpc/kernel/",N_SO,0,0,0f
 306         .stabs  "entry_32.S",N_SO,0,0,0f
 307 0:
 308
 309 _GLOBAL(DoSyscall)
 310         stw     r3,ORIG_GPR3(r1)
 311         li      r12,0
 312         stw     r12,RESULT(r1)
 313         lwz     r11,_CCR(r1)    /* Clear SO bit in CR */
 314         rlwinm  r11,r11,0,4,2
 315         stw     r11,_CCR(r1)
 316 #ifdef CONFIG_TRACE_IRQFLAGS
 317         /* Return from syscalls can (and generally will) hard enable
 318          * interrupts. You aren't supposed to call a syscall with
 319          * interrupts disabled in the first place. However, to ensure
 320          * that we get it right vs. lockdep if it happens, we force
 321          * that hard enable here with appropriate tracing if we see
 322          * that we have been called with interrupts off
 323          */
 324         mfmsr   r11
 325         andi.   r12,r11,MSR_EE
 326         bne+    1f
 327         /* We came in with interrupts disabled, we enable them now */
 328         bl      trace_hardirqs_on
 329         mfmsr   r11
 330         lwz     r0,GPR0(r1)
 331         lwz     r3,GPR3(r1)
 332         lwz     r4,GPR4(r1)
 333         ori     r11,r11,MSR_EE
 334         lwz     r5,GPR5(r1)
 335         lwz     r6,GPR6(r1)
 336         lwz     r7,GPR7(r1)
 337         lwz     r8,GPR8(r1)
 338         mtmsr   r11
 339 1:
 340 #endif /* CONFIG_TRACE_IRQFLAGS */
 341         CURRENT_THREAD_INFO(r10, r1)
 342         lwz     r11,TI_FLAGS(r10)
 343         andi.   r11,r11,_TIF_SYSCALL_DOTRACE
 344         bne-    syscall_dotrace
 345 syscall_dotrace_cont:
 346         cmplwi  0,r0,NR_syscalls
 347         lis     r10,sys_call_table@h
 348         ori     r10,r10,sys_call_table@l
 349         slwi    r0,r0,2
 350         bge-    66f
 351
 352         barrier_nospec_asm
 353         /*
 354          * Prevent the load of the handler below (based on the user-passed
 355          * system call number) being speculatively executed until the test
 356          * against NR_syscalls and branch to .66f above has
 357          * committed.
 358          */
 359
 360         lwzx    r10,r10,r0      /* Fetch system call handler [ptr] */
 361         mtlr    r10
 362         addi    r9,r1,STACK_FRAME_OVERHEAD
 363         PPC440EP_ERR42
 364         blrl                    /* Call handler */
 365         .globl  ret_from_syscall
 366 ret_from_syscall:
 367         mr      r6,r3
 368         CURRENT_THREAD_INFO(r12, r1)
 369         /* disable interrupts so current_thread_info()->flags can't change */
 370         LOAD_MSR_KERNEL(r10,MSR_KERNEL) /* doesn't include MSR_EE */
 371         /* Note: We don't bother telling lockdep about it */
 372         SYNC
 373         MTMSRD(r10)
 374         lwz     r9,TI_FLAGS(r12)
 375         li      r8,-MAX_ERRNO
 376         andi.   r0,r9,(_TIF_SYSCALL_DOTRACE|_TIF_SINGLESTEP|_TIF_USER_WORK_MASK|_TIF_PERSYSCALL_MASK)
 377         bne-    syscall_exit_work
 378         cmplw   0,r3,r8
 379         blt+    syscall_exit_cont
 380         lwz     r11,_CCR(r1)                    /* Load CR */
 381         neg     r3,r3
 382         oris    r11,r11,0x1000  /* Set SO bit in CR */
 383         stw     r11,_CCR(r1)
 384 syscall_exit_cont:
 385         lwz     r8,_MSR(r1)
 386 #ifdef CONFIG_TRACE_IRQFLAGS
 387         /* If we are going to return from the syscall with interrupts
 388          * off, we trace that here. It shouldn't happen though but we
 389          * want to catch the bugger if it does right ?
 390          */
 391         andi.   r10,r8,MSR_EE
 392         bne+    1f
 393         stw     r3,GPR3(r1)
 394         bl      trace_hardirqs_off
 395         lwz     r3,GPR3(r1)
 396 1:
 397 #endif /* CONFIG_TRACE_IRQFLAGS */
 398 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 399         /* If the process has its own DBCR0 value, load it up.  The internal
 400            debug mode bit tells us that dbcr0 should be loaded. */
 401         lwz     r0,THREAD+THREAD_DBCR0(r2)
 402         andis.  r10,r0,DBCR0_IDM@h
 403         bnel-   load_dbcr0
 404 #endif
 405 #ifdef CONFIG_44x
 406 BEGIN_MMU_FTR_SECTION
 407         lis     r4,icache_44x_need_flush@ha
 408         lwz     r5,icache_44x_need_flush@l(r4)
 409         cmplwi  cr0,r5,0
 410         bne-    2f
 411 1:
 412 END_MMU_FTR_SECTION_IFCLR(MMU_FTR_TYPE_47x)
 413 #endif /* CONFIG_44x */
 414 BEGIN_FTR_SECTION
 415         lwarx   r7,0,r1
 416 END_FTR_SECTION_IFSET(CPU_FTR_NEED_PAIRED_STWCX)
 417         stwcx.  r0,0,r1                 /* to clear the reservation */
 418 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
 419         andi.   r4,r8,MSR_PR
 420         beq     3f
 421         CURRENT_THREAD_INFO(r4, r1)
 422         ACCOUNT_CPU_USER_EXIT(r4, r5, r7)
 423 3:
 424 #endif
 425         lwz     r4,_LINK(r1)
 426         lwz     r5,_CCR(r1)
 427         mtlr    r4
 428         mtcr    r5
 429         lwz     r7,_NIP(r1)
 430         FIX_SRR1(r8, r0)
 431         lwz     r2,GPR2(r1)
 432         lwz     r1,GPR1(r1)
 433         mtspr   SPRN_SRR0,r7
 434         mtspr   SPRN_SRR1,r8
 435         SYNC
 436         RFI
 437 #ifdef CONFIG_44x
 438 2:      li      r7,0
 439         iccci   r0,r0
 440         stw     r7,icache_44x_need_flush@l(r4)
 441         b       1b
 442 #endif  /* CONFIG_44x */
 443
 444 66:     li      r3,-ENOSYS
 445         b       ret_from_syscall
 446
 447         .globl  ret_from_fork
 448 ret_from_fork:
 449         REST_NVGPRS(r1)
 450         bl      schedule_tail
 451         li      r3,0
 452         b       ret_from_syscall
 453
 454         .globl  ret_from_kernel_thread
 455 ret_from_kernel_thread:
 456         REST_NVGPRS(r1)
 457         bl      schedule_tail
 458         mtlr    r14
 459         mr      r3,r15
 460         PPC440EP_ERR42
 461         blrl
 462         li      r3,0
 463         b       ret_from_syscall
 464
 465 /* Traced system call support */
 466 syscall_dotrace:
 467         SAVE_NVGPRS(r1)
 468         li      r0,0xc00
 469         stw     r0,_TRAP(r1)
 470         addi    r3,r1,STACK_FRAME_OVERHEAD
 471         bl      do_syscall_trace_enter
 472         /*
 473          * Restore argument registers possibly just changed.
 474          * We use the return value of do_syscall_trace_enter
 475          * for call number to look up in the table (r0).
 476          */
 477         mr      r0,r3
 478         lwz     r3,GPR3(r1)
 479         lwz     r4,GPR4(r1)
 480         lwz     r5,GPR5(r1)
 481         lwz     r6,GPR6(r1)
 482         lwz     r7,GPR7(r1)
 483         lwz     r8,GPR8(r1)
 484         REST_NVGPRS(r1)
 485
 486         cmplwi  r0,NR_syscalls
 487         /* Return code is already in r3 thanks to do_syscall_trace_enter() */
 488         bge-    ret_from_syscall
 489         b       syscall_dotrace_cont
 490
 491 syscall_exit_work:
 492         andi.   r0,r9,_TIF_RESTOREALL
 493         beq+    0f
 494         REST_NVGPRS(r1)
 495         b       2f
 496 0:      cmplw   0,r3,r8
 497         blt+    1f
 498         andi.   r0,r9,_TIF_NOERROR
 499         bne-    1f
 500         lwz     r11,_CCR(r1)                    /* Load CR */
 501         neg     r3,r3
 502         oris    r11,r11,0x1000  /* Set SO bit in CR */
 503         stw     r11,_CCR(r1)
 504
 505 1:      stw     r6,RESULT(r1)   /* Save result */
 506         stw     r3,GPR3(r1)     /* Update return value */
 507 2:      andi.   r0,r9,(_TIF_PERSYSCALL_MASK)
 508         beq     4f
 509
 510         /* Clear per-syscall TIF flags if any are set.  */
 511
 512         li      r11,_TIF_PERSYSCALL_MASK
 513         addi    r12,r12,TI_FLAGS
 514 3:      lwarx   r8,0,r12
 515         andc    r8,r8,r11
 516 #ifdef CONFIG_IBM405_ERR77
 517         dcbt    0,r12
 518 #endif
 519         stwcx.  r8,0,r12
 520         bne-    3b
 521         subi    r12,r12,TI_FLAGS
 522
 523 4:      /* Anything which requires enabling interrupts? */
 524         andi.   r0,r9,(_TIF_SYSCALL_DOTRACE|_TIF_SINGLESTEP)
 525         beq     ret_from_except
 526
 527         /* Re-enable interrupts. There is no need to trace that with
 528          * lockdep as we are supposed to have IRQs on at this point
 529          */
 530         ori     r10,r10,MSR_EE
 531         SYNC
 532         MTMSRD(r10)
 533
 534         /* Save NVGPRS if they're not saved already */
 535         lwz     r4,_TRAP(r1)
 536         andi.   r4,r4,1
 537         beq     5f
 538         SAVE_NVGPRS(r1)
 539         li      r4,0xc00
 540         stw     r4,_TRAP(r1)
 541 5:
 542         addi    r3,r1,STACK_FRAME_OVERHEAD
 543         bl      do_syscall_trace_leave
 544         b       ret_from_except_full
 545
 546 /*
 547  * The fork/clone functions need to copy the full register set into
 548  * the child process. Therefore we need to save all the nonvolatile
 549  * registers (r13 - r31) before calling the C code.
 550  */
 551         .globl  ppc_fork
 552 ppc_fork:
 553         SAVE_NVGPRS(r1)
 554         lwz     r0,_TRAP(r1)
 555         rlwinm  r0,r0,0,0,30            /* clear LSB to indicate full */
 556         stw     r0,_TRAP(r1)            /* register set saved */
 557         b       sys_fork
 558
 559         .globl  ppc_vfork
 560 ppc_vfork:
 561         SAVE_NVGPRS(r1)
 562         lwz     r0,_TRAP(r1)
 563         rlwinm  r0,r0,0,0,30            /* clear LSB to indicate full */
 564         stw     r0,_TRAP(r1)            /* register set saved */
 565         b       sys_vfork
 566
 567         .globl  ppc_clone
 568 ppc_clone:
 569         SAVE_NVGPRS(r1)
 570         lwz     r0,_TRAP(r1)
 571         rlwinm  r0,r0,0,0,30            /* clear LSB to indicate full */
 572         stw     r0,_TRAP(r1)            /* register set saved */
 573         b       sys_clone
 574
 575         .globl  ppc_swapcontext
 576 ppc_swapcontext:
 577         SAVE_NVGPRS(r1)
 578         lwz     r0,_TRAP(r1)
 579         rlwinm  r0,r0,0,0,30            /* clear LSB to indicate full */
 580         stw     r0,_TRAP(r1)            /* register set saved */
 581         b       sys_swapcontext
 582
 583 /*
 584  * Top-level page fault handling.
 585  * This is in assembler because if do_page_fault tells us that
 586  * it is a bad kernel page fault, we want to save the non-volatile
 587  * registers before calling bad_page_fault.
 588  */
 589         .globl  handle_page_fault
 590 handle_page_fault:
 591         stw     r4,_DAR(r1)
 592         addi    r3,r1,STACK_FRAME_OVERHEAD
 593         bl      do_page_fault
 594         cmpwi   r3,0
 595         beq+    ret_from_except
 596         SAVE_NVGPRS(r1)
 597         lwz     r0,_TRAP(r1)
 598         clrrwi  r0,r0,1
 599         stw     r0,_TRAP(r1)
 600         mr      r5,r3
 601         addi    r3,r1,STACK_FRAME_OVERHEAD
 602         lwz     r4,_DAR(r1)
 603         bl      bad_page_fault
 604         b       ret_from_except_full
 605
 606 /*
 607  * This routine switches between two different tasks.  The process
 608  * state of one is saved on its kernel stack.  Then the state
 609  * of the other is restored from its kernel stack.  The memory
 610  * management hardware is updated to the second process's state.
 611  * Finally, we can return to the second process.
 612  * On entry, r3 points to the THREAD for the current task, r4
 613  * points to the THREAD for the new task.
 614  *
 615  * This routine is always called with interrupts disabled.
 616  *
 617  * Note: there are two ways to get to the "going out" portion
 618  * of this code; either by coming in via the entry (_switch)
 619  * or via "fork" which must set up an environment equivalent
 620  * to the "_switch" path.  If you change this , you'll have to
 621  * change the fork code also.
 622  *
 623  * The code which creates the new task context is in 'copy_thread'
 624  * in arch/ppc/kernel/process.c
 625  */
 626 _GLOBAL(_switch)
 627         stwu    r1,-INT_FRAME_SIZE(r1)
 628         mflr    r0
 629         stw     r0,INT_FRAME_SIZE+4(r1)
 630         /* r3-r12 are caller saved -- Cort */
 631         SAVE_NVGPRS(r1)
 632         stw     r0,_NIP(r1)     /* Return to switch caller */
 633         mfmsr   r11
 634         li      r0,MSR_FP       /* Disable floating-point */
 635 #ifdef CONFIG_ALTIVEC
 636 BEGIN_FTR_SECTION
 637         oris    r0,r0,MSR_VEC@h /* Disable altivec */
 638         mfspr   r12,SPRN_VRSAVE /* save vrsave register value */
 639         stw     r12,THREAD+THREAD_VRSAVE(r2)
 640 END_FTR_SECTION_IFSET(CPU_FTR_ALTIVEC)
 641 #endif /* CONFIG_ALTIVEC */
 642 #ifdef CONFIG_SPE
 643 BEGIN_FTR_SECTION
 644         oris    r0,r0,MSR_SPE@h  /* Disable SPE */
 645         mfspr   r12,SPRN_SPEFSCR /* save spefscr register value */
 646         stw     r12,THREAD+THREAD_SPEFSCR(r2)
 647 END_FTR_SECTION_IFSET(CPU_FTR_SPE)
 648 #endif /* CONFIG_SPE */
 649         and.    r0,r0,r11       /* FP or altivec or SPE enabled? */
 650         beq+    1f
 651         andc    r11,r11,r0
 652         MTMSRD(r11)
 653         isync
 654 1:      stw     r11,_MSR(r1)
 655         mfcr    r10
 656         stw     r10,_CCR(r1)
 657         stw     r1,KSP(r3)      /* Set old stack pointer */
 658
 659 #ifdef CONFIG_SMP
 660         /* We need a sync somewhere here to make sure that if the
 661          * previous task gets rescheduled on another CPU, it sees all
 662          * stores it has performed on this one.
 663          */
 664         sync
 665 #endif /* CONFIG_SMP */
 666
 667         tophys(r0,r4)
 668         mtspr   SPRN_SPRG_THREAD,r0     /* Update current THREAD phys addr */
 669         lwz     r1,KSP(r4)      /* Load new stack pointer */
 670
 671         /* save the old current 'last' for return value */
 672         mr      r3,r2
 673         addi    r2,r4,-THREAD   /* Update current */
 674
 675 #ifdef CONFIG_ALTIVEC
 676 BEGIN_FTR_SECTION
 677         lwz     r0,THREAD+THREAD_VRSAVE(r2)
 678         mtspr   SPRN_VRSAVE,r0          /* if G4, restore VRSAVE reg */
 679 END_FTR_SECTION_IFSET(CPU_FTR_ALTIVEC)
 680 #endif /* CONFIG_ALTIVEC */
 681 #ifdef CONFIG_SPE
 682 BEGIN_FTR_SECTION
 683         lwz     r0,THREAD+THREAD_SPEFSCR(r2)
 684         mtspr   SPRN_SPEFSCR,r0         /* restore SPEFSCR reg */
 685 END_FTR_SECTION_IFSET(CPU_FTR_SPE)
 686 #endif /* CONFIG_SPE */
 687
 688         lwz     r0,_CCR(r1)
 689         mtcrf   0xFF,r0
 690         /* r3-r12 are destroyed -- Cort */
 691         REST_NVGPRS(r1)
 692
 693         lwz     r4,_NIP(r1)     /* Return to _switch caller in new task */
 694         mtlr    r4
 695         addi    r1,r1,INT_FRAME_SIZE
 696         blr
 697
 698         .globl  fast_exception_return
 699 fast_exception_return:
 700 #if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
 701         andi.   r10,r9,MSR_RI           /* check for recoverable interrupt */
 702         beq     1f                      /* if not, we've got problems */
 703 #endif
 704
 705 2:      REST_4GPRS(3, r11)
 706         lwz     r10,_CCR(r11)
 707         REST_GPR(1, r11)
 708         mtcr    r10
 709         lwz     r10,_LINK(r11)
 710         mtlr    r10
 711         /* Clear the exception_marker on the stack to avoid confusing stacktrace */
 712         li      r10, 0
 713         stw     r10, 8(r11)
 714         REST_GPR(10, r11)
 715         mtspr   SPRN_SRR1,r9
 716         mtspr   SPRN_SRR0,r12
 717         REST_GPR(9, r11)
 718         REST_GPR(12, r11)
 719         lwz     r11,GPR11(r11)
 720         SYNC
 721         RFI
 722
 723 #if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
 724 /* check if the exception happened in a restartable section */
 725 1:      lis     r3,exc_exit_restart_end@ha
 726         addi    r3,r3,exc_exit_restart_end@l
 727         cmplw   r12,r3
 728         bge     3f
 729         lis     r4,exc_exit_restart@ha
 730         addi    r4,r4,exc_exit_restart@l
 731         cmplw   r12,r4
 732         blt     3f
 733         lis     r3,fee_restarts@ha
 734         tophys(r3,r3)
 735         lwz     r5,fee_restarts@l(r3)
 736         addi    r5,r5,1
 737         stw     r5,fee_restarts@l(r3)
 738         mr      r12,r4          /* restart at exc_exit_restart */
 739         b       2b
 740
 741         .section .bss
 742         .align  2
 743 fee_restarts:
 744         .space  4
 745         .previous
 746
 747 /* aargh, a nonrecoverable interrupt, panic */
 748 /* aargh, we don't know which trap this is */
 749 /* but the 601 doesn't implement the RI bit, so assume it's OK */
 750 3:
 751 BEGIN_FTR_SECTION
 752         b       2b
 753 END_FTR_SECTION_IFSET(CPU_FTR_601)
 754         li      r10,-1
 755         stw     r10,_TRAP(r11)
 756         addi    r3,r1,STACK_FRAME_OVERHEAD
 757         lis     r10,MSR_KERNEL@h
 758         ori     r10,r10,MSR_KERNEL@l
 759         bl      transfer_to_handler_full
 760         .long   nonrecoverable_exception
 761         .long   ret_from_except
 762 #endif
 763
 764         .globl  ret_from_except_full
 765 ret_from_except_full:
 766         REST_NVGPRS(r1)
 767         /* fall through */
 768
 769         .globl  ret_from_except
 770 ret_from_except:
 771         /* Hard-disable interrupts so that current_thread_info()->flags
 772          * can't change between when we test it and when we return
 773          * from the interrupt. */
 774         /* Note: We don't bother telling lockdep about it */
 775         LOAD_MSR_KERNEL(r10,MSR_KERNEL)
 776         SYNC                    /* Some chip revs have problems here... */
 777         MTMSRD(r10)             /* disable interrupts */
 778
 779         lwz     r3,_MSR(r1)     /* Returning to user mode? */
 780         andi.   r0,r3,MSR_PR
 781         beq     resume_kernel
 782
 783 user_exc_return:                /* r10 contains MSR_KERNEL here */
 784         /* Check current_thread_info()->flags */
 785         CURRENT_THREAD_INFO(r9, r1)
 786         lwz     r9,TI_FLAGS(r9)
 787         andi.   r0,r9,_TIF_USER_WORK_MASK
 788         bne     do_work
 789
 790 restore_user:
 791 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 792         /* Check whether this process has its own DBCR0 value.  The internal
 793            debug mode bit tells us that dbcr0 should be loaded. */
 794         lwz     r0,THREAD+THREAD_DBCR0(r2)
 795         andis.  r10,r0,DBCR0_IDM@h
 796         bnel-   load_dbcr0
 797 #endif
 798 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
 799         CURRENT_THREAD_INFO(r9, r1)
 800         ACCOUNT_CPU_USER_EXIT(r9, r10, r11)
 801 #endif
 802
 803         b       restore
 804
 805 /* N.B. the only way to get here is from the beq following ret_from_except. */
 806 resume_kernel:
 807         /* check current_thread_info, _TIF_EMULATE_STACK_STORE */
 808         CURRENT_THREAD_INFO(r9, r1)
 809         lwz     r8,TI_FLAGS(r9)
 810         andis.  r0,r8,_TIF_EMULATE_STACK_STORE@h
 811         beq+    1f
 812
 813         addi    r8,r1,INT_FRAME_SIZE    /* Get the kprobed function entry */
 814
 815         lwz     r3,GPR1(r1)
 816         subi    r3,r3,INT_FRAME_SIZE    /* dst: Allocate a trampoline exception frame */
 817         mr      r4,r1                   /* src:  current exception frame */
 818         mr      r1,r3                   /* Reroute the trampoline frame to r1 */
 819
 820         /* Copy from the original to the trampoline. */
 821         li      r5,INT_FRAME_SIZE/4     /* size: INT_FRAME_SIZE */
 822         li      r6,0                    /* start offset: 0 */
 823         mtctr   r5
 824 2:      lwzx    r0,r6,r4
 825         stwx    r0,r6,r3
 826         addi    r6,r6,4
 827         bdnz    2b
 828
 829         /* Do real store operation to complete stwu */
 830         lwz     r5,GPR1(r1)
 831         stw     r8,0(r5)
 832
 833         /* Clear _TIF_EMULATE_STACK_STORE flag */
 834         lis     r11,_TIF_EMULATE_STACK_STORE@h
 835         addi    r5,r9,TI_FLAGS
 836 0:      lwarx   r8,0,r5
 837         andc    r8,r8,r11
 838 #ifdef CONFIG_IBM405_ERR77
 839         dcbt    0,r5
 840 #endif
 841         stwcx.  r8,0,r5
 842         bne-    0b
 843 1:
 844
 845 #ifdef CONFIG_PREEMPT
 846         /* check current_thread_info->preempt_count */
 847         lwz     r0,TI_PREEMPT(r9)
 848         cmpwi   0,r0,0          /* if non-zero, just restore regs and return */
 849         bne     restore
 850         andi.   r8,r8,_TIF_NEED_RESCHED
 851         beq+    restore
 852         lwz     r3,_MSR(r1)
 853         andi.   r0,r3,MSR_EE    /* interrupts off? */
 854         beq     restore         /* don't schedule if so */
 855 #ifdef CONFIG_TRACE_IRQFLAGS
 856         /* Lockdep thinks irqs are enabled, we need to call
 857          * preempt_schedule_irq with IRQs off, so we inform lockdep
 858          * now that we -did- turn them off already
 859          */
 860         bl      trace_hardirqs_off
 861 #endif
 862 1:      bl      preempt_schedule_irq
 863         CURRENT_THREAD_INFO(r9, r1)
 864         lwz     r3,TI_FLAGS(r9)
 865         andi.   r0,r3,_TIF_NEED_RESCHED
 866         bne-    1b
 867 #ifdef CONFIG_TRACE_IRQFLAGS
 868         /* And now, to properly rebalance the above, we tell lockdep they
 869          * are being turned back on, which will happen when we return
 870          */
 871         bl      trace_hardirqs_on
 872 #endif
 873 #endif /* CONFIG_PREEMPT */
 874
 875         /* interrupts are hard-disabled at this point */
 876 restore:
 877 #ifdef CONFIG_44x
 878 BEGIN_MMU_FTR_SECTION
 879         b       1f
 880 END_MMU_FTR_SECTION_IFSET(MMU_FTR_TYPE_47x)
 881         lis     r4,icache_44x_need_flush@ha
 882         lwz     r5,icache_44x_need_flush@l(r4)
 883         cmplwi  cr0,r5,0
 884         beq+    1f
 885         li      r6,0
 886         iccci   r0,r0
 887         stw     r6,icache_44x_need_flush@l(r4)
 888 1:
 889 #endif  /* CONFIG_44x */
 890
 891         lwz     r9,_MSR(r1)
 892 #ifdef CONFIG_TRACE_IRQFLAGS
 893         /* Lockdep doesn't know about the fact that IRQs are temporarily turned
 894          * off in this assembly code while peeking at TI_FLAGS() and such. However
 895          * we need to inform it if the exception turned interrupts off, and we
 896          * are about to trun them back on.
 897          *
 898          * The problem here sadly is that we don't know whether the exceptions was
 899          * one that turned interrupts off or not. So we always tell lockdep about
 900          * turning them on here when we go back to wherever we came from with EE
 901          * on, even if that may meen some redudant calls being tracked. Maybe later
 902          * we could encode what the exception did somewhere or test the exception
 903          * type in the pt_regs but that sounds overkill
 904          */
 905         andi.   r10,r9,MSR_EE
 906         beq     1f
 907         /*
 908          * Since the ftrace irqsoff latency trace checks CALLER_ADDR1,
 909          * which is the stack frame here, we need to force a stack frame
 910          * in case we came from user space.
 911          */
 912         stwu    r1,-32(r1)
 913         mflr    r0
 914         stw     r0,4(r1)
 915         stwu    r1,-32(r1)
 916         bl      trace_hardirqs_on
 917         lwz     r1,0(r1)
 918         lwz     r1,0(r1)
 919         lwz     r9,_MSR(r1)
 920 1:
 921 #endif /* CONFIG_TRACE_IRQFLAGS */
 922
 923         lwz     r0,GPR0(r1)
 924         lwz     r2,GPR2(r1)
 925         REST_4GPRS(3, r1)
 926         REST_2GPRS(7, r1)
 927
 928         lwz     r10,_XER(r1)
 929         lwz     r11,_CTR(r1)
 930         mtspr   SPRN_XER,r10
 931         mtctr   r11
 932
 933         PPC405_ERR77(0,r1)
 934 BEGIN_FTR_SECTION
 935         lwarx   r11,0,r1
 936 END_FTR_SECTION_IFSET(CPU_FTR_NEED_PAIRED_STWCX)
 937         stwcx.  r0,0,r1                 /* to clear the reservation */
 938
 939 #if !(defined(CONFIG_4xx) || defined(CONFIG_BOOKE))
 940         andi.   r10,r9,MSR_RI           /* check if this exception occurred */
 941         beql    nonrecoverable          /* at a bad place (MSR:RI = 0) */
 942
 943         lwz     r10,_CCR(r1)
 944         lwz     r11,_LINK(r1)
 945         mtcrf   0xFF,r10
 946         mtlr    r11
 947
 948         /* Clear the exception_marker on the stack to avoid confusing stacktrace */
 949         li      r10, 0
 950         stw     r10, 8(r1)
 951         /*
 952          * Once we put values in SRR0 and SRR1, we are in a state
 953          * where exceptions are not recoverable, since taking an
 954          * exception will trash SRR0 and SRR1.  Therefore we clear the
 955          * MSR:RI bit to indicate this.  If we do take an exception,
 956          * we can't return to the point of the exception but we
 957          * can restart the exception exit path at the label
 958          * exc_exit_restart below.  -- paulus
 959          */
 960         LOAD_MSR_KERNEL(r10,MSR_KERNEL & ~MSR_RI)
 961         SYNC
 962         MTMSRD(r10)             /* clear the RI bit */
 963         .globl exc_exit_restart
 964 exc_exit_restart:
 965         lwz     r12,_NIP(r1)
 966         FIX_SRR1(r9,r10)
 967         mtspr   SPRN_SRR0,r12
 968         mtspr   SPRN_SRR1,r9
 969         REST_4GPRS(9, r1)
 970         lwz     r1,GPR1(r1)
 971         .globl exc_exit_restart_end
 972 exc_exit_restart_end:
 973         SYNC
 974         RFI
 975
 976 #else /* !(CONFIG_4xx || CONFIG_BOOKE) */
 977         /*
 978          * This is a bit different on 4xx/Book-E because it doesn't have
 979          * the RI bit in the MSR.
 980          * The TLB miss handler checks if we have interrupted
 981          * the exception exit path and restarts it if so
 982          * (well maybe one day it will... :).
 983          */
 984         lwz     r11,_LINK(r1)
 985         mtlr    r11
 986         lwz     r10,_CCR(r1)
 987         mtcrf   0xff,r10
 988         /* Clear the exception_marker on the stack to avoid confusing stacktrace */
 989         li      r10, 0
 990         stw     r10, 8(r1)
 991         REST_2GPRS(9, r1)
 992         .globl exc_exit_restart
 993 exc_exit_restart:
 994         lwz     r11,_NIP(r1)
 995         lwz     r12,_MSR(r1)
 996 exc_exit_start:
 997         mtspr   SPRN_SRR0,r11
 998         mtspr   SPRN_SRR1,r12
 999         REST_2GPRS(11, r1)
1000         lwz     r1,GPR1(r1)
1001         .globl exc_exit_restart_end
1002 exc_exit_restart_end:
1003         PPC405_ERR77_SYNC
1004         rfi
1005         b       .                       /* prevent prefetch past rfi */
1006
1007 /*
1008  * Returning from a critical interrupt in user mode doesn't need
1009  * to be any different from a normal exception.  For a critical
1010  * interrupt in the kernel, we just return (without checking for
1011  * preemption) since the interrupt may have happened at some crucial
1012  * place (e.g. inside the TLB miss handler), and because we will be
1013  * running with r1 pointing into critical_stack, not the current
1014  * process's kernel stack (and therefore current_thread_info() will
1015  * give the wrong answer).
1016  * We have to restore various SPRs that may have been in use at the
1017  * time of the critical interrupt.
1018  *
1019  */
1020 #ifdef CONFIG_40x
1021 #define PPC_40x_TURN_OFF_MSR_DR                                             \
1022         /* avoid any possible TLB misses here by turning off MSR.DR, we     \
1023          * assume the instructions here are mapped by a pinned TLB entry */ \
1024         li      r10,MSR_IR;                                                 \
1025         mtmsr   r10;                                                        \
1026         isync;                                                              \
1027         tophys(r1, r1);
1028 #else
1029 #define PPC_40x_TURN_OFF_MSR_DR
1030 #endif
1031
1032 #define RET_FROM_EXC_LEVEL(exc_lvl_srr0, exc_lvl_srr1, exc_lvl_rfi)     \
1033         REST_NVGPRS(r1);                                                \
1034         lwz     r3,_MSR(r1);                                            \
1035         andi.   r3,r3,MSR_PR;                                           \
1036         LOAD_MSR_KERNEL(r10,MSR_KERNEL);                                \
1037         bne     user_exc_return;                                        \
1038         lwz     r0,GPR0(r1);                                            \
1039         lwz     r2,GPR2(r1);                                            \
1040         REST_4GPRS(3, r1);                                              \
1041         REST_2GPRS(7, r1);                                              \
1042         lwz     r10,_XER(r1);                                           \
1043         lwz     r11,_CTR(r1);                                           \
1044         mtspr   SPRN_XER,r10;                                           \
1045         mtctr   r11;                                                    \
1046         PPC405_ERR77(0,r1);                                             \
1047         stwcx.  r0,0,r1;                /* to clear the reservation */  \
1048         lwz     r11,_LINK(r1);                                          \
1049         mtlr    r11;                                                    \
1050         lwz     r10,_CCR(r1);                                           \
1051         mtcrf   0xff,r10;                                               \
1052         PPC_40x_TURN_OFF_MSR_DR;                                        \
1053         lwz     r9,_DEAR(r1);                                           \
1054         lwz     r10,_ESR(r1);                                           \
1055         mtspr   SPRN_DEAR,r9;                                           \
1056         mtspr   SPRN_ESR,r10;                                           \
1057         lwz     r11,_NIP(r1);                                           \
1058         lwz     r12,_MSR(r1);                                           \
1059         mtspr   exc_lvl_srr0,r11;                                       \
1060         mtspr   exc_lvl_srr1,r12;                                       \
1061         lwz     r9,GPR9(r1);                                            \
1062         lwz     r12,GPR12(r1);                                          \
1063         lwz     r10,GPR10(r1);                                          \
1064         lwz     r11,GPR11(r1);                                          \
1065         lwz     r1,GPR1(r1);                                            \
1066         PPC405_ERR77_SYNC;                                              \
1067         exc_lvl_rfi;                                                    \
1068         b       .;              /* prevent prefetch past exc_lvl_rfi */
1069
1070 #define RESTORE_xSRR(exc_lvl_srr0, exc_lvl_srr1)                        \
1071         lwz     r9,_##exc_lvl_srr0(r1);                                 \
1072         lwz     r10,_##exc_lvl_srr1(r1);                                \
1073         mtspr   SPRN_##exc_lvl_srr0,r9;                                 \
1074         mtspr   SPRN_##exc_lvl_srr1,r10;
1075
1076 #if defined(CONFIG_PPC_BOOK3E_MMU)
1077 #ifdef CONFIG_PHYS_64BIT
1078 #define RESTORE_MAS7                                                    \
1079         lwz     r11,MAS7(r1);                                           \
1080         mtspr   SPRN_MAS7,r11;
1081 #else
1082 #define RESTORE_MAS7
1083 #endif /* CONFIG_PHYS_64BIT */
1084 #define RESTORE_MMU_REGS                                                \
1085         lwz     r9,MAS0(r1);                                            \
1086         lwz     r10,MAS1(r1);                                           \
1087         lwz     r11,MAS2(r1);                                           \
1088         mtspr   SPRN_MAS0,r9;                                           \
1089         lwz     r9,MAS3(r1);                                            \
1090         mtspr   SPRN_MAS1,r10;                                          \
1091         lwz     r10,MAS6(r1);                                           \
1092         mtspr   SPRN_MAS2,r11;                                          \
1093         mtspr   SPRN_MAS3,r9;                                           \
1094         mtspr   SPRN_MAS6,r10;                                          \
1095         RESTORE_MAS7;
1096 #elif defined(CONFIG_44x)
1097 #define RESTORE_MMU_REGS                                                \
1098         lwz     r9,MMUCR(r1);                                           \
1099         mtspr   SPRN_MMUCR,r9;
1100 #else
1101 #define RESTORE_MMU_REGS
1102 #endif
1103
1104 #ifdef CONFIG_40x
1105         .globl  ret_from_crit_exc
1106 ret_from_crit_exc:
1107         mfspr   r9,SPRN_SPRG_THREAD
1108         lis     r10,saved_ksp_limit@ha;
1109         lwz     r10,saved_ksp_limit@l(r10);
1110         tovirt(r9,r9);
1111         stw     r10,KSP_LIMIT(r9)
1112         lis     r9,crit_srr0@ha;
1113         lwz     r9,crit_srr0@l(r9);
1114         lis     r10,crit_srr1@ha;
1115         lwz     r10,crit_srr1@l(r10);
1116         mtspr   SPRN_SRR0,r9;
1117         mtspr   SPRN_SRR1,r10;
1118         RET_FROM_EXC_LEVEL(SPRN_CSRR0, SPRN_CSRR1, PPC_RFCI)
1119 #endif /* CONFIG_40x */
1120
1121 #ifdef CONFIG_BOOKE
1122         .globl  ret_from_crit_exc
1123 ret_from_crit_exc:
1124         mfspr   r9,SPRN_SPRG_THREAD
1125         lwz     r10,SAVED_KSP_LIMIT(r1)
1126         stw     r10,KSP_LIMIT(r9)
1127         RESTORE_xSRR(SRR0,SRR1);
1128         RESTORE_MMU_REGS;
1129         RET_FROM_EXC_LEVEL(SPRN_CSRR0, SPRN_CSRR1, PPC_RFCI)
1130
1131         .globl  ret_from_debug_exc
1132 ret_from_debug_exc:
1133         mfspr   r9,SPRN_SPRG_THREAD
1134         lwz     r10,SAVED_KSP_LIMIT(r1)
1135         stw     r10,KSP_LIMIT(r9)
1136         lwz     r9,THREAD_INFO-THREAD(r9)
1137         CURRENT_THREAD_INFO(r10, r1)
1138         lwz     r10,TI_PREEMPT(r10)
1139         stw     r10,TI_PREEMPT(r9)
1140         RESTORE_xSRR(SRR0,SRR1);
1141         RESTORE_xSRR(CSRR0,CSRR1);
1142         RESTORE_MMU_REGS;
1143         RET_FROM_EXC_LEVEL(SPRN_DSRR0, SPRN_DSRR1, PPC_RFDI)
1144
1145         .globl  ret_from_mcheck_exc
1146 ret_from_mcheck_exc:
1147         mfspr   r9,SPRN_SPRG_THREAD
1148         lwz     r10,SAVED_KSP_LIMIT(r1)
1149         stw     r10,KSP_LIMIT(r9)
1150         RESTORE_xSRR(SRR0,SRR1);
1151         RESTORE_xSRR(CSRR0,CSRR1);
1152         RESTORE_xSRR(DSRR0,DSRR1);
1153         RESTORE_MMU_REGS;
1154         RET_FROM_EXC_LEVEL(SPRN_MCSRR0, SPRN_MCSRR1, PPC_RFMCI)
1155 #endif /* CONFIG_BOOKE */
1156
1157 /*
1158  * Load the DBCR0 value for a task that is being ptraced,
1159  * having first saved away the global DBCR0.  Note that r0
1160  * has the dbcr0 value to set upon entry to this.
1161  */
1162 load_dbcr0:
1163         mfmsr   r10             /* first disable debug exceptions */
1164         rlwinm  r10,r10,0,~MSR_DE
1165         mtmsr   r10
1166         isync
1167         mfspr   r10,SPRN_DBCR0
1168         lis     r11,global_dbcr0@ha
1169         addi    r11,r11,global_dbcr0@l
1170 #ifdef CONFIG_SMP
1171         CURRENT_THREAD_INFO(r9, r1)
1172         lwz     r9,TI_CPU(r9)
1173         slwi    r9,r9,3
1174         add     r11,r11,r9
1175 #endif
1176         stw     r10,0(r11)
1177         mtspr   SPRN_DBCR0,r0
1178         lwz     r10,4(r11)
1179         addi    r10,r10,1
1180         stw     r10,4(r11)
1181         li      r11,-1
1182         mtspr   SPRN_DBSR,r11   /* clear all pending debug events */
1183         blr
1184
1185         .section .bss
1186         .align  4
1187 global_dbcr0:
1188         .space  8*NR_CPUS
1189         .previous
1190 #endif /* !(CONFIG_4xx || CONFIG_BOOKE) */
1191
1192 do_work:                        /* r10 contains MSR_KERNEL here */
1193         andi.   r0,r9,_TIF_NEED_RESCHED
1194         beq     do_user_signal
1195
1196 do_resched:                     /* r10 contains MSR_KERNEL here */
1197         /* Note: We don't need to inform lockdep that we are enabling
1198          * interrupts here. As far as it knows, they are already enabled
1199          */
1200         ori     r10,r10,MSR_EE
1201         SYNC
1202         MTMSRD(r10)             /* hard-enable interrupts */
1203         bl      schedule
1204 recheck:
1205         /* Note: And we don't tell it we are disabling them again
1206          * neither. Those disable/enable cycles used to peek at
1207          * TI_FLAGS aren't advertised.
1208          */
1209         LOAD_MSR_KERNEL(r10,MSR_KERNEL)
1210         SYNC
1211         MTMSRD(r10)             /* disable interrupts */
1212         CURRENT_THREAD_INFO(r9, r1)
1213         lwz     r9,TI_FLAGS(r9)
1214         andi.   r0,r9,_TIF_NEED_RESCHED
1215         bne-    do_resched
1216         andi.   r0,r9,_TIF_USER_WORK_MASK
1217         beq     restore_user
1218 do_user_signal:                 /* r10 contains MSR_KERNEL here */
1219         ori     r10,r10,MSR_EE
1220         SYNC
1221         MTMSRD(r10)             /* hard-enable interrupts */
1222         /* save r13-r31 in the exception frame, if not already done */
1223         lwz     r3,_TRAP(r1)
1224         andi.   r0,r3,1
1225         beq     2f
1226         SAVE_NVGPRS(r1)
1227         rlwinm  r3,r3,0,0,30
1228         stw     r3,_TRAP(r1)
1229 2:      addi    r3,r1,STACK_FRAME_OVERHEAD
1230         mr      r4,r9
1231         bl      do_notify_resume
1232         REST_NVGPRS(r1)
1233         b       recheck
1234
1235 /*
1236  * We come here when we are at the end of handling an exception
1237  * that occurred at a place where taking an exception will lose
1238  * state information, such as the contents of SRR0 and SRR1.
1239  */
1240 nonrecoverable:
1241         lis     r10,exc_exit_restart_end@ha
1242         addi    r10,r10,exc_exit_restart_end@l
1243         cmplw   r12,r10
1244         bge     3f
1245         lis     r11,exc_exit_restart@ha
1246         addi    r11,r11,exc_exit_restart@l
1247         cmplw   r12,r11
1248         blt     3f
1249         lis     r10,ee_restarts@ha
1250         lwz     r12,ee_restarts@l(r10)
1251         addi    r12,r12,1
1252         stw     r12,ee_restarts@l(r10)
1253         mr      r12,r11         /* restart at exc_exit_restart */
1254         blr
1255 3:      /* OK, we can't recover, kill this process */
1256         /* but the 601 doesn't implement the RI bit, so assume it's OK */
1257 BEGIN_FTR_SECTION
1258         blr
1259 END_FTR_SECTION_IFSET(CPU_FTR_601)
1260         lwz     r3,_TRAP(r1)
1261         andi.   r0,r3,1
1262         beq     4f
1263         SAVE_NVGPRS(r1)
1264         rlwinm  r3,r3,0,0,30
1265         stw     r3,_TRAP(r1)
1266 4:      addi    r3,r1,STACK_FRAME_OVERHEAD
1267         bl      nonrecoverable_exception
1268         /* shouldn't return */
1269         b       4b
1270
1271         .section .bss
1272         .align  2
1273 ee_restarts:
1274         .space  4
1275         .previous
1276
1277 /*
1278  * PROM code for specific machines follows.  Put it
1279  * here so it's easy to add arch-specific sections later.
1280  * -- Cort
1281  */
1282 #ifdef CONFIG_PPC_RTAS
1283 /*
1284  * On CHRP, the Run-Time Abstraction Services (RTAS) have to be
1285  * called with the MMU off.
1286  */
1287 _GLOBAL(enter_rtas)
1288         stwu    r1,-INT_FRAME_SIZE(r1)
1289         mflr    r0
1290         stw     r0,INT_FRAME_SIZE+4(r1)
1291         LOAD_REG_ADDR(r4, rtas)
1292         lis     r6,1f@ha        /* physical return address for rtas */
1293         addi    r6,r6,1f@l
1294         tophys(r6,r6)
1295         tophys(r7,r1)
1296         lwz     r8,RTASENTRY(r4)
1297         lwz     r4,RTASBASE(r4)
1298         mfmsr   r9
1299         stw     r9,8(r1)
1300         LOAD_MSR_KERNEL(r0,MSR_KERNEL)
1301         SYNC                    /* disable interrupts so SRR0/1 */
1302         MTMSRD(r0)              /* don't get trashed */
1303         li      r9,MSR_KERNEL & ~(MSR_IR|MSR_DR)
1304         mtlr    r6
1305         mtspr   SPRN_SPRG_RTAS,r7
1306         mtspr   SPRN_SRR0,r8
1307         mtspr   SPRN_SRR1,r9
1308         RFI
1309 1:      tophys(r9,r1)
1310         lwz     r8,INT_FRAME_SIZE+4(r9) /* get return address */
1311         lwz     r9,8(r9)        /* original msr value */
1312         FIX_SRR1(r9,r0)
1313         addi    r1,r1,INT_FRAME_SIZE
1314         li      r0,0
1315         mtspr   SPRN_SPRG_RTAS,r0
1316         mtspr   SPRN_SRR0,r8
1317         mtspr   SPRN_SRR1,r9
1318         RFI                     /* return to caller */
1319
1320         .globl  machine_check_in_rtas
1321 machine_check_in_rtas:
1322         twi     31,0,0
1323         /* XXX load up BATs and panic */
1324
1325 #endif /* CONFIG_PPC_RTAS */
1326
1327 #ifdef CONFIG_FUNCTION_TRACER
1328 #ifdef CONFIG_DYNAMIC_FTRACE
1329 _GLOBAL(mcount)
1330 _GLOBAL(_mcount)
1331         /*
1332          * It is required that _mcount on PPC32 must preserve the
1333          * link register. But we have r0 to play with. We use r0
1334          * to push the return address back to the caller of mcount
1335          * into the ctr register, restore the link register and
1336          * then jump back using the ctr register.
1337          */
1338         mflr    r0
1339         mtctr   r0
1340         lwz     r0, 4(r1)
1341         mtlr    r0
1342         bctr
1343
1344 _GLOBAL(ftrace_caller)
1345         MCOUNT_SAVE_FRAME
1346         /* r3 ends up with link register */
1347         subi    r3, r3, MCOUNT_INSN_SIZE
1348 .globl ftrace_call
1349 ftrace_call:
1350         bl      ftrace_stub
1351         nop
1352 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
1353 .globl ftrace_graph_call
1354 ftrace_graph_call:
1355         b       ftrace_graph_stub
1356 _GLOBAL(ftrace_graph_stub)
1357 #endif
1358         MCOUNT_RESTORE_FRAME
1359         /* old link register ends up in ctr reg */
1360         bctr
1361 #else
1362 _GLOBAL(mcount)
1363 _GLOBAL(_mcount)
1364
1365         MCOUNT_SAVE_FRAME
1366
1367         subi    r3, r3, MCOUNT_INSN_SIZE
1368         LOAD_REG_ADDR(r5, ftrace_trace_function)
1369         lwz     r5,0(r5)
1370
1371         mtctr   r5
1372         bctrl
1373         nop
1374
1375 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
1376         b       ftrace_graph_caller
1377 #endif
1378         MCOUNT_RESTORE_FRAME
1379         bctr
1380 #endif
1381 EXPORT_SYMBOL(_mcount)
1382
1383 _GLOBAL(ftrace_stub)
1384         blr
1385
1386 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
1387 _GLOBAL(ftrace_graph_caller)
1388         /* load r4 with local address */
1389         lwz     r4, 44(r1)
1390         subi    r4, r4, MCOUNT_INSN_SIZE
1391
1392         /* Grab the LR out of the caller stack frame */
1393         lwz     r3,52(r1)
1394
1395         bl      prepare_ftrace_return
1396         nop
1397
1398         /*
1399          * prepare_ftrace_return gives us the address we divert to.
1400          * Change the LR in the callers stack frame to this.
1401          */
1402         stw     r3,52(r1)
1403
1404         MCOUNT_RESTORE_FRAME
1405         /* old link register ends up in ctr reg */
1406         bctr
1407
1408 _GLOBAL(return_to_handler)
1409         /* need to save return values */
1410         stwu    r1, -32(r1)
1411         stw     r3, 20(r1)
1412         stw     r4, 16(r1)
1413         stw     r31, 12(r1)
1414         mr      r31, r1
1415
1416         bl      ftrace_return_to_handler
1417         nop
1418
1419         /* return value has real return address */
1420         mtlr    r3
1421
1422         lwz     r3, 20(r1)
1423         lwz     r4, 16(r1)
1424         lwz     r31,12(r1)
1425         lwz     r1, 0(r1)
1426
1427         /* Jump back to real return address */
1428         blr
1429 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
1430
1431 #endif /* CONFIG_FUNCTION_TRACER */