[deliverable/linux.git] / arch / m68k / 68000 / ints.c

/*
 * ints.c - Generic interrupt controller support
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file COPYING in the main directory of this archive
 * for more details.
 *
 * Copyright 1996 Roman Zippel
 * Copyright 1999 D. Jeff Dionne <jeff@rt-control.com>
 */

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <asm/traps.h>
#include <asm/io.h>
#include <asm/machdep.h>

#if defined(CONFIG_M68328)
#include <asm/MC68328.h>
#elif defined(CONFIG_M68EZ328)
#include <asm/MC68EZ328.h>
#elif defined(CONFIG_M68VZ328)
#include <asm/MC68VZ328.h>
#endif

/* assembler routines */
asmlinkage void system_call(void);
asmlinkage void buserr(void);
asmlinkage void trap(void);
asmlinkage void trap3(void);
asmlinkage void trap4(void);
asmlinkage void trap5(void);
asmlinkage void trap6(void);
asmlinkage void trap7(void);
asmlinkage void trap8(void);
asmlinkage void trap9(void);
asmlinkage void trap10(void);
asmlinkage void trap11(void);
asmlinkage void trap12(void);
asmlinkage void trap13(void);
asmlinkage void trap14(void);
asmlinkage void trap15(void);
asmlinkage void trap33(void);
asmlinkage void trap34(void);
asmlinkage void trap35(void);
asmlinkage void trap36(void);
asmlinkage void trap37(void);
asmlinkage void trap38(void);
asmlinkage void trap39(void);
asmlinkage void trap40(void);
asmlinkage void trap41(void);
asmlinkage void trap42(void);
asmlinkage void trap43(void);
asmlinkage void trap44(void);
asmlinkage void trap45(void);
asmlinkage void trap46(void);
asmlinkage void trap47(void);
asmlinkage irqreturn_t bad_interrupt(int, void *);
asmlinkage irqreturn_t inthandler(void);
asmlinkage irqreturn_t inthandler1(void);
asmlinkage irqreturn_t inthandler2(void);
asmlinkage irqreturn_t inthandler3(void);
asmlinkage irqreturn_t inthandler4(void);
asmlinkage irqreturn_t inthandler5(void);
asmlinkage irqreturn_t inthandler6(void);
asmlinkage irqreturn_t inthandler7(void);

/* The 68k family did not have a good way to determine the source
 * of interrupts until later in the family.  The EC000 core does
 * not provide the vector number on the stack, we vector everything
 * into one vector and look in the blasted mask register...
 * This code is designed to be fast, almost constant time, not clean!
 */
void process_int(int vec, struct pt_regs *fp)
{
	int irq;
	int mask;

	unsigned long pend = ISR;

	while (pend) {
		if (pend & 0x0000ffff) {
			if (pend & 0x000000ff) {
				if (pend & 0x0000000f) {
					mask = 0x00000001;
					irq = 0;
				} else {
					mask = 0x00000010;
					irq = 4;
				}
			} else {
				if (pend & 0x00000f00) {
					mask = 0x00000100;
					irq = 8;
				} else {
					mask = 0x00001000;
					irq = 12;
				}
			}
		} else {
			if (pend & 0x00ff0000) {
				if (pend & 0x000f0000) {
					mask = 0x00010000;
					irq = 16;
				} else {
					mask = 0x00100000;
					irq = 20;
				}
			} else {
				if (pend & 0x0f000000) {
					mask = 0x01000000;
					irq = 24;
				} else {
					mask = 0x10000000;
					irq = 28;
				}
			}
		}

		while (! (mask & pend)) {
			mask <<=1;
			irq++;
		}

		do_IRQ(irq, fp);
		pend &= ~mask;
	}
}

static void intc_irq_unmask(struct irq_data *d)
{
	IMR &= ~(1 << d->irq);
}

static void intc_irq_mask(struct irq_data *d)
{
	IMR |= (1 << d->irq);
}

static struct irq_chip intc_irq_chip = {
	.name		= "M68K-INTC",
	.irq_mask	= intc_irq_mask,
	.irq_unmask	= intc_irq_unmask,
};

