Remove obsolete #include <linux/config.h>
[linux-2.6.git] / arch / m68knommu / platform / 68360 / ints.c
1 /*
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 (c) 2000  Michael Leslie <mleslie@lineo.com>
9  * Copyright (c) 1996 Roman Zippel
10  * Copyright (c) 1999 D. Jeff Dionne <jeff@uclinux.org>
11  */
12
13 #include <linux/module.h>
14 #include <linux/types.h>
15 #include <linux/kernel.h>
16 #include <linux/sched.h>
17 #include <linux/kernel_stat.h>
18 #include <linux/errno.h>
19
20 #include <asm/system.h>
21 #include <asm/irq.h>
22 #include <asm/irqnode.h>
23 #include <asm/traps.h>
24 #include <asm/io.h>
25 #include <asm/machdep.h>
26 #include <asm/setup.h>
27 #include <asm/m68360.h>
28
29 /* from quicc/commproc.c: */
30 extern QUICC *pquicc;
31 extern void cpm_interrupt_init(void);
32
33 #define INTERNAL_IRQS (96)
34
35 /* assembler routines */
36 asmlinkage void system_call(void);
37 asmlinkage void buserr(void);
38 asmlinkage void trap(void);
39 asmlinkage irqreturn_t bad_interrupt(void);
40 asmlinkage irqreturn_t inthandler(void);
41
42 extern void *_ramvec[];
43
44 /* The number of spurious interrupts */
45 volatile unsigned int num_spurious;
46 unsigned int local_irq_count[NR_CPUS];
47
48 /* irq node variables for the 32 (potential) on chip sources */
49 static irq_node_t int_irq_list[INTERNAL_IRQS];
50
51 static short int_irq_ablecount[INTERNAL_IRQS];
52
53 /*
54  * This function should be called during kernel startup to initialize
55  * IRQ handling routines.
56  */
57
58 void init_IRQ(void)
59 {
60         int i;
61         int vba = (CPM_VECTOR_BASE<<4);
62
63         /* set up the vectors */
64         _ramvec[2] = buserr;
65         _ramvec[3] = trap;
66         _ramvec[4] = trap;
67         _ramvec[5] = trap;
68         _ramvec[6] = trap;
69         _ramvec[7] = trap;
70         _ramvec[8] = trap;
71         _ramvec[9] = trap;
72         _ramvec[10] = trap;
73         _ramvec[11] = trap;
74         _ramvec[12] = trap;
75         _ramvec[13] = trap;
76         _ramvec[14] = trap;
77         _ramvec[15] = trap;
78
79         _ramvec[32] = system_call;
80         _ramvec[33] = trap;
81
82
83         cpm_interrupt_init();
84
85         /* set up CICR for vector base address and irq level */
86         /* irl = 4, hp = 1f - see MC68360UM p 7-377 */
87         pquicc->intr_cicr = 0x00e49f00 | vba;
88
89         /* CPM interrupt vectors: (p 7-376) */
90         _ramvec[vba+CPMVEC_ERROR]       = bad_interrupt; /* Error */
91         _ramvec[vba+CPMVEC_PIO_PC11]    = inthandler;   /* pio - pc11 */
92         _ramvec[vba+CPMVEC_PIO_PC10]    = inthandler;   /* pio - pc10 */
93         _ramvec[vba+CPMVEC_SMC2]        = inthandler;   /* smc2/pip */
94         _ramvec[vba+CPMVEC_SMC1]        = inthandler;   /* smc1 */
95         _ramvec[vba+CPMVEC_SPI]         = inthandler;   /* spi */
96         _ramvec[vba+CPMVEC_PIO_PC9]     = inthandler;   /* pio - pc9 */
97         _ramvec[vba+CPMVEC_TIMER4]      = inthandler;   /* timer 4 */
98         _ramvec[vba+CPMVEC_RESERVED1]   = inthandler;   /* reserved */
99         _ramvec[vba+CPMVEC_PIO_PC8]     = inthandler;   /* pio - pc8 */
100         _ramvec[vba+CPMVEC_PIO_PC7]     = inthandler;  /* pio - pc7 */
101         _ramvec[vba+CPMVEC_PIO_PC6]     = inthandler;  /* pio - pc6 */
102         _ramvec[vba+CPMVEC_TIMER3]      = inthandler;  /* timer 3 */
103         _ramvec[vba+CPMVEC_RISCTIMER]   = inthandler;  /* reserved */
104         _ramvec[vba+CPMVEC_PIO_PC5]     = inthandler;  /* pio - pc5 */
105         _ramvec[vba+CPMVEC_PIO_PC4]     = inthandler;  /* pio - pc4 */
106         _ramvec[vba+CPMVEC_RESERVED2]   = inthandler;  /* reserved */
107         _ramvec[vba+CPMVEC_RISCTIMER]   = inthandler;  /* timer table */
108         _ramvec[vba+CPMVEC_TIMER2]      = inthandler;  /* timer 2 */
109         _ramvec[vba+CPMVEC_RESERVED3]   = inthandler;  /* reserved */
110         _ramvec[vba+CPMVEC_IDMA2]       = inthandler;  /* idma 2 */
111         _ramvec[vba+CPMVEC_IDMA1]       = inthandler;  /* idma 1 */
112         _ramvec[vba+CPMVEC_SDMA_CB_ERR] = inthandler;  /* sdma channel bus error */
113         _ramvec[vba+CPMVEC_PIO_PC3]     = inthandler;  /* pio - pc3 */
114         _ramvec[vba+CPMVEC_PIO_PC2]     = inthandler;  /* pio - pc2 */
115         /* _ramvec[vba+CPMVEC_TIMER1]      = cpm_isr_timer1; */  /* timer 1 */
116         _ramvec[vba+CPMVEC_TIMER1]      = inthandler;  /* timer 1 */
117         _ramvec[vba+CPMVEC_PIO_PC1]     = inthandler;  /* pio - pc1 */
118         _ramvec[vba+CPMVEC_SCC4]        = inthandler;  /* scc 4 */
119         _ramvec[vba+CPMVEC_SCC3]        = inthandler;  /* scc 3 */
120         _ramvec[vba+CPMVEC_SCC2]        = inthandler;  /* scc 2 */
121         _ramvec[vba+CPMVEC_SCC1]        = inthandler;  /* scc 1 */
122         _ramvec[vba+CPMVEC_PIO_PC0]     = inthandler;  /* pio - pc0 */
123
124
125         /* turn off all CPM interrupts */
126         pquicc->intr_cimr = 0x00000000;
127
128         /* initialize handlers */
129         for (i = 0; i < INTERNAL_IRQS; i++) {
130                 int_irq_list[i].handler = NULL;
131                 int_irq_list[i].flags   = IRQ_FLG_STD;
132                 int_irq_list[i].dev_id  = NULL;
133                 int_irq_list[i].devname = NULL;
134         }
135 }
136
137 #if 0
138 void M68360_insert_irq(irq_node_t **list, irq_node_t *node)
139 {
140         unsigned long flags;
141         irq_node_t *cur;
142
143         if (!node->dev_id)
144                 printk(KERN_INFO "%s: Warning: dev_id of %s is zero\n",
145                        __FUNCTION__, node->devname);
146
147         local_irq_save(flags);
148
149         cur = *list;
150
151         while (cur) {
152                 list = &cur->next;
153                 cur = cur->next;
154         }
155
156         node->next = cur;
157         *list = node;
158
159         local_irq_restore(flags);
160 }
161
162 void M68360_delete_irq(irq_node_t **list, void *dev_id)
163 {
164         unsigned long flags;
165         irq_node_t *node;
166
167         local_irq_save(flags);
168
169         for (node = *list; node; list = &node->next, node = *list) {
170                 if (node->dev_id == dev_id) {
171                         *list = node->next;
172                         /* Mark it as free. */
173                         node->handler = NULL;
174                         local_irq_restore(flags);
175                         return;
176                 }
177         }
178         local_irq_restore(flags);
179         printk (KERN_INFO "%s: tried to remove invalid irq\n", __FUNCTION__);
180 }
181 #endif
182
183 int request_irq(
184         unsigned int irq,
185         irqreturn_t (*handler)(int, void *, struct pt_regs *),
186         unsigned long flags,
187         const char *devname,
188         void *dev_id)
189 {
190         int mask = (1<<irq);
191
192         irq += (CPM_VECTOR_BASE<<4);
193
194         if (irq >= INTERNAL_IRQS) {
195                 printk (KERN_ERR "%s: Unknown IRQ %d from %s\n", __FUNCTION__, irq, devname);
196                 return -ENXIO;
197         }
198
199         if (!(int_irq_list[irq].flags & IRQ_FLG_STD)) {
200                 if (int_irq_list[irq].flags & IRQ_FLG_LOCK) {
201                         printk(KERN_ERR "%s: IRQ %d from %s is not replaceable\n",
202                                __FUNCTION__, irq, int_irq_list[irq].devname);
203                         return -EBUSY;
204                 }
205                 if (flags & IRQ_FLG_REPLACE) {
206                         printk(KERN_ERR "%s: %s can't replace IRQ %d from %s\n",
207                                __FUNCTION__, devname, irq, int_irq_list[irq].devname);
208                         return -EBUSY;
209                 }
210         }
211         int_irq_list[irq].handler = handler;
212         int_irq_list[irq].flags   = flags;
213         int_irq_list[irq].dev_id  = dev_id;
214         int_irq_list[irq].devname = devname;
215
216         /* enable in the CIMR */
217         if (!int_irq_ablecount[irq])
218                 pquicc->intr_cimr |= mask;
219         /*      *(volatile unsigned long *)0xfffff304 &= ~(1<<irq); */
220
221         return 0;
222 }
223
224 EXPORT_SYMBOL(request_irq);
225
226 void free_irq(unsigned int irq, void *dev_id)
227 {
228         if (irq >= INTERNAL_IRQS) {
229                 printk (KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq);
230                 return;
231         }
232
233         if (int_irq_list[irq].dev_id != dev_id)
234                 printk(KERN_INFO "%s: removing probably wrong IRQ %d from %s\n",
235                        __FUNCTION__, irq, int_irq_list[irq].devname);
236         int_irq_list[irq].handler = NULL;
237         int_irq_list[irq].flags   = IRQ_FLG_STD;
238         int_irq_list[irq].dev_id  = NULL;
239         int_irq_list[irq].devname = NULL;
240
241         *(volatile unsigned long *)0xfffff304 |= 1<<irq;
242 }
243
244 EXPORT_SYMBOL(free_irq);
245
246 #if 0
247 /*
248  * Enable/disable a particular machine specific interrupt source.
249  * Note that this may affect other interrupts in case of a shared interrupt.
250  * This function should only be called for a _very_ short time to change some
251  * internal data, that may not be changed by the interrupt at the same time.
252  * int_(enable|disable)_irq calls may also be nested.
253  */
254 void M68360_enable_irq(unsigned int irq)
255 {
256         if (irq >= INTERNAL_IRQS) {
257                 printk(KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq);
258                 return;
259         }
260
261         if (--int_irq_ablecount[irq])
262                 return;
263
264         /* enable the interrupt */
265         *(volatile unsigned long *)0xfffff304 &= ~(1<<irq);
266 }
267
268 void M68360_disable_irq(unsigned int irq)
269 {
270         if (irq >= INTERNAL_IRQS) {
271                 printk(KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq);
272                 return;
273         }
274
275         if (int_irq_ablecount[irq]++)
276                 return;
277
278         /* disable the interrupt */
279         *(volatile unsigned long *)0xfffff304 |= 1<<irq;
280 }
281 #endif
282
283 int show_interrupts(struct seq_file *p, void *v)
284 {
285         int i = *(loff_t *) v;
286
287         if (i < NR_IRQS) {
288                 if (int_irq_list[i].devname) {
289                         seq_printf(p, "%3d: %10u ", i, kstat_cpu(0).irqs[i]);
290                         if (int_irq_list[i].flags & IRQ_FLG_LOCK)
291                                 seq_printf(p, "L ");
292                         else
293                                 seq_printf(p, "  ");
294                         seq_printf(p, "%s\n", int_irq_list[i].devname);
295                 }
296         }
297         if (i == NR_IRQS)
298                 seq_printf(p, "   : %10u   spurious\n", num_spurious);
299
300         return 0;
301 }
302
303 /* The 68k family did not have a good way to determine the source
304  * of interrupts until later in the family.  The EC000 core does
305  * not provide the vector number on the stack, we vector everything
306  * into one vector and look in the blasted mask register...
307  * This code is designed to be fast, almost constant time, not clean!
308  */
309 void process_int(int vec, struct pt_regs *fp)
310 {
311         int irq;
312         int mask;
313
314         /* unsigned long pend = *(volatile unsigned long *)0xfffff30c; */
315
316         /* irq = vec + (CPM_VECTOR_BASE<<4); */
317         irq = vec;
318
319         /* unsigned long pend = *(volatile unsigned long *)pquicc->intr_cipr; */
320
321         /* Bugger all that weirdness. For the moment, I seem to know where I came from;
322          * vec is passed from a specific ISR, so I'll use it. */
323
324         if (int_irq_list[irq].handler) {
325                 int_irq_list[irq].handler(irq , int_irq_list[irq].dev_id, fp);
326                 kstat_cpu(0).irqs[irq]++;
327                 pquicc->intr_cisr = (1 << vec); /* indicate that irq has been serviced */
328         } else {
329                 printk(KERN_ERR "unregistered interrupt %d!\nTurning it off in the CIMR...\n", irq);
330                 /* *(volatile unsigned long *)0xfffff304 |= mask; */
331                 pquicc->intr_cimr &= ~(1 << vec);
332                 num_spurious += 1;
333         }
334         return(IRQ_HANDLED);
335 }