[deliverable/linux.git] / arch / sparc / kernel / irq_32.c

/*
 *  arch/sparc/kernel/irq.c:  Interrupt request handling routines. On the
 *                            Sparc the IRQs are basically 'cast in stone'
 *                            and you are supposed to probe the prom's device
 *                            node trees to find out who's got which IRQ.
 *
 *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
 *  Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)
 *  Copyright (C) 1995,2002 Pete A. Zaitcev (zaitcev@yahoo.com)
 *  Copyright (C) 1996 Dave Redman (djhr@tadpole.co.uk)
 *  Copyright (C) 1998-2000 Anton Blanchard (anton@samba.org)
 */

#include <linux/module.h>
#include <linux/sched.h>
#include <linux/ptrace.h>
#include <linux/errno.h>
#include <linux/linkage.h>
#include <linux/kernel_stat.h>
#include <linux/signal.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/random.h>
#include <linux/init.h>
#include <linux/smp.h>
#include <linux/delay.h>
#include <linux/threads.h>
#include <linux/spinlock.h>
#include <linux/seq_file.h>

#include <asm/ptrace.h>
#include <asm/processor.h>
#include <asm/system.h>
#include <asm/psr.h>
#include <asm/smp.h>
#include <asm/vaddrs.h>
#include <asm/timer.h>
#include <asm/openprom.h>
#include <asm/oplib.h>
#include <asm/traps.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/pgalloc.h>
#include <asm/pgtable.h>
#include <asm/pcic.h>
#include <asm/cacheflush.h>
#include <asm/irq_regs.h>

#include "kernel.h"
#include "irq.h"

#ifdef CONFIG_SMP
#define SMP_NOP2 "nop; nop;\n\t"
#define SMP_NOP3 "nop; nop; nop;\n\t"
#else
#define SMP_NOP2
#define SMP_NOP3
#endif /* SMP */
unsigned long __raw_local_irq_save(void)
{
	unsigned long retval;
	unsigned long tmp;

	__asm__ __volatile__(
		"rd	%%psr, %0\n\t"
		SMP_NOP3	/* Sun4m + Cypress + SMP bug */
		"or	%0, %2, %1\n\t"
		"wr	%1, 0, %%psr\n\t"
		"nop; nop; nop\n"
		: "=&r" (retval), "=r" (tmp)
		: "i" (PSR_PIL)
		: "memory");

	return retval;
}

void raw_local_irq_enable(void)
{
	unsigned long tmp;

	__asm__ __volatile__(
		"rd	%%psr, %0\n\t"
		SMP_NOP3	/* Sun4m + Cypress + SMP bug */
		"andn	%0, %1, %0\n\t"
		"wr	%0, 0, %%psr\n\t"
		"nop; nop; nop\n"
		: "=&r" (tmp)
		: "i" (PSR_PIL)
		: "memory");
}

void raw_local_irq_restore(unsigned long old_psr)
{
	unsigned long tmp;

	__asm__ __volatile__(
		"rd	%%psr, %0\n\t"
		"and	%2, %1, %2\n\t"
		SMP_NOP2	/* Sun4m + Cypress + SMP bug */
		"andn	%0, %1, %0\n\t"
		"wr	%0, %2, %%psr\n\t"
		"nop; nop; nop\n"
		: "=&r" (tmp)
		: "i" (PSR_PIL), "r" (old_psr)
		: "memory");
}

EXPORT_SYMBOL(__raw_local_irq_save);
EXPORT_SYMBOL(raw_local_irq_enable);
EXPORT_SYMBOL(raw_local_irq_restore);

/*
 * Dave Redman (djhr@tadpole.co.uk)
 *
 * IRQ numbers.. These are no longer restricted to 15..
 *
 * this is done to enable SBUS cards and onboard IO to be masked
 * correctly. using the interrupt level isn't good enough.
 *
 * For example:
 *   A device interrupting at sbus level6 and the Floppy both come in
 *   at IRQ11, but enabling and disabling them requires writing to
 *   different bits in the SLAVIO/SEC.
 *
 * As a result of these changes sun4m machines could now support
 * directed CPU interrupts using the existing enable/disable irq code
 * with tweaks.
 *
 */

static void irq_panic(void)
{
    extern char *cputypval;
    prom_printf("machine: %s doesn't have irq handlers defined!\n",cputypval);
    prom_halt();
}

