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