5498149979ab1a4aa4dc3e9ac8891443e68e8a4d
[dragonfly.git] / sys / kern / kern_intr.c
1 /*
2  * Copyright (c) 2003, Matthew Dillon <dillon@backplane.com> All rights reserved.
3  * Copyright (c) 1997, Stefan Esser <se@freebsd.org> All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice unmodified, this list of conditions, and the following
10  *    disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/kern/kern_intr.c,v 1.24.2.1 2001/10/14 20:05:50 luigi Exp $
27  * $DragonFly: src/sys/kern/kern_intr.c,v 1.7 2003/07/04 05:57:27 dillon Exp $
28  *
29  */
30
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/malloc.h>
34 #include <sys/kernel.h>
35 #include <sys/sysctl.h>
36 #include <sys/thread.h>
37 #include <sys/proc.h>
38 #include <sys/thread2.h>
39 #include <sys/random.h>
40
41 #include <machine/ipl.h>
42
43 #include <sys/interrupt.h>
44
45 typedef struct intrec {
46     struct intrec *next;
47     inthand2_t  *handler;
48     void        *argument;
49     const char  *name;
50     int         intr;
51 } intrec_t;
52
53 static intrec_t *intlists[NHWI+NSWI];
54 static thread_t ithreads[NHWI+NSWI];
55 static struct thread ithread_ary[NHWI+NSWI];
56 static struct random_softc irandom_ary[NHWI+NSWI];
57
58 static void ithread_handler(void *arg);
59
60 void
61 register_swi(int intr, inthand2_t *handler, void *arg, const char *name)
62 {
63     if (intr < NHWI || intr >= NHWI + NSWI)
64         panic("register_swi: bad intr %d", intr);
65     register_int(intr, handler, arg, name);
66 }
67
68 void
69 register_int(int intr, inthand2_t *handler, void *arg, const char *name)
70 {
71     intrec_t **list;
72     intrec_t *rec;
73     thread_t td;
74
75     if (intr < 0 || intr > NHWI + NSWI)
76         panic("register_int: bad intr %d", intr);
77
78     rec = malloc(sizeof(intrec_t), M_DEVBUF, M_NOWAIT);
79     if (rec == NULL)
80         panic("register_swi: malloc failed");
81     rec->handler = handler;
82     rec->argument = arg;
83     rec->name = name;
84     rec->intr = intr;
85     rec->next = NULL;
86
87     list = &intlists[intr];
88
89     /*
90      * Create an interrupt thread if necessary, leave it in an unscheduled
91      * state.  The kthread restore function exits a critical section before
92      * starting the function so we need *TWO* critical sections in order
93      * for the handler to begin running in one.
94      */
95     if ((td = ithreads[intr]) == NULL) {
96         lwkt_create((void *)ithread_handler, (void *)intr, &ithreads[intr],
97             &ithread_ary[intr], TDF_STOPREQ, "ithread %d", intr);
98         td = ithreads[intr];
99         if (intr >= NHWI && intr < NHWI + NSWI)
100             lwkt_setpri(td, TDPRI_SOFT_NORM + TDPRI_CRIT * 2);
101         else
102             lwkt_setpri(td, TDPRI_INT_MED + TDPRI_CRIT * 2);
103     }
104
105     /*
106      * Add the record to the interrupt list
107      */
108     crit_enter();       /* token */
109     while (*list != NULL)
110         list = &(*list)->next;
111     *list = rec;
112     crit_exit();
113 }
114
115 void
116 unregister_swi(int intr, inthand2_t *handler)
117 {
118     if (intr < NHWI || intr >= NHWI + NSWI)
119         panic("register_swi: bad intr %d", intr);
120     unregister_int(intr, handler);
121 }
122
123 void
124 unregister_int(int intr, inthand2_t handler)
125 {
126     intrec_t **list;
127     intrec_t *rec;
128
129     if (intr < 0 || intr > NHWI + NSWI)
130         panic("register_int: bad intr %d", intr);
131     list = &intlists[intr];
132     crit_enter();
133     while ((rec = *list) != NULL) {
134         if (rec->handler == (void *)handler) {
135             *list = rec->next;
136             break;
137         }
138         list = &rec->next;
139     }
140     crit_exit();
141     if (rec != NULL) {
142         free(rec, M_DEVBUF);
143     } else {
144         printf("warning: unregister_int: int %d handler %p not found\n",
145             intr, handler);
146     }
147 }
148
149 void
150 swi_setpriority(int intr, int pri)
151 {
152     struct thread *td;
153
154     if (intr < NHWI || intr >= NHWI + NSWI)
155         panic("register_swi: bad intr %d", intr);
156     if ((td = ithreads[intr]) != NULL)
157         lwkt_setpri(td, pri);
158 }
159
160 void
161 register_randintr(int intr)
162 {
163     struct random_softc *sc = &irandom_ary[intr];
164     sc->sc_intr = intr;
165     sc->sc_enabled = 1;
166 }
167
168 void
169 unregister_randintr(int intr)
170 {
171     struct random_softc *sc = &irandom_ary[intr];
172     sc->sc_enabled = 0;
173 }
174
175 /*
176  * Dispatch an interrupt.  If there's nothing to do we have a stray
177  * interrupt and can just return, leaving the interrupt masked.
178  */
179 void
180 sched_ithd(int intr)
181 {
182     thread_t td;
183
184     if ((td = ithreads[intr]) != NULL) {
185         if (intlists[intr] == NULL) {
186             printf("sched_ithd: stray interrupt %d\n", intr);
187         } else {
188             lwkt_schedule(td);
189             lwkt_preempt(td, intr);
190         }
191     } else {
192         printf("sched_ithd: stray interrupt %d\n", intr);
193     }
194 }
195
196 /*
197  * Interrupt threads run this as their main loop.  The handler should be
198  * in a critical section on entry.
199  */
200 static void
201 ithread_handler(void *arg)
202 {
203     int intr = (int)arg;
204     intrec_t **list = &intlists[intr];
205     intrec_t *rec;
206     intrec_t *nrec;
207     struct random_softc *sc = &irandom_ary[intr];
208
209     KKASSERT(curthread->td_pri >= TDPRI_CRIT);
210     for (;;) {
211         for (rec = *list; rec; rec = nrec) {
212             nrec = rec->next;
213             rec->handler(rec->argument);
214         }
215         if (sc->sc_enabled)
216                 add_interrupt_randomness(intr);
217         ithread_done(intr);
218     }
219 }
220
221
222 /* 
223  * Sysctls used by systat and others: hw.intrnames and hw.intrcnt.
224  * The data for this machine dependent, and the declarations are in machine
225  * dependent code.  The layout of intrnames and intrcnt however is machine
226  * independent.
227  *
228  * We do not know the length of intrcnt and intrnames at compile time, so
229  * calculate things at run time.
230  */
231 static int
232 sysctl_intrnames(SYSCTL_HANDLER_ARGS)
233 {
234         return (sysctl_handle_opaque(oidp, intrnames, eintrnames - intrnames, 
235             req));
236 }
237
238 SYSCTL_PROC(_hw, OID_AUTO, intrnames, CTLTYPE_OPAQUE | CTLFLAG_RD,
239         NULL, 0, sysctl_intrnames, "", "Interrupt Names");
240
241 static int
242 sysctl_intrcnt(SYSCTL_HANDLER_ARGS)
243 {
244         return (sysctl_handle_opaque(oidp, intrcnt, 
245             (char *)eintrcnt - (char *)intrcnt, req));
246 }
247
248 SYSCTL_PROC(_hw, OID_AUTO, intrcnt, CTLTYPE_OPAQUE | CTLFLAG_RD,
249         NULL, 0, sysctl_intrcnt, "", "Interrupt Counts");