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