/* * linux/arch/cris/kernel/irq.c * * Copyright (c) 2000, 2001, 2002, 2003 Axis Communications AB * * Authors: Bjorn Wesen (bjornw@axis.com) * * This file contains the code used by various IRQ handling routines: * asking for different IRQ's should be done through these routines * instead of just grabbing them. Thus setups with different IRQ numbers * shouldn't result in any weird surprises, and installing new handlers * should be easier. * * Notice Linux/CRIS: these routines do not care about SMP * */ /* * IRQ's are in fact implemented a bit like signal handlers for the kernel. * Naturally it's not a 1:1 relation, but there are similarities. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include char *hw_bp_msg = "BP 0x%x\n"; static inline void mask_irq(unsigned int irq_nr) { *R_VECT_MASK_CLR = 1 << irq_nr; } static inline void unmask_irq(unsigned int irq_nr) { *R_VECT_MASK_SET = 1 << irq_nr; } void disable_irq(unsigned int irq_nr) { unsigned long flags; save_flags(flags); cli(); mask_irq(irq_nr); restore_flags(flags); } void enable_irq(unsigned int irq_nr) { unsigned long flags; save_flags(flags); cli(); unmask_irq(irq_nr); restore_flags(flags); } unsigned long probe_irq_on() { return 0; } int probe_irq_off(unsigned long x) { return 0; } /* vector of shortcut jumps after the irq prologue */ irqvectptr irq_shortcuts[NR_IRQS]; /* don't use set_int_vector, it bypasses the linux interrupt handlers. it is * global just so that the kernel gdb can use it. */ void set_int_vector(int n, irqvectptr addr, irqvectptr saddr) { /* remember the shortcut entry point, after the prologue */ irq_shortcuts[n] = saddr; etrax_irv->v[n + 0x20] = (irqvectptr)addr; } /* the breakpoint vector is obviously not made just like the normal irq * handlers but needs to contain _code_ to jump to addr. * * the BREAK n instruction jumps to IBR + n * 8 */ void set_break_vector(int n, irqvectptr addr) { unsigned short *jinstr = (unsigned short *)&etrax_irv->v[n*2]; unsigned long *jaddr = (unsigned long *)(jinstr + 1); /* if you don't know what this does, do not touch it! */ *jinstr = 0x0d3f; *jaddr = (unsigned long)addr; /* 00000026 3f0d82000000 jump 0x82 */ } /* * This builds up the IRQ handler stubs using some ugly macros in irq.h * * These macros create the low-level assembly IRQ routines that do all * the operations that are needed. They are also written to be fast - and to * disable interrupts as little as humanly possible. * */ /* IRQ0 and 1 are special traps */ void hwbreakpoint(void); void IRQ1_interrupt(void); BUILD_TIMER_IRQ(2, 0x04) /* the timer interrupt is somewhat special */ BUILD_IRQ(3, 0x08) BUILD_IRQ(4, 0x10) BUILD_IRQ(5, 0x20) BUILD_IRQ(6, 0x40) BUILD_IRQ(7, 0x80) BUILD_IRQ(8, 0x100) BUILD_IRQ(9, 0x200) BUILD_IRQ(10, 0x400) BUILD_IRQ(11, 0x800) BUILD_IRQ(12, 0x1000) BUILD_IRQ(13, 0x2000) void mmu_bus_fault(void); /* IRQ 14 is the bus fault interrupt */ void multiple_interrupt(void); /* IRQ 15 is the multiple IRQ interrupt */ BUILD_IRQ(16, 0x10000) BUILD_IRQ(17, 0x20000) BUILD_IRQ(18, 0x40000) BUILD_IRQ(19, 0x80000) BUILD_IRQ(20, 0x100000) BUILD_IRQ(21, 0x200000) BUILD_IRQ(22, 0x400000) BUILD_IRQ(23, 0x800000) BUILD_IRQ(24, 0x1000000) BUILD_IRQ(25, 0x2000000) /* IRQ 26-30 are reserved */ BUILD_IRQ(31, 0x80000000) /* * Pointers to the low-level handlers */ static void (*interrupt[NR_IRQS])(void) = { NULL, NULL, IRQ2_interrupt, IRQ3_interrupt, IRQ4_interrupt, IRQ5_interrupt, IRQ6_interrupt, IRQ7_interrupt, IRQ8_interrupt, IRQ9_interrupt, IRQ10_interrupt, IRQ11_interrupt, IRQ12_interrupt, IRQ13_interrupt, NULL, NULL, IRQ16_interrupt, IRQ17_interrupt, IRQ18_interrupt, IRQ19_interrupt, IRQ20_interrupt, IRQ21_interrupt, IRQ22_interrupt, IRQ23_interrupt, IRQ24_interrupt, IRQ25_interrupt, NULL, NULL, NULL, NULL, NULL, IRQ31_interrupt }; static void (*sinterrupt[NR_IRQS])(void) = { NULL, NULL, sIRQ2_interrupt, sIRQ3_interrupt, sIRQ4_interrupt, sIRQ5_interrupt, sIRQ6_interrupt, sIRQ7_interrupt, sIRQ8_interrupt, sIRQ9_interrupt, sIRQ10_interrupt, sIRQ11_interrupt, sIRQ12_interrupt, sIRQ13_interrupt, NULL, NULL, sIRQ16_interrupt, sIRQ17_interrupt, sIRQ18_interrupt, sIRQ19_interrupt, sIRQ20_interrupt, sIRQ21_interrupt, sIRQ22_interrupt, sIRQ23_interrupt, sIRQ24_interrupt, sIRQ25_interrupt, NULL, NULL, NULL, NULL, NULL, sIRQ31_interrupt }; static void (*bad_interrupt[NR_IRQS])(void) = { NULL, NULL, NULL, bad_IRQ3_interrupt, bad_IRQ4_interrupt, bad_IRQ5_interrupt, bad_IRQ6_interrupt, bad_IRQ7_interrupt, bad_IRQ8_interrupt, bad_IRQ9_interrupt, bad_IRQ10_interrupt, bad_IRQ11_interrupt, bad_IRQ12_interrupt, bad_IRQ13_interrupt, NULL, NULL, bad_IRQ16_interrupt, bad_IRQ17_interrupt, bad_IRQ18_interrupt, bad_IRQ19_interrupt, bad_IRQ20_interrupt, bad_IRQ21_interrupt, bad_IRQ22_interrupt, bad_IRQ23_interrupt, bad_IRQ24_interrupt, bad_IRQ25_interrupt, NULL, NULL, NULL, NULL, NULL, bad_IRQ31_interrupt }; /* * Initial irq handlers. */ static struct irqaction *irq_action[NR_IRQS] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }; int get_irq_list(char *buf) { int i, len = 0; struct irqaction * action; for (i = 0; i < NR_IRQS; i++) { action = irq_action[i]; if (!action) continue; len += sprintf(buf+len, "%2d: %10u %c %s", i, kstat.irqs[0][i], (action->flags & SA_INTERRUPT) ? '+' : ' ', action->name); for (action = action->next; action; action = action->next) { len += sprintf(buf+len, ",%s %s", (action->flags & SA_INTERRUPT) ? " +" : "", action->name); } len += sprintf(buf+len, "\n"); } return len; } /* called by the assembler IRQ entry functions defined in irq.h * to dispatch the interrupts to registred handlers * interrupts are disabled upon entry - depending on if the * interrupt was registred with SA_INTERRUPT or not, interrupts * are re-enabled or not. */ asmlinkage void do_IRQ(int irq, struct pt_regs * regs) { struct irqaction *action; int do_random, cpu; cpu = smp_processor_id(); irq_enter(cpu); kstat.irqs[cpu][irq]++; action = irq_action[irq]; if (action) { if (!(action->flags & SA_INTERRUPT)) __sti(); action = irq_action[irq]; do_random = 0; do { do_random |= action->flags; action->handler(irq, action->dev_id, regs); action = action->next; } while (action); if (do_random & SA_SAMPLE_RANDOM) add_interrupt_randomness(irq); __cli(); } irq_exit(cpu); if (softirq_pending(cpu)) do_softirq(); /* unmasking and bottom half handling is done magically for us. */ } /* this function links in a handler into the chain of handlers for the * given irq, and if the irq has never been registred, the appropriate * handler is entered into the interrupt vector */ int setup_etrax_irq(int irq, struct irqaction * new) { int shared = 0; struct irqaction *old, **p; unsigned long flags; p = irq_action + irq; if ((old = *p) != NULL) { /* Can't share interrupts unless both agree to */ if (!(old->flags & new->flags & SA_SHIRQ)) return -EBUSY; /* Can't share interrupts unless both are same type */ if ((old->flags ^ new->flags) & SA_INTERRUPT) return -EBUSY; /* add new interrupt at end of irq queue */ do { p = &old->next; old = *p; } while (old); shared = 1; } if (new->flags & SA_SAMPLE_RANDOM) rand_initialize_irq(irq); save_flags(flags); cli(); *p = new; if (!shared) { /* if the irq wasn't registred before, enter it into the vector * table and unmask it physically */ set_int_vector(irq, interrupt[irq], sinterrupt[irq]); unmask_irq(irq); } restore_flags(flags); return 0; } /* this function is called by a driver to register an irq handler * Valid flags: * SA_INTERRUPT: it's a fast interrupt, handler called with irq disabled and * no signal checking etc is performed upon exit * SA_SHIRQ: the interrupt can be shared between different handlers, the * handler is required to check if the irq was "aimed" at it * explicitely * SA_RANDOM: the interrupt will add to the random generators entropy */ int request_irq(unsigned int irq, void (*handler)(int, void *, struct pt_regs *), unsigned long irqflags, const char * devname, void *dev_id) { int retval; struct irqaction * action; /* interrupts 0 and 1 are hardware breakpoint and NMI and we can't * support these yet. interrupt 15 is the multiple irq, it's special. */ if(irq < 2 || irq == 15 || irq >= NR_IRQS) return -EINVAL; if(!handler) return -EINVAL; /* allocate and fill in a handler structure and setup the irq */ action = kmalloc(sizeof *action, GFP_KERNEL); if (!action) return -ENOMEM; action->handler = handler; action->flags = irqflags; action->mask = 0; action->name = devname; action->next = NULL; action->dev_id = dev_id; retval = setup_etrax_irq(irq, action); if (retval) kfree(action); return retval; } void free_irq(unsigned int irq, void *dev_id) { struct irqaction * action, **p; unsigned long flags; if (irq >= NR_IRQS) { printk("Trying to free IRQ%d\n",irq); return; } for (p = irq + irq_action; (action = *p) != NULL; p = &action->next) { if (action->dev_id != dev_id) continue; /* Found it - now free it */ save_flags(flags); cli(); *p = action->next; if (!irq_action[irq]) { mask_irq(irq); set_int_vector(irq, bad_interrupt[irq], 0); } restore_flags(flags); kfree(action); return; } printk("Trying to free free IRQ%d\n",irq); } void weird_irq(void) { __asm__("di"); printk("weird irq\n"); while(1); } /* init_IRQ() is called by start_kernel and is responsible for fixing IRQ masks * and setting the irq vector table to point to bad_interrupt ptrs. */ void system_call(void); /* from entry.S */ void do_sigtrap(void); /* from entry.S */ void gdb_handle_breakpoint(void); /* from entry.S */ void __init init_IRQ(void) { int i; /* clear all interrupt masks */ #ifndef CONFIG_SVINTO_SIM *R_IRQ_MASK0_CLR = 0xffffffff; *R_IRQ_MASK1_CLR = 0xffffffff; *R_IRQ_MASK2_CLR = 0xffffffff; #endif *R_VECT_MASK_CLR = 0xffffffff; /* clear the shortcut entry points */ for(i = 0; i < NR_IRQS; i++) irq_shortcuts[i] = NULL; for (i = 0; i < 256; i++) etrax_irv->v[i] = weird_irq; /* the entries in the break vector contain actual code to be * executed by the associated break handler, rather than just a jump * address. therefore we need to setup a default breakpoint handler * for all breakpoints */ for (i = 0; i < 16; i++) set_break_vector(i, do_sigtrap); /* set all etrax irq's to the bad handlers */ for (i = 2; i < NR_IRQS; i++) set_int_vector(i, bad_interrupt[i], 0); /* except IRQ 15 which is the multiple-IRQ handler on Etrax100 */ set_int_vector(15, multiple_interrupt, 0); /* 0 and 1 which are special breakpoint/NMI traps */ set_int_vector(0, hwbreakpoint, 0); set_int_vector(1, IRQ1_interrupt, 0); /* and irq 14 which is the mmu bus fault handler */ set_int_vector(14, mmu_bus_fault, 0); /* setup the system-call trap, which is reached by BREAK 13 */ set_break_vector(13, system_call); /* setup a breakpoint handler for debugging used for both user and * kernel mode debugging (which is why it is not inside an ifdef * CONFIG_ETRAX_KGDB) */ set_break_vector(8, gdb_handle_breakpoint); #ifdef CONFIG_ETRAX_KGDB /* setup kgdb if its enabled, and break into the debugger */ kgdb_init(); breakpoint(); #endif } #if defined(CONFIG_PROC_FS) && defined(CONFIG_SYSCTL) /* Used by other archs to show/control IRQ steering during SMP */ void __init init_irq_proc(void) { } #endif