macints.c

内核linux2.4.20,可跟rtlinux3.2打补丁 组成实时linux系统,编译内核

	int irq_src	= IRQ_SRC(irq);

	switch(irq_src) {
		case 1: via_irq_enable(irq);
			break;
		case 2:
		case 7: if (oss_present) {
				oss_irq_enable(irq);
			} else {
				via_irq_enable(irq);
			}
			break;
		case 3:
		case 4:
		case 5:
		case 6: if (psc_present) {
				psc_irq_enable(irq);
			} else if (oss_present) {
				oss_irq_enable(irq);
			} else if (irq_src == 4) {
				scc_irq_enable(irq);
			}
			break;
		case 8: if (baboon_present) {
				baboon_irq_enable(irq);
			}
			break;
	}
}

void mac_disable_irq (unsigned int irq)
{
	int irq_src	= IRQ_SRC(irq);

	switch(irq_src) {
		case 1: via_irq_disable(irq);
			break;
		case 2:
		case 7: if (oss_present) {
				oss_irq_disable(irq);
			} else {
				via_irq_disable(irq);
			}
			break;
		case 3:
		case 4:
		case 5:
		case 6: if (psc_present) {
				psc_irq_disable(irq);
			} else if (oss_present) {
				oss_irq_disable(irq);
			} else if (irq_src == 4) {
				scc_irq_disable(irq);
			}
			break;
		case 8: if (baboon_present) {
				baboon_irq_disable(irq);
			}
			break;
	}
}

void mac_clear_irq( unsigned int irq )
{
	switch(IRQ_SRC(irq)) {
		case 1: via_irq_clear(irq);
			break;
		case 2:
		case 7: if (oss_present) {
				oss_irq_clear(irq);
			} else {
				via_irq_clear(irq);
			}
			break;
		case 3:
		case 4:
		case 5:
		case 6: if (psc_present) {
				psc_irq_clear(irq);
			} else if (oss_present) {
				oss_irq_clear(irq);
			}
			break;
		case 8: if (baboon_present) {
				baboon_irq_clear(irq);
			}
			break;
	}
}

int mac_irq_pending( unsigned int irq )
{
	switch(IRQ_SRC(irq)) {
		case 1: return via_irq_pending(irq);
		case 2:
		case 7: if (oss_present) {
				return oss_irq_pending(irq);
			} else {
				return via_irq_pending(irq);
			}
		case 3:
		case 4:
		case 5:
		case 6: if (psc_present) {
				return psc_irq_pending(irq);
			} else if (oss_present) {
				return oss_irq_pending(irq);
			}
	}
	return 0;
}

/*
 * Add an interrupt service routine to an interrupt source.
 * Returns 0 on success.
 *
 * FIXME: You can register interrupts on nonexistant source (ie PSC4 on a
 *        non-PSC machine). We should return -EINVAL in those cases.
 */
 
int mac_request_irq(unsigned int irq,
		    void (*handler)(int, void *, struct pt_regs *),
		    unsigned long flags, const char *devname, void *dev_id)
{
	irq_node_t *node;

#ifdef DEBUG_MACINTS
	printk ("%s: irq %d requested for %s\n", __FUNCTION__, irq, devname);
#endif

	if (irq < VIA1_SOURCE_BASE) {
		return sys_request_irq(irq, handler, flags, devname, dev_id);
	}

	if (irq >= NUM_MAC_SOURCES) {
		printk ("%s: unknown irq %d requested by %s\n",
		        __FUNCTION__, irq, devname);
	}

	/* Get a node and stick it onto the right list */

	if (!(node = new_irq_node())) return -ENOMEM;

	node->handler	= handler;
	node->flags	= flags;
	node->dev_id	= dev_id;
	node->devname	= devname;
	node->next	= NULL;
	mac_insert_irq(&mac_irq_list[irq], node);

	/* Now enable the IRQ source */

	mac_enable_irq(irq);

	return 0;
}
                            
/*
 * Removes an interrupt service routine from an interrupt source.
 */

void mac_free_irq(unsigned int irq, void *dev_id)
{
#ifdef DEBUG_MACINTS
	printk ("%s: irq %d freed by %p\n", __FUNCTION__, irq, dev_id);
#endif

	if (irq < VIA1_SOURCE_BASE) {
		return sys_free_irq(irq, dev_id);
	}

	if (irq >= NUM_MAC_SOURCES) {
		printk ("%s: unknown irq %d freed\n",
		        __FUNCTION__, irq);
		return;
	}

	mac_delete_irq(&mac_irq_list[irq], dev_id);

	/* If the list for this interrupt is */
	/* empty then disable the source.    */

	if (!mac_irq_list[irq]) {
		mac_disable_irq(irq);
	}
}

/*
 * Generate a pretty listing for /proc/interrupts
 *
 * By the time we're called the autovector interrupt list has already been
 * generated, so we just need to do the machspec interrupts.
 *
 * 990506 (jmt) - rewritten to handle chained machspec interrupt handlers.
 *                Also removed display of num_spurious it is already
 *		  displayed for us as autovector irq 0.
 */