void (*sparc_init_timers)(irq_handler_t ) =
    (void (*)(irq_handler_t )) irq_panic;

/*
 * Dave Redman (djhr@tadpole.co.uk)
 *
 * There used to be extern calls and hard coded values here.. very sucky!
 * instead, because some of the devices attach very early, I do something
 * equally sucky but at least we'll never try to free statically allocated
 * space or call kmalloc before kmalloc_init :(.
 * 
 * In fact it's the timer10 that attaches first.. then timer14
 * then kmalloc_init is called.. then the tty interrupts attach.
 * hmmm....
 *
 */
#define MAX_STATIC_ALLOC	4
struct irqaction static_irqaction[MAX_STATIC_ALLOC];
int static_irq_count;

static struct {
	struct irqaction *action;
	int flags;
} sparc_irq[NR_IRQS];
#define SPARC_IRQ_INPROGRESS 1

/* Used to protect the IRQ action lists */
DEFINE_SPINLOCK(irq_action_lock);

int show_interrupts(struct seq_file *p, void *v)
{
	int i = *(loff_t *) v;
	struct irqaction * action;
	unsigned long flags;
#ifdef CONFIG_SMP
	int j;
#endif

	if (sparc_cpu_model == sun4d) {
		extern int show_sun4d_interrupts(struct seq_file *, void *);
		
		return show_sun4d_interrupts(p, v);
	}
	spin_lock_irqsave(&irq_action_lock, flags);
	if (i < NR_IRQS) {
		action = sparc_irq[i].action;
		if (!action) 
			goto out_unlock;
		seq_printf(p, "%3d: ", i);
#ifndef CONFIG_SMP
		seq_printf(p, "%10u ", kstat_irqs(i));
#else
		for_each_online_cpu(j) {
			seq_printf(p, "%10u ",
				    kstat_cpu(j).irqs[i]);
		}
#endif
		seq_printf(p, " %c %s",
			(action->flags & IRQF_DISABLED) ? '+' : ' ',
			action->name);
		for (action=action->next; action; action = action->next) {
			seq_printf(p, ",%s %s",
				(action->flags & IRQF_DISABLED) ? " +" : "",
				action->name);
		}
		seq_putc(p, '\n');
	}
out_unlock:
	spin_unlock_irqrestore(&irq_action_lock, flags);
	return 0;
}

void free_irq(unsigned int irq, void *dev_id)
{
	struct irqaction * action;
	struct irqaction **actionp;
        unsigned long flags;
	unsigned int cpu_irq;
	
	if (sparc_cpu_model == sun4d) {
		extern void sun4d_free_irq(unsigned int, void *);
		
		sun4d_free_irq(irq, dev_id);
		return;
	}
	cpu_irq = irq & (NR_IRQS - 1);
        if (cpu_irq > 14) {  /* 14 irq levels on the sparc */
                printk("Trying to free bogus IRQ %d\n", irq);
                return;
        }

	spin_lock_irqsave(&irq_action_lock, flags);

	actionp = &sparc_irq[cpu_irq].action;
	action = *actionp;

	if (!action->handler) {
		printk("Trying to free free IRQ%d\n",irq);
		goto out_unlock;
	}
	if (dev_id) {
		for (; action; action = action->next) {
			if (action->dev_id == dev_id)
				break;
			actionp = &action->next;
		}
		if (!action) {
			printk("Trying to free free shared IRQ%d\n",irq);
			goto out_unlock;
		}
	} else if (action->flags & IRQF_SHARED) {
		printk("Trying to free shared IRQ%d with NULL device ID\n", irq);
		goto out_unlock;
	}
	if (action->flags & SA_STATIC_ALLOC)
	{
		/* This interrupt is marked as specially allocated
		 * so it is a bad idea to free it.
		 */
		printk("Attempt to free statically allocated IRQ%d (%s)\n",
		       irq, action->name);
		goto out_unlock;
	}

	*actionp = action->next;

	spin_unlock_irqrestore(&irq_action_lock, flags);

	synchronize_irq(irq);

	spin_lock_irqsave(&irq_action_lock, flags);

	kfree(action);

	if (!sparc_irq[cpu_irq].action)
		__disable_irq(irq);

out_unlock:
	spin_unlock_irqrestore(&irq_action_lock, flags);
}

