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