int mac_get_irq_list (char *buf)
{
	int i, len = 0;
	irq_node_t *node;
	char *base;

	/* Don't do Nubus interrupts in this loop; we do them separately  */
	/* below so that we can print slot numbers instead of IRQ numbers */

	for (i = VIA1_SOURCE_BASE ; i < NUM_MAC_SOURCES ; ++i) {

		/* Nonexistant interrupt or nothing registered; skip it. */

		if ((node = mac_irq_list[i]) == NULL) continue;
		if (node->flags & IRQ_FLG_STD) continue;

		base = "";
		switch(IRQ_SRC(i)) {
			case 1: base = "via1";
				break;
			case 2: if (oss_present) {
					base = "oss";
				} else {
					base = "via2";
				}
				break;
			case 3:
			case 4:
			case 5:
			case 6: if (psc_present) {
					base = "psc";
				} else if (oss_present) {
					base = "oss";
				} else {
					if (IRQ_SRC(i) == 4) base = "scc";
				}
				break;
			case 7: base = "nbus";
				break;
			case 8: base = "bbn";
				break;
		}
		len += sprintf(buf+len, "%4s %2d: %10u ",
				base, i, kstat.irqs[0][i]);

		do {
			if (node->flags & IRQ_FLG_FAST) {
				len += sprintf(buf+len, "F ");
			} else if (node->flags & IRQ_FLG_SLOW) {
				len += sprintf(buf+len, "S ");
			} else {
				len += sprintf(buf+len, "  ");
			}
			len += sprintf(buf+len, "%s\n", node->devname);
			if ((node = node->next)) {
				len += sprintf(buf+len, "                    ");
			}
		} while(node);

	}
	return len;
}

void mac_default_handler(int irq, void *dev_id, struct pt_regs *regs)
{
#ifdef DEBUG_SPURIOUS
	printk("Unexpected IRQ %d on device %p\n", irq, dev_id);
#endif
}

static int num_debug[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };

void mac_debug_handler(int irq, void *dev_id, struct pt_regs *regs)
{
	if (num_debug[irq] < 10) {
		printk("DEBUG: Unexpected IRQ %d\n", irq);
		num_debug[irq]++;
	}
}

static int in_nmi = 0;
static volatile int nmi_hold = 0;

void mac_nmi_handler(int irq, void *dev_id, struct pt_regs *fp)
{
	int i;
	/* 
	 * generate debug output on NMI switch if 'debug' kernel option given
	 * (only works with Penguin!)
	 */

	in_nmi++;
	for (i=0; i<100; i++)
		udelay(1000);

	if (in_nmi == 1) {
		nmi_hold = 1;
		printk("... pausing, press NMI to resume ...");
	} else {
		printk(" ok!\n");
		nmi_hold = 0;
	}

	barrier();

	while (nmi_hold == 1)
		udelay(1000);

	if ( console_loglevel >= 8 ) {
#if 0
		show_state();
		printk("PC: %08lx\nSR: %04x  SP: %p\n", fp->pc, fp->sr, fp);
		printk("d0: %08lx    d1: %08lx    d2: %08lx    d3: %08lx\n",
		       fp->d0, fp->d1, fp->d2, fp->d3);
		printk("d4: %08lx    d5: %08lx    a0: %08lx    a1: %08lx\n",
		       fp->d4, fp->d5, fp->a0, fp->a1);
	
		if (STACK_MAGIC != *(unsigned long *)current->kernel_stack_page)
			printk("Corrupted stack page\n");
		printk("Process %s (pid: %d, stackpage=%08lx)\n",
			current->comm, current->pid, current->kernel_stack_page);
		if (intr_count == 1)
			dump_stack((struct frame *)fp);
#else
		/* printk("NMI "); */
#endif
	}
	in_nmi--;
}

/*
 * Simple routines for masking and unmasking
 * SCC interrupts in cases where this can't be
 * done in hardware (only the PSC can do that.)
 */

static void scc_irq_enable(int irq) {
	int irq_idx     = IRQ_IDX(irq);

	scc_mask |= (1 << irq_idx);
}

static void scc_irq_disable(int irq) {
	int irq_idx     = IRQ_IDX(irq);

	scc_mask &= ~(1 << irq_idx);
}

/*
 * SCC master interrupt handler. We have to do a bit of magic here
 * to figure out what channel gave us the interrupt; putting this
 * here is cleaner than hacking it into drivers/char/macserial.c.
 */

void mac_scc_dispatch(int irq, void *dev_id, struct pt_regs *regs)
{
	volatile unsigned char *scc = (unsigned char *) mac_bi_data.sccbase + 2;
	unsigned char reg;
	unsigned long cpu_flags;

	/* Read RR3 from the chip. Always do this on channel A */
	/* This must be an atomic operation so disable irqs.   */

	save_flags(cpu_flags); cli();
	*scc = 3;
	reg = *scc;
	restore_flags(cpu_flags);

	/* Now dispatch. Bits 0-2 are for channel B and */
	/* bits 3-5 are for channel A. We can safely    */
	/* ignore the remaining bits here.              */
	/*                                              */
	/* Note that we're ignoring scc_mask for now.   */
	/* If we actually mask the ints then we tend to */
	/* get hammered by very persistant SCC irqs,    */
	/* and since they're autovector interrupts they */
	/* pretty much kill the system.                 */

	if (reg & 0x38) mac_do_irq_list(IRQ_SCCA, regs);
	if (reg & 0x07) mac_do_irq_list(IRQ_SCCB, regs);
}