Linux-2.6.12-rc2
[linux-2.6.git] / arch / cris / kernel / irq.c
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