EXPORT_SYMBOL(free_irq);

/*
 * This is called when we want to synchronize with
 * interrupts. We may for example tell a device to
 * stop sending interrupts: but to make sure there
 * are no interrupts that are executing on another
 * CPU we need to call this function.
 */
#ifdef CONFIG_SMP
void synchronize_irq(unsigned int irq)
{
	unsigned int cpu_irq;

	cpu_irq = irq & (NR_IRQS - 1);
	while (sparc_irq[cpu_irq].flags & SPARC_IRQ_INPROGRESS)
		cpu_relax();
}
EXPORT_SYMBOL(synchronize_irq);
#endif /* SMP */

void unexpected_irq(int irq, void *dev_id, struct pt_regs * regs)
{
        int i;
	struct irqaction * action;
	unsigned int cpu_irq;
	
	cpu_irq = irq & (NR_IRQS - 1);
	action = sparc_irq[cpu_irq].action;

        printk("IO device interrupt, irq = %d\n", irq);
        printk("PC = %08lx NPC = %08lx FP=%08lx\n", regs->pc, 
		    regs->npc, regs->u_regs[14]);
	if (action) {
		printk("Expecting: ");
        	for (i = 0; i < 16; i++)
                	if (action->handler)
                        	printk("[%s:%d:0x%x] ", action->name,
				       (int) i, (unsigned int) action->handler);
	}
        printk("AIEEE\n");
	panic("bogus interrupt received");
}

void handler_irq(int irq, struct pt_regs * regs)
{
	struct pt_regs *old_regs;
	struct irqaction * action;
	int cpu = smp_processor_id();
#ifdef CONFIG_SMP
	extern void smp4m_irq_rotate(int cpu);
#endif

	old_regs = set_irq_regs(regs);
	irq_enter();
	disable_pil_irq(irq);
#ifdef CONFIG_SMP
	/* Only rotate on lower priority IRQs (scsi, ethernet, etc.). */
	if((sparc_cpu_model==sun4m) && (irq < 10))
		smp4m_irq_rotate(cpu);
#endif
	action = sparc_irq[irq].action;
	sparc_irq[irq].flags |= SPARC_IRQ_INPROGRESS;
	kstat_cpu(cpu).irqs[irq]++;
	do {
		if (!action || !action->handler)
			unexpected_irq(irq, NULL, regs);
		action->handler(irq, action->dev_id);
		action = action->next;
	} while (action);
	sparc_irq[irq].flags &= ~SPARC_IRQ_INPROGRESS;
	enable_pil_irq(irq);
	irq_exit();
	set_irq_regs(old_regs);
}

#if defined(CONFIG_BLK_DEV_FD) || defined(CONFIG_BLK_DEV_FD_MODULE)

/* Fast IRQs on the Sparc can only have one routine attached to them,
 * thus no sharing possible.
 */
