Remove all remaining SPL code. Replace the mtd_cpl field in the machine
[dragonfly.git] / sys / i386 / 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/i386/isa/Attic/ipl.s,v 1.18 2005/06/16 21:12:47 dillon Exp $
41  */
42
43
44 /*
45  * AT/386
46  * Vector interrupt control section
47  *
48  *  ipending    - Pending interrupts (set when a masked interrupt occurs)
49  */
50
51         .text
52         /*
53          * GENERAL NOTES
54          *
55          *      - fast interrupts are always called with a critical section
56          *        held
57          *
58          *      - we release our critical section when scheduling interrupt
59          *        or softinterrupt threads in order so they can preempt
60          *        (unless we are called manually from a critical section, in
61          *        which case there will still be a critical section and
62          *        they won't preempt anyway).
63          *
64          *      - TD_NEST_COUNT prevents splz from nesting too deeply within
65          *        itself.  It is *not* actually an interrupt nesting count.
66          *        PCPU(intr_nesting_level) is an interrupt nesting count.
67          *
68          *      - We have to be careful in regards to local interrupts
69          *        occuring simultaniously with our doreti and splz 
70          *        processing.
71          */
72
73         /*
74          * DORETI
75          *
76          * Handle return from interrupts, traps and syscalls.  This function
77          * checks the cpl for unmasked pending interrupts (fast, normal, or
78          * soft) and schedules them if appropriate, then irets.
79          *
80          * If we are in a critical section we cannot run any pending ints
81          * nor can be play with mp_lock.
82          *
83          * NOTE: Since SPLs no longer exist, all callers of this function
84          * push $0 for the CPL.  HOWEVER, we *STILL* use the cpl mask within
85          * this function to mark fast interrupts which could not be dispatched
86          * do to the unavailability of the BGL.
87          */
88         SUPERALIGN_TEXT
89         .type   doreti,@function
90 doreti:
91         FAKE_MCOUNT(bintr)              /* init "from" bintr -> doreti */
92         popl    %eax                    /* cpl to restore XXX */
93         movl    $0,%eax                 /* irq mask unavailable due to BGL */
94         movl    PCPU(curthread),%ebx
95         cli                             /* interlock with TDPRI_CRIT */
96         cmpl    $0,PCPU(reqflags)       /* short cut if nothing to do */
97         je      5f
98         cmpl    $TDPRI_CRIT,TD_PRI(%ebx) /* can't unpend if in critical sec */
99         jge     5f
100         addl    $TDPRI_CRIT,TD_PRI(%ebx) /* force all ints to pending */
101 doreti_next:
102         sti                             /* allow new interrupts */
103         movl    %eax,%ecx               /* irq mask unavailable due to BGL */
104         notl    %ecx
105         cli                             /* disallow YYY remove */
106 #ifdef SMP
107         testl   $RQF_IPIQ,PCPU(reqflags)
108         jnz     doreti_ipiq
109 #endif
110         testl   PCPU(fpending),%ecx     /* check for an unmasked fast int */
111         jnz     doreti_fast
112
113         testl   PCPU(ipending),%ecx
114         jnz     doreti_intr
115
116         testl   $RQF_AST_MASK,PCPU(reqflags) /* any pending ASTs? */
117         jz      2f
118         testl   $PSL_VM,TF_EFLAGS(%esp)
119         jz      1f
120         cmpl    $1,in_vm86call          /* YYY make per 'cpu'? */
121         jnz     doreti_ast
122 1:
123         /* ASTs are only applicable when returning to userland */
124         testb   $SEL_RPL_MASK,TF_CS(%esp)
125         jnz     doreti_ast
126 2:
127         /*
128          * Nothing left to do, finish up.  Interrupts are still disabled.
129          * %eax contains the mask of IRQ's that are not available due to
130          * BGL requirements.  We can only clear RQF_INTPEND if *ALL* pending
131          * interrupts have been processed.
132          */
133         subl    $TDPRI_CRIT,TD_PRI(%ebx)        /* interlocked with cli */
134         testl   %eax,%eax
135         jnz     5f
136         andl    $~RQF_INTPEND,PCPU(reqflags)
137 5:
138         MEXITCOUNT
139         .globl  doreti_popl_fs
140         .globl  doreti_popl_es
141         .globl  doreti_popl_ds
142         .globl  doreti_iret
143         .globl  doreti_syscall_ret
144 doreti_syscall_ret:
145 doreti_popl_fs:
146         popl    %fs
147 doreti_popl_es:
148         popl    %es
149 doreti_popl_ds:
150         popl    %ds
151         popal
152         addl    $8,%esp
153 doreti_iret:
154         iret
155
156         ALIGN_TEXT
157         .globl  doreti_iret_fault
158 doreti_iret_fault:
159         subl    $8,%esp
160         pushal
161         pushl   %ds
162         .globl  doreti_popl_ds_fault
163 doreti_popl_ds_fault:
164         pushl   %es
165         .globl  doreti_popl_es_fault
166 doreti_popl_es_fault:
167         pushl   %fs
168         .globl  doreti_popl_fs_fault
169 doreti_popl_fs_fault:
170         movl    $0,TF_ERR(%esp) /* XXX should be the error code */
171         movl    $T_PROTFLT,TF_TRAPNO(%esp)
172         jmp     alltraps_with_regs_pushed
173
174         /*
175          * FAST interrupt pending.  NOTE: stack context holds frame structure
176          * for fast interrupt procedure, do not do random pushes or pops!
177          */
178         ALIGN_TEXT
179 doreti_fast:
180         andl    PCPU(fpending),%ecx     /* only check fast ints */
181         bsfl    %ecx, %ecx              /* locate the next dispatchable int */
182         btrl    %ecx, PCPU(fpending)    /* is it really still pending? */
183         jnc     doreti_next
184         pushl   %eax                    /* save IRQ mask unavailable for BGL */
185                                         /* NOTE: is also CPL in frame */
186 #ifdef SMP
187         pushl   %ecx                    /* save ecx */
188         call    try_mplock
189         popl    %ecx
190         testl   %eax,%eax
191         jz      1f
192         /* MP lock successful */
193 #endif
194         incl    PCPU(intr_nesting_level)
195         call    *fastunpend(,%ecx,4)
196         decl    PCPU(intr_nesting_level)
197 #ifdef SMP
198         call    rel_mplock
199 #endif
200         popl    %eax
201         jmp     doreti_next
202 1:
203         btsl    %ecx, PCPU(fpending)    /* oops, couldn't get the MP lock */
204         popl    %eax                    /* add to temp. cpl mask to ignore */
205         orl     PCPU(fpending),%eax
206         jmp     doreti_next
207
208         /*
209          *  INTR interrupt pending
210          *
211          *  Temporarily back-out our critical section to allow an interrupt
212          *  preempt us when we schedule it.  Bump intr_nesting_level to
213          *  prevent the switch code from recursing via splz too deeply.
214          */
215         ALIGN_TEXT
216 doreti_intr:
217         andl    PCPU(ipending),%ecx     /* only check normal ints */
218         bsfl    %ecx, %ecx              /* locate the next dispatchable int */
219         btrl    %ecx, PCPU(ipending)    /* is it really still pending? */
220         jnc     doreti_next
221         pushl   %eax
222         pushl   %ecx
223         incl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
224         subl    $TDPRI_CRIT,TD_PRI(%ebx) /* so we can preempt */
225         call    sched_ithd              /* YYY must pull in imasks */
226         addl    $TDPRI_CRIT,TD_PRI(%ebx)
227         decl    TD_NEST_COUNT(%ebx)
228         addl    $4,%esp
229         popl    %eax
230         jmp     doreti_next
231
232         /*
233          * AST pending.  We clear RQF_AST_SIGNAL automatically, the others
234          * are cleared by the trap as they are processed.
235          *
236          * Temporarily back-out our critical section because trap() can be
237          * a long-winded call, and we want to be more syscall-like.  
238          *
239          * YYY theoretically we can call lwkt_switch directly if all we need
240          * to do is a reschedule.
241          */
242 doreti_ast:
243         andl    $~(RQF_AST_SIGNAL|RQF_AST_UPCALL),PCPU(reqflags)
244         sti
245         movl    %eax,%esi               /* save cpl (can't use stack) */
246         movl    $T_ASTFLT,TF_TRAPNO(%esp)
247         subl    $TDPRI_CRIT,TD_PRI(%ebx)
248 1:      call    trap
249         addl    $TDPRI_CRIT,TD_PRI(%ebx)
250         movl    %esi,%eax               /* restore cpl for loop */
251         jmp     doreti_next
252
253 #ifdef SMP
254         /*
255          * IPIQ message pending.  We clear RQF_IPIQ automatically.
256          */
257 doreti_ipiq:
258         movl    %eax,%esi               /* save cpl (can't use stack) */
259         incl    PCPU(intr_nesting_level)
260         andl    $~RQF_IPIQ,PCPU(reqflags)
261         subl    $8,%esp                 /* add dummy vec and ppl */
262         call    lwkt_process_ipiq_frame
263         addl    $8,%esp
264         decl    PCPU(intr_nesting_level)
265         movl    %esi,%eax               /* restore cpl for loop */
266         jmp     doreti_next
267
268 #endif
269
270         /*
271          * SPLZ() a C callable procedure to dispatch any unmasked pending
272          *        interrupts regardless of critical section nesting.  ASTs
273          *        are not dispatched.
274          *
275          *        Use %eax to track those IRQs that could not be processed
276          *        due to BGL requirements.
277          */
278         SUPERALIGN_TEXT
279
280 ENTRY(splz)
281         pushfl
282         pushl   %ebx
283         movl    PCPU(curthread),%ebx
284         addl    $TDPRI_CRIT,TD_PRI(%ebx)
285         movl    $0,%eax
286
287 splz_next:
288         cli
289         movl    %eax,%ecx               /* ecx = ~CPL */
290         notl    %ecx
291 #ifdef SMP
292         testl   $RQF_IPIQ,PCPU(reqflags)
293         jnz     splz_ipiq
294 #endif
295         testl   PCPU(fpending),%ecx     /* check for an unmasked fast int */
296         jnz     splz_fast
297
298         testl   PCPU(ipending),%ecx
299         jnz     splz_intr
300
301         subl    $TDPRI_CRIT,TD_PRI(%ebx)
302
303         /*
304          * Nothing left to do, finish up.  Interrupts are still disabled.
305          * If our mask of IRQs we couldn't process due to BGL requirements
306          * is 0 then there are no pending interrupt sources left and we
307          * can clear RQF_INTPEND.
308          */
309         testl   %eax,%eax
310         jnz     5f
311         andl    $~RQF_INTPEND,PCPU(reqflags)
312 5:
313         popl    %ebx
314         popfl
315         ret
316
317         /*
318          * FAST interrupt pending
319          */
320         ALIGN_TEXT
321 splz_fast:
322         andl    PCPU(fpending),%ecx     /* only check fast ints */
323         bsfl    %ecx, %ecx              /* locate the next dispatchable int */
324         btrl    %ecx, PCPU(fpending)    /* is it really still pending? */
325         jnc     splz_next
326         pushl   %eax
327 #ifdef SMP
328         pushl   %ecx
329         call    try_mplock
330         popl    %ecx
331         testl   %eax,%eax
332         jz      1f
333 #endif
334         incl    PCPU(intr_nesting_level)
335         call    *fastunpend(,%ecx,4)
336         decl    PCPU(intr_nesting_level)
337 #ifdef SMP
338         call    rel_mplock
339 #endif
340         popl    %eax
341         jmp     splz_next
342 1:
343         btsl    %ecx, PCPU(fpending)    /* oops, couldn't get the MP lock */
344         popl    %eax
345         orl     PCPU(fpending),%eax
346         jmp     splz_next
347
348         /*
349          *  INTR interrupt pending
350          *
351          *  Temporarily back-out our critical section to allow the interrupt
352          *  preempt us.
353          */
354         ALIGN_TEXT
355 splz_intr:
356         andl    PCPU(ipending),%ecx     /* only check normal ints */
357         bsfl    %ecx, %ecx              /* locate the next dispatchable int */
358         btrl    %ecx, PCPU(ipending)    /* is it really still pending? */
359         jnc     splz_next
360         sti
361         pushl   %eax
362         pushl   %ecx
363         subl    $TDPRI_CRIT,TD_PRI(%ebx)
364         incl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
365         call    sched_ithd              /* YYY must pull in imasks */
366         addl    $TDPRI_CRIT,TD_PRI(%ebx)
367         decl    TD_NEST_COUNT(%ebx)     /* prevent doreti/splz nesting */
368         addl    $4,%esp
369         popl    %eax
370         jmp     splz_next
371
372 #ifdef SMP
373 splz_ipiq:
374         andl    $~RQF_IPIQ,PCPU(reqflags)
375         pushl   %eax
376         call    lwkt_process_ipiq
377         popl    %eax
378         jmp     splz_next
379 #endif
380
381         /*
382          * APIC/ICU specific ipl functions provide masking and unmasking
383          * calls for userland.
384          */
385
386 #ifdef APIC_IO
387 #include "i386/isa/apic_ipl.s"
388 #else
389 #include "i386/isa/icu_ipl.s"
390 #endif /* APIC_IO */