1d670bd4fSSam Ravnborg /* 2d670bd4fSSam Ravnborg * arch/sparc/kernel/irq.c: Interrupt request handling routines. On the 3d670bd4fSSam Ravnborg * Sparc the IRQs are basically 'cast in stone' 4d670bd4fSSam Ravnborg * and you are supposed to probe the prom's device 5d670bd4fSSam Ravnborg * node trees to find out who's got which IRQ. 6d670bd4fSSam Ravnborg * 7d670bd4fSSam Ravnborg * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) 8d670bd4fSSam Ravnborg * Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx) 9d670bd4fSSam Ravnborg * Copyright (C) 1995,2002 Pete A. Zaitcev (zaitcev@yahoo.com) 10d670bd4fSSam Ravnborg * Copyright (C) 1996 Dave Redman (djhr@tadpole.co.uk) 11d670bd4fSSam Ravnborg * Copyright (C) 1998-2000 Anton Blanchard (anton@samba.org) 12d670bd4fSSam Ravnborg */ 13d670bd4fSSam Ravnborg 14d670bd4fSSam Ravnborg #include <linux/module.h> 15d670bd4fSSam Ravnborg #include <linux/sched.h> 16d670bd4fSSam Ravnborg #include <linux/ptrace.h> 17d670bd4fSSam Ravnborg #include <linux/errno.h> 18d670bd4fSSam Ravnborg #include <linux/linkage.h> 19d670bd4fSSam Ravnborg #include <linux/kernel_stat.h> 20d670bd4fSSam Ravnborg #include <linux/signal.h> 21d670bd4fSSam Ravnborg #include <linux/interrupt.h> 22d670bd4fSSam Ravnborg #include <linux/slab.h> 23d670bd4fSSam Ravnborg #include <linux/random.h> 24d670bd4fSSam Ravnborg #include <linux/init.h> 25d670bd4fSSam Ravnborg #include <linux/smp.h> 26d670bd4fSSam Ravnborg #include <linux/delay.h> 27d670bd4fSSam Ravnborg #include <linux/threads.h> 28d670bd4fSSam Ravnborg #include <linux/spinlock.h> 29d670bd4fSSam Ravnborg #include <linux/seq_file.h> 30d670bd4fSSam Ravnborg 31d670bd4fSSam Ravnborg #include <asm/ptrace.h> 32d670bd4fSSam Ravnborg #include <asm/processor.h> 33d670bd4fSSam Ravnborg #include <asm/system.h> 34d670bd4fSSam Ravnborg #include <asm/psr.h> 35d670bd4fSSam Ravnborg #include <asm/smp.h> 36d670bd4fSSam Ravnborg #include <asm/vaddrs.h> 37d670bd4fSSam Ravnborg #include <asm/timer.h> 38d670bd4fSSam Ravnborg #include <asm/openprom.h> 39d670bd4fSSam Ravnborg #include <asm/oplib.h> 40d670bd4fSSam Ravnborg #include <asm/traps.h> 41d670bd4fSSam Ravnborg #include <asm/irq.h> 42d670bd4fSSam Ravnborg #include <asm/io.h> 43d670bd4fSSam Ravnborg #include <asm/pgalloc.h> 44d670bd4fSSam Ravnborg #include <asm/pgtable.h> 45d670bd4fSSam Ravnborg #include <asm/pcic.h> 46d670bd4fSSam Ravnborg #include <asm/cacheflush.h> 47d670bd4fSSam Ravnborg #include <asm/irq_regs.h> 48d670bd4fSSam Ravnborg 4981265fd9SSam Ravnborg #include "kernel.h" 50d670bd4fSSam Ravnborg #include "irq.h" 51d670bd4fSSam Ravnborg 52d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 53d670bd4fSSam Ravnborg #define SMP_NOP2 "nop; nop;\n\t" 54d670bd4fSSam Ravnborg #define SMP_NOP3 "nop; nop; nop;\n\t" 55d670bd4fSSam Ravnborg #else 56d670bd4fSSam Ravnborg #define SMP_NOP2 57d670bd4fSSam Ravnborg #define SMP_NOP3 58d670bd4fSSam Ravnborg #endif /* SMP */ 59d670bd4fSSam Ravnborg unsigned long __raw_local_irq_save(void) 60d670bd4fSSam Ravnborg { 61d670bd4fSSam Ravnborg unsigned long retval; 62d670bd4fSSam Ravnborg unsigned long tmp; 63d670bd4fSSam Ravnborg 64d670bd4fSSam Ravnborg __asm__ __volatile__( 65d670bd4fSSam Ravnborg "rd %%psr, %0\n\t" 66d670bd4fSSam Ravnborg SMP_NOP3 /* Sun4m + Cypress + SMP bug */ 67d670bd4fSSam Ravnborg "or %0, %2, %1\n\t" 68d670bd4fSSam Ravnborg "wr %1, 0, %%psr\n\t" 69d670bd4fSSam Ravnborg "nop; nop; nop\n" 70d670bd4fSSam Ravnborg : "=&r" (retval), "=r" (tmp) 71d670bd4fSSam Ravnborg : "i" (PSR_PIL) 72d670bd4fSSam Ravnborg : "memory"); 73d670bd4fSSam Ravnborg 74d670bd4fSSam Ravnborg return retval; 75d670bd4fSSam Ravnborg } 76d670bd4fSSam Ravnborg 77d670bd4fSSam Ravnborg void raw_local_irq_enable(void) 78d670bd4fSSam Ravnborg { 79d670bd4fSSam Ravnborg unsigned long tmp; 80d670bd4fSSam Ravnborg 81d670bd4fSSam Ravnborg __asm__ __volatile__( 82d670bd4fSSam Ravnborg "rd %%psr, %0\n\t" 83d670bd4fSSam Ravnborg SMP_NOP3 /* Sun4m + Cypress + SMP bug */ 84d670bd4fSSam Ravnborg "andn %0, %1, %0\n\t" 85d670bd4fSSam Ravnborg "wr %0, 0, %%psr\n\t" 86d670bd4fSSam Ravnborg "nop; nop; nop\n" 87d670bd4fSSam Ravnborg : "=&r" (tmp) 88d670bd4fSSam Ravnborg : "i" (PSR_PIL) 89d670bd4fSSam Ravnborg : "memory"); 90d670bd4fSSam Ravnborg } 91d670bd4fSSam Ravnborg 92d670bd4fSSam Ravnborg void raw_local_irq_restore(unsigned long old_psr) 93d670bd4fSSam Ravnborg { 94d670bd4fSSam Ravnborg unsigned long tmp; 95d670bd4fSSam Ravnborg 96d670bd4fSSam Ravnborg __asm__ __volatile__( 97d670bd4fSSam Ravnborg "rd %%psr, %0\n\t" 98d670bd4fSSam Ravnborg "and %2, %1, %2\n\t" 99d670bd4fSSam Ravnborg SMP_NOP2 /* Sun4m + Cypress + SMP bug */ 100d670bd4fSSam Ravnborg "andn %0, %1, %0\n\t" 101d670bd4fSSam Ravnborg "wr %0, %2, %%psr\n\t" 102d670bd4fSSam Ravnborg "nop; nop; nop\n" 103d670bd4fSSam Ravnborg : "=&r" (tmp) 104d670bd4fSSam Ravnborg : "i" (PSR_PIL), "r" (old_psr) 105d670bd4fSSam Ravnborg : "memory"); 106d670bd4fSSam Ravnborg } 107d670bd4fSSam Ravnborg 108d670bd4fSSam Ravnborg EXPORT_SYMBOL(__raw_local_irq_save); 109d670bd4fSSam Ravnborg EXPORT_SYMBOL(raw_local_irq_enable); 110d670bd4fSSam Ravnborg EXPORT_SYMBOL(raw_local_irq_restore); 111d670bd4fSSam Ravnborg 112d670bd4fSSam Ravnborg /* 113d670bd4fSSam Ravnborg * Dave Redman (djhr@tadpole.co.uk) 114d670bd4fSSam Ravnborg * 115d670bd4fSSam Ravnborg * IRQ numbers.. These are no longer restricted to 15.. 116d670bd4fSSam Ravnborg * 117d670bd4fSSam Ravnborg * this is done to enable SBUS cards and onboard IO to be masked 118d670bd4fSSam Ravnborg * correctly. using the interrupt level isn't good enough. 119d670bd4fSSam Ravnborg * 120d670bd4fSSam Ravnborg * For example: 121d670bd4fSSam Ravnborg * A device interrupting at sbus level6 and the Floppy both come in 122d670bd4fSSam Ravnborg * at IRQ11, but enabling and disabling them requires writing to 123d670bd4fSSam Ravnborg * different bits in the SLAVIO/SEC. 124d670bd4fSSam Ravnborg * 125d670bd4fSSam Ravnborg * As a result of these changes sun4m machines could now support 126d670bd4fSSam Ravnborg * directed CPU interrupts using the existing enable/disable irq code 127d670bd4fSSam Ravnborg * with tweaks. 128d670bd4fSSam Ravnborg * 129d670bd4fSSam Ravnborg */ 130d670bd4fSSam Ravnborg 131d670bd4fSSam Ravnborg static void irq_panic(void) 132d670bd4fSSam Ravnborg { 133d670bd4fSSam Ravnborg extern char *cputypval; 134d670bd4fSSam Ravnborg prom_printf("machine: %s doesn't have irq handlers defined!\n",cputypval); 135d670bd4fSSam Ravnborg prom_halt(); 136d670bd4fSSam Ravnborg } 137d670bd4fSSam Ravnborg 138d670bd4fSSam Ravnborg void (*sparc_init_timers)(irq_handler_t ) = 139d670bd4fSSam Ravnborg (void (*)(irq_handler_t )) irq_panic; 140d670bd4fSSam Ravnborg 141d670bd4fSSam Ravnborg /* 142d670bd4fSSam Ravnborg * Dave Redman (djhr@tadpole.co.uk) 143d670bd4fSSam Ravnborg * 144d670bd4fSSam Ravnborg * There used to be extern calls and hard coded values here.. very sucky! 145d670bd4fSSam Ravnborg * instead, because some of the devices attach very early, I do something 146d670bd4fSSam Ravnborg * equally sucky but at least we'll never try to free statically allocated 147d670bd4fSSam Ravnborg * space or call kmalloc before kmalloc_init :(. 148d670bd4fSSam Ravnborg * 149d670bd4fSSam Ravnborg * In fact it's the timer10 that attaches first.. then timer14 150d670bd4fSSam Ravnborg * then kmalloc_init is called.. then the tty interrupts attach. 151d670bd4fSSam Ravnborg * hmmm.... 152d670bd4fSSam Ravnborg * 153d670bd4fSSam Ravnborg */ 154d670bd4fSSam Ravnborg #define MAX_STATIC_ALLOC 4 155d670bd4fSSam Ravnborg struct irqaction static_irqaction[MAX_STATIC_ALLOC]; 156d670bd4fSSam Ravnborg int static_irq_count; 157d670bd4fSSam Ravnborg 158d670bd4fSSam Ravnborg static struct { 159d670bd4fSSam Ravnborg struct irqaction *action; 160d670bd4fSSam Ravnborg int flags; 161d670bd4fSSam Ravnborg } sparc_irq[NR_IRQS]; 162d670bd4fSSam Ravnborg #define SPARC_IRQ_INPROGRESS 1 163d670bd4fSSam Ravnborg 164d670bd4fSSam Ravnborg /* Used to protect the IRQ action lists */ 165d670bd4fSSam Ravnborg DEFINE_SPINLOCK(irq_action_lock); 166d670bd4fSSam Ravnborg 167d670bd4fSSam Ravnborg int show_interrupts(struct seq_file *p, void *v) 168d670bd4fSSam Ravnborg { 169d670bd4fSSam Ravnborg int i = *(loff_t *) v; 170d670bd4fSSam Ravnborg struct irqaction * action; 171d670bd4fSSam Ravnborg unsigned long flags; 172d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 173d670bd4fSSam Ravnborg int j; 174d670bd4fSSam Ravnborg #endif 175d670bd4fSSam Ravnborg 176d670bd4fSSam Ravnborg if (sparc_cpu_model == sun4d) { 177d670bd4fSSam Ravnborg extern int show_sun4d_interrupts(struct seq_file *, void *); 178d670bd4fSSam Ravnborg 179d670bd4fSSam Ravnborg return show_sun4d_interrupts(p, v); 180d670bd4fSSam Ravnborg } 181d670bd4fSSam Ravnborg spin_lock_irqsave(&irq_action_lock, flags); 182d670bd4fSSam Ravnborg if (i < NR_IRQS) { 183d670bd4fSSam Ravnborg action = sparc_irq[i].action; 184d670bd4fSSam Ravnborg if (!action) 185d670bd4fSSam Ravnborg goto out_unlock; 186d670bd4fSSam Ravnborg seq_printf(p, "%3d: ", i); 187d670bd4fSSam Ravnborg #ifndef CONFIG_SMP 188d670bd4fSSam Ravnborg seq_printf(p, "%10u ", kstat_irqs(i)); 189d670bd4fSSam Ravnborg #else 190d670bd4fSSam Ravnborg for_each_online_cpu(j) { 191d670bd4fSSam Ravnborg seq_printf(p, "%10u ", 192d670bd4fSSam Ravnborg kstat_cpu(j).irqs[i]); 193d670bd4fSSam Ravnborg } 194d670bd4fSSam Ravnborg #endif 195d670bd4fSSam Ravnborg seq_printf(p, " %c %s", 196d670bd4fSSam Ravnborg (action->flags & IRQF_DISABLED) ? '+' : ' ', 197d670bd4fSSam Ravnborg action->name); 198d670bd4fSSam Ravnborg for (action=action->next; action; action = action->next) { 199d670bd4fSSam Ravnborg seq_printf(p, ",%s %s", 200d670bd4fSSam Ravnborg (action->flags & IRQF_DISABLED) ? " +" : "", 201d670bd4fSSam Ravnborg action->name); 202d670bd4fSSam Ravnborg } 203d670bd4fSSam Ravnborg seq_putc(p, '\n'); 204d670bd4fSSam Ravnborg } 205d670bd4fSSam Ravnborg out_unlock: 206d670bd4fSSam Ravnborg spin_unlock_irqrestore(&irq_action_lock, flags); 207d670bd4fSSam Ravnborg return 0; 208d670bd4fSSam Ravnborg } 209d670bd4fSSam Ravnborg 210d670bd4fSSam Ravnborg void free_irq(unsigned int irq, void *dev_id) 211d670bd4fSSam Ravnborg { 212d670bd4fSSam Ravnborg struct irqaction * action; 213d670bd4fSSam Ravnborg struct irqaction **actionp; 214d670bd4fSSam Ravnborg unsigned long flags; 215d670bd4fSSam Ravnborg unsigned int cpu_irq; 216d670bd4fSSam Ravnborg 217d670bd4fSSam Ravnborg if (sparc_cpu_model == sun4d) { 218d670bd4fSSam Ravnborg extern void sun4d_free_irq(unsigned int, void *); 219d670bd4fSSam Ravnborg 220d670bd4fSSam Ravnborg sun4d_free_irq(irq, dev_id); 221d670bd4fSSam Ravnborg return; 222d670bd4fSSam Ravnborg } 223d670bd4fSSam Ravnborg cpu_irq = irq & (NR_IRQS - 1); 224d670bd4fSSam Ravnborg if (cpu_irq > 14) { /* 14 irq levels on the sparc */ 225d670bd4fSSam Ravnborg printk("Trying to free bogus IRQ %d\n", irq); 226d670bd4fSSam Ravnborg return; 227d670bd4fSSam Ravnborg } 228d670bd4fSSam Ravnborg 229d670bd4fSSam Ravnborg spin_lock_irqsave(&irq_action_lock, flags); 230d670bd4fSSam Ravnborg 231d670bd4fSSam Ravnborg actionp = &sparc_irq[cpu_irq].action; 232d670bd4fSSam Ravnborg action = *actionp; 233d670bd4fSSam Ravnborg 234d670bd4fSSam Ravnborg if (!action->handler) { 235d670bd4fSSam Ravnborg printk("Trying to free free IRQ%d\n",irq); 236d670bd4fSSam Ravnborg goto out_unlock; 237d670bd4fSSam Ravnborg } 238d670bd4fSSam Ravnborg if (dev_id) { 239d670bd4fSSam Ravnborg for (; action; action = action->next) { 240d670bd4fSSam Ravnborg if (action->dev_id == dev_id) 241d670bd4fSSam Ravnborg break; 242d670bd4fSSam Ravnborg actionp = &action->next; 243d670bd4fSSam Ravnborg } 244d670bd4fSSam Ravnborg if (!action) { 245d670bd4fSSam Ravnborg printk("Trying to free free shared IRQ%d\n",irq); 246d670bd4fSSam Ravnborg goto out_unlock; 247d670bd4fSSam Ravnborg } 248d670bd4fSSam Ravnborg } else if (action->flags & IRQF_SHARED) { 249d670bd4fSSam Ravnborg printk("Trying to free shared IRQ%d with NULL device ID\n", irq); 250d670bd4fSSam Ravnborg goto out_unlock; 251d670bd4fSSam Ravnborg } 252d670bd4fSSam Ravnborg if (action->flags & SA_STATIC_ALLOC) 253d670bd4fSSam Ravnborg { 254d670bd4fSSam Ravnborg /* This interrupt is marked as specially allocated 255d670bd4fSSam Ravnborg * so it is a bad idea to free it. 256d670bd4fSSam Ravnborg */ 257d670bd4fSSam Ravnborg printk("Attempt to free statically allocated IRQ%d (%s)\n", 258d670bd4fSSam Ravnborg irq, action->name); 259d670bd4fSSam Ravnborg goto out_unlock; 260d670bd4fSSam Ravnborg } 261d670bd4fSSam Ravnborg 262d670bd4fSSam Ravnborg *actionp = action->next; 263d670bd4fSSam Ravnborg 264d670bd4fSSam Ravnborg spin_unlock_irqrestore(&irq_action_lock, flags); 265d670bd4fSSam Ravnborg 266d670bd4fSSam Ravnborg synchronize_irq(irq); 267d670bd4fSSam Ravnborg 268d670bd4fSSam Ravnborg spin_lock_irqsave(&irq_action_lock, flags); 269d670bd4fSSam Ravnborg 270d670bd4fSSam Ravnborg kfree(action); 271d670bd4fSSam Ravnborg 272d670bd4fSSam Ravnborg if (!sparc_irq[cpu_irq].action) 273d670bd4fSSam Ravnborg __disable_irq(irq); 274d670bd4fSSam Ravnborg 275d670bd4fSSam Ravnborg out_unlock: 276d670bd4fSSam Ravnborg spin_unlock_irqrestore(&irq_action_lock, flags); 277d670bd4fSSam Ravnborg } 278d670bd4fSSam Ravnborg 279d670bd4fSSam Ravnborg EXPORT_SYMBOL(free_irq); 280d670bd4fSSam Ravnborg 281d670bd4fSSam Ravnborg /* 282d670bd4fSSam Ravnborg * This is called when we want to synchronize with 283d670bd4fSSam Ravnborg * interrupts. We may for example tell a device to 284d670bd4fSSam Ravnborg * stop sending interrupts: but to make sure there 285d670bd4fSSam Ravnborg * are no interrupts that are executing on another 286d670bd4fSSam Ravnborg * CPU we need to call this function. 287d670bd4fSSam Ravnborg */ 288d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 289d670bd4fSSam Ravnborg void synchronize_irq(unsigned int irq) 290d670bd4fSSam Ravnborg { 291d670bd4fSSam Ravnborg unsigned int cpu_irq; 292d670bd4fSSam Ravnborg 293d670bd4fSSam Ravnborg cpu_irq = irq & (NR_IRQS - 1); 294d670bd4fSSam Ravnborg while (sparc_irq[cpu_irq].flags & SPARC_IRQ_INPROGRESS) 295d670bd4fSSam Ravnborg cpu_relax(); 296d670bd4fSSam Ravnborg } 297d670bd4fSSam Ravnborg #endif /* SMP */ 298d670bd4fSSam Ravnborg 299d670bd4fSSam Ravnborg void unexpected_irq(int irq, void *dev_id, struct pt_regs * regs) 300d670bd4fSSam Ravnborg { 301d670bd4fSSam Ravnborg int i; 302d670bd4fSSam Ravnborg struct irqaction * action; 303d670bd4fSSam Ravnborg unsigned int cpu_irq; 304d670bd4fSSam Ravnborg 305d670bd4fSSam Ravnborg cpu_irq = irq & (NR_IRQS - 1); 306d670bd4fSSam Ravnborg action = sparc_irq[cpu_irq].action; 307d670bd4fSSam Ravnborg 308d670bd4fSSam Ravnborg printk("IO device interrupt, irq = %d\n", irq); 309d670bd4fSSam Ravnborg printk("PC = %08lx NPC = %08lx FP=%08lx\n", regs->pc, 310d670bd4fSSam Ravnborg regs->npc, regs->u_regs[14]); 311d670bd4fSSam Ravnborg if (action) { 312d670bd4fSSam Ravnborg printk("Expecting: "); 313d670bd4fSSam Ravnborg for (i = 0; i < 16; i++) 314d670bd4fSSam Ravnborg if (action->handler) 315d670bd4fSSam Ravnborg printk("[%s:%d:0x%x] ", action->name, 316d670bd4fSSam Ravnborg (int) i, (unsigned int) action->handler); 317d670bd4fSSam Ravnborg } 318d670bd4fSSam Ravnborg printk("AIEEE\n"); 319d670bd4fSSam Ravnborg panic("bogus interrupt received"); 320d670bd4fSSam Ravnborg } 321d670bd4fSSam Ravnborg 322d670bd4fSSam Ravnborg void handler_irq(int irq, struct pt_regs * regs) 323d670bd4fSSam Ravnborg { 324d670bd4fSSam Ravnborg struct pt_regs *old_regs; 325d670bd4fSSam Ravnborg struct irqaction * action; 326d670bd4fSSam Ravnborg int cpu = smp_processor_id(); 327d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 328d670bd4fSSam Ravnborg extern void smp4m_irq_rotate(int cpu); 329d670bd4fSSam Ravnborg #endif 330d670bd4fSSam Ravnborg 331d670bd4fSSam Ravnborg old_regs = set_irq_regs(regs); 332d670bd4fSSam Ravnborg irq_enter(); 333d670bd4fSSam Ravnborg disable_pil_irq(irq); 334d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 335d670bd4fSSam Ravnborg /* Only rotate on lower priority IRQs (scsi, ethernet, etc.). */ 336d670bd4fSSam Ravnborg if((sparc_cpu_model==sun4m) && (irq < 10)) 337d670bd4fSSam Ravnborg smp4m_irq_rotate(cpu); 338d670bd4fSSam Ravnborg #endif 339d670bd4fSSam Ravnborg action = sparc_irq[irq].action; 340d670bd4fSSam Ravnborg sparc_irq[irq].flags |= SPARC_IRQ_INPROGRESS; 341d670bd4fSSam Ravnborg kstat_cpu(cpu).irqs[irq]++; 342d670bd4fSSam Ravnborg do { 343d670bd4fSSam Ravnborg if (!action || !action->handler) 344d670bd4fSSam Ravnborg unexpected_irq(irq, NULL, regs); 345d670bd4fSSam Ravnborg action->handler(irq, action->dev_id); 346d670bd4fSSam Ravnborg action = action->next; 347d670bd4fSSam Ravnborg } while (action); 348d670bd4fSSam Ravnborg sparc_irq[irq].flags &= ~SPARC_IRQ_INPROGRESS; 349d670bd4fSSam Ravnborg enable_pil_irq(irq); 350d670bd4fSSam Ravnborg irq_exit(); 351d670bd4fSSam Ravnborg set_irq_regs(old_regs); 352d670bd4fSSam Ravnborg } 353d670bd4fSSam Ravnborg 354d670bd4fSSam Ravnborg #if defined(CONFIG_BLK_DEV_FD) || defined(CONFIG_BLK_DEV_FD_MODULE) 355d670bd4fSSam Ravnborg 356d670bd4fSSam Ravnborg /* Fast IRQs on the Sparc can only have one routine attached to them, 357d670bd4fSSam Ravnborg * thus no sharing possible. 358d670bd4fSSam Ravnborg */ 359d670bd4fSSam Ravnborg static int request_fast_irq(unsigned int irq, 360d670bd4fSSam Ravnborg void (*handler)(void), 361d670bd4fSSam Ravnborg unsigned long irqflags, const char *devname) 362d670bd4fSSam Ravnborg { 363d670bd4fSSam Ravnborg struct irqaction *action; 364d670bd4fSSam Ravnborg unsigned long flags; 365d670bd4fSSam Ravnborg unsigned int cpu_irq; 366d670bd4fSSam Ravnborg int ret; 367d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 368d670bd4fSSam Ravnborg struct tt_entry *trap_table; 369d670bd4fSSam Ravnborg extern struct tt_entry trapbase_cpu1, trapbase_cpu2, trapbase_cpu3; 370d670bd4fSSam Ravnborg #endif 371d670bd4fSSam Ravnborg 372d670bd4fSSam Ravnborg cpu_irq = irq & (NR_IRQS - 1); 373d670bd4fSSam Ravnborg if(cpu_irq > 14) { 374d670bd4fSSam Ravnborg ret = -EINVAL; 375d670bd4fSSam Ravnborg goto out; 376d670bd4fSSam Ravnborg } 377d670bd4fSSam Ravnborg if(!handler) { 378d670bd4fSSam Ravnborg ret = -EINVAL; 379d670bd4fSSam Ravnborg goto out; 380d670bd4fSSam Ravnborg } 381d670bd4fSSam Ravnborg 382d670bd4fSSam Ravnborg spin_lock_irqsave(&irq_action_lock, flags); 383d670bd4fSSam Ravnborg 384d670bd4fSSam Ravnborg action = sparc_irq[cpu_irq].action; 385d670bd4fSSam Ravnborg if(action) { 386d670bd4fSSam Ravnborg if(action->flags & IRQF_SHARED) 387d670bd4fSSam Ravnborg panic("Trying to register fast irq when already shared.\n"); 388d670bd4fSSam Ravnborg if(irqflags & IRQF_SHARED) 389d670bd4fSSam Ravnborg panic("Trying to register fast irq as shared.\n"); 390d670bd4fSSam Ravnborg 391d670bd4fSSam Ravnborg /* Anyway, someone already owns it so cannot be made fast. */ 392d670bd4fSSam Ravnborg printk("request_fast_irq: Trying to register yet already owned.\n"); 393d670bd4fSSam Ravnborg ret = -EBUSY; 394d670bd4fSSam Ravnborg goto out_unlock; 395d670bd4fSSam Ravnborg } 396d670bd4fSSam Ravnborg 397d670bd4fSSam Ravnborg /* If this is flagged as statically allocated then we use our 398d670bd4fSSam Ravnborg * private struct which is never freed. 399d670bd4fSSam Ravnborg */ 400d670bd4fSSam Ravnborg if (irqflags & SA_STATIC_ALLOC) { 401d670bd4fSSam Ravnborg if (static_irq_count < MAX_STATIC_ALLOC) 402d670bd4fSSam Ravnborg action = &static_irqaction[static_irq_count++]; 403d670bd4fSSam Ravnborg else 404d670bd4fSSam Ravnborg printk("Fast IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", 405d670bd4fSSam Ravnborg irq, devname); 406d670bd4fSSam Ravnborg } 407d670bd4fSSam Ravnborg 408d670bd4fSSam Ravnborg if (action == NULL) 409d670bd4fSSam Ravnborg action = kmalloc(sizeof(struct irqaction), 410d670bd4fSSam Ravnborg GFP_ATOMIC); 411d670bd4fSSam Ravnborg 412d670bd4fSSam Ravnborg if (!action) { 413d670bd4fSSam Ravnborg ret = -ENOMEM; 414d670bd4fSSam Ravnborg goto out_unlock; 415d670bd4fSSam Ravnborg } 416d670bd4fSSam Ravnborg 417d670bd4fSSam Ravnborg /* Dork with trap table if we get this far. */ 418d670bd4fSSam Ravnborg #define INSTANTIATE(table) \ 419d670bd4fSSam Ravnborg table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_one = SPARC_RD_PSR_L0; \ 420d670bd4fSSam Ravnborg table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two = \ 421d670bd4fSSam Ravnborg SPARC_BRANCH((unsigned long) handler, \ 422d670bd4fSSam Ravnborg (unsigned long) &table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two);\ 423d670bd4fSSam Ravnborg table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_three = SPARC_RD_WIM_L3; \ 424d670bd4fSSam Ravnborg table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_four = SPARC_NOP; 425d670bd4fSSam Ravnborg 426d670bd4fSSam Ravnborg INSTANTIATE(sparc_ttable) 427d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 428d670bd4fSSam Ravnborg trap_table = &trapbase_cpu1; INSTANTIATE(trap_table) 429d670bd4fSSam Ravnborg trap_table = &trapbase_cpu2; INSTANTIATE(trap_table) 430d670bd4fSSam Ravnborg trap_table = &trapbase_cpu3; INSTANTIATE(trap_table) 431d670bd4fSSam Ravnborg #endif 432d670bd4fSSam Ravnborg #undef INSTANTIATE 433d670bd4fSSam Ravnborg /* 434d670bd4fSSam Ravnborg * XXX Correct thing whould be to flush only I- and D-cache lines 435d670bd4fSSam Ravnborg * which contain the handler in question. But as of time of the 436d670bd4fSSam Ravnborg * writing we have no CPU-neutral interface to fine-grained flushes. 437d670bd4fSSam Ravnborg */ 438d670bd4fSSam Ravnborg flush_cache_all(); 439d670bd4fSSam Ravnborg 440d670bd4fSSam Ravnborg action->flags = irqflags; 441d670bd4fSSam Ravnborg cpus_clear(action->mask); 442d670bd4fSSam Ravnborg action->name = devname; 443d670bd4fSSam Ravnborg action->dev_id = NULL; 444d670bd4fSSam Ravnborg action->next = NULL; 445d670bd4fSSam Ravnborg 446d670bd4fSSam Ravnborg sparc_irq[cpu_irq].action = action; 447d670bd4fSSam Ravnborg 448d670bd4fSSam Ravnborg __enable_irq(irq); 449d670bd4fSSam Ravnborg 450d670bd4fSSam Ravnborg ret = 0; 451d670bd4fSSam Ravnborg out_unlock: 452d670bd4fSSam Ravnborg spin_unlock_irqrestore(&irq_action_lock, flags); 453d670bd4fSSam Ravnborg out: 454d670bd4fSSam Ravnborg return ret; 455d670bd4fSSam Ravnborg } 456d670bd4fSSam Ravnborg 457d670bd4fSSam Ravnborg /* These variables are used to access state from the assembler 458d670bd4fSSam Ravnborg * interrupt handler, floppy_hardint, so we cannot put these in 459d670bd4fSSam Ravnborg * the floppy driver image because that would not work in the 460d670bd4fSSam Ravnborg * modular case. 461d670bd4fSSam Ravnborg */ 462d670bd4fSSam Ravnborg volatile unsigned char *fdc_status; 463d670bd4fSSam Ravnborg EXPORT_SYMBOL(fdc_status); 464d670bd4fSSam Ravnborg 465d670bd4fSSam Ravnborg char *pdma_vaddr; 466d670bd4fSSam Ravnborg EXPORT_SYMBOL(pdma_vaddr); 467d670bd4fSSam Ravnborg 468d670bd4fSSam Ravnborg unsigned long pdma_size; 469d670bd4fSSam Ravnborg EXPORT_SYMBOL(pdma_size); 470d670bd4fSSam Ravnborg 471d670bd4fSSam Ravnborg volatile int doing_pdma; 472d670bd4fSSam Ravnborg EXPORT_SYMBOL(doing_pdma); 473d670bd4fSSam Ravnborg 474d670bd4fSSam Ravnborg char *pdma_base; 475d670bd4fSSam Ravnborg EXPORT_SYMBOL(pdma_base); 476d670bd4fSSam Ravnborg 477d670bd4fSSam Ravnborg unsigned long pdma_areasize; 478d670bd4fSSam Ravnborg EXPORT_SYMBOL(pdma_areasize); 479d670bd4fSSam Ravnborg 480d670bd4fSSam Ravnborg extern void floppy_hardint(void); 481d670bd4fSSam Ravnborg 482d670bd4fSSam Ravnborg static irq_handler_t floppy_irq_handler; 483d670bd4fSSam Ravnborg 484d670bd4fSSam Ravnborg void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs) 485d670bd4fSSam Ravnborg { 486d670bd4fSSam Ravnborg struct pt_regs *old_regs; 487d670bd4fSSam Ravnborg int cpu = smp_processor_id(); 488d670bd4fSSam Ravnborg 489d670bd4fSSam Ravnborg old_regs = set_irq_regs(regs); 490d670bd4fSSam Ravnborg disable_pil_irq(irq); 491d670bd4fSSam Ravnborg irq_enter(); 492d670bd4fSSam Ravnborg kstat_cpu(cpu).irqs[irq]++; 493d670bd4fSSam Ravnborg floppy_irq_handler(irq, dev_id); 494d670bd4fSSam Ravnborg irq_exit(); 495d670bd4fSSam Ravnborg enable_pil_irq(irq); 496d670bd4fSSam Ravnborg set_irq_regs(old_regs); 497d670bd4fSSam Ravnborg // XXX Eek, it's totally changed with preempt_count() and such 498d670bd4fSSam Ravnborg // if (softirq_pending(cpu)) 499d670bd4fSSam Ravnborg // do_softirq(); 500d670bd4fSSam Ravnborg } 501d670bd4fSSam Ravnborg 502d670bd4fSSam Ravnborg int sparc_floppy_request_irq(int irq, unsigned long flags, 503d670bd4fSSam Ravnborg irq_handler_t irq_handler) 504d670bd4fSSam Ravnborg { 505d670bd4fSSam Ravnborg floppy_irq_handler = irq_handler; 506d670bd4fSSam Ravnborg return request_fast_irq(irq, floppy_hardint, flags, "floppy"); 507d670bd4fSSam Ravnborg } 508d670bd4fSSam Ravnborg EXPORT_SYMBOL(sparc_floppy_request_irq); 509d670bd4fSSam Ravnborg 510d670bd4fSSam Ravnborg #endif 511d670bd4fSSam Ravnborg 512d670bd4fSSam Ravnborg int request_irq(unsigned int irq, 513d670bd4fSSam Ravnborg irq_handler_t handler, 514d670bd4fSSam Ravnborg unsigned long irqflags, const char * devname, void *dev_id) 515d670bd4fSSam Ravnborg { 516d670bd4fSSam Ravnborg struct irqaction * action, **actionp; 517d670bd4fSSam Ravnborg unsigned long flags; 518d670bd4fSSam Ravnborg unsigned int cpu_irq; 519d670bd4fSSam Ravnborg int ret; 520d670bd4fSSam Ravnborg 521d670bd4fSSam Ravnborg if (sparc_cpu_model == sun4d) { 522d670bd4fSSam Ravnborg extern int sun4d_request_irq(unsigned int, 523d670bd4fSSam Ravnborg irq_handler_t , 524d670bd4fSSam Ravnborg unsigned long, const char *, void *); 525d670bd4fSSam Ravnborg return sun4d_request_irq(irq, handler, irqflags, devname, dev_id); 526d670bd4fSSam Ravnborg } 527d670bd4fSSam Ravnborg cpu_irq = irq & (NR_IRQS - 1); 528d670bd4fSSam Ravnborg if(cpu_irq > 14) { 529d670bd4fSSam Ravnborg ret = -EINVAL; 530d670bd4fSSam Ravnborg goto out; 531d670bd4fSSam Ravnborg } 532d670bd4fSSam Ravnborg if (!handler) { 533d670bd4fSSam Ravnborg ret = -EINVAL; 534d670bd4fSSam Ravnborg goto out; 535d670bd4fSSam Ravnborg } 536d670bd4fSSam Ravnborg 537d670bd4fSSam Ravnborg spin_lock_irqsave(&irq_action_lock, flags); 538d670bd4fSSam Ravnborg 539d670bd4fSSam Ravnborg actionp = &sparc_irq[cpu_irq].action; 540d670bd4fSSam Ravnborg action = *actionp; 541d670bd4fSSam Ravnborg if (action) { 542d670bd4fSSam Ravnborg if (!(action->flags & IRQF_SHARED) || !(irqflags & IRQF_SHARED)) { 543d670bd4fSSam Ravnborg ret = -EBUSY; 544d670bd4fSSam Ravnborg goto out_unlock; 545d670bd4fSSam Ravnborg } 546d670bd4fSSam Ravnborg if ((action->flags & IRQF_DISABLED) != (irqflags & IRQF_DISABLED)) { 547d670bd4fSSam Ravnborg printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq); 548d670bd4fSSam Ravnborg ret = -EBUSY; 549d670bd4fSSam Ravnborg goto out_unlock; 550d670bd4fSSam Ravnborg } 551d670bd4fSSam Ravnborg for ( ; action; action = *actionp) 552d670bd4fSSam Ravnborg actionp = &action->next; 553d670bd4fSSam Ravnborg } 554d670bd4fSSam Ravnborg 555d670bd4fSSam Ravnborg /* If this is flagged as statically allocated then we use our 556d670bd4fSSam Ravnborg * private struct which is never freed. 557d670bd4fSSam Ravnborg */ 558d670bd4fSSam Ravnborg if (irqflags & SA_STATIC_ALLOC) { 559d670bd4fSSam Ravnborg if (static_irq_count < MAX_STATIC_ALLOC) 560d670bd4fSSam Ravnborg action = &static_irqaction[static_irq_count++]; 561d670bd4fSSam Ravnborg else 562d670bd4fSSam Ravnborg printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname); 563d670bd4fSSam Ravnborg } 564d670bd4fSSam Ravnborg 565d670bd4fSSam Ravnborg if (action == NULL) 566d670bd4fSSam Ravnborg action = kmalloc(sizeof(struct irqaction), 567d670bd4fSSam Ravnborg GFP_ATOMIC); 568d670bd4fSSam Ravnborg 569d670bd4fSSam Ravnborg if (!action) { 570d670bd4fSSam Ravnborg ret = -ENOMEM; 571d670bd4fSSam Ravnborg goto out_unlock; 572d670bd4fSSam Ravnborg } 573d670bd4fSSam Ravnborg 574d670bd4fSSam Ravnborg action->handler = handler; 575d670bd4fSSam Ravnborg action->flags = irqflags; 576d670bd4fSSam Ravnborg cpus_clear(action->mask); 577d670bd4fSSam Ravnborg action->name = devname; 578d670bd4fSSam Ravnborg action->next = NULL; 579d670bd4fSSam Ravnborg action->dev_id = dev_id; 580d670bd4fSSam Ravnborg 581d670bd4fSSam Ravnborg *actionp = action; 582d670bd4fSSam Ravnborg 583d670bd4fSSam Ravnborg __enable_irq(irq); 584d670bd4fSSam Ravnborg 585d670bd4fSSam Ravnborg ret = 0; 586d670bd4fSSam Ravnborg out_unlock: 587d670bd4fSSam Ravnborg spin_unlock_irqrestore(&irq_action_lock, flags); 588d670bd4fSSam Ravnborg out: 589d670bd4fSSam Ravnborg return ret; 590d670bd4fSSam Ravnborg } 591d670bd4fSSam Ravnborg 592d670bd4fSSam Ravnborg EXPORT_SYMBOL(request_irq); 593d670bd4fSSam Ravnborg 594d670bd4fSSam Ravnborg void disable_irq_nosync(unsigned int irq) 595d670bd4fSSam Ravnborg { 59681265fd9SSam Ravnborg __disable_irq(irq); 597d670bd4fSSam Ravnborg } 598d670bd4fSSam Ravnborg EXPORT_SYMBOL(disable_irq_nosync); 599d670bd4fSSam Ravnborg 600d670bd4fSSam Ravnborg void disable_irq(unsigned int irq) 601d670bd4fSSam Ravnborg { 60281265fd9SSam Ravnborg __disable_irq(irq); 603d670bd4fSSam Ravnborg } 604d670bd4fSSam Ravnborg EXPORT_SYMBOL(disable_irq); 605d670bd4fSSam Ravnborg 606d670bd4fSSam Ravnborg void enable_irq(unsigned int irq) 607d670bd4fSSam Ravnborg { 60881265fd9SSam Ravnborg __enable_irq(irq); 609d670bd4fSSam Ravnborg } 610d670bd4fSSam Ravnborg 611d670bd4fSSam Ravnborg EXPORT_SYMBOL(enable_irq); 612d670bd4fSSam Ravnborg 613d670bd4fSSam Ravnborg /* We really don't need these at all on the Sparc. We only have 614d670bd4fSSam Ravnborg * stubs here because they are exported to modules. 615d670bd4fSSam Ravnborg */ 616d670bd4fSSam Ravnborg unsigned long probe_irq_on(void) 617d670bd4fSSam Ravnborg { 618d670bd4fSSam Ravnborg return 0; 619d670bd4fSSam Ravnborg } 620d670bd4fSSam Ravnborg 621d670bd4fSSam Ravnborg EXPORT_SYMBOL(probe_irq_on); 622d670bd4fSSam Ravnborg 623d670bd4fSSam Ravnborg int probe_irq_off(unsigned long mask) 624d670bd4fSSam Ravnborg { 625d670bd4fSSam Ravnborg return 0; 626d670bd4fSSam Ravnborg } 627d670bd4fSSam Ravnborg 628d670bd4fSSam Ravnborg EXPORT_SYMBOL(probe_irq_off); 629d670bd4fSSam Ravnborg 630d670bd4fSSam Ravnborg /* djhr 631d670bd4fSSam Ravnborg * This could probably be made indirect too and assigned in the CPU 632d670bd4fSSam Ravnborg * bits of the code. That would be much nicer I think and would also 633d670bd4fSSam Ravnborg * fit in with the idea of being able to tune your kernel for your machine 634d670bd4fSSam Ravnborg * by removing unrequired machine and device support. 635d670bd4fSSam Ravnborg * 636d670bd4fSSam Ravnborg */ 637d670bd4fSSam Ravnborg 638d670bd4fSSam Ravnborg void __init init_IRQ(void) 639d670bd4fSSam Ravnborg { 640d670bd4fSSam Ravnborg extern void sun4c_init_IRQ( void ); 641d670bd4fSSam Ravnborg extern void sun4m_init_IRQ( void ); 642d670bd4fSSam Ravnborg extern void sun4d_init_IRQ( void ); 643d670bd4fSSam Ravnborg 644d670bd4fSSam Ravnborg switch(sparc_cpu_model) { 645d670bd4fSSam Ravnborg case sun4c: 646d670bd4fSSam Ravnborg case sun4: 647d670bd4fSSam Ravnborg sun4c_init_IRQ(); 648d670bd4fSSam Ravnborg break; 649d670bd4fSSam Ravnborg 650d670bd4fSSam Ravnborg case sun4m: 651d670bd4fSSam Ravnborg #ifdef CONFIG_PCI 652d670bd4fSSam Ravnborg pcic_probe(); 653d670bd4fSSam Ravnborg if (pcic_present()) { 654d670bd4fSSam Ravnborg sun4m_pci_init_IRQ(); 655d670bd4fSSam Ravnborg break; 656d670bd4fSSam Ravnborg } 657d670bd4fSSam Ravnborg #endif 658d670bd4fSSam Ravnborg sun4m_init_IRQ(); 659d670bd4fSSam Ravnborg break; 660d670bd4fSSam Ravnborg 661d670bd4fSSam Ravnborg case sun4d: 662d670bd4fSSam Ravnborg sun4d_init_IRQ(); 663d670bd4fSSam Ravnborg break; 664d670bd4fSSam Ravnborg 665d670bd4fSSam Ravnborg default: 666d670bd4fSSam Ravnborg prom_printf("Cannot initialize IRQs on this Sun machine..."); 667d670bd4fSSam Ravnborg break; 668d670bd4fSSam Ravnborg } 669d670bd4fSSam Ravnborg btfixup(); 670d670bd4fSSam Ravnborg } 671d670bd4fSSam Ravnborg 672d670bd4fSSam Ravnborg void init_irq_proc(void) 673d670bd4fSSam Ravnborg { 674d670bd4fSSam Ravnborg /* For now, nothing... */ 675d670bd4fSSam Ravnborg } 676