static int request_fast_irq(unsigned int irq,
			    void (*handler)(void),
			    unsigned long irqflags, const char *devname)
{
	struct irqaction *action;
	unsigned long flags;
	unsigned int cpu_irq;
	int ret;
#ifdef CONFIG_SMP
	struct tt_entry *trap_table;
	extern struct tt_entry trapbase_cpu1, trapbase_cpu2, trapbase_cpu3;
#endif
	
	cpu_irq = irq & (NR_IRQS - 1);
	if(cpu_irq > 14) {
		ret = -EINVAL;
		goto out;
	}
	if(!handler) {
		ret = -EINVAL;
		goto out;
	}

	spin_lock_irqsave(&irq_action_lock, flags);

	action = sparc_irq[cpu_irq].action;
	if(action) {
		if(action->flags & IRQF_SHARED)
			panic("Trying to register fast irq when already shared.\n");
		if(irqflags & IRQF_SHARED)
			panic("Trying to register fast irq as shared.\n");

		/* Anyway, someone already owns it so cannot be made fast. */
		printk("request_fast_irq: Trying to register yet already owned.\n");
		ret = -EBUSY;
		goto out_unlock;
	}

	/* If this is flagged as statically allocated then we use our
	 * private struct which is never freed.
	 */
	if (irqflags & SA_STATIC_ALLOC) {
	    if (static_irq_count < MAX_STATIC_ALLOC)
		action = &static_irqaction[static_irq_count++];
	    else
		printk("Fast IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n",
		       irq, devname);
	}
	
	if (action == NULL)
	    action = kmalloc(sizeof(struct irqaction),
						 GFP_ATOMIC);
	
	if (!action) { 
		ret = -ENOMEM;
		goto out_unlock;
	}

	/* Dork with trap table if we get this far. */
#define INSTANTIATE(table) \
	table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_one = SPARC_RD_PSR_L0; \
	table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two = \
		SPARC_BRANCH((unsigned long) handler, \
			     (unsigned long) &table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two);\
	table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_three = SPARC_RD_WIM_L3; \
	table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_four = SPARC_NOP;

	INSTANTIATE(sparc_ttable)
#ifdef CONFIG_SMP
	trap_table = &trapbase_cpu1; INSTANTIATE(trap_table)
	trap_table = &trapbase_cpu2; INSTANTIATE(trap_table)
	trap_table = &trapbase_cpu3; INSTANTIATE(trap_table)
#endif
#undef INSTANTIATE
	/*
	 * XXX Correct thing whould be to flush only I- and D-cache lines
	 * which contain the handler in question. But as of time of the
	 * writing we have no CPU-neutral interface to fine-grained flushes.
	 */
	flush_cache_all();

	action->flags = irqflags;
	cpus_clear(action->mask);
	action->name = devname;
	action->dev_id = NULL;
	action->next = NULL;

	sparc_irq[cpu_irq].action = action;

	__enable_irq(irq);

	ret = 0;
out_unlock:
	spin_unlock_irqrestore(&irq_action_lock, flags);
out:
	return ret;
}

/* These variables are used to access state from the assembler
 * interrupt handler, floppy_hardint, so we cannot put these in
 * the floppy driver image because that would not work in the
 * modular case.
 */
volatile unsigned char *fdc_status;
EXPORT_SYMBOL(fdc_status);

char *pdma_vaddr;
EXPORT_SYMBOL(pdma_vaddr);

unsigned long pdma_size;
EXPORT_SYMBOL(pdma_size);

volatile int doing_pdma;
EXPORT_SYMBOL(doing_pdma);

char *pdma_base;
EXPORT_SYMBOL(pdma_base);

unsigned long pdma_areasize;
EXPORT_SYMBOL(pdma_areasize);

extern void floppy_hardint(void);

static irq_handler_t floppy_irq_handler;

void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs)
{
	struct pt_regs *old_regs;
	int cpu = smp_processor_id();

	old_regs = set_irq_regs(regs);
	disable_pil_irq(irq);
	irq_enter();
	kstat_cpu(cpu).irqs[irq]++;
	floppy_irq_handler(irq, dev_id);
	irq_exit();
	enable_pil_irq(irq);
	set_irq_regs(old_regs);
	// XXX Eek, it's totally changed with preempt_count() and such
	// if (softirq_pending(cpu))
	//	do_softirq();
}

int sparc_floppy_request_irq(int irq, unsigned long flags,
			     irq_handler_t irq_handler)
{
	floppy_irq_handler = irq_handler;
	return request_fast_irq(irq, floppy_hardint, flags, "floppy");
}
EXPORT_SYMBOL(sparc_floppy_request_irq);

#endif

int request_irq(unsigned int irq,
		irq_handler_t handler,
		unsigned long irqflags, const char * devname, void *dev_id)
{
	struct irqaction * action, **actionp;
	unsigned long flags;
	unsigned int cpu_irq;
	int ret;
	
	if (sparc_cpu_model == sun4d) {
		extern int sun4d_request_irq(unsigned int, 
					     irq_handler_t ,
					     unsigned long, const char *, void *);
		return sun4d_request_irq(irq, handler, irqflags, devname, dev_id);
	}
	cpu_irq = irq & (NR_IRQS - 1);
	if(cpu_irq > 14) {
		ret = -EINVAL;
		goto out;
	}
	if (!handler) {
		ret = -EINVAL;
		goto out;
	}
	    
	spin_lock_irqsave(&irq_action_lock, flags);

	actionp = &sparc_irq[cpu_irq].action;
	action = *actionp;
	if (action) {
		if (!(action->flags & IRQF_SHARED) || !(irqflags & IRQF_SHARED)) {
			ret = -EBUSY;
			goto out_unlock;
		}
		if ((action->flags & IRQF_DISABLED) != (irqflags & IRQF_DISABLED)) {
			printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq);
			ret = -EBUSY;
			goto out_unlock;
		}
		for ( ; action; action = *actionp)
			actionp = &action->next;
	}

	/* If this is flagged as statically allocated then we use our
	 * private struct which is never freed.
	 */
	if (irqflags & SA_STATIC_ALLOC) {
		if (static_irq_count < MAX_STATIC_ALLOC)
			action = &static_irqaction[static_irq_count++];
		else
			printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname);
	}
	
	if (action == NULL)
		action = kmalloc(sizeof(struct irqaction),
						     GFP_ATOMIC);
	
	if (!action) { 
		ret = -ENOMEM;
		goto out_unlock;
	}

	action->handler = handler;
	action->flags = irqflags;
	cpus_clear(action->mask);
	action->name = devname;
	action->next = NULL;
	action->dev_id = dev_id;

	*actionp = action;

	__enable_irq(irq);

	ret = 0;
