arch/parisc/kernel/entry.S

   1 /*
   2  * Linux/PA-RISC Project (http://www.parisc-linux.org/)
   3  *
   4  * kernel entry points (interruptions, system call wrappers)
   5  *  Copyright (C) 1999,2000 Philipp Rumpf
   6  *  Copyright (C) 1999 SuSE GmbH Nuernberg
   7  *  Copyright (C) 2000 Hewlett-Packard (John Marvin)
   8  *  Copyright (C) 1999 Hewlett-Packard (Frank Rowand)
   9  *
  10  *    This program is free software; you can redistribute it and/or modify
  11  *    it under the terms of the GNU General Public License as published by
  12  *    the Free Software Foundation; either version 2, or (at your option)
  13  *    any later version.
  14  *
  15  *    This program is distributed in the hope that it will be useful,
  16  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *    GNU General Public License for more details.
  19  *
  20  *    You should have received a copy of the GNU General Public License
  21  *    along with this program; if not, write to the Free Software
  22  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #include <linux/config.h>
  26 #include <asm/offsets.h>
  27
  28 /* we have the following possibilities to act on an interruption:
  29  *  - handle in assembly and use shadowed registers only
  30  *  - save registers to kernel stack and handle in assembly or C */
  31
  32
  33 #include <asm/assembly.h>       /* for LDREG/STREG defines */
  34 #include <asm/pgtable.h>
  35 #include <asm/psw.h>
  36 #include <asm/signal.h>
  37 #include <asm/unistd.h>
  38 #include <asm/thread_info.h>
  39
  40 #ifdef __LP64__
  41 #define CMPIB           cmpib,*
  42 #define CMPB            cmpb,*
  43 #define COND(x)         *x
  44
  45         .level 2.0w
  46 #else
  47 #define CMPIB           cmpib,
  48 #define CMPB            cmpb,
  49 #define COND(x)         x
  50
  51         .level 2.0
  52 #endif
  53
  54         .import         pa_dbit_lock,data
  55
  56         /* space_to_prot macro creates a prot id from a space id */
  57
  58 #if (SPACEID_SHIFT) == 0
  59         .macro  space_to_prot spc prot
  60         depd,z  \spc,62,31,\prot
  61         .endm
  62 #else
  63         .macro  space_to_prot spc prot
  64         extrd,u \spc,(64 - (SPACEID_SHIFT)),32,\prot
  65         .endm
  66 #endif
  67
  68         /* Switch to virtual mapping, trashing only %r1 */
  69         .macro  virt_map
  70         rsm     PSW_SM_Q,%r0
  71         tovirt_r1 %r29
  72         mfsp    %sr7, %r1
  73         or,=    %r0,%r1,%r0 /* Only save sr7 in sr3 if sr7 != 0 */
  74         mtsp    %r1, %sr3
  75         mtsp    %r0, %sr4
  76         mtsp    %r0, %sr5
  77         mtsp    %r0, %sr6
  78         mtsp    %r0, %sr7
  79         ldil    L%KERNEL_PSW, %r1
  80         ldo     R%KERNEL_PSW(%r1), %r1
  81         mtctl   %r1, %cr22
  82         mtctl   %r0, %cr17      /* Clear IIASQ tail */
  83         mtctl   %r0, %cr17      /* Clear IIASQ head */
  84         ldil    L%4f, %r1
  85         ldo     R%4f(%r1), %r1
  86         mtctl   %r1, %cr18      /* Set IIAOQ tail */
  87         ldo     4(%r1), %r1
  88         mtctl   %r1, %cr18      /* Set IIAOQ head */
  89         rfir
  90         nop
  91 4:
  92         .endm
  93
  94         /*
  95          * The "get_stack" macros are responsible for determining the
  96          * kernel stack value.
  97          *
  98          * For Faults:
  99          *      If sr7 == 0
 100          *          Already using a kernel stack, so call the
 101          *          get_stack_use_r30 macro to push a pt_regs structure
 102          *          on the stack, and store registers there.
 103          *      else
 104          *          Need to set up a kernel stack, so call the
 105          *          get_stack_use_cr30 macro to set up a pointer
 106          *          to the pt_regs structure contained within the
 107          *          task pointer pointed to by cr30. Set the stack
 108          *          pointer to point to the end of the task structure.
 109          *
 110          * For Interrupts:
 111          *      If sr7 == 0
 112          *          Already using a kernel stack, check to see if r30
 113          *          is already pointing to the per processor interrupt
 114          *          stack. If it is, call the get_stack_use_r30 macro
 115          *          to push a pt_regs structure on the stack, and store
 116          *          registers there. Otherwise, call get_stack_use_cr31
 117          *          to get a pointer to the base of the interrupt stack
 118          *          and push a pt_regs structure on that stack.
 119          *      else
 120          *          Need to set up a kernel stack, so call the
 121          *          get_stack_use_cr30 macro to set up a pointer
 122          *          to the pt_regs structure contained within the
 123          *          task pointer pointed to by cr30. Set the stack
 124          *          pointer to point to the end of the task structure.
 125          *          N.B: We don't use the interrupt stack for the
 126          *          first interrupt from userland, because signals/
 127          *          resched's are processed when returning to userland,
 128          *          and we can sleep in those cases.
 129          *
 130          * Note that we use shadowed registers for temps until
 131          * we can save %r26 and %r29. %r26 is used to preserve
 132          * %r8 (a shadowed register) which temporarily contained
 133          * either the fault type ("code") or the eirr. We need
 134          * to use a non-shadowed register to carry the value over
 135          * the rfir in virt_map. We use %r26 since this value winds
 136          * up being passed as the argument to either do_cpu_irq_mask
 137          * or handle_interruption. %r29 is used to hold a pointer
 138          * the register save area, and once again, it needs to
 139          * be a non-shadowed register so that it survives the rfir.
 140          *
 141          * N.B. TASK_SZ_ALGN and PT_SZ_ALGN include space for a stack frame.
 142          */
 143
 144         .macro  get_stack_use_cr30
 145
 146         /* we save the registers in the task struct */
 147
 148         mfctl   %cr30, %r1
 149         tophys  %r1,%r9
 150         LDREG   TI_TASK(%r9), %r1       /* thread_info -> task_struct */
 151         tophys  %r1,%r9
 152         ldo     TASK_REGS(%r9),%r9
 153         STREG   %r30, PT_GR30(%r9)
 154         STREG   %r29,PT_GR29(%r9)
 155         STREG   %r26,PT_GR26(%r9)
 156         copy    %r9,%r29
 157         mfctl   %cr30, %r1
 158         ldo     THREAD_SZ_ALGN(%r1), %r30
 159         .endm
 160
 161         .macro  get_stack_use_r30
 162
 163         /* we put a struct pt_regs on the stack and save the registers there */
 164
 165         tophys  %r30,%r9
 166         STREG   %r30,PT_GR30(%r9)
 167         ldo     PT_SZ_ALGN(%r30),%r30
 168         STREG   %r29,PT_GR29(%r9)
 169         STREG   %r26,PT_GR26(%r9)
 170         copy    %r9,%r29
 171         .endm
 172
 173         .macro  rest_stack
 174         LDREG   PT_GR1(%r29), %r1
 175         LDREG   PT_GR30(%r29),%r30
 176         LDREG   PT_GR29(%r29),%r29
 177         .endm
 178
 179         /* default interruption handler
 180          * (calls traps.c:handle_interruption) */
 181         .macro  def code
 182         b       intr_save
 183         ldi     \code, %r8
 184         .align  32
 185         .endm
 186
 187         /* Interrupt interruption handler
 188          * (calls irq.c:do_cpu_irq_mask) */
 189         .macro  extint code
 190         b       intr_extint
 191         mfsp    %sr7,%r16
 192         .align  32
 193         .endm
 194
 195         .import os_hpmc, code
 196
 197         /* HPMC handler */
 198         .macro  hpmc code
 199         nop                     /* must be a NOP, will be patched later */
 200         ldil    L%PA(os_hpmc), %r3
 201         ldo     R%PA(os_hpmc)(%r3), %r3
 202         bv,n    0(%r3)
 203         nop
 204         .word   0               /* checksum (will be patched) */
 205         .word   PA(os_hpmc)     /* address of handler */
 206         .word   0               /* length of handler */
 207         .endm
 208
 209         /*
 210          * Performance Note: Instructions will be moved up into
 211          * this part of the code later on, once we are sure
 212          * that the tlb miss handlers are close to final form.
 213          */
 214
 215         /* Register definitions for tlb miss handler macros */
 216
 217         va  = r8        /* virtual address for which the trap occured */
 218         spc = r24       /* space for which the trap occured */
 219
 220 #ifndef __LP64__
 221
 222         /*
 223          * itlb miss interruption handler (parisc 1.1 - 32 bit)
 224          */
 225
 226         .macro  itlb_11 code
 227
 228         mfctl   %pcsq, spc
 229         b       itlb_miss_11
 230         mfctl   %pcoq, va
 231
 232         .align          32
 233         .endm
 234 #endif
 235
 236         /*
 237          * itlb miss interruption handler (parisc 2.0)
 238          */
 239
 240         .macro  itlb_20 code
 241         mfctl   %pcsq, spc
 242 #ifdef __LP64__
 243         b       itlb_miss_20w
 244 #else
 245         b       itlb_miss_20
 246 #endif
 247         mfctl   %pcoq, va
 248
 249         .align          32
 250         .endm
 251
 252 #ifndef __LP64__
 253         /*
 254          * naitlb miss interruption handler (parisc 1.1 - 32 bit)
 255          *
 256          * Note: naitlb misses will be treated
 257          * as an ordinary itlb miss for now.
 258          * However, note that naitlb misses
 259          * have the faulting address in the
 260          * IOR/ISR.
 261          */
 262
 263         .macro  naitlb_11 code
 264
 265         mfctl   %isr,spc
 266         b       itlb_miss_11
 267         mfctl   %ior,va
 268         /* FIXME: If user causes a naitlb miss, the priv level may not be in
 269          * lower bits of va, where the itlb miss handler is expecting them
 270          */
 271
 272         .align          32
 273         .endm
 274 #endif
 275
 276         /*
 277          * naitlb miss interruption handler (parisc 2.0)
 278          *
 279          * Note: naitlb misses will be treated
 280          * as an ordinary itlb miss for now.
 281          * However, note that naitlb misses
 282          * have the faulting address in the
 283          * IOR/ISR.
 284          */
 285
 286         .macro  naitlb_20 code
 287
 288         mfctl   %isr,spc
 289 #ifdef __LP64__
 290         b       itlb_miss_20w
 291 #else
 292         b       itlb_miss_20
 293 #endif
 294         mfctl   %ior,va
 295         /* FIXME: If user causes a naitlb miss, the priv level may not be in
 296          * lower bits of va, where the itlb miss handler is expecting them
 297          */
 298
 299         .align          32
 300         .endm
 301
 302 #ifndef __LP64__
 303         /*
 304          * dtlb miss interruption handler (parisc 1.1 - 32 bit)
 305          */
 306
 307         .macro  dtlb_11 code
 308
 309         mfctl   %isr, spc
 310         b       dtlb_miss_11
 311         mfctl   %ior, va
 312
 313         .align          32
 314         .endm
 315 #endif
 316
 317         /*
 318          * dtlb miss interruption handler (parisc 2.0)
 319          */
 320
 321         .macro  dtlb_20 code
 322
 323         mfctl   %isr, spc
 324 #ifdef __LP64__
 325         b       dtlb_miss_20w
 326 #else
 327         b       dtlb_miss_20
 328 #endif
 329         mfctl   %ior, va
 330
 331         .align          32
 332         .endm
 333
 334 #ifndef __LP64__
 335         /* nadtlb miss interruption handler (parisc 1.1 - 32 bit) */
 336
 337         .macro  nadtlb_11 code
 338
 339         mfctl   %isr,spc
 340         b       nadtlb_miss_11
 341         mfctl   %ior,va
 342
 343         .align          32
 344         .endm
 345 #endif
 346
 347         /* nadtlb miss interruption handler (parisc 2.0) */
 348
 349         .macro  nadtlb_20 code
 350
 351         mfctl   %isr,spc
 352 #ifdef __LP64__
 353         b       nadtlb_miss_20w
 354 #else
 355         b       nadtlb_miss_20
 356 #endif
 357         mfctl   %ior,va
 358
 359         .align          32
 360         .endm
 361
 362 #ifndef __LP64__
 363         /*
 364          * dirty bit trap interruption handler (parisc 1.1 - 32 bit)
 365          */
 366
 367         .macro  dbit_11 code
 368
 369         mfctl   %isr,spc
 370         b       dbit_trap_11
 371         mfctl   %ior,va
 372
 373         .align          32
 374         .endm
 375 #endif
 376
 377         /*
 378          * dirty bit trap interruption handler (parisc 2.0)
 379          */
 380
 381         .macro  dbit_20 code
 382
 383         mfctl   %isr,spc
 384 #ifdef __LP64__
 385         b       dbit_trap_20w
 386 #else
 387         b       dbit_trap_20
 388 #endif
 389         mfctl   %ior,va
 390
 391         .align          32
 392         .endm
 393
 394         /* The following are simple 32 vs 64 bit instruction
 395          * abstractions for the macros */
 396         .macro          EXTR    reg1,start,length,reg2
 397 #ifdef __LP64__
 398         extrd,u         \reg1,32+\start,\length,\reg2
 399 #else
 400         extrw,u         \reg1,\start,\length,\reg2
 401 #endif
 402         .endm
 403
 404         .macro          DEP     reg1,start,length,reg2
 405 #ifdef __LP64__
 406         depd            \reg1,32+\start,\length,\reg2
 407 #else
 408         depw            \reg1,\start,\length,\reg2
 409 #endif
 410         .endm
 411
 412         .macro          DEPI    val,start,length,reg
 413 #ifdef __LP64__
 414         depdi           \val,32+\start,\length,\reg
 415 #else
 416         depwi           \val,\start,\length,\reg
 417 #endif
 418         .endm
 419
 420         /* In LP64, the space contains part of the upper 32 bits of the
 421          * fault.  We have to extract this and place it in the va,
 422          * zeroing the corresponding bits in the space register */
 423         .macro          space_adjust    spc,va,tmp
 424 #ifdef __LP64__
 425         extrd,u         \spc,63,SPACEID_SHIFT,\tmp
 426         depd            %r0,63,SPACEID_SHIFT,\spc
 427         depd            \tmp,31,SPACEID_SHIFT,\va
 428 #endif
 429         .endm
 430
 431         .import         swapper_pg_dir,code
 432
 433         /* Get the pgd.  For faults on space zero (kernel space), this
 434          * is simply swapper_pg_dir.  For user space faults, the
 435          * pgd is stored in %cr25 */
 436         .macro          get_pgd         spc,reg
 437         ldil            L%PA(swapper_pg_dir),\reg
 438         ldo             R%PA(swapper_pg_dir)(\reg),\reg
 439         or,COND(=)      %r0,\spc,%r0
 440         mfctl           %cr25,\reg
 441         .endm
 442
 443         /*
 444                 space_check(spc,tmp,fault)
 445
 446                 spc - The space we saw the fault with.
 447                 tmp - The place to store the current space.
 448                 fault - Function to call on failure.
 449
 450                 Only allow faults on different spaces from the
 451                 currently active one if we're the kernel
 452
 453         */
 454         .macro          space_check     spc,tmp,fault
 455         mfsp            %sr7,\tmp
 456         or,COND(<>)     %r0,\spc,%r0    /* user may execute gateway page
 457                                          * as kernel, so defeat the space
 458                                          * check if it is */
 459         copy            \spc,\tmp
 460         or,COND(=)      %r0,\tmp,%r0    /* nullify if executing as kernel */
 461         cmpb,COND(<>),n \tmp,\spc,\fault
 462         .endm
 463
 464         /* Look up a PTE in a 2-Level scheme (faulting at each
 465          * level if the entry isn't present
 466          *
 467          * NOTE: we use ldw even for LP64, since the short pointers
 468          * can address up to 1TB
 469          */
 470         .macro          L2_ptep pmd,pte,index,va,fault
 471 #if PT_NLEVELS == 3
 472         EXTR            \va,31-ASM_PMD_SHIFT,ASM_BITS_PER_PMD,\index
 473 #else
 474         EXTR            \va,31-ASM_PGDIR_SHIFT,ASM_BITS_PER_PGD,\index
 475 #endif
 476         DEP             %r0,31,PAGE_SHIFT,\pmd  /* clear offset */
 477         copy            %r0,\pte
 478         ldw,s           \index(\pmd),\pmd
 479         bb,>=,n         \pmd,_PxD_PRESENT_BIT,\fault
 480         DEP             %r0,31,PxD_FLAG_SHIFT,\pmd /* clear flags */
 481         copy            \pmd,%r9
 482 #ifdef __LP64__
 483         shld            %r9,PxD_VALUE_SHIFT,\pmd
 484 #else
 485         shlw            %r9,PxD_VALUE_SHIFT,\pmd
 486 #endif
 487         EXTR            \va,31-PAGE_SHIFT,ASM_BITS_PER_PTE,\index
 488         DEP             %r0,31,PAGE_SHIFT,\pmd  /* clear offset */
 489         shladd          \index,BITS_PER_PTE_ENTRY,\pmd,\pmd
 490         LDREG           %r0(\pmd),\pte          /* pmd is now pte */
 491         bb,>=,n         \pte,_PAGE_PRESENT_BIT,\fault
 492         .endm
 493
 494         /* Look up PTE in a 3-Level scheme.
 495          *
 496          * Here we implement a Hybrid L2/L3 scheme: we allocate the
 497          * first pmd adjacent to the pgd.  This means that we can
 498          * subtract a constant offset to get to it.  The pmd and pgd
 499          * sizes are arranged so that a single pmd covers 4GB (giving
 500          * a full LP64 process access to 8TB) so our lookups are
 501          * effectively L2 for the first 4GB of the kernel (i.e. for
 502          * all ILP32 processes and all the kernel for machines with
 503          * under 4GB of memory) */
 504         .macro          L3_ptep pgd,pte,index,va,fault
 505         extrd,u         \va,63-ASM_PGDIR_SHIFT,ASM_BITS_PER_PGD,\index
 506         copy            %r0,\pte
 507         extrd,u,*=      \va,31,32,%r0
 508         ldw,s           \index(\pgd),\pgd
 509         extrd,u,*=      \va,31,32,%r0
 510         bb,>=,n         \pgd,_PxD_PRESENT_BIT,\fault
 511         extrd,u,*=      \va,31,32,%r0
 512         shld            \pgd,PxD_VALUE_SHIFT,\index
 513         extrd,u,*=      \va,31,32,%r0
 514         copy            \index,\pgd
 515         extrd,u,*<>     \va,31,32,%r0
 516         ldo             ASM_PGD_PMD_OFFSET(\pgd),\pgd
 517         L2_ptep         \pgd,\pte,\index,\va,\fault
 518         .endm
 519
 520         /* Set the _PAGE_ACCESSED bit of the PTE.  Be clever and
 521          * don't needlessly dirty the cache line if it was already set */
 522         .macro          update_ptep     ptep,pte,tmp,tmp1
 523         ldi             _PAGE_ACCESSED,\tmp1
 524         or              \tmp1,\pte,\tmp
 525         and,COND(<>)    \tmp1,\pte,%r0
 526         STREG           \tmp,0(\ptep)
 527         .endm
 528
 529         /* Set the dirty bit (and accessed bit).  No need to be
 530          * clever, this is only used from the dirty fault */
 531         .macro          update_dirty    ptep,pte,tmp
 532         ldi             _PAGE_ACCESSED|_PAGE_DIRTY,\tmp
 533         or              \tmp,\pte,\pte
 534         STREG           \pte,0(\ptep)
 535         .endm
 536
 537         /* Convert the pte and prot to tlb insertion values.  How
 538          * this happens is quite subtle, read below */
 539         .macro          make_insert_tlb spc,pte,prot
 540         space_to_prot   \spc \prot        /* create prot id from space */
 541         /* The following is the real subtlety.  This is depositing
 542          * T <-> _PAGE_REFTRAP
 543          * D <-> _PAGE_DIRTY
 544          * B <-> _PAGE_DMB (memory break)
 545          *
 546          * Then incredible subtlety: The access rights are
 547          * _PAGE_GATEWAY _PAGE_EXEC _PAGE_READ
 548          * See 3-14 of the parisc 2.0 manual
 549          *
 550          * Finally, _PAGE_READ goes in the top bit of PL1 (so we
 551          * trigger an access rights trap in user space if the user
 552          * tries to read an unreadable page */
 553         depd            \pte,8,7,\prot
 554
 555         /* PAGE_USER indicates the page can be read with user privileges,
 556          * so deposit X1|11 to PL1|PL2 (remember the upper bit of PL1
 557          * contains _PAGE_READ */
 558         extrd,u,*=      \pte,_PAGE_USER_BIT+32,1,%r0
 559         depdi           7,11,3,\prot
 560         /* If we're a gateway page, drop PL2 back to zero for promotion
 561          * to kernel privilege (so we can execute the page as kernel).
 562          * Any privilege promotion page always denys read and write */
 563         extrd,u,*=      \pte,_PAGE_GATEWAY_BIT+32,1,%r0
 564         depd            %r0,11,2,\prot  /* If Gateway, Set PL2 to 0 */
 565
 566         /* Get rid of prot bits and convert to page addr for iitlbt */
 567
 568         depd            %r0,63,PAGE_SHIFT,\pte
 569         extrd,u         \pte,56,32,\pte
 570         .endm
 571
 572         /* Identical macro to make_insert_tlb above, except it
 573          * makes the tlb entry for the differently formatted pa11
 574          * insertion instructions */
 575         .macro          make_insert_tlb_11      spc,pte,prot
 576         zdep            \spc,30,15,\prot
 577         dep             \pte,8,7,\prot
 578         extru,=         \pte,_PAGE_NO_CACHE_BIT,1,%r0
 579         depi            1,12,1,\prot
 580         extru,=         \pte,_PAGE_USER_BIT,1,%r0
 581         depi            7,11,3,\prot   /* Set for user space (1 rsvd for read) */
 582         extru,=         \pte,_PAGE_GATEWAY_BIT,1,%r0
 583         depi            0,11,2,\prot    /* If Gateway, Set PL2 to 0 */
 584
 585         /* Get rid of prot bits and convert to page addr for iitlba */
 586
 587         depi            0,31,12,\pte
 588         extru           \pte,24,25,\pte
 589
 590         .endm
 591
 592         /* This is for ILP32 PA2.0 only.  The TLB insertion needs
 593          * to extend into I/O space if the address is 0xfXXXXXXX
 594          * so we extend the f's into the top word of the pte in
 595          * this case */
 596         .macro          f_extend        pte,tmp
 597         extrd,s         \pte,42,4,\tmp
 598         addi,<>         1,\tmp,%r0
 599         extrd,s         \pte,63,25,\pte
 600         .endm
 601
 602         /* The alias region is an 8MB aligned 16MB to do clear and
 603          * copy user pages at addresses congruent with the user
 604          * virtual address.
 605          *
 606          * To use the alias page, you set %r26 up with the to TLB
 607          * entry (identifying the physical page) and %r23 up with
 608          * the from tlb entry (or nothing if only a to entry---for
 609          * clear_user_page_asm) */
 610         .macro          do_alias        spc,tmp,tmp1,va,pte,prot,fault
 611         cmpib,COND(<>),n 0,\spc,\fault
 612         ldil            L%(TMPALIAS_MAP_START),\tmp
 613 #if defined(__LP64__) && (TMPALIAS_MAP_START >= 0x80000000)
 614         /* on LP64, ldi will sign extend into the upper 32 bits,
 615          * which is behaviour we don't want */
 616         depdi           0,31,32,\tmp
 617 #endif
 618         copy            \va,\tmp1
 619         DEPI            0,31,23,\tmp1
 620         cmpb,COND(<>),n \tmp,\tmp1,\fault
 621         ldi             (_PAGE_DIRTY|_PAGE_WRITE|_PAGE_READ),\prot
 622         depd,z          \prot,8,7,\prot
 623         /*
 624          * OK, it is in the temp alias region, check whether "from" or "to".
 625          * Check "subtle" note in pacache.S re: r23/r26.
 626          */
 627 #ifdef __LP64__
 628         extrd,u,*=      \va,41,1,%r0
 629 #else
 630         extrw,u,=       \va,9,1,%r0
 631 #endif
 632         or,COND(tr)     %r23,%r0,\pte
 633         or              %r26,%r0,\pte
 634         .endm
 635
 636
 637         /*
 638          * Align fault_vector_20 on 4K boundary so that both
 639          * fault_vector_11 and fault_vector_20 are on the
 640          * same page. This is only necessary as long as we
 641          * write protect the kernel text, which we may stop
 642          * doing once we use large page translations to cover
 643          * the static part of the kernel address space.
 644          */
 645
 646         .export fault_vector_20
 647
 648         .text
 649
 650         .align 4096
 651
 652 fault_vector_20:
 653         /* First vector is invalid (0) */
 654         .ascii  "cows can fly"
 655         .byte 0
 656         .align 32
 657
 658         hpmc             1
 659         def              2
 660         def              3
 661         extint           4
 662         def              5
 663         itlb_20          6
 664         def              7
 665         def              8
 666         def              9
 667         def             10
 668         def             11
 669         def             12
 670         def             13
 671         def             14
 672         dtlb_20         15
 673 #if 0
 674         naitlb_20       16
 675 #else
 676         def             16
 677 #endif
 678         nadtlb_20       17
 679         def             18
 680         def             19
 681         dbit_20         20
 682         def             21
 683         def             22
 684         def             23
 685         def             24
 686         def             25
 687         def             26
 688         def             27
 689         def             28
 690         def             29
 691         def             30
 692         def             31
 693
 694 #ifndef __LP64__
 695
 696         .export fault_vector_11
 697
 698         .align 2048
 699
 700 fault_vector_11:
 701         /* First vector is invalid (0) */
 702         .ascii  "cows can fly"
 703         .byte 0
 704         .align 32
 705
 706         hpmc             1
 707         def              2
 708         def              3
 709         extint           4
 710         def              5
 711         itlb_11          6
 712         def              7
 713         def              8
 714         def              9
 715         def             10
 716         def             11
 717         def             12
 718         def             13
 719         def             14
 720         dtlb_11         15
 721 #if 0
 722         naitlb_11       16
 723 #else
 724         def             16
 725 #endif
 726         nadtlb_11       17
 727         def             18
 728         def             19
 729         dbit_11         20
 730         def             21
 731         def             22
 732         def             23
 733         def             24
 734         def             25
 735         def             26
 736         def             27
 737         def             28
 738         def             29
 739         def             30
 740         def             31
 741
 742 #endif
 743
 744         .import         handle_interruption,code
 745         .import         do_cpu_irq_mask,code
 746
 747         /*
 748          * r26 = function to be called
 749          * r25 = argument to pass in
 750          * r24 = flags for do_fork()
 751          *
 752          * Kernel threads don't ever return, so they don't need
 753          * a true register context. We just save away the arguments
 754          * for copy_thread/ret_ to properly set up the child.
 755          */
 756
 757 #define CLONE_VM 0x100  /* Must agree with <linux/sched.h> */
 758 #define CLONE_UNTRACED 0x00800000
 759
 760         .export __kernel_thread, code
 761         .import do_fork
 762 __kernel_thread:
 763         STREG   %r2, -RP_OFFSET(%r30)
 764
 765         copy    %r30, %r1
 766         ldo     PT_SZ_ALGN(%r30),%r30
 767 #ifdef __LP64__
 768         /* Yo, function pointers in wide mode are little structs... -PB */
 769         ldd     24(%r26), %r2
 770         STREG   %r2, PT_GR27(%r1)       /* Store childs %dp */
 771         ldd     16(%r26), %r26
 772
 773         STREG   %r22, PT_GR22(%r1)      /* save r22 (arg5) */
 774         copy    %r0, %r22               /* user_tid */
 775 #endif
 776         STREG   %r26, PT_GR26(%r1)  /* Store function & argument for child */
 777         STREG   %r25, PT_GR25(%r1)
 778         ldil    L%CLONE_UNTRACED, %r26
 779         ldo     CLONE_VM(%r26), %r26   /* Force CLONE_VM since only init_mm */
 780         or      %r26, %r24, %r26      /* will have kernel mappings.      */
 781         ldi     1, %r25                 /* stack_start, signals kernel thread */
 782         stw     %r0, -52(%r30)          /* user_tid */
 783 #ifdef __LP64__
 784         ldo     -16(%r30),%r29          /* Reference param save area */
 785 #endif
 786         BL      do_fork, %r2
 787         copy    %r1, %r24               /* pt_regs */
 788
 789         /* Parent Returns here */
 790
 791         LDREG   -PT_SZ_ALGN-RP_OFFSET(%r30), %r2
 792         ldo     -PT_SZ_ALGN(%r30), %r30
 793         bv      %r0(%r2)
 794         nop
 795
 796         /*
 797          * Child Returns here
 798          *
 799          * copy_thread moved args from temp save area set up above
 800          * into task save area.
 801          */
 802
 803         .export ret_from_kernel_thread
 804 ret_from_kernel_thread:
 805
 806         /* Call schedule_tail first though */
 807         BL      schedule_tail, %r2
 808         nop
 809
 810         LDREG   TI_TASK-THREAD_SZ_ALGN(%r30), %r1
 811         LDREG   TASK_PT_GR25(%r1), %r26
 812 #ifdef __LP64__
 813         LDREG   TASK_PT_GR27(%r1), %r27
 814         LDREG   TASK_PT_GR22(%r1), %r22
 815 #endif
 816         LDREG   TASK_PT_GR26(%r1), %r1
 817         ble     0(%sr7, %r1)
 818         copy    %r31, %r2
 819
 820 #ifdef __LP64__
 821         ldo     -16(%r30),%r29          /* Reference param save area */
 822         loadgp                          /* Thread could have been in a module */
 823 #endif
 824         b       sys_exit
 825         ldi     0, %r26
 826
 827         .import sys_execve, code
 828         .export __execve, code
 829 __execve:
 830         copy    %r2, %r15
 831         copy    %r30, %r16
 832         ldo     PT_SZ_ALGN(%r30), %r30
 833         STREG   %r26, PT_GR26(%r16)
 834         STREG   %r25, PT_GR25(%r16)
 835         STREG   %r24, PT_GR24(%r16)
 836 #ifdef __LP64__
 837         ldo     -16(%r30),%r29          /* Reference param save area */
 838 #endif
 839         BL      sys_execve, %r2
 840         copy    %r16, %r26
 841
 842         cmpib,=,n 0,%r28,intr_return    /* forward */
 843
 844         /* yes, this will trap and die. */
 845         copy    %r15, %r2
 846         copy    %r16, %r30
 847         bv      %r0(%r2)
 848         nop
 849
 850         .align 4
 851
 852         /*
 853          * struct task_struct *_switch_to(struct task_struct *prev,
 854          *      struct task_struct *next)
 855          *
 856          * switch kernel stacks and return prev */
 857         .export _switch_to, code
 858 _switch_to:
 859         STREG    %r2, -RP_OFFSET(%r30)
 860
 861         callee_save
 862
 863         ldil    L%_switch_to_ret, %r2
 864         ldo     R%_switch_to_ret(%r2), %r2
 865
 866         STREG   %r2, TASK_PT_KPC(%r26)
 867         LDREG   TASK_PT_KPC(%r25), %r2
 868
 869         STREG   %r30, TASK_PT_KSP(%r26)
 870         LDREG   TASK_PT_KSP(%r25), %r30
 871         LDREG   TASK_THREAD_INFO(%r25), %r25
 872         bv      %r0(%r2)
 873         mtctl   %r25,%cr30
 874
 875 _switch_to_ret:
 876         mtctl   %r0, %cr0               /* Needed for single stepping */
 877         callee_rest
 878
 879         LDREG   -RP_OFFSET(%r30), %r2
 880         bv      %r0(%r2)
 881         copy    %r26, %r28
 882
 883         /*
 884          * Common rfi return path for interruptions, kernel execve, and
 885          * sys_rt_sigreturn (sometimes).  The sys_rt_sigreturn syscall will
 886          * return via this path if the signal was received when the process
 887          * was running; if the process was blocked on a syscall then the
 888          * normal syscall_exit path is used.  All syscalls for traced
 889          * proceses exit via intr_restore.
 890          *
 891          * XXX If any syscalls that change a processes space id ever exit
 892          * this way, then we will need to copy %sr3 in to PT_SR[3..7], and
 893          * adjust IASQ[0..1].
 894          *
 895          * Note that the following code uses a "relied upon translation".
 896          * See the parisc ACD for details. The ssm is necessary due to a
 897          * PCXT bug.
 898          */
 899
 900         .align 4096
 901
 902         .export syscall_exit_rfi
 903 syscall_exit_rfi:
 904         mfctl   %cr30,%r16
 905         LDREG   TI_TASK(%r16), %r16     /* thread_info -> task_struct */
 906         ldo     TASK_REGS(%r16),%r16
 907         /* Force iaoq to userspace, as the user has had access to our current
 908          * context via sigcontext. Also Filter the PSW for the same reason.
 909          */
 910         LDREG   PT_IAOQ0(%r16),%r19
 911         depi    3,31,2,%r19
 912         STREG   %r19,PT_IAOQ0(%r16)
 913         LDREG   PT_IAOQ1(%r16),%r19
 914         depi    3,31,2,%r19
 915         STREG   %r19,PT_IAOQ1(%r16)
 916         LDREG   PT_PSW(%r16),%r19
 917         ldil    L%USER_PSW_MASK,%r1
 918         ldo     R%USER_PSW_MASK(%r1),%r1
 919 #ifdef __LP64__
 920         ldil    L%USER_PSW_HI_MASK,%r20
 921         ldo     R%USER_PSW_HI_MASK(%r20),%r20
 922         depd    %r20,31,32,%r1
 923 #endif
 924         and     %r19,%r1,%r19 /* Mask out bits that user shouldn't play with */
 925         ldil    L%USER_PSW,%r1
 926         ldo     R%USER_PSW(%r1),%r1
 927         or      %r19,%r1,%r19 /* Make sure default USER_PSW bits are set */
 928         STREG   %r19,PT_PSW(%r16)
 929
 930         /*
 931          * If we aren't being traced, we never saved space registers
 932          * (we don't store them in the sigcontext), so set them
 933          * to "proper" values now (otherwise we'll wind up restoring
 934          * whatever was last stored in the task structure, which might
 935          * be inconsistent if an interrupt occured while on the gateway
 936          * page) Note that we may be "trashing" values the user put in
 937          * them, but we don't support the the user changing them.
 938          */
 939
 940         STREG   %r0,PT_SR2(%r16)
 941         mfsp    %sr3,%r19
 942         STREG   %r19,PT_SR0(%r16)
 943         STREG   %r19,PT_SR1(%r16)
 944         STREG   %r19,PT_SR3(%r16)
 945         STREG   %r19,PT_SR4(%r16)
 946         STREG   %r19,PT_SR5(%r16)
 947         STREG   %r19,PT_SR6(%r16)
 948         STREG   %r19,PT_SR7(%r16)
 949
 950 intr_return:
 951         /* NOTE: Need to enable interrupts incase we schedule. */
 952         ssm     PSW_SM_I, %r0
 953
 954         /* Check for software interrupts */
 955
 956         .import irq_stat,data
 957
 958         ldil    L%irq_stat,%r19
 959         ldo     R%irq_stat(%r19),%r19
 960 #ifdef CONFIG_SMP
 961         mfctl   %cr30,%r1
 962         ldw     TI_CPU(%r1),%r1 /* get cpu # - int */
 963         /* shift left ____cacheline_aligned (aka L1_CACHE_BYTES) amount
 964         ** irq_stat[] is defined using ____cacheline_aligned.
 965         */
 966 #ifdef __LP64__
 967         shld    %r1, 6, %r20
 968 #else
 969         shlw    %r1, 5, %r20
 970 #endif
 971         add     %r19,%r20,%r19  /* now have &irq_stat[smp_processor_id()] */
 972 #endif /* CONFIG_SMP */
 973
 974         LDREG   IRQSTAT_SIRQ_PEND(%r19),%r20    /* hardirq.h: unsigned long */
 975         cmpib,<>,n 0,%r20,intr_do_softirq /* forward */
 976
 977 intr_check_resched:
 978
 979         /* check for reschedule */
 980         mfctl   %cr30,%r1
 981         LDREG   TI_FLAGS(%r1),%r19      /* sched.h: TIF_NEED_RESCHED */
 982         bb,<,n  %r19,31-TIF_NEED_RESCHED,intr_do_resched /* forward */
 983
 984 intr_check_sig:
 985         /* As above */
 986         mfctl   %cr30,%r1
 987         LDREG   TI_FLAGS(%r1),%r19      /* sched.h: TIF_SIGPENDING */
 988         bb,<,n %r19, 31-TIF_SIGPENDING, intr_do_signal /* forward */
 989
 990 intr_restore:
 991         copy            %r16,%r29
 992         ldo             PT_FR31(%r29),%r1
 993         rest_fp         %r1
 994         rest_general    %r29
 995
 996         /* Create a "relied upon translation" PA 2.0 Arch. F-5 */
 997         ssm             0,%r0
 998         nop
 999         nop
