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