Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * | |
3 | * linux/arch/cris/kernel/irq.c | |
4 | * | |
5 | * Copyright (c) 2000,2001 Axis Communications AB | |
6 | * | |
7 | * Authors: Bjorn Wesen (bjornw@axis.com) | |
8 | * | |
9 | * This file contains the code used by various IRQ handling routines: | |
10 | * asking for different IRQ's should be done through these routines | |
11 | * instead of just grabbing them. Thus setups with different IRQ numbers | |
12 | * shouldn't result in any weird surprises, and installing new handlers | |
13 | * should be easier. | |
14 | * | |
15 | * Notice Linux/CRIS: these routines do not care about SMP | |
16 | * | |
17 | */ | |
18 | ||
19 | /* | |
20 | * IRQ's are in fact implemented a bit like signal handlers for the kernel. | |
21 | * Naturally it's not a 1:1 relation, but there are similarities. | |
22 | */ | |
23 | ||
24 | #include <linux/config.h> | |
25 | #include <linux/module.h> | |
26 | #include <linux/ptrace.h> | |
27 | ||
28 | #include <linux/kernel_stat.h> | |
29 | #include <linux/signal.h> | |
30 | #include <linux/sched.h> | |
31 | #include <linux/ioport.h> | |
32 | #include <linux/interrupt.h> | |
33 | #include <linux/timex.h> | |
34 | #include <linux/slab.h> | |
35 | #include <linux/random.h> | |
36 | #include <linux/init.h> | |
37 | #include <linux/seq_file.h> | |
38 | #include <linux/errno.h> | |
39 | #include <linux/bitops.h> | |
40 | ||
41 | #include <asm/io.h> | |
42 | ||
43 | /* Defined in arch specific irq.c */ | |
44 | extern void arch_setup_irq(int irq); | |
45 | extern void arch_free_irq(int irq); | |
46 | ||
47 | void | |
48 | disable_irq(unsigned int irq_nr) | |
49 | { | |
50 | unsigned long flags; | |
51 | ||
52 | local_save_flags(flags); | |
53 | local_irq_disable(); | |
54 | mask_irq(irq_nr); | |
55 | local_irq_restore(flags); | |
56 | } | |
57 | ||
58 | void | |
59 | enable_irq(unsigned int irq_nr) | |
60 | { | |
61 | unsigned long flags; | |
62 | local_save_flags(flags); | |
63 | local_irq_disable(); | |
64 | unmask_irq(irq_nr); | |
65 | local_irq_restore(flags); | |
66 | } | |
67 | ||
68 | unsigned long | |
69 | probe_irq_on() | |
70 | { | |
71 | return 0; | |
72 | } | |
73 | ||
74 | EXPORT_SYMBOL(probe_irq_on); | |
75 | ||
76 | int | |
77 | probe_irq_off(unsigned long x) | |
78 | { | |
79 | return 0; | |
80 | } | |
81 | ||
82 | EXPORT_SYMBOL(probe_irq_off); | |
83 | ||
84 | /* | |
85 | * Initial irq handlers. | |
86 | */ | |
87 | ||
88 | static struct irqaction *irq_action[NR_IRQS]; | |
89 | ||
90 | int show_interrupts(struct seq_file *p, void *v) | |
91 | { | |
92 | int i = *(loff_t *) v; | |
93 | struct irqaction * action; | |
94 | unsigned long flags; | |
95 | ||
96 | if (i < NR_IRQS) { | |
97 | local_irq_save(flags); | |
98 | action = irq_action[i]; | |
99 | if (!action) | |
100 | goto skip; | |
101 | seq_printf(p, "%2d: %10u %c %s", | |
102 | i, kstat_this_cpu.irqs[i], | |
103 | (action->flags & SA_INTERRUPT) ? '+' : ' ', | |
104 | action->name); | |
105 | for (action = action->next; action; action = action->next) { | |
106 | seq_printf(p, ",%s %s", | |
107 | (action->flags & SA_INTERRUPT) ? " +" : "", | |
108 | action->name); | |
109 | } | |
110 | seq_putc(p, '\n'); | |
111 | skip: | |
112 | local_irq_restore(flags); | |
113 | } | |
114 | return 0; | |
115 | } | |
116 | ||
117 | /* called by the assembler IRQ entry functions defined in irq.h | |
118 | * to dispatch the interrupts to registred handlers | |
119 | * interrupts are disabled upon entry - depending on if the | |
120 | * interrupt was registred with SA_INTERRUPT or not, interrupts | |
121 | * are re-enabled or not. | |
122 | */ | |
123 | ||
124 | asmlinkage void do_IRQ(int irq, struct pt_regs * regs) | |
125 | { | |
126 | struct irqaction *action; | |
127 | int do_random, cpu; | |
128 | int ret, retval = 0; | |
129 | ||
130 | cpu = smp_processor_id(); | |
131 | irq_enter(); | |
132 | kstat_cpu(cpu).irqs[irq - FIRST_IRQ]++; | |
133 | action = irq_action[irq - FIRST_IRQ]; | |
134 | ||
135 | if (action) { | |
136 | if (!(action->flags & SA_INTERRUPT)) | |
137 | local_irq_enable(); | |
138 | do_random = 0; | |
139 | do { | |
140 | ret = action->handler(irq, action->dev_id, regs); | |
141 | if (ret == IRQ_HANDLED) | |
142 | do_random |= action->flags; | |
143 | retval |= ret; | |
144 | action = action->next; | |
145 | } while (action); | |
146 | ||
147 | if (retval != 1) { | |
148 | if (retval) { | |
149 | printk("irq event %d: bogus retval mask %x\n", | |
150 | irq, retval); | |
151 | } else { | |
152 | printk("irq %d: nobody cared\n", irq); | |
153 | } | |
154 | } | |
155 | ||
156 | if (do_random & SA_SAMPLE_RANDOM) | |
157 | add_interrupt_randomness(irq); | |
158 | local_irq_disable(); | |
159 | } | |
160 | irq_exit(); | |
161 | } | |
162 | ||
163 | /* this function links in a handler into the chain of handlers for the | |
164 | given irq, and if the irq has never been registred, the appropriate | |
165 | handler is entered into the interrupt vector | |
166 | */ | |
167 | ||
168 | int setup_irq(int irq, struct irqaction * new) | |
169 | { | |
170 | int shared = 0; | |
171 | struct irqaction *old, **p; | |
172 | unsigned long flags; | |
173 | ||
174 | p = irq_action + irq - FIRST_IRQ; | |
175 | if ((old = *p) != NULL) { | |
176 | /* Can't share interrupts unless both agree to */ | |
177 | if (!(old->flags & new->flags & SA_SHIRQ)) | |
178 | return -EBUSY; | |
179 | ||
180 | /* Can't share interrupts unless both are same type */ | |
181 | if ((old->flags ^ new->flags) & SA_INTERRUPT) | |
182 | return -EBUSY; | |
183 | ||
184 | /* add new interrupt at end of irq queue */ | |
185 | do { | |
186 | p = &old->next; | |
187 | old = *p; | |
188 | } while (old); | |
189 | shared = 1; | |
190 | } | |
191 | ||
192 | if (new->flags & SA_SAMPLE_RANDOM) | |
193 | rand_initialize_irq(irq); | |
194 | ||
195 | local_save_flags(flags); | |
196 | local_irq_disable(); | |
197 | *p = new; | |
198 | ||
199 | if (!shared) { | |
200 | /* if the irq wasn't registred before, enter it into the vector table | |
201 | and unmask it physically | |
202 | */ | |
203 | arch_setup_irq(irq); | |
204 | unmask_irq(irq); | |
205 | } | |
206 | ||
207 | local_irq_restore(flags); | |
208 | return 0; | |
209 | } | |
210 | ||
211 | /* this function is called by a driver to register an irq handler | |
212 | Valid flags: | |
213 | SA_INTERRUPT -> it's a fast interrupt, handler called with irq disabled and | |
214 | no signal checking etc is performed upon exit | |
215 | SA_SHIRQ -> the interrupt can be shared between different handlers, the handler | |
216 | is required to check if the irq was "aimed" at it explicitely | |
217 | SA_RANDOM -> the interrupt will add to the random generators entropy | |
218 | */ | |
219 | ||
220 | int request_irq(unsigned int irq, | |
221 | irqreturn_t (*handler)(int, void *, struct pt_regs *), | |
222 | unsigned long irqflags, | |
223 | const char * devname, | |
224 | void *dev_id) | |
225 | { | |
226 | int retval; | |
227 | struct irqaction * action; | |
228 | ||
229 | if(!handler) | |
230 | return -EINVAL; | |
231 | ||
232 | /* allocate and fill in a handler structure and setup the irq */ | |
233 | ||
234 | action = (struct irqaction *)kmalloc(sizeof(struct irqaction), GFP_KERNEL); | |
235 | if (!action) | |
236 | return -ENOMEM; | |
237 | ||
238 | action->handler = handler; | |
239 | action->flags = irqflags; | |
240 | cpus_clear(action->mask); | |
241 | action->name = devname; | |
242 | action->next = NULL; | |
243 | action->dev_id = dev_id; | |
244 | ||
245 | retval = setup_irq(irq, action); | |
246 | ||
247 | if (retval) | |
248 | kfree(action); | |
249 | return retval; | |
250 | } | |
251 | ||
252 | EXPORT_SYMBOL(request_irq); | |
253 | ||
254 | void free_irq(unsigned int irq, void *dev_id) | |
255 | { | |
256 | struct irqaction * action, **p; | |
257 | unsigned long flags; | |
258 | ||
259 | if (irq >= NR_IRQS) { | |
260 | printk("Trying to free IRQ%d\n",irq); | |
261 | return; | |
262 | } | |
263 | for (p = irq - FIRST_IRQ + irq_action; (action = *p) != NULL; p = &action->next) { | |
264 | if (action->dev_id != dev_id) | |
265 | continue; | |
266 | ||
267 | /* Found it - now free it */ | |
268 | local_save_flags(flags); | |
269 | local_irq_disable(); | |
270 | *p = action->next; | |
271 | if (!irq_action[irq - FIRST_IRQ]) { | |
272 | mask_irq(irq); | |
273 | arch_free_irq(irq); | |
274 | } | |
275 | local_irq_restore(flags); | |
276 | kfree(action); | |
277 | return; | |
278 | } | |
279 | printk("Trying to free free IRQ%d\n",irq); | |
280 | } | |
281 | ||
282 | EXPORT_SYMBOL(free_irq); | |
283 | ||
284 | void weird_irq(void) | |
285 | { | |
286 | local_irq_disable(); | |
287 | printk("weird irq\n"); | |
288 | while(1); | |
289 | } | |
290 | ||
291 | #if defined(CONFIG_PROC_FS) && defined(CONFIG_SYSCTL) | |
292 | /* Used by other archs to show/control IRQ steering during SMP */ | |
293 | void __init | |
294 | init_irq_proc(void) | |
295 | { | |
296 | } | |
297 | #endif |