out_unlock:
	spin_unlock_irqrestore(&irq_action_lock, flags);
out:
	return ret;
}

EXPORT_SYMBOL(request_irq);

void disable_irq_nosync(unsigned int irq)
{
	__disable_irq(irq);
}
EXPORT_SYMBOL(disable_irq_nosync);

void disable_irq(unsigned int irq)
{
	__disable_irq(irq);
}
EXPORT_SYMBOL(disable_irq);

void enable_irq(unsigned int irq)
{
	__enable_irq(irq);
}

EXPORT_SYMBOL(enable_irq);

/* We really don't need these at all on the Sparc.  We only have
 * stubs here because they are exported to modules.
 */
unsigned long probe_irq_on(void)
{
	return 0;
}

EXPORT_SYMBOL(probe_irq_on);

int probe_irq_off(unsigned long mask)
{
	return 0;
}

EXPORT_SYMBOL(probe_irq_off);

/* djhr
 * This could probably be made indirect too and assigned in the CPU
 * bits of the code. That would be much nicer I think and would also
 * fit in with the idea of being able to tune your kernel for your machine
 * by removing unrequired machine and device support.
 *
 */

void __init init_IRQ(void)
{
	extern void sun4c_init_IRQ( void );
	extern void sun4m_init_IRQ( void );
	extern void sun4d_init_IRQ( void );

	switch(sparc_cpu_model) {
	case sun4c:
	case sun4:
		sun4c_init_IRQ();
		break;

	case sun4m:
#ifdef CONFIG_PCI
		pcic_probe();
		if (pcic_present()) {
			sun4m_pci_init_IRQ();
			break;
		}
#endif
		sun4m_init_IRQ();
		break;
		
	case sun4d:
		sun4d_init_IRQ();
		break;

	default:
		prom_printf("Cannot initialize IRQs on this Sun machine...");
		break;
	}
	btfixup();
}

#ifdef CONFIG_PROC_FS
void init_irq_proc(void)
{
	/* For now, nothing... */
}
#endif /* CONFIG_PROC_FS */
Commit	Line	Data
88278ca2	1	/*
1da177e4	2	* arch/sparc/kernel/irq.c: Interrupt request handling routines. On the
d1a78c32	3	* Sparc the IRQs are basically 'cast in stone'
1da177e4 LT	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
1da177e4 LT	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>
1da177e4 LT	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>
1da177e4 LT	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>
0d84438d	47	#include <asm/irq_regs.h>
1da177e4	48
81265fd9	49	#include "kernel.h"
32231a66 AV	50	#include "irq.h"
32231a66 AV	51
1da177e4 LT	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 */
e8dd1612	59	unsigned long __raw_local_irq_save(void)
1da177e4 LT	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
e8dd1612	77	void raw_local_irq_enable(void)
1da177e4 LT	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
e8dd1612	92	void raw_local_irq_restore(unsigned long old_psr)
1da177e4 LT	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
e8dd1612 RR	108	EXPORT_SYMBOL(__raw_local_irq_save);
	109	EXPORT_SYMBOL(raw_local_irq_enable);
	110	EXPORT_SYMBOL(raw_local_irq_restore);
