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