2 * linux/arch/sh/kernel/irq.c
4 * Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
7 * SuperH version: Copyright (C) 1999 Niibe Yutaka
10 #include <linux/interrupt.h>
11 #include <linux/module.h>
12 #include <linux/kernel_stat.h>
13 #include <linux/seq_file.h>
14 #include <linux/ftrace.h>
15 #include <linux/delay.h>
16 #include <asm/processor.h>
17 #include <asm/machvec.h>
18 #include <asm/uaccess.h>
19 #include <asm/thread_info.h>
20 #include <cpu/mmu_context.h>
22 atomic_t irq_err_count;
25 * 'what should we do if we get a hw irq event on an illegal vector'.
26 * each architecture has to answer this themselves, it doesn't deserve
27 * a generic callback i think.
29 void ack_bad_irq(unsigned int irq)
31 atomic_inc(&irq_err_count);
32 printk("unexpected IRQ trap at vector %02x\n", irq);
35 #if defined(CONFIG_PROC_FS)
37 * /proc/interrupts printing:
39 static int show_other_interrupts(struct seq_file *p, int prec)
43 seq_printf(p, "%*s: ", prec, "NMI");
44 for_each_online_cpu(j)
45 seq_printf(p, "%10u ", irq_stat[j].__nmi_count);
46 seq_printf(p, " Non-maskable interrupts\n");
48 seq_printf(p, "%*s: %10u\n", prec, "ERR", atomic_read(&irq_err_count));
53 int show_interrupts(struct seq_file *p, void *v)
55 unsigned long flags, any_count = 0;
56 int i = *(loff_t *)v, j, prec;
57 struct irqaction *action;
58 struct irq_desc *desc;
63 for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
67 return show_other_interrupts(p, prec);
70 seq_printf(p, "%*s", prec + 8, "");
71 for_each_online_cpu(j)
72 seq_printf(p, "CPU%-8d", j);
76 desc = irq_to_desc(i);
80 raw_spin_lock_irqsave(&desc->lock, flags);
81 for_each_online_cpu(j)
82 any_count |= kstat_irqs_cpu(i, j);
83 action = desc->action;
84 if (!action && !any_count)
87 seq_printf(p, "%*d: ", prec, i);
88 for_each_online_cpu(j)
89 seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
90 seq_printf(p, " %14s", desc->chip->name);
91 seq_printf(p, "-%-8s", desc->name);
94 seq_printf(p, " %s", action->name);
95 while ((action = action->next) != NULL)
96 seq_printf(p, ", %s", action->name);
101 raw_spin_unlock_irqrestore(&desc->lock, flags);
106 #ifdef CONFIG_IRQSTACKS
108 * per-CPU IRQ handling contexts (thread information and stack)
111 struct thread_info tinfo;
112 u32 stack[THREAD_SIZE/sizeof(u32)];
115 static union irq_ctx *hardirq_ctx[NR_CPUS] __read_mostly;
116 static union irq_ctx *softirq_ctx[NR_CPUS] __read_mostly;
118 static char softirq_stack[NR_CPUS * THREAD_SIZE] __page_aligned_bss;
119 static char hardirq_stack[NR_CPUS * THREAD_SIZE] __page_aligned_bss;
121 static inline void handle_one_irq(unsigned int irq)
123 union irq_ctx *curctx, *irqctx;
125 curctx = (union irq_ctx *)current_thread_info();
126 irqctx = hardirq_ctx[smp_processor_id()];
129 * this is where we switch to the IRQ stack. However, if we are
130 * already using the IRQ stack (because we interrupted a hardirq
131 * handler) we can't do that and just have to keep using the
132 * current stack (which is the irq stack already after all)
134 if (curctx != irqctx) {
137 isp = (u32 *)((char *)irqctx + sizeof(*irqctx));
138 irqctx->tinfo.task = curctx->tinfo.task;
139 irqctx->tinfo.previous_sp = current_stack_pointer;
142 * Copy the softirq bits in preempt_count so that the
143 * softirq checks work in the hardirq context.
145 irqctx->tinfo.preempt_count =
146 (irqctx->tinfo.preempt_count & ~SOFTIRQ_MASK) |
147 (curctx->tinfo.preempt_count & SOFTIRQ_MASK);
149 __asm__ __volatile__ (
153 /* swith to the irq stack */
155 /* restore the stack (ring zero) */
158 : "r" (irq), "r" (generic_handle_irq), "r" (isp)
159 : "memory", "r0", "r1", "r2", "r3", "r4",
160 "r5", "r6", "r7", "r8", "t", "pr"
163 generic_handle_irq(irq);
167 * allocate per-cpu stacks for hardirq and for softirq processing
169 void irq_ctx_init(int cpu)
171 union irq_ctx *irqctx;
173 if (hardirq_ctx[cpu])
176 irqctx = (union irq_ctx *)&hardirq_stack[cpu * THREAD_SIZE];
177 irqctx->tinfo.task = NULL;
178 irqctx->tinfo.exec_domain = NULL;
179 irqctx->tinfo.cpu = cpu;
180 irqctx->tinfo.preempt_count = HARDIRQ_OFFSET;
181 irqctx->tinfo.addr_limit = MAKE_MM_SEG(0);
183 hardirq_ctx[cpu] = irqctx;
185 irqctx = (union irq_ctx *)&softirq_stack[cpu * THREAD_SIZE];
186 irqctx->tinfo.task = NULL;
187 irqctx->tinfo.exec_domain = NULL;
188 irqctx->tinfo.cpu = cpu;
189 irqctx->tinfo.preempt_count = 0;
190 irqctx->tinfo.addr_limit = MAKE_MM_SEG(0);
192 softirq_ctx[cpu] = irqctx;
194 printk("CPU %u irqstacks, hard=%p soft=%p\n",
195 cpu, hardirq_ctx[cpu], softirq_ctx[cpu]);
198 void irq_ctx_exit(int cpu)
200 hardirq_ctx[cpu] = NULL;
203 asmlinkage void do_softirq(void)
206 struct thread_info *curctx;
207 union irq_ctx *irqctx;
213 local_irq_save(flags);
215 if (local_softirq_pending()) {
216 curctx = current_thread_info();
217 irqctx = softirq_ctx[smp_processor_id()];
218 irqctx->tinfo.task = curctx->task;
219 irqctx->tinfo.previous_sp = current_stack_pointer;
221 /* build the stack frame on the softirq stack */
222 isp = (u32 *)((char *)irqctx + sizeof(*irqctx));
224 __asm__ __volatile__ (
227 /* switch to the softirq stack */
229 /* restore the thread stack */
232 : "r" (__do_softirq), "r" (isp)
233 : "memory", "r0", "r1", "r2", "r3", "r4",
234 "r5", "r6", "r7", "r8", "r9", "r15", "t", "pr"
238 * Shouldnt happen, we returned above if in_interrupt():
240 WARN_ON_ONCE(softirq_count());
243 local_irq_restore(flags);
246 static inline void handle_one_irq(unsigned int irq)
248 generic_handle_irq(irq);
252 asmlinkage __irq_entry int do_IRQ(unsigned int irq, struct pt_regs *regs)
254 struct pt_regs *old_regs = set_irq_regs(regs);
258 irq = irq_demux(irq_lookup(irq));
260 if (irq != NO_IRQ_IGNORE) {
267 set_irq_regs(old_regs);
272 void __init init_IRQ(void)
277 * Pin any of the legacy IRQ vectors that haven't already been
278 * grabbed by the platform
280 reserve_irq_legacy();
282 /* Perform the machine specific initialisation */
283 if (sh_mv.mv_init_irq)
288 irq_ctx_init(smp_processor_id());
291 #ifdef CONFIG_SPARSE_IRQ
292 int __init arch_probe_nr_irqs(void)
294 nr_irqs = sh_mv.mv_nr_irqs;
295 return NR_IRQS_LEGACY;
299 #ifdef CONFIG_HOTPLUG_CPU
300 static void route_irq(struct irq_desc *desc, unsigned int irq, unsigned int cpu)
302 printk(KERN_INFO "IRQ%u: moving from cpu%u to cpu%u\n",
303 irq, desc->node, cpu);
305 raw_spin_lock_irq(&desc->lock);
306 desc->chip->set_affinity(irq, cpumask_of(cpu));
307 raw_spin_unlock_irq(&desc->lock);
311 * The CPU has been marked offline. Migrate IRQs off this CPU. If
312 * the affinity settings do not allow other CPUs, force them onto any
315 void migrate_irqs(void)
317 struct irq_desc *desc;
318 unsigned int irq, cpu = smp_processor_id();
320 for_each_irq_desc(irq, desc) {
321 if (desc->node == cpu) {
322 unsigned int newcpu = cpumask_any_and(desc->affinity,
324 if (newcpu >= nr_cpu_ids) {
325 if (printk_ratelimit())
326 printk(KERN_INFO "IRQ%u no longer affine to CPU%u\n",
329 cpumask_setall(desc->affinity);
330 newcpu = cpumask_any_and(desc->affinity,
334 route_irq(desc, irq, newcpu);