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