1da177e4 LT	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
40220c1a DH	138	void (*sparc_init_timers)(irq_handler_t ) =
40220c1a DH	139	(void (*)(irq_handler_t )) irq_panic;
1da177e4 LT	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
c61c65cd	158	static struct {
a54123e2 BB	159	struct irqaction *action;
	160	int flags;
	161	} sparc_irq[NR_IRQS];
	162	#define SPARC_IRQ_INPROGRESS 1
1da177e4 LT	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) {
a54123e2	183	action = sparc_irq[i].action;
1da177e4 LT	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
394e3902 AM	190	for_each_online_cpu(j) {
394e3902 AM	191	seq_printf(p, "%10u ",
a54123e2	192	kstat_cpu(j).irqs[i]);
1da177e4 LT	193	}
	194	#endif
	195	seq_printf(p, " %c %s",
67413202	196	(action->flags & IRQF_DISABLED) ? '+' : ' ',
1da177e4 LT	197	action->name);
	198	for (action=action->next; action; action = action->next) {
	199	seq_printf(p, ",%s %s",
67413202	200	(action->flags & IRQF_DISABLED) ? " +" : "",
1da177e4 LT	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;
a54123e2	213	struct irqaction **actionp;
1da177e4 LT	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
a54123e2 BB	231	actionp = &sparc_irq[cpu_irq].action;
a54123e2 BB	232	action = *actionp;
1da177e4 LT	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;
a54123e2	242	actionp = &action->next;
1da177e4 LT	243	}
	244	if (!action) {
	245	printk("Trying to free free shared IRQ%d\n",irq);
	246	goto out_unlock;
	247	}
67413202	248	} else if (action->flags & IRQF_SHARED) {
1da177e4 LT	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	}
a54123e2 BB	261
a54123e2 BB	262	*actionp = action->next;
1da177e4 LT	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
a54123e2	272	if (!sparc_irq[cpu_irq].action)
0f516813	273	__disable_irq(irq);
1da177e4 LT	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	{
a54123e2 BB	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();
1da177e4	296	}
6943f3da	297	EXPORT_SYMBOL(synchronize_irq);
1da177e4 LT	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);
a54123e2	307	action = sparc_irq[cpu_irq].action;
1da177e4 LT	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	{
0d84438d	325	struct pt_regs *old_regs;
1da177e4 LT	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
0d84438d	332	old_regs = set_irq_regs(regs);
1da177e4 LT	333	irq_enter();
	334	disable_pil_irq(irq);
	335	#ifdef CONFIG_SMP
d1a78c32	336	/* Only rotate on lower priority IRQs (scsi, ethernet, etc.). */
198c167c	337	if((sparc_cpu_model==sun4m) && (irq < 10))
1da177e4 LT	338	smp4m_irq_rotate(cpu);
1da177e4 LT	339	#endif
a54123e2 BB	340	action = sparc_irq[irq].action;
a54123e2 BB	341	sparc_irq[irq].flags \|= SPARC_IRQ_INPROGRESS;
1da177e4 LT	342	kstat_cpu(cpu).irqs[irq]++;
	343	do {
	344	if (!action \|\| !action->handler)
	345	unexpected_irq(irq, NULL, regs);
0d84438d	346	action->handler(irq, action->dev_id);
1da177e4 LT	347	action = action->next;
1da177e4 LT	348	} while (action);
a54123e2	349	sparc_irq[irq].flags &= ~SPARC_IRQ_INPROGRESS;
1da177e4 LT	350	enable_pil_irq(irq);
1da177e4 LT	351	irq_exit();
0d84438d	352	set_irq_regs(old_regs);
1da177e4 LT	353	}
1da177e4 LT	354
0a808a31	355	#if defined(CONFIG_BLK_DEV_FD) \|\| defined(CONFIG_BLK_DEV_FD_MODULE)
1da177e4	356
d1a78c32	357	/* Fast IRQs on the Sparc can only have one routine attached to them,
1da177e4 LT	358	* thus no sharing possible.
1da177e4 LT	359	*/
0a808a31 DM	360	static int request_fast_irq(unsigned int irq,
	361	void (*handler)(void),
	362	unsigned long irqflags, const char *devname)
