Annotation of prex-old/sys/kern/irq.c, Revision 1.1.1.1
1.1 nbrk 1: /*-
2: * Copyright (c) 2005-2007, Kohsuke Ohtani
3: * 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, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. Neither the name of the author nor the names of any co-contributors
14: * may be used to endorse or promote products derived from this software
15: * without specific prior written permission.
16: *
17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27: * SUCH DAMAGE.
28: */
29:
30: /*
31: * irq.c - interrupt request management routines.
32: */
33:
34: /**
35: * We define the following two different types of interrupt
36: * services in order to improve real-time performance.
37: *
38: * - Interrupt Service Routine (ISR)
39: *
40: * ISR is started by an actual hardware interrupt. The associated
41: * interrupt is disabled in Interrupt Control Unit (ICU), and CPU
42: * interrupt is enabled while ISR runs.
43: * If ISR determines that the corresponding device generated the
44: * interrupt, ISR must program the device to stop that interrupt.
45: * Then, ISR should do minimum I/O operation and return control
46: * as quickly as possible. ISR will run within a context of the
47: * thread running when interrupt occurs. So, only few kernel
48: * services are available within ISR. We can use irq_level value
49: * to detect the illegal call from ISR code.
50: *
51: * - Interrupt Service Thread (IST)
52: *
53: * IST is automatically activated if ISR returns INT_CONTINUE. It
54: * will be called when the system enters safer condition than ISR.
55: * A device driver should use IST to do heavy I/O operation as much
56: * as possible. Since ISR for the same IRQ line may be invoked
57: * during IST, the shared data, resources, and device registers
58: * must be synchronized by using irq_lock(). IST does not have to
59: * be reentrant because it is not interrupted by same IST itself.
60: */
61:
62: #include <kernel.h>
63: #include <event.h>
64: #include <kmem.h>
65: #include <sched.h>
66: #include <thread.h>
67: #include <irq.h>
68:
69: /* forward declarations */
70: static void irq_thread(u_long);
71:
72: static struct irq *irq_table[NIRQS]; /* IRQ descriptor table */
73: static volatile int nr_irq_locks; /* lock count for interrupt */
74: static volatile int saved_irq_state; /* IRQ state saved by irq_lock() */
75:
76: /*
77: * irq_attach - attach ISR and IST to the specified interrupt.
78: * @vector: interrupt vector number
79: * @prio: interrupt priority level.
80: * @shared: true if it allows the IRQ sharing.
81: * @isr: pointer to the interrupt service routine.
82: * @ist: pointer to the interrupt service thread. NULL for no ist.
83: *
84: * irq_attach() returns irq handle which is needed for irq_detach().
85: * Or, it returns -1 if it failed.
86: * The interrupt of attached irq will be unmasked (enabled) in this
87: * routine.
88: *
89: * TODO: Interrupt sharing is not supported, for now.
90: */
91: int
92: irq_attach(int vector, int prio, int shared, int (*isr)(int),
93: void (*ist)(int))
94: {
95: struct irq *irq;
96: thread_t th;
97: int mode;
98:
99: ASSERT(irq_level == 0);
100: ASSERT(isr != NULL);
101:
102: sched_lock();
103: if ((irq = kmem_alloc(sizeof(struct irq))) == NULL) {
104: sched_unlock();
105: return -1;
106: }
107: memset(irq, 0, sizeof(struct irq));
108: irq->vector = vector;
109: irq->isr = isr;
110: irq->ist = ist;
111:
112: if (ist != NULL) {
113: /*
114: * Create a new thread for IST.
115: */
116: th = kernel_thread(ISTPRIO(prio), irq_thread, (u_long)irq);
117: if (th == NULL)
118: panic("irq_attach");
119: irq->thread = th;
120: event_init(&irq->ist_event, "interrupt");
121: }
122: irq_table[vector] = irq;
123: mode = shared ? IMODE_LEVEL : IMODE_EDGE;
124:
125: irq_lock();
126: interrupt_setup(vector, mode);
127: interrupt_unmask(vector, prio);
128: irq_unlock();
129:
130: sched_unlock();
131: printk("IRQ%d attached priority=%d\n", vector, prio);
132: return (int)irq;
133: }
134:
135: /*
136: * Detach an interrupt handler from the interrupt chain.
137: * The detached interrupt will be masked off if nobody attaches
138: * to it, anymore.
139: */
140: void
141: irq_detach(int handle)
142: {
143: struct irq *irq = (struct irq *)handle;
144:
145: ASSERT(irq_level == 0);
146: ASSERT(irq);
147: ASSERT(irq->vector < NIRQS);
148:
149: irq_lock();
150: interrupt_mask(irq->vector);
151: irq_unlock();
152:
153: irq_table[irq->vector] = NULL;
154: if (irq->thread != NULL)
155: thread_kill(irq->thread);
156: kmem_free(irq);
157: }
158:
159: /*
160: * Lock IRQ.
161: *
162: * All H/W interrupts are masked off.
163: * Caller is no need to save the interrupt state before irq_lock()
164: * because it is automatically restored in irq_unlock() when no one
165: * is locking the IRQ anymore.
166: */
167: void
168: irq_lock(void)
169: {
170: int s;
171:
172: interrupt_save(&s);
173: interrupt_disable();
174: if (++nr_irq_locks == 1)
175: saved_irq_state = s;
176: }
177:
178: /*
179: * Unlock IRQ.
180: *
181: * If lock count becomes 0, the interrupt is restored to original
182: * state at first irq_lock() call.
183: */
184: void
185: irq_unlock(void)
186: {
187: ASSERT(nr_irq_locks > 0);
188:
189: if (--nr_irq_locks == 0)
190: interrupt_restore(saved_irq_state);
191: }
192:
193: /*
194: * Interrupt service thread.
195: * This is a common dispatcher to all interrupt threads.
196: */
197: static void
198: irq_thread(u_long arg)
199: {
200: int vec;
201: void (*func)(int);
202: struct irq *irq;
203:
204: interrupt_enable();
205:
206: irq = (struct irq *)arg;
207: func = irq->ist;
208: vec = irq->vector;
209:
210: for (;;) {
211: interrupt_disable();
212: if (irq->ist_request <= 0) {
213: /*
214: * Since the interrupt is disabled above, an
215: * interrupt for this vector keeps pending until
216: * this thread enters sleep state. Thus, we don't
217: * lose any IST requests even if the interrupt
218: * is fired here.
219: */
220: sched_sleep(&irq->ist_event);
221: }
222: irq->ist_request--;
223: ASSERT(irq->ist_request >= 0);
224: interrupt_enable();
225:
226: /* Call IST */
227: (func)(vec);
228: }
229: /* NOTREACHED */
230: }
231:
232: /*
233: * Interrupt handler.
234: *
235: * This routine will call the corresponding ISR for the requested
236: * interrupt vector. This routine is called from the code in the
237: * architecture dependent layer. We assumes the scheduler is already
238: * locked by caller.
239: */
240: void
241: irq_handler(int vector)
242: {
243: struct irq *irq;
244: int rc;
245:
246: irq = irq_table[vector];
247: if (irq == NULL)
248: return; /* Ignore stray interrupt */
249: ASSERT(irq->isr);
250:
251: /* Call ISR */
252: rc = (irq->isr)(vector);
253:
254: if (rc == INT_CONTINUE) {
255: /* Kick IST */
256: ASSERT(irq->ist);
257: irq->ist_request++;
258: sched_wakeup(&irq->ist_event);
259: }
260: irq->count++;
261: }
262:
263: #if defined(DEBUG) && defined(CONFIG_KDUMP)
264: void
265: irq_dump(void)
266: {
267: int vector;
268: struct irq *irq;
269:
270: printk("IRQ dump:\n");
271: printk(" vector isr ist prio count\n");
272: printk(" ------ -------- -------- -------- --------\n");
273:
274: for (vector = 0; vector < NIRQS; vector++) {
275: irq = irq_table[vector];
276: if (irq) {
277: printk(" %4d %08x %08x %3d %8d\n",
278: vector, irq->isr, irq->ist,
279: (irq->thread ? irq->thread->prio : 0),
280: irq->count);
281: }
282: }
283: }
284: #endif
285:
286: void
287: irq_init(void)
288: {
289: /*
290: * Start interrupt processing.
291: */
292: interrupt_enable();
293: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to irq.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / sys / kern