1 /* 2 * Macintosh interrupts 3 * 4 * General design: 5 * In contrary to the Amiga and Atari platforms, the Mac hardware seems to 6 * exclusively use the autovector interrupts (the 'generic level0-level7' 7 * interrupts with exception vectors 0x19-0x1f). The following interrupt levels 8 * are used: 9 * 1 - VIA1 10 * - slot 0: one second interrupt (CA2) 11 * - slot 1: VBlank (CA1) 12 * - slot 2: ADB data ready (SR full) 13 * - slot 3: ADB data (CB2) 14 * - slot 4: ADB clock (CB1) 15 * - slot 5: timer 2 16 * - slot 6: timer 1 17 * - slot 7: status of IRQ; signals 'any enabled int.' 18 * 19 * 2 - VIA2 or RBV 20 * - slot 0: SCSI DRQ (CA2) 21 * - slot 1: NUBUS IRQ (CA1) need to read port A to find which 22 * - slot 2: /EXP IRQ (only on IIci) 23 * - slot 3: SCSI IRQ (CB2) 24 * - slot 4: ASC IRQ (CB1) 25 * - slot 5: timer 2 (not on IIci) 26 * - slot 6: timer 1 (not on IIci) 27 * - slot 7: status of IRQ; signals 'any enabled int.' 28 * 29 * 2 - OSS (IIfx only?) 30 * - slot 0: SCSI interrupt 31 * - slot 1: Sound interrupt 32 * 33 * Levels 3-6 vary by machine type. For VIA or RBV Macintoshes: 34 * 35 * 3 - unused (?) 36 * 37 * 4 - SCC (slot number determined by reading RR3 on the SSC itself) 38 * - slot 1: SCC channel A 39 * - slot 2: SCC channel B 40 * 41 * 5 - unused (?) 42 * [serial errors or special conditions seem to raise level 6 43 * interrupts on some models (LC4xx?)] 44 * 45 * 6 - off switch (?) 46 * 47 * For OSS Macintoshes (IIfx only at this point): 48 * 49 * 3 - Nubus interrupt 50 * - slot 0: Slot $9 51 * - slot 1: Slot $A 52 * - slot 2: Slot $B 53 * - slot 3: Slot $C 54 * - slot 4: Slot $D 55 * - slot 5: Slot $E 56 * 57 * 4 - SCC IOP 58 * - slot 1: SCC channel A 59 * - slot 2: SCC channel B 60 * 61 * 5 - ISM IOP (ADB?) 62 * 63 * 6 - unused 64 * 65 * For PSC Macintoshes (660AV, 840AV): 66 * 67 * 3 - PSC level 3 68 * - slot 0: MACE 69 * 70 * 4 - PSC level 4 71 * - slot 1: SCC channel A interrupt 72 * - slot 2: SCC channel B interrupt 73 * - slot 3: MACE DMA 74 * 75 * 5 - PSC level 5 76 * 77 * 6 - PSC level 6 78 * 79 * Finally we have good 'ole level 7, the non-maskable interrupt: 80 * 81 * 7 - NMI (programmer's switch on the back of some Macs) 82 * Also RAM parity error on models which support it (IIc, IIfx?) 83 * 84 * The current interrupt logic looks something like this: 85 * 86 * - We install dispatchers for the autovector interrupts (1-7). These 87 * dispatchers are responsible for querying the hardware (the 88 * VIA/RBV/OSS/PSC chips) to determine the actual interrupt source. Using 89 * this information a machspec interrupt number is generated by placing the 90 * index of the interrupt hardware into the low three bits and the original 91 * autovector interrupt number in the upper 5 bits. The handlers for the 92 * resulting machspec interrupt are then called. 93 * 94 * - Nubus is a special case because its interrupts are hidden behind two 95 * layers of hardware. Nubus interrupts come in as index 1 on VIA #2, 96 * which translates to IRQ number 17. In this spot we install _another_ 97 * dispatcher. This dispatcher finds the interrupting slot number (9-F) and 98 * then forms a new machspec interrupt number as above with the slot number 99 * minus 9 in the low three bits and the pseudo-level 7 in the upper five 100 * bits. The handlers for this new machspec interrupt number are then 101 * called. This puts Nubus interrupts into the range 56-62. 102 * 103 * - The Baboon interrupts (used on some PowerBooks) are an even more special 104 * case. They're hidden behind the Nubus slot $C interrupt thus adding a 105 * third layer of indirection. Why oh why did the Apple engineers do that? 106 * 107 * - We support "fast" and "slow" handlers, just like the Amiga port. The 108 * fast handlers are called first and with all interrupts disabled. They 109 * are expected to execute quickly (hence the name). The slow handlers are 110 * called last with interrupts enabled and the interrupt level restored. 111 * They must therefore be reentrant. 112 * 113 * TODO: 114 * 115 */ 116 117 #include <linux/types.h> 118 #include <linux/kernel.h> 119 #include <linux/sched.h> 120 #include <linux/kernel_stat.h> 121 #include <linux/interrupt.h> /* for intr_count */ 122 #include <linux/delay.h> 123 #include <linux/seq_file.h> 124 125 #include <asm/system.h> 126 #include <asm/irq.h> 127 #include <asm/traps.h> 128 #include <asm/bootinfo.h> 129 #include <asm/machw.h> 130 #include <asm/macintosh.h> 131 #include <asm/mac_via.h> 132 #include <asm/mac_psc.h> 133 #include <asm/hwtest.h> 134 #include <asm/errno.h> 135 #include <asm/macints.h> 136 137 #define DEBUG_SPURIOUS 138 #define SHUTUP_SONIC 139 140 /* 141 * The mac_irq_list array is an array of linked lists of irq_node_t nodes. 142 * Each node contains one handler to be called whenever the interrupt 143 * occurs, with fast handlers listed before slow handlers. 144 */ 145 146 irq_node_t *mac_irq_list[NUM_MAC_SOURCES]; 147 148 /* SCC interrupt mask */ 149 150 static int scc_mask; 151 152 /* 153 * VIA/RBV hooks 154 */ 155 156 extern void via_init(void); 157 extern void via_register_interrupts(void); 158 extern void via_irq_enable(int); 159 extern void via_irq_disable(int); 160 extern void via_irq_clear(int); 161 extern int via_irq_pending(int); 162 163 /* 164 * OSS hooks 165 */ 166 167 extern int oss_present; 168 169 extern void oss_init(void); 170 extern void oss_register_interrupts(void); 171 extern void oss_irq_enable(int); 172 extern void oss_irq_disable(int); 173 extern void oss_irq_clear(int); 174 extern int oss_irq_pending(int); 175 176 /* 177 * PSC hooks 178 */ 179 180 extern int psc_present; 181 182 extern void psc_init(void); 183 extern void psc_register_interrupts(void); 184 extern void psc_irq_enable(int); 185 extern void psc_irq_disable(int); 186 extern void psc_irq_clear(int); 187 extern int psc_irq_pending(int); 188 189 /* 190 * IOP hooks 191 */ 192 193 extern void iop_register_interrupts(void); 194 195 /* 196 * Baboon hooks 197 */ 198 199 extern int baboon_present; 200 201 extern void baboon_init(void); 202 extern void baboon_register_interrupts(void); 203 extern void baboon_irq_enable(int); 204 extern void baboon_irq_disable(int); 205 extern void baboon_irq_clear(int); 206 extern int baboon_irq_pending(int); 207 208 /* 209 * SCC interrupt routines 210 */ 211 212 static void scc_irq_enable(int); 213 static void scc_irq_disable(int); 214 215 /* 216 * console_loglevel determines NMI handler function 217 */ 218 219 irqreturn_t mac_nmi_handler(int, void *, struct pt_regs *); 220 irqreturn_t mac_debug_handler(int, void *, struct pt_regs *); 221 222 /* #define DEBUG_MACINTS */ 223 224 void mac_init_IRQ(void) 225 { 226 int i; 227 228 #ifdef DEBUG_MACINTS 229 printk("mac_init_IRQ(): Setting things up...\n"); 230 #endif 231 /* Initialize the IRQ handler lists. Initially each list is empty, */ 232 233 for (i = 0; i < NUM_MAC_SOURCES; i++) { 234 mac_irq_list[i] = NULL; 235 } 236 237 scc_mask = 0; 238 239 /* Make sure the SONIC interrupt is cleared or things get ugly */ 240 #ifdef SHUTUP_SONIC 241 printk("Killing onboard sonic... "); 242 /* This address should hopefully be mapped already */ 243 if (hwreg_present((void*)(0x50f0a000))) { 244 *(long *)(0x50f0a014) = 0x7fffL; 245 *(long *)(0x50f0a010) = 0L; 246 } 247 printk("Done.\n"); 248 #endif /* SHUTUP_SONIC */ 249 250 /* 251 * Now register the handlers for the master IRQ handlers 252 * at levels 1-7. Most of the work is done elsewhere. 253 */ 254 255 if (oss_present) { 256 oss_register_interrupts(); 257 } else { 258 via_register_interrupts(); 259 } 260 if (psc_present) psc_register_interrupts(); 261 if (baboon_present) baboon_register_interrupts(); 262 iop_register_interrupts(); 263 cpu_request_irq(7, mac_nmi_handler, IRQ_FLG_LOCK, "NMI", 264 mac_nmi_handler); 265 #ifdef DEBUG_MACINTS 266 printk("mac_init_IRQ(): Done!\n"); 267 #endif 268 } 269 270 /* 271 * Routines to work with irq_node_t's on linked lists lifted from 272 * the Amiga code written by Roman Zippel. 273 */ 274 275 static inline void mac_insert_irq(irq_node_t **list, irq_node_t *node) 276 { 277 unsigned long flags; 278 irq_node_t *cur; 279 280 if (!node->dev_id) 281 printk("%s: Warning: dev_id of %s is zero\n", 282 __FUNCTION__, node->devname); 283 284 local_irq_save(flags); 285 286 cur = *list; 287 288 if (node->flags & IRQ_FLG_FAST) { 289 node->flags &= ~IRQ_FLG_SLOW; 290 while (cur && cur->flags & IRQ_FLG_FAST) { 291 list = &cur->next; 292 cur = cur->next; 293 } 294 } else if (node->flags & IRQ_FLG_SLOW) { 295 while (cur) { 296 list = &cur->next; 297 cur = cur->next; 298 } 299 } else { 300 while (cur && !(cur->flags & IRQ_FLG_SLOW)) { 301 list = &cur->next; 302 cur = cur->next; 303 } 304 } 305 306 node->next = cur; 307 *list = node; 308 309 local_irq_restore(flags); 310 } 311 312 static inline void mac_delete_irq(irq_node_t **list, void *dev_id) 313 { 314 unsigned long flags; 315 irq_node_t *node; 316 317 local_irq_save(flags); 318 319 for (node = *list; node; list = &node->next, node = *list) { 320 if (node->dev_id == dev_id) { 321 *list = node->next; 322 /* Mark it as free. */ 323 node->handler = NULL; 324 local_irq_restore(flags); 325 return; 326 } 327 } 328 local_irq_restore(flags); 329 printk ("%s: tried to remove invalid irq\n", __FUNCTION__); 330 } 331 332 /* 333 * Call all the handlers for a given interrupt. Fast handlers are called 334 * first followed by slow handlers. 335 * 336 * This code taken from the original Amiga code written by Roman Zippel. 337 */ 338 339 void mac_do_irq_list(int irq, struct pt_regs *fp) 340 { 341 irq_node_t *node, *slow_nodes; 342 unsigned long flags; 343 344 kstat_cpu(0).irqs[irq]++; 345 346 #ifdef DEBUG_SPURIOUS 347 if (!mac_irq_list[irq] && (console_loglevel > 7)) { 348 printk("mac_do_irq_list: spurious interrupt %d!\n", irq); 349 return; 350 } 351 #endif 352 353 /* serve first fast and normal handlers */ 354 for (node = mac_irq_list[irq]; 355 node && (!(node->flags & IRQ_FLG_SLOW)); 356 node = node->next) 357 node->handler(irq, node->dev_id, fp); 358 if (!node) return; 359 local_save_flags(flags); 360 local_irq_restore((flags & ~0x0700) | (fp->sr & 0x0700)); 361 /* if slow handlers exists, serve them now */ 362 slow_nodes = node; 363 for (; node; node = node->next) { 364 node->handler(irq, node->dev_id, fp); 365 } 366 } 367 368 /* 369 * mac_enable_irq - enable an interrupt source 370 * mac_disable_irq - disable an interrupt source 371 * mac_clear_irq - clears a pending interrupt 372 * mac_pending_irq - Returns the pending status of an IRQ (nonzero = pending) 373 * 374 * These routines are just dispatchers to the VIA/OSS/PSC routines. 375 */ 376 377 void mac_enable_irq (unsigned int irq) 378 { 379 int irq_src = IRQ_SRC(irq); 380 381 switch(irq_src) { 382 case 1: via_irq_enable(irq); 383 break; 384 case 2: 385 case 7: if (oss_present) { 386 oss_irq_enable(irq); 387 } else { 388 via_irq_enable(irq); 389 } 390 break; 391 case 3: 392 case 4: 393 case 5: 394 case 6: if (psc_present) { 395 psc_irq_enable(irq); 396 } else if (oss_present) { 397 oss_irq_enable(irq); 398 } else if (irq_src == 4) { 399 scc_irq_enable(irq); 400 } 401 break; 402 case 8: if (baboon_present) { 403 baboon_irq_enable(irq); 404 } 405 break; 406 } 407 } 408 409 void mac_disable_irq (unsigned int irq) 410 { 411 int irq_src = IRQ_SRC(irq); 412 413 switch(irq_src) { 414 case 1: via_irq_disable(irq); 415 break; 416 case 2: 417 case 7: if (oss_present) { 418 oss_irq_disable(irq); 419 } else { 420 via_irq_disable(irq); 421 } 422 break; 423 case 3: 424 case 4: 425 case 5: 426 case 6: if (psc_present) { 427 psc_irq_disable(irq); 428 } else if (oss_present) { 429 oss_irq_disable(irq); 430 } else if (irq_src == 4) { 431 scc_irq_disable(irq); 432 } 433 break; 434 case 8: if (baboon_present) { 435 baboon_irq_disable(irq); 436 } 437 break; 438 } 439 } 440 441 void mac_clear_irq( unsigned int irq ) 442 { 443 switch(IRQ_SRC(irq)) { 444 case 1: via_irq_clear(irq); 445 break; 446 case 2: 447 case 7: if (oss_present) { 448 oss_irq_clear(irq); 449 } else { 450 via_irq_clear(irq); 451 } 452 break; 453 case 3: 454 case 4: 455 case 5: 456 case 6: if (psc_present) { 457 psc_irq_clear(irq); 458 } else if (oss_present) { 459 oss_irq_clear(irq); 460 } 461 break; 462 case 8: if (baboon_present) { 463 baboon_irq_clear(irq); 464 } 465 break; 466 } 467 } 468 469 int mac_irq_pending( unsigned int irq ) 470 { 471 switch(IRQ_SRC(irq)) { 472 case 1: return via_irq_pending(irq); 473 case 2: 474 case 7: if (oss_present) { 475 return oss_irq_pending(irq); 476 } else { 477 return via_irq_pending(irq); 478 } 479 case 3: 480 case 4: 481 case 5: 482 case 6: if (psc_present) { 483 return psc_irq_pending(irq); 484 } else if (oss_present) { 485 return oss_irq_pending(irq); 486 } 487 } 488 return 0; 489 } 490 491 /* 492 * Add an interrupt service routine to an interrupt source. 493 * Returns 0 on success. 494 * 495 * FIXME: You can register interrupts on nonexistent source (ie PSC4 on a 496 * non-PSC machine). We should return -EINVAL in those cases. 497 */ 498 499 int mac_request_irq(unsigned int irq, 500 irqreturn_t (*handler)(int, void *, struct pt_regs *), 501 unsigned long flags, const char *devname, void *dev_id) 502 { 503 irq_node_t *node; 504 505 #ifdef DEBUG_MACINTS 506 printk ("%s: irq %d requested for %s\n", __FUNCTION__, irq, devname); 507 #endif 508 509 if (irq < VIA1_SOURCE_BASE) { 510 return cpu_request_irq(irq, handler, flags, devname, dev_id); 511 } 512 513 if (irq >= NUM_MAC_SOURCES) { 514 printk ("%s: unknown irq %d requested by %s\n", 515 __FUNCTION__, irq, devname); 516 } 517 518 /* Get a node and stick it onto the right list */ 519 520 if (!(node = new_irq_node())) return -ENOMEM; 521 522 node->handler = handler; 523 node->flags = flags; 524 node->dev_id = dev_id; 525 node->devname = devname; 526 node->next = NULL; 527 mac_insert_irq(&mac_irq_list[irq], node); 528 529 /* Now enable the IRQ source */ 530 531 mac_enable_irq(irq); 532 533 return 0; 534 } 535 536 /* 537 * Removes an interrupt service routine from an interrupt source. 538 */ 539 540 void mac_free_irq(unsigned int irq, void *dev_id) 541 { 542 #ifdef DEBUG_MACINTS 543 printk ("%s: irq %d freed by %p\n", __FUNCTION__, irq, dev_id); 544 #endif 545 546 if (irq < VIA1_SOURCE_BASE) { 547 cpu_free_irq(irq, dev_id); 548 return; 549 } 550 551 if (irq >= NUM_MAC_SOURCES) { 552 printk ("%s: unknown irq %d freed\n", 553 __FUNCTION__, irq); 554 return; 555 } 556 557 mac_delete_irq(&mac_irq_list[irq], dev_id); 558 559 /* If the list for this interrupt is */ 560 /* empty then disable the source. */ 561 562 if (!mac_irq_list[irq]) { 563 mac_disable_irq(irq); 564 } 565 } 566 567 /* 568 * Generate a pretty listing for /proc/interrupts 569 * 570 * By the time we're called the autovector interrupt list has already been 571 * generated, so we just need to do the machspec interrupts. 572 * 573 * 990506 (jmt) - rewritten to handle chained machspec interrupt handlers. 574 * Also removed display of num_spurious it is already 575 * displayed for us as autovector irq 0. 576 */ 577 578 int show_mac_interrupts(struct seq_file *p, void *v) 579 { 580 int i; 581 irq_node_t *node; 582 char *base; 583 584 /* Don't do Nubus interrupts in this loop; we do them separately */ 585 /* below so that we can print slot numbers instead of IRQ numbers */ 586 587 for (i = VIA1_SOURCE_BASE ; i < NUM_MAC_SOURCES ; ++i) { 588 589 /* Nonexistant interrupt or nothing registered; skip it. */ 590 591 if ((node = mac_irq_list[i]) == NULL) continue; 592 if (node->flags & IRQ_FLG_STD) continue; 593 594 base = ""; 595 switch(IRQ_SRC(i)) { 596 case 1: base = "via1"; 597 break; 598 case 2: if (oss_present) { 599 base = "oss"; 600 } else { 601 base = "via2"; 602 } 603 break; 604 case 3: 605 case 4: 606 case 5: 607 case 6: if (psc_present) { 608 base = "psc"; 609 } else if (oss_present) { 610 base = "oss"; 611 } else { 612 if (IRQ_SRC(i) == 4) base = "scc"; 613 } 614 break; 615 case 7: base = "nbus"; 616 break; 617 case 8: base = "bbn"; 618 break; 619 } 620 seq_printf(p, "%4s %2d: %10u ", base, i, kstat_cpu(0).irqs[i]); 621 622 do { 623 if (node->flags & IRQ_FLG_FAST) { 624 seq_puts(p, "F "); 625 } else if (node->flags & IRQ_FLG_SLOW) { 626 seq_puts(p, "S "); 627 } else { 628 seq_puts(p, " "); 629 } 630 seq_printf(p, "%s\n", node->devname); 631 if ((node = node->next)) { 632 seq_puts(p, " "); 633 } 634 } while(node); 635 636 } 637 return 0; 638 } 639 640 void mac_default_handler(int irq, void *dev_id, struct pt_regs *regs) 641 { 642 #ifdef DEBUG_SPURIOUS 643 printk("Unexpected IRQ %d on device %p\n", irq, dev_id); 644 #endif 645 } 646 647 static int num_debug[8]; 648 649 irqreturn_t mac_debug_handler(int irq, void *dev_id, struct pt_regs *regs) 650 { 651 if (num_debug[irq] < 10) { 652 printk("DEBUG: Unexpected IRQ %d\n", irq); 653 num_debug[irq]++; 654 } 655 return IRQ_HANDLED; 656 } 657 658 static int in_nmi; 659 static volatile int nmi_hold; 660 661 irqreturn_t mac_nmi_handler(int irq, void *dev_id, struct pt_regs *fp) 662 { 663 int i; 664 /* 665 * generate debug output on NMI switch if 'debug' kernel option given 666 * (only works with Penguin!) 667 */ 668 669 in_nmi++; 670 for (i=0; i<100; i++) 671 udelay(1000); 672 673 if (in_nmi == 1) { 674 nmi_hold = 1; 675 printk("... pausing, press NMI to resume ..."); 676 } else { 677 printk(" ok!\n"); 678 nmi_hold = 0; 679 } 680 681 barrier(); 682 683 while (nmi_hold == 1) 684 udelay(1000); 685 686 if ( console_loglevel >= 8 ) { 687 #if 0 688 show_state(); 689 printk("PC: %08lx\nSR: %04x SP: %p\n", fp->pc, fp->sr, fp); 690 printk("d0: %08lx d1: %08lx d2: %08lx d3: %08lx\n", 691 fp->d0, fp->d1, fp->d2, fp->d3); 692 printk("d4: %08lx d5: %08lx a0: %08lx a1: %08lx\n", 693 fp->d4, fp->d5, fp->a0, fp->a1); 694 695 if (STACK_MAGIC != *(unsigned long *)current->kernel_stack_page) 696 printk("Corrupted stack page\n"); 697 printk("Process %s (pid: %d, stackpage=%08lx)\n", 698 current->comm, current->pid, current->kernel_stack_page); 699 if (intr_count == 1) 700 dump_stack((struct frame *)fp); 701 #else 702 /* printk("NMI "); */ 703 #endif 704 } 705 in_nmi--; 706 return IRQ_HANDLED; 707 } 708 709 /* 710 * Simple routines for masking and unmasking 711 * SCC interrupts in cases where this can't be 712 * done in hardware (only the PSC can do that.) 713 */ 714 715 static void scc_irq_enable(int irq) { 716 int irq_idx = IRQ_IDX(irq); 717 718 scc_mask |= (1 << irq_idx); 719 } 720 721 static void scc_irq_disable(int irq) { 722 int irq_idx = IRQ_IDX(irq); 723 724 scc_mask &= ~(1 << irq_idx); 725 } 726 727 /* 728 * SCC master interrupt handler. We have to do a bit of magic here 729 * to figure out what channel gave us the interrupt; putting this 730 * here is cleaner than hacking it into drivers/char/macserial.c. 731 */ 732 733 void mac_scc_dispatch(int irq, void *dev_id, struct pt_regs *regs) 734 { 735 volatile unsigned char *scc = (unsigned char *) mac_bi_data.sccbase + 2; 736 unsigned char reg; 737 unsigned long flags; 738 739 /* Read RR3 from the chip. Always do this on channel A */ 740 /* This must be an atomic operation so disable irqs. */ 741 742 local_irq_save(flags); 743 *scc = 3; 744 reg = *scc; 745 local_irq_restore(flags); 746 747 /* Now dispatch. Bits 0-2 are for channel B and */ 748 /* bits 3-5 are for channel A. We can safely */ 749 /* ignore the remaining bits here. */ 750 /* */ 751 /* Note that we're ignoring scc_mask for now. */ 752 /* If we actually mask the ints then we tend to */ 753 /* get hammered by very persistent SCC irqs, */ 754 /* and since they're autovector interrupts they */ 755 /* pretty much kill the system. */ 756 757 if (reg & 0x38) mac_do_irq_list(IRQ_SCCA, regs); 758 if (reg & 0x07) mac_do_irq_list(IRQ_SCCB, regs); 759 } 760