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