genirq: Make irq_shutdown() symmetric vs. irq_startup again
[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/msi.h>
15 #include <linux/module.h>
16 #include <linux/interrupt.h>
17 #include <linux/kernel_stat.h>
18
19 #include "internals.h"
20
21 /**
22  *      irq_set_chip - set the irq chip for an irq
23  *      @irq:   irq number
24  *      @chip:  pointer to irq chip description structure
25  */
26 int irq_set_chip(unsigned int irq, struct irq_chip *chip)
27 {
28         unsigned long flags;
29         struct irq_desc *desc = irq_get_desc_lock(irq, &flags);
30
31         if (!desc)
32                 return -EINVAL;
33
34         if (!chip)
35                 chip = &no_irq_chip;
36
37         desc->irq_data.chip = chip;
38         irq_put_desc_unlock(desc, flags);
39         /*
40          * For !CONFIG_SPARSE_IRQ make the irq show up in
41          * allocated_irqs. For the CONFIG_SPARSE_IRQ case, it is
42          * already marked, and this call is harmless.
43          */
44         irq_reserve_irq(irq);
45         return 0;
46 }
47 EXPORT_SYMBOL(irq_set_chip);
48
49 /**
50  *      irq_set_type - set the irq trigger type for an irq
51  *      @irq:   irq number
52  *      @type:  IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
53  */
54 int irq_set_irq_type(unsigned int irq, unsigned int type)
55 {
56         unsigned long flags;
57         struct irq_desc *desc = irq_get_desc_buslock(irq, &flags);
58         int ret = 0;
59
60         if (!desc)
61                 return -EINVAL;
62
63         type &= IRQ_TYPE_SENSE_MASK;
64         if (type != IRQ_TYPE_NONE)
65                 ret = __irq_set_trigger(desc, irq, type);
66         irq_put_desc_busunlock(desc, flags);
67         return ret;
68 }
69 EXPORT_SYMBOL(irq_set_irq_type);
70
71 /**
72  *      irq_set_handler_data - set irq handler data for an irq
73  *      @irq:   Interrupt number
74  *      @data:  Pointer to interrupt specific data
75  *
76  *      Set the hardware irq controller data for an irq
77  */
78 int irq_set_handler_data(unsigned int irq, void *data)
79 {
80         unsigned long flags;
81         struct irq_desc *desc = irq_get_desc_lock(irq, &flags);
82
83         if (!desc)
84                 return -EINVAL;
85         desc->irq_data.handler_data = data;
86         irq_put_desc_unlock(desc, flags);
87         return 0;
88 }
89 EXPORT_SYMBOL(irq_set_handler_data);
90
91 /**
92  *      irq_set_msi_desc - set MSI descriptor data for an irq
93  *      @irq:   Interrupt number
94  *      @entry: Pointer to MSI descriptor data
95  *
96  *      Set the MSI descriptor entry for an irq
97  */
98 int irq_set_msi_desc(unsigned int irq, struct msi_desc *entry)
99 {
100         unsigned long flags;
101         struct irq_desc *desc = irq_get_desc_lock(irq, &flags);
102
103         if (!desc)
104                 return -EINVAL;
105         desc->irq_data.msi_desc = entry;
106         if (entry)
107                 entry->irq = irq;
108         irq_put_desc_unlock(desc, flags);
109         return 0;
110 }
111
112 /**
113  *      irq_set_chip_data - set irq chip data for an irq
114  *      @irq:   Interrupt number
115  *      @data:  Pointer to chip specific data
116  *
117  *      Set the hardware irq chip data for an irq
118  */
119 int irq_set_chip_data(unsigned int irq, void *data)
120 {
121         unsigned long flags;
122         struct irq_desc *desc = irq_get_desc_lock(irq, &flags);
123
124         if (!desc)
125                 return -EINVAL;
126         desc->irq_data.chip_data = data;
127         irq_put_desc_unlock(desc, flags);
128         return 0;
129 }
130 EXPORT_SYMBOL(irq_set_chip_data);
131
132 struct irq_data *irq_get_irq_data(unsigned int irq)
133 {
134         struct irq_desc *desc = irq_to_desc(irq);
135
136         return desc ? &desc->irq_data : NULL;
137 }
138 EXPORT_SYMBOL_GPL(irq_get_irq_data);
139
140 static void irq_state_clr_disabled(struct irq_desc *desc)
141 {
142         irqd_clear(&desc->irq_data, IRQD_IRQ_DISABLED);
143 }
144
145 static void irq_state_set_disabled(struct irq_desc *desc)
146 {
147         irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
148 }
149
150 static void irq_state_clr_masked(struct irq_desc *desc)
151 {
152         irqd_clear(&desc->irq_data, IRQD_IRQ_MASKED);
153 }
154
155 static void irq_state_set_masked(struct irq_desc *desc)
156 {
157         irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);
158 }
159
160 int irq_startup(struct irq_desc *desc)
161 {
162         irq_state_clr_disabled(desc);
163         desc->depth = 0;
164
165         if (desc->irq_data.chip->irq_startup) {
166                 int ret = desc->irq_data.chip->irq_startup(&desc->irq_data);
167                 irq_state_clr_masked(desc);
168                 return ret;
169         }
170
171         irq_enable(desc);
172         return 0;
173 }
174
175 void irq_shutdown(struct irq_desc *desc)
176 {
177         irq_state_set_disabled(desc);
178         desc->depth = 1;
179         if (desc->irq_data.chip->irq_shutdown)
180                 desc->irq_data.chip->irq_shutdown(&desc->irq_data);
181         else if (desc->irq_data.chip->irq_disable)
182                 desc->irq_data.chip->irq_disable(&desc->irq_data);
183         else
184                 desc->irq_data.chip->irq_mask(&desc->irq_data);
185         irq_state_set_masked(desc);
186 }
187
188 void irq_enable(struct irq_desc *desc)
189 {
190         irq_state_clr_disabled(desc);
191         if (desc->irq_data.chip->irq_enable)
192                 desc->irq_data.chip->irq_enable(&desc->irq_data);
193         else
194                 desc->irq_data.chip->irq_unmask(&desc->irq_data);
195         irq_state_clr_masked(desc);
196 }
197
198 void irq_disable(struct irq_desc *desc)
199 {
200         irq_state_set_disabled(desc);
201         if (desc->irq_data.chip->irq_disable) {
202                 desc->irq_data.chip->irq_disable(&desc->irq_data);
203                 irq_state_set_masked(desc);
204         }
205 }
206
207 static inline void mask_ack_irq(struct irq_desc *desc)
208 {
209         if (desc->irq_data.chip->irq_mask_ack)
210                 desc->irq_data.chip->irq_mask_ack(&desc->irq_data);
211         else {
212                 desc->irq_data.chip->irq_mask(&desc->irq_data);
213                 if (desc->irq_data.chip->irq_ack)
214                         desc->irq_data.chip->irq_ack(&desc->irq_data);
215         }
216         irq_state_set_masked(desc);
217 }
218
219 void mask_irq(struct irq_desc *desc)
220 {
221         if (desc->irq_data.chip->irq_mask) {
222                 desc->irq_data.chip->irq_mask(&desc->irq_data);
223                 irq_state_set_masked(desc);
224         }
225 }
226
227 void unmask_irq(struct irq_desc *desc)
228 {
229         if (desc->irq_data.chip->irq_unmask) {
230                 desc->irq_data.chip->irq_unmask(&desc->irq_data);
231                 irq_state_clr_masked(desc);
232         }
233 }
234
235 /*
236  *      handle_nested_irq - Handle a nested irq from a irq thread
237  *      @irq:   the interrupt number
238  *
239  *      Handle interrupts which are nested into a threaded interrupt
240  *      handler. The handler function is called inside the calling
241  *      threads context.
242  */
243 void handle_nested_irq(unsigned int irq)
244 {
245         struct irq_desc *desc = irq_to_desc(irq);
246         struct irqaction *action;
247         irqreturn_t action_ret;
248
249         might_sleep();
250
251         raw_spin_lock_irq(&desc->lock);
252
253         kstat_incr_irqs_this_cpu(irq, desc);
254
255         action = desc->action;
256         if (unlikely(!action || irqd_irq_disabled(&desc->irq_data)))
257                 goto out_unlock;
258
259         irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
260         raw_spin_unlock_irq(&desc->lock);
261
262         action_ret = action->thread_fn(action->irq, action->dev_id);
263         if (!noirqdebug)
264                 note_interrupt(irq, desc, action_ret);
265
266         raw_spin_lock_irq(&desc->lock);
267         irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
268
269 out_unlock:
270         raw_spin_unlock_irq(&desc->lock);
271 }
272 EXPORT_SYMBOL_GPL(handle_nested_irq);
273
274 static bool irq_check_poll(struct irq_desc *desc)
275 {
276         if (!(desc->istate & IRQS_POLL_INPROGRESS))
277                 return false;
278         return irq_wait_for_poll(desc);
279 }
280
281 /**
282  *      handle_simple_irq - Simple and software-decoded IRQs.
283  *      @irq:   the interrupt number
284  *      @desc:  the interrupt description structure for this irq
285  *
286  *      Simple interrupts are either sent from a demultiplexing interrupt
287  *      handler or come from hardware, where no interrupt hardware control
288  *      is necessary.
289  *
290  *      Note: The caller is expected to handle the ack, clear, mask and
291  *      unmask issues if necessary.
292  */
293 void
294 handle_simple_irq(unsigned int irq, struct irq_desc *desc)
295 {
296         raw_spin_lock(&desc->lock);
297
298         if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
299                 if (!irq_check_poll(desc))
300                         goto out_unlock;
301
302         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
303         kstat_incr_irqs_this_cpu(irq, desc);
304
305         if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data)))
306                 goto out_unlock;
307
308         handle_irq_event(desc);
309
310 out_unlock:
311         raw_spin_unlock(&desc->lock);
312 }
313 EXPORT_SYMBOL_GPL(handle_simple_irq);
314
315 /**
316  *      handle_level_irq - Level type irq handler
317  *      @irq:   the interrupt number
318  *      @desc:  the interrupt description structure for this irq
319  *
320  *      Level type interrupts are active as long as the hardware line has
321  *      the active level. This may require to mask the interrupt and unmask
322  *      it after the associated handler has acknowledged the device, so the
323  *      interrupt line is back to inactive.
324  */
325 void
326 handle_level_irq(unsigned int irq, struct irq_desc *desc)
327 {
328         raw_spin_lock(&desc->lock);
329         mask_ack_irq(desc);
330
331         if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
332                 if (!irq_check_poll(desc))
333                         goto out_unlock;
334
335         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
336         kstat_incr_irqs_this_cpu(irq, desc);
337
338         /*
339          * If its disabled or no action available
340          * keep it masked and get out of here
341          */
342         if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data)))
343                 goto out_unlock;
344
345         handle_irq_event(desc);
346
347         if (!irqd_irq_disabled(&desc->irq_data) && !(desc->istate & IRQS_ONESHOT))
348                 unmask_irq(desc);
349 out_unlock:
350         raw_spin_unlock(&desc->lock);
351 }
352 EXPORT_SYMBOL_GPL(handle_level_irq);
353
354 #ifdef CONFIG_IRQ_PREFLOW_FASTEOI
355 static inline void preflow_handler(struct irq_desc *desc)
356 {
357         if (desc->preflow_handler)
358                 desc->preflow_handler(&desc->irq_data);
359 }
360 #else
361 static inline void preflow_handler(struct irq_desc *desc) { }
362 #endif
363
364 /**
365  *      handle_fasteoi_irq - irq handler for transparent controllers
366  *      @irq:   the interrupt number
367  *      @desc:  the interrupt description structure for this irq
368  *
369  *      Only a single callback will be issued to the chip: an ->eoi()
370  *      call when the interrupt has been serviced. This enables support
371  *      for modern forms of interrupt handlers, which handle the flow
372  *      details in hardware, transparently.
373  */
374 void
375 handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
376 {
377         raw_spin_lock(&desc->lock);
378
379         if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
380                 if (!irq_check_poll(desc))
381                         goto out;
382
383         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
384         kstat_incr_irqs_this_cpu(irq, desc);
385
386         /*
387          * If its disabled or no action available
388          * then mask it and get out of here:
389          */
390         if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
391                 desc->istate |= IRQS_PENDING;
392                 mask_irq(desc);
393                 goto out;
394         }
395
396         if (desc->istate & IRQS_ONESHOT)
397                 mask_irq(desc);
398
399         preflow_handler(desc);
400         handle_irq_event(desc);
401
402 out_eoi:
403         desc->irq_data.chip->irq_eoi(&desc->irq_data);
404 out_unlock:
405         raw_spin_unlock(&desc->lock);
406         return;
407 out:
408         if (!(desc->irq_data.chip->flags & IRQCHIP_EOI_IF_HANDLED))
409                 goto out_eoi;
410         goto out_unlock;
411 }
412
413 /**
414  *      handle_edge_irq - edge type IRQ handler
415  *      @irq:   the interrupt number
416  *      @desc:  the interrupt description structure for this irq
417  *
418  *      Interrupt occures on the falling and/or rising edge of a hardware
419  *      signal. The occurrence is latched into the irq controller hardware
420  *      and must be acked in order to be reenabled. After the ack another
421  *      interrupt can happen on the same source even before the first one
422  *      is handled by the associated event handler. If this happens it
423  *      might be necessary to disable (mask) the interrupt depending on the
424  *      controller hardware. This requires to reenable the interrupt inside
425  *      of the loop which handles the interrupts which have arrived while
426  *      the handler was running. If all pending interrupts are handled, the
427  *      loop is left.
428  */
429 void
430 handle_edge_irq(unsigned int irq, struct irq_desc *desc)
431 {
432         raw_spin_lock(&desc->lock);
433
434         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
435         /*
436          * If we're currently running this IRQ, or its disabled,
437          * we shouldn't process the IRQ. Mark it pending, handle
438          * the necessary masking and go out
439          */
440         if (unlikely(irqd_irq_disabled(&desc->irq_data) ||
441                      irqd_irq_inprogress(&desc->irq_data) || !desc->action)) {
442                 if (!irq_check_poll(desc)) {
443                         desc->istate |= IRQS_PENDING;
444                         mask_ack_irq(desc);
445                         goto out_unlock;
446                 }
447         }
448         kstat_incr_irqs_this_cpu(irq, desc);
449
450         /* Start handling the irq */
451         desc->irq_data.chip->irq_ack(&desc->irq_data);
452
453         do {
454                 if (unlikely(!desc->action)) {
455                         mask_irq(desc);
456                         goto out_unlock;
457                 }
458
459                 /*
460                  * When another irq arrived while we were handling
461                  * one, we could have masked the irq.
462                  * Renable it, if it was not disabled in meantime.
463                  */
464                 if (unlikely(desc->istate & IRQS_PENDING)) {
465                         if (!irqd_irq_disabled(&desc->irq_data) &&
466                             irqd_irq_masked(&desc->irq_data))
467                                 unmask_irq(desc);
468                 }
469
470                 handle_irq_event(desc);
471
472         } while ((desc->istate & IRQS_PENDING) &&
473                  !irqd_irq_disabled(&desc->irq_data));
474
475 out_unlock:
476         raw_spin_unlock(&desc->lock);
477 }
478
479 #ifdef CONFIG_IRQ_EDGE_EOI_HANDLER
480 /**
481  *      handle_edge_eoi_irq - edge eoi type IRQ handler
482  *      @irq:   the interrupt number
483  *      @desc:  the interrupt description structure for this irq
484  *
485  * Similar as the above handle_edge_irq, but using eoi and w/o the
486  * mask/unmask logic.
487  */
488 void handle_edge_eoi_irq(unsigned int irq, struct irq_desc *desc)
489 {
490         struct irq_chip *chip = irq_desc_get_chip(desc);
491
492         raw_spin_lock(&desc->lock);
493
494         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
495         /*
496          * If we're currently running this IRQ, or its disabled,
497          * we shouldn't process the IRQ. Mark it pending, handle
498          * the necessary masking and go out
499          */
500         if (unlikely(irqd_irq_disabled(&desc->irq_data) ||
501                      irqd_irq_inprogress(&desc->irq_data) || !desc->action)) {
502                 if (!irq_check_poll(desc)) {
503                         desc->istate |= IRQS_PENDING;
504                         goto out_eoi;
505                 }
506         }
507         kstat_incr_irqs_this_cpu(irq, desc);
508
509         do {
510                 if (unlikely(!desc->action))
511                         goto out_eoi;
512
513                 handle_irq_event(desc);
514
515         } while ((desc->istate & IRQS_PENDING) &&
516                  !irqd_irq_disabled(&desc->irq_data));
517
518 out_eoi:
519         chip->irq_eoi(&desc->irq_data);
520         raw_spin_unlock(&desc->lock);
521 }
522 #endif
523
524 /**
525  *      handle_percpu_irq - Per CPU local irq handler
526  *      @irq:   the interrupt number
527  *      @desc:  the interrupt description structure for this irq
528  *
529  *      Per CPU interrupts on SMP machines without locking requirements
530  */
531 void
532 handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
533 {
534         struct irq_chip *chip = irq_desc_get_chip(desc);
535
536         kstat_incr_irqs_this_cpu(irq, desc);
537
538         if (chip->irq_ack)
539                 chip->irq_ack(&desc->irq_data);
540
541         handle_irq_event_percpu(desc, desc->action);
542
543         if (chip->irq_eoi)
544                 chip->irq_eoi(&desc->irq_data);
545 }
546
547 void
548 __irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
549                   const char *name)
550 {
551         unsigned long flags;
552         struct irq_desc *desc = irq_get_desc_buslock(irq, &flags);
553
554         if (!desc)
555                 return;
556
557         if (!handle) {
558                 handle = handle_bad_irq;
559         } else {
560                 if (WARN_ON(desc->irq_data.chip == &no_irq_chip))
561                         goto out;
562         }
563
564         /* Uninstall? */
565         if (handle == handle_bad_irq) {
566                 if (desc->irq_data.chip != &no_irq_chip)
567                         mask_ack_irq(desc);
568                 irq_state_set_disabled(desc);
569                 desc->depth = 1;
570         }
571         desc->handle_irq = handle;
572         desc->name = name;
573
574         if (handle != handle_bad_irq && is_chained) {
575                 irq_settings_set_noprobe(desc);
576                 irq_settings_set_norequest(desc);
577                 irq_settings_set_nothread(desc);
578                 irq_startup(desc);
579         }
580 out:
581         irq_put_desc_busunlock(desc, flags);
582 }
583 EXPORT_SYMBOL_GPL(__irq_set_handler);
584
585 void
586 irq_set_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
587                               irq_flow_handler_t handle, const char *name)
588 {
589         irq_set_chip(irq, chip);
590         __irq_set_handler(irq, handle, 0, name);
591 }
592
593 void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set)
594 {
595         unsigned long flags;
596         struct irq_desc *desc = irq_get_desc_lock(irq, &flags);
597
598         if (!desc)
599                 return;
600         irq_settings_clr_and_set(desc, clr, set);
601
602         irqd_clear(&desc->irq_data, IRQD_NO_BALANCING | IRQD_PER_CPU |
603                    IRQD_TRIGGER_MASK | IRQD_LEVEL | IRQD_MOVE_PCNTXT);
604         if (irq_settings_has_no_balance_set(desc))
605                 irqd_set(&desc->irq_data, IRQD_NO_BALANCING);
606         if (irq_settings_is_per_cpu(desc))
607                 irqd_set(&desc->irq_data, IRQD_PER_CPU);
608         if (irq_settings_can_move_pcntxt(desc))
609                 irqd_set(&desc->irq_data, IRQD_MOVE_PCNTXT);
610         if (irq_settings_is_level(desc))
611                 irqd_set(&desc->irq_data, IRQD_LEVEL);
612
613         irqd_set(&desc->irq_data, irq_settings_get_trigger_mask(desc));
614
615         irq_put_desc_unlock(desc, flags);
616 }
617 EXPORT_SYMBOL_GPL(irq_modify_status);
618
619 /**
620  *      irq_cpu_online - Invoke all irq_cpu_online functions.
621  *
622  *      Iterate through all irqs and invoke the chip.irq_cpu_online()
623  *      for each.
624  */
625 void irq_cpu_online(void)
626 {
627         struct irq_desc *desc;
628         struct irq_chip *chip;
629         unsigned long flags;
630         unsigned int irq;
631
632         for_each_active_irq(irq) {
633                 desc = irq_to_desc(irq);
634                 if (!desc)
635                         continue;
636
637                 raw_spin_lock_irqsave(&desc->lock, flags);
638
639                 chip = irq_data_get_irq_chip(&desc->irq_data);
640                 if (chip && chip->irq_cpu_online &&
641                     (!(chip->flags & IRQCHIP_ONOFFLINE_ENABLED) ||
642                      !irqd_irq_disabled(&desc->irq_data)))
643                         chip->irq_cpu_online(&desc->irq_data);
644
645                 raw_spin_unlock_irqrestore(&desc->lock, flags);
646         }
647 }
648
649 /**
650  *      irq_cpu_offline - Invoke all irq_cpu_offline functions.
651  *
652  *      Iterate through all irqs and invoke the chip.irq_cpu_offline()
653  *      for each.
654  */
655 void irq_cpu_offline(void)
656 {
657         struct irq_desc *desc;
658         struct irq_chip *chip;
659         unsigned long flags;
660         unsigned int irq;
661
662         for_each_active_irq(irq) {
663                 desc = irq_to_desc(irq);
664                 if (!desc)
665                         continue;
666
667                 raw_spin_lock_irqsave(&desc->lock, flags);
668
669                 chip = irq_data_get_irq_chip(&desc->irq_data);
670                 if (chip && chip->irq_cpu_offline &&
671                     (!(chip->flags & IRQCHIP_ONOFFLINE_ENABLED) ||
672                      !irqd_irq_disabled(&desc->irq_data)))
673                         chip->irq_cpu_offline(&desc->irq_data);
674
675                 raw_spin_unlock_irqrestore(&desc->lock, flags);
676         }
677 }