2 * linux/arch/arm/kernel/irq.c
4 * Copyright (C) 1992 Linus Torvalds
5 * Modifications for ARM processor Copyright (C) 1995-2000 Russell King.
6 * 'Borrowed' for ARM26 and (C) 2003 Ian Molton.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
12 * This file contains the code used by various IRQ handling routines:
13 * asking for different IRQ's should be done through these routines
14 * instead of just grabbing them. Thus setups with different IRQ numbers
15 * shouldn't result in any weird surprises, and installing new handlers
18 * IRQ's are in fact implemented a bit like signal handlers for the kernel.
19 * Naturally it's not a 1:1 relation, but there are similarities.
21 #include <linux/module.h>
22 #include <linux/ptrace.h>
23 #include <linux/kernel_stat.h>
24 #include <linux/signal.h>
25 #include <linux/sched.h>
26 #include <linux/ioport.h>
27 #include <linux/interrupt.h>
28 #include <linux/slab.h>
29 #include <linux/random.h>
30 #include <linux/smp.h>
31 #include <linux/init.h>
32 #include <linux/seq_file.h>
33 #include <linux/errno.h>
36 #include <asm/system.h>
37 #include <asm/irqchip.h>
39 //FIXME - this ought to be in a header IMO
40 void __init
arc_init_irq(void);
43 * Maximum IRQ count. Currently, this is arbitary. However, it should
44 * not be set too low to prevent false triggering. Conversely, if it
45 * is set too high, then you could miss a stuck IRQ.
47 * FIXME Maybe we ought to set a timer and re-enable the IRQ at a later time?
49 #define MAX_IRQ_CNT 100000
51 static volatile unsigned long irq_err_count
;
52 static DEFINE_SPINLOCK(irq_controller_lock
);
54 struct irqdesc irq_desc
[NR_IRQS
];
57 * Dummy mask/unmask handler
59 void dummy_mask_unmask_irq(unsigned int irq
)
63 void do_bad_IRQ(unsigned int irq
, struct irqdesc
*desc
, struct pt_regs
*regs
)
66 printk(KERN_ERR
"IRQ: spurious interrupt %d\n", irq
);
69 static struct irqchip bad_chip
= {
70 .ack
= dummy_mask_unmask_irq
,
71 .mask
= dummy_mask_unmask_irq
,
72 .unmask
= dummy_mask_unmask_irq
,
75 static struct irqdesc bad_irq_desc
= {
82 * disable_irq - disable an irq and wait for completion
83 * @irq: Interrupt to disable
85 * Disable the selected interrupt line. We do this lazily.
87 * This function may be called from IRQ context.
89 void disable_irq(unsigned int irq
)
91 struct irqdesc
*desc
= irq_desc
+ irq
;
93 spin_lock_irqsave(&irq_controller_lock
, flags
);
96 spin_unlock_irqrestore(&irq_controller_lock
, flags
);
98 EXPORT_SYMBOL(disable_irq
);
100 void disable_irq_nosync(unsigned int irq
) __attribute__((alias("disable_irq")));
102 EXPORT_SYMBOL(disable_irq_nosync
);
105 * enable_irq - enable interrupt handling on an irq
106 * @irq: Interrupt to enable
108 * Re-enables the processing of interrupts on this IRQ line.
109 * Note that this may call the interrupt handler, so you may
110 * get unexpected results if you hold IRQs disabled.
112 * This function may be called from IRQ context.
114 void enable_irq(unsigned int irq
)
116 struct irqdesc
*desc
= irq_desc
+ irq
;
120 spin_lock_irqsave(&irq_controller_lock
, flags
);
121 if (unlikely(!desc
->depth
)) {
122 printk("enable_irq(%u) unbalanced from %p\n", irq
,
123 __builtin_return_address(0)); //FIXME bum addresses reported - why?
124 } else if (!--desc
->depth
) {
127 desc
->chip
->unmask(irq
);
128 pending
= desc
->pending
;
131 * If the interrupt was waiting to be processed,
135 desc
->chip
->rerun(irq
);
137 spin_unlock_irqrestore(&irq_controller_lock
, flags
);
139 EXPORT_SYMBOL(enable_irq
);
141 int show_interrupts(struct seq_file
*p
, void *v
)
143 int i
= *(loff_t
*) v
;
144 struct irqaction
* action
;
147 action
= irq_desc
[i
].action
;
150 seq_printf(p
, "%3d: %10u ", i
, kstat_irqs(i
));
151 seq_printf(p
, " %s", action
->name
);
152 for (action
= action
->next
; action
; action
= action
->next
) {
153 seq_printf(p
, ", %s", action
->name
);
156 } else if (i
== NR_IRQS
) {
158 seq_printf(p
, "Err: %10lu\n", irq_err_count
);
165 * IRQ lock detection.
167 * Hopefully, this should get us out of a few locked situations.
168 * However, it may take a while for this to happen, since we need
169 * a large number if IRQs to appear in the same jiffie with the
170 * same instruction pointer (or within 2 instructions).
172 static int check_irq_lock(struct irqdesc
*desc
, int irq
, struct pt_regs
*regs
)
174 unsigned long instr_ptr
= instruction_pointer(regs
);
176 if (desc
->lck_jif
== jiffies
&&
177 desc
->lck_pc
>= instr_ptr
&& desc
->lck_pc
< instr_ptr
+ 8) {
180 if (desc
->lck_cnt
> MAX_IRQ_CNT
) {
181 printk(KERN_ERR
"IRQ LOCK: IRQ%d is locking the system, disabled\n", irq
);
186 desc
->lck_pc
= instruction_pointer(regs
);
187 desc
->lck_jif
= jiffies
;
193 __do_irq(unsigned int irq
, struct irqaction
*action
, struct pt_regs
*regs
)
198 spin_unlock(&irq_controller_lock
);
199 if (!(action
->flags
& IRQF_DISABLED
))
204 ret
= action
->handler(irq
, action
->dev_id
, regs
);
205 if (ret
== IRQ_HANDLED
)
206 status
|= action
->flags
;
207 action
= action
->next
;
210 if (status
& IRQF_SAMPLE_RANDOM
)
211 add_interrupt_randomness(irq
);
213 spin_lock_irq(&irq_controller_lock
);
217 * This is for software-decoded IRQs. The caller is expected to
218 * handle the ack, clear, mask and unmask issues.
221 do_simple_IRQ(unsigned int irq
, struct irqdesc
*desc
, struct pt_regs
*regs
)
223 struct irqaction
*action
;
224 const int cpu
= smp_processor_id();
228 kstat_cpu(cpu
).irqs
[irq
]++;
230 action
= desc
->action
;
232 __do_irq(irq
, desc
->action
, regs
);
236 * Most edge-triggered IRQ implementations seem to take a broken
237 * approach to this. Hence the complexity.
240 do_edge_IRQ(unsigned int irq
, struct irqdesc
*desc
, struct pt_regs
*regs
)
242 const int cpu
= smp_processor_id();
247 * If we're currently running this IRQ, or its disabled,
248 * we shouldn't process the IRQ. Instead, turn on the
251 if (unlikely(desc
->running
|| !desc
->enabled
))
255 * Acknowledge and clear the IRQ, but don't mask it.
257 desc
->chip
->ack(irq
);
260 * Mark the IRQ currently in progress.
264 kstat_cpu(cpu
).irqs
[irq
]++;
267 struct irqaction
*action
;
269 action
= desc
->action
;
273 if (desc
->pending
&& desc
->enabled
) {
275 desc
->chip
->unmask(irq
);
278 __do_irq(irq
, action
, regs
);
279 } while (desc
->pending
);
284 * If we were disabled or freed, shut down the handler.
286 if (likely(desc
->action
&& !check_irq_lock(desc
, irq
, regs
)))
291 * We got another IRQ while this one was masked or
292 * currently running. Delay it.
295 desc
->chip
->mask(irq
);
296 desc
->chip
->ack(irq
);
300 * Level-based IRQ handler. Nice and simple.
303 do_level_IRQ(unsigned int irq
, struct irqdesc
*desc
, struct pt_regs
*regs
)
305 struct irqaction
*action
;
306 const int cpu
= smp_processor_id();
311 * Acknowledge, clear _AND_ disable the interrupt.
313 desc
->chip
->ack(irq
);
315 if (likely(desc
->enabled
)) {
316 kstat_cpu(cpu
).irqs
[irq
]++;
319 * Return with this interrupt masked if no action
321 action
= desc
->action
;
323 __do_irq(irq
, desc
->action
, regs
);
325 if (likely(desc
->enabled
&&
326 !check_irq_lock(desc
, irq
, regs
)))
327 desc
->chip
->unmask(irq
);
333 * do_IRQ handles all hardware IRQ's. Decoded IRQs should not
334 * come via this function. Instead, they should provide their
337 asmlinkage
void asm_do_IRQ(int irq
, struct pt_regs
*regs
)
339 struct irqdesc
*desc
= irq_desc
+ irq
;
342 * Some hardware gives randomly wrong interrupts. Rather
343 * than crashing, do something sensible.
346 desc
= &bad_irq_desc
;
349 spin_lock(&irq_controller_lock
);
350 desc
->handle(irq
, desc
, regs
);
351 spin_unlock(&irq_controller_lock
);
355 void __set_irq_handler(unsigned int irq
, irq_handler_t handle
, int is_chained
)
357 struct irqdesc
*desc
;
360 if (irq
>= NR_IRQS
) {
361 printk(KERN_ERR
"Trying to install handler for IRQ%d\n", irq
);
368 desc
= irq_desc
+ irq
;
370 if (is_chained
&& desc
->chip
== &bad_chip
)
371 printk(KERN_WARNING
"Trying to install chained handler for IRQ%d\n", irq
);
373 spin_lock_irqsave(&irq_controller_lock
, flags
);
374 if (handle
== do_bad_IRQ
) {
375 desc
->chip
->mask(irq
);
376 desc
->chip
->ack(irq
);
380 desc
->handle
= handle
;
381 if (handle
!= do_bad_IRQ
&& is_chained
) {
385 desc
->chip
->unmask(irq
);
387 spin_unlock_irqrestore(&irq_controller_lock
, flags
);
390 void set_irq_chip(unsigned int irq
, struct irqchip
*chip
)
392 struct irqdesc
*desc
;
395 if (irq
>= NR_IRQS
) {
396 printk(KERN_ERR
"Trying to install chip for IRQ%d\n", irq
);
403 desc
= irq_desc
+ irq
;
404 spin_lock_irqsave(&irq_controller_lock
, flags
);
406 spin_unlock_irqrestore(&irq_controller_lock
, flags
);
409 int set_irq_type(unsigned int irq
, unsigned int type
)
411 struct irqdesc
*desc
;
415 if (irq
>= NR_IRQS
) {
416 printk(KERN_ERR
"Trying to set irq type for IRQ%d\n", irq
);
420 desc
= irq_desc
+ irq
;
421 if (desc
->chip
->type
) {
422 spin_lock_irqsave(&irq_controller_lock
, flags
);
423 ret
= desc
->chip
->type(irq
, type
);
424 spin_unlock_irqrestore(&irq_controller_lock
, flags
);
430 void set_irq_flags(unsigned int irq
, unsigned int iflags
)
432 struct irqdesc
*desc
;
435 if (irq
>= NR_IRQS
) {
436 printk(KERN_ERR
"Trying to set irq flags for IRQ%d\n", irq
);
440 desc
= irq_desc
+ irq
;
441 spin_lock_irqsave(&irq_controller_lock
, flags
);
442 desc
->valid
= (iflags
& IRQF_VALID
) != 0;
443 desc
->probe_ok
= (iflags
& IRQF_PROBE
) != 0;
444 desc
->noautoenable
= (iflags
& IRQF_NOAUTOEN
) != 0;
445 spin_unlock_irqrestore(&irq_controller_lock
, flags
);
448 int setup_irq(unsigned int irq
, struct irqaction
*new)
451 struct irqaction
*old
, **p
;
453 struct irqdesc
*desc
;
456 * Some drivers like serial.c use request_irq() heavily,
457 * so we have to be careful not to interfere with a
460 if (new->flags
& IRQF_SAMPLE_RANDOM
) {
462 * This function might sleep, we want to call it first,
463 * outside of the atomic block.
464 * Yes, this might clear the entropy pool if the wrong
465 * driver is attempted to be loaded, without actually
466 * installing a new handler, but is this really a problem,
467 * only the sysadmin is able to do this.
469 rand_initialize_irq(irq
);
473 * The following block of code has to be executed atomically
475 desc
= irq_desc
+ irq
;
476 spin_lock_irqsave(&irq_controller_lock
, flags
);
478 if ((old
= *p
) != NULL
) {
479 /* Can't share interrupts unless both agree to */
480 if (!(old
->flags
& new->flags
& IRQF_SHARED
)) {
481 spin_unlock_irqrestore(&irq_controller_lock
, flags
);
485 /* add new interrupt at end of irq queue */
500 if (!desc
->noautoenable
) {
503 desc
->chip
->unmask(irq
);
507 spin_unlock_irqrestore(&irq_controller_lock
, flags
);
512 * request_irq - allocate an interrupt line
513 * @irq: Interrupt line to allocate
514 * @handler: Function to be called when the IRQ occurs
515 * @irqflags: Interrupt type flags
516 * @devname: An ascii name for the claiming device
517 * @dev_id: A cookie passed back to the handler function
519 * This call allocates interrupt resources and enables the
520 * interrupt line and IRQ handling. From the point this
521 * call is made your handler function may be invoked. Since
522 * your handler function must clear any interrupt the board
523 * raises, you must take care both to initialise your hardware
524 * and to set up the interrupt handler in the right order.
526 * Dev_id must be globally unique. Normally the address of the
527 * device data structure is used as the cookie. Since the handler
528 * receives this value it makes sense to use it.
530 * If your interrupt is shared you must pass a non NULL dev_id
531 * as this is required when freeing the interrupt.
535 * IRQF_SHARED Interrupt is shared
537 * IRQF_DISABLED Disable local interrupts while processing
539 * IRQF_SAMPLE_RANDOM The interrupt can be used for entropy
543 //FIXME - handler used to return void - whats the significance of the change?
544 int request_irq(unsigned int irq
, irqreturn_t (*handler
)(int, void *, struct pt_regs
*),
545 unsigned long irq_flags
, const char * devname
, void *dev_id
)
547 unsigned long retval
;
548 struct irqaction
*action
;
550 if (irq
>= NR_IRQS
|| !irq_desc
[irq
].valid
|| !handler
||
551 (irq_flags
& IRQF_SHARED
&& !dev_id
))
554 action
= kmalloc(sizeof(struct irqaction
), GFP_KERNEL
);
558 action
->handler
= handler
;
559 action
->flags
= irq_flags
;
560 cpus_clear(action
->mask
);
561 action
->name
= devname
;
563 action
->dev_id
= dev_id
;
565 retval
= setup_irq(irq
, action
);
572 EXPORT_SYMBOL(request_irq
);
575 * free_irq - free an interrupt
576 * @irq: Interrupt line to free
577 * @dev_id: Device identity to free
579 * Remove an interrupt handler. The handler is removed and if the
580 * interrupt line is no longer in use by any driver it is disabled.
581 * On a shared IRQ the caller must ensure the interrupt is disabled
582 * on the card it drives before calling this function.
584 * This function may be called from interrupt context.
586 void free_irq(unsigned int irq
, void *dev_id
)
588 struct irqaction
* action
, **p
;
591 if (irq
>= NR_IRQS
|| !irq_desc
[irq
].valid
) {
592 printk(KERN_ERR
"Trying to free IRQ%d\n",irq
);
593 #ifdef CONFIG_DEBUG_ERRORS
599 spin_lock_irqsave(&irq_controller_lock
, flags
);
600 for (p
= &irq_desc
[irq
].action
; (action
= *p
) != NULL
; p
= &action
->next
) {
601 if (action
->dev_id
!= dev_id
)
604 /* Found it - now free it */
609 printk(KERN_ERR
"Trying to free free IRQ%d\n",irq
);
610 #ifdef CONFIG_DEBUG_ERRORS
614 spin_unlock_irqrestore(&irq_controller_lock
, flags
);
617 EXPORT_SYMBOL(free_irq
);
619 /* Start the interrupt probing. Unlike other architectures,
620 * we don't return a mask of interrupts from probe_irq_on,
621 * but return the number of interrupts enabled for the probe.
622 * The interrupts which have been enabled for probing is
623 * instead recorded in the irq_desc structure.
625 unsigned long probe_irq_on(void)
627 unsigned int i
, irqs
= 0;
631 * first snaffle up any unassigned but
632 * probe-able interrupts
634 spin_lock_irq(&irq_controller_lock
);
635 for (i
= 0; i
< NR_IRQS
; i
++) {
636 if (!irq_desc
[i
].probe_ok
|| irq_desc
[i
].action
)
639 irq_desc
[i
].probing
= 1;
640 irq_desc
[i
].triggered
= 0;
641 if (irq_desc
[i
].chip
->type
)
642 irq_desc
[i
].chip
->type(i
, IRQT_PROBE
);
643 irq_desc
[i
].chip
->unmask(i
);
646 spin_unlock_irq(&irq_controller_lock
);
649 * wait for spurious interrupts to mask themselves out again
651 for (delay
= jiffies
+ HZ
/10; time_before(jiffies
, delay
); )
652 /* min 100ms delay */;
655 * now filter out any obviously spurious interrupts
657 spin_lock_irq(&irq_controller_lock
);
658 for (i
= 0; i
< NR_IRQS
; i
++) {
659 if (irq_desc
[i
].probing
&& irq_desc
[i
].triggered
) {
660 irq_desc
[i
].probing
= 0;
664 spin_unlock_irq(&irq_controller_lock
);
669 EXPORT_SYMBOL(probe_irq_on
);
672 * Possible return values:
673 * >= 0 - interrupt number
674 * -1 - no interrupt/many interrupts
676 int probe_irq_off(unsigned long irqs
)
679 int irq_found
= NO_IRQ
;
682 * look at the interrupts, and find exactly one
683 * that we were probing has been triggered
685 spin_lock_irq(&irq_controller_lock
);
686 for (i
= 0; i
< NR_IRQS
; i
++) {
687 if (irq_desc
[i
].probing
&&
688 irq_desc
[i
].triggered
) {
689 if (irq_found
!= NO_IRQ
) {
700 spin_unlock_irq(&irq_controller_lock
);
705 EXPORT_SYMBOL(probe_irq_off
);
707 void __init
init_irq_proc(void)
711 void __init
init_IRQ(void)
713 struct irqdesc
*desc
;
714 extern void init_dma(void);
717 for (irq
= 0, desc
= irq_desc
; irq
< NR_IRQS
; irq
++, desc
++)
718 *desc
= bad_irq_desc
;