URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [uclinux/] [uClinux-2.0.x/] [arch/] [m68knommu/] [platform/] [68EZ328/] [ints.c] - Blame information for rev 1781

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * linux/arch/$(ARCH)/platform/$(PLATFORM)/ints.c
 *
 * 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/sched.h>
#include <linux/kernel_stat.h>
 
#include <asm/system.h>
#include <asm/irq.h>
#include <asm/traps.h>
#include <asm/io.h>
#include <asm/machdep.h>
#include <asm/setup.h>
 
#include <asm/MC68EZ328.h>
 
#define INTERNAL_IRQS (32)
 
/* 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 void bad_interrupt(void);
asmlinkage void inthandler(void);
asmlinkage void inthandler1(void);
asmlinkage void inthandler2(void);
asmlinkage void inthandler3(void);
asmlinkage void inthandler4(void);
asmlinkage void inthandler5(void);
asmlinkage void inthandler6(void);
asmlinkage void inthandler7(void);
 
extern void *_ramvec[];
 
/* irq node variables for the 32 (potential) on chip sources */
static irq_node_t *int_irq_list[INTERNAL_IRQS];
 
static int int_irq_count[INTERNAL_IRQS];
static short int_irq_ablecount[INTERNAL_IRQS];
 
static void int_badint(int irq, void *dev_id, struct pt_regs *fp)
{
        num_spurious += 1;
}
 
/*
 * This function should be called during kernel startup to initialize
 * the amiga IRQ handling routines.
 */
 
void M68EZ328_init_IRQ(void)
{
        int i;
 
        /* set up the vectors */
#if 0
        _ramvec[2] = buserr;
        _ramvec[3] = trap3;
        _ramvec[4] = trap4;
        _ramvec[5] = trap5;
        _ramvec[6] = trap6;
        _ramvec[7] = trap7;
        _ramvec[8] = trap8;
        _ramvec[9] = trap9;
        _ramvec[10] = trap10;
        _ramvec[11] = trap11;
        _ramvec[12] = trap12;
        _ramvec[13] = trap13;
        _ramvec[14] = trap14;
        _ramvec[15] = trap15;
#endif
        _ramvec[9] = trap9;
        _ramvec[32] = system_call;
        _ramvec[33] = trap33;
 
        _ramvec[64] = bad_interrupt;
        _ramvec[65] = inthandler1;
        _ramvec[66] = inthandler2;
        _ramvec[67] = inthandler3;
        _ramvec[68] = inthandler4;
        _ramvec[69] = inthandler5;
        _ramvec[70] = inthandler6;
        _ramvec[71] = inthandler7;
 
        IVR = 0x40; /* Set DragonBall IVR (interrupt base) to 64 */
 
        /* initialize handlers */
        for (i = 0; i < INTERNAL_IRQS; i++) {
                int_irq_list[i] = NULL;
 
                int_irq_ablecount[i] = 0;
                int_irq_count[i] = 0;
        }
        /* turn off all interrupts */
        IMR = ~0;
}
 
void M68EZ328_insert_irq(irq_node_t **list, irq_node_t *node)
{
        unsigned long flags;
        irq_node_t *cur;
 
        if (!node->dev_id)
                printk("%s: Warning: dev_id of %s is zero\n",
                       __FUNCTION__, node->devname);
 
        save_flags(flags);
        cli();
 
        cur = *list;
 
        while (cur) {
                list = &cur->next;
                cur = cur->next;
        }
 
        node->next = cur;
        *list = node;
 
        restore_flags(flags);
}
 
void M68EZ328_delete_irq(irq_node_t **list, void *dev_id)
{
        unsigned long flags;
        irq_node_t *node;
 
        save_flags(flags);
        cli();
 
        for (node = *list; node; list = &node->next, node = *list) {
                if (node->dev_id == dev_id) {
                        *list = node->next;
                        /* Mark it as free. */
                        node->handler = NULL;
                        restore_flags(flags);
                        return;
                }
        }
        restore_flags(flags);
        printk ("%s: tried to remove invalid irq\n", __FUNCTION__);
}
 
