2006-09-27 09:22:14 +00:00
|
|
|
/*
|
2005-04-16 22:20:36 +00:00
|
|
|
* linux/arch/sh/kernel/irq.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* SuperH version: Copyright (C) 1999 Niibe Yutaka
|
|
|
|
*/
|
2006-01-17 06:14:14 +00:00
|
|
|
#include <linux/irq.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/interrupt.h>
|
2006-09-27 09:22:14 +00:00
|
|
|
#include <linux/module.h>
|
2006-01-17 06:14:14 +00:00
|
|
|
#include <linux/kernel_stat.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/seq_file.h>
|
2006-01-17 06:14:14 +00:00
|
|
|
#include <asm/processor.h>
|
2007-03-12 05:09:35 +00:00
|
|
|
#include <asm/machvec.h>
|
2006-09-27 09:22:14 +00:00
|
|
|
#include <asm/uaccess.h>
|
2009-08-13 16:58:43 +00:00
|
|
|
#include <asm/dwarf.h>
|
2006-09-27 09:22:14 +00:00
|
|
|
#include <asm/thread_info.h>
|
2008-07-28 23:09:44 +00:00
|
|
|
#include <cpu/mmu_context.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-10-06 06:31:16 +00:00
|
|
|
atomic_t irq_err_count;
|
|
|
|
|
2005-04-16 22:20:36 +00: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-12 03:03:04 +00:00
|
|
|
atomic_inc(&irq_err_count);
|
2005-04-16 22:20:36 +00:00
|
|
|
printk("unexpected IRQ trap at vector %02x\n", irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(CONFIG_PROC_FS)
|
2009-05-21 16:26:16 +00:00
|
|
|
/*
|
|
|
|
* /proc/interrupts printing:
|
|
|
|
*/
|
|
|
|
static int show_other_interrupts(struct seq_file *p, int prec)
|
|
|
|
{
|
|
|
|
seq_printf(p, "%*s: %10u\n", prec, "ERR", atomic_read(&irq_err_count));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
int show_interrupts(struct seq_file *p, void *v)
|
|
|
|
{
|
2009-05-21 16:26:16 +00:00
|
|
|
unsigned long flags, any_count = 0;
|
|
|
|
int i = *(loff_t *)v, j, prec;
|
|
|
|
struct irqaction *action;
|
|
|
|
struct irq_desc *desc;
|
|
|
|
|
|
|
|
if (i > nr_irqs)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
|
|
|
|
j *= 10;
|
|
|
|
|
|
|
|
if (i == nr_irqs)
|
|
|
|
return show_other_interrupts(p, prec);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (i == 0) {
|
2009-05-21 16:26:16 +00:00
|
|
|
seq_printf(p, "%*s", prec + 8, "");
|
2006-03-23 11:01:05 +00:00
|
|
|
for_each_online_cpu(j)
|
2009-05-21 16:26:16 +00:00
|
|
|
seq_printf(p, "CPU%-8d", j);
|
2005-04-16 22:20:36 +00:00
|
|
|
seq_putc(p, '\n');
|
|
|
|
}
|
|
|
|
|
2009-05-21 16:26:16 +00:00
|
|
|
desc = irq_to_desc(i);
|
|
|
|
if (!desc)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&desc->lock, flags);
|
|
|
|
for_each_online_cpu(j)
|
|
|
|
any_count |= kstat_irqs_cpu(i, j);
|
|
|
|
action = desc->action;
|
|
|
|
if (!action && !any_count)
|
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-05-21 16:26:16 +00:00
|
|
|
seq_printf(p, "%*d: ", prec, i);
|
|
|
|
for_each_online_cpu(j)
|
|
|
|
seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
|
|
|
|
seq_printf(p, " %14s", desc->chip->name);
|
|
|
|
seq_printf(p, "-%-8s", desc->name);
|
|
|
|
|
|
|
|
if (action) {
|
|
|
|
seq_printf(p, " %s", action->name);
|
|
|
|
while ((action = action->next) != NULL)
|
2005-04-16 22:20:36 +00:00
|
|
|
seq_printf(p, ", %s", action->name);
|
2009-05-21 16:26:16 +00:00
|
|
|
}
|
2006-10-06 06:31:16 +00:00
|
|
|
|
2009-05-21 16:26:16 +00:00
|
|
|
seq_putc(p, '\n');
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&desc->lock, flags);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-11-02 03:16:51 +00:00
|
|
|
#ifdef CONFIG_IRQSTACKS
|
2006-09-27 09:22:14 +00: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 10:46:18 +00:00
|
|
|
static union irq_ctx *hardirq_ctx[NR_CPUS] __read_mostly;
|
|
|
|
static union irq_ctx *softirq_ctx[NR_CPUS] __read_mostly;
|
2006-09-27 09:22:14 +00:00
|
|
|
#endif
|
|
|
|
|
2007-03-14 04:03:35 +00:00
|
|
|
asmlinkage int do_IRQ(unsigned int irq, struct pt_regs *regs)
|
2006-01-17 06:14:14 +00:00
|
|
|
{
|
2006-11-21 02:16:57 +00:00
|
|
|
struct pt_regs *old_regs = set_irq_regs(regs);
|
2007-11-02 03:16:51 +00:00
|
|
|
#ifdef CONFIG_IRQSTACKS
|
2006-09-27 09:22:14 +00:00
|
|
|
union irq_ctx *curctx, *irqctx;
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
irq_enter();
|
2009-02-24 13:58:57 +00:00
|
|
|
irq = irq_demux(intc_evt2irq(irq));
|
2006-09-27 09:22:14 +00:00
|
|
|
|
2007-11-02 03:16:51 +00:00
|
|
|
#ifdef CONFIG_IRQSTACKS
|
2006-09-27 09:22:14 +00:00
|
|
|
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 10:46:18 +00: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 09:22:14 +00:00
|
|
|
__asm__ __volatile__ (
|
|
|
|
"mov %0, r4 \n"
|
2006-11-24 10:46:18 +00: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-12 03:03:04 +00:00
|
|
|
"jsr @%1 \n"
|
2006-09-27 09:22:14 +00: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-12 03:03:04 +00:00
|
|
|
" mov %2, r15 \n"
|
2006-09-27 09:22:14 +00:00
|
|
|
/* restore the stack (ring zero) */
|
2006-11-24 10:46:18 +00:00
|
|
|
"mov r8, r15 \n"
|
2006-09-27 09:22:14 +00:00
|
|
|
: /* no outputs */
|
2006-10-06 06:31:16 +00:00
|
|
|
: "r" (irq), "r" (generic_handle_irq), "r" (isp)
|
2006-09-27 09:22:14 +00:00
|
|
|
: "memory", "r0", "r1", "r2", "r3", "r4",
|
|
|
|
"r5", "r6", "r7", "r8", "t", "pr"
|
|
|
|
);
|
|
|
|
} else
|
|
|
|
#endif
|
2006-10-06 06:31:16 +00:00
|
|
|
generic_handle_irq(irq);
|
2006-09-27 09:22:14 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
irq_exit();
|
2006-09-27 09:22:14 +00:00
|
|
|
|
2006-10-06 06:31:16 +00:00
|
|
|
set_irq_regs(old_regs);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2006-09-27 09:22:14 +00:00
|
|
|
|
2007-11-02 03:16:51 +00:00
|
|
|
#ifdef CONFIG_IRQSTACKS
|
2006-09-27 09:22:14 +00:00
|
|
|
static char softirq_stack[NR_CPUS * THREAD_SIZE]
|
2007-07-12 01:41:52 +00:00
|
|
|
__attribute__((__section__(".bss.page_aligned")));
|
2006-09-27 09:22:14 +00:00
|
|
|
|
|
|
|
static char hardirq_stack[NR_CPUS * THREAD_SIZE]
|
2007-07-12 01:41:52 +00:00
|
|
|
__attribute__((__section__(".bss.page_aligned")));
|
2006-09-27 09:22:14 +00: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 10:46:18 +00:00
|
|
|
irqctx->tinfo.preempt_count = 0;
|
2006-09-27 09:22:14 +00: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
asmlinkage void do_softirq(void)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct thread_info *curctx;
|
|
|
|
union irq_ctx *irqctx;
|
|
|
|
u32 *isp;
|
|
|
|
|
|
|
|
if (in_interrupt())
|
|
|
|
return;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
|
|
|
|
if (local_softirq_pending()) {
|
|
|
|
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-11-24 10:46:18 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Shouldnt happen, we returned above if in_interrupt():
|
|
|
|
*/
|
|
|
|
WARN_ON_ONCE(softirq_count());
|
2006-09-27 09:22:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
#endif
|
2006-12-06 03:05:02 +00:00
|
|
|
|
|
|
|
void __init init_IRQ(void)
|
|
|
|
{
|
2007-07-18 08:57:34 +00:00
|
|
|
plat_irq_setup();
|
2006-12-06 03:05:02 +00:00
|
|
|
|
|
|
|
/* Perform the machine specific initialisation */
|
|
|
|
if (sh_mv.mv_init_irq)
|
|
|
|
sh_mv.mv_init_irq();
|
|
|
|
|
|
|
|
irq_ctx_init(smp_processor_id());
|
2009-08-13 16:58:43 +00:00
|
|
|
|
|
|
|
/* This needs to be early, but not too early.. */
|
|
|
|
dwarf_unwinder_init();
|
2006-12-06 03:05:02 +00:00
|
|
|
}
|
2009-05-21 16:36:13 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_SPARSE_IRQ
|
|
|
|
int __init arch_probe_nr_irqs(void)
|
|
|
|
{
|
|
|
|
nr_irqs = sh_mv.mv_nr_irqs;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|