2 * arch/sparc/kernel/irq.c: Interrupt request handling routines. On the
3 * Sparc the IRQs are basically 'cast in stone'
4 * and you are supposed to probe the prom's device
5 * node trees to find out who's got which IRQ.
7 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
8 * Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)
9 * Copyright (C) 1995,2002 Pete A. Zaitcev (zaitcev@yahoo.com)
10 * Copyright (C) 1996 Dave Redman (djhr@tadpole.co.uk)
11 * Copyright (C) 1998-2000 Anton Blanchard (anton@samba.org)
14 #include <linux/module.h>
15 #include <linux/sched.h>
16 #include <linux/ptrace.h>
17 #include <linux/errno.h>
18 #include <linux/linkage.h>
19 #include <linux/kernel_stat.h>
20 #include <linux/signal.h>
21 #include <linux/interrupt.h>
22 #include <linux/slab.h>
23 #include <linux/random.h>
24 #include <linux/init.h>
25 #include <linux/smp.h>
26 #include <linux/delay.h>
27 #include <linux/threads.h>
28 #include <linux/spinlock.h>
29 #include <linux/seq_file.h>
31 #include <asm/ptrace.h>
32 #include <asm/processor.h>
33 #include <asm/system.h>
36 #include <asm/vaddrs.h>
37 #include <asm/timer.h>
38 #include <asm/openprom.h>
39 #include <asm/oplib.h>
40 #include <asm/traps.h>
43 #include <asm/pgalloc.h>
44 #include <asm/pgtable.h>
46 #include <asm/cacheflush.h>
47 #include <asm/irq_regs.h>
52 #define SMP_NOP2 "nop; nop;\n\t"
53 #define SMP_NOP3 "nop; nop; nop;\n\t"
59 int nr_irqs = NR_IRQS;
60 EXPORT_SYMBOL(nr_irqs);
62 unsigned long __raw_local_irq_save(void)
69 SMP_NOP3 /* Sun4m + Cypress + SMP bug */
73 : "=&r" (retval), "=r" (tmp)
80 void raw_local_irq_enable(void)
86 SMP_NOP3 /* Sun4m + Cypress + SMP bug */
95 void raw_local_irq_restore(unsigned long old_psr)
102 SMP_NOP2 /* Sun4m + Cypress + SMP bug */
103 "andn %0, %1, %0\n\t"
104 "wr %0, %2, %%psr\n\t"
107 : "i" (PSR_PIL), "r" (old_psr)
111 EXPORT_SYMBOL(__raw_local_irq_save);
112 EXPORT_SYMBOL(raw_local_irq_enable);
113 EXPORT_SYMBOL(raw_local_irq_restore);
116 * Dave Redman (djhr@tadpole.co.uk)
118 * IRQ numbers.. These are no longer restricted to 15..
120 * this is done to enable SBUS cards and onboard IO to be masked
121 * correctly. using the interrupt level isn't good enough.
124 * A device interrupting at sbus level6 and the Floppy both come in
125 * at IRQ11, but enabling and disabling them requires writing to
126 * different bits in the SLAVIO/SEC.
128 * As a result of these changes sun4m machines could now support
129 * directed CPU interrupts using the existing enable/disable irq code
134 static void irq_panic(void)
136 extern char *cputypval;
137 prom_printf("machine: %s doesn't have irq handlers defined!\n",cputypval);
141 void (*sparc_init_timers)(irq_handler_t ) =
142 (void (*)(irq_handler_t )) irq_panic;
145 * Dave Redman (djhr@tadpole.co.uk)
147 * There used to be extern calls and hard coded values here.. very sucky!
148 * instead, because some of the devices attach very early, I do something
149 * equally sucky but at least we'll never try to free statically allocated
150 * space or call kmalloc before kmalloc_init :(.
152 * In fact it's the timer10 that attaches first.. then timer14
153 * then kmalloc_init is called.. then the tty interrupts attach.
157 #define MAX_STATIC_ALLOC 4
158 struct irqaction static_irqaction[MAX_STATIC_ALLOC];
159 int static_irq_count;
162 struct irqaction *action;
164 } sparc_irq[NR_IRQS];
165 #define SPARC_IRQ_INPROGRESS 1
167 /* Used to protect the IRQ action lists */
168 DEFINE_SPINLOCK(irq_action_lock);
170 int show_interrupts(struct seq_file *p, void *v)
172 int i = *(loff_t *) v;
173 struct irqaction * action;
179 if (sparc_cpu_model == sun4d) {
180 extern int show_sun4d_interrupts(struct seq_file *, void *);
182 return show_sun4d_interrupts(p, v);
184 spin_lock_irqsave(&irq_action_lock, flags);
186 action = sparc_irq[i].action;
189 seq_printf(p, "%3d: ", i);
191 seq_printf(p, "%10u ", kstat_irqs(i));
193 for_each_online_cpu(j) {
194 seq_printf(p, "%10u ",
195 kstat_cpu(j).irqs[i]);
198 seq_printf(p, " %c %s",
199 (action->flags & IRQF_DISABLED) ? '+' : ' ',
201 for (action=action->next; action; action = action->next) {
202 seq_printf(p, ",%s %s",
203 (action->flags & IRQF_DISABLED) ? " +" : "",
209 spin_unlock_irqrestore(&irq_action_lock, flags);
213 void free_irq(unsigned int irq, void *dev_id)
215 struct irqaction * action;
216 struct irqaction **actionp;
218 unsigned int cpu_irq;
220 if (sparc_cpu_model == sun4d) {
221 extern void sun4d_free_irq(unsigned int, void *);
223 sun4d_free_irq(irq, dev_id);
226 cpu_irq = irq & (NR_IRQS - 1);
227 if (cpu_irq > 14) { /* 14 irq levels on the sparc */
228 printk("Trying to free bogus IRQ %d\n", irq);
232 spin_lock_irqsave(&irq_action_lock, flags);
234 actionp = &sparc_irq[cpu_irq].action;
237 if (!action->handler) {
238 printk("Trying to free free IRQ%d\n",irq);
242 for (; action; action = action->next) {
243 if (action->dev_id == dev_id)
245 actionp = &action->next;
248 printk("Trying to free free shared IRQ%d\n",irq);
251 } else if (action->flags & IRQF_SHARED) {
252 printk("Trying to free shared IRQ%d with NULL device ID\n", irq);
255 if (action->flags & SA_STATIC_ALLOC)
257 /* This interrupt is marked as specially allocated
258 * so it is a bad idea to free it.
260 printk("Attempt to free statically allocated IRQ%d (%s)\n",
265 *actionp = action->next;
267 spin_unlock_irqrestore(&irq_action_lock, flags);
269 synchronize_irq(irq);
271 spin_lock_irqsave(&irq_action_lock, flags);
275 if (!sparc_irq[cpu_irq].action)
279 spin_unlock_irqrestore(&irq_action_lock, flags);
282 EXPORT_SYMBOL(free_irq);
285 * This is called when we want to synchronize with
286 * interrupts. We may for example tell a device to
287 * stop sending interrupts: but to make sure there
288 * are no interrupts that are executing on another
289 * CPU we need to call this function.
292 void synchronize_irq(unsigned int irq)
294 unsigned int cpu_irq;
296 cpu_irq = irq & (NR_IRQS - 1);
297 while (sparc_irq[cpu_irq].flags & SPARC_IRQ_INPROGRESS)
302 void unexpected_irq(int irq, void *dev_id, struct pt_regs * regs)
305 struct irqaction * action;
306 unsigned int cpu_irq;
308 cpu_irq = irq & (NR_IRQS - 1);
309 action = sparc_irq[cpu_irq].action;
311 printk("IO device interrupt, irq = %d\n", irq);
312 printk("PC = %08lx NPC = %08lx FP=%08lx\n", regs->pc,
313 regs->npc, regs->u_regs[14]);
315 printk("Expecting: ");
316 for (i = 0; i < 16; i++)
318 printk("[%s:%d:0x%x] ", action->name,
319 (int) i, (unsigned int) action->handler);
322 panic("bogus interrupt received");
325 void handler_irq(int irq, struct pt_regs * regs)
327 struct pt_regs *old_regs;
328 struct irqaction * action;
329 int cpu = smp_processor_id();
331 extern void smp4m_irq_rotate(int cpu);
334 old_regs = set_irq_regs(regs);
336 disable_pil_irq(irq);
338 /* Only rotate on lower priority IRQs (scsi, ethernet, etc.). */
339 if((sparc_cpu_model==sun4m) && (irq < 10))
340 smp4m_irq_rotate(cpu);
342 action = sparc_irq[irq].action;
343 sparc_irq[irq].flags |= SPARC_IRQ_INPROGRESS;
344 kstat_cpu(cpu).irqs[irq]++;
346 if (!action || !action->handler)
347 unexpected_irq(irq, NULL, regs);
348 action->handler(irq, action->dev_id);
349 action = action->next;
351 sparc_irq[irq].flags &= ~SPARC_IRQ_INPROGRESS;
354 set_irq_regs(old_regs);
357 #if defined(CONFIG_BLK_DEV_FD) || defined(CONFIG_BLK_DEV_FD_MODULE)
359 /* Fast IRQs on the Sparc can only have one routine attached to them,
360 * thus no sharing possible.
362 static int request_fast_irq(unsigned int irq,
363 void (*handler)(void),
364 unsigned long irqflags, const char *devname)
366 struct irqaction *action;
368 unsigned int cpu_irq;
371 struct tt_entry *trap_table;
372 extern struct tt_entry trapbase_cpu1, trapbase_cpu2, trapbase_cpu3;
375 cpu_irq = irq & (NR_IRQS - 1);
385 spin_lock_irqsave(&irq_action_lock, flags);
387 action = sparc_irq[cpu_irq].action;
389 if(action->flags & IRQF_SHARED)
390 panic("Trying to register fast irq when already shared.\n");
391 if(irqflags & IRQF_SHARED)
392 panic("Trying to register fast irq as shared.\n");
394 /* Anyway, someone already owns it so cannot be made fast. */
395 printk("request_fast_irq: Trying to register yet already owned.\n");
400 /* If this is flagged as statically allocated then we use our
401 * private struct which is never freed.
403 if (irqflags & SA_STATIC_ALLOC) {
404 if (static_irq_count < MAX_STATIC_ALLOC)
405 action = &static_irqaction[static_irq_count++];
407 printk("Fast IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n",
412 action = kmalloc(sizeof(struct irqaction),
420 /* Dork with trap table if we get this far. */
421 #define INSTANTIATE(table) \
422 table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_one = SPARC_RD_PSR_L0; \
423 table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two = \
424 SPARC_BRANCH((unsigned long) handler, \
425 (unsigned long) &table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two);\
426 table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_three = SPARC_RD_WIM_L3; \
427 table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_four = SPARC_NOP;
429 INSTANTIATE(sparc_ttable)
431 trap_table = &trapbase_cpu1; INSTANTIATE(trap_table)
432 trap_table = &trapbase_cpu2; INSTANTIATE(trap_table)
433 trap_table = &trapbase_cpu3; INSTANTIATE(trap_table)
437 * XXX Correct thing whould be to flush only I- and D-cache lines
438 * which contain the handler in question. But as of time of the
439 * writing we have no CPU-neutral interface to fine-grained flushes.
443 action->flags = irqflags;
444 cpus_clear(action->mask);
445 action->name = devname;
446 action->dev_id = NULL;
449 sparc_irq[cpu_irq].action = action;
455 spin_unlock_irqrestore(&irq_action_lock, flags);
460 /* These variables are used to access state from the assembler
461 * interrupt handler, floppy_hardint, so we cannot put these in
462 * the floppy driver image because that would not work in the
465 volatile unsigned char *fdc_status;
466 EXPORT_SYMBOL(fdc_status);
469 EXPORT_SYMBOL(pdma_vaddr);
471 unsigned long pdma_size;
472 EXPORT_SYMBOL(pdma_size);
474 volatile int doing_pdma;
475 EXPORT_SYMBOL(doing_pdma);
478 EXPORT_SYMBOL(pdma_base);
480 unsigned long pdma_areasize;
481 EXPORT_SYMBOL(pdma_areasize);
483 extern void floppy_hardint(void);
485 static irq_handler_t floppy_irq_handler;
487 void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs)
489 struct pt_regs *old_regs;
490 int cpu = smp_processor_id();
492 old_regs = set_irq_regs(regs);
493 disable_pil_irq(irq);
495 kstat_cpu(cpu).irqs[irq]++;
496 floppy_irq_handler(irq, dev_id);
499 set_irq_regs(old_regs);
500 // XXX Eek, it's totally changed with preempt_count() and such
501 // if (softirq_pending(cpu))
505 int sparc_floppy_request_irq(int irq, unsigned long flags,
506 irq_handler_t irq_handler)
508 floppy_irq_handler = irq_handler;
509 return request_fast_irq(irq, floppy_hardint, flags, "floppy");
511 EXPORT_SYMBOL(sparc_floppy_request_irq);
515 int request_irq(unsigned int irq,
516 irq_handler_t handler,
517 unsigned long irqflags, const char * devname, void *dev_id)
519 struct irqaction * action, **actionp;
521 unsigned int cpu_irq;
524 if (sparc_cpu_model == sun4d) {
525 extern int sun4d_request_irq(unsigned int,
527 unsigned long, const char *, void *);
528 return sun4d_request_irq(irq, handler, irqflags, devname, dev_id);
530 cpu_irq = irq & (NR_IRQS - 1);
540 spin_lock_irqsave(&irq_action_lock, flags);
542 actionp = &sparc_irq[cpu_irq].action;
545 if (!(action->flags & IRQF_SHARED) || !(irqflags & IRQF_SHARED)) {
549 if ((action->flags & IRQF_DISABLED) != (irqflags & IRQF_DISABLED)) {
550 printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq);
554 for ( ; action; action = *actionp)
555 actionp = &action->next;
558 /* If this is flagged as statically allocated then we use our
559 * private struct which is never freed.
561 if (irqflags & SA_STATIC_ALLOC) {
562 if (static_irq_count < MAX_STATIC_ALLOC)
563 action = &static_irqaction[static_irq_count++];
565 printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname);
569 action = kmalloc(sizeof(struct irqaction),
577 action->handler = handler;
578 action->flags = irqflags;
579 cpus_clear(action->mask);
580 action->name = devname;
582 action->dev_id = dev_id;
590 spin_unlock_irqrestore(&irq_action_lock, flags);
595 EXPORT_SYMBOL(request_irq);
597 void disable_irq_nosync(unsigned int irq)
599 return __disable_irq(irq);
601 EXPORT_SYMBOL(disable_irq_nosync);
603 void disable_irq(unsigned int irq)
605 return __disable_irq(irq);
607 EXPORT_SYMBOL(disable_irq);
609 void enable_irq(unsigned int irq)
611 return __enable_irq(irq);
614 EXPORT_SYMBOL(enable_irq);
616 /* We really don't need these at all on the Sparc. We only have
617 * stubs here because they are exported to modules.
619 unsigned long probe_irq_on(void)
624 EXPORT_SYMBOL(probe_irq_on);
626 int probe_irq_off(unsigned long mask)
631 EXPORT_SYMBOL(probe_irq_off);
634 * This could probably be made indirect too and assigned in the CPU
635 * bits of the code. That would be much nicer I think and would also
636 * fit in with the idea of being able to tune your kernel for your machine
637 * by removing unrequired machine and device support.
641 void __init init_IRQ(void)
643 extern void sun4c_init_IRQ( void );
644 extern void sun4m_init_IRQ( void );
645 extern void sun4d_init_IRQ( void );
647 switch(sparc_cpu_model) {
656 if (pcic_present()) {
657 sun4m_pci_init_IRQ();
669 prom_printf("Cannot initialize IRQs on this Sun machine...");
675 void init_irq_proc(void)
677 /* For now, nothing... */