int M68EZ328_request_irq(unsigned int irq, void (*handler)(int, void *, struct pt_regs *),
                         unsigned long flags, const char *devname, void *dev_id)
{
        if (irq >= INTERNAL_IRQS) {
                printk ("%s: Unknown IRQ %d from %s\n", __FUNCTION__, irq, devname);
                return -ENXIO;
        }
 
        if (!int_irq_list[irq]) {
                int_irq_list[irq] = new_irq_node();
                int_irq_list[irq]->flags   = IRQ_FLG_STD;
        }
 
        if (!(int_irq_list[irq]->flags & IRQ_FLG_STD)) {
                if (int_irq_list[irq]->flags & IRQ_FLG_LOCK) {
                        printk("%s: IRQ %d from %s is not replaceable\n",
                               __FUNCTION__, irq, int_irq_list[irq]->devname);
                        return -EBUSY;
                }
                if (flags & IRQ_FLG_REPLACE) {
                        printk("%s: %s can't replace IRQ %d from %s\n",
                               __FUNCTION__, devname, irq, int_irq_list[irq]->devname);
                        return -EBUSY;
                }
        }
        int_irq_list[irq]->handler = handler;
        int_irq_list[irq]->flags   = flags;
        int_irq_list[irq]->dev_id  = dev_id;
        int_irq_list[irq]->devname = devname;
 
        /* enable in the IMR */
        if (!int_irq_ablecount[irq])
                *(volatile unsigned long *)0xfffff304 &= ~(1<<irq);
 
        return 0;
}
 
void M68EZ328_free_irq(unsigned int irq, void *dev_id)
{
        if (irq >= INTERNAL_IRQS) {
                printk ("%s: Unknown IRQ %d\n", __FUNCTION__, irq);
                return;
        }
 
        if (int_irq_list[irq]->dev_id != dev_id)
                printk("%s: removing probably wrong IRQ %d from %s\n",
                       __FUNCTION__, irq, int_irq_list[irq]->devname);
        int_irq_list[irq]->handler = int_badint;
        int_irq_list[irq]->flags   = IRQ_FLG_STD;
        int_irq_list[irq]->dev_id  = NULL;
        int_irq_list[irq]->devname = NULL;
 
        *(volatile unsigned long *)0xfffff304 |= 1<<irq;
}
 
/*
 * Enable/disable a particular machine specific interrupt source.
 * Note that this may affect other interrupts in case of a shared interrupt.
 * This function should only be called for a _very_ short time to change some
 * internal data, that may not be changed by the interrupt at the same time.
 * int_(enable|disable)_irq calls may also be nested.
 */
 
void M68EZ328_enable_irq(unsigned int irq)
{
        if (irq >= INTERNAL_IRQS) {
                printk("%s: Unknown IRQ %d\n", __FUNCTION__, irq);
                return;
        }
 
        if (--int_irq_ablecount[irq])
                return;
 
        /* enable the interrupt */
        *(volatile unsigned long *)0xfffff304 &= ~(1<<irq);
}
 
void M68EZ328_disable_irq(unsigned int irq)
{
        if (irq >= INTERNAL_IRQS) {
                printk("%s: Unknown IRQ %d\n", __FUNCTION__, irq);
                return;
        }
 
        if (int_irq_ablecount[irq]++)
                return;
 
        /* disable the interrupt */
        *(volatile unsigned long *)0xfffff304 |= 1<<irq;
}
 
/* 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!
 */