1da177e4 LT	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
a54123e2	385	action = sparc_irq[cpu_irq].action;
1da177e4	386	if(action) {
67413202	387	if(action->flags & IRQF_SHARED)
1da177e4	388	panic("Trying to register fast irq when already shared.\n");
67413202	389	if(irqflags & IRQF_SHARED)
1da177e4 LT	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)
5cbded58	410	action = kmalloc(sizeof(struct irqaction),
1da177e4 LT	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
1da177e4 LT	441	action->flags = irqflags;
	442	cpus_clear(action->mask);
	443	action->name = devname;
	444	action->dev_id = NULL;
	445	action->next = NULL;
	446
a54123e2	447	sparc_irq[cpu_irq].action = action;
1da177e4	448
0f516813	449	__enable_irq(irq);
1da177e4 LT	450
	451	ret = 0;
	452	out_unlock:
	453	spin_unlock_irqrestore(&irq_action_lock, flags);
	454	out:
	455	return ret;
	456	}
	457
0a808a31 DM	458	/* These variables are used to access state from the assembler
	459	* interrupt handler, floppy_hardint, so we cannot put these in
	460	* the floppy driver image because that would not work in the
	461	* modular case.
	462	*/
	463	volatile unsigned char *fdc_status;
	464	EXPORT_SYMBOL(fdc_status);
	465
	466	char *pdma_vaddr;
	467	EXPORT_SYMBOL(pdma_vaddr);
	468
	469	unsigned long pdma_size;
	470	EXPORT_SYMBOL(pdma_size);
	471
	472	volatile int doing_pdma;
	473	EXPORT_SYMBOL(doing_pdma);
	474
	475	char *pdma_base;
	476	EXPORT_SYMBOL(pdma_base);
	477
	478	unsigned long pdma_areasize;
	479	EXPORT_SYMBOL(pdma_areasize);
	480
	481	extern void floppy_hardint(void);
	482
7c239975	483	static irq_handler_t floppy_irq_handler;
0a808a31 DM	484
	485	void sparc_floppy_irq(int irq, void dev_id, struct pt_regs regs)
	486	{
	487	struct pt_regs *old_regs;
	488	int cpu = smp_processor_id();
	489
	490	old_regs = set_irq_regs(regs);
	491	disable_pil_irq(irq);
	492	irq_enter();
	493	kstat_cpu(cpu).irqs[irq]++;
	494	floppy_irq_handler(irq, dev_id);
	495	irq_exit();
	496	enable_pil_irq(irq);
	497	set_irq_regs(old_regs);
	498	// XXX Eek, it's totally changed with preempt_count() and such
	499	// if (softirq_pending(cpu))
	500	// do_softirq();
	501	}
	502
	503	int sparc_floppy_request_irq(int irq, unsigned long flags,
7c239975	504	irq_handler_t irq_handler)
0a808a31 DM	505	{
	506	floppy_irq_handler = irq_handler;
	507	return request_fast_irq(irq, floppy_hardint, flags, "floppy");
	508	}
	509	EXPORT_SYMBOL(sparc_floppy_request_irq);
	510
	511	#endif
	512
1da177e4	513	int request_irq(unsigned int irq,
40220c1a	514	irq_handler_t handler,
1da177e4 LT	515	unsigned long irqflags, const char * devname, void *dev_id)
1da177e4 LT	516	{
a54123e2	517	struct irqaction * action, **actionp;
1da177e4 LT	518	unsigned long flags;
	519	unsigned int cpu_irq;
	520	int ret;
	521
	522	if (sparc_cpu_model == sun4d) {
	523	extern int sun4d_request_irq(unsigned int,
40220c1a	524	irq_handler_t ,
1da177e4 LT	525	unsigned long, const char , void );
	526	return sun4d_request_irq(irq, handler, irqflags, devname, dev_id);
	527	}
	528	cpu_irq = irq & (NR_IRQS - 1);
	529	if(cpu_irq > 14) {
	530	ret = -EINVAL;
	531	goto out;
	532	}
	533	if (!handler) {
	534	ret = -EINVAL;
	535	goto out;
	536	}
	537
	538	spin_lock_irqsave(&irq_action_lock, flags);
	539
a54123e2 BB	540	actionp = &sparc_irq[cpu_irq].action;
a54123e2 BB	541	action = *actionp;
1da177e4	542	if (action) {
67413202	543	if (!(action->flags & IRQF_SHARED) \|\| !(irqflags & IRQF_SHARED)) {
1da177e4 LT	544	ret = -EBUSY;
	545	goto out_unlock;
	546	}
67413202	547	if ((action->flags & IRQF_DISABLED) != (irqflags & IRQF_DISABLED)) {
1da177e4 LT	548	printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq);
	549	ret = -EBUSY;
	550	goto out_unlock;
a54123e2 BB	551	}
	552	for ( ; action; action = *actionp)
	553	actionp = &action->next;
1da177e4 LT	554	}
	555
	556	/* If this is flagged as statically allocated then we use our
	557	* private struct which is never freed.
	558	*/
	559	if (irqflags & SA_STATIC_ALLOC) {
	560	if (static_irq_count < MAX_STATIC_ALLOC)
	561	action = &static_irqaction[static_irq_count++];
	562	else
	563	printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname);
	564	}
	565
	566	if (action == NULL)
