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