1
2
3
4
5
6
7
8
9
10
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
23
24
25void dynamic_irq_init(unsigned int irq)
26{
27 struct irq_desc *desc;
28 unsigned long flags;
29
30 desc = irq_to_desc(irq);
31 if (!desc) {
32 WARN(1, KERN_ERR "Trying to initialize invalid IRQ%d\n", irq);
33 return;
34 }
35
36
37 spin_lock_irqsave(&desc->lock, flags);
38 desc->status = IRQ_DISABLED;
39 desc->chip = &no_irq_chip;
40 desc->handle_irq = handle_bad_irq;
41 desc->depth = 1;
42 desc->msi_desc = NULL;
43 desc->handler_data = NULL;
44 desc->chip_data = NULL;
45 desc->action = NULL;
46 desc->irq_count = 0;
47 desc->irqs_unhandled = 0;
48#ifdef CONFIG_SMP
49 cpumask_setall(desc->affinity);
50#ifdef CONFIG_GENERIC_PENDING_IRQ
51 cpumask_clear(desc->pending_mask);
52#endif
53#endif
54 spin_unlock_irqrestore(&desc->lock, flags);
55}
56
57
58
59
60
61void dynamic_irq_cleanup(unsigned int irq)
62{
63 struct irq_desc *desc = irq_to_desc(irq);
64 unsigned long flags;
65
66 if (!desc) {
67 WARN(1, KERN_ERR "Trying to cleanup invalid IRQ%d\n", irq);
68 return;
69 }
70
71 spin_lock_irqsave(&desc->lock, flags);
72 if (desc->action) {
73 spin_unlock_irqrestore(&desc->lock, flags);
74 WARN(1, KERN_ERR "Destroying IRQ%d without calling free_irq\n",
75 irq);
76 return;
77 }
78 desc->msi_desc = NULL;
79 desc->handler_data = NULL;
80 desc->chip_data = NULL;
81 desc->handle_irq = handle_bad_irq;
82 desc->chip = &no_irq_chip;
83 desc->name = NULL;
84 clear_kstat_irqs(desc);
85 spin_unlock_irqrestore(&desc->lock, flags);
86}
87
88
89
90
91
92
93
94int set_irq_chip(unsigned int irq, struct irq_chip *chip)
95{
96 struct irq_desc *desc = irq_to_desc(irq);
97 unsigned long flags;
98
99 if (!desc) {
100 WARN(1, KERN_ERR "Trying to install chip for IRQ%d\n", irq);
101 return -EINVAL;
102 }
103
104 if (!chip)
105 chip = &no_irq_chip;
106
107 spin_lock_irqsave(&desc->lock, flags);
108 irq_chip_set_defaults(chip);
109 desc->chip = chip;
110 spin_unlock_irqrestore(&desc->lock, flags);
111
112 return 0;
113}
114EXPORT_SYMBOL(set_irq_chip);
115
116
117
118
119
120
121int set_irq_type(unsigned int irq, unsigned int type)
122{
123 struct irq_desc *desc = irq_to_desc(irq);
124 unsigned long flags;
125 int ret = -ENXIO;
126
127 if (!desc) {
128 printk(KERN_ERR "Trying to set irq type for IRQ%d\n", irq);
129 return -ENODEV;
130 }
131
132 type &= IRQ_TYPE_SENSE_MASK;
133 if (type == IRQ_TYPE_NONE)
134 return 0;
135
136 spin_lock_irqsave(&desc->lock, flags);
137 ret = __irq_set_trigger(desc, irq, type);
138 spin_unlock_irqrestore(&desc->lock, flags);
139 return ret;
140}
141EXPORT_SYMBOL(set_irq_type);
142
143
144
145
146
147
148
149
150int set_irq_data(unsigned int irq, void *data)
151{
152 struct irq_desc *desc = irq_to_desc(irq);
153 unsigned long flags;
154
155 if (!desc) {
156 printk(KERN_ERR
157 "Trying to install controller data for IRQ%d\n", irq);
158 return -EINVAL;
159 }
160
161 spin_lock_irqsave(&desc->lock, flags);
162 desc->handler_data = data;
163 spin_unlock_irqrestore(&desc->lock, flags);
164 return 0;
165}
166EXPORT_SYMBOL(set_irq_data);
167
168
169
170
171
172
173
174
175int set_irq_msi(unsigned int irq, struct msi_desc *entry)
176{
177 struct irq_desc *desc = irq_to_desc(irq);
178 unsigned long flags;
179
180 if (!desc) {
181 printk(KERN_ERR
182 "Trying to install msi data for IRQ%d\n", irq);
183 return -EINVAL;
184 }
185
186 spin_lock_irqsave(&desc->lock, flags);
187 desc->msi_desc = entry;
188 if (entry)
189 entry->irq = irq;
190 spin_unlock_irqrestore(&desc->lock, flags);
191 return 0;
192}
193
194
195
196
197
198
199
200
201int set_irq_chip_data(unsigned int irq, void *data)
202{
203 struct irq_desc *desc = irq_to_desc(irq);
204 unsigned long flags;
205
206 if (!desc) {
207 printk(KERN_ERR
208 "Trying to install chip data for IRQ%d\n", irq);
209 return -EINVAL;
210 }
211
212 if (!desc->chip) {
213 printk(KERN_ERR "BUG: bad set_irq_chip_data(IRQ#%d)\n", irq);
214 return -EINVAL;
215 }
216
217 spin_lock_irqsave(&desc->lock, flags);
218 desc->chip_data = data;
219 spin_unlock_irqrestore(&desc->lock, flags);
220
221 return 0;
222}
223EXPORT_SYMBOL(set_irq_chip_data);
224
225
226
227
228
229
230
231
232
233
234
235
236void set_irq_nested_thread(unsigned int irq, int nest)
237{
238 struct irq_desc *desc = irq_to_desc(irq);
239 unsigned long flags;
240
241 if (!desc)
242 return;
243
244 spin_lock_irqsave(&desc->lock, flags);
245 if (nest)
246 desc->status |= IRQ_NESTED_THREAD;
247 else
248 desc->status &= ~IRQ_NESTED_THREAD;
249 spin_unlock_irqrestore(&desc->lock, flags);
250}
251EXPORT_SYMBOL_GPL(set_irq_nested_thread);
252
253
254
255
256static void default_enable(unsigned int irq)
257{
258 struct irq_desc *desc = irq_to_desc(irq);
259
260 desc->chip->unmask(irq);
261 desc->status &= ~IRQ_MASKED;
262}
263
264
265
266
267static void default_disable(unsigned int irq)
268{
269}
270
271
272
273
274static unsigned int default_startup(unsigned int irq)
275{
276 struct irq_desc *desc = irq_to_desc(irq);
277
278 desc->chip->enable(irq);
279 return 0;
280}
281
282
283
284
285static void default_shutdown(unsigned int irq)
286{
287 struct irq_desc *desc = irq_to_desc(irq);
288
289 desc->chip->mask(irq);
290 desc->status |= IRQ_MASKED;
291}
292
293
294
295
296void irq_chip_set_defaults(struct irq_chip *chip)
297{
298 if (!chip->enable)
299 chip->enable = default_enable;
300 if (!chip->disable)
301 chip->disable = default_disable;
302 if (!chip->startup)
303 chip->startup = default_startup;
304
305
306
307
308
309
310 if (!chip->shutdown)
311 chip->shutdown = chip->disable != default_disable ?
312 chip->disable : default_shutdown;
313 if (!chip->name)
314 chip->name = chip->typename;
315 if (!chip->end)
316 chip->end = dummy_irq_chip.end;
317}
318
319static inline void mask_ack_irq(struct irq_desc *desc, int irq)
320{
321 if (desc->chip->mask_ack)
322 desc->chip->mask_ack(irq);
323 else {
324 desc->chip->mask(irq);
325 if (desc->chip->ack)
326 desc->chip->ack(irq);
327 }
328}
329
330
331
332
333
334
335
336
337
338void handle_nested_irq(unsigned int irq)
339{
340 struct irq_desc *desc = irq_to_desc(irq);
341 struct irqaction *action;
342 irqreturn_t action_ret;
343
344 might_sleep();
345
346 spin_lock_irq(&desc->lock);
347
348 kstat_incr_irqs_this_cpu(irq, desc);
349
350 action = desc->action;
351 if (unlikely(!action || (desc->status & IRQ_DISABLED)))
352 goto out_unlock;
353
354 desc->status |= IRQ_INPROGRESS;
355 spin_unlock_irq(&desc->lock);
356
357 action_ret = action->thread_fn(action->irq, action->dev_id);
358 if (!noirqdebug)
359 note_interrupt(irq, desc, action_ret);
360
361 spin_lock_irq(&desc->lock);
362 desc->status &= ~IRQ_INPROGRESS;
363
364out_unlock:
365 spin_unlock_irq(&desc->lock);
366}
367EXPORT_SYMBOL_GPL(handle_nested_irq);
368
369
370
371
372
373
374
375
376
377
378
379
380
381void
382handle_simple_irq(unsigned int irq, struct irq_desc *desc)
383{
384 struct irqaction *action;
385 irqreturn_t action_ret;
386
387 spin_lock(&desc->lock);
388
389 if (unlikely(desc->status & IRQ_INPROGRESS))
390 goto out_unlock;
391 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
392 kstat_incr_irqs_this_cpu(irq, desc);
393
394 action = desc->action;
395 if (unlikely(!action || (desc->status & IRQ_DISABLED)))
396 goto out_unlock;
397
398 desc->status |= IRQ_INPROGRESS;
399 spin_unlock(&desc->lock);
400
401 action_ret = handle_IRQ_event(irq, action);
402 if (!noirqdebug)
403 note_interrupt(irq, desc, action_ret);
404
405 spin_lock(&desc->lock);
406 desc->status &= ~IRQ_INPROGRESS;
407out_unlock:
408 spin_unlock(&desc->lock);
409}
410
411
412
413
414
415
416
417
418
419
420
421void
422handle_level_irq(unsigned int irq, struct irq_desc *desc)
423{
424 struct irqaction *action;
425 irqreturn_t action_ret;
426
427 spin_lock(&desc->lock);
428 mask_ack_irq(desc, irq);
429
430 if (unlikely(desc->status & IRQ_INPROGRESS))
431 goto out_unlock;
432 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
433 kstat_incr_irqs_this_cpu(irq, desc);
434
435
436
437
438
439 action = desc->action;
440 if (unlikely(!action || (desc->status & IRQ_DISABLED)))
441 goto out_unlock;
442
443 desc->status |= IRQ_INPROGRESS;
444 spin_unlock(&desc->lock);
445
446 action_ret = handle_IRQ_event(irq, action);
447 if (!noirqdebug)
448 note_interrupt(irq, desc, action_ret);
449
450 spin_lock(&desc->lock);
451 desc->status &= ~IRQ_INPROGRESS;
452
453 if (unlikely(desc->status & IRQ_ONESHOT))
454 desc->status |= IRQ_MASKED;
455 else if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
456 desc->chip->unmask(irq);
457out_unlock:
458 spin_unlock(&desc->lock);
459}
460EXPORT_SYMBOL_GPL(handle_level_irq);
461
462
463
464
465
466
467
468
469
470
471
472void
473handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
474{
475 struct irqaction *action;
476 irqreturn_t action_ret;
477
478 spin_lock(&desc->lock);
479
480 if (unlikely(desc->status & IRQ_INPROGRESS))
481 goto out;
482
483 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
484 kstat_incr_irqs_this_cpu(irq, desc);
485
486
487
488
489
490 action = desc->action;
491 if (unlikely(!action || (desc->status & IRQ_DISABLED))) {
492 desc->status |= IRQ_PENDING;
493 if (desc->chip->mask)
494 desc->chip->mask(irq);
495 goto out;
496 }
497
498 desc->status |= IRQ_INPROGRESS;
499 desc->status &= ~IRQ_PENDING;
500 spin_unlock(&desc->lock);
501
502 action_ret = handle_IRQ_event(irq, action);
503 if (!noirqdebug)
504 note_interrupt(irq, desc, action_ret);
505
506 spin_lock(&desc->lock);
507 desc->status &= ~IRQ_INPROGRESS;
508out:
509 desc->chip->eoi(irq);
510
511 spin_unlock(&desc->lock);
512}
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530void
531handle_edge_irq(unsigned int irq, struct irq_desc *desc)
532{
533 spin_lock(&desc->lock);
534
535 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
536
537
538
539
540
541
542 if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
543 !desc->action)) {
544 desc->status |= (IRQ_PENDING | IRQ_MASKED);
545 mask_ack_irq(desc, irq);
546 goto out_unlock;
547 }
548 kstat_incr_irqs_this_cpu(irq, desc);
549
550
551 if (desc->chip->ack)
552 desc->chip->ack(irq);
553
554
555 desc->status |= IRQ_INPROGRESS;
556
557 do {
558 struct irqaction *action = desc->action;
559 irqreturn_t action_ret;
560
561 if (unlikely(!action)) {
562 desc->chip->mask(irq);
563 goto out_unlock;
564 }
565
566
567
568
569
570
571 if (unlikely((desc->status &
572 (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
573 (IRQ_PENDING | IRQ_MASKED))) {
574 desc->chip->unmask(irq);
575 desc->status &= ~IRQ_MASKED;
576 }
577
578 desc->status &= ~IRQ_PENDING;
579 spin_unlock(&desc->lock);
580 action_ret = handle_IRQ_event(irq, action);
581 if (!noirqdebug)
582 note_interrupt(irq, desc, action_ret);
583 spin_lock(&desc->lock);
584
585 } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
586
587 desc->status &= ~IRQ_INPROGRESS;
588out_unlock:
589 spin_unlock(&desc->lock);
590}
591
592
593
594
595
596
597
598
599void
600handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
601{
602 irqreturn_t action_ret;
603
604 kstat_incr_irqs_this_cpu(irq, desc);
605
606 if (desc->chip->ack)
607 desc->chip->ack(irq);
608
609 action_ret = handle_IRQ_event(irq, desc->action);
610 if (!noirqdebug)
611 note_interrupt(irq, desc, action_ret);
612
613 if (desc->chip->eoi)
614 desc->chip->eoi(irq);
615}
616
617void
618__set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
619 const char *name)
620{
621 struct irq_desc *desc = irq_to_desc(irq);
622 unsigned long flags;
623
624 if (!desc) {
625 printk(KERN_ERR
626 "Trying to install type control for IRQ%d\n", irq);
627 return;
628 }
629
630 if (!handle)
631 handle = handle_bad_irq;
632 else if (desc->chip == &no_irq_chip) {
633 printk(KERN_WARNING "Trying to install %sinterrupt handler "
634 "for IRQ%d\n", is_chained ? "chained " : "", irq);
635
636
637
638
639
640
641
642 desc->chip = &dummy_irq_chip;
643 }
644
645 chip_bus_lock(irq, desc);
646 spin_lock_irqsave(&desc->lock, flags);
647
648
649 if (handle == handle_bad_irq) {
650 if (desc->chip != &no_irq_chip)
651 mask_ack_irq(desc, irq);
652 desc->status |= IRQ_DISABLED;
653 desc->depth = 1;
654 }
655 desc->handle_irq = handle;
656 desc->name = name;
657
658 if (handle != handle_bad_irq && is_chained) {
659 desc->status &= ~IRQ_DISABLED;
660 desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE;
661 desc->depth = 0;
662 desc->chip->startup(irq);
663 }
664 spin_unlock_irqrestore(&desc->lock, flags);
665 chip_bus_sync_unlock(irq, desc);
666}
667EXPORT_SYMBOL_GPL(__set_irq_handler);
668
669void
670set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
671 irq_flow_handler_t handle)
672{
673 set_irq_chip(irq, chip);
674 __set_irq_handler(irq, handle, 0, NULL);
675}
676
677void
678set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
679 irq_flow_handler_t handle, const char *name)
680{
681 set_irq_chip(irq, chip);
682 __set_irq_handler(irq, handle, 0, name);
683}
684
685void __init set_irq_noprobe(unsigned int irq)
686{
687 struct irq_desc *desc = irq_to_desc(irq);
688 unsigned long flags;
689
690 if (!desc) {
691 printk(KERN_ERR "Trying to mark IRQ%d non-probeable\n", irq);
692 return;
693 }
694
695 spin_lock_irqsave(&desc->lock, flags);
696 desc->status |= IRQ_NOPROBE;
697 spin_unlock_irqrestore(&desc->lock, flags);
698}
699
700void __init set_irq_probe(unsigned int irq)
701{
702 struct irq_desc *desc = irq_to_desc(irq);
703 unsigned long flags;
704
705 if (!desc) {
706 printk(KERN_ERR "Trying to mark IRQ%d probeable\n", irq);
707 return;
708 }
709
710 spin_lock_irqsave(&desc->lock, flags);
711 desc->status &= ~IRQ_NOPROBE;
712 spin_unlock_irqrestore(&desc->lock, flags);
713}
714