736cb0bd498f8ff5c7a50d8b60e3130da43d9d7f
[linux-2.6.git] / kernel / irq / chip.c
1 /*
2  * linux/kernel/irq/chip.c
3  *
4  * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
5  * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
6  *
7  * This file contains the core interrupt handling code, for irq-chip
8  * based architectures.
9  *
10  * Detailed information is available in Documentation/DocBook/genericirq
11  */
12
13 #include <linux/irq.h>
14 #include <linux/module.h>
15 #include <linux/interrupt.h>
16 #include <linux/kernel_stat.h>
17
18 #include "internals.h"
19
20 /**
21  *      set_irq_chip - set the irq chip for an irq
22  *      @irq:   irq number
23  *      @chip:  pointer to irq chip description structure
24  */
25 int set_irq_chip(unsigned int irq, struct irq_chip *chip)
26 {
27         struct irq_desc *desc;
28         unsigned long flags;
29
30         if (irq >= NR_IRQS) {
31                 printk(KERN_ERR "Trying to install chip for IRQ%d\n", irq);
32                 WARN_ON(1);
33                 return -EINVAL;
34         }
35
36         if (!chip)
37                 chip = &no_irq_chip;
38
39         desc = irq_desc + irq;
40         spin_lock_irqsave(&desc->lock, flags);
41         irq_chip_set_defaults(chip);
42         desc->chip = chip;
43         spin_unlock_irqrestore(&desc->lock, flags);
44
45         return 0;
46 }
47 EXPORT_SYMBOL(set_irq_chip);
48
49 /**
50  *      set_irq_type - set the irq type for an irq
51  *      @irq:   irq number
52  *      @type:  interrupt type - see include/linux/interrupt.h
53  */
54 int set_irq_type(unsigned int irq, unsigned int type)
55 {
56         struct irq_desc *desc;
57         unsigned long flags;
58         int ret = -ENXIO;
59
60         if (irq >= NR_IRQS) {
61                 printk(KERN_ERR "Trying to set irq type for IRQ%d\n", irq);
62                 return -ENODEV;
63         }
64
65         desc = irq_desc + irq;
66         if (desc->chip->set_type) {
67                 spin_lock_irqsave(&desc->lock, flags);
68                 ret = desc->chip->set_type(irq, type);
69                 spin_unlock_irqrestore(&desc->lock, flags);
70         }
71         return ret;
72 }
73 EXPORT_SYMBOL(set_irq_type);
74
75 /**
76  *      set_irq_data - set irq type data for an irq
77  *      @irq:   Interrupt number
78  *      @data:  Pointer to interrupt specific data
79  *
80  *      Set the hardware irq controller data for an irq
81  */
82 int set_irq_data(unsigned int irq, void *data)
83 {
84         struct irq_desc *desc;
85         unsigned long flags;
86
87         if (irq >= NR_IRQS) {
88                 printk(KERN_ERR
89                        "Trying to install controller data for IRQ%d\n", irq);
90                 return -EINVAL;
91         }
92
93         desc = irq_desc + irq;
94         spin_lock_irqsave(&desc->lock, flags);
95         desc->handler_data = data;
96         spin_unlock_irqrestore(&desc->lock, flags);
97         return 0;
98 }
99 EXPORT_SYMBOL(set_irq_data);
100
101 /**
102  *      set_irq_chip_data - set irq chip data for an irq
103  *      @irq:   Interrupt number
104  *      @data:  Pointer to chip specific data
105  *
106  *      Set the hardware irq chip data for an irq
107  */
108 int set_irq_chip_data(unsigned int irq, void *data)
109 {
110         struct irq_desc *desc = irq_desc + irq;
111         unsigned long flags;
112
113         if (irq >= NR_IRQS || !desc->chip) {
114                 printk(KERN_ERR "BUG: bad set_irq_chip_data(IRQ#%d)\n", irq);
115                 return -EINVAL;
116         }
117
118         spin_lock_irqsave(&desc->lock, flags);
119         desc->chip_data = data;
120         spin_unlock_irqrestore(&desc->lock, flags);
121
122         return 0;
123 }
124 EXPORT_SYMBOL(set_irq_chip_data);
125
126 /*
127  * default enable function
128  */
129 static void default_enable(unsigned int irq)
130 {
131         struct irq_desc *desc = irq_desc + irq;
132
133         desc->chip->unmask(irq);
134         desc->status &= ~IRQ_MASKED;
135 }
136
137 /*
138  * default disable function
139  */
140 static void default_disable(unsigned int irq)
141 {
142         struct irq_desc *desc = irq_desc + irq;
143
144         if (!(desc->status & IRQ_DELAYED_DISABLE))
145                 desc->chip->mask(irq);
146 }
147
148 /*
149  * default startup function
150  */
151 static unsigned int default_startup(unsigned int irq)
152 {
153         irq_desc[irq].chip->enable(irq);
154
155         return 0;
156 }
157
158 /*
159  * Fixup enable/disable function pointers
160  */
161 void irq_chip_set_defaults(struct irq_chip *chip)
162 {
163         if (!chip->enable)
164                 chip->enable = default_enable;
165         if (!chip->disable)
166                 chip->disable = default_disable;
167         if (!chip->startup)
168                 chip->startup = default_startup;
169         if (!chip->shutdown)
170                 chip->shutdown = chip->disable;
171         if (!chip->name)
172                 chip->name = chip->typename;
173 }
174
175 static inline void mask_ack_irq(struct irq_desc *desc, int irq)
176 {
177         if (desc->chip->mask_ack)
178                 desc->chip->mask_ack(irq);
179         else {
180                 desc->chip->mask(irq);
181                 desc->chip->ack(irq);
182         }
183 }
184
185 /**
186  *      handle_simple_irq - Simple and software-decoded IRQs.
187  *      @irq:   the interrupt number
188  *      @desc:  the interrupt description structure for this irq
189  *      @regs:  pointer to a register structure
190  *
191  *      Simple interrupts are either sent from a demultiplexing interrupt
192  *      handler or come from hardware, where no interrupt hardware control
193  *      is necessary.
194  *
195  *      Note: The caller is expected to handle the ack, clear, mask and
196  *      unmask issues if necessary.
197  */
198 void fastcall
199 handle_simple_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs)
200 {
201         struct irqaction *action;
202         irqreturn_t action_ret;
203         const unsigned int cpu = smp_processor_id();
204
205         spin_lock(&desc->lock);
206
207         if (unlikely(desc->status & IRQ_INPROGRESS))
208                 goto out_unlock;
209         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
210         kstat_cpu(cpu).irqs[irq]++;
211
212         action = desc->action;
213         if (unlikely(!action || (desc->status & IRQ_DISABLED)))
214                 goto out_unlock;
215
216         desc->status |= IRQ_INPROGRESS;
217         spin_unlock(&desc->lock);
218
219         action_ret = handle_IRQ_event(irq, regs, action);
220         if (!noirqdebug)
221                 note_interrupt(irq, desc, action_ret, regs);
222
223         spin_lock(&desc->lock);
224         desc->status &= ~IRQ_INPROGRESS;
225 out_unlock:
226         spin_unlock(&desc->lock);
227 }
228
229 /**
230  *      handle_level_irq - Level type irq handler
231  *      @irq:   the interrupt number
232  *      @desc:  the interrupt description structure for this irq
233  *      @regs:  pointer to a register structure
234  *
235  *      Level type interrupts are active as long as the hardware line has
236  *      the active level. This may require to mask the interrupt and unmask
237  *      it after the associated handler has acknowledged the device, so the
238  *      interrupt line is back to inactive.
239  */
240 void fastcall
241 handle_level_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs)
242 {
243         unsigned int cpu = smp_processor_id();
244         struct irqaction *action;
245         irqreturn_t action_ret;
246
247         spin_lock(&desc->lock);
248         mask_ack_irq(desc, irq);
249
250         if (unlikely(desc->status & IRQ_INPROGRESS))
251                 goto out_unlock;
252         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
253         kstat_cpu(cpu).irqs[irq]++;
254
255         /*
256          * If its disabled or no action available
257          * keep it masked and get out of here
258          */
259         action = desc->action;
260         if (unlikely(!action || (desc->status & IRQ_DISABLED))) {
261                 desc->status |= IRQ_PENDING;
262                 goto out_unlock;
263         }
264
265         desc->status |= IRQ_INPROGRESS;
266         desc->status &= ~IRQ_PENDING;
267         spin_unlock(&desc->lock);
268
269         action_ret = handle_IRQ_event(irq, regs, action);
270         if (!noirqdebug)
271                 note_interrupt(irq, desc, action_ret, regs);
272
273         spin_lock(&desc->lock);
274         desc->status &= ~IRQ_INPROGRESS;
275         if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
276                 desc->chip->unmask(irq);
277 out_unlock:
278         spin_unlock(&desc->lock);
279 }
280
281 /**
282  *      handle_fasteoi_irq - irq handler for transparent controllers
283  *      @irq:   the interrupt number
284  *      @desc:  the interrupt description structure for this irq
285  *      @regs:  pointer to a register structure
286  *
287  *      Only a single callback will be issued to the chip: an ->eoi()
288  *      call when the interrupt has been serviced. This enables support
289  *      for modern forms of interrupt handlers, which handle the flow
290  *      details in hardware, transparently.
291  */
292 void fastcall
293 handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc,
294                    struct pt_regs *regs)
295 {
296         unsigned int cpu = smp_processor_id();
297         struct irqaction *action;
298         irqreturn_t action_ret;
299
300         spin_lock(&desc->lock);
301
302         if (unlikely(desc->status & IRQ_INPROGRESS))
303                 goto out;
304
305         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
306         kstat_cpu(cpu).irqs[irq]++;
307
308         /*
309          * If its disabled or no action available
310          * keep it masked and get out of here
311          */
312         action = desc->action;
313         if (unlikely(!action || (desc->status & IRQ_DISABLED))) {
314                 desc->status |= IRQ_PENDING;
315                 goto out;
316         }
317
318         desc->status |= IRQ_INPROGRESS;
319         desc->status &= ~IRQ_PENDING;
320         spin_unlock(&desc->lock);
321
322         action_ret = handle_IRQ_event(irq, regs, action);
323         if (!noirqdebug)
324                 note_interrupt(irq, desc, action_ret, regs);
325
326         spin_lock(&desc->lock);
327         desc->status &= ~IRQ_INPROGRESS;
328 out:
329         desc->chip->eoi(irq);
330
331         spin_unlock(&desc->lock);
332 }
333
334 /**
335  *      handle_edge_irq - edge type IRQ handler
336  *      @irq:   the interrupt number
337  *      @desc:  the interrupt description structure for this irq
338  *      @regs:  pointer to a register structure
339  *
340  *      Interrupt occures on the falling and/or rising edge of a hardware
341  *      signal. The occurence is latched into the irq controller hardware
342  *      and must be acked in order to be reenabled. After the ack another
343  *      interrupt can happen on the same source even before the first one
344  *      is handled by the assosiacted event handler. If this happens it
345  *      might be necessary to disable (mask) the interrupt depending on the
346  *      controller hardware. This requires to reenable the interrupt inside
347  *      of the loop which handles the interrupts which have arrived while
348  *      the handler was running. If all pending interrupts are handled, the
349  *      loop is left.
350  */
351 void fastcall
352 handle_edge_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs)
353 {
354         const unsigned int cpu = smp_processor_id();
355
356         spin_lock(&desc->lock);
357
358         desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
359
360         /*
361          * If we're currently running this IRQ, or its disabled,
362          * we shouldn't process the IRQ. Mark it pending, handle
363          * the necessary masking and go out
364          */
365         if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
366                     !desc->action)) {
367                 desc->status |= (IRQ_PENDING | IRQ_MASKED);
368                 mask_ack_irq(desc, irq);
369                 goto out_unlock;
370         }
371
372         kstat_cpu(cpu).irqs[irq]++;
373
374         /* Start handling the irq */
375         desc->chip->ack(irq);
376
377         /* Mark the IRQ currently in progress.*/
378         desc->status |= IRQ_INPROGRESS;
379
380         do {
381                 struct irqaction *action = desc->action;
382                 irqreturn_t action_ret;
383
384                 if (unlikely(!action)) {
385                         desc->chip->mask(irq);
386                         goto out_unlock;
387                 }
388
389                 /*
390                  * When another irq arrived while we were handling
391                  * one, we could have masked the irq.
392                  * Renable it, if it was not disabled in meantime.
393                  */
394                 if (unlikely((desc->status &
395                                (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
396                               (IRQ_PENDING | IRQ_MASKED))) {
397                         desc->chip->unmask(irq);
398                         desc->status &= ~IRQ_MASKED;
399                 }
400
401                 desc->status &= ~IRQ_PENDING;
402                 spin_unlock(&desc->lock);
403                 action_ret = handle_IRQ_event(irq, regs, action);
404                 if (!noirqdebug)
405                         note_interrupt(irq, desc, action_ret, regs);
406                 spin_lock(&desc->lock);
407
408         } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
409
410         desc->status &= ~IRQ_INPROGRESS;
411 out_unlock:
412         spin_unlock(&desc->lock);
413 }
414
415 #ifdef CONFIG_SMP
416 /**
417  *      handle_percpu_IRQ - Per CPU local irq handler
418  *      @irq:   the interrupt number
419  *      @desc:  the interrupt description structure for this irq
420  *      @regs:  pointer to a register structure
421  *
422  *      Per CPU interrupts on SMP machines without locking requirements
423  */
424 void fastcall
425 handle_percpu_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs)
426 {
427         irqreturn_t action_ret;
428
429         kstat_this_cpu.irqs[irq]++;
430
431         if (desc->chip->ack)
432                 desc->chip->ack(irq);
433
434         action_ret = handle_IRQ_event(irq, regs, desc->action);
435         if (!noirqdebug)
436                 note_interrupt(irq, desc, action_ret, regs);
437
438         if (desc->chip->eoi)
439                 desc->chip->eoi(irq);
440 }
441
442 #endif /* CONFIG_SMP */
443
444 void
445 __set_irq_handler(unsigned int irq,
446                   void fastcall (*handle)(unsigned int, irq_desc_t *,
447                                           struct pt_regs *),
448                   int is_chained)
449 {
450         struct irq_desc *desc;
451         unsigned long flags;
452
453         if (irq >= NR_IRQS) {
454                 printk(KERN_ERR
455                        "Trying to install type control for IRQ%d\n", irq);
456                 return;
457         }
458
459         desc = irq_desc + irq;
460
461         if (!handle)
462                 handle = handle_bad_irq;
463
464         if (desc->chip == &no_irq_chip) {
465                 printk(KERN_WARNING "Trying to install %sinterrupt handler "
466                        "for IRQ%d\n", is_chained ? "chained " : " ", irq);
467                 /*
468                  * Some ARM implementations install a handler for really dumb
469                  * interrupt hardware without setting an irq_chip. This worked
470                  * with the ARM no_irq_chip but the check in setup_irq would
471                  * prevent us to setup the interrupt at all. Switch it to
472                  * dummy_irq_chip for easy transition.
473                  */
474                 desc->chip = &dummy_irq_chip;
475         }
476
477         spin_lock_irqsave(&desc->lock, flags);
478
479         /* Uninstall? */
480         if (handle == handle_bad_irq) {
481                 if (desc->chip != &no_irq_chip) {
482                         desc->chip->mask(irq);
483                         desc->chip->ack(irq);
484                 }
485                 desc->status |= IRQ_DISABLED;
486                 desc->depth = 1;
487         }
488         desc->handle_irq = handle;
489
490         if (handle != handle_bad_irq && is_chained) {
491                 desc->status &= ~IRQ_DISABLED;
492                 desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE;
493                 desc->depth = 0;
494                 desc->chip->unmask(irq);
495         }
496         spin_unlock_irqrestore(&desc->lock, flags);
497 }
498
499 void
500 set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
501                          void fastcall (*handle)(unsigned int,
502                                                  struct irq_desc *,
503                                                  struct pt_regs *))
504 {
505         set_irq_chip(irq, chip);
506         __set_irq_handler(irq, handle, 0);
507 }
508
509 /*
510  * Get a descriptive string for the highlevel handler, for
511  * /proc/interrupts output:
512  */
513 const char *
514 handle_irq_name(void fastcall (*handle)(unsigned int, struct irq_desc *,
515                                         struct pt_regs *))
516 {
517         if (handle == handle_level_irq)
518                 return "level  ";
519         if (handle == handle_fasteoi_irq)
520                 return "fasteoi";
521         if (handle == handle_edge_irq)
522                 return "edge   ";
523         if (handle == handle_simple_irq)
524                 return "simple ";
525 #ifdef CONFIG_SMP
526         if (handle == handle_percpu_irq)
527                 return "percpu ";
528 #endif
529         if (handle == handle_bad_irq)
530                 return "bad    ";
531
532         return NULL;
533 }