e2d47b7bdfc1748b0591e118ea7e7e14123f5bfe
[linux-2.6.git] / arch / m68k / amiga / amiints.c
1 /*
2  * linux/arch/m68k/amiga/amiints.c -- Amiga Linux interrupt handling code
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  * 11/07/96: rewritten interrupt handling, irq lists are exists now only for
9  *           this sources where it makes sense (VERTB/PORTS/EXTER) and you must
10  *           be careful that dev_id for this sources is unique since this the
11  *           only possibility to distinguish between different handlers for
12  *           free_irq. irq lists also have different irq flags:
13  *           - IRQ_FLG_FAST: handler is inserted at top of list (after other
14  *                           fast handlers)
15  *           - IRQ_FLG_SLOW: handler is inserted at bottom of list and before
16  *                           they're executed irq level is set to the previous
17  *                           one, but handlers don't need to be reentrant, if
18  *                           reentrance occurred, slow handlers will be just
19  *                           called again.
20  *           The whole interrupt handling for CIAs is moved to cia.c
21  *           /Roman Zippel
22  *
23  * 07/08/99: rewamp of the interrupt handling - we now have two types of
24  *           interrupts, normal and fast handlers, fast handlers being
25  *           marked with SA_INTERRUPT and runs with all other interrupts
26  *           disabled. Normal interrupts disable their own source but
27  *           run with all other interrupt sources enabled.
28  *           PORTS and EXTER interrupts are always shared even if the
29  *           drivers do not explicitly mark this when calling
30  *           request_irq which they really should do.
31  *           This is similar to the way interrupts are handled on all
32  *           other architectures and makes a ton of sense besides
33  *           having the advantage of making it easier to share
34  *           drivers.
35  *           /Jes
36  */
37
38 #include <linux/types.h>
39 #include <linux/kernel.h>
40 #include <linux/sched.h>
41 #include <linux/kernel_stat.h>
42 #include <linux/init.h>
43 #include <linux/interrupt.h>
44 #include <linux/errno.h>
45 #include <linux/seq_file.h>
46
47 #include <asm/system.h>
48 #include <asm/irq.h>
49 #include <asm/traps.h>
50 #include <asm/amigahw.h>
51 #include <asm/amigaints.h>
52 #include <asm/amipcmcia.h>
53
54 extern int cia_request_irq(struct ciabase *base,int irq,
55                            irqreturn_t (*handler)(int, void *, struct pt_regs *),
56                            unsigned long flags, const char *devname, void *dev_id);
57 extern void cia_free_irq(struct ciabase *base, unsigned int irq, void *dev_id);
58 extern void cia_init_IRQ(struct ciabase *base);
59 extern int cia_get_irq_list(struct ciabase *base, struct seq_file *p);
60
61 /* irq node variables for amiga interrupt sources */
62 static irq_node_t *ami_irq_list[AMI_STD_IRQS];
63
64 static unsigned short amiga_intena_vals[AMI_STD_IRQS] = {
65         [IRQ_AMIGA_VERTB-IRQ_USER]      = IF_VERTB,
66         [IRQ_AMIGA_COPPER-IRQ_USER]     = IF_COPER,
67         [IRQ_AMIGA_AUD0-IRQ_USER]       = IF_AUD0,
68         [IRQ_AMIGA_AUD1-IRQ_USER]       = IF_AUD1,
69         [IRQ_AMIGA_AUD2-IRQ_USER]       = IF_AUD2,
70         [IRQ_AMIGA_AUD3-IRQ_USER]       = IF_AUD3,
71         [IRQ_AMIGA_BLIT-IRQ_USER]       = IF_BLIT,
72         [IRQ_AMIGA_DSKSYN-IRQ_USER]     = IF_DSKSYN,
73         [IRQ_AMIGA_DSKBLK-IRQ_USER]     = IF_DSKBLK,
74         [IRQ_AMIGA_RBF-IRQ_USER]        = IF_RBF,
75         [IRQ_AMIGA_TBE-IRQ_USER]        = IF_TBE,
76         [IRQ_AMIGA_SOFT-IRQ_USER]       = IF_SOFT,
77         [IRQ_AMIGA_PORTS-IRQ_USER]      = IF_PORTS,
78         [IRQ_AMIGA_EXTER-IRQ_USER]      = IF_EXTER
79 };
80 static const unsigned char ami_servers[AMI_STD_IRQS] = {
81         [IRQ_AMIGA_VERTB-IRQ_USER]      = 1,
82         [IRQ_AMIGA_PORTS-IRQ_USER]      = 1,
83         [IRQ_AMIGA_EXTER-IRQ_USER]      = 1
84 };
85
86 static short ami_ablecount[AMI_IRQS];
87
88 static irqreturn_t ami_badint(int irq, void *dev_id, struct pt_regs *fp)
89 {
90         num_spurious += 1;
91         return IRQ_NONE;
92 }
93
94 /*
95  * void amiga_init_IRQ(void)
96  *
97  * Parameters:  None
98  *
99  * Returns:     Nothing
100  *
101  * This function should be called during kernel startup to initialize
102  * the amiga IRQ handling routines.
103  */
104
105 void __init amiga_init_IRQ(void)
106 {
107         int i;
108
109         /* initialize handlers */
110         for (i = 0; i < AMI_STD_IRQS; i++) {
111                 if (ami_servers[i]) {
112                         ami_irq_list[i] = NULL;
113                 } else {
114                         ami_irq_list[i] = new_irq_node();
115                         ami_irq_list[i]->handler = ami_badint;
116                         ami_irq_list[i]->flags   = 0;
117                         ami_irq_list[i]->dev_id  = NULL;
118                         ami_irq_list[i]->devname = NULL;
119                         ami_irq_list[i]->next    = NULL;
120                 }
121         }
122         for (i = 0; i < AMI_IRQS; i++)
123                 ami_ablecount[i] = 0;
124
125         /* turn off PCMCIA interrupts */
126         if (AMIGAHW_PRESENT(PCMCIA))
127                 gayle.inten = GAYLE_IRQ_IDE;
128
129         /* turn off all interrupts and enable the master interrupt bit */
130         amiga_custom.intena = 0x7fff;
131         amiga_custom.intreq = 0x7fff;
132         amiga_custom.intena = IF_SETCLR | IF_INTEN;
133
134         cia_init_IRQ(&ciaa_base);
135         cia_init_IRQ(&ciab_base);
136 }
137
138 static inline int amiga_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("%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         if (node->flags & SA_INTERRUPT) {
152                 if (node->flags & SA_SHIRQ)
153                         return -EBUSY;
154                 /*
155                  * There should never be more than one
156                  */
157                 while (cur && cur->flags & SA_INTERRUPT) {
158                         list = &cur->next;
159                         cur = cur->next;
160                 }
161         } else {
162                 while (cur) {
163                         list = &cur->next;
164                         cur = cur->next;
165                 }
166         }
167
168         node->next = cur;
169         *list = node;
170
171         local_irq_restore(flags);
172         return 0;
173 }
174
175 static inline void amiga_delete_irq(irq_node_t **list, void *dev_id)
176 {
177         unsigned long flags;
178         irq_node_t *node;
179
180         local_irq_save(flags);
181
182         for (node = *list; node; list = &node->next, node = *list) {
183                 if (node->dev_id == dev_id) {
184                         *list = node->next;
185                         /* Mark it as free. */
186                         node->handler = NULL;
187                         local_irq_restore(flags);
188                         return;
189                 }
190         }
191         local_irq_restore(flags);
192         printk ("%s: tried to remove invalid irq\n", __FUNCTION__);
193 }
194
195 /*
196  * amiga_request_irq : add an interrupt service routine for a particular
197  *                     machine specific interrupt source.
198  *                     If the addition was successful, it returns 0.
199  */
200
201 int amiga_request_irq(unsigned int irq,
202                       irqreturn_t (*handler)(int, void *, struct pt_regs *),
203                       unsigned long flags, const char *devname, void *dev_id)
204 {
205         irq_node_t *node;
206         int error = 0;
207
208         if (irq >= AMI_IRQS) {
209                 printk ("%s: Unknown IRQ %d from %s\n", __FUNCTION__,
210                         irq, devname);
211                 return -ENXIO;
212         }
213
214         if (irq < IRQ_USER)
215                 return cpu_request_irq(irq, handler, flags, devname, dev_id);
216
217         if (irq >= IRQ_AMIGA_CIAB)
218                 return cia_request_irq(&ciab_base, irq - IRQ_AMIGA_CIAB,
219                                        handler, flags, devname, dev_id);
220
221         if (irq >= IRQ_AMIGA_CIAA)
222                 return cia_request_irq(&ciaa_base, irq - IRQ_AMIGA_CIAA,
223                                        handler, flags, devname, dev_id);
224
225         irq -= IRQ_USER;
226         /*
227          * IRQ_AMIGA_PORTS & IRQ_AMIGA_EXTER defaults to shared,
228          * we could add a check here for the SA_SHIRQ flag but all drivers
229          * should be aware of sharing anyway.
230          */
231         if (ami_servers[irq]) {
232                 if (!(node = new_irq_node()))
233                         return -ENOMEM;
234                 node->handler = handler;
235                 node->flags   = flags;
236                 node->dev_id  = dev_id;
237                 node->devname = devname;
238                 node->next    = NULL;
239                 error = amiga_insert_irq(&ami_irq_list[irq], node);
240         } else {
241                 ami_irq_list[irq]->handler = handler;
242                 ami_irq_list[irq]->flags   = flags;
243                 ami_irq_list[irq]->dev_id  = dev_id;
244                 ami_irq_list[irq]->devname = devname;
245         }
246
247         /* enable the interrupt */
248         if (irq < IRQ_AMIGA_PORTS && !ami_ablecount[irq])
249                 amiga_custom.intena = IF_SETCLR | amiga_intena_vals[irq];
250
251         return error;
252 }
253
254 void amiga_free_irq(unsigned int irq, void *dev_id)
255 {
256         if (irq >= AMI_IRQS) {
257                 printk ("%s: Unknown IRQ %d\n", __FUNCTION__, irq);
258                 return;
259         }
260
261         if (irq < IRQ_USER)
262                 cpu_free_irq(irq, dev_id);
263
264         if (irq >= IRQ_AMIGA_CIAB) {
265                 cia_free_irq(&ciab_base, irq - IRQ_AMIGA_CIAB, dev_id);
266                 return;
267         }
268
269         if (irq >= IRQ_AMIGA_CIAA) {
270                 cia_free_irq(&ciaa_base, irq - IRQ_AMIGA_CIAA, dev_id);
271                 return;
272         }
273
274         irq -= IRQ_USER;
275         if (ami_servers[irq]) {
276                 amiga_delete_irq(&ami_irq_list[irq], dev_id);
277                 /* if server list empty, disable the interrupt */
278                 if (!ami_irq_list[irq] && irq < IRQ_AMIGA_PORTS)
279                         amiga_custom.intena = amiga_intena_vals[irq];
280         } else {
281                 if (ami_irq_list[irq]->dev_id != dev_id)
282                         printk("%s: removing probably wrong IRQ %d from %s\n",
283                                __FUNCTION__, irq, ami_irq_list[irq]->devname);
284                 ami_irq_list[irq]->handler = ami_badint;
285                 ami_irq_list[irq]->flags   = 0;
286                 ami_irq_list[irq]->dev_id  = NULL;
287                 ami_irq_list[irq]->devname = NULL;
288                 amiga_custom.intena = amiga_intena_vals[irq];
289         }
290 }
291
292 /*
293  * Enable/disable a particular machine specific interrupt source.
294  * Note that this may affect other interrupts in case of a shared interrupt.
295  * This function should only be called for a _very_ short time to change some
296  * internal data, that may not be changed by the interrupt at the same time.
297  * ami_(enable|disable)_irq calls may also be nested.
298  */
299
300 void amiga_enable_irq(unsigned int irq)
301 {
302         if (irq >= AMI_IRQS) {
303                 printk("%s: Unknown IRQ %d\n", __FUNCTION__, irq);
304                 return;
305         }
306
307         if (--ami_ablecount[irq])
308                 return;
309
310         /* No action for auto-vector interrupts */
311         if (irq < IRQ_USER) {
312                 printk("%s: Trying to enable auto-vector IRQ %i\n",
313                        __FUNCTION__, irq);
314                 return;
315         }
316
317         if (irq >= IRQ_AMIGA_CIAB) {
318                 cia_set_irq(&ciab_base, (1 << (irq - IRQ_AMIGA_CIAB)));
319                 cia_able_irq(&ciab_base, CIA_ICR_SETCLR |
320                              (1 << (irq - IRQ_AMIGA_CIAB)));
321                 return;
322         }
323
324         if (irq >= IRQ_AMIGA_CIAA) {
325                 cia_set_irq(&ciaa_base, (1 << (irq - IRQ_AMIGA_CIAA)));
326                 cia_able_irq(&ciaa_base, CIA_ICR_SETCLR |
327                              (1 << (irq - IRQ_AMIGA_CIAA)));
328                 return;
329         }
330
331         /* enable the interrupt */
332         amiga_custom.intena = IF_SETCLR | amiga_intena_vals[irq-IRQ_USER];
333 }
334
335 void amiga_disable_irq(unsigned int irq)
336 {
337         if (irq >= AMI_IRQS) {
338                 printk("%s: Unknown IRQ %d\n", __FUNCTION__, irq);
339                 return;
340         }
341
342         if (ami_ablecount[irq]++)
343                 return;
344
345         /* No action for auto-vector interrupts */
346         if (irq < IRQ_USER) {
347                 printk("%s: Trying to disable auto-vector IRQ %i\n",
348                        __FUNCTION__, irq);
349                 return;
350         }
351
352         if (irq >= IRQ_AMIGA_CIAB) {
353                 cia_able_irq(&ciab_base, 1 << (irq - IRQ_AMIGA_CIAB));
354                 return;
355         }
356
357         if (irq >= IRQ_AMIGA_CIAA) {
358                 cia_able_irq(&ciaa_base, 1 << (irq - IRQ_AMIGA_CIAA));
359                 return;
360         }
361
362         /* disable the interrupt */
363         amiga_custom.intena = amiga_intena_vals[irq-IRQ_USER];
364 }
365
366 inline void amiga_do_irq(int irq, struct pt_regs *fp)
367 {
368         kstat_cpu(0).irqs[irq]++;
369         ami_irq_list[irq-IRQ_USER]->handler(irq, ami_irq_list[irq-IRQ_USER]->dev_id, fp);
370 }
371
372 void amiga_do_irq_list(int irq, struct pt_regs *fp)
373 {
374         irq_node_t *node;
375
376         kstat_cpu(0).irqs[irq]++;
377
378         amiga_custom.intreq = amiga_intena_vals[irq-IRQ_USER];
379
380         for (node = ami_irq_list[irq-IRQ_USER]; node; node = node->next)
381                 node->handler(irq, node->dev_id, fp);
382 }
383
384 /*
385  * The builtin Amiga hardware interrupt handlers.
386  */
387
388 static irqreturn_t ami_int1(int irq, void *dev_id, struct pt_regs *fp)
389 {
390         unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
391
392         /* if serial transmit buffer empty, interrupt */
393         if (ints & IF_TBE) {
394                 amiga_custom.intreq = IF_TBE;
395                 amiga_do_irq(IRQ_AMIGA_TBE, fp);
396         }
397
398         /* if floppy disk transfer complete, interrupt */
399         if (ints & IF_DSKBLK) {
400                 amiga_custom.intreq = IF_DSKBLK;
401                 amiga_do_irq(IRQ_AMIGA_DSKBLK, fp);
402         }
403
404         /* if software interrupt set, interrupt */
405         if (ints & IF_SOFT) {
406                 amiga_custom.intreq = IF_SOFT;
407                 amiga_do_irq(IRQ_AMIGA_SOFT, fp);
408         }
409         return IRQ_HANDLED;
410 }
411
412 static irqreturn_t ami_int3(int irq, void *dev_id, struct pt_regs *fp)
413 {
414         unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
415
416         /* if a blitter interrupt */
417         if (ints & IF_BLIT) {
418                 amiga_custom.intreq = IF_BLIT;
419                 amiga_do_irq(IRQ_AMIGA_BLIT, fp);
420         }
421
422         /* if a copper interrupt */
423         if (ints & IF_COPER) {
424                 amiga_custom.intreq = IF_COPER;
425                 amiga_do_irq(IRQ_AMIGA_COPPER, fp);
426         }
427
428         /* if a vertical blank interrupt */
429         if (ints & IF_VERTB)
430                 amiga_do_irq_list(IRQ_AMIGA_VERTB, fp);
431         return IRQ_HANDLED;
432 }
433
434 static irqreturn_t ami_int4(int irq, void *dev_id, struct pt_regs *fp)
435 {
436         unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
437
438         /* if audio 0 interrupt */
439         if (ints & IF_AUD0) {
440                 amiga_custom.intreq = IF_AUD0;
441                 amiga_do_irq(IRQ_AMIGA_AUD0, fp);
442         }
443
444         /* if audio 1 interrupt */
445         if (ints & IF_AUD1) {
446                 amiga_custom.intreq = IF_AUD1;
447                 amiga_do_irq(IRQ_AMIGA_AUD1, fp);
448         }
449
450         /* if audio 2 interrupt */
451         if (ints & IF_AUD2) {
452                 amiga_custom.intreq = IF_AUD2;
453                 amiga_do_irq(IRQ_AMIGA_AUD2, fp);
454         }
455
456         /* if audio 3 interrupt */
457         if (ints & IF_AUD3) {
458                 amiga_custom.intreq = IF_AUD3;
459                 amiga_do_irq(IRQ_AMIGA_AUD3, fp);
460         }
461         return IRQ_HANDLED;
462 }
463
464 static irqreturn_t ami_int5(int irq, void *dev_id, struct pt_regs *fp)
465 {
466         unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
467
468         /* if serial receive buffer full interrupt */
469         if (ints & IF_RBF) {
470                 /* acknowledge of IF_RBF must be done by the serial interrupt */
471                 amiga_do_irq(IRQ_AMIGA_RBF, fp);
472         }
473
474         /* if a disk sync interrupt */
475         if (ints & IF_DSKSYN) {
476                 amiga_custom.intreq = IF_DSKSYN;
477                 amiga_do_irq(IRQ_AMIGA_DSKSYN, fp);
478         }
479         return IRQ_HANDLED;
480 }
481
482 static irqreturn_t ami_int7(int irq, void *dev_id, struct pt_regs *fp)
483 {
484         panic ("level 7 interrupt received\n");
485 }
486
487 irqreturn_t (*amiga_default_handler[SYS_IRQS])(int, void *, struct pt_regs *) = {
488         [1] = ami_int1,
489         [3] = ami_int3,
490         [4] = ami_int4,
491         [5] = ami_int5,
492         [7] = ami_int7
493 };
494
495 int show_amiga_interrupts(struct seq_file *p, void *v)
496 {
497         int i;
498         irq_node_t *node;
499
500         for (i = IRQ_USER; i < IRQ_AMIGA_CIAA; i++) {
501                 node = ami_irq_list[i - IRQ_USER];
502                 if (!node)
503                         continue;
504                 seq_printf(p, "ami  %2d: %10u ", i,
505                                kstat_cpu(0).irqs[i]);
506                 do {
507                         if (node->flags & SA_INTERRUPT)
508                                 seq_puts(p, "F ");
509                         else
510                                 seq_puts(p, "  ");
511                         seq_printf(p, "%s\n", node->devname);
512                         if ((node = node->next))
513                                 seq_puts(p, "                    ");
514                 } while (node);
515         }
516
517         cia_get_irq_list(&ciaa_base, p);
518         cia_get_irq_list(&ciab_base, p);
519         return 0;
520 }