5cbded58	567	action = kmalloc(sizeof(struct irqaction),
1da177e4 LT	568	GFP_ATOMIC);
	569
	570	if (!action) {
	571	ret = -ENOMEM;
	572	goto out_unlock;
	573	}
	574
	575	action->handler = handler;
	576	action->flags = irqflags;
	577	cpus_clear(action->mask);
	578	action->name = devname;
	579	action->next = NULL;
	580	action->dev_id = dev_id;
	581
a54123e2	582	*actionp = action;
1da177e4	583
0f516813	584	__enable_irq(irq);
1da177e4 LT	585
	586	ret = 0;
	587	out_unlock:
	588	spin_unlock_irqrestore(&irq_action_lock, flags);
	589	out:
	590	return ret;
	591	}
	592
	593	EXPORT_SYMBOL(request_irq);
	594
0f516813 AV	595	void disable_irq_nosync(unsigned int irq)
0f516813 AV	596	{
81265fd9	597	__disable_irq(irq);
0f516813 AV	598	}
	599	EXPORT_SYMBOL(disable_irq_nosync);
	600
	601	void disable_irq(unsigned int irq)
	602	{
81265fd9	603	__disable_irq(irq);
0f516813 AV	604	}
	605	EXPORT_SYMBOL(disable_irq);
	606
	607	void enable_irq(unsigned int irq)
	608	{
81265fd9	609	__enable_irq(irq);
0f516813 AV	610	}
	611
	612	EXPORT_SYMBOL(enable_irq);
	613
1da177e4 LT	614	/* We really don't need these at all on the Sparc. We only have
	615	* stubs here because they are exported to modules.
	616	*/
	617	unsigned long probe_irq_on(void)
	618	{
	619	return 0;
	620	}
	621
	622	EXPORT_SYMBOL(probe_irq_on);
	623
	624	int probe_irq_off(unsigned long mask)
	625	{
	626	return 0;
	627	}
	628
	629	EXPORT_SYMBOL(probe_irq_off);
	630
	631	/* djhr
	632	* This could probably be made indirect too and assigned in the CPU
	633	* bits of the code. That would be much nicer I think and would also
	634	* fit in with the idea of being able to tune your kernel for your machine
	635	* by removing unrequired machine and device support.
	636	*
	637	*/
	638
	639	void __init init_IRQ(void)
	640	{
	641	extern void sun4c_init_IRQ( void );
	642	extern void sun4m_init_IRQ( void );
	643	extern void sun4d_init_IRQ( void );
	644
	645	switch(sparc_cpu_model) {
	646	case sun4c:
	647	case sun4:
	648	sun4c_init_IRQ();
	649	break;
	650
	651	case sun4m:
	652	#ifdef CONFIG_PCI
	653	pcic_probe();
	654	if (pcic_present()) {
	655	sun4m_pci_init_IRQ();
	656	break;
	657	}
	658	#endif
	659	sun4m_init_IRQ();
	660	break;
	661
	662	case sun4d:
	663	sun4d_init_IRQ();
	664	break;
	665
	666	default:
d1a78c32	667	prom_printf("Cannot initialize IRQs on this Sun machine...");
1da177e4 LT	668	break;
	669	}
	670	btfixup();
	671	}
	672
4696b64d	673	#ifdef CONFIG_PROC_FS
1da177e4 LT	674	void init_irq_proc(void)
	675	{
	676	/* For now, nothing... */
	677	}
4696b64d	678	#endif /* CONFIG_PROC_FS */