2006-09-27 03:22:14 -06:00
|
|
|
/*
|
2005-04-16 16:20:36 -06:00
|
|
|
* linux/arch/sh/kernel/irq.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* SuperH version: Copyright (C) 1999 Niibe Yutaka
|
|
|
|
*/
|
2006-01-16 23:14:14 -07:00
|
|
|
#include <linux/irq.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/interrupt.h>
|
2006-09-27 03:22:14 -06:00
|
|
|
#include <linux/module.h>
|
2006-01-16 23:14:14 -07:00
|
|
|
#include <linux/kernel_stat.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/seq_file.h>
|
2009-10-25 18:58:31 -06:00
|
|
|
#include <linux/ftrace.h>
|
2010-04-26 04:08:55 -06:00
|
|
|
#include <linux/delay.h>
|
2011-06-30 00:10:06 -06:00
|
|
|
#include <linux/ratelimit.h>
|
2006-01-16 23:14:14 -07:00
|
|
|
#include <asm/processor.h>
|
2007-03-11 23:09:35 -06:00
|
|
|
#include <asm/machvec.h>
|
2006-09-27 03:22:14 -06:00
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/thread_info.h>
|
2008-07-28 17:09:44 -06:00
|
|
|
#include <cpu/mmu_context.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-10-06 00:31:16 -06:00
|
|
|
atomic_t irq_err_count;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* 'what should we do if we get a hw irq event on an illegal vector'.
|
|
|
|
* each architecture has to answer this themselves, it doesn't deserve
|
|
|
|
* a generic callback i think.
|
|
|
|
*/
|
|
|
|
void ack_bad_irq(unsigned int irq)
|
|
|
|
{
|
sh: interrupt exception handling rework
Kill off interrupt_table for all of the CPU subtypes, we now
default in to stepping in to do_IRQ() for _all_ IRQ exceptions
and counting the spurious ones, rather than simply flipping on
the ones we cared about. This and enabling the IRQ by default
automatically has already uncovered a couple of bugs and IRQs
that weren't being caught, as well as some that are being
generated far too often (SCI Tx Data Empty, for example).
The general rationale is to use a marker for interrupt exceptions,
test for it in the handle_exception() path, and skip out to
do_IRQ() if it's found. Everything else follows the same behaviour
of finding the cached EXPEVT value in r2/r2_bank, we just rip out
the INTEVT read from entry.S entirely (except for in the kGDB NMI
case, which is another matter).
Note that while this changes the do_IRQ() semantics regarding r4
handling, they were fundamentally broken anyways (relying entirely
on r2_bank for the cached code). With this, we do the INTEVT read
from do_IRQ() itself (in the CONFIG_CPU_HAS_INTEVT case), or fall
back on r4 for the muxed IRQ number, which should also be closer
to what SH-2 and SH-2A want anyways.
Signed-off-by: Paul Mundt <lethal@linux-sh.org>
2006-10-11 21:03:04 -06:00
|
|
|
atomic_inc(&irq_err_count);
|
2005-04-16 16:20:36 -06:00
|
|
|
printk("unexpected IRQ trap at vector %02x\n", irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(CONFIG_PROC_FS)
|
2009-05-21 10:26:16 -06:00
|
|
|
/*
|
2011-03-17 02:31:51 -06:00
|
|
|
* /proc/interrupts printing for arch specific interrupts
|
2009-05-21 10:26:16 -06:00
|
|
|
*/
|
2011-03-17 02:31:51 -06:00
|
|
|
int arch_show_interrupts(struct seq_file *p, int prec)
|
2009-05-21 10:26:16 -06:00
|
|
|
{
|
2009-10-14 01:42:28 -06:00
|
|
|
int j;
|
|
|
|
|
|
|
|
seq_printf(p, "%*s: ", prec, "NMI");
|
|
|
|
for_each_online_cpu(j)
|
|
|
|
seq_printf(p, "%10u ", irq_stat[j].__nmi_count);
|
|
|
|
seq_printf(p, " Non-maskable interrupts\n");
|
|
|
|
|
2009-05-21 10:26:16 -06:00
|
|
|
seq_printf(p, "%*s: %10u\n", prec, "ERR", atomic_read(&irq_err_count));
|
2009-10-14 01:42:28 -06:00
|
|
|
|
2009-05-21 10:26:16 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
2007-11-01 21:16:51 -06:00
|
|
|
#ifdef CONFIG_IRQSTACKS
|
2006-09-27 03:22:14 -06:00
|
|
|
/*
|
|
|
|
* per-CPU IRQ handling contexts (thread information and stack)
|
|
|
|
*/
|
|
|
|
union irq_ctx {
|
|
|
|
struct thread_info tinfo;
|
|
|
|
u32 stack[THREAD_SIZE/sizeof(u32)];
|
|
|
|
};
|
|
|
|
|
2006-11-24 03:46:18 -07:00
|
|
|
static union irq_ctx *hardirq_ctx[NR_CPUS] __read_mostly;
|
|
|
|
static union irq_ctx *softirq_ctx[NR_CPUS] __read_mostly;
|
2006-09-27 03:22:14 -06:00
|
|
|
|
2010-04-14 22:13:52 -06:00
|
|
|
static char softirq_stack[NR_CPUS * THREAD_SIZE] __page_aligned_bss;
|
|
|
|
static char hardirq_stack[NR_CPUS * THREAD_SIZE] __page_aligned_bss;
|
|
|
|
|
|
|
|
static inline void handle_one_irq(unsigned int irq)
|
2006-01-16 23:14:14 -07:00
|
|
|
{
|
2006-09-27 03:22:14 -06:00
|
|
|
union irq_ctx *curctx, *irqctx;
|
|
|
|
|
|
|
|
curctx = (union irq_ctx *)current_thread_info();
|
|
|
|
irqctx = hardirq_ctx[smp_processor_id()];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this is where we switch to the IRQ stack. However, if we are
|
|
|
|
* already using the IRQ stack (because we interrupted a hardirq
|
|
|
|
* handler) we can't do that and just have to keep using the
|
|
|
|
* current stack (which is the irq stack already after all)
|
|
|
|
*/
|
|
|
|
if (curctx != irqctx) {
|
|
|
|
u32 *isp;
|
|
|
|
|
|
|
|
isp = (u32 *)((char *)irqctx + sizeof(*irqctx));
|
|
|
|
irqctx->tinfo.task = curctx->tinfo.task;
|
|
|
|
irqctx->tinfo.previous_sp = current_stack_pointer;
|
|
|
|
|
2006-11-24 03:46:18 -07:00
|
|
|
/*
|
|
|
|
* Copy the softirq bits in preempt_count so that the
|
|
|
|
* softirq checks work in the hardirq context.
|
|
|
|
*/
|
|
|
|
irqctx->tinfo.preempt_count =
|
|
|
|
(irqctx->tinfo.preempt_count & ~SOFTIRQ_MASK) |
|
|
|
|
(curctx->tinfo.preempt_count & SOFTIRQ_MASK);
|
|
|
|
|
2006-09-27 03:22:14 -06:00
|
|
|
__asm__ __volatile__ (
|
|
|
|
"mov %0, r4 \n"
|
2006-11-24 03:46:18 -07:00
|
|
|
"mov r15, r8 \n"
|
sh: interrupt exception handling rework
Kill off interrupt_table for all of the CPU subtypes, we now
default in to stepping in to do_IRQ() for _all_ IRQ exceptions
and counting the spurious ones, rather than simply flipping on
the ones we cared about. This and enabling the IRQ by default
automatically has already uncovered a couple of bugs and IRQs
that weren't being caught, as well as some that are being
generated far too often (SCI Tx Data Empty, for example).
The general rationale is to use a marker for interrupt exceptions,
test for it in the handle_exception() path, and skip out to
do_IRQ() if it's found. Everything else follows the same behaviour
of finding the cached EXPEVT value in r2/r2_bank, we just rip out
the INTEVT read from entry.S entirely (except for in the kGDB NMI
case, which is another matter).
Note that while this changes the do_IRQ() semantics regarding r4
handling, they were fundamentally broken anyways (relying entirely
on r2_bank for the cached code). With this, we do the INTEVT read
from do_IRQ() itself (in the CONFIG_CPU_HAS_INTEVT case), or fall
back on r4 for the muxed IRQ number, which should also be closer
to what SH-2 and SH-2A want anyways.
Signed-off-by: Paul Mundt <lethal@linux-sh.org>
2006-10-11 21:03:04 -06:00
|
|
|
"jsr @%1 \n"
|
2006-09-27 03:22:14 -06:00
|
|
|
/* swith to the irq stack */
|
sh: interrupt exception handling rework
Kill off interrupt_table for all of the CPU subtypes, we now
default in to stepping in to do_IRQ() for _all_ IRQ exceptions
and counting the spurious ones, rather than simply flipping on
the ones we cared about. This and enabling the IRQ by default
automatically has already uncovered a couple of bugs and IRQs
that weren't being caught, as well as some that are being
generated far too often (SCI Tx Data Empty, for example).
The general rationale is to use a marker for interrupt exceptions,
test for it in the handle_exception() path, and skip out to
do_IRQ() if it's found. Everything else follows the same behaviour
of finding the cached EXPEVT value in r2/r2_bank, we just rip out
the INTEVT read from entry.S entirely (except for in the kGDB NMI
case, which is another matter).
Note that while this changes the do_IRQ() semantics regarding r4
handling, they were fundamentally broken anyways (relying entirely
on r2_bank for the cached code). With this, we do the INTEVT read
from do_IRQ() itself (in the CONFIG_CPU_HAS_INTEVT case), or fall
back on r4 for the muxed IRQ number, which should also be closer
to what SH-2 and SH-2A want anyways.
Signed-off-by: Paul Mundt <lethal@linux-sh.org>
2006-10-11 21:03:04 -06:00
|
|
|
" mov %2, r15 \n"
|
2006-09-27 03:22:14 -06:00
|
|
|
/* restore the stack (ring zero) */
|
2006-11-24 03:46:18 -07:00
|
|
|
"mov r8, r15 \n"
|
2006-09-27 03:22:14 -06:00
|
|
|
: /* no outputs */
|
2006-10-06 00:31:16 -06:00
|
|
|
: "r" (irq), "r" (generic_handle_irq), "r" (isp)
|
2006-09-27 03:22:14 -06:00
|
|
|
: "memory", "r0", "r1", "r2", "r3", "r4",
|
|
|
|
"r5", "r6", "r7", "r8", "t", "pr"
|
|
|
|
);
|
|
|
|
} else
|
2006-10-06 00:31:16 -06:00
|
|
|
generic_handle_irq(irq);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-09-27 03:22:14 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* allocate per-cpu stacks for hardirq and for softirq processing
|
|
|
|
*/
|
|
|
|
void irq_ctx_init(int cpu)
|
|
|
|
{
|
|
|
|
union irq_ctx *irqctx;
|
|
|
|
|
|
|
|
if (hardirq_ctx[cpu])
|
|
|
|
return;
|
|
|
|
|
|
|
|
irqctx = (union irq_ctx *)&hardirq_stack[cpu * THREAD_SIZE];
|
|
|
|
irqctx->tinfo.task = NULL;
|
|
|
|
irqctx->tinfo.exec_domain = NULL;
|
|
|
|
irqctx->tinfo.cpu = cpu;
|
|
|
|
irqctx->tinfo.preempt_count = HARDIRQ_OFFSET;
|
|
|
|
irqctx->tinfo.addr_limit = MAKE_MM_SEG(0);
|
|
|
|
|
|
|
|
hardirq_ctx[cpu] = irqctx;
|
|
|
|
|
|
|
|
irqctx = (union irq_ctx *)&softirq_stack[cpu * THREAD_SIZE];
|
|
|
|
irqctx->tinfo.task = NULL;
|
|
|
|
irqctx->tinfo.exec_domain = NULL;
|
|
|
|
irqctx->tinfo.cpu = cpu;
|
2006-11-24 03:46:18 -07:00
|
|
|
irqctx->tinfo.preempt_count = 0;
|
2006-09-27 03:22:14 -06:00
|
|
|
irqctx->tinfo.addr_limit = MAKE_MM_SEG(0);
|
|
|
|
|
|
|
|
softirq_ctx[cpu] = irqctx;
|
|
|
|
|
|
|
|
printk("CPU %u irqstacks, hard=%p soft=%p\n",
|
|
|
|
cpu, hardirq_ctx[cpu], softirq_ctx[cpu]);
|
|
|
|
}
|
|
|
|
|
|
|
|
void irq_ctx_exit(int cpu)
|
|
|
|
{
|
|
|
|
hardirq_ctx[cpu] = NULL;
|
|
|
|
}
|
|
|
|
|
2013-09-05 07:49:45 -06:00
|
|
|
void do_softirq_own_stack(void)
|
2006-09-27 03:22:14 -06:00
|
|
|
{
|
|
|
|
struct thread_info *curctx;
|
|
|
|
union irq_ctx *irqctx;
|
|
|
|
u32 *isp;
|
|
|
|
|
2013-09-05 07:49:45 -06:00
|
|
|
curctx = current_thread_info();
|
|
|
|
irqctx = softirq_ctx[smp_processor_id()];
|
|
|
|
irqctx->tinfo.task = curctx->task;
|
|
|
|
irqctx->tinfo.previous_sp = current_stack_pointer;
|
|
|
|
|
|
|
|
/* build the stack frame on the softirq stack */
|
|
|
|
isp = (u32 *)((char *)irqctx + sizeof(*irqctx));
|
|
|
|
|
|
|
|
__asm__ __volatile__ (
|
|
|
|
"mov r15, r9 \n"
|
|
|
|
"jsr @%0 \n"
|
|
|
|
/* switch to the softirq stack */
|
|
|
|
" mov %1, r15 \n"
|
|
|
|
/* restore the thread stack */
|
|
|
|
"mov r9, r15 \n"
|
|
|
|
: /* no outputs */
|
|
|
|
: "r" (__do_softirq), "r" (isp)
|
|
|
|
: "memory", "r0", "r1", "r2", "r3", "r4",
|
|
|
|
"r5", "r6", "r7", "r8", "r9", "r15", "t", "pr"
|
|
|
|
);
|
2006-09-27 03:22:14 -06:00
|
|
|
}
|
2010-04-14 22:13:52 -06:00
|
|
|
#else
|
|
|
|
static inline void handle_one_irq(unsigned int irq)
|
|
|
|
{
|
|
|
|
generic_handle_irq(irq);
|
|
|
|
}
|
2006-09-27 03:22:14 -06:00
|
|
|
#endif
|
2006-12-05 20:05:02 -07:00
|
|
|
|
2010-04-14 22:13:52 -06:00
|
|
|
asmlinkage __irq_entry int do_IRQ(unsigned int irq, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
struct pt_regs *old_regs = set_irq_regs(regs);
|
|
|
|
|
|
|
|
irq_enter();
|
|
|
|
|
|
|
|
irq = irq_demux(irq_lookup(irq));
|
|
|
|
|
|
|
|
if (irq != NO_IRQ_IGNORE) {
|
|
|
|
handle_one_irq(irq);
|
|
|
|
irq_finish(irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
irq_exit();
|
|
|
|
|
|
|
|
set_irq_regs(old_regs);
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2006-12-05 20:05:02 -07:00
|
|
|
void __init init_IRQ(void)
|
|
|
|
{
|
2007-07-18 02:57:34 -06:00
|
|
|
plat_irq_setup();
|
2006-12-05 20:05:02 -07:00
|
|
|
|
|
|
|
/* Perform the machine specific initialisation */
|
|
|
|
if (sh_mv.mv_init_irq)
|
|
|
|
sh_mv.mv_init_irq();
|
|
|
|
|
2010-10-04 13:47:03 -06:00
|
|
|
intc_finalize();
|
|
|
|
|
2006-12-05 20:05:02 -07:00
|
|
|
irq_ctx_init(smp_processor_id());
|
|
|
|
}
|
2009-05-21 10:36:13 -06:00
|
|
|
|
2010-04-26 04:08:55 -06:00
|
|
|
#ifdef CONFIG_HOTPLUG_CPU
|
2010-10-27 20:33:21 -06:00
|
|
|
static void route_irq(struct irq_data *data, unsigned int irq, unsigned int cpu)
|
2010-04-26 04:08:55 -06:00
|
|
|
{
|
2010-10-27 20:33:21 -06:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
struct irq_chip *chip = irq_data_get_irq_chip(data);
|
|
|
|
|
2010-04-26 04:08:55 -06:00
|
|
|
printk(KERN_INFO "IRQ%u: moving from cpu%u to cpu%u\n",
|
2010-10-27 20:33:21 -06:00
|
|
|
irq, data->node, cpu);
|
2010-04-26 04:08:55 -06:00
|
|
|
|
|
|
|
raw_spin_lock_irq(&desc->lock);
|
2010-10-27 20:33:21 -06:00
|
|
|
chip->irq_set_affinity(data, cpumask_of(cpu), false);
|
2010-04-26 04:08:55 -06:00
|
|
|
raw_spin_unlock_irq(&desc->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The CPU has been marked offline. Migrate IRQs off this CPU. If
|
|
|
|
* the affinity settings do not allow other CPUs, force them onto any
|
|
|
|
* available CPU.
|
|
|
|
*/
|
|
|
|
void migrate_irqs(void)
|
|
|
|
{
|
|
|
|
unsigned int irq, cpu = smp_processor_id();
|
|
|
|
|
2010-10-27 20:33:21 -06:00
|
|
|
for_each_active_irq(irq) {
|
|
|
|
struct irq_data *data = irq_get_irq_data(irq);
|
|
|
|
|
|
|
|
if (data->node == cpu) {
|
|
|
|
unsigned int newcpu = cpumask_any_and(data->affinity,
|
2010-04-26 04:08:55 -06:00
|
|
|
cpu_online_mask);
|
|
|
|
if (newcpu >= nr_cpu_ids) {
|
2011-06-30 00:10:06 -06:00
|
|
|
pr_info_ratelimited("IRQ%u no longer affine to CPU%u\n",
|
|
|
|
irq, cpu);
|
2010-04-26 04:08:55 -06:00
|
|
|
|
2010-10-27 20:33:21 -06:00
|
|
|
cpumask_setall(data->affinity);
|
|
|
|
newcpu = cpumask_any_and(data->affinity,
|
2010-04-26 04:08:55 -06:00
|
|
|
cpu_online_mask);
|
|
|
|
}
|
|
|
|
|
2010-10-27 20:33:21 -06:00
|
|
|
route_irq(data, irq, newcpu);
|
2010-04-26 04:08:55 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|