lapic timer: Add necessary bits for lapic timer interrupt delivery
[dragonfly.git] / sys / platform / pc32 / isa / ipl.s
1 /*-
2  * Copyright (c) 1989, 1990 William F. Jolitz.
3  * Copyright (c) 1990 The Regents of the University of California.
4  * All rights reserved.
5  *
6  * This code is derived from software contributed to Berkeley by
7  * William Jolitz.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. All advertising materials mentioning features or use of this software
18  *    must display the following acknowledgement:
19  *      This product includes software developed by the University of
20  *      California, Berkeley and its contributors.
21  * 4. Neither the name of the University nor the names of its contributors
22  *    may be used to endorse or promote products derived from this software
23  *    without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  *
37  *      @(#)ipl.s
38  *
39  * $FreeBSD: src/sys/i386/isa/ipl.s,v 1.32.2.3 2002/05/16 16:03:56 bde Exp $
40  * $DragonFly: src/sys/platform/pc32/isa/ipl.s,v 1.28 2007/01/22 19:37:04 corecode Exp $
41  */
42
43 #include "use_npx.h"
44
45 #include <machine/asmacros.h>
46 #include <machine/segments.h>
47 #include <machine/ipl.h>
48 #include <machine/lock.h>
49 #include <machine/psl.h>
50 #include <machine/trap.h>
51  
52 #include "assym.s"
53
54 /*
55  * AT/386
56  * Vector interrupt control section
57  *
58  *  ipending    - Pending interrupts (set when a masked interrupt occurs)
59  *  spending    - Pending software interrupts
60  */
61         .data
62         ALIGN_DATA
63
64         .globl          fastunpend_count
65 fastunpend_count:       .long   0
66
67         .text
68         SUPERALIGN_TEXT
69
70         /*
71          * GENERAL NOTES
72          *
73          *      - fast interrupts are always called with a critical section
74          *        held
75          *
76          *      - we release our critical section when scheduling interrupt
77          *        or softinterrupt threads in order so they can preempt
78          *        (unless we are called manually from a critical section, in
79          *        which case there will still be a critical section and
80          *        they won't preempt anyway).
81          *
82          *      - TD_NEST_COUNT prevents splz from nesting too deeply within
83          *        itself.  It is *not* actually an interrupt nesting count.
84          *        PCPU(intr_nesting_level) is an interrupt nesting count.
85          *
86          *      - We have to be careful in regards to local interrupts
87          *        occuring simultaniously with our doreti and splz 
88          *        processing.
89          */
90
91         /*
92          * DORETI
93          *
94          * Handle return from interrupts, traps and syscalls.  This function
95          * checks the cpl for unmasked pending interrupts (fast, normal, or
96          * soft) and schedules them if appropriate, then irets.
97          *
98          * If we are in a critical section we cannot run any pending ints
99          * nor can be play with mp_lock.
100          *
101          * NOTE: Since SPLs no longer exist, all callers of this function
102          * push $0 for the CPL.  HOWEVER, we *STILL* use the cpl mask within
103          * this function to mark fast interrupts which could not be dispatched
104          * do to the unavailability of the BGL.
105          */
106         SUPERALIGN_TEXT
107         .globl  doreti
108         .type   doreti,@function
109 doreti:
110         FAKE_MCOUNT(bintr)              /* init "from" bintr -> doreti */
111         popl    %eax                    /* cpl to restore XXX */
112         movl    $0,%eax                 /* irq mask unavailable due to BGL */
113         movl    PCPU(curthread),%ebx
114         cli                             /* interlock with TDPRI_CRIT */
115         cmpl    $0,PCPU(reqflags)       /* short cut if nothing to do */
116         je      5f
117         cmpl    $TDPRI_CRIT,TD_PRI(%ebx) /* can't unpend if in critical sec */
118         jge     5f
119         addl    $TDPRI_CRIT,TD_PRI(%ebx) /* force all ints to pending */
120 doreti_next:
121         sti                             /* allow new interrupts */
122         movl    %eax,%ecx               /* irq mask unavailable due to BGL */
123         notl    %ecx
124         cli                             /* disallow YYY remove */
125 #ifdef SMP
126         testl   $RQF_IPIQ,PCPU(reqflags)
127         jnz     doreti_ipiq
128         testl   $RQF_TIMER,PCPU(reqflags)
129         jnz     doreti_timer
130 #endif
131         testl   PCPU(fpending),%ecx     /* check for an unmasked fast int */
132         jnz     doreti_fast
133
134         testl   PCPU(ipending),%ecx     /* check for an unmasked slow int */
135         jnz     doreti_intr
136
137         movl    PCPU(spending),%ecx     /* check for a pending software int */
138         cmpl    $0,%ecx
139         jnz     doreti_soft
140
141         testl   $RQF_AST_MASK,PCPU(reqflags) /* any pending ASTs? */
142         jz      2f
143         testl   $PSL_VM,TF_EFLAGS(%esp)
144         jz      1f
145         cmpl    $1,in_vm86call          /* YYY make per 'cpu'? */
146         jnz     doreti_ast
147 1:
148         /* ASTs are only applicable when returning to userland */
149         testb   $SEL_RPL_MASK,TF_CS(%esp)
150         jnz     doreti_ast
151 2:
152         /*
153          * Nothing left to do, finish up.  Interrupts are still disabled.
154          * %eax contains the mask of IRQ's that are not available due to
155          * BGL requirements.  We can only clear RQF_INTPEND if *ALL* pending
156          * interrupts have been processed.
157          */
158         subl    $TDPRI_CRIT,TD_PRI(%ebx)        /* interlocked with cli */
159         testl   %eax,%eax
160         jnz     5f
161         andl    $~RQF_INTPEND,PCPU(reqflags)
162 5:
163         MEXITCOUNT
164
165         /*
166          * Restore the segment registers.  Since segment register values
167          * can be set from user mode, this can result in a kernel mode
168          * exception.  The trap code will revector to the *_fault code
169          * which then sets up a T_PROTFLT signal.  If the signal is
170          * sent to userland, sendsig() will automatically clean up all
171          * the segment registers to avoid a loop.
172          */
173         .globl  doreti_popl_gs
174         .globl  doreti_popl_fs
175         .globl  doreti_popl_es
176         .globl  doreti_popl_ds
177         .globl  doreti_iret
178         .globl  doreti_syscall_ret
179 doreti_syscall_ret:
180 doreti_popl_gs:
181         popl    %gs
182 doreti_popl_fs:
183         popl    %fs
184 doreti_popl_es:
185         popl    %es
186 doreti_popl_ds:
187         popl    %ds
188         popal
189         addl    $3*4,%esp       /* xflags, trap, err */
190 doreti_iret:
191         iret
192
193         ALIGN_TEXT
194         .globl  doreti_iret_fault
195 doreti_iret_fault:
196         subl    $3*4,%esp       /* xflags, trap, err */
197         pushal
198         pushl   %ds
199         .globl  doreti_popl_ds_fault
200 doreti_popl_ds_fault:
201         pushl   %es
202         .globl  doreti_popl_es_fault
203 doreti_popl_es_fault:
204         pushl   %fs
205         .globl  doreti_popl_fs_fault
206 doreti_popl_fs_fault:
207         pushl   %gs
208         .globl  doreti_popl_gs_fault
209 doreti_popl_gs_fault:
210         movl    $0,TF_ERR(%esp) /* XXX should be the error code */
211         movl    $T_PROTFLT,TF_TRAPNO(%esp)
212         jmp     alltraps_with_regs_pushed
213
214         /*
215          * FAST interrupt pending.  NOTE: stack context holds frame structure
216          * for fast interrupt procedure, do not do random pushes or pops!
217          */
218         ALIGN_TEXT
219 doreti_fast:
220         andl    PCPU(fpending),%ecx     /* only check fast ints */
221         bsfl    %ecx, %ecx              /* locate the next dispatchable int */
222         btrl    %ecx, PCPU(fpending)    /* is it really still pending? */
223         jnc     doreti_next
224         pushl   %eax                    /* save IRQ mask unavailable for BGL */
225                                         /* NOTE: is also CPL in frame */
226 #if 0
227 #ifdef SMP
228         pushl   %ecx                    /* save ecx */
229         call    try_mplock
230         popl    %ecx
231         testl   %eax,%eax
232         jz      1f
233         /* MP lock successful */
234 #endif
235 #endif
236         incl    PCPU(intr_nesting_level)
237         call    dofastunpend            /* unpend fast intr %ecx */
238         decl    PCPU(intr_nesting_level)
239 #if 0
240 #ifdef SMP
241         call    rel_mplock
242 #endif
243 #endif
244         popl    %eax
245         jmp     doreti_next
246 1:
247         btsl    %ecx, PCPU(fpending)    /* oops, couldn't get the MP lock */
248         popl    %eax                    /* add to temp. cpl mask to ignore */
249         orl     PCPU(fpending),%eax
250         jmp     doreti_next
251
252         /*
253          *  INTR interrupt pending
254          *
255          *  Temporarily back-out our critical section to allow an interrupt
256          *  preempt us when we schedule it.  Bump intr_nesting_level to
257          *  prevent the switch code from recursing via splz too deeply.
258          */
259         ALIGN_TEXT
260 doreti_intr:
261         andl    PCPU(ipending),%ecx     /* only check normal ints */
262         bsfl    %ecx, %ecx              /* locate the next dispatchable int */
263         btrl    %ecx, PCPU(ipending)    /* is it really still pending? */
264         jnc     doreti_next
265         pushl   %eax
266         pushl   %ecx
267         incl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
268         subl    $TDPRI_CRIT,TD_PRI(%ebx) /* so we can preempt */
269         call    sched_ithd              /* YYY must pull in imasks */
270         addl    $TDPRI_CRIT,TD_PRI(%ebx)
271         decl    TD_NEST_COUNT(%ebx)
272         addl    $4,%esp
273         popl    %eax
274         jmp     doreti_next
275
276         /*
277          *  SOFT interrupt pending
278          *
279          *  Temporarily back-out our critical section to allow an interrupt
280          *  preempt us when we schedule it.  Bump intr_nesting_level to
281          *  prevent the switch code from recursing via splz too deeply.
282          */
283         ALIGN_TEXT
284 doreti_soft:
285         bsfl    %ecx,%ecx               /* locate the next pending softint */
286         btrl    %ecx,PCPU(spending)     /* make sure its still pending */
287         jnc     doreti_next
288         addl    $FIRST_SOFTINT,%ecx     /* actual intr number */
289         pushl   %eax
290         pushl   %ecx
291         incl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
292         subl    $TDPRI_CRIT,TD_PRI(%ebx) /* so we can preempt */
293         call    sched_ithd              /* YYY must pull in imasks */
294         addl    $TDPRI_CRIT,TD_PRI(%ebx)
295         decl    TD_NEST_COUNT(%ebx)
296         addl    $4,%esp
297         popl    %eax
298         jmp     doreti_next
299
300         /*
301          * AST pending.  We clear RQF_AST_SIGNAL automatically, the others
302          * are cleared by the trap as they are processed.
303          *
304          * Temporarily back-out our critical section because trap() can be
305          * a long-winded call, and we want to be more syscall-like.  
306          *
307          * YYY theoretically we can call lwkt_switch directly if all we need
308          * to do is a reschedule.
309          */
310 doreti_ast:
311         andl    $~(RQF_AST_SIGNAL|RQF_AST_UPCALL),PCPU(reqflags)
312         sti
313         movl    %eax,%esi               /* save cpl (can't use stack) */
314         movl    $T_ASTFLT,TF_TRAPNO(%esp)
315         pushl   %esp                    /* pass frame by reference */
316         subl    $TDPRI_CRIT,TD_PRI(%ebx)
317         call    trap
318         addl    $TDPRI_CRIT,TD_PRI(%ebx)
319         addl    $4,%esp
320         movl    %esi,%eax               /* restore cpl for loop */
321         jmp     doreti_next
322
323 #ifdef SMP
324         /*
325          * IPIQ message pending.  We clear RQF_IPIQ automatically.
326          */
327 doreti_ipiq:
328         movl    %eax,%esi               /* save cpl (can't use stack) */
329         incl    PCPU(intr_nesting_level)
330         andl    $~RQF_IPIQ,PCPU(reqflags)
331         subl    $8,%esp                 /* add dummy vec and ppl */
332         pushl   %esp                    /* pass frame by reference */
333         call    lwkt_process_ipiq_frame
334         addl    $12,%esp
335         decl    PCPU(intr_nesting_level)
336         movl    %esi,%eax               /* restore cpl for loop */
337         jmp     doreti_next
338
339 doreti_timer:
340         movl    %eax,%esi               /* save cpl (can't use stack) */
341         incl    PCPU(intr_nesting_level)
342         andl    $~RQF_TIMER,PCPU(reqflags)
343         subl    $8,%esp                 /* add dummy vec and ppl */
344         pushl   %esp                    /* pass frame by reference */
345         call    lapic_timer_process_frame
346         addl    $12,%esp
347         decl    PCPU(intr_nesting_level)
348         movl    %esi,%eax               /* restore cpl for loop */
349         jmp     doreti_next
350
351 #endif
352
353         /*
354          * SPLZ() a C callable procedure to dispatch any unmasked pending
355          *        interrupts regardless of critical section nesting.  ASTs
356          *        are not dispatched.
357          *
358          *        Use %eax to track those IRQs that could not be processed
359          *        due to BGL requirements.
360          */
361         SUPERALIGN_TEXT
362
363 ENTRY(splz)
364         pushfl
365         pushl   %ebx
366         movl    PCPU(curthread),%ebx
367         addl    $TDPRI_CRIT,TD_PRI(%ebx)
368         movl    $0,%eax
369
370 splz_next:
371         cli
372         movl    %eax,%ecx               /* ecx = ~CPL */
373         notl    %ecx
374 #ifdef SMP
375         testl   $RQF_IPIQ,PCPU(reqflags)
376         jnz     splz_ipiq
377         testl   $RQF_TIMER,PCPU(reqflags)
378         jnz     splz_timer
379 #endif
380         testl   PCPU(fpending),%ecx     /* check for an unmasked fast int */
381         jnz     splz_fast
382
383         testl   PCPU(ipending),%ecx
384         jnz     splz_intr
385
386         movl    PCPU(spending),%ecx
387         cmpl    $0,%ecx
388         jnz     splz_soft
389
390         subl    $TDPRI_CRIT,TD_PRI(%ebx)
391
392         /*
393          * Nothing left to do, finish up.  Interrupts are still disabled.
394          * If our mask of IRQs we couldn't process due to BGL requirements
395          * is 0 then there are no pending interrupt sources left and we
396          * can clear RQF_INTPEND.
397          */
398         testl   %eax,%eax
399         jnz     5f
400         andl    $~RQF_INTPEND,PCPU(reqflags)
401 5:
402         popl    %ebx
403         popfl
404         ret
405
406         /*
407          * FAST interrupt pending
408          */
409         ALIGN_TEXT
410 splz_fast:
411         andl    PCPU(fpending),%ecx     /* only check fast ints */
412         bsfl    %ecx, %ecx              /* locate the next dispatchable int */
413         btrl    %ecx, PCPU(fpending)    /* is it really still pending? */
414         jnc     splz_next
415         pushl   %eax
416 #if 0
417 #ifdef SMP
418         pushl   %ecx
419         call    try_mplock
420         popl    %ecx
421         testl   %eax,%eax
422         jz      1f
423 #endif
424 #endif
425         incl    PCPU(intr_nesting_level)
426         call    dofastunpend            /* unpend fast intr %ecx */
427         decl    PCPU(intr_nesting_level)
428 #if 0
429 #ifdef SMP
430         call    rel_mplock
431 #endif
432 #endif
433         popl    %eax
434         jmp     splz_next
435 1:
436         btsl    %ecx, PCPU(fpending)    /* oops, couldn't get the MP lock */
437         popl    %eax
438         orl     PCPU(fpending),%eax
439         jmp     splz_next
440
441         /*
442          *  INTR interrupt pending
443          *
444          *  Temporarily back-out our critical section to allow the interrupt
445          *  preempt us.
446          */
447         ALIGN_TEXT
448 splz_intr:
449         andl    PCPU(ipending),%ecx     /* only check normal ints */
450         bsfl    %ecx, %ecx              /* locate the next dispatchable int */
451         btrl    %ecx, PCPU(ipending)    /* is it really still pending? */
452         jnc     splz_next
453         sti
454         pushl   %eax
455         pushl   %ecx
456         subl    $TDPRI_CRIT,TD_PRI(%ebx)
457         incl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
458         call    sched_ithd              /* YYY must pull in imasks */
459         addl    $TDPRI_CRIT,TD_PRI(%ebx)
460         decl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
461         addl    $4,%esp
462         popl    %eax
463         jmp     splz_next
464
465         /*
466          *  SOFT interrupt pending
467          *
468          *  Temporarily back-out our critical section to allow the interrupt
469          *  preempt us.
470          */
471         ALIGN_TEXT
472 splz_soft:
473         bsfl    %ecx,%ecx               /* locate the next pending softint */
474         btrl    %ecx,PCPU(spending)     /* make sure its still pending */
475         jnc     splz_next
476         addl    $FIRST_SOFTINT,%ecx     /* actual intr number */
477         sti
478         pushl   %eax
479         pushl   %ecx
480         subl    $TDPRI_CRIT,TD_PRI(%ebx)
481         incl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
482         call    sched_ithd              /* YYY must pull in imasks */
483         addl    $TDPRI_CRIT,TD_PRI(%ebx)
484         decl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
485         addl    $4,%esp
486         popl    %eax
487         jmp     splz_next
488
489 #ifdef SMP
490 splz_ipiq:
491         andl    $~RQF_IPIQ,PCPU(reqflags)
492         pushl   %eax
493         call    lwkt_process_ipiq
494         popl    %eax
495         jmp     splz_next
496
497 splz_timer:
498         andl    $~RQF_TIMER,PCPU(reqflags)
499         pushl   %eax
500         call    lapic_timer_process
501         popl    %eax
502         jmp     splz_next
503 #endif
504
505         /*
506          * dofastunpend(%ecx:intr)
507          *
508          * A FAST interrupt previously made pending can now be run,
509          * execute it by pushing a dummy interrupt frame and 
510          * calling ithread_fast_handler to execute or schedule it.
511          * 
512          * ithread_fast_handler() returns 0 if it wants us to unmask
513          * further interrupts.
514          */
515 #define PUSH_DUMMY                                                      \
516         pushfl ;                /* phys int frame / flags */            \
517         pushl   %cs ;           /* phys int frame / cs */               \
518         pushl   12(%esp) ;      /* original caller eip */               \
519         pushl   $0 ;            /* dummy error code */                  \
520         pushl   $0 ;            /* dummy trap type */                   \
521         pushl   $0 ;            /* dummy xflags */                      \
522         subl    $13*4,%esp ;    /* pushal + 4 seg regs (dummy) + CPL */ \
523
524 #define POP_DUMMY                                                       \
525         addl    $19*4,%esp ;                                            \
526
527 dofastunpend:
528         pushl   %ebp                    /* frame for backtrace */
529         movl    %esp,%ebp
530         PUSH_DUMMY
531         pushl   %ecx                    /* last part of intrframe = intr */
532         incl    fastunpend_count
533         pushl   %esp                    /* pass frame by reference */
534         call    ithread_fast_handler    /* returns 0 to unmask */
535         addl    $4,%esp                 /* remove pointer, now intr on top */
536         cmpl    $0,%eax
537         jnz     1f
538         movl    MachIntrABI + MACHINTR_INTREN, %eax
539         call    *%eax                   /* MachIntrABI.intren(intr) */
540 1:
541         addl    $4,%esp
542         POP_DUMMY
543         popl    %ebp
544         ret
545