/*
 * This function should be called during kernel startup to initialize
 * the machine vector table.
 */
void __init trap_init(void)
{
	int i;

	/* set up the vectors */
	for (i = 72; i < 256; ++i)
		_ramvec[i] = (e_vector) bad_interrupt;

	_ramvec[32] = system_call;

	_ramvec[65] = (e_vector) inthandler1;
	_ramvec[66] = (e_vector) inthandler2;
	_ramvec[67] = (e_vector) inthandler3;
	_ramvec[68] = (e_vector) inthandler4;
	_ramvec[69] = (e_vector) inthandler5;
	_ramvec[70] = (e_vector) inthandler6;
	_ramvec[71] = (e_vector) inthandler7;
}

void __init init_IRQ(void)
{
	int i;

	IVR = 0x40; /* Set DragonBall IVR (interrupt base) to 64 */

	/* turn off all interrupts */
	IMR = ~0;

	for (i = 0; (i < NR_IRQS); i++) {
		irq_set_chip(i, &intc_irq_chip);
		irq_set_handler(i, handle_level_irq);
	}
}
Commit	Line	Data
1da177e4	1	/*
99e08374	2	* ints.c - Generic interrupt controller support
1da177e4 LT	3	*
	4	* This file is subject to the terms and conditions of the GNU General Public
	5	* License. See the file COPYING in the main directory of this archive
	6	* for more details.
	7	*
	8	* Copyright 1996 Roman Zippel
	9	* Copyright 1999 D. Jeff Dionne <jeff@rt-control.com>
	10	*/
	11
1da177e4 LT	12	#include <linux/types.h>
1da177e4 LT	13	#include <linux/kernel.h>
2502b667	14	#include <linux/init.h>
8668fb5d	15	#include <linux/interrupt.h>
2502b667	16	#include <linux/irq.h>
1da177e4 LT	17	#include <asm/traps.h>
	18	#include <asm/io.h>
	19	#include <asm/machdep.h>
1da177e4 LT	20
	21	#if defined(CONFIG_M68328)
	22	#include <asm/MC68328.h>
	23	#elif defined(CONFIG_M68EZ328)
	24	#include <asm/MC68EZ328.h>
	25	#elif defined(CONFIG_M68VZ328)
	26	#include <asm/MC68VZ328.h>
	27	#endif
	28
	29	/* assembler routines */
	30	asmlinkage void system_call(void);
	31	asmlinkage void buserr(void);
	32	asmlinkage void trap(void);
	33	asmlinkage void trap3(void);
	34	asmlinkage void trap4(void);
	35	asmlinkage void trap5(void);
	36	asmlinkage void trap6(void);
	37	asmlinkage void trap7(void);
	38	asmlinkage void trap8(void);
	39	asmlinkage void trap9(void);
	40	asmlinkage void trap10(void);
	41	asmlinkage void trap11(void);
	42	asmlinkage void trap12(void);
	43	asmlinkage void trap13(void);
	44	asmlinkage void trap14(void);
	45	asmlinkage void trap15(void);
	46	asmlinkage void trap33(void);
	47	asmlinkage void trap34(void);
	48	asmlinkage void trap35(void);
	49	asmlinkage void trap36(void);
	50	asmlinkage void trap37(void);
	51	asmlinkage void trap38(void);
	52	asmlinkage void trap39(void);
	53	asmlinkage void trap40(void);
	54	asmlinkage void trap41(void);
	55	asmlinkage void trap42(void);
	56	asmlinkage void trap43(void);
	57	asmlinkage void trap44(void);
	58	asmlinkage void trap45(void);
	59	asmlinkage void trap46(void);
	60	asmlinkage void trap47(void);
8668fb5d	61	asmlinkage irqreturn_t bad_interrupt(int, void *);
1da177e4 LT	62	asmlinkage irqreturn_t inthandler(void);
	63	asmlinkage irqreturn_t inthandler1(void);
	64	asmlinkage irqreturn_t inthandler2(void);
	65	asmlinkage irqreturn_t inthandler3(void);
	66	asmlinkage irqreturn_t inthandler4(void);
	67	asmlinkage irqreturn_t inthandler5(void);
	68	asmlinkage irqreturn_t inthandler6(void);
	69	asmlinkage irqreturn_t inthandler7(void);
	70