1000         nop
1001         nop
1002         nop
1003         nop
1004         nop
1005         tophys_r1       %r29
1006         rsm             (PSW_SM_Q|PSW_SM_P|PSW_SM_D|PSW_SM_I),%r0
1007
1008         /* Restore space id's and special cr's from PT_REGS
1009          * structure pointed to by r29 */
1010         rest_specials   %r29
1011
1012         /* Important: Note that rest_stack restores r29
1013          * last (we are using it)! It also restores r1 and r30. */
1014         rest_stack
1015
1016         rfi
1017         nop
1018         nop
1019         nop
1020         nop
1021         nop
1022         nop
1023         nop
1024         nop
1025
1026         .import do_softirq,code
1027 intr_do_softirq:
1028         bl      do_softirq,%r2
1029 #ifdef __LP64__
1030         ldo     -16(%r30),%r29          /* Reference param save area */
1031 #else
1032         nop
1033 #endif
1034         b       intr_check_resched
1035         nop
1036
1037         .import schedule,code
1038 intr_do_resched:
1039         /* Only do reschedule if we are returning to user space */
1040         LDREG   PT_IASQ0(%r16), %r20
1041         CMPIB= 0,%r20,intr_restore /* backward */
1042         nop
1043         LDREG   PT_IASQ1(%r16), %r20
1044         CMPIB= 0,%r20,intr_restore /* backward */
1045         nop
1046
1047 #ifdef __LP64__
1048         ldo     -16(%r30),%r29          /* Reference param save area */
1049 #endif
1050
1051         ldil    L%intr_check_sig, %r2
1052         b       schedule
1053         ldo     R%intr_check_sig(%r2), %r2
1054
1055
1056         .import do_signal,code
1057 intr_do_signal:
1058         /*
1059                 This check is critical to having LWS
1060                 working. The IASQ is zero on the gateway
1061                 page and we cannot deliver any signals until
1062                 we get off the gateway page.
1063
1064                 Only do signals if we are returning to user space
1065         */
1066         LDREG   PT_IASQ0(%r16), %r20
1067         CMPIB= 0,%r20,intr_restore /* backward */
1068         nop
1069         LDREG   PT_IASQ1(%r16), %r20
1070         CMPIB= 0,%r20,intr_restore /* backward */
1071         nop
1072
1073         copy    %r0, %r24                       /* unsigned long in_syscall */
1074         copy    %r16, %r25                      /* struct pt_regs *regs */
1075 #ifdef __LP64__
1076         ldo     -16(%r30),%r29                  /* Reference param save area */
1077 #endif
1078
1079         BL      do_signal,%r2
1080         copy    %r0, %r26                       /* sigset_t *oldset = NULL */
1081
1082         b       intr_restore
1083         nop
1084
1085         /*
1086          * External interrupts.
1087          */
1088
1089 intr_extint:
1090         CMPIB=,n 0,%r16,1f
1091         get_stack_use_cr30
1092         b,n 3f
1093
1094 1:
1095 #if 0  /* Interrupt Stack support not working yet! */
1096         mfctl   %cr31,%r1
1097         copy    %r30,%r17
1098         /* FIXME! depi below has hardcoded idea of interrupt stack size (32k)*/
1099 #ifdef __LP64__
1100         depdi   0,63,15,%r17
1101 #else
1102         depi    0,31,15,%r17
1103 #endif
1104         CMPB=,n %r1,%r17,2f
1105         get_stack_use_cr31
1106         b,n 3f
1107 #endif
1108 2:
1109         get_stack_use_r30
1110
1111 3:
1112         save_specials   %r29
1113         virt_map
1114         save_general    %r29
1115
1116         ldo     PT_FR0(%r29), %r24
1117         save_fp %r24
1118
1119         loadgp
1120
1121         copy    %r29, %r26      /* arg0 is pt_regs */
1122         copy    %r29, %r16      /* save pt_regs */
1123
1124         ldil    L%intr_return, %r2
1125
1126 #ifdef __LP64__
1127         ldo     -16(%r30),%r29  /* Reference param save area */
1128 #endif
1129
1130         b       do_cpu_irq_mask
1131         ldo     R%intr_return(%r2), %r2 /* return to intr_return, not here */
1132
1133
1134         /* Generic interruptions (illegal insn, unaligned, page fault, etc) */
1135
1136         .export         intr_save, code /* for os_hpmc */
1137
1138 intr_save:
1139         mfsp    %sr7,%r16
1140         CMPIB=,n 0,%r16,1f
1141         get_stack_use_cr30
1142         b       2f
1143         copy    %r8,%r26
1144
1145 1:
1146         get_stack_use_r30
1147         copy    %r8,%r26
1148
1149 2:
1150         save_specials   %r29
1151
1152         /* If this trap is a itlb miss, skip saving/adjusting isr/ior */
1153
1154         /*
1155          * FIXME: 1) Use a #define for the hardwired "6" below (and in
1156          *           traps.c.
1157          *        2) Once we start executing code above 4 Gb, we need
1158          *           to adjust iasq/iaoq here in the same way we
1159          *           adjust isr/ior below.
1160          */
1161
1162         CMPIB=,n        6,%r26,skip_save_ior
1163
1164         /* save_specials left ipsw value in r8 for us to test */
1165
1166         mfctl           %cr20, %r16 /* isr */
1167         mfctl           %cr21, %r17 /* ior */
1168
1169 #ifdef __LP64__
1170         /*
1171          * If the interrupted code was running with W bit off (32 bit),
1172          * clear the b bits (bits 0 & 1) in the ior.
1173          */
1174         extrd,u,*<>     %r8,PSW_W_BIT,1,%r0
1175         depdi           0,1,2,%r17
1176
1177         /*
1178          * FIXME: This code has hardwired assumptions about the split
1179          *        between space bits and offset bits. This will change
1180          *        when we allow alternate page sizes.
1181          */
1182
1183         /* adjust isr/ior. */
1184
1185         extrd,u         %r16,63,7,%r1    /* get high bits from isr for ior */
1186         depd            %r1,31,7,%r17    /* deposit them into ior */
1187         depdi           0,63,7,%r16      /* clear them from isr */
1188 #endif
1189         STREG           %r16, PT_ISR(%r29)
1190         STREG           %r17, PT_IOR(%r29)
1191
1192
1193 skip_save_ior:
1194         virt_map
1195         save_general    %r29
1196
1197         ldo             PT_FR0(%r29), %r25
1198         save_fp         %r25
1199
1200         loadgp
1201
1202         copy            %r29, %r25      /* arg1 is pt_regs */
1203 #ifdef __LP64__
1204         ldo             -16(%r30),%r29  /* Reference param save area */
1205 #endif
1206
1207         ldil            L%intr_check_sig, %r2
1208         copy            %r25, %r16      /* save pt_regs */
1209
1210         b               handle_interruption
1211         ldo             R%intr_check_sig(%r2), %r2
1212
1213
1214         /*
1215          * Note for all tlb miss handlers:
1216          *
1217          * cr24 contains a pointer to the kernel address space
1218          * page directory.
1219          *
1220          * cr25 contains a pointer to the current user address
1221          * space page directory.
1222          *
1223          * sr3 will contain the space id of the user address space
1224          * of the current running thread while that thread is
1225          * running in the kernel.
1226          */
1227
1228         /*
1229          * register number allocations.  Note that these are all
1230          * in the shadowed registers
1231          */
1232
1233         t0 = r1         /* temporary register 0 */
1234         va = r8         /* virtual address for which the trap occured */
1235         t1 = r9         /* temporary register 1 */
1236         pte  = r16      /* pte/phys page # */
1237         prot = r17      /* prot bits */
1238         spc  = r24      /* space for which the trap occured */
1239         ptp = r25       /* page directory/page table pointer */
1240
1241 #ifdef __LP64__
1242
1243 dtlb_miss_20w:
1244         space_adjust    spc,va,t0
1245         get_pgd         spc,ptp
1246         space_check     spc,t0,dtlb_fault
1247
1248         L3_ptep         ptp,pte,t0,va,dtlb_check_alias_20w
1249
1250         update_ptep     ptp,pte,t0,t1
1251
1252         make_insert_tlb spc,pte,prot
1253
1254         idtlbt          pte,prot
1255
1256         rfir
1257         nop
1258
1259 dtlb_check_alias_20w:
1260         do_alias        spc,t0,t1,va,pte,prot,dtlb_fault
1261
1262         idtlbt          pte,prot
1263
1264         rfir
1265         nop
1266
1267 nadtlb_miss_20w:
1268         space_adjust    spc,va,t0
1269         get_pgd         spc,ptp
1270         space_check     spc,t0,nadtlb_fault
1271
1272         L3_ptep         ptp,pte,t0,va,nadtlb_check_flush_20w
1273
1274         update_ptep     ptp,pte,t0,t1
1275
1276         make_insert_tlb spc,pte,prot
1277
1278         idtlbt          pte,prot
1279
1280         rfir
1281         nop
1282
1283 nadtlb_check_flush_20w:
1284         bb,>=,n          pte,_PAGE_FLUSH_BIT,nadtlb_emulate
1285
1286         /* Insert a "flush only" translation */
1287
1288         depdi,z         7,7,3,prot
1289         depdi           1,10,1,prot
1290
1291         /* Get rid of prot bits and convert to page addr for idtlbt */
1292
1293         depdi           0,63,12,pte
1294         extrd,u         pte,56,52,pte
1295         idtlbt          pte,prot
1296
1297         rfir
1298         nop
1299
1300 #else
1301
1302 dtlb_miss_11:
1303         get_pgd         spc,ptp
1304
1305         space_check     spc,t0,dtlb_fault
1306
1307         L2_ptep         ptp,pte,t0,va,dtlb_check_alias_11
1308
1309         update_ptep     ptp,pte,t0,t1
1310
1311         make_insert_tlb_11      spc,pte,prot
1312
1313         mfsp            %sr1,t0  /* Save sr1 so we can use it in tlb inserts */
1314         mtsp            spc,%sr1
1315
1316         idtlba          pte,(%sr1,va)
1317         idtlbp          prot,(%sr1,va)
1318
1319         mtsp            t0, %sr1        /* Restore sr1 */
1320
1321         rfir
1322         nop
1323
1324 dtlb_check_alias_11:
1325
1326         /* Check to see if fault is in the temporary alias region */
1327
1328         cmpib,<>,n      0,spc,dtlb_fault /* forward */
1329         ldil            L%(TMPALIAS_MAP_START),t0
1330         copy            va,t1
1331         depwi           0,31,23,t1
1332         cmpb,<>,n       t0,t1,dtlb_fault /* forward */
1333         ldi             (_PAGE_DIRTY|_PAGE_WRITE|_PAGE_READ),prot
1334         depw,z          prot,8,7,prot
1335
1336         /*
1337          * OK, it is in the temp alias region, check whether "from" or "to".
1338          * Check "subtle" note in pacache.S re: r23/r26.
1339          */
1340
1341         extrw,u,=       va,9,1,r0
1342         or,tr           %r23,%r0,pte    /* If "from" use "from" page */
1343         or              %r26,%r0,pte    /* else "to", use "to" page  */
1344
1345         idtlba          pte,(va)
1346         idtlbp          prot,(va)
1347
1348         rfir
1349         nop
1350
1351 nadtlb_miss_11:
1352         get_pgd         spc,ptp
1353
1354         space_check     spc,t0,nadtlb_fault
1355
1356         L2_ptep         ptp,pte,t0,va,nadtlb_check_flush_11
1357
1358         update_ptep     ptp,pte,t0,t1
1359
1360         make_insert_tlb_11      spc,pte,prot
1361
1362
1363         mfsp            %sr1,t0  /* Save sr1 so we can use it in tlb inserts */
1364         mtsp            spc,%sr1
1365
1366         idtlba          pte,(%sr1,va)
1367         idtlbp          prot,(%sr1,va)
1368
1369         mtsp            t0, %sr1        /* Restore sr1 */
1370
1371         rfir
1372         nop
1373
1374 nadtlb_check_flush_11:
1375         bb,>=,n          pte,_PAGE_FLUSH_BIT,nadtlb_emulate
1376
1377         /* Insert a "flush only" translation */
1378
1379         zdepi           7,7,3,prot
1380         depi            1,10,1,prot
1381
1382         /* Get rid of prot bits and convert to page addr for idtlba */
1383
1384         depi            0,31,12,pte
1385         extru           pte,24,25,pte
1386
1387         mfsp            %sr1,t0  /* Save sr1 so we can use it in tlb inserts */
1388         mtsp            spc,%sr1
1389
1390         idtlba          pte,(%sr1,va)
1391         idtlbp          prot,(%sr1,va)
1392
1393         mtsp            t0, %sr1        /* Restore sr1 */
1394
1395         rfir
1396         nop
1397
1398 dtlb_miss_20:
1399         space_adjust    spc,va,t0
1400         get_pgd         spc,ptp
1401         space_check     spc,t0,dtlb_fault
1402
1403         L2_ptep         ptp,pte,t0,va,dtlb_check_alias_20
1404
1405         update_ptep     ptp,pte,t0,t1
1406
1407         make_insert_tlb spc,pte,prot
1408
1409         f_extend        pte,t0
1410
1411         idtlbt          pte,prot
1412
1413         rfir
1414         nop
1415
1416 dtlb_check_alias_20:
1417         do_alias        spc,t0,t1,va,pte,prot,dtlb_fault
1418
1419         idtlbt          pte,prot
1420
1421         rfir
1422         nop
1423
1424 nadtlb_miss_20:
1425         get_pgd         spc,ptp
1426
1427         space_check     spc,t0,nadtlb_fault
1428
1429         L2_ptep         ptp,pte,t0,va,nadtlb_check_flush_20
1430
1431         update_ptep     ptp,pte,t0,t1
1432
1433         make_insert_tlb spc,pte,prot
1434
1435         f_extend        pte,t0
1436
1437         idtlbt          pte,prot
1438
1439         rfir
1440         nop
1441
1442 nadtlb_check_flush_20:
1443         bb,>=,n          pte,_PAGE_FLUSH_BIT,nadtlb_emulate
1444
1445         /* Insert a "flush only" translation */
1446
1447         depdi,z         7,7,3,prot
1448         depdi           1,10,1,prot
1449
1450         /* Get rid of prot bits and convert to page addr for idtlbt */
1451
1452         depdi           0,63,12,pte
1453         extrd,u         pte,56,32,pte
1454         idtlbt          pte,prot
1455
1456         rfir
1457         nop
1458 #endif
1459
1460 nadtlb_emulate:
1461
1462         /*
1463          * Non access misses can be caused by fdc,fic,pdc,lpa,probe and
1464          * probei instructions. We don't want to fault for these
1465          * instructions (not only does it not make sense, it can cause
1466          * deadlocks, since some flushes are done with the mmap
1467          * semaphore held). If the translation doesn't exist, we can't
1468          * insert a translation, so have to emulate the side effects
1469          * of the instruction. Since we don't insert a translation
1470          * we can get a lot of faults during a flush loop, so it makes
1471          * sense to try to do it here with minimum overhead. We only
1472          * emulate fdc,fic,pdc,probew,prober instructions whose base
1473          * and index registers are not shadowed. We defer everything
1474          * else to the "slow" path.
1475          */
1476
1477         mfctl           %cr19,%r9 /* Get iir */
1478
1479         /* PA 2.0 Arch Ref. Book pg 382 has a good description of the insn bits.
1480            Checks for fdc,fdce,pdc,"fic,4f",prober,probeir,probew, probeiw */
1481
1482         /* Checks for fdc,fdce,pdc,"fic,4f" only */
1483         ldi             0x280,%r16
1484         and             %r9,%r16,%r17
1485         cmpb,<>,n       %r16,%r17,nadtlb_probe_check
1486         bb,>=,n         %r9,26,nadtlb_nullify  /* m bit not set, just nullify */
1487         BL              get_register,%r25
1488         extrw,u         %r9,15,5,%r8           /* Get index register # */
1489         CMPIB=,n        -1,%r1,nadtlb_fault    /* have to use slow path */
1490         copy            %r1,%r24
1491         BL              get_register,%r25
1492         extrw,u         %r9,10,5,%r8           /* Get base register # */
1493         CMPIB=,n        -1,%r1,nadtlb_fault    /* have to use slow path */
1494         BL              set_register,%r25
1495         add,l           %r1,%r24,%r1           /* doesn't affect c/b bits */
1496
1497 nadtlb_nullify:
1498         mfctl           %cr22,%r8              /* Get ipsw */
1499         ldil            L%PSW_N,%r9
1500         or              %r8,%r9,%r8            /* Set PSW_N */
1501         mtctl           %r8,%cr22
1502
1503         rfir
1504         nop
1505
1506         /*
1507                 When there is no translation for the probe address then we
1508                 must nullify the insn and return zero in the target regsiter.
1509                 This will indicate to the calling code that it does not have
1510                 write/read privileges to this address.
1511
1512                 This should technically work for prober and probew in PA 1.1,
1513                 and also probe,r and probe,w in PA 2.0
1514
1515                 WARNING: USE ONLY NON-SHADOW REGISTERS WITH PROBE INSN!
1516                 THE SLOW-PATH EMULATION HAS NOT BEEN WRITTEN YET.
1517
1518         */
1519 nadtlb_probe_check:
1520         ldi             0x80,%r16
1521         and             %r9,%r16,%r17
1522         cmpb,<>,n       %r16,%r17,nadtlb_fault /* Must be probe,[rw]*/
1523         BL              get_register,%r25      /* Find the target register */
1524         extrw,u         %r9,31,5,%r8           /* Get target register */
1525         CMPIB=,n        -1,%r1,nadtlb_fault    /* have to use slow path */
1526         BL              set_register,%r25
1527         copy            %r0,%r1                /* Write zero to target register */
1528         b nadtlb_nullify                       /* Nullify return insn */
1529         nop
1530
1531
1532 #ifdef __LP64__
1533 itlb_miss_20w:
1534
1535         /*
1536          * I miss is a little different, since we allow users to fault
1537          * on the gateway page which is in the kernel address space.
1538          */
1539
1540         space_adjust    spc,va,t0
1541         get_pgd         spc,ptp
1542         space_check     spc,t0,itlb_fault
1543
1544         L3_ptep         ptp,pte,t0,va,itlb_fault
1545
1546         update_ptep     ptp,pte,t0,t1
1547
1548         make_insert_tlb spc,pte,prot
1549
1550         iitlbt          pte,prot
1551
1552         rfir
1553         nop
1554
1555 #else
1556
1557 itlb_miss_11:
1558         get_pgd         spc,ptp
1559
1560         space_check     spc,t0,itlb_fault
1561
1562         L2_ptep         ptp,pte,t0,va,itlb_fault
1563
1564         update_ptep     ptp,pte,t0,t1
1565
1566         make_insert_tlb_11      spc,pte,prot
1567
1568         mfsp            %sr1,t0  /* Save sr1 so we can use it in tlb inserts */
1569         mtsp            spc,%sr1
1570
1571         iitlba          pte,(%sr1,va)
1572         iitlbp          prot,(%sr1,va)
1573
1574         mtsp            t0, %sr1        /* Restore sr1 */
1575
1576         rfir
1577         nop
1578
1579 itlb_miss_20:
1580         get_pgd         spc,ptp
1581
1582         space_check     spc,t0,itlb_fault
1583
1584         L2_ptep         ptp,pte,t0,va,itlb_fault
1585
1586         update_ptep     ptp,pte,t0,t1
1587
1588         make_insert_tlb spc,pte,prot
1589
1590         f_extend        pte,t0
1591
1592         iitlbt          pte,prot
1593
1594         rfir
1595         nop
1596
1597 #endif
1598
1599 #ifdef __LP64__
1600
1601 dbit_trap_20w:
1602         space_adjust    spc,va,t0
1603         get_pgd         spc,ptp
1604         space_check     spc,t0,dbit_fault
1605
1606         L3_ptep         ptp,pte,t0,va,dbit_fault
1607
1608 #ifdef CONFIG_SMP
1609         CMPIB=,n        0,spc,dbit_nolock_20w
1610         ldil            L%PA(pa_dbit_lock),t0
1611         ldo             R%PA(pa_dbit_lock)(t0),t0
1612
1613 dbit_spin_20w:
1614         ldcw            0(t0),t1
1615         cmpib,=         0,t1,dbit_spin_20w
1616         nop
1617
1618 dbit_nolock_20w:
1619 #endif
1620         update_dirty    ptp,pte,t1
1621
1622         make_insert_tlb spc,pte,prot
1623
1624         idtlbt          pte,prot
1625 #ifdef CONFIG_SMP
1626         CMPIB=,n        0,spc,dbit_nounlock_20w
1627         ldi             1,t1
1628         stw             t1,0(t0)
1629
1630 dbit_nounlock_20w:
1631 #endif
1632
1633         rfir
1634         nop
1635 #else
1636
1637 dbit_trap_11:
1638
1639         get_pgd         spc,ptp
1640
1641         space_check     spc,t0,dbit_fault
1642
1643         L2_ptep         ptp,pte,t0,va,dbit_fault
1644
1645 #ifdef CONFIG_SMP
1646         CMPIB=,n        0,spc,dbit_nolock_11
1647         ldil            L%PA(pa_dbit_lock),t0
1648         ldo             R%PA(pa_dbit_lock)(t0),t0
1649
1650 dbit_spin_11:
1651         ldcw            0(t0),t1
1652         cmpib,=         0,t1,dbit_spin_11
1653         nop
1654
1655 dbit_nolock_11:
1656 #endif
1657         update_dirty    ptp,pte,t1
1658
1659         make_insert_tlb_11      spc,pte,prot
1660
1661         mfsp            %sr1,t1  /* Save sr1 so we can use it in tlb inserts */
1662         mtsp            spc,%sr1
1663
1664         idtlba          pte,(%sr1,va)
1665         idtlbp          prot,(%sr1,va)
1666
1667         mtsp            t1, %sr1     /* Restore sr1 */
1668 #ifdef CONFIG_SMP
1669         CMPIB=,n        0,spc,dbit_nounlock_11
1670         ldi             1,t1
1671         stw             t1,0(t0)
1672
1673 dbit_nounlock_11:
1674 #endif
1675
1676         rfir
1677         nop
1678
1679 dbit_trap_20:
1680         get_pgd         spc,ptp
1681
1682         space_check     spc,t0,dbit_fault
1683
1684         L2_ptep         ptp,pte,t0,va,dbit_fault
1685
1686 #ifdef CONFIG_SMP
1687         CMPIB=,n        0,spc,dbit_nolock_20
1688         ldil            L%PA(pa_dbit_lock),t0
1689         ldo             R%PA(pa_dbit_lock)(t0),t0
1690
1691 dbit_spin_20:
1692         ldcw            0(t0),t1
1693         cmpib,=         0,t1,dbit_spin_20
1694         nop
1695
1696 dbit_nolock_20:
1697 #endif
1698         update_dirty    ptp,pte,t1
1699
1700         make_insert_tlb spc,pte,prot
1701
1702         f_extend        pte,t1
1703
1704         idtlbt          pte,prot
1705
1706 #ifdef CONFIG_SMP
1707         CMPIB=,n        0,spc,dbit_nounlock_20
1708         ldi             1,t1
1709         stw             t1,0(t0)
1710
1711 dbit_nounlock_20:
1712 #endif
1713
1714         rfir
1715         nop
1716 #endif
1717
1718         .import handle_interruption,code
1719
1720 kernel_bad_space:
1721         b               intr_save
1722         ldi             31,%r8  /* Use an unused code */
1723
1724 dbit_fault:
1725         b               intr_save
1726         ldi             20,%r8
1727
1728 itlb_fault:
1729         b               intr_save
1730         ldi             6,%r8
1731
1732 nadtlb_fault:
1733         b               intr_save
1734         ldi             17,%r8
1735
1736 dtlb_fault:
1737         b               intr_save
1738         ldi             15,%r8
1739
1740         /* Register saving semantics for system calls:
1741
1742            %r1             clobbered by system call macro in userspace
1743            %r2             saved in PT_REGS by gateway page
1744            %r3  - %r18     preserved by C code (saved by signal code)
1745            %r19 - %r20     saved in PT_REGS by gateway page
1746            %r21 - %r22     non-standard syscall args
1747                            stored in kernel stack by gateway page
1748            %r23 - %r26     arg3-arg0, saved in PT_REGS by gateway page
1749            %r27 - %r30     saved in PT_REGS by gateway page
1750            %r31            syscall return pointer
1751          */
1752
1753         /* Floating point registers (FIXME: what do we do with these?)
1754
1755            %fr0  - %fr3    status/exception, not preserved
1756            %fr4  - %fr7    arguments
1757            %fr8  - %fr11   not preserved by C code
1758            %fr12 - %fr21   preserved by C code
1759            %fr22 - %fr31   not preserved by C code
1760          */
1761
1762         .macro  reg_save regs
1763         STREG   %r3, PT_GR3(\regs)
1764         STREG   %r4, PT_GR4(\regs)
1765         STREG   %r5, PT_GR5(\regs)
1766         STREG   %r6, PT_GR6(\regs)
1767         STREG   %r7, PT_GR7(\regs)
1768         STREG   %r8, PT_GR8(\regs)
1769         STREG   %r9, PT_GR9(\regs)
1770         STREG   %r10,PT_GR10(\regs)
1771         STREG   %r11,PT_GR11(\regs)
1772         STREG   %r12,PT_GR12(\regs)
1773         STREG   %r13,PT_GR13(\regs)
1774         STREG   %r14,PT_GR14(\regs)
1775         STREG   %r15,PT_GR15(\regs)
1776         STREG   %r16,PT_GR16(\regs)
1777         STREG   %r17,PT_GR17(\regs)
1778         STREG   %r18,PT_GR18(\regs)
1779         .endm
1780
1781         .macro  reg_restore regs
1782         LDREG   PT_GR3(\regs), %r3
1783         LDREG   PT_GR4(\regs), %r4
1784         LDREG   PT_GR5(\regs), %r5
1785         LDREG   PT_GR6(\regs), %r6
1786         LDREG   PT_GR7(\regs), %r7
1787         LDREG   PT_GR8(\regs), %r8
1788         LDREG   PT_GR9(\regs), %r9
1789         LDREG   PT_GR10(\regs),%r10
1790         LDREG   PT_GR11(\regs),%r11
1791         LDREG   PT_GR12(\regs),%r12
1792         LDREG   PT_GR13(\regs),%r13
1793         LDREG   PT_GR14(\regs),%r14
1794         LDREG   PT_GR15(\regs),%r15
1795         LDREG   PT_GR16(\regs),%r16
1796         LDREG   PT_GR17(\regs),%r17
1797         LDREG   PT_GR18(\regs),%r18
1798         .endm
1799
1800         .export sys_fork_wrapper
1801         .export child_return
1802 sys_fork_wrapper:
1803         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30), %r1
1804         ldo     TASK_REGS(%r1),%r1
1805         reg_save %r1
1806         mfctl   %cr27, %r3
1807         STREG   %r3, PT_CR27(%r1)
1808
1809         STREG   %r2,-RP_OFFSET(%r30)
1810         ldo     FRAME_SIZE(%r30),%r30
1811 #ifdef __LP64__
1812         ldo     -16(%r30),%r29          /* Reference param save area */
1813 #endif
1814
1815         /* These are call-clobbered registers and therefore
1816            also syscall-clobbered (we hope). */
1817         STREG   %r2,PT_GR19(%r1)        /* save for child */
1818         STREG   %r30,PT_GR21(%r1)
1819
1820         LDREG   PT_GR30(%r1),%r25
1821         copy    %r1,%r24
1822         BL      sys_clone,%r2
1823         ldi     SIGCHLD,%r26
1824
1825         LDREG   -RP_OFFSET-FRAME_SIZE(%r30),%r2
1826 wrapper_exit:
1827         ldo     -FRAME_SIZE(%r30),%r30          /* get the stackframe */
1828         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
1829         ldo     TASK_REGS(%r1),%r1       /* get pt regs */
1830
1831         LDREG   PT_CR27(%r1), %r3
1832         mtctl   %r3, %cr27
1833         reg_restore %r1
1834
1835         /* strace expects syscall # to be preserved in r20 */
1836         ldi     __NR_fork,%r20
1837         bv %r0(%r2)
1838         STREG   %r20,PT_GR20(%r1)
1839
1840         /* Set the return value for the child */
1841 child_return:
1842         BL      schedule_tail, %r2
1843         nop
1844
1845         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE-FRAME_SIZE(%r30), %r1
1846         LDREG   TASK_PT_GR19(%r1),%r2
1847         b       wrapper_exit
1848         copy    %r0,%r28
1849
1850
1851         .export sys_clone_wrapper
1852 sys_clone_wrapper:
1853         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
1854         ldo     TASK_REGS(%r1),%r1      /* get pt regs */
1855         reg_save %r1
1856         mfctl   %cr27, %r3
1857         STREG   %r3, PT_CR27(%r1)
1858
1859         STREG   %r2,-RP_OFFSET(%r30)
1860         ldo     FRAME_SIZE(%r30),%r30
1861 #ifdef __LP64__
1862         ldo     -16(%r30),%r29          /* Reference param save area */
1863 #endif
1864
1865         STREG   %r2,PT_GR19(%r1)        /* save for child */
1866         STREG   %r30,PT_GR21(%r1)
1867         BL      sys_clone,%r2
1868         copy    %r1,%r24
1869
1870         b       wrapper_exit
1871         LDREG   -RP_OFFSET-FRAME_SIZE(%r30),%r2
1872
1873         .export sys_vfork_wrapper
1874 sys_vfork_wrapper:
1875         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
1876         ldo     TASK_REGS(%r1),%r1      /* get pt regs */
1877         reg_save %r1
1878         mfctl   %cr27, %r3
1879         STREG   %r3, PT_CR27(%r1)
1880
1881         STREG   %r2,-RP_OFFSET(%r30)
1882         ldo     FRAME_SIZE(%r30),%r30
1883 #ifdef __LP64__
1884         ldo     -16(%r30),%r29          /* Reference param save area */
1885 #endif
1886
1887         STREG   %r2,PT_GR19(%r1)        /* save for child */
1888         STREG   %r30,PT_GR21(%r1)
1889
1890         BL      sys_vfork,%r2
1891         copy    %r1,%r26
1892
1893         b       wrapper_exit
1894         LDREG   -RP_OFFSET-FRAME_SIZE(%r30),%r2
1895
1896
1897         .macro  execve_wrapper execve
1898         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
1899         ldo     TASK_REGS(%r1),%r1      /* get pt regs */
1900
1901         /*
1902          * Do we need to save/restore r3-r18 here?
1903          * I don't think so. why would new thread need old
1904          * threads registers?
1905          */
1906
1907         /* %arg0 - %arg3 are already saved for us. */
1908
1909         STREG %r2,-RP_OFFSET(%r30)
1910         ldo FRAME_SIZE(%r30),%r30
1911 #ifdef __LP64__
1912         ldo     -16(%r30),%r29          /* Reference param save area */
1913 #endif
1914         bl \execve,%r2
1915         copy %r1,%arg0
1916
1917         ldo -FRAME_SIZE(%r30),%r30
1918         LDREG -RP_OFFSET(%r30),%r2
1919
1920         /* If exec succeeded we need to load the args */
1921
1922         ldo -1024(%r0),%r1
1923         cmpb,>>= %r28,%r1,error_\execve
1924         copy %r2,%r19
1925
1926 error_\execve:
1927         bv %r0(%r19)
1928         nop
1929         .endm
1930
1931         .export sys_execve_wrapper
1932         .import sys_execve
1933
1934 sys_execve_wrapper:
1935         execve_wrapper sys_execve
1936
1937 #ifdef __LP64__
1938         .export sys32_execve_wrapper
1939         .import sys32_execve
1940
1941 sys32_execve_wrapper:
1942         execve_wrapper sys32_execve
1943 #endif
1944
1945         .export sys_rt_sigreturn_wrapper
1946 sys_rt_sigreturn_wrapper:
1947         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r26
1948         ldo     TASK_REGS(%r26),%r26    /* get pt regs */
1949         /* Don't save regs, we are going to restore them from sigcontext. */
1950         STREG   %r2, -RP_OFFSET(%r30)
1951 #ifdef __LP64__
1952         ldo     FRAME_SIZE(%r30), %r30
1953         BL      sys_rt_sigreturn,%r2
1954         ldo     -16(%r30),%r29          /* Reference param save area */
1955 #else
1956         BL      sys_rt_sigreturn,%r2
1957         ldo     FRAME_SIZE(%r30), %r30
1958 #endif
1959
1960         ldo     -FRAME_SIZE(%r30), %r30
1961         LDREG   -RP_OFFSET(%r30), %r2
1962
1963         /* FIXME: I think we need to restore a few more things here. */
1964         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
1965         ldo     TASK_REGS(%r1),%r1      /* get pt regs */
1966         reg_restore %r1
1967
1968         /* If the signal was received while the process was blocked on a
1969          * syscall, then r2 will take us to syscall_exit; otherwise r2 will
1970          * take us to syscall_exit_rfi and on to intr_return.
1971          */
1972         bv      %r0(%r2)
1973         LDREG   PT_GR28(%r1),%r28  /* reload original r28 for syscall_exit */
1974
1975         .export sys_sigaltstack_wrapper
1976 sys_sigaltstack_wrapper:
1977         /* Get the user stack pointer */
1978         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
1979         ldo     TASK_REGS(%r1),%r24     /* get pt regs */
1980         LDREG   TASK_PT_GR30(%r24),%r24
1981         STREG   %r2, -RP_OFFSET(%r30)
1982 #ifdef __LP64__
1983         ldo     FRAME_SIZE(%r30), %r30
1984         b,l     do_sigaltstack,%r2
1985         ldo     -16(%r30),%r29          /* Reference param save area */
1986 #else
1987         bl      do_sigaltstack,%r2
1988         ldo     FRAME_SIZE(%r30), %r30
1989 #endif
1990
1991         ldo     -FRAME_SIZE(%r30), %r30
1992         LDREG   -RP_OFFSET(%r30), %r2
1993         bv      %r0(%r2)
1994         nop
1995
1996 #ifdef __LP64__
1997         .export sys32_sigaltstack_wrapper
1998 sys32_sigaltstack_wrapper:
1999         /* Get the user stack pointer */
2000         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r24
2001         LDREG   TASK_PT_GR30(%r24),%r24
2002         STREG   %r2, -RP_OFFSET(%r30)
2003         ldo     FRAME_SIZE(%r30), %r30
2004         b,l     do_sigaltstack32,%r2
2005         ldo     -16(%r30),%r29          /* Reference param save area */
2006
2007         ldo     -FRAME_SIZE(%r30), %r30
2008         LDREG   -RP_OFFSET(%r30), %r2
2009         bv      %r0(%r2)
2010         nop
2011 #endif
2012
2013         .export sys_rt_sigsuspend_wrapper
2014 sys_rt_sigsuspend_wrapper:
2015         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30), %r1
2016         ldo     TASK_REGS(%r1),%r24
2017         reg_save %r24
2018
2019         STREG   %r2, -RP_OFFSET(%r30)
2020 #ifdef __LP64__
2021         ldo     FRAME_SIZE(%r30), %r30
2022         b,l     sys_rt_sigsuspend,%r2
2023         ldo     -16(%r30),%r29          /* Reference param save area */
2024 #else
2025         bl      sys_rt_sigsuspend,%r2
2026         ldo     FRAME_SIZE(%r30), %r30
2027 #endif
2028
2029         ldo     -FRAME_SIZE(%r30), %r30
2030         LDREG   -RP_OFFSET(%r30), %r2
2031
2032         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30), %r1
2033         ldo     TASK_REGS(%r1),%r1
2034         reg_restore %r1
2035
2036         bv      %r0(%r2)
2037         nop
2038
2039         .export syscall_exit
2040 syscall_exit:
2041
2042         /* NOTE: HP-UX syscalls also come through here
2043          * after hpux_syscall_exit fixes up return
2044          * values. */
2045
2046         /* NOTE: Not all syscalls exit this way.  rt_sigreturn will exit
2047          * via syscall_exit_rfi if the signal was received while the process
2048          * was running.
2049          */
2050
2051         /* save return value now */
2052
2053         mfctl     %cr30, %r1
2054         LDREG     TI_TASK(%r1),%r1
2055         STREG     %r28,TASK_PT_GR28(%r1)
2056
2057 #ifdef CONFIG_HPUX
2058
2059 /* <linux/personality.h> cannot be easily included */
2060 #define PER_HPUX 0x10
2061         LDREG     TASK_PERSONALITY(%r1),%r19
2062
2063         /* We can't use "CMPIB<> PER_HPUX" since "im5" field is sign extended */
2064         ldo       -PER_HPUX(%r19), %r19
2065         CMPIB<>,n 0,%r19,1f
2066
2067         /* Save other hpux returns if personality is PER_HPUX */
2068         STREG     %r22,TASK_PT_GR22(%r1)
2069         STREG     %r29,TASK_PT_GR29(%r1)
2070 1:
2071
2072 #endif /* CONFIG_HPUX */
2073
2074         /* Seems to me that dp could be wrong here, if the syscall involved
2075          * calling a module, and nothing got round to restoring dp on return.
2076          */
2077         loadgp
2078
2079 syscall_check_bh:
2080
2081         /* Check for software interrupts */
2082
2083         .import irq_stat,data
2084
2085         ldil    L%irq_stat,%r19
2086         ldo     R%irq_stat(%r19),%r19
2087
2088 #ifdef CONFIG_SMP
2089         /* sched.h: int processor */
2090         /* %r26 is used as scratch register to index into irq_stat[] */
2091         ldw     TI_CPU-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r26 /* cpu # */
2092
2093         /* shift left ____cacheline_aligned (aka L1_CACHE_BYTES) bits */
2094 #ifdef __LP64__
2095         shld    %r26, 6, %r20
2096 #else
2097         shlw    %r26, 5, %r20
2098 #endif
2099         add     %r19,%r20,%r19  /* now have &irq_stat[smp_processor_id()] */
2100 #endif /* CONFIG_SMP */
2101
2102         LDREG   IRQSTAT_SIRQ_PEND(%r19),%r20    /* hardirq.h: unsigned long */
2103         cmpib,<>,n 0,%r20,syscall_do_softirq /* forward */
2104
2105 syscall_check_resched:
2106
2107         /* check for reschedule */
2108
2109         LDREG   TI_FLAGS-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r19   /* long */
2110         bb,<,n  %r19, 31-TIF_NEED_RESCHED, syscall_do_resched /* forward */
2111
2112 syscall_check_sig:
2113         LDREG   TI_FLAGS-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r19    /* get ti flags */
2114         bb,<,n  %r19, 31-TIF_SIGPENDING, syscall_do_signal /* forward */
2115
2116 syscall_restore:
2117         /* Are we being ptraced? */
2118         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
2119
2120         LDREG   TASK_PTRACE(%r1), %r19
2121         bb,<    %r19,31,syscall_restore_rfi
2122         nop
2123
2124         ldo     TASK_PT_FR31(%r1),%r19             /* reload fpregs */
2125         rest_fp %r19
2126
2127         LDREG   TASK_PT_SAR(%r1),%r19              /* restore SAR */
2128         mtsar   %r19
2129
2130         LDREG   TASK_PT_GR2(%r1),%r2               /* restore user rp */
2131         LDREG   TASK_PT_GR19(%r1),%r19
2132         LDREG   TASK_PT_GR20(%r1),%r20
2133         LDREG   TASK_PT_GR21(%r1),%r21
2134         LDREG   TASK_PT_GR22(%r1),%r22
2135         LDREG   TASK_PT_GR23(%r1),%r23
2136         LDREG   TASK_PT_GR24(%r1),%r24
2137         LDREG   TASK_PT_GR25(%r1),%r25
2138         LDREG   TASK_PT_GR26(%r1),%r26
2139         LDREG   TASK_PT_GR27(%r1),%r27     /* restore user dp */
2140         LDREG   TASK_PT_GR28(%r1),%r28     /* syscall return value */
2141         LDREG   TASK_PT_GR29(%r1),%r29
2142         LDREG   TASK_PT_GR31(%r1),%r31     /* restore syscall rp */
2143
2144         /* NOTE: We use rsm/ssm pair to make this operation atomic */
2145         rsm     PSW_SM_I, %r0
2146         LDREG   TASK_PT_GR30(%r1),%r30             /* restore user sp */
2147         mfsp    %sr3,%r1                           /* Get users space id */
2148         mtsp    %r1,%sr7                           /* Restore sr7 */
2149         ssm     PSW_SM_I, %r0
2150
2151         /* Set sr2 to zero for userspace syscalls to work. */
2152         mtsp    %r0,%sr2
2153         mtsp    %r1,%sr4                           /* Restore sr4 */
2154         mtsp    %r1,%sr5                           /* Restore sr5 */
2155         mtsp    %r1,%sr6                           /* Restore sr6 */
2156
2157         depi    3,31,2,%r31                        /* ensure return to user mode. */
2158
2159 #ifdef __LP64__
2160         /* decide whether to reset the wide mode bit
2161          *
2162          * For a syscall, the W bit is stored in the lowest bit
2163          * of sp.  Extract it and reset W if it is zero */
2164         extrd,u,*<>     %r30,63,1,%r1
2165         rsm     PSW_SM_W, %r0
2166         /* now reset the lowest bit of sp if it was set */
2167         xor     %r30,%r1,%r30
2168 #endif
2169         be,n    0(%sr3,%r31)                       /* return to user space */
2170
2171         /* We have to return via an RFI, so that PSW T and R bits can be set
2172          * appropriately.
2173          * This sets up pt_regs so we can return via intr_restore, which is not
2174          * the most efficient way of doing things, but it works.
2175          */
2176 syscall_restore_rfi:
2177         ldo     -1(%r0),%r2                        /* Set recovery cntr to -1 */
2178         mtctl   %r2,%cr0                           /*   for immediate trap */
2179         LDREG   TASK_PT_PSW(%r1),%r2               /* Get old PSW */
2180         ldi     0x0b,%r20                          /* Create new PSW */
2181         depi    -1,13,1,%r20                       /* C, Q, D, and I bits */
2182
2183         /* The values of PA_SINGLESTEP_BIT and PA_BLOCKSTEP_BIT are
2184          * set in include/linux/ptrace.h and converted to PA bitmap
2185          * numbers in asm-offsets.c */
2186
2187         /* if ((%r19.PA_SINGLESTEP_BIT)) { %r20.27=1} */
2188         extru,= %r19,PA_SINGLESTEP_BIT,1,%r0
2189         depi    -1,27,1,%r20                       /* R bit */
2190
2191         /* if ((%r19.PA_BLOCKSTEP_BIT)) { %r20.7=1} */
2192         extru,= %r19,PA_BLOCKSTEP_BIT,1,%r0
2193         depi    -1,7,1,%r20                        /* T bit */
2194
2195         STREG   %r20,TASK_PT_PSW(%r1)
2196
2197         /* Always store space registers, since sr3 can be changed (e.g. fork) */
2198
2199         mfsp    %sr3,%r25
2200         STREG   %r25,TASK_PT_SR3(%r1)
2201         STREG   %r25,TASK_PT_SR4(%r1)
2202         STREG   %r25,TASK_PT_SR5(%r1)
2203         STREG   %r25,TASK_PT_SR6(%r1)
2204         STREG   %r25,TASK_PT_SR7(%r1)
2205         STREG   %r25,TASK_PT_IASQ0(%r1)
2206         STREG   %r25,TASK_PT_IASQ1(%r1)
2207
2208         /* XXX W bit??? */
2209         /* Now if old D bit is clear, it means we didn't save all registers
2210          * on syscall entry, so do that now.  This only happens on TRACEME
2211          * calls, or if someone attached to us while we were on a syscall.
2212          * We could make this more efficient by not saving r3-r18, but
2213          * then we wouldn't be able to use the common intr_restore path.
2214          * It is only for traced processes anyway, so performance is not
2215          * an issue.
2216          */
2217         bb,<    %r2,30,pt_regs_ok                  /* Branch if D set */
2218         ldo     TASK_REGS(%r1),%r25
2219         reg_save %r25                              /* Save r3 to r18 */
2220
2221         /* Save the current sr */
2222         mfsp    %sr0,%r2
2223         STREG   %r2,TASK_PT_SR0(%r1)
2224
2225         /* Save the scratch sr */
2226         mfsp    %sr1,%r2
2227         STREG   %r2,TASK_PT_SR1(%r1)
2228
2229         /* sr2 should be set to zero for userspace syscalls */
2230         STREG   %r0,TASK_PT_SR2(%r1)
2231
2232 pt_regs_ok:
2233         LDREG   TASK_PT_GR31(%r1),%r2
2234         depi    3,31,2,%r2                         /* ensure return to user mode. */
2235         STREG   %r2,TASK_PT_IAOQ0(%r1)
2236         ldo     4(%r2),%r2
2237         STREG   %r2,TASK_PT_IAOQ1(%r1)
2238         copy    %r25,%r16
2239         b       intr_restore
2240         nop
2241
2242         .import do_softirq,code
2243 syscall_do_softirq:
2244         bl      do_softirq,%r2
2245         nop
2246         /* NOTE: We enable I-bit incase we schedule later,
2247          * and we might be going back to userspace if we were
2248          * traced. */
2249         b       syscall_check_resched
2250         ssm     PSW_SM_I, %r0  /* do_softirq returns with I bit off */
2251
2252         .import schedule,code
2253 syscall_do_resched:
2254         BL      schedule,%r2
2255 #ifdef __LP64__
2256         ldo     -16(%r30),%r29          /* Reference param save area */
2257 #else
2258         nop
2259 #endif
2260         b       syscall_check_bh  /* if resched, we start over again */
2261         nop
2262
2263         .import do_signal,code
2264 syscall_do_signal:
2265         /* Save callee-save registers (for sigcontext).
2266            FIXME: After this point the process structure should be
2267            consistent with all the relevant state of the process
2268            before the syscall.  We need to verify this. */
2269         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
2270         ldo     TASK_REGS(%r1), %r25            /* struct pt_regs *regs */
2271         reg_save %r25
2272
2273         ldi     1, %r24                         /* unsigned long in_syscall */
2274
2275 #ifdef __LP64__
2276         ldo     -16(%r30),%r29                  /* Reference param save area */
2277 #endif
2278         BL      do_signal,%r2
2279         copy    %r0, %r26                       /* sigset_t *oldset = NULL */
2280
2281         LDREG   TI_TASK-THREAD_SZ_ALGN-FRAME_SIZE(%r30),%r1
2282         ldo     TASK_REGS(%r1), %r20            /* reload pt_regs */
2283         reg_restore %r20
2284
2285         b,n     syscall_restore
2286
2287         /*
2288          * get_register is used by the non access tlb miss handlers to
2289          * copy the value of the general register specified in r8 into
2290          * r1. This routine can't be used for shadowed registers, since
2291          * the rfir will restore the original value. So, for the shadowed
2292          * registers we put a -1 into r1 to indicate that the register
2293          * should not be used (the register being copied could also have
2294          * a -1 in it, but that is OK, it just means that we will have
2295          * to use the slow path instead).
2296          */
2297
2298 get_register:
2299         blr     %r8,%r0
2300         nop
2301         bv      %r0(%r25)    /* r0 */
2302         copy    %r0,%r1
2303         bv      %r0(%r25)    /* r1 - shadowed */
2304         ldi     -1,%r1
2305         bv      %r0(%r25)    /* r2 */
2306         copy    %r2,%r1
2307         bv      %r0(%r25)    /* r3 */
2308         copy    %r3,%r1
2309         bv      %r0(%r25)    /* r4 */
2310         copy    %r4,%r1
2311         bv      %r0(%r25)    /* r5 */
2312         copy    %r5,%r1
2313         bv      %r0(%r25)    /* r6 */
2314         copy    %r6,%r1
2315         bv      %r0(%r25)    /* r7 */
2316         copy    %r7,%r1
2317         bv      %r0(%r25)    /* r8 - shadowed */
2318         ldi     -1,%r1
2319         bv      %r0(%r25)    /* r9 - shadowed */
2320         ldi     -1,%r1
2321         bv      %r0(%r25)    /* r10 */
2322         copy    %r10,%r1
2323         bv      %r0(%r25)    /* r11 */
2324         copy    %r11,%r1
2325         bv      %r0(%r25)    /* r12 */
2326         copy    %r12,%r1
2327         bv      %r0(%r25)    /* r13 */
2328         copy    %r13,%r1
2329         bv      %r0(%r25)    /* r14 */
2330         copy    %r14,%r1
2331         bv      %r0(%r25)    /* r15 */
2332         copy    %r15,%r1
2333         bv      %r0(%r25)    /* r16 - shadowed */
2334         ldi     -1,%r1
2335         bv      %r0(%r25)    /* r17 - shadowed */
2336         ldi     -1,%r1
2337         bv      %r0(%r25)    /* r18 */
2338         copy    %r18,%r1
2339         bv      %r0(%r25)    /* r19 */
2340         copy    %r19,%r1
2341         bv      %r0(%r25)    /* r20 */
2342         copy    %r20,%r1
2343         bv      %r0(%r25)    /* r21 */
2344         copy    %r21,%r1
2345         bv      %r0(%r25)    /* r22 */
2346         copy    %r22,%r1
2347         bv      %r0(%r25)    /* r23 */
2348         copy    %r23,%r1
2349         bv      %r0(%r25)    /* r24 - shadowed */
2350         ldi     -1,%r1
2351         bv      %r0(%r25)    /* r25 - shadowed */
2352         ldi     -1,%r1
2353         bv      %r0(%r25)    /* r26 */
2354         copy    %r26,%r1
2355         bv      %r0(%r25)    /* r27 */
2356         copy    %r27,%r1
2357         bv      %r0(%r25)    /* r28 */
2358         copy    %r28,%r1
2359         bv      %r0(%r25)    /* r29 */
2360         copy    %r29,%r1
2361         bv      %r0(%r25)    /* r30 */
2362         copy    %r30,%r1
2363         bv      %r0(%r25)    /* r31 */
2364         copy    %r31,%r1
2365
2366         /*
2367          * set_register is used by the non access tlb miss handlers to
2368          * copy the value of r1 into the general register specified in
2369          * r8.
2370          */
2371
2372 set_register:
2373         blr     %r8,%r0
2374         nop
2375         bv      %r0(%r25)    /* r0 (silly, but it is a place holder) */
2376         copy    %r1,%r0
2377         bv      %r0(%r25)    /* r1 */
2378         copy    %r1,%r1
2379         bv      %r0(%r25)    /* r2 */
2380         copy    %r1,%r2
2381         bv      %r0(%r25)    /* r3 */
2382         copy    %r1,%r3
2383         bv      %r0(%r25)    /* r4 */
2384         copy    %r1,%r4
2385         bv      %r0(%r25)    /* r5 */
2386         copy    %r1,%r5
2387         bv      %r0(%r25)    /* r6 */
2388         copy    %r1,%r6
2389         bv      %r0(%r25)    /* r7 */
2390         copy    %r1,%r7
2391         bv      %r0(%r25)    /* r8 */
2392         copy    %r1,%r8
2393         bv      %r0(%r25)    /* r9 */
2394         copy    %r1,%r9
2395         bv      %r0(%r25)    /* r10 */
2396         copy    %r1,%r10
2397         bv      %r0(%r25)    /* r11 */
2398         copy    %r1,%r11
2399         bv      %r0(%r25)    /* r12 */
2400         copy    %r1,%r12
2401         bv      %r0(%r25)    /* r13 */
2402         copy    %r1,%r13
2403         bv      %r0(%r25)    /* r14 */
2404         copy    %r1,%r14
2405         bv      %r0(%r25)    /* r15 */
2406         copy    %r1,%r15
2407         bv      %r0(%r25)    /* r16 */
2408         copy    %r1,%r16
2409         bv      %r0(%r25)    /* r17 */
2410         copy    %r1,%r17
2411         bv      %r0(%r25)    /* r18 */
2412         copy    %r1,%r18
2413         bv      %r0(%r25)    /* r19 */
2414         copy    %r1,%r19
2415         bv      %r0(%r25)    /* r20 */
2416         copy    %r1,%r20
2417         bv      %r0(%r25)    /* r21 */
2418         copy    %r1,%r21
2419         bv      %r0(%r25)    /* r22 */
2420         copy    %r1,%r22
2421         bv      %r0(%r25)    /* r23 */
2422         copy    %r1,%r23
2423         bv      %r0(%r25)    /* r24 */
2424         copy    %r1,%r24
2425         bv      %r0(%r25)    /* r25 */
2426         copy    %r1,%r25
2427         bv      %r0(%r25)    /* r26 */
2428         copy    %r1,%r26
2429         bv      %r0(%r25)    /* r27 */
2430         copy    %r1,%r27
2431         bv      %r0(%r25)    /* r28 */
2432         copy    %r1,%r28
2433         bv      %r0(%r25)    /* r29 */
2434         copy    %r1,%r29
2435         bv      %r0(%r25)    /* r30 */
2436         copy    %r1,%r30
2437         bv      %r0(%r25)    /* r31 */
2438         copy    %r1,%r31