This patch contains updated scripts to reduce qemu build time by
[kvmfornfv.git] / kernel / arch / xtensa / kernel / entry.S
1 /*
2  * Low-level exception handling
3  *
4  * This file is subject to the terms and conditions of the GNU General Public
5  * License.  See the file "COPYING" in the main directory of this archive
6  * for more details.
7  *
8  * Copyright (C) 2004 - 2008 by Tensilica Inc.
9  * Copyright (C) 2015 Cadence Design Systems Inc.
10  *
11  * Chris Zankel <chris@zankel.net>
12  *
13  */
14
15 #include <linux/linkage.h>
16 #include <asm/asm-offsets.h>
17 #include <asm/processor.h>
18 #include <asm/coprocessor.h>
19 #include <asm/thread_info.h>
20 #include <asm/uaccess.h>
21 #include <asm/unistd.h>
22 #include <asm/ptrace.h>
23 #include <asm/current.h>
24 #include <asm/pgtable.h>
25 #include <asm/page.h>
26 #include <asm/signal.h>
27 #include <asm/tlbflush.h>
28 #include <variant/tie-asm.h>
29
30 /* Unimplemented features. */
31
32 #undef KERNEL_STACK_OVERFLOW_CHECK
33
34 /* Not well tested.
35  *
36  * - fast_coprocessor
37  */
38
39 /*
40  * Macro to find first bit set in WINDOWBASE from the left + 1
41  *
42  * 100....0 -> 1
43  * 010....0 -> 2
44  * 000....1 -> WSBITS
45  */
46
47         .macro ffs_ws bit mask
48
49 #if XCHAL_HAVE_NSA
50         nsau    \bit, \mask                     # 32-WSBITS ... 31 (32 iff 0)
51         addi    \bit, \bit, WSBITS - 32 + 1     # uppest bit set -> return 1
52 #else
53         movi    \bit, WSBITS
54 #if WSBITS > 16
55         _bltui  \mask, 0x10000, 99f
56         addi    \bit, \bit, -16
57         extui   \mask, \mask, 16, 16
58 #endif
59 #if WSBITS > 8
60 99:     _bltui  \mask, 0x100, 99f
61         addi    \bit, \bit, -8
62         srli    \mask, \mask, 8
63 #endif
64 99:     _bltui  \mask, 0x10, 99f
65         addi    \bit, \bit, -4
66         srli    \mask, \mask, 4
67 99:     _bltui  \mask, 0x4, 99f
68         addi    \bit, \bit, -2
69         srli    \mask, \mask, 2
70 99:     _bltui  \mask, 0x2, 99f
71         addi    \bit, \bit, -1
72 99:
73
74 #endif
75         .endm
76
77
78         .macro  irq_save flags tmp
79 #if XTENSA_FAKE_NMI
80 #if defined(CONFIG_DEBUG_KERNEL) && (LOCKLEVEL | TOPLEVEL) >= XCHAL_DEBUGLEVEL
81         rsr     \flags, ps
82         extui   \tmp, \flags, PS_INTLEVEL_SHIFT, PS_INTLEVEL_WIDTH
83         bgei    \tmp, LOCKLEVEL, 99f
84         rsil    \tmp, LOCKLEVEL
85 99:
86 #else
87         movi    \tmp, LOCKLEVEL
88         rsr     \flags, ps
89         or      \flags, \flags, \tmp
90         xsr     \flags, ps
91         rsync
92 #endif
93 #else
94         rsil    \flags, LOCKLEVEL
95 #endif
96         .endm
97
98 /* ----------------- DEFAULT FIRST LEVEL EXCEPTION HANDLERS ----------------- */
99
100 /*
101  * First-level exception handler for user exceptions.
102  * Save some special registers, extra states and all registers in the AR
103  * register file that were in use in the user task, and jump to the common
104  * exception code.
105  * We save SAR (used to calculate WMASK), and WB and WS (we don't have to
106  * save them for kernel exceptions).
107  *
108  * Entry condition for user_exception:
109  *
110  *   a0:        trashed, original value saved on stack (PT_AREG0)
111  *   a1:        a1
112  *   a2:        new stack pointer, original value in depc
113  *   a3:        a3
114  *   depc:      a2, original value saved on stack (PT_DEPC)
115  *   excsave1:  dispatch table
116  *
117  *   PT_DEPC >= VALID_DOUBLE_EXCEPTION_ADDRESS: double exception, DEPC
118  *           <  VALID_DOUBLE_EXCEPTION_ADDRESS: regular exception
119  *
120  * Entry condition for _user_exception:
121  *
122  *   a0-a3 and depc have been saved to PT_AREG0...PT_AREG3 and PT_DEPC
123  *   excsave has been restored, and
124  *   stack pointer (a1) has been set.
125  *
126  * Note: _user_exception might be at an odd address. Don't use call0..call12
127  */
128
129 ENTRY(user_exception)
130
131         /* Save a1, a2, a3, and set SP. */
132
133         rsr     a0, depc
134         s32i    a1, a2, PT_AREG1
135         s32i    a0, a2, PT_AREG2
136         s32i    a3, a2, PT_AREG3
137         mov     a1, a2
138
139         .globl _user_exception
140 _user_exception:
141
142         /* Save SAR and turn off single stepping */
143
144         movi    a2, 0
145         wsr     a2, depc                # terminate user stack trace with 0
146         rsr     a3, sar
147         xsr     a2, icountlevel
148         s32i    a3, a1, PT_SAR
149         s32i    a2, a1, PT_ICOUNTLEVEL
150
151 #if XCHAL_HAVE_THREADPTR
152         rur     a2, threadptr
153         s32i    a2, a1, PT_THREADPTR
154 #endif
155
156         /* Rotate ws so that the current windowbase is at bit0. */
157         /* Assume ws = xxwww1yyyy. Rotate ws right, so that a2 = yyyyxxwww1 */
158
159         rsr     a2, windowbase
160         rsr     a3, windowstart
161         ssr     a2
162         s32i    a2, a1, PT_WINDOWBASE
163         s32i    a3, a1, PT_WINDOWSTART
164         slli    a2, a3, 32-WSBITS
165         src     a2, a3, a2
166         srli    a2, a2, 32-WSBITS
167         s32i    a2, a1, PT_WMASK        # needed for restoring registers
168
169         /* Save only live registers. */
170
171         _bbsi.l a2, 1, 1f
172         s32i    a4, a1, PT_AREG4
173         s32i    a5, a1, PT_AREG5
174         s32i    a6, a1, PT_AREG6
175         s32i    a7, a1, PT_AREG7
176         _bbsi.l a2, 2, 1f
177         s32i    a8, a1, PT_AREG8
178         s32i    a9, a1, PT_AREG9
179         s32i    a10, a1, PT_AREG10
180         s32i    a11, a1, PT_AREG11
181         _bbsi.l a2, 3, 1f
182         s32i    a12, a1, PT_AREG12
183         s32i    a13, a1, PT_AREG13
184         s32i    a14, a1, PT_AREG14
185         s32i    a15, a1, PT_AREG15
186         _bnei   a2, 1, 1f               # only one valid frame?
187
188         /* Only one valid frame, skip saving regs. */
189
190         j       2f
191
192         /* Save the remaining registers.
193          * We have to save all registers up to the first '1' from
194          * the right, except the current frame (bit 0).
195          * Assume a2 is:  001001000110001
196          * All register frames starting from the top field to the marked '1'
197          * must be saved.
198          */
199
200 1:      addi    a3, a2, -1              # eliminate '1' in bit 0: yyyyxxww0
201         neg     a3, a3                  # yyyyxxww0 -> YYYYXXWW1+1
202         and     a3, a3, a2              # max. only one bit is set
203
204         /* Find number of frames to save */
205
206         ffs_ws  a0, a3                  # number of frames to the '1' from left
207
208         /* Store information into WMASK:
209          * bits 0..3: xxx1 masked lower 4 bits of the rotated windowstart,
210          * bits 4...: number of valid 4-register frames
211          */
212
213         slli    a3, a0, 4               # number of frames to save in bits 8..4
214         extui   a2, a2, 0, 4            # mask for the first 16 registers
215         or      a2, a3, a2
216         s32i    a2, a1, PT_WMASK        # needed when we restore the reg-file
217
218         /* Save 4 registers at a time */
219
220 1:      rotw    -1
221         s32i    a0, a5, PT_AREG_END - 16
222         s32i    a1, a5, PT_AREG_END - 12
223         s32i    a2, a5, PT_AREG_END - 8
224         s32i    a3, a5, PT_AREG_END - 4
225         addi    a0, a4, -1
226         addi    a1, a5, -16
227         _bnez   a0, 1b
228
229         /* WINDOWBASE still in SAR! */
230
231         rsr     a2, sar                 # original WINDOWBASE
232         movi    a3, 1
233         ssl     a2
234         sll     a3, a3
235         wsr     a3, windowstart         # set corresponding WINDOWSTART bit
236         wsr     a2, windowbase          # and WINDOWSTART
237         rsync
238
239         /* We are back to the original stack pointer (a1) */
240
241 2:      /* Now, jump to the common exception handler. */
242
243         j       common_exception
244
245 ENDPROC(user_exception)
246
247 /*
248  * First-level exit handler for kernel exceptions
249  * Save special registers and the live window frame.
250  * Note: Even though we changes the stack pointer, we don't have to do a
251  *       MOVSP here, as we do that when we return from the exception.
252  *       (See comment in the kernel exception exit code)
253  *
254  * Entry condition for kernel_exception:
255  *
256  *   a0:        trashed, original value saved on stack (PT_AREG0)
257  *   a1:        a1
258  *   a2:        new stack pointer, original in DEPC
259  *   a3:        a3
260  *   depc:      a2, original value saved on stack (PT_DEPC)
261  *   excsave_1: dispatch table
262  *
263  *   PT_DEPC >= VALID_DOUBLE_EXCEPTION_ADDRESS: double exception, DEPC
264  *           <  VALID_DOUBLE_EXCEPTION_ADDRESS: regular exception
265  *
266  * Entry condition for _kernel_exception:
267  *
268  *   a0-a3 and depc have been saved to PT_AREG0...PT_AREG3 and PT_DEPC
269  *   excsave has been restored, and
270  *   stack pointer (a1) has been set.
271  *
272  * Note: _kernel_exception might be at an odd address. Don't use call0..call12
273  */
274
275 ENTRY(kernel_exception)
276
277         /* Save a1, a2, a3, and set SP. */
278
279         rsr     a0, depc                # get a2
280         s32i    a1, a2, PT_AREG1
281         s32i    a0, a2, PT_AREG2
282         s32i    a3, a2, PT_AREG3
283         mov     a1, a2
284
285         .globl _kernel_exception
286 _kernel_exception:
287
288         /* Save SAR and turn off single stepping */
289
290         movi    a2, 0
291         rsr     a3, sar
292         xsr     a2, icountlevel
293         s32i    a3, a1, PT_SAR
294         s32i    a2, a1, PT_ICOUNTLEVEL
295
296         /* Rotate ws so that the current windowbase is at bit0. */
297         /* Assume ws = xxwww1yyyy. Rotate ws right, so that a2 = yyyyxxwww1 */
298
299         rsr     a2, windowbase          # don't need to save these, we only
300         rsr     a3, windowstart         # need shifted windowstart: windowmask
301         ssr     a2
302         slli    a2, a3, 32-WSBITS
303         src     a2, a3, a2
304         srli    a2, a2, 32-WSBITS
305         s32i    a2, a1, PT_WMASK        # needed for kernel_exception_exit
306
307         /* Save only the live window-frame */
308
309         _bbsi.l a2, 1, 1f
310         s32i    a4, a1, PT_AREG4
311         s32i    a5, a1, PT_AREG5
312         s32i    a6, a1, PT_AREG6
313         s32i    a7, a1, PT_AREG7
314         _bbsi.l a2, 2, 1f
315         s32i    a8, a1, PT_AREG8
316         s32i    a9, a1, PT_AREG9
317         s32i    a10, a1, PT_AREG10
318         s32i    a11, a1, PT_AREG11
319         _bbsi.l a2, 3, 1f
320         s32i    a12, a1, PT_AREG12
321         s32i    a13, a1, PT_AREG13
322         s32i    a14, a1, PT_AREG14
323         s32i    a15, a1, PT_AREG15
324
325         _bnei   a2, 1, 1f
326
327         /* Copy spill slots of a0 and a1 to imitate movsp
328          * in order to keep exception stack continuous
329          */
330         l32i    a3, a1, PT_SIZE
331         l32i    a0, a1, PT_SIZE + 4
332         s32e    a3, a1, -16
333         s32e    a0, a1, -12
334 1:
335         l32i    a0, a1, PT_AREG0        # restore saved a0
336         wsr     a0, depc
337
338 #ifdef KERNEL_STACK_OVERFLOW_CHECK
339
340         /*  Stack overflow check, for debugging  */
341         extui   a2, a1, TASK_SIZE_BITS,XX
342         movi    a3, SIZE??
343         _bge    a2, a3, out_of_stack_panic
344
345 #endif
346
347 /*
348  * This is the common exception handler.
349  * We get here from the user exception handler or simply by falling through
350  * from the kernel exception handler.
351  * Save the remaining special registers, switch to kernel mode, and jump
352  * to the second-level exception handler.
353  *
354  */
355
356 common_exception:
357
358         /* Save some registers, disable loops and clear the syscall flag. */
359
360         rsr     a2, debugcause
361         rsr     a3, epc1
362         s32i    a2, a1, PT_DEBUGCAUSE
363         s32i    a3, a1, PT_PC
364
365         movi    a2, -1
366         rsr     a3, excvaddr
367         s32i    a2, a1, PT_SYSCALL
368         movi    a2, 0
369         s32i    a3, a1, PT_EXCVADDR
370 #if XCHAL_HAVE_LOOPS
371         xsr     a2, lcount
372         s32i    a2, a1, PT_LCOUNT
373 #endif
374
375         /* It is now save to restore the EXC_TABLE_FIXUP variable. */
376
377         rsr     a2, exccause
378         movi    a3, 0
379         rsr     a0, excsave1
380         s32i    a2, a1, PT_EXCCAUSE
381         s32i    a3, a0, EXC_TABLE_FIXUP
382
383         /* All unrecoverable states are saved on stack, now, and a1 is valid.
384          * Now we can allow exceptions again. In case we've got an interrupt
385          * PS.INTLEVEL is set to LOCKLEVEL disabling furhter interrupts,
386          * otherwise it's left unchanged.
387          *
388          * Set PS(EXCM = 0, UM = 0, RING = 0, OWB = 0, WOE = 1, INTLEVEL = X)
389          */
390
391         rsr     a3, ps
392         s32i    a3, a1, PT_PS           # save ps
393
394 #if XTENSA_FAKE_NMI
395         /* Correct PS needs to be saved in the PT_PS:
396          * - in case of exception or level-1 interrupt it's in the PS,
397          *   and is already saved.
398          * - in case of medium level interrupt it's in the excsave2.
399          */
400         movi    a0, EXCCAUSE_MAPPED_NMI
401         extui   a3, a3, PS_INTLEVEL_SHIFT, PS_INTLEVEL_WIDTH
402         beq     a2, a0, .Lmedium_level_irq
403         bnei    a2, EXCCAUSE_LEVEL1_INTERRUPT, .Lexception
404         beqz    a3, .Llevel1_irq        # level-1 IRQ sets ps.intlevel to 0
405
406 .Lmedium_level_irq:
407         rsr     a0, excsave2
408         s32i    a0, a1, PT_PS           # save medium-level interrupt ps
409         bgei    a3, LOCKLEVEL, .Lexception
410
411 .Llevel1_irq:
412         movi    a3, LOCKLEVEL
413
414 .Lexception:
415         movi    a0, 1 << PS_WOE_BIT
416         or      a3, a3, a0
417 #else
418         addi    a2, a2, -EXCCAUSE_LEVEL1_INTERRUPT
419         movi    a0, LOCKLEVEL
420         extui   a3, a3, PS_INTLEVEL_SHIFT, PS_INTLEVEL_WIDTH
421                                         # a3 = PS.INTLEVEL
422         moveqz  a3, a0, a2              # a3 = LOCKLEVEL iff interrupt
423         movi    a2, 1 << PS_WOE_BIT
424         or      a3, a3, a2
425         rsr     a2, exccause
426 #endif
427
428         /* restore return address (or 0 if return to userspace) */
429         rsr     a0, depc
430         wsr     a3, ps
431         rsync                           # PS.WOE => rsync => overflow
432
433         /* Save lbeg, lend */
434 #if XCHAL_HAVE_LOOPS
435         rsr     a4, lbeg
436         rsr     a3, lend
437         s32i    a4, a1, PT_LBEG
438         s32i    a3, a1, PT_LEND
439 #endif
440
441         /* Save SCOMPARE1 */
442
443 #if XCHAL_HAVE_S32C1I
444         rsr     a3, scompare1
445         s32i    a3, a1, PT_SCOMPARE1
446 #endif
447
448         /* Save optional registers. */
449
450         save_xtregs_opt a1 a3 a4 a5 a6 a7 PT_XTREGS_OPT
451         
452         /* Go to second-level dispatcher. Set up parameters to pass to the
453          * exception handler and call the exception handler.
454          */
455
456         rsr     a4, excsave1
457         mov     a6, a1                  # pass stack frame
458         mov     a7, a2                  # pass EXCCAUSE
459         addx4   a4, a2, a4
460         l32i    a4, a4, EXC_TABLE_DEFAULT               # load handler
461
462         /* Call the second-level handler */
463
464         callx4  a4
465
466         /* Jump here for exception exit */
467         .global common_exception_return
468 common_exception_return:
469
470 #if XTENSA_FAKE_NMI
471         l32i    a2, a1, PT_EXCCAUSE
472         movi    a3, EXCCAUSE_MAPPED_NMI
473         beq     a2, a3, .LNMIexit
474 #endif
475 1:
476         irq_save a2, a3
477 #ifdef CONFIG_TRACE_IRQFLAGS
478         movi    a4, trace_hardirqs_off
479         callx4  a4
480 #endif
481
482         /* Jump if we are returning from kernel exceptions. */
483
484         l32i    a3, a1, PT_PS
485         GET_THREAD_INFO(a2, a1)
486         l32i    a4, a2, TI_FLAGS
487         _bbci.l a3, PS_UM_BIT, 6f
488
489         /* Specific to a user exception exit:
490          * We need to check some flags for signal handling and rescheduling,
491          * and have to restore WB and WS, extra states, and all registers
492          * in the register file that were in use in the user task.
493          * Note that we don't disable interrupts here. 
494          */
495
496         _bbsi.l a4, TIF_NEED_RESCHED, 3f
497         _bbsi.l a4, TIF_NOTIFY_RESUME, 2f
498         _bbci.l a4, TIF_SIGPENDING, 5f
499
500 2:      l32i    a4, a1, PT_DEPC
501         bgeui   a4, VALID_DOUBLE_EXCEPTION_ADDRESS, 4f
502
503         /* Call do_signal() */
504
505 #ifdef CONFIG_TRACE_IRQFLAGS
506         movi    a4, trace_hardirqs_on
507         callx4  a4
508 #endif
509         rsil    a2, 0
510         movi    a4, do_notify_resume    # int do_notify_resume(struct pt_regs*)
511         mov     a6, a1
512         callx4  a4
513         j       1b
514
515 3:      /* Reschedule */
516
517 #ifdef CONFIG_TRACE_IRQFLAGS
518         movi    a4, trace_hardirqs_on
519         callx4  a4
520 #endif
521         rsil    a2, 0
522         movi    a4, schedule    # void schedule (void)
523         callx4  a4
524         j       1b
525
526 #ifdef CONFIG_PREEMPT
527 6:
528         _bbci.l a4, TIF_NEED_RESCHED, 4f
529
530         /* Check current_thread_info->preempt_count */
531
532         l32i    a4, a2, TI_PRE_COUNT
533         bnez    a4, 4f
534         movi    a4, preempt_schedule_irq
535         callx4  a4
536         j       1b
537 #endif
538
539 #if XTENSA_FAKE_NMI
540 .LNMIexit:
541         l32i    a3, a1, PT_PS
542         _bbci.l a3, PS_UM_BIT, 4f
543 #endif
544
545 5:
546 #ifdef CONFIG_DEBUG_TLB_SANITY
547         l32i    a4, a1, PT_DEPC
548         bgeui   a4, VALID_DOUBLE_EXCEPTION_ADDRESS, 4f
549         movi    a4, check_tlb_sanity
550         callx4  a4
551 #endif
552 6:
553 4:
554 #ifdef CONFIG_TRACE_IRQFLAGS
555         extui   a4, a3, PS_INTLEVEL_SHIFT, PS_INTLEVEL_WIDTH
556         bgei    a4, LOCKLEVEL, 1f
557         movi    a4, trace_hardirqs_on
558         callx4  a4
559 1:
560 #endif
561         /* Restore optional registers. */
562
563         load_xtregs_opt a1 a2 a4 a5 a6 a7 PT_XTREGS_OPT
564
565         /* Restore SCOMPARE1 */
566
567 #if XCHAL_HAVE_S32C1I
568         l32i    a2, a1, PT_SCOMPARE1
569         wsr     a2, scompare1
570 #endif
571         wsr     a3, ps          /* disable interrupts */
572
573         _bbci.l a3, PS_UM_BIT, kernel_exception_exit
574
575 user_exception_exit:
576
577         /* Restore the state of the task and return from the exception. */
578
579         /* Switch to the user thread WINDOWBASE. Save SP temporarily in DEPC */
580
581         l32i    a2, a1, PT_WINDOWBASE
582         l32i    a3, a1, PT_WINDOWSTART
583         wsr     a1, depc                # use DEPC as temp storage
584         wsr     a3, windowstart         # restore WINDOWSTART
585         ssr     a2                      # preserve user's WB in the SAR
586         wsr     a2, windowbase          # switch to user's saved WB
587         rsync
588         rsr     a1, depc                # restore stack pointer
589         l32i    a2, a1, PT_WMASK        # register frames saved (in bits 4...9)
590         rotw    -1                      # we restore a4..a7
591         _bltui  a6, 16, 1f              # only have to restore current window?
592
593         /* The working registers are a0 and a3.  We are restoring to
594          * a4..a7.  Be careful not to destroy what we have just restored.
595          * Note: wmask has the format YYYYM:
596          *       Y: number of registers saved in groups of 4
597          *       M: 4 bit mask of first 16 registers
598          */
599
600         mov     a2, a6
601         mov     a3, a5
602
603 2:      rotw    -1                      # a0..a3 become a4..a7
604         addi    a3, a7, -4*4            # next iteration
605         addi    a2, a6, -16             # decrementing Y in WMASK
606         l32i    a4, a3, PT_AREG_END + 0
607         l32i    a5, a3, PT_AREG_END + 4
608         l32i    a6, a3, PT_AREG_END + 8
609         l32i    a7, a3, PT_AREG_END + 12
610         _bgeui  a2, 16, 2b
611
612         /* Clear unrestored registers (don't leak anything to user-land */
613
614 1:      rsr     a0, windowbase
615         rsr     a3, sar
616         sub     a3, a0, a3
617         beqz    a3, 2f
618         extui   a3, a3, 0, WBBITS
619
620 1:      rotw    -1
621         addi    a3, a7, -1
622         movi    a4, 0
623         movi    a5, 0
624         movi    a6, 0
625         movi    a7, 0
626         bgei    a3, 1, 1b
627
628         /* We are back were we were when we started.
629          * Note: a2 still contains WMASK (if we've returned to the original
630          *       frame where we had loaded a2), or at least the lower 4 bits
631          *       (if we have restored WSBITS-1 frames).
632          */
633
634 2:
635 #if XCHAL_HAVE_THREADPTR
636         l32i    a3, a1, PT_THREADPTR
637         wur     a3, threadptr
638 #endif
639
640         j       common_exception_exit
641
642         /* This is the kernel exception exit.
643          * We avoided to do a MOVSP when we entered the exception, but we
644          * have to do it here.
645          */
646
647 kernel_exception_exit:
648
649         /* Check if we have to do a movsp.
650          *
651          * We only have to do a movsp if the previous window-frame has
652          * been spilled to the *temporary* exception stack instead of the
653          * task's stack. This is the case if the corresponding bit in
654          * WINDOWSTART for the previous window-frame was set before
655          * (not spilled) but is zero now (spilled).
656          * If this bit is zero, all other bits except the one for the
657          * current window frame are also zero. So, we can use a simple test:
658          * 'and' WINDOWSTART and WINDOWSTART-1:
659          *
660          *  (XXXXXX1[0]* - 1) AND XXXXXX1[0]* = XXXXXX0[0]*
661          *
662          * The result is zero only if one bit was set.
663          *
664          * (Note: We might have gone through several task switches before
665          *        we come back to the current task, so WINDOWBASE might be
666          *        different from the time the exception occurred.)
667          */
668
669         /* Test WINDOWSTART before and after the exception.
670          * We actually have WMASK, so we only have to test if it is 1 or not.
671          */
672
673         l32i    a2, a1, PT_WMASK
674         _beqi   a2, 1, common_exception_exit    # Spilled before exception,jump
675
676         /* Test WINDOWSTART now. If spilled, do the movsp */
677
678         rsr     a3, windowstart
679         addi    a0, a3, -1
680         and     a3, a3, a0
681         _bnez   a3, common_exception_exit
682
683         /* Do a movsp (we returned from a call4, so we have at least a0..a7) */
684
685         addi    a0, a1, -16
686         l32i    a3, a0, 0
687         l32i    a4, a0, 4
688         s32i    a3, a1, PT_SIZE+0
689         s32i    a4, a1, PT_SIZE+4
690         l32i    a3, a0, 8
691         l32i    a4, a0, 12
692         s32i    a3, a1, PT_SIZE+8
693         s32i    a4, a1, PT_SIZE+12
694
695         /* Common exception exit.
696          * We restore the special register and the current window frame, and
697          * return from the exception.
698          *
699          * Note: We expect a2 to hold PT_WMASK
700          */
701
702 common_exception_exit:
703
704         /* Restore address registers. */
705
706         _bbsi.l a2, 1, 1f
707         l32i    a4,  a1, PT_AREG4
708         l32i    a5,  a1, PT_AREG5
709         l32i    a6,  a1, PT_AREG6
710         l32i    a7,  a1, PT_AREG7
711         _bbsi.l a2, 2, 1f
712         l32i    a8,  a1, PT_AREG8
713         l32i    a9,  a1, PT_AREG9
714         l32i    a10, a1, PT_AREG10
715         l32i    a11, a1, PT_AREG11
716         _bbsi.l a2, 3, 1f
717         l32i    a12, a1, PT_AREG12
718         l32i    a13, a1, PT_AREG13
719         l32i    a14, a1, PT_AREG14
720         l32i    a15, a1, PT_AREG15
721
722         /* Restore PC, SAR */
723
724 1:      l32i    a2, a1, PT_PC
725         l32i    a3, a1, PT_SAR
726         wsr     a2, epc1
727         wsr     a3, sar
728
729         /* Restore LBEG, LEND, LCOUNT */
730 #if XCHAL_HAVE_LOOPS
731         l32i    a2, a1, PT_LBEG
732         l32i    a3, a1, PT_LEND
733         wsr     a2, lbeg
734         l32i    a2, a1, PT_LCOUNT
735         wsr     a3, lend
736         wsr     a2, lcount
737 #endif
738
739         /* We control single stepping through the ICOUNTLEVEL register. */
740
741         l32i    a2, a1, PT_ICOUNTLEVEL
742         movi    a3, -2
743         wsr     a2, icountlevel
744         wsr     a3, icount
745
746         /* Check if it was double exception. */
747
748         l32i    a0, a1, PT_DEPC
749         l32i    a3, a1, PT_AREG3
750         l32i    a2, a1, PT_AREG2
751         _bgeui  a0, VALID_DOUBLE_EXCEPTION_ADDRESS, 1f
752
753         /* Restore a0...a3 and return */
754
755         l32i    a0, a1, PT_AREG0
756         l32i    a1, a1, PT_AREG1
757         rfe
758
759 1:      wsr     a0, depc
760         l32i    a0, a1, PT_AREG0
761         l32i    a1, a1, PT_AREG1
762         rfde
763
764 ENDPROC(kernel_exception)
765
766 /*
767  * Debug exception handler.
768  *
769  * Currently, we don't support KGDB, so only user application can be debugged.
770  *
771  * When we get here,  a0 is trashed and saved to excsave[debuglevel]
772  */
773
774 ENTRY(debug_exception)
775
776         rsr     a0, SREG_EPS + XCHAL_DEBUGLEVEL
777         bbsi.l  a0, PS_EXCM_BIT, 1f     # exception mode
778
779         /* Set EPC1 and EXCCAUSE */
780
781         wsr     a2, depc                # save a2 temporarily
782         rsr     a2, SREG_EPC + XCHAL_DEBUGLEVEL
783         wsr     a2, epc1
784
785         movi    a2, EXCCAUSE_MAPPED_DEBUG
786         wsr     a2, exccause
787
788         /* Restore PS to the value before the debug exc but with PS.EXCM set.*/
789
790         movi    a2, 1 << PS_EXCM_BIT
791         or      a2, a0, a2
792         movi    a0, debug_exception     # restore a3, debug jump vector
793         wsr     a2, ps
794         xsr     a0, SREG_EXCSAVE + XCHAL_DEBUGLEVEL
795
796         /* Switch to kernel/user stack, restore jump vector, and save a0 */
797
798         bbsi.l  a2, PS_UM_BIT, 2f       # jump if user mode
799
800         addi    a2, a1, -16-PT_SIZE     # assume kernel stack
801         s32i    a0, a2, PT_AREG0
802         movi    a0, 0
803         s32i    a1, a2, PT_AREG1
804         s32i    a0, a2, PT_DEPC         # mark it as a regular exception
805         xsr     a0, depc
806         s32i    a3, a2, PT_AREG3
807         s32i    a0, a2, PT_AREG2
808         mov     a1, a2
809         j       _kernel_exception
810
811 2:      rsr     a2, excsave1
812         l32i    a2, a2, EXC_TABLE_KSTK  # load kernel stack pointer
813         s32i    a0, a2, PT_AREG0
814         movi    a0, 0
815         s32i    a1, a2, PT_AREG1
816         s32i    a0, a2, PT_DEPC
817         xsr     a0, depc
818         s32i    a3, a2, PT_AREG3
819         s32i    a0, a2, PT_AREG2
820         mov     a1, a2
821         j       _user_exception
822
823         /* Debug exception while in exception mode. */
824 1:      j       1b      // FIXME!!
825
826 ENDPROC(debug_exception)
827
828 /*
829  * We get here in case of an unrecoverable exception.
830  * The only thing we can do is to be nice and print a panic message.
831  * We only produce a single stack frame for panic, so ???
832  *
833  *
834  * Entry conditions:
835  *
836  *   - a0 contains the caller address; original value saved in excsave1.
837  *   - the original a0 contains a valid return address (backtrace) or 0.
838  *   - a2 contains a valid stackpointer
839  *
840  * Notes:
841  *
842  *   - If the stack pointer could be invalid, the caller has to setup a
843  *     dummy stack pointer (e.g. the stack of the init_task)
844  *
845  *   - If the return address could be invalid, the caller has to set it
846  *     to 0, so the backtrace would stop.
847  *
848  */
849         .align 4
850 unrecoverable_text:
851         .ascii "Unrecoverable error in exception handler\0"
852
853 ENTRY(unrecoverable_exception)
854
855         movi    a0, 1
856         movi    a1, 0
857
858         wsr     a0, windowstart
859         wsr     a1, windowbase
860         rsync
861
862         movi    a1, (1 << PS_WOE_BIT) | LOCKLEVEL
863         wsr     a1, ps
864         rsync
865
866         movi    a1, init_task
867         movi    a0, 0
868         addi    a1, a1, PT_REGS_OFFSET
869
870         movi    a4, panic
871         movi    a6, unrecoverable_text
872
873         callx4  a4
874
875 1:      j       1b
876
877 ENDPROC(unrecoverable_exception)
878
879 /* -------------------------- FAST EXCEPTION HANDLERS ----------------------- */
880
881 /*
882  * Fast-handler for alloca exceptions
883  *
884  *  The ALLOCA handler is entered when user code executes the MOVSP
885  *  instruction and the caller's frame is not in the register file.
886  *
887  * This algorithm was taken from the Ross Morley's RTOS Porting Layer:
888  *
889  *    /home/ross/rtos/porting/XtensaRTOS-PortingLayer-20090507/xtensa_vectors.S
890  *
891  * It leverages the existing window spill/fill routines and their support for
892  * double exceptions. The 'movsp' instruction will only cause an exception if
893  * the next window needs to be loaded. In fact this ALLOCA exception may be
894  * replaced at some point by changing the hardware to do a underflow exception
895  * of the proper size instead.
896  *
897  * This algorithm simply backs out the register changes started by the user
898  * excpetion handler, makes it appear that we have started a window underflow
899  * by rotating the window back and then setting the old window base (OWB) in
900  * the 'ps' register with the rolled back window base. The 'movsp' instruction
901  * will be re-executed and this time since the next window frames is in the
902  * active AR registers it won't cause an exception.
903  *
904  * If the WindowUnderflow code gets a TLB miss the page will get mapped
905  * the the partial windeowUnderflow will be handeled in the double exception
906  * handler.
907  *
908  * Entry condition:
909  *
910  *   a0:        trashed, original value saved on stack (PT_AREG0)
911  *   a1:        a1
912  *   a2:        new stack pointer, original in DEPC
913  *   a3:        a3
914  *   depc:      a2, original value saved on stack (PT_DEPC)
915  *   excsave_1: dispatch table
916  *
917  *   PT_DEPC >= VALID_DOUBLE_EXCEPTION_ADDRESS: double exception, DEPC
918  *           <  VALID_DOUBLE_EXCEPTION_ADDRESS: regular exception
919  */
920
921 ENTRY(fast_alloca)
922         rsr     a0, windowbase
923         rotw    -1
924         rsr     a2, ps
925         extui   a3, a2, PS_OWB_SHIFT, PS_OWB_WIDTH
926         xor     a3, a3, a4
927         l32i    a4, a6, PT_AREG0
928         l32i    a1, a6, PT_DEPC
929         rsr     a6, depc
930         wsr     a1, depc
931         slli    a3, a3, PS_OWB_SHIFT
932         xor     a2, a2, a3
933         wsr     a2, ps
934         rsync
935
936         _bbci.l a4, 31, 4f
937         rotw    -1
938         _bbci.l a8, 30, 8f
939         rotw    -1
940         j       _WindowUnderflow12
941 8:      j       _WindowUnderflow8
942 4:      j       _WindowUnderflow4
943 ENDPROC(fast_alloca)
944
945 /*
946  * fast system calls.
947  *
948  * WARNING:  The kernel doesn't save the entire user context before
949  * handling a fast system call.  These functions are small and short,
950  * usually offering some functionality not available to user tasks.
951  *
952  * BE CAREFUL TO PRESERVE THE USER'S CONTEXT.
953  *
954  * Entry condition:
955  *
956  *   a0:        trashed, original value saved on stack (PT_AREG0)
957  *   a1:        a1
958  *   a2:        new stack pointer, original in DEPC
959  *   a3:        a3
960  *   depc:      a2, original value saved on stack (PT_DEPC)
961  *   excsave_1: dispatch table
962  */
963
964 ENTRY(fast_syscall_kernel)
965
966         /* Skip syscall. */
967
968         rsr     a0, epc1
969         addi    a0, a0, 3
970         wsr     a0, epc1
971
972         l32i    a0, a2, PT_DEPC
973         bgeui   a0, VALID_DOUBLE_EXCEPTION_ADDRESS, fast_syscall_unrecoverable
974
975         rsr     a0, depc                        # get syscall-nr
976         _beqz   a0, fast_syscall_spill_registers
977         _beqi   a0, __NR_xtensa, fast_syscall_xtensa
978
979         j       kernel_exception
980
981 ENDPROC(fast_syscall_kernel)
982
983 ENTRY(fast_syscall_user)
984
985         /* Skip syscall. */
986
987         rsr     a0, epc1
988         addi    a0, a0, 3
989         wsr     a0, epc1
990
991         l32i    a0, a2, PT_DEPC
992         bgeui   a0, VALID_DOUBLE_EXCEPTION_ADDRESS, fast_syscall_unrecoverable
993
994         rsr     a0, depc                        # get syscall-nr
995         _beqz   a0, fast_syscall_spill_registers
996         _beqi   a0, __NR_xtensa, fast_syscall_xtensa
997
998         j       user_exception
999
1000 ENDPROC(fast_syscall_user)
1001
1002 ENTRY(fast_syscall_unrecoverable)
1003
1004         /* Restore all states. */
1005
1006         l32i    a0, a2, PT_AREG0        # restore a0
1007         xsr     a2, depc                # restore a2, depc
1008
1009         wsr     a0, excsave1
1010         movi    a0, unrecoverable_exception
1011         callx0  a0
1012
1013 ENDPROC(fast_syscall_unrecoverable)
1014
1015 /*
1016  * sysxtensa syscall handler
1017  *
1018  * int sysxtensa (SYS_XTENSA_ATOMIC_SET,     ptr, val,    unused);
1019  * int sysxtensa (SYS_XTENSA_ATOMIC_ADD,     ptr, val,    unused);
1020  * int sysxtensa (SYS_XTENSA_ATOMIC_EXG_ADD, ptr, val,    unused);
1021  * int sysxtensa (SYS_XTENSA_ATOMIC_CMP_SWP, ptr, oldval, newval);
1022  *        a2            a6                   a3    a4      a5
1023  *
1024  * Entry condition:
1025  *
1026  *   a0:        a2 (syscall-nr), original value saved on stack (PT_AREG0)
1027  *   a1:        a1
1028  *   a2:        new stack pointer, original in a0 and DEPC
1029  *   a3:        a3
1030  *   a4..a15:   unchanged
1031  *   depc:      a2, original value saved on stack (PT_DEPC)
1032  *   excsave_1: dispatch table
1033  *
1034  *   PT_DEPC >= VALID_DOUBLE_EXCEPTION_ADDRESS: double exception, DEPC
1035  *           <  VALID_DOUBLE_EXCEPTION_ADDRESS: regular exception
1036  *
1037  * Note: we don't have to save a2; a2 holds the return value
1038  *
1039  * We use the two macros TRY and CATCH:
1040  *
1041  * TRY   adds an entry to the __ex_table fixup table for the immediately
1042  *       following instruction.
1043  *
1044  * CATCH catches any exception that occurred at one of the preceding TRY
1045  *       statements and continues from there
1046  *
1047  * Usage TRY    l32i    a0, a1, 0
1048  *              <other code>
1049  *       done:  rfe
1050  *       CATCH  <set return code>
1051  *              j done
1052  */
1053
1054 #ifdef CONFIG_FAST_SYSCALL_XTENSA
1055
1056 #define TRY                                                             \
1057         .section __ex_table, "a";                                       \
1058         .word   66f, 67f;                                               \
1059         .text;                                                          \
1060 66:
1061
1062 #define CATCH                                                           \
1063 67:
1064
1065 ENTRY(fast_syscall_xtensa)
1066
1067         s32i    a7, a2, PT_AREG7        # we need an additional register
1068         movi    a7, 4                   # sizeof(unsigned int)
1069         access_ok a3, a7, a0, a2, .Leac # a0: scratch reg, a2: sp
1070
1071         _bgeui  a6, SYS_XTENSA_COUNT, .Lill
1072         _bnei   a6, SYS_XTENSA_ATOMIC_CMP_SWP, .Lnswp
1073
1074         /* Fall through for ATOMIC_CMP_SWP. */
1075
1076 .Lswp:  /* Atomic compare and swap */
1077
1078 TRY     l32i    a0, a3, 0               # read old value
1079         bne     a0, a4, 1f              # same as old value? jump
1080 TRY     s32i    a5, a3, 0               # different, modify value
1081         l32i    a7, a2, PT_AREG7        # restore a7
1082         l32i    a0, a2, PT_AREG0        # restore a0
1083         movi    a2, 1                   # and return 1
1084         rfe
1085
1086 1:      l32i    a7, a2, PT_AREG7        # restore a7
1087         l32i    a0, a2, PT_AREG0        # restore a0
1088         movi    a2, 0                   # return 0 (note that we cannot set
1089         rfe
1090
1091 .Lnswp: /* Atomic set, add, and exg_add. */
1092
1093 TRY     l32i    a7, a3, 0               # orig
1094         addi    a6, a6, -SYS_XTENSA_ATOMIC_SET
1095         add     a0, a4, a7              # + arg
1096         moveqz  a0, a4, a6              # set
1097         addi    a6, a6, SYS_XTENSA_ATOMIC_SET
1098 TRY     s32i    a0, a3, 0               # write new value
1099
1100         mov     a0, a2
1101         mov     a2, a7
1102         l32i    a7, a0, PT_AREG7        # restore a7
1103         l32i    a0, a0, PT_AREG0        # restore a0
1104         rfe
1105
1106 CATCH
1107 .Leac:  l32i    a7, a2, PT_AREG7        # restore a7
1108         l32i    a0, a2, PT_AREG0        # restore a0
1109         movi    a2, -EFAULT
1110         rfe
1111
1112 .Lill:  l32i    a7, a2, PT_AREG7        # restore a7
1113         l32i    a0, a2, PT_AREG0        # restore a0
1114         movi    a2, -EINVAL
1115         rfe
1116
1117 ENDPROC(fast_syscall_xtensa)
1118
1119 #else /* CONFIG_FAST_SYSCALL_XTENSA */
1120
1121 ENTRY(fast_syscall_xtensa)
1122
1123         l32i    a0, a2, PT_AREG0        # restore a0
1124         movi    a2, -ENOSYS
1125         rfe
1126
1127 ENDPROC(fast_syscall_xtensa)
1128
1129 #endif /* CONFIG_FAST_SYSCALL_XTENSA */
1130
1131
1132 /* fast_syscall_spill_registers.
1133  *
1134  * Entry condition:
1135  *
1136  *   a0:        trashed, original value saved on stack (PT_AREG0)
1137  *   a1:        a1
1138  *   a2:        new stack pointer, original in DEPC
1139  *   a3:        a3
1140  *   depc:      a2, original value saved on stack (PT_DEPC)
1141  *   excsave_1: dispatch table
1142  *
1143  * Note: We assume the stack pointer is EXC_TABLE_KSTK in the fixup handler.
1144  */
1145
1146 #ifdef CONFIG_FAST_SYSCALL_SPILL_REGISTERS
1147
1148 ENTRY(fast_syscall_spill_registers)
1149
1150         /* Register a FIXUP handler (pass current wb as a parameter) */
1151
1152         xsr     a3, excsave1
1153         movi    a0, fast_syscall_spill_registers_fixup
1154         s32i    a0, a3, EXC_TABLE_FIXUP
1155         rsr     a0, windowbase
1156         s32i    a0, a3, EXC_TABLE_PARAM
1157         xsr     a3, excsave1            # restore a3 and excsave_1
1158
1159         /* Save a3, a4 and SAR on stack. */
1160
1161         rsr     a0, sar
1162         s32i    a3, a2, PT_AREG3
1163         s32i    a0, a2, PT_SAR
1164
1165         /* The spill routine might clobber a4, a7, a8, a11, a12, and a15. */
1166
1167         s32i    a4, a2, PT_AREG4
1168         s32i    a7, a2, PT_AREG7
1169         s32i    a8, a2, PT_AREG8
1170         s32i    a11, a2, PT_AREG11
1171         s32i    a12, a2, PT_AREG12
1172         s32i    a15, a2, PT_AREG15
1173
1174         /*
1175          * Rotate ws so that the current windowbase is at bit 0.
1176          * Assume ws = xxxwww1yy (www1 current window frame).
1177          * Rotate ws right so that a4 = yyxxxwww1.
1178          */
1179
1180         rsr     a0, windowbase
1181         rsr     a3, windowstart         # a3 = xxxwww1yy
1182         ssr     a0                      # holds WB
1183         slli    a0, a3, WSBITS
1184         or      a3, a3, a0              # a3 = xxxwww1yyxxxwww1yy
1185         srl     a3, a3                  # a3 = 00xxxwww1yyxxxwww1
1186
1187         /* We are done if there are no more than the current register frame. */
1188
1189         extui   a3, a3, 1, WSBITS-1     # a3 = 0yyxxxwww
1190         movi    a0, (1 << (WSBITS-1))
1191         _beqz   a3, .Lnospill           # only one active frame? jump
1192
1193         /* We want 1 at the top, so that we return to the current windowbase */
1194
1195         or      a3, a3, a0              # 1yyxxxwww
1196
1197         /* Skip empty frames - get 'oldest' WINDOWSTART-bit. */
1198
1199         wsr     a3, windowstart         # save shifted windowstart
1200         neg     a0, a3
1201         and     a3, a0, a3              # first bit set from right: 000010000
1202
1203         ffs_ws  a0, a3                  # a0: shifts to skip empty frames
1204         movi    a3, WSBITS
1205         sub     a0, a3, a0              # WSBITS-a0:number of 0-bits from right
1206         ssr     a0                      # save in SAR for later.
1207
1208         rsr     a3, windowbase
1209         add     a3, a3, a0
1210         wsr     a3, windowbase
1211         rsync
1212
1213         rsr     a3, windowstart
1214         srl     a3, a3                  # shift windowstart
1215
1216         /* WB is now just one frame below the oldest frame in the register
1217            window. WS is shifted so the oldest frame is in bit 0, thus, WB
1218            and WS differ by one 4-register frame. */
1219
1220         /* Save frames. Depending what call was used (call4, call8, call12),
1221          * we have to save 4,8. or 12 registers.
1222          */
1223
1224
1225 .Lloop: _bbsi.l a3, 1, .Lc4
1226         _bbci.l a3, 2, .Lc12
1227
1228 .Lc8:   s32e    a4, a13, -16
1229         l32e    a4, a5, -12
1230         s32e    a8, a4, -32
1231         s32e    a5, a13, -12
1232         s32e    a6, a13, -8
1233         s32e    a7, a13, -4
1234         s32e    a9, a4, -28
1235         s32e    a10, a4, -24
1236         s32e    a11, a4, -20
1237         srli    a11, a3, 2              # shift windowbase by 2
1238         rotw    2
1239         _bnei   a3, 1, .Lloop
1240         j       .Lexit
1241
1242 .Lc4:   s32e    a4, a9, -16
1243         s32e    a5, a9, -12
1244         s32e    a6, a9, -8
1245         s32e    a7, a9, -4
1246
1247         srli    a7, a3, 1
1248         rotw    1
1249         _bnei   a3, 1, .Lloop
1250         j       .Lexit
1251
1252 .Lc12:  _bbci.l a3, 3, .Linvalid_mask   # bit 2 shouldn't be zero!
1253
1254         /* 12-register frame (call12) */
1255
1256         l32e    a0, a5, -12
1257         s32e    a8, a0, -48
1258         mov     a8, a0
1259
1260         s32e    a9, a8, -44
1261         s32e    a10, a8, -40
1262         s32e    a11, a8, -36
1263         s32e    a12, a8, -32
1264         s32e    a13, a8, -28
1265         s32e    a14, a8, -24
1266         s32e    a15, a8, -20
1267         srli    a15, a3, 3
1268
1269         /* The stack pointer for a4..a7 is out of reach, so we rotate the
1270          * window, grab the stackpointer, and rotate back.
1271          * Alternatively, we could also use the following approach, but that
1272          * makes the fixup routine much more complicated:
1273          * rotw 1
1274          * s32e a0, a13, -16
1275          * ...
1276          * rotw 2
1277          */
1278
1279         rotw    1
1280         mov     a4, a13
1281         rotw    -1
1282
1283         s32e    a4, a8, -16
1284         s32e    a5, a8, -12
1285         s32e    a6, a8, -8
1286         s32e    a7, a8, -4
1287
1288         rotw    3
1289
1290         _beqi   a3, 1, .Lexit
1291         j       .Lloop
1292
1293 .Lexit:
1294
1295         /* Done. Do the final rotation and set WS */
1296
1297         rotw    1
1298         rsr     a3, windowbase
1299         ssl     a3
1300         movi    a3, 1
1301         sll     a3, a3
1302         wsr     a3, windowstart
1303 .Lnospill:
1304
1305         /* Advance PC, restore registers and SAR, and return from exception. */
1306
1307         l32i    a3, a2, PT_SAR
1308         l32i    a0, a2, PT_AREG0
1309         wsr     a3, sar
1310         l32i    a3, a2, PT_AREG3
1311
1312         /* Restore clobbered registers. */
1313
1314         l32i    a4, a2, PT_AREG4
1315         l32i    a7, a2, PT_AREG7
1316         l32i    a8, a2, PT_AREG8
1317         l32i    a11, a2, PT_AREG11
1318         l32i    a12, a2, PT_AREG12
1319         l32i    a15, a2, PT_AREG15
1320
1321         movi    a2, 0
1322         rfe
1323
1324 .Linvalid_mask:
1325
1326         /* We get here because of an unrecoverable error in the window
1327          * registers, so set up a dummy frame and kill the user application.
1328          * Note: We assume EXC_TABLE_KSTK contains a valid stack pointer.
1329          */
1330
1331         movi    a0, 1
1332         movi    a1, 0
1333
1334         wsr     a0, windowstart
1335         wsr     a1, windowbase
1336         rsync
1337
1338         movi    a0, 0
1339
1340         rsr     a3, excsave1
1341         l32i    a1, a3, EXC_TABLE_KSTK
1342
1343         movi    a4, (1 << PS_WOE_BIT) | LOCKLEVEL
1344         wsr     a4, ps
1345         rsync
1346
1347         movi    a6, SIGSEGV
1348         movi    a4, do_exit
1349         callx4  a4
1350
1351         /* shouldn't return, so panic */
1352
1353         wsr     a0, excsave1
1354         movi    a0, unrecoverable_exception
1355         callx0  a0              # should not return
1356 1:      j       1b
1357
1358
1359 ENDPROC(fast_syscall_spill_registers)
1360
1361 /* Fixup handler.
1362  *
1363  * We get here if the spill routine causes an exception, e.g. tlb miss.
1364  * We basically restore WINDOWBASE and WINDOWSTART to the condition when
1365  * we entered the spill routine and jump to the user exception handler.
1366  *
1367  * Note that we only need to restore the bits in windowstart that have not
1368  * been spilled yet by the _spill_register routine. Luckily, a3 contains a
1369  * rotated windowstart with only those bits set for frames that haven't been
1370  * spilled yet. Because a3 is rotated such that bit 0 represents the register
1371  * frame for the current windowbase - 1, we need to rotate a3 left by the
1372  * value of the current windowbase + 1 and move it to windowstart.
1373  *
1374  * a0: value of depc, original value in depc
1375  * a2: trashed, original value in EXC_TABLE_DOUBLE_SAVE
1376  * a3: exctable, original value in excsave1
1377  */
1378
1379 ENTRY(fast_syscall_spill_registers_fixup)
1380
1381         rsr     a2, windowbase  # get current windowbase (a2 is saved)
1382         xsr     a0, depc        # restore depc and a0
1383         ssl     a2              # set shift (32 - WB)
1384
1385         /* We need to make sure the current registers (a0-a3) are preserved.
1386          * To do this, we simply set the bit for the current window frame
1387          * in WS, so that the exception handlers save them to the task stack.
1388          *
1389          * Note: we use a3 to set the windowbase, so we take a special care
1390          * of it, saving it in the original _spill_registers frame across
1391          * the exception handler call.
1392          */
1393
1394         xsr     a3, excsave1    # get spill-mask
1395         slli    a3, a3, 1       # shift left by one
1396         addi    a3, a3, 1       # set the bit for the current window frame
1397
1398         slli    a2, a3, 32-WSBITS
1399         src     a2, a3, a2      # a2 = xxwww1yyxxxwww1yy......
1400         wsr     a2, windowstart # set corrected windowstart
1401
1402         srli    a3, a3, 1
1403         rsr     a2, excsave1
1404         l32i    a2, a2, EXC_TABLE_DOUBLE_SAVE   # restore a2
1405         xsr     a2, excsave1
1406         s32i    a3, a2, EXC_TABLE_DOUBLE_SAVE   # save a3
1407         l32i    a3, a2, EXC_TABLE_PARAM # original WB (in user task)
1408         xsr     a2, excsave1
1409
1410         /* Return to the original (user task) WINDOWBASE.
1411          * We leave the following frame behind:
1412          * a0, a1, a2   same
1413          * a3:          trashed (saved in EXC_TABLE_DOUBLE_SAVE)
1414          * depc:        depc (we have to return to that address)
1415          * excsave_1:   exctable
1416          */
1417
1418         wsr     a3, windowbase
1419         rsync
1420
1421         /* We are now in the original frame when we entered _spill_registers:
1422          *  a0: return address
1423          *  a1: used, stack pointer
1424          *  a2: kernel stack pointer
1425          *  a3: available
1426          *  depc: exception address
1427          *  excsave: exctable
1428          * Note: This frame might be the same as above.
1429          */
1430
1431         /* Setup stack pointer. */
1432
1433         addi    a2, a2, -PT_USER_SIZE
1434         s32i    a0, a2, PT_AREG0
1435
1436         /* Make sure we return to this fixup handler. */
1437
1438         movi    a3, fast_syscall_spill_registers_fixup_return
1439         s32i    a3, a2, PT_DEPC         # setup depc
1440
1441         /* Jump to the exception handler. */
1442
1443         rsr     a3, excsave1
1444         rsr     a0, exccause
1445         addx4   a0, a0, a3                      # find entry in table
1446         l32i    a0, a0, EXC_TABLE_FAST_USER     # load handler
1447         l32i    a3, a3, EXC_TABLE_DOUBLE_SAVE
1448         jx      a0
1449
1450 ENDPROC(fast_syscall_spill_registers_fixup)
1451
1452 ENTRY(fast_syscall_spill_registers_fixup_return)
1453
1454         /* When we return here, all registers have been restored (a2: DEPC) */
1455
1456         wsr     a2, depc                # exception address
1457
1458         /* Restore fixup handler. */
1459
1460         rsr     a2, excsave1
1461         s32i    a3, a2, EXC_TABLE_DOUBLE_SAVE
1462         movi    a3, fast_syscall_spill_registers_fixup
1463         s32i    a3, a2, EXC_TABLE_FIXUP
1464         rsr     a3, windowbase
1465         s32i    a3, a2, EXC_TABLE_PARAM
1466         l32i    a2, a2, EXC_TABLE_KSTK
1467
1468         /* Load WB at the time the exception occurred. */
1469
1470         rsr     a3, sar                 # WB is still in SAR
1471         neg     a3, a3
1472         wsr     a3, windowbase
1473         rsync
1474
1475         rsr     a3, excsave1
1476         l32i    a3, a3, EXC_TABLE_DOUBLE_SAVE
1477
1478         rfde
1479
1480 ENDPROC(fast_syscall_spill_registers_fixup_return)
1481
1482 #else /* CONFIG_FAST_SYSCALL_SPILL_REGISTERS */
1483
1484 ENTRY(fast_syscall_spill_registers)
1485
1486         l32i    a0, a2, PT_AREG0        # restore a0
1487         movi    a2, -ENOSYS
1488         rfe
1489
1490 ENDPROC(fast_syscall_spill_registers)
1491
1492 #endif /* CONFIG_FAST_SYSCALL_SPILL_REGISTERS */
1493
1494 #ifdef CONFIG_MMU
1495 /*
1496  * We should never get here. Bail out!
1497  */
1498
1499 ENTRY(fast_second_level_miss_double_kernel)
1500
1501 1:      movi    a0, unrecoverable_exception
1502         callx0  a0              # should not return
1503 1:      j       1b
1504
1505 ENDPROC(fast_second_level_miss_double_kernel)
1506
1507 /* First-level entry handler for user, kernel, and double 2nd-level
1508  * TLB miss exceptions.  Note that for now, user and kernel miss
1509  * exceptions share the same entry point and are handled identically.
1510  *
1511  * An old, less-efficient C version of this function used to exist.
1512  * We include it below, interleaved as comments, for reference.
1513  *
1514  * Entry condition:
1515  *
1516  *   a0:        trashed, original value saved on stack (PT_AREG0)
1517  *   a1:        a1
1518  *   a2:        new stack pointer, original in DEPC
1519  *   a3:        a3
1520  *   depc:      a2, original value saved on stack (PT_DEPC)
1521  *   excsave_1: dispatch table
1522  *
1523  *   PT_DEPC >= VALID_DOUBLE_EXCEPTION_ADDRESS: double exception, DEPC
1524  *           <  VALID_DOUBLE_EXCEPTION_ADDRESS: regular exception
1525  */
1526
1527 ENTRY(fast_second_level_miss)
1528
1529         /* Save a1 and a3. Note: we don't expect a double exception. */
1530
1531         s32i    a1, a2, PT_AREG1
1532         s32i    a3, a2, PT_AREG3
1533
1534         /* We need to map the page of PTEs for the user task.  Find
1535          * the pointer to that page.  Also, it's possible for tsk->mm
1536          * to be NULL while tsk->active_mm is nonzero if we faulted on
1537          * a vmalloc address.  In that rare case, we must use
1538          * active_mm instead to avoid a fault in this handler.  See
1539          *
1540          * http://mail.nl.linux.org/linux-mm/2002-08/msg00258.html
1541          *   (or search Internet on "mm vs. active_mm")
1542          *
1543          *      if (!mm)
1544          *              mm = tsk->active_mm;
1545          *      pgd = pgd_offset (mm, regs->excvaddr);
1546          *      pmd = pmd_offset (pgd, regs->excvaddr);
1547          *      pmdval = *pmd;
1548          */
1549
1550         GET_CURRENT(a1,a2)
1551         l32i    a0, a1, TASK_MM         # tsk->mm
1552         beqz    a0, 9f
1553
1554 8:      rsr     a3, excvaddr            # fault address
1555         _PGD_OFFSET(a0, a3, a1)
1556         l32i    a0, a0, 0               # read pmdval
1557         beqz    a0, 2f
1558
1559         /* Read ptevaddr and convert to top of page-table page.
1560          *
1561          *      vpnval = read_ptevaddr_register() & PAGE_MASK;
1562          *      vpnval += DTLB_WAY_PGTABLE;
1563          *      pteval = mk_pte (virt_to_page(pmd_val(pmdval)), PAGE_KERNEL);
1564          *      write_dtlb_entry (pteval, vpnval);
1565          *
1566          * The messy computation for 'pteval' above really simplifies
1567          * into the following:
1568          *
1569          * pteval = ((pmdval - PAGE_OFFSET) & PAGE_MASK) | PAGE_DIRECTORY
1570          */
1571
1572         movi    a1, (-PAGE_OFFSET) & 0xffffffff
1573         add     a0, a0, a1              # pmdval - PAGE_OFFSET
1574         extui   a1, a0, 0, PAGE_SHIFT   # ... & PAGE_MASK
1575         xor     a0, a0, a1
1576
1577         movi    a1, _PAGE_DIRECTORY
1578         or      a0, a0, a1              # ... | PAGE_DIRECTORY
1579
1580         /*
1581          * We utilize all three wired-ways (7-9) to hold pmd translations.
1582          * Memory regions are mapped to the DTLBs according to bits 28 and 29.
1583          * This allows to map the three most common regions to three different
1584          * DTLBs:
1585          *  0,1 -> way 7        program (0040.0000) and virtual (c000.0000)
1586          *  2   -> way 8        shared libaries (2000.0000)
1587          *  3   -> way 0        stack (3000.0000)
1588          */
1589
1590         extui   a3, a3, 28, 2           # addr. bit 28 and 29   0,1,2,3
1591         rsr     a1, ptevaddr
1592         addx2   a3, a3, a3              # ->                    0,3,6,9
1593         srli    a1, a1, PAGE_SHIFT
1594         extui   a3, a3, 2, 2            # ->                    0,0,1,2
1595         slli    a1, a1, PAGE_SHIFT      # ptevaddr & PAGE_MASK
1596         addi    a3, a3, DTLB_WAY_PGD
1597         add     a1, a1, a3              # ... + way_number
1598
1599 3:      wdtlb   a0, a1
1600         dsync
1601
1602         /* Exit critical section. */
1603
1604 4:      rsr     a3, excsave1
1605         movi    a0, 0
1606         s32i    a0, a3, EXC_TABLE_FIXUP
1607
1608         /* Restore the working registers, and return. */
1609
1610         l32i    a0, a2, PT_AREG0
1611         l32i    a1, a2, PT_AREG1
1612         l32i    a3, a2, PT_AREG3
1613         l32i    a2, a2, PT_DEPC
1614
1615         bgeui   a2, VALID_DOUBLE_EXCEPTION_ADDRESS, 1f
1616
1617         /* Restore excsave1 and return. */
1618
1619         rsr     a2, depc
1620         rfe
1621
1622         /* Return from double exception. */
1623
1624 1:      xsr     a2, depc
1625         esync
1626         rfde
1627
1628 9:      l32i    a0, a1, TASK_ACTIVE_MM  # unlikely case mm == 0
1629         bnez    a0, 8b
1630
1631         /* Even more unlikely case active_mm == 0.
1632          * We can get here with NMI in the middle of context_switch that
1633          * touches vmalloc area.
1634          */
1635         movi    a0, init_mm
1636         j       8b
1637
1638 #if (DCACHE_WAY_SIZE > PAGE_SIZE)
1639
1640 2:      /* Special case for cache aliasing.
1641          * We (should) only get here if a clear_user_page, copy_user_page
1642          * or the aliased cache flush functions got preemptively interrupted 
1643          * by another task. Re-establish temporary mapping to the 
1644          * TLBTEMP_BASE areas.
1645          */
1646
1647         /* We shouldn't be in a double exception */
1648
1649         l32i    a0, a2, PT_DEPC
1650         bgeui   a0, VALID_DOUBLE_EXCEPTION_ADDRESS, 2f
1651
1652         /* Make sure the exception originated in the special functions */
1653
1654         movi    a0, __tlbtemp_mapping_start
1655         rsr     a3, epc1
1656         bltu    a3, a0, 2f
1657         movi    a0, __tlbtemp_mapping_end
1658         bgeu    a3, a0, 2f
1659
1660         /* Check if excvaddr was in one of the TLBTEMP_BASE areas. */
1661
1662         movi    a3, TLBTEMP_BASE_1
1663         rsr     a0, excvaddr
1664         bltu    a0, a3, 2f
1665
1666         addi    a1, a0, -TLBTEMP_SIZE
1667         bgeu    a1, a3, 2f
1668
1669         /* Check if we have to restore an ITLB mapping. */
1670
1671         movi    a1, __tlbtemp_mapping_itlb
1672         rsr     a3, epc1
1673         sub     a3, a3, a1
1674
1675         /* Calculate VPN */
1676
1677         movi    a1, PAGE_MASK
1678         and     a1, a1, a0
1679
1680         /* Jump for ITLB entry */
1681
1682         bgez    a3, 1f
1683
1684         /* We can use up to two TLBTEMP areas, one for src and one for dst. */
1685
1686         extui   a3, a0, PAGE_SHIFT + DCACHE_ALIAS_ORDER, 1
1687         add     a1, a3, a1
1688
1689         /* PPN is in a6 for the first TLBTEMP area and in a7 for the second. */
1690
1691         mov     a0, a6
1692         movnez  a0, a7, a3
1693         j       3b
1694
1695         /* ITLB entry. We only use dst in a6. */
1696
1697 1:      witlb   a6, a1
1698         isync
1699         j       4b
1700
1701
1702 #endif  // DCACHE_WAY_SIZE > PAGE_SIZE
1703
1704
1705 2:      /* Invalid PGD, default exception handling */
1706
1707         rsr     a1, depc
1708         s32i    a1, a2, PT_AREG2
1709         mov     a1, a2
1710
1711         rsr     a2, ps
1712         bbsi.l  a2, PS_UM_BIT, 1f
1713         j       _kernel_exception
1714 1:      j       _user_exception
1715
1716 ENDPROC(fast_second_level_miss)
1717
1718 /*
1719  * StoreProhibitedException
1720  *
1721  * Update the pte and invalidate the itlb mapping for this pte.
1722  *
1723  * Entry condition:
1724  *
1725  *   a0:        trashed, original value saved on stack (PT_AREG0)
1726  *   a1:        a1
1727  *   a2:        new stack pointer, original in DEPC
1728  *   a3:        a3
1729  *   depc:      a2, original value saved on stack (PT_DEPC)
1730  *   excsave_1: dispatch table
1731  *
1732  *   PT_DEPC >= VALID_DOUBLE_EXCEPTION_ADDRESS: double exception, DEPC
1733  *           <  VALID_DOUBLE_EXCEPTION_ADDRESS: regular exception
1734  */
1735
1736 ENTRY(fast_store_prohibited)
1737
1738         /* Save a1 and a3. */
1739
1740         s32i    a1, a2, PT_AREG1
1741         s32i    a3, a2, PT_AREG3
1742
1743         GET_CURRENT(a1,a2)
1744         l32i    a0, a1, TASK_MM         # tsk->mm
1745         beqz    a0, 9f
1746
1747 8:      rsr     a1, excvaddr            # fault address
1748         _PGD_OFFSET(a0, a1, a3)
1749         l32i    a0, a0, 0
1750         beqz    a0, 2f
1751
1752         /*
1753          * Note that we test _PAGE_WRITABLE_BIT only if PTE is present
1754          * and is not PAGE_NONE. See pgtable.h for possible PTE layouts.
1755          */
1756
1757         _PTE_OFFSET(a0, a1, a3)
1758         l32i    a3, a0, 0               # read pteval
1759         movi    a1, _PAGE_CA_INVALID
1760         ball    a3, a1, 2f
1761         bbci.l  a3, _PAGE_WRITABLE_BIT, 2f
1762
1763         movi    a1, _PAGE_ACCESSED | _PAGE_DIRTY | _PAGE_HW_WRITE
1764         or      a3, a3, a1
1765         rsr     a1, excvaddr
1766         s32i    a3, a0, 0
1767
1768         /* We need to flush the cache if we have page coloring. */
1769 #if (DCACHE_WAY_SIZE > PAGE_SIZE) && XCHAL_DCACHE_IS_WRITEBACK
1770         dhwb    a0, 0
1771 #endif
1772         pdtlb   a0, a1
1773         wdtlb   a3, a0
1774
1775         /* Exit critical section. */
1776
1777         movi    a0, 0
1778         rsr     a3, excsave1
1779         s32i    a0, a3, EXC_TABLE_FIXUP
1780
1781         /* Restore the working registers, and return. */
1782
1783         l32i    a3, a2, PT_AREG3
1784         l32i    a1, a2, PT_AREG1
1785         l32i    a0, a2, PT_AREG0
1786         l32i    a2, a2, PT_DEPC
1787
1788         bgeui   a2, VALID_DOUBLE_EXCEPTION_ADDRESS, 1f
1789
1790         rsr     a2, depc
1791         rfe
1792
1793         /* Double exception. Restore FIXUP handler and return. */
1794
1795 1:      xsr     a2, depc
1796         esync
1797         rfde
1798
1799 9:      l32i    a0, a1, TASK_ACTIVE_MM  # unlikely case mm == 0
1800         j       8b
1801
1802 2:      /* If there was a problem, handle fault in C */
1803
1804         rsr     a3, depc        # still holds a2
1805         s32i    a3, a2, PT_AREG2
1806         mov     a1, a2
1807
1808         rsr     a2, ps
1809         bbsi.l  a2, PS_UM_BIT, 1f
1810         j       _kernel_exception
1811 1:      j       _user_exception
1812
1813 ENDPROC(fast_store_prohibited)
1814
1815 #endif /* CONFIG_MMU */
1816
1817 /*
1818  * System Calls.
1819  *
1820  * void system_call (struct pt_regs* regs, int exccause)
1821  *                            a2                 a3
1822  */
1823
1824 ENTRY(system_call)
1825
1826         entry   a1, 32
1827
1828         /* regs->syscall = regs->areg[2] */
1829
1830         l32i    a3, a2, PT_AREG2
1831         mov     a6, a2
1832         movi    a4, do_syscall_trace_enter
1833         s32i    a3, a2, PT_SYSCALL
1834         callx4  a4
1835
1836         /* syscall = sys_call_table[syscall_nr] */
1837
1838         movi    a4, sys_call_table;
1839         movi    a5, __NR_syscall_count
1840         movi    a6, -ENOSYS
1841         bgeu    a3, a5, 1f
1842
1843         addx4   a4, a3, a4
1844         l32i    a4, a4, 0
1845         movi    a5, sys_ni_syscall;
1846         beq     a4, a5, 1f
1847
1848         /* Load args: arg0 - arg5 are passed via regs. */
1849
1850         l32i    a6, a2, PT_AREG6
1851         l32i    a7, a2, PT_AREG3
1852         l32i    a8, a2, PT_AREG4
1853         l32i    a9, a2, PT_AREG5
1854         l32i    a10, a2, PT_AREG8
1855         l32i    a11, a2, PT_AREG9
1856
1857         /* Pass one additional argument to the syscall: pt_regs (on stack) */
1858         s32i    a2, a1, 0
1859
1860         callx4  a4
1861
1862 1:      /* regs->areg[2] = return_value */
1863
1864         s32i    a6, a2, PT_AREG2
1865         movi    a4, do_syscall_trace_leave
1866         mov     a6, a2
1867         callx4  a4
1868         retw
1869
1870 ENDPROC(system_call)
1871
1872 /*
1873  * Spill live registers on the kernel stack macro.
1874  *
1875  * Entry condition: ps.woe is set, ps.excm is cleared
1876  * Exit condition: windowstart has single bit set
1877  * May clobber: a12, a13
1878  */
1879         .macro  spill_registers_kernel
1880
1881 #if XCHAL_NUM_AREGS > 16
1882         call12  1f
1883         _j      2f
1884         retw
1885         .align  4
1886 1:
1887         _entry  a1, 48
1888         addi    a12, a0, 3
1889 #if XCHAL_NUM_AREGS > 32
1890         .rept   (XCHAL_NUM_AREGS - 32) / 12
1891         _entry  a1, 48
1892         mov     a12, a0
1893         .endr
1894 #endif
1895         _entry  a1, 16
1896 #if XCHAL_NUM_AREGS % 12 == 0
1897         mov     a8, a8
1898 #elif XCHAL_NUM_AREGS % 12 == 4
1899         mov     a12, a12
1900 #elif XCHAL_NUM_AREGS % 12 == 8
1901         mov     a4, a4
1902 #endif
1903         retw
1904 2:
1905 #else
1906         mov     a12, a12
1907 #endif
1908         .endm
1909
1910 /*
1911  * Task switch.
1912  *
1913  * struct task*  _switch_to (struct task* prev, struct task* next)
1914  *         a2                              a2                 a3
1915  */
1916
1917 ENTRY(_switch_to)
1918
1919         entry   a1, 48
1920
1921         mov     a11, a3                 # and 'next' (a3)
1922
1923         l32i    a4, a2, TASK_THREAD_INFO
1924         l32i    a5, a3, TASK_THREAD_INFO
1925
1926         save_xtregs_user a4 a6 a8 a9 a12 a13 THREAD_XTREGS_USER
1927
1928 #if THREAD_RA > 1020 || THREAD_SP > 1020
1929         addi    a10, a2, TASK_THREAD
1930         s32i    a0, a10, THREAD_RA - TASK_THREAD        # save return address
1931         s32i    a1, a10, THREAD_SP - TASK_THREAD        # save stack pointer
1932 #else
1933         s32i    a0, a2, THREAD_RA       # save return address
1934         s32i    a1, a2, THREAD_SP       # save stack pointer
1935 #endif
1936
1937         /* Disable ints while we manipulate the stack pointer. */
1938
1939         irq_save a14, a3
1940         rsync
1941
1942         /* Switch CPENABLE */
1943
1944 #if (XTENSA_HAVE_COPROCESSORS || XTENSA_HAVE_IO_PORTS)
1945         l32i    a3, a5, THREAD_CPENABLE
1946         xsr     a3, cpenable
1947         s32i    a3, a4, THREAD_CPENABLE
1948 #endif
1949
1950         /* Flush register file. */
1951
1952         spill_registers_kernel
1953
1954         /* Set kernel stack (and leave critical section)
1955          * Note: It's save to set it here. The stack will not be overwritten
1956          *       because the kernel stack will only be loaded again after
1957          *       we return from kernel space.
1958          */
1959
1960         rsr     a3, excsave1            # exc_table
1961         addi    a7, a5, PT_REGS_OFFSET
1962         s32i    a7, a3, EXC_TABLE_KSTK
1963
1964         /* restore context of the task 'next' */
1965
1966         l32i    a0, a11, THREAD_RA      # restore return address
1967         l32i    a1, a11, THREAD_SP      # restore stack pointer
1968
1969         load_xtregs_user a5 a6 a8 a9 a12 a13 THREAD_XTREGS_USER
1970
1971         wsr     a14, ps
1972         rsync
1973
1974         retw
1975
1976 ENDPROC(_switch_to)
1977
1978 ENTRY(ret_from_fork)
1979
1980         /* void schedule_tail (struct task_struct *prev)
1981          * Note: prev is still in a6 (return value from fake call4 frame)
1982          */
1983         movi    a4, schedule_tail
1984         callx4  a4
1985
1986         movi    a4, do_syscall_trace_leave
1987         mov     a6, a1
1988         callx4  a4
1989
1990         j       common_exception_return
1991
1992 ENDPROC(ret_from_fork)
1993
1994 /*
1995  * Kernel thread creation helper
1996  * On entry, set up by copy_thread: a2 = thread_fn, a3 = thread_fn arg
1997  *           left from _switch_to: a6 = prev
1998  */
1999 ENTRY(ret_from_kernel_thread)
2000
2001         call4   schedule_tail
2002         mov     a6, a3
2003         callx4  a2
2004         j       common_exception_return
2005
2006 ENDPROC(ret_from_kernel_thread)