1da177e4 LT	71	/* The 68k family did not have a good way to determine the source
	72	* of interrupts until later in the family. The EC000 core does
	73	* not provide the vector number on the stack, we vector everything
	74	* into one vector and look in the blasted mask register...
	75	* This code is designed to be fast, almost constant time, not clean!
	76	*/
	77	void process_int(int vec, struct pt_regs *fp)
	78	{
	79	int irq;
	80	int mask;
	81
	82	unsigned long pend = ISR;
	83
	84	while (pend) {
	85	if (pend & 0x0000ffff) {
	86	if (pend & 0x000000ff) {
	87	if (pend & 0x0000000f) {
	88	mask = 0x00000001;
	89	irq = 0;
	90	} else {
	91	mask = 0x00000010;
	92	irq = 4;
	93	}
	94	} else {
	95	if (pend & 0x00000f00) {
	96	mask = 0x00000100;
	97	irq = 8;
	98	} else {
	99	mask = 0x00001000;
	100	irq = 12;
	101	}
	102	}
	103	} else {
	104	if (pend & 0x00ff0000) {
	105	if (pend & 0x000f0000) {
	106	mask = 0x00010000;
	107	irq = 16;
	108	} else {
	109	mask = 0x00100000;
	110	irq = 20;
	111	}
	112	} else {
	113	if (pend & 0x0f000000) {
	114	mask = 0x01000000;
	115	irq = 24;
	116	} else {
	117	mask = 0x10000000;
	118	irq = 28;
	119	}
	120	}
	121	}
	122
	123	while (! (mask & pend)) {
	124	mask <<=1;
	125	irq++;
	126	}
	127
2502b667	128	do_IRQ(irq, fp);
1da177e4 LT	129	pend &= ~mask;
	130	}
	131	}
2502b667	132
39a17940	133	static void intc_irq_unmask(struct irq_data *d)
2502b667	134	{
39a17940	135	IMR &= ~(1 << d->irq);
2502b667 GU	136	}
2502b667 GU	137
39a17940	138	static void intc_irq_mask(struct irq_data *d)
2502b667	139	{
39a17940	140	IMR \|= (1 << d->irq);
2502b667 GU	141	}
2502b667 GU	142
1985d253 GU	143	static struct irq_chip intc_irq_chip = {
1985d253 GU	144	.name = "M68K-INTC",
39a17940 TG	145	.irq_mask = intc_irq_mask,
39a17940 TG	146	.irq_unmask = intc_irq_unmask,
1985d253 GU	147	};
	148
	149	/*
	150	* This function should be called during kernel startup to initialize
	151	* the machine vector table.
	152	*/
622e9472	153	void __init trap_init(void)
2502b667	154	{
1985d253 GU	155	int i;
	156
	157	/* set up the vectors */
	158	for (i = 72; i < 256; ++i)
	159	_ramvec[i] = (e_vector) bad_interrupt;
	160
	161	_ramvec[32] = system_call;
	162
	163	_ramvec[65] = (e_vector) inthandler1;
	164	_ramvec[66] = (e_vector) inthandler2;
	165	_ramvec[67] = (e_vector) inthandler3;
	166	_ramvec[68] = (e_vector) inthandler4;
	167	_ramvec[69] = (e_vector) inthandler5;
	168	_ramvec[70] = (e_vector) inthandler6;
	169	_ramvec[71] = (e_vector) inthandler7;
622e9472 GU	170	}
	171
	172	void __init init_IRQ(void)
	173	{
	174	int i;
1985d253 GU	175
	176	IVR = 0x40; /* Set DragonBall IVR (interrupt base) to 64 */
	177
	178	/* turn off all interrupts */
	179	IMR = ~0;
	180
	181	for (i = 0; (i < NR_IRQS); i++) {
0b98b163 TG	182	irq_set_chip(i, &intc_irq_chip);
0b98b163 TG	183	irq_set_handler(i, handle_level_irq);
1985d253	184	}
2502b667 GU	185	}
2502b667 GU	186