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> 480fd7ef1fSKonrad Eisele #include <asm/leon.h> 49d670bd4fSSam Ravnborg 5081265fd9SSam Ravnborg #include "kernel.h" 51d670bd4fSSam Ravnborg #include "irq.h" 52d670bd4fSSam Ravnborg 53d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 54d670bd4fSSam Ravnborg #define SMP_NOP2 "nop; nop;\n\t" 55d670bd4fSSam Ravnborg #define SMP_NOP3 "nop; nop; nop;\n\t" 56d670bd4fSSam Ravnborg #else 57d670bd4fSSam Ravnborg #define SMP_NOP2 58d670bd4fSSam Ravnborg #define SMP_NOP3 59d670bd4fSSam Ravnborg #endif /* SMP */ 60d670bd4fSSam Ravnborg unsigned long __raw_local_irq_save(void) 61d670bd4fSSam Ravnborg { 62d670bd4fSSam Ravnborg unsigned long retval; 63d670bd4fSSam Ravnborg unsigned long tmp; 64d670bd4fSSam Ravnborg 65d670bd4fSSam Ravnborg __asm__ __volatile__( 66d670bd4fSSam Ravnborg "rd %%psr, %0\n\t" 67d670bd4fSSam Ravnborg SMP_NOP3 /* Sun4m + Cypress + SMP bug */ 68d670bd4fSSam Ravnborg "or %0, %2, %1\n\t" 69d670bd4fSSam Ravnborg "wr %1, 0, %%psr\n\t" 70d670bd4fSSam Ravnborg "nop; nop; nop\n" 71d670bd4fSSam Ravnborg : "=&r" (retval), "=r" (tmp) 72d670bd4fSSam Ravnborg : "i" (PSR_PIL) 73d670bd4fSSam Ravnborg : "memory"); 74d670bd4fSSam Ravnborg 75d670bd4fSSam Ravnborg return retval; 76d670bd4fSSam Ravnborg } 77d670bd4fSSam Ravnborg 78d670bd4fSSam Ravnborg void raw_local_irq_enable(void) 79d670bd4fSSam Ravnborg { 80d670bd4fSSam Ravnborg unsigned long tmp; 81d670bd4fSSam Ravnborg 82d670bd4fSSam Ravnborg __asm__ __volatile__( 83d670bd4fSSam Ravnborg "rd %%psr, %0\n\t" 84d670bd4fSSam Ravnborg SMP_NOP3 /* Sun4m + Cypress + SMP bug */ 85d670bd4fSSam Ravnborg "andn %0, %1, %0\n\t" 86d670bd4fSSam Ravnborg "wr %0, 0, %%psr\n\t" 87d670bd4fSSam Ravnborg "nop; nop; nop\n" 88d670bd4fSSam Ravnborg : "=&r" (tmp) 89d670bd4fSSam Ravnborg : "i" (PSR_PIL) 90d670bd4fSSam Ravnborg : "memory"); 91d670bd4fSSam Ravnborg } 92d670bd4fSSam Ravnborg 93d670bd4fSSam Ravnborg void raw_local_irq_restore(unsigned long old_psr) 94d670bd4fSSam Ravnborg { 95d670bd4fSSam Ravnborg unsigned long tmp; 96d670bd4fSSam Ravnborg 97d670bd4fSSam Ravnborg __asm__ __volatile__( 98d670bd4fSSam Ravnborg "rd %%psr, %0\n\t" 99d670bd4fSSam Ravnborg "and %2, %1, %2\n\t" 100d670bd4fSSam Ravnborg SMP_NOP2 /* Sun4m + Cypress + SMP bug */ 101d670bd4fSSam Ravnborg "andn %0, %1, %0\n\t" 102d670bd4fSSam Ravnborg "wr %0, %2, %%psr\n\t" 103d670bd4fSSam Ravnborg "nop; nop; nop\n" 104d670bd4fSSam Ravnborg : "=&r" (tmp) 105d670bd4fSSam Ravnborg : "i" (PSR_PIL), "r" (old_psr) 106d670bd4fSSam Ravnborg : "memory"); 107d670bd4fSSam Ravnborg } 108d670bd4fSSam Ravnborg 109d670bd4fSSam Ravnborg EXPORT_SYMBOL(__raw_local_irq_save); 110d670bd4fSSam Ravnborg EXPORT_SYMBOL(raw_local_irq_enable); 111d670bd4fSSam Ravnborg EXPORT_SYMBOL(raw_local_irq_restore); 112d670bd4fSSam Ravnborg 113d670bd4fSSam Ravnborg /* 114d670bd4fSSam Ravnborg * Dave Redman (djhr@tadpole.co.uk) 115d670bd4fSSam Ravnborg * 116d670bd4fSSam Ravnborg * IRQ numbers.. These are no longer restricted to 15.. 117d670bd4fSSam Ravnborg * 118d670bd4fSSam Ravnborg * this is done to enable SBUS cards and onboard IO to be masked 119d670bd4fSSam Ravnborg * correctly. using the interrupt level isn't good enough. 120d670bd4fSSam Ravnborg * 121d670bd4fSSam Ravnborg * For example: 122d670bd4fSSam Ravnborg * A device interrupting at sbus level6 and the Floppy both come in 123d670bd4fSSam Ravnborg * at IRQ11, but enabling and disabling them requires writing to 124d670bd4fSSam Ravnborg * different bits in the SLAVIO/SEC. 125d670bd4fSSam Ravnborg * 126d670bd4fSSam Ravnborg * As a result of these changes sun4m machines could now support 127d670bd4fSSam Ravnborg * directed CPU interrupts using the existing enable/disable irq code 128d670bd4fSSam Ravnborg * with tweaks. 129d670bd4fSSam Ravnborg * 130d670bd4fSSam Ravnborg */ 131d670bd4fSSam Ravnborg 132d670bd4fSSam Ravnborg static void irq_panic(void) 133d670bd4fSSam Ravnborg { 134d670bd4fSSam Ravnborg extern char *cputypval; 135d670bd4fSSam Ravnborg prom_printf("machine: %s doesn't have irq handlers defined!\n",cputypval); 136d670bd4fSSam Ravnborg prom_halt(); 137d670bd4fSSam Ravnborg } 138d670bd4fSSam Ravnborg 139d670bd4fSSam Ravnborg void (*sparc_init_timers)(irq_handler_t ) = 140d670bd4fSSam Ravnborg (void (*)(irq_handler_t )) irq_panic; 141d670bd4fSSam Ravnborg 142d670bd4fSSam Ravnborg /* 143d670bd4fSSam Ravnborg * Dave Redman (djhr@tadpole.co.uk) 144d670bd4fSSam Ravnborg * 145d670bd4fSSam Ravnborg * There used to be extern calls and hard coded values here.. very sucky! 146d670bd4fSSam Ravnborg * instead, because some of the devices attach very early, I do something 147d670bd4fSSam Ravnborg * equally sucky but at least we'll never try to free statically allocated 148d670bd4fSSam Ravnborg * space or call kmalloc before kmalloc_init :(. 149d670bd4fSSam Ravnborg * 150d670bd4fSSam Ravnborg * In fact it's the timer10 that attaches first.. then timer14 151d670bd4fSSam Ravnborg * then kmalloc_init is called.. then the tty interrupts attach. 152d670bd4fSSam Ravnborg * hmmm.... 153d670bd4fSSam Ravnborg * 154d670bd4fSSam Ravnborg */ 155d670bd4fSSam Ravnborg #define MAX_STATIC_ALLOC 4 156d670bd4fSSam Ravnborg struct irqaction static_irqaction[MAX_STATIC_ALLOC]; 157d670bd4fSSam Ravnborg int static_irq_count; 158d670bd4fSSam Ravnborg 159d670bd4fSSam Ravnborg static struct { 160d670bd4fSSam Ravnborg struct irqaction *action; 161d670bd4fSSam Ravnborg int flags; 162d670bd4fSSam Ravnborg } sparc_irq[NR_IRQS]; 163d670bd4fSSam Ravnborg #define SPARC_IRQ_INPROGRESS 1 164d670bd4fSSam Ravnborg 165d670bd4fSSam Ravnborg /* Used to protect the IRQ action lists */ 166d670bd4fSSam Ravnborg DEFINE_SPINLOCK(irq_action_lock); 167d670bd4fSSam Ravnborg 168d670bd4fSSam Ravnborg int show_interrupts(struct seq_file *p, void *v) 169d670bd4fSSam Ravnborg { 170d670bd4fSSam Ravnborg int i = *(loff_t *) v; 171d670bd4fSSam Ravnborg struct irqaction * action; 172d670bd4fSSam Ravnborg unsigned long flags; 173d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 174d670bd4fSSam Ravnborg int j; 175d670bd4fSSam Ravnborg #endif 176d670bd4fSSam Ravnborg 177d670bd4fSSam Ravnborg if (sparc_cpu_model == sun4d) { 178d670bd4fSSam Ravnborg extern int show_sun4d_interrupts(struct seq_file *, void *); 179d670bd4fSSam Ravnborg 180d670bd4fSSam Ravnborg return show_sun4d_interrupts(p, v); 181d670bd4fSSam Ravnborg } 182d670bd4fSSam Ravnborg spin_lock_irqsave(&irq_action_lock, flags); 183d670bd4fSSam Ravnborg if (i < NR_IRQS) { 184d670bd4fSSam Ravnborg action = sparc_irq[i].action; 185d670bd4fSSam Ravnborg if (!action) 186d670bd4fSSam Ravnborg goto out_unlock; 187d670bd4fSSam Ravnborg seq_printf(p, "%3d: ", i); 188d670bd4fSSam Ravnborg #ifndef CONFIG_SMP 189d670bd4fSSam Ravnborg seq_printf(p, "%10u ", kstat_irqs(i)); 190d670bd4fSSam Ravnborg #else 191d670bd4fSSam Ravnborg for_each_online_cpu(j) { 192d670bd4fSSam Ravnborg seq_printf(p, "%10u ", 193d670bd4fSSam Ravnborg kstat_cpu(j).irqs[i]); 194d670bd4fSSam Ravnborg } 195d670bd4fSSam Ravnborg #endif 196d670bd4fSSam Ravnborg seq_printf(p, " %c %s", 197d670bd4fSSam Ravnborg (action->flags & IRQF_DISABLED) ? '+' : ' ', 198d670bd4fSSam Ravnborg action->name); 199d670bd4fSSam Ravnborg for (action=action->next; action; action = action->next) { 200d670bd4fSSam Ravnborg seq_printf(p, ",%s %s", 201d670bd4fSSam Ravnborg (action->flags & IRQF_DISABLED) ? " +" : "", 202d670bd4fSSam Ravnborg action->name); 203d670bd4fSSam Ravnborg } 204d670bd4fSSam Ravnborg seq_putc(p, '\n'); 205d670bd4fSSam Ravnborg } 206d670bd4fSSam Ravnborg out_unlock: 207d670bd4fSSam Ravnborg spin_unlock_irqrestore(&irq_action_lock, flags); 208d670bd4fSSam Ravnborg return 0; 209d670bd4fSSam Ravnborg } 210d670bd4fSSam Ravnborg 211d670bd4fSSam Ravnborg void free_irq(unsigned int irq, void *dev_id) 212d670bd4fSSam Ravnborg { 213d670bd4fSSam Ravnborg struct irqaction * action; 214d670bd4fSSam Ravnborg struct irqaction **actionp; 215d670bd4fSSam Ravnborg unsigned long flags; 216d670bd4fSSam Ravnborg unsigned int cpu_irq; 217d670bd4fSSam Ravnborg 218d670bd4fSSam Ravnborg if (sparc_cpu_model == sun4d) { 219d670bd4fSSam Ravnborg extern void sun4d_free_irq(unsigned int, void *); 220d670bd4fSSam Ravnborg 221d670bd4fSSam Ravnborg sun4d_free_irq(irq, dev_id); 222d670bd4fSSam Ravnborg return; 223d670bd4fSSam Ravnborg } 224d670bd4fSSam Ravnborg cpu_irq = irq & (NR_IRQS - 1); 225d670bd4fSSam Ravnborg if (cpu_irq > 14) { /* 14 irq levels on the sparc */ 226d670bd4fSSam Ravnborg printk("Trying to free bogus IRQ %d\n", irq); 227d670bd4fSSam Ravnborg return; 228d670bd4fSSam Ravnborg } 229d670bd4fSSam Ravnborg 230d670bd4fSSam Ravnborg spin_lock_irqsave(&irq_action_lock, flags); 231d670bd4fSSam Ravnborg 232d670bd4fSSam Ravnborg actionp = &sparc_irq[cpu_irq].action; 233d670bd4fSSam Ravnborg action = *actionp; 234d670bd4fSSam Ravnborg 235d670bd4fSSam Ravnborg if (!action->handler) { 236d670bd4fSSam Ravnborg printk("Trying to free free IRQ%d\n",irq); 237d670bd4fSSam Ravnborg goto out_unlock; 238d670bd4fSSam Ravnborg } 239d670bd4fSSam Ravnborg if (dev_id) { 240d670bd4fSSam Ravnborg for (; action; action = action->next) { 241d670bd4fSSam Ravnborg if (action->dev_id == dev_id) 242d670bd4fSSam Ravnborg break; 243d670bd4fSSam Ravnborg actionp = &action->next; 244d670bd4fSSam Ravnborg } 245d670bd4fSSam Ravnborg if (!action) { 246d670bd4fSSam Ravnborg printk("Trying to free free shared IRQ%d\n",irq); 247d670bd4fSSam Ravnborg goto out_unlock; 248d670bd4fSSam Ravnborg } 249d670bd4fSSam Ravnborg } else if (action->flags & IRQF_SHARED) { 250d670bd4fSSam Ravnborg printk("Trying to free shared IRQ%d with NULL device ID\n", irq); 251d670bd4fSSam Ravnborg goto out_unlock; 252d670bd4fSSam Ravnborg } 253d670bd4fSSam Ravnborg if (action->flags & SA_STATIC_ALLOC) 254d670bd4fSSam Ravnborg { 255d670bd4fSSam Ravnborg /* This interrupt is marked as specially allocated 256d670bd4fSSam Ravnborg * so it is a bad idea to free it. 257d670bd4fSSam Ravnborg */ 258d670bd4fSSam Ravnborg printk("Attempt to free statically allocated IRQ%d (%s)\n", 259d670bd4fSSam Ravnborg irq, action->name); 260d670bd4fSSam Ravnborg goto out_unlock; 261d670bd4fSSam Ravnborg } 262d670bd4fSSam Ravnborg 263d670bd4fSSam Ravnborg *actionp = action->next; 264d670bd4fSSam Ravnborg 265d670bd4fSSam Ravnborg spin_unlock_irqrestore(&irq_action_lock, flags); 266d670bd4fSSam Ravnborg 267d670bd4fSSam Ravnborg synchronize_irq(irq); 268d670bd4fSSam Ravnborg 269d670bd4fSSam Ravnborg spin_lock_irqsave(&irq_action_lock, flags); 270d670bd4fSSam Ravnborg 271d670bd4fSSam Ravnborg kfree(action); 272d670bd4fSSam Ravnborg 273d670bd4fSSam Ravnborg if (!sparc_irq[cpu_irq].action) 274d670bd4fSSam Ravnborg __disable_irq(irq); 275d670bd4fSSam Ravnborg 276d670bd4fSSam Ravnborg out_unlock: 277d670bd4fSSam Ravnborg spin_unlock_irqrestore(&irq_action_lock, flags); 278d670bd4fSSam Ravnborg } 279d670bd4fSSam Ravnborg 280d670bd4fSSam Ravnborg EXPORT_SYMBOL(free_irq); 281d670bd4fSSam Ravnborg 282d670bd4fSSam Ravnborg /* 283d670bd4fSSam Ravnborg * This is called when we want to synchronize with 284d670bd4fSSam Ravnborg * interrupts. We may for example tell a device to 285d670bd4fSSam Ravnborg * stop sending interrupts: but to make sure there 286d670bd4fSSam Ravnborg * are no interrupts that are executing on another 287d670bd4fSSam Ravnborg * CPU we need to call this function. 288d670bd4fSSam Ravnborg */ 289d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 290d670bd4fSSam Ravnborg void synchronize_irq(unsigned int irq) 291d670bd4fSSam Ravnborg { 292d670bd4fSSam Ravnborg unsigned int cpu_irq; 293d670bd4fSSam Ravnborg 294d670bd4fSSam Ravnborg cpu_irq = irq & (NR_IRQS - 1); 295d670bd4fSSam Ravnborg while (sparc_irq[cpu_irq].flags & SPARC_IRQ_INPROGRESS) 296d670bd4fSSam Ravnborg cpu_relax(); 297d670bd4fSSam Ravnborg } 2986943f3daSSam Ravnborg EXPORT_SYMBOL(synchronize_irq); 299d670bd4fSSam Ravnborg #endif /* SMP */ 300d670bd4fSSam Ravnborg 301d670bd4fSSam Ravnborg void unexpected_irq(int irq, void *dev_id, struct pt_regs * regs) 302d670bd4fSSam Ravnborg { 303d670bd4fSSam Ravnborg int i; 304d670bd4fSSam Ravnborg struct irqaction * action; 305d670bd4fSSam Ravnborg unsigned int cpu_irq; 306d670bd4fSSam Ravnborg 307d670bd4fSSam Ravnborg cpu_irq = irq & (NR_IRQS - 1); 308d670bd4fSSam Ravnborg action = sparc_irq[cpu_irq].action; 309d670bd4fSSam Ravnborg 310d670bd4fSSam Ravnborg printk("IO device interrupt, irq = %d\n", irq); 311d670bd4fSSam Ravnborg printk("PC = %08lx NPC = %08lx FP=%08lx\n", regs->pc, 312d670bd4fSSam Ravnborg regs->npc, regs->u_regs[14]); 313d670bd4fSSam Ravnborg if (action) { 314d670bd4fSSam Ravnborg printk("Expecting: "); 315d670bd4fSSam Ravnborg for (i = 0; i < 16; i++) 316d670bd4fSSam Ravnborg if (action->handler) 317d670bd4fSSam Ravnborg printk("[%s:%d:0x%x] ", action->name, 318d670bd4fSSam Ravnborg (int) i, (unsigned int) action->handler); 319d670bd4fSSam Ravnborg } 320d670bd4fSSam Ravnborg printk("AIEEE\n"); 321d670bd4fSSam Ravnborg panic("bogus interrupt received"); 322d670bd4fSSam Ravnborg } 323d670bd4fSSam Ravnborg 324d670bd4fSSam Ravnborg void handler_irq(int irq, struct pt_regs * regs) 325d670bd4fSSam Ravnborg { 326d670bd4fSSam Ravnborg struct pt_regs *old_regs; 327d670bd4fSSam Ravnborg struct irqaction * action; 328d670bd4fSSam Ravnborg int cpu = smp_processor_id(); 329d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 330d670bd4fSSam Ravnborg extern void smp4m_irq_rotate(int cpu); 331d670bd4fSSam Ravnborg #endif 332d670bd4fSSam Ravnborg 333d670bd4fSSam Ravnborg old_regs = set_irq_regs(regs); 334d670bd4fSSam Ravnborg irq_enter(); 335d670bd4fSSam Ravnborg disable_pil_irq(irq); 336d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 337d670bd4fSSam Ravnborg /* Only rotate on lower priority IRQs (scsi, ethernet, etc.). */ 338d670bd4fSSam Ravnborg if((sparc_cpu_model==sun4m) && (irq < 10)) 339d670bd4fSSam Ravnborg smp4m_irq_rotate(cpu); 340d670bd4fSSam Ravnborg #endif 341d670bd4fSSam Ravnborg action = sparc_irq[irq].action; 342d670bd4fSSam Ravnborg sparc_irq[irq].flags |= SPARC_IRQ_INPROGRESS; 343d670bd4fSSam Ravnborg kstat_cpu(cpu).irqs[irq]++; 344d670bd4fSSam Ravnborg do { 345d670bd4fSSam Ravnborg if (!action || !action->handler) 346d670bd4fSSam Ravnborg unexpected_irq(irq, NULL, regs); 347d670bd4fSSam Ravnborg action->handler(irq, action->dev_id); 348d670bd4fSSam Ravnborg action = action->next; 349d670bd4fSSam Ravnborg } while (action); 350d670bd4fSSam Ravnborg sparc_irq[irq].flags &= ~SPARC_IRQ_INPROGRESS; 351d670bd4fSSam Ravnborg enable_pil_irq(irq); 352d670bd4fSSam Ravnborg irq_exit(); 353d670bd4fSSam Ravnborg set_irq_regs(old_regs); 354d670bd4fSSam Ravnborg } 355d670bd4fSSam Ravnborg 356d670bd4fSSam Ravnborg #if defined(CONFIG_BLK_DEV_FD) || defined(CONFIG_BLK_DEV_FD_MODULE) 357d670bd4fSSam Ravnborg 358d670bd4fSSam Ravnborg /* Fast IRQs on the Sparc can only have one routine attached to them, 359d670bd4fSSam Ravnborg * thus no sharing possible. 360d670bd4fSSam Ravnborg */ 361d670bd4fSSam Ravnborg static int request_fast_irq(unsigned int irq, 362d670bd4fSSam Ravnborg void (*handler)(void), 363d670bd4fSSam Ravnborg unsigned long irqflags, const char *devname) 364d670bd4fSSam Ravnborg { 365d670bd4fSSam Ravnborg struct irqaction *action; 366d670bd4fSSam Ravnborg unsigned long flags; 367d670bd4fSSam Ravnborg unsigned int cpu_irq; 368d670bd4fSSam Ravnborg int ret; 369d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 370d670bd4fSSam Ravnborg struct tt_entry *trap_table; 371d670bd4fSSam Ravnborg extern struct tt_entry trapbase_cpu1, trapbase_cpu2, trapbase_cpu3; 372d670bd4fSSam Ravnborg #endif 373d670bd4fSSam Ravnborg 374d670bd4fSSam Ravnborg cpu_irq = irq & (NR_IRQS - 1); 375d670bd4fSSam Ravnborg if(cpu_irq > 14) { 376d670bd4fSSam Ravnborg ret = -EINVAL; 377d670bd4fSSam Ravnborg goto out; 378d670bd4fSSam Ravnborg } 379d670bd4fSSam Ravnborg if(!handler) { 380d670bd4fSSam Ravnborg ret = -EINVAL; 381d670bd4fSSam Ravnborg goto out; 382d670bd4fSSam Ravnborg } 383d670bd4fSSam Ravnborg 384d670bd4fSSam Ravnborg spin_lock_irqsave(&irq_action_lock, flags); 385d670bd4fSSam Ravnborg 386d670bd4fSSam Ravnborg action = sparc_irq[cpu_irq].action; 387d670bd4fSSam Ravnborg if(action) { 388d670bd4fSSam Ravnborg if(action->flags & IRQF_SHARED) 389d670bd4fSSam Ravnborg panic("Trying to register fast irq when already shared.\n"); 390d670bd4fSSam Ravnborg if(irqflags & IRQF_SHARED) 391d670bd4fSSam Ravnborg panic("Trying to register fast irq as shared.\n"); 392d670bd4fSSam Ravnborg 393d670bd4fSSam Ravnborg /* Anyway, someone already owns it so cannot be made fast. */ 394d670bd4fSSam Ravnborg printk("request_fast_irq: Trying to register yet already owned.\n"); 395d670bd4fSSam Ravnborg ret = -EBUSY; 396d670bd4fSSam Ravnborg goto out_unlock; 397d670bd4fSSam Ravnborg } 398d670bd4fSSam Ravnborg 399d670bd4fSSam Ravnborg /* If this is flagged as statically allocated then we use our 400d670bd4fSSam Ravnborg * private struct which is never freed. 401d670bd4fSSam Ravnborg */ 402d670bd4fSSam Ravnborg if (irqflags & SA_STATIC_ALLOC) { 403d670bd4fSSam Ravnborg if (static_irq_count < MAX_STATIC_ALLOC) 404d670bd4fSSam Ravnborg action = &static_irqaction[static_irq_count++]; 405d670bd4fSSam Ravnborg else 406d670bd4fSSam Ravnborg printk("Fast IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", 407d670bd4fSSam Ravnborg irq, devname); 408d670bd4fSSam Ravnborg } 409d670bd4fSSam Ravnborg 410d670bd4fSSam Ravnborg if (action == NULL) 411d670bd4fSSam Ravnborg action = kmalloc(sizeof(struct irqaction), 412d670bd4fSSam Ravnborg GFP_ATOMIC); 413d670bd4fSSam Ravnborg 414d670bd4fSSam Ravnborg if (!action) { 415d670bd4fSSam Ravnborg ret = -ENOMEM; 416d670bd4fSSam Ravnborg goto out_unlock; 417d670bd4fSSam Ravnborg } 418d670bd4fSSam Ravnborg 419d670bd4fSSam Ravnborg /* Dork with trap table if we get this far. */ 420d670bd4fSSam Ravnborg #define INSTANTIATE(table) \ 421d670bd4fSSam Ravnborg table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_one = SPARC_RD_PSR_L0; \ 422d670bd4fSSam Ravnborg table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two = \ 423d670bd4fSSam Ravnborg SPARC_BRANCH((unsigned long) handler, \ 424d670bd4fSSam Ravnborg (unsigned long) &table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two);\ 425d670bd4fSSam Ravnborg table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_three = SPARC_RD_WIM_L3; \ 426d670bd4fSSam Ravnborg table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_four = SPARC_NOP; 427d670bd4fSSam Ravnborg 428d670bd4fSSam Ravnborg INSTANTIATE(sparc_ttable) 429d670bd4fSSam Ravnborg #ifdef CONFIG_SMP 430d670bd4fSSam Ravnborg trap_table = &trapbase_cpu1; INSTANTIATE(trap_table) 431d670bd4fSSam Ravnborg trap_table = &trapbase_cpu2; INSTANTIATE(trap_table) 432d670bd4fSSam Ravnborg trap_table = &trapbase_cpu3; INSTANTIATE(trap_table) 433d670bd4fSSam Ravnborg #endif 434d670bd4fSSam Ravnborg #undef INSTANTIATE 435d670bd4fSSam Ravnborg /* 436d670bd4fSSam Ravnborg * XXX Correct thing whould be to flush only I- and D-cache lines 437d670bd4fSSam Ravnborg * which contain the handler in question. But as of time of the 438d670bd4fSSam Ravnborg * writing we have no CPU-neutral interface to fine-grained flushes. 439d670bd4fSSam Ravnborg */ 440d670bd4fSSam Ravnborg flush_cache_all(); 441d670bd4fSSam Ravnborg 442d670bd4fSSam Ravnborg action->flags = irqflags; 443d670bd4fSSam Ravnborg action->name = devname; 444d670bd4fSSam Ravnborg action->dev_id = NULL; 445d670bd4fSSam Ravnborg action->next = NULL; 446d670bd4fSSam Ravnborg 447d670bd4fSSam Ravnborg sparc_irq[cpu_irq].action = action; 448d670bd4fSSam Ravnborg 449d670bd4fSSam Ravnborg __enable_irq(irq); 450d670bd4fSSam Ravnborg 451d670bd4fSSam Ravnborg ret = 0; 452d670bd4fSSam Ravnborg out_unlock: 453d670bd4fSSam Ravnborg spin_unlock_irqrestore(&irq_action_lock, flags); 454d670bd4fSSam Ravnborg out: 455d670bd4fSSam Ravnborg return ret; 456d670bd4fSSam Ravnborg } 457d670bd4fSSam Ravnborg 458d670bd4fSSam Ravnborg /* These variables are used to access state from the assembler 459d670bd4fSSam Ravnborg * interrupt handler, floppy_hardint, so we cannot put these in 460d670bd4fSSam Ravnborg * the floppy driver image because that would not work in the 461d670bd4fSSam Ravnborg * modular case. 462d670bd4fSSam Ravnborg */ 463d670bd4fSSam Ravnborg volatile unsigned char *fdc_status; 464d670bd4fSSam Ravnborg EXPORT_SYMBOL(fdc_status); 465d670bd4fSSam Ravnborg 466d670bd4fSSam Ravnborg char *pdma_vaddr; 467d670bd4fSSam Ravnborg EXPORT_SYMBOL(pdma_vaddr); 468d670bd4fSSam Ravnborg 469d670bd4fSSam Ravnborg unsigned long pdma_size; 470d670bd4fSSam Ravnborg EXPORT_SYMBOL(pdma_size); 471d670bd4fSSam Ravnborg 472d670bd4fSSam Ravnborg volatile int doing_pdma; 473d670bd4fSSam Ravnborg EXPORT_SYMBOL(doing_pdma); 474d670bd4fSSam Ravnborg 475d670bd4fSSam Ravnborg char *pdma_base; 476d670bd4fSSam Ravnborg EXPORT_SYMBOL(pdma_base); 477d670bd4fSSam Ravnborg 478d670bd4fSSam Ravnborg unsigned long pdma_areasize; 479d670bd4fSSam Ravnborg EXPORT_SYMBOL(pdma_areasize); 480d670bd4fSSam Ravnborg 481d670bd4fSSam Ravnborg extern void floppy_hardint(void); 482d670bd4fSSam Ravnborg 483d670bd4fSSam Ravnborg static irq_handler_t floppy_irq_handler; 484d670bd4fSSam Ravnborg 485d670bd4fSSam Ravnborg void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs) 486d670bd4fSSam Ravnborg { 487d670bd4fSSam Ravnborg struct pt_regs *old_regs; 488d670bd4fSSam Ravnborg int cpu = smp_processor_id(); 489d670bd4fSSam Ravnborg 490d670bd4fSSam Ravnborg old_regs = set_irq_regs(regs); 491d670bd4fSSam Ravnborg disable_pil_irq(irq); 492d670bd4fSSam Ravnborg irq_enter(); 493d670bd4fSSam Ravnborg kstat_cpu(cpu).irqs[irq]++; 494d670bd4fSSam Ravnborg floppy_irq_handler(irq, dev_id); 495d670bd4fSSam Ravnborg irq_exit(); 496d670bd4fSSam Ravnborg enable_pil_irq(irq); 497d670bd4fSSam Ravnborg set_irq_regs(old_regs); 498d670bd4fSSam Ravnborg // XXX Eek, it's totally changed with preempt_count() and such 499d670bd4fSSam Ravnborg // if (softirq_pending(cpu)) 500d670bd4fSSam Ravnborg // do_softirq(); 501d670bd4fSSam Ravnborg } 502d670bd4fSSam Ravnborg 503d670bd4fSSam Ravnborg int sparc_floppy_request_irq(int irq, unsigned long flags, 504d670bd4fSSam Ravnborg irq_handler_t irq_handler) 505d670bd4fSSam Ravnborg { 506d670bd4fSSam Ravnborg floppy_irq_handler = irq_handler; 507d670bd4fSSam Ravnborg return request_fast_irq(irq, floppy_hardint, flags, "floppy"); 508d670bd4fSSam Ravnborg } 509d670bd4fSSam Ravnborg EXPORT_SYMBOL(sparc_floppy_request_irq); 510d670bd4fSSam Ravnborg 511d670bd4fSSam Ravnborg #endif 512d670bd4fSSam Ravnborg 513d670bd4fSSam Ravnborg int request_irq(unsigned int irq, 514d670bd4fSSam Ravnborg irq_handler_t handler, 515d670bd4fSSam Ravnborg unsigned long irqflags, const char * devname, void *dev_id) 516d670bd4fSSam Ravnborg { 517d670bd4fSSam Ravnborg struct irqaction * action, **actionp; 518d670bd4fSSam Ravnborg unsigned long flags; 519d670bd4fSSam Ravnborg unsigned int cpu_irq; 520d670bd4fSSam Ravnborg int ret; 521d670bd4fSSam Ravnborg 522d670bd4fSSam Ravnborg if (sparc_cpu_model == sun4d) { 523d670bd4fSSam Ravnborg extern int sun4d_request_irq(unsigned int, 524d670bd4fSSam Ravnborg irq_handler_t , 525d670bd4fSSam Ravnborg unsigned long, const char *, void *); 526d670bd4fSSam Ravnborg return sun4d_request_irq(irq, handler, irqflags, devname, dev_id); 527d670bd4fSSam Ravnborg } 528d670bd4fSSam Ravnborg cpu_irq = irq & (NR_IRQS - 1); 529d670bd4fSSam Ravnborg if(cpu_irq > 14) { 530d670bd4fSSam Ravnborg ret = -EINVAL; 531d670bd4fSSam Ravnborg goto out; 532d670bd4fSSam Ravnborg } 533d670bd4fSSam Ravnborg if (!handler) { 534d670bd4fSSam Ravnborg ret = -EINVAL; 535d670bd4fSSam Ravnborg goto out; 536d670bd4fSSam Ravnborg } 537d670bd4fSSam Ravnborg 538d670bd4fSSam Ravnborg spin_lock_irqsave(&irq_action_lock, flags); 539d670bd4fSSam Ravnborg 540d670bd4fSSam Ravnborg actionp = &sparc_irq[cpu_irq].action; 541d670bd4fSSam Ravnborg action = *actionp; 542d670bd4fSSam Ravnborg if (action) { 543d670bd4fSSam Ravnborg if (!(action->flags & IRQF_SHARED) || !(irqflags & IRQF_SHARED)) { 544d670bd4fSSam Ravnborg ret = -EBUSY; 545d670bd4fSSam Ravnborg goto out_unlock; 546d670bd4fSSam Ravnborg } 547d670bd4fSSam Ravnborg if ((action->flags & IRQF_DISABLED) != (irqflags & IRQF_DISABLED)) { 548d670bd4fSSam Ravnborg printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq); 549d670bd4fSSam Ravnborg ret = -EBUSY; 550d670bd4fSSam Ravnborg goto out_unlock; 551d670bd4fSSam Ravnborg } 552d670bd4fSSam Ravnborg for ( ; action; action = *actionp) 553d670bd4fSSam Ravnborg actionp = &action->next; 554d670bd4fSSam Ravnborg } 555d670bd4fSSam Ravnborg 556d670bd4fSSam Ravnborg /* If this is flagged as statically allocated then we use our 557d670bd4fSSam Ravnborg * private struct which is never freed. 558d670bd4fSSam Ravnborg */ 559d670bd4fSSam Ravnborg if (irqflags & SA_STATIC_ALLOC) { 560d670bd4fSSam Ravnborg if (static_irq_count < MAX_STATIC_ALLOC) 561d670bd4fSSam Ravnborg action = &static_irqaction[static_irq_count++]; 562d670bd4fSSam Ravnborg else 563d670bd4fSSam Ravnborg printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname); 564d670bd4fSSam Ravnborg } 565d670bd4fSSam Ravnborg 566d670bd4fSSam Ravnborg if (action == NULL) 567d670bd4fSSam Ravnborg action = kmalloc(sizeof(struct irqaction), 568d670bd4fSSam Ravnborg GFP_ATOMIC); 569d670bd4fSSam Ravnborg 570d670bd4fSSam Ravnborg if (!action) { 571d670bd4fSSam Ravnborg ret = -ENOMEM; 572d670bd4fSSam Ravnborg goto out_unlock; 573d670bd4fSSam Ravnborg } 574d670bd4fSSam Ravnborg 575d670bd4fSSam Ravnborg action->handler = handler; 576d670bd4fSSam Ravnborg action->flags = irqflags; 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 6650fd7ef1fSKonrad Eisele case sparc_leon: 6660fd7ef1fSKonrad Eisele leon_init_IRQ(); 6670fd7ef1fSKonrad Eisele break; 6680fd7ef1fSKonrad Eisele 669d670bd4fSSam Ravnborg default: 670d670bd4fSSam Ravnborg prom_printf("Cannot initialize IRQs on this Sun machine..."); 671d670bd4fSSam Ravnborg break; 672d670bd4fSSam Ravnborg } 673d670bd4fSSam Ravnborg btfixup(); 674d670bd4fSSam Ravnborg } 675d670bd4fSSam Ravnborg 6764696b64dSJulian Calaby #ifdef CONFIG_PROC_FS 677d670bd4fSSam Ravnborg void init_irq_proc(void) 678d670bd4fSSam Ravnborg { 679d670bd4fSSam Ravnborg /* For now, nothing... */ 680d670bd4fSSam Ravnborg } 6814696b64dSJulian Calaby #endif /* CONFIG_PROC_FS */ 682