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