inline int M68EZ328_do_irq(int vec, struct pt_regs *fp)
{
        int irq;
        int mask;
 
        unsigned long pend = *(volatile unsigned long *)0xfffff30c;
 
        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++;
                }
 
                if (int_irq_list[irq] && int_irq_list[irq]->handler) {
                        int_irq_list[irq]->handler(irq | IRQ_MACHSPEC, int_irq_list[irq]->dev_id, fp);
                        int_irq_count[irq]++;
                } else {
                        printk("unregistered interrupt %d!\nTurning it off in the IMR...\n", irq);
                        *(volatile unsigned long *)0xfffff304 |= mask;
                }
                pend &= ~mask;
        }
        return 0;
}
 
int M68EZ328_get_irq_list(char *buf)
{
        int i, len = 0;
        irq_node_t *node;
 
        len += sprintf(buf+len, "Internal 68EZ328 interrupts\n");
 
        for (i = 0; i < INTERNAL_IRQS; i++) {
                if (!(node = int_irq_list[i]))
                        continue;
                if (!(node->handler))
                        continue;
 
                len += sprintf(buf+len, " %2d: %10u    %s\n", i,
                               int_irq_count[i], int_irq_list[i]->devname);
        }
        return len;
}
 
void config_M68EZ328_irq(void)
{
        mach_default_handler = NULL;
        mach_init_IRQ        = M68EZ328_init_IRQ;
        mach_request_irq     = M68EZ328_request_irq;
        mach_free_irq        = M68EZ328_free_irq;
        mach_enable_irq      = M68EZ328_enable_irq;
        mach_disable_irq     = M68EZ328_disable_irq;
        mach_get_irq_list    = M68EZ328_get_irq_list;
        mach_process_int     = M68EZ328_do_irq;
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [uclinux/] [uClinux-2.0.x/] [arch/] [m68knommu/] [platform/] [68EZ328/] [ints.c] - Blame information for rev 1781

Line No.	Rev	Author	Line
1	199	simons	`/*`
2			`* linux/arch/$(ARCH)/platform/$(PLATFORM)/ints.c`
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
12			`#include <linux/types.h>`
13			`#include <linux/kernel.h>`
14			`#include <linux/sched.h>`
15			`#include <linux/kernel_stat.h>`
16
17			`#include <asm/system.h>`
18			`#include <asm/irq.h>`
19			`#include <asm/traps.h>`
20			`#include <asm/io.h>`
21			`#include <asm/machdep.h>`
22			`#include <asm/setup.h>`
23
24			`#include <asm/MC68EZ328.h>`
25
26			`#define INTERNAL_IRQS (32)`
27
28			`/* assembler routines */`
29			`asmlinkage void system_call(void);`
30			`asmlinkage void buserr(void);`
31			`asmlinkage void trap(void);`
32			`asmlinkage void trap3(void);`
33			`asmlinkage void trap4(void);`
34			`asmlinkage void trap5(void);`
35			`asmlinkage void trap6(void);`
36			`asmlinkage void trap7(void);`
37			`asmlinkage void trap8(void);`
38			`asmlinkage void trap9(void);`
39			`asmlinkage void trap10(void);`
40			`asmlinkage void trap11(void);`
41			`asmlinkage void trap12(void);`
42			`asmlinkage void trap13(void);`
43			`asmlinkage void trap14(void);`
44			`asmlinkage void trap15(void);`
45			`asmlinkage void trap33(void);`
46			`asmlinkage void trap34(void);`
47			`asmlinkage void trap35(void);`
48			`asmlinkage void trap36(void);`
49			`asmlinkage void trap37(void);`
50			`asmlinkage void trap38(void);`
51			`asmlinkage void trap39(void);`
52			`asmlinkage void trap40(void);`
53			`asmlinkage void trap41(void);`
54			`asmlinkage void trap42(void);`
55			`asmlinkage void trap43(void);`
56			`asmlinkage void trap44(void);`
57			`asmlinkage void trap45(void);`
58			`asmlinkage void trap46(void);`
59			`asmlinkage void trap47(void);`
60			`asmlinkage void bad_interrupt(void);`
61			`asmlinkage void inthandler(void);`
62			`asmlinkage void inthandler1(void);`
63			`asmlinkage void inthandler2(void);`
64			`asmlinkage void inthandler3(void);`
65			`asmlinkage void inthandler4(void);`
66			`asmlinkage void inthandler5(void);`
67			`asmlinkage void inthandler6(void);`
68			`asmlinkage void inthandler7(void);`
69
70			`extern void *_ramvec[];`
71
72			`/* irq node variables for the 32 (potential) on chip sources */`
73			`static irq_node_t *int_irq_list[INTERNAL_IRQS];`
74
75			`static int int_irq_count[INTERNAL_IRQS];`
76			`static short int_irq_ablecount[INTERNAL_IRQS];`
77
78			`static void int_badint(int irq, void dev_id, struct pt_regs fp)`
79			`{`
80			`num_spurious += 1;`
81			`}`
82
83			`/*`
84			`* This function should be called during kernel startup to initialize`
85			`* the amiga IRQ handling routines.`
86			`*/`
87
88			`void M68EZ328_init_IRQ(void)`
89			`{`
90			`int i;`
91
92			`/* set up the vectors */`
93			`#if 0`
94			`_ramvec[2] = buserr;`
95			`_ramvec[3] = trap3;`
96			`_ramvec[4] = trap4;`
97			`_ramvec[5] = trap5;`
98			`_ramvec[6] = trap6;`
99			`_ramvec[7] = trap7;`
100			`_ramvec[8] = trap8;`
101			`_ramvec[9] = trap9;`
102			`_ramvec[10] = trap10;`
103			`_ramvec[11] = trap11;`
104			`_ramvec[12] = trap12;`
105			`_ramvec[13] = trap13;`
106			`_ramvec[14] = trap14;`
107			`_ramvec[15] = trap15;`
108			`#endif`
109			`_ramvec[9] = trap9;`
110			`_ramvec[32] = system_call;`
111			`_ramvec[33] = trap33;`
112
113			`_ramvec[64] = bad_interrupt;`
114			`_ramvec[65] = inthandler1;`
115			`_ramvec[66] = inthandler2;`
116			`_ramvec[67] = inthandler3;`
117			`_ramvec[68] = inthandler4;`
118			`_ramvec[69] = inthandler5;`
119			`_ramvec[70] = inthandler6;`
120			`_ramvec[71] = inthandler7;`
121
122			`IVR = 0x40; /* Set DragonBall IVR (interrupt base) to 64 */`
123
124			`/* initialize handlers */`
125			`for (i = 0; i < INTERNAL_IRQS; i++) {`
126			`int_irq_list[i] = NULL;`
127
128			`int_irq_ablecount[i] = 0;`
129			`int_irq_count[i] = 0;`
130			`}`
131			`/* turn off all interrupts */`
132			`IMR = ~0;`
133			`}`
134
135			`void M68EZ328_insert_irq(irq_node_t *list, irq_node_t node)`
136			`{`
137			`unsigned long flags;`
138			`irq_node_t *cur;`
139
140			`if (!node->dev_id)`
141			`printk("%s: Warning: dev_id of %s is zero\n",`
142			`__FUNCTION__, node->devname);`
143
144			`save_flags(flags);`
145			`cli();`
146
147			`cur = *list;`
148
149			`while (cur) {`
150			`list = &cur->next;`
151			`cur = cur->next;`
152			`}`
153
154			`node->next = cur;`
155			`*list = node;`
156
157			`restore_flags(flags);`
158			`}`
159
160			`void M68EZ328_delete_irq(irq_node_t *list, void dev_id)`
161			`{`
162			`unsigned long flags;`
163			`irq_node_t *node;`
164
165			`save_flags(flags);`
166			`cli();`
167
168			`for (node = list; node; list = &node->next, node = list) {`
169			`if (node->dev_id == dev_id) {`
170			`*list = node->next;`
171			`/* Mark it as free. */`
172			`node->handler = NULL;`
173			`restore_flags(flags);`
174			`return;`
175			`}`
176			`}`
177			`restore_flags(flags);`
178			`printk ("%s: tried to remove invalid irq\n", __FUNCTION__);`
179			`}`
180
181			`int M68EZ328_request_irq(unsigned int irq, void (handler)(int, void , struct pt_regs *),`
182			`unsigned long flags, const char devname, void dev_id)`
183			`{`
184			`if (irq >= INTERNAL_IRQS) {`
185			`printk ("%s: Unknown IRQ %d from %s\n", __FUNCTION__, irq, devname);`
186			`return -ENXIO;`
187			`}`
188
189			`if (!int_irq_list[irq]) {`
190			`int_irq_list[irq] = new_irq_node();`
191			`int_irq_list[irq]->flags = IRQ_FLG_STD;`
192			`}`
193
194			`if (!(int_irq_list[irq]->flags & IRQ_FLG_STD)) {`
195			`if (int_irq_list[irq]->flags & IRQ_FLG_LOCK) {`
196			`printk("%s: IRQ %d from %s is not replaceable\n",`
197			`__FUNCTION__, irq, int_irq_list[irq]->devname);`
198			`return -EBUSY;`
199			`}`
200			`if (flags & IRQ_FLG_REPLACE) {`
201			`printk("%s: %s can't replace IRQ %d from %s\n",`
202			`__FUNCTION__, devname, irq, int_irq_list[irq]->devname);`
203			`return -EBUSY;`
204			`}`
205			`}`
206			`int_irq_list[irq]->handler = handler;`
207			`int_irq_list[irq]->flags = flags;`
208			`int_irq_list[irq]->dev_id = dev_id;`
209			`int_irq_list[irq]->devname = devname;`
210
211			`/* enable in the IMR */`
212			`if (!int_irq_ablecount[irq])`
213			`(volatile unsigned long )0xfffff304 &= ~(1<<irq);`
214
215			`return 0;`
216			`}`
217
218			`void M68EZ328_free_irq(unsigned int irq, void *dev_id)`
219			`{`
220			`if (irq >= INTERNAL_IRQS) {`
221			`printk ("%s: Unknown IRQ %d\n", __FUNCTION__, irq);`
222			`return;`
223			`}`
224
225			`if (int_irq_list[irq]->dev_id != dev_id)`
226			`printk("%s: removing probably wrong IRQ %d from %s\n",`
227			`__FUNCTION__, irq, int_irq_list[irq]->devname);`
228			`int_irq_list[irq]->handler = int_badint;`
229			`int_irq_list[irq]->flags = IRQ_FLG_STD;`
230			`int_irq_list[irq]->dev_id = NULL;`
231			`int_irq_list[irq]->devname = NULL;`
232
233			`(volatile unsigned long )0xfffff304 \|= 1<<irq;`
234			`}`
235
236			`/*`
237			`* Enable/disable a particular machine specific interrupt source.`
238			`* Note that this may affect other interrupts in case of a shared interrupt.`
239			`* This function should only be called for a _very_ short time to change some`
240			`* internal data, that may not be changed by the interrupt at the same time.`
241			`* int_(enable\|disable)_irq calls may also be nested.`
242			`*/`
243
244			`void M68EZ328_enable_irq(unsigned int irq)`
245			`{`
246			`if (irq >= INTERNAL_IRQS) {`
247			`printk("%s: Unknown IRQ %d\n", __FUNCTION__, irq);`
248			`return;`
249			`}`
250
251			`if (--int_irq_ablecount[irq])`
252			`return;`
253
254			`/* enable the interrupt */`
255			`(volatile unsigned long )0xfffff304 &= ~(1<<irq);`
256			`}`
257
258			`void M68EZ328_disable_irq(unsigned int irq)`
259			`{`
260			`if (irq >= INTERNAL_IRQS) {`
261			`printk("%s: Unknown IRQ %d\n", __FUNCTION__, irq);`
262			`return;`
263			`}`
264
265			`if (int_irq_ablecount[irq]++)`
266			`return;`
267
268			`/* disable the interrupt */`
269			`(volatile unsigned long )0xfffff304 \|= 1<<irq;`
270			`}`
271
272			`/* The 68k family did not have a good way to determine the source`
273			`* of interrupts until later in the family. The EC000 core does`
274			`* not provide the vector number on the stack, we vector everything`
275			`* into one vector and look in the blasted mask register...`
276			`* This code is designed to be fast, almost constant time, not clean!`
277			`*/`
278			`inline int M68EZ328_do_irq(int vec, struct pt_regs *fp)`
279			`{`
280			`int irq;`
281			`int mask;`
282
283			`unsigned long pend = (volatile unsigned long )0xfffff30c;`
284
285			`while (pend) {`
286			`if (pend & 0x0000ffff) {`
287			`if (pend & 0x000000ff) {`
288			`if (pend & 0x0000000f) {`
289			`mask = 0x00000001;`
290			`irq = 0;`
291			`} else {`
292			`mask = 0x00000010;`
293			`irq = 4;`
294			`}`
295			`} else {`
296			`if (pend & 0x00000f00) {`
297			`mask = 0x00000100;`
298			`irq = 8;`
299			`} else {`
300			`mask = 0x00001000;`
301			`irq = 12;`
302			`}`
303			`}`
304			`} else {`
305			`if (pend & 0x00ff0000) {`
306			`if (pend & 0x000f0000) {`
307			`mask = 0x00010000;`
308			`irq = 16;`
309			`} else {`
310			`mask = 0x00100000;`
311			`irq = 20;`
312			`}`
313			`} else {`
314			`if (pend & 0x0f000000) {`
315			`mask = 0x01000000;`
316			`irq = 24;`
317			`} else {`
318			`mask = 0x10000000;`
319			`irq = 28;`
320			`}`
321			`}`
322			`}`
323
324			`while (! (mask & pend)) {`
325			`mask <<=1;`
326			`irq++;`
327			`}`
328
329			`if (int_irq_list[irq] && int_irq_list[irq]->handler) {`
330			`int_irq_list[irq]->handler(irq \| IRQ_MACHSPEC, int_irq_list[irq]->dev_id, fp);`
331			`int_irq_count[irq]++;`
332			`} else {`
333			`printk("unregistered interrupt %d!\nTurning it off in the IMR...\n", irq);`
334			`(volatile unsigned long )0xfffff304 \|= mask;`
335			`}`
336			`pend &= ~mask;`
337			`}`
338			`return 0;`
339			`}`
340
341			`int M68EZ328_get_irq_list(char *buf)`
342			`{`
343			`int i, len = 0;`
344			`irq_node_t *node;`
345
346			`len += sprintf(buf+len, "Internal 68EZ328 interrupts\n");`
347
348			`for (i = 0; i < INTERNAL_IRQS; i++) {`
349			`if (!(node = int_irq_list[i]))`
350			`continue;`
351			`if (!(node->handler))`
352			`continue;`
353
354			`len += sprintf(buf+len, " %2d: %10u %s\n", i,`
355			`int_irq_count[i], int_irq_list[i]->devname);`
356			`}`
357			`return len;`
358			`}`
359
360			`void config_M68EZ328_irq(void)`
361			`{`
362			`mach_default_handler = NULL;`
363			`mach_init_IRQ = M68EZ328_init_IRQ;`
364			`mach_request_irq = M68EZ328_request_irq;`
365			`mach_free_irq = M68EZ328_free_irq;`
366			`mach_enable_irq = M68EZ328_enable_irq;`
367			`mach_disable_irq = M68EZ328_disable_irq;`
368			`mach_get_irq_list = M68EZ328_get_irq_list;`
369			`mach_process_int = M68EZ328_do_irq;`
370			`}`