irq.c 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
  1. /*
  2. * linux/arch/arm/kernel/irq.c
  3. *
  4. * Copyright (C) 1992 Linus Torvalds
  5. * Modifications for ARM processor Copyright (C) 1995-2000 Russell King.
  6. *
  7. * Support for Dynamic Tick Timer Copyright (C) 2004-2005 Nokia Corporation.
  8. * Dynamic Tick Timer written by Tony Lindgren <tony@atomide.com> and
  9. * Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>.
  10. *
  11. * This program is free software; you can redistribute it and/or modify
  12. * it under the terms of the GNU General Public License version 2 as
  13. * published by the Free Software Foundation.
  14. *
  15. * This file contains the code used by various IRQ handling routines:
  16. * asking for different IRQ's should be done through these routines
  17. * instead of just grabbing them. Thus setups with different IRQ numbers
  18. * shouldn't result in any weird surprises, and installing new handlers
  19. * should be easier.
  20. *
  21. * IRQ's are in fact implemented a bit like signal handlers for the kernel.
  22. * Naturally it's not a 1:1 relation, but there are similarities.
  23. */
  24. #include <linux/kernel_stat.h>
  25. #include <linux/module.h>
  26. #include <linux/signal.h>
  27. #include <linux/ioport.h>
  28. #include <linux/interrupt.h>
  29. #include <linux/irq.h>
  30. #include <linux/ptrace.h>
  31. #include <linux/slab.h>
  32. #include <linux/random.h>
  33. #include <linux/smp.h>
  34. #include <linux/init.h>
  35. #include <linux/seq_file.h>
  36. #include <linux/errno.h>
  37. #include <linux/list.h>
  38. #include <linux/kallsyms.h>
  39. #include <linux/proc_fs.h>
  40. #include <asm/system.h>
  41. #include <asm/mach/time.h>
  42. /*
  43. * No architecture-specific irq_finish function defined in arm/arch/irqs.h.
  44. */
  45. #ifndef irq_finish
  46. #define irq_finish(irq) do { } while (0)
  47. #endif
  48. void (*init_arch_irq)(void) __initdata = NULL;
  49. unsigned long irq_err_count;
  50. int show_interrupts(struct seq_file *p, void *v)
  51. {
  52. int i = *(loff_t *) v, cpu;
  53. struct irqaction * action;
  54. unsigned long flags;
  55. if (i == 0) {
  56. char cpuname[12];
  57. seq_printf(p, " ");
  58. for_each_present_cpu(cpu) {
  59. sprintf(cpuname, "CPU%d", cpu);
  60. seq_printf(p, " %10s", cpuname);
  61. }
  62. seq_putc(p, '\n');
  63. }
  64. if (i < NR_IRQS) {
  65. spin_lock_irqsave(&irq_desc[i].lock, flags);
  66. action = irq_desc[i].action;
  67. if (!action)
  68. goto unlock;
  69. seq_printf(p, "%3d: ", i);
  70. for_each_present_cpu(cpu)
  71. seq_printf(p, "%10u ", kstat_cpu(cpu).irqs[i]);
  72. seq_printf(p, " %10s", irq_desc[i].chip->name ? : "-");
  73. seq_printf(p, " %s", action->name);
  74. for (action = action->next; action; action = action->next)
  75. seq_printf(p, ", %s", action->name);
  76. seq_putc(p, '\n');
  77. unlock:
  78. spin_unlock_irqrestore(&irq_desc[i].lock, flags);
  79. } else if (i == NR_IRQS) {
  80. #ifdef CONFIG_ARCH_ACORN
  81. show_fiq_list(p, v);
  82. #endif
  83. #ifdef CONFIG_SMP
  84. show_ipi_list(p);
  85. show_local_irqs(p);
  86. #endif
  87. seq_printf(p, "Err: %10lu\n", irq_err_count);
  88. }
  89. return 0;
  90. }
  91. /* Handle bad interrupts */
  92. static struct irq_desc bad_irq_desc = {
  93. .handle_irq = handle_bad_irq,
  94. .lock = SPIN_LOCK_UNLOCKED
  95. };
  96. /*
  97. * do_IRQ handles all hardware IRQ's. Decoded IRQs should not
  98. * come via this function. Instead, they should provide their
  99. * own 'handler'
  100. */
  101. asmlinkage void asm_do_IRQ(unsigned int irq, struct pt_regs *regs)
  102. {
  103. struct pt_regs *old_regs = set_irq_regs(regs);
  104. struct irq_desc *desc = irq_desc + irq;
  105. /*
  106. * Some hardware gives randomly wrong interrupts. Rather
  107. * than crashing, do something sensible.
  108. */
  109. if (irq >= NR_IRQS)
  110. desc = &bad_irq_desc;
  111. irq_enter();
  112. desc_handle_irq(irq, desc);
  113. /* AT91 specific workaround */
  114. irq_finish(irq);
  115. irq_exit();
  116. set_irq_regs(old_regs);
  117. }
  118. void set_irq_flags(unsigned int irq, unsigned int iflags)
  119. {
  120. struct irq_desc *desc;
  121. unsigned long flags;
  122. if (irq >= NR_IRQS) {
  123. printk(KERN_ERR "Trying to set irq flags for IRQ%d\n", irq);
  124. return;
  125. }
  126. desc = irq_desc + irq;
  127. spin_lock_irqsave(&desc->lock, flags);
  128. desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE | IRQ_NOAUTOEN;
  129. if (iflags & IRQF_VALID)
  130. desc->status &= ~IRQ_NOREQUEST;
  131. if (iflags & IRQF_PROBE)
  132. desc->status &= ~IRQ_NOPROBE;
  133. if (!(iflags & IRQF_NOAUTOEN))
  134. desc->status &= ~IRQ_NOAUTOEN;
  135. spin_unlock_irqrestore(&desc->lock, flags);
  136. }
  137. void __init init_IRQ(void)
  138. {
  139. int irq;
  140. for (irq = 0; irq < NR_IRQS; irq++)
  141. irq_desc[irq].status |= IRQ_NOREQUEST | IRQ_NOPROBE;
  142. #ifdef CONFIG_SMP
  143. bad_irq_desc.affinity = CPU_MASK_ALL;
  144. bad_irq_desc.cpu = smp_processor_id();
  145. #endif
  146. init_arch_irq();
  147. }
  148. #ifdef CONFIG_HOTPLUG_CPU
  149. static void route_irq(struct irq_desc *desc, unsigned int irq, unsigned int cpu)
  150. {
  151. pr_debug("IRQ%u: moving from cpu%u to cpu%u\n", irq, desc->cpu, cpu);
  152. spin_lock_irq(&desc->lock);
  153. desc->chip->set_affinity(irq, cpumask_of_cpu(cpu));
  154. spin_unlock_irq(&desc->lock);
  155. }
  156. /*
  157. * The CPU has been marked offline. Migrate IRQs off this CPU. If
  158. * the affinity settings do not allow other CPUs, force them onto any
  159. * available CPU.
  160. */
  161. void migrate_irqs(void)
  162. {
  163. unsigned int i, cpu = smp_processor_id();
  164. for (i = 0; i < NR_IRQS; i++) {
  165. struct irq_desc *desc = irq_desc + i;
  166. if (desc->cpu == cpu) {
  167. unsigned int newcpu = any_online_cpu(desc->affinity);
  168. if (newcpu == NR_CPUS) {
  169. if (printk_ratelimit())
  170. printk(KERN_INFO "IRQ%u no longer affine to CPU%u\n",
  171. i, cpu);
  172. cpus_setall(desc->affinity);
  173. newcpu = any_online_cpu(desc->affinity);
  174. }
  175. route_irq(desc, i, newcpu);
  176. }
  177. }
  178. }
  179. #endif /* CONFIG_HOTPLUG_CPU */