m68k/irq: Rename {,__}m68k_handle_int()
[linux-3.10.git] / arch / m68k / mac / oss.c
1 /*
2  *      OSS handling
3  *      Written by Joshua M. Thompson (funaho@jurai.org)
4  *
5  *
6  *      This chip is used in the IIfx in place of VIA #2. It acts like a fancy
7  *      VIA chip with prorammable interrupt levels.
8  *
9  * 990502 (jmt) - Major rewrite for new interrupt architecture as well as some
10  *                recent insights into OSS operational details.
11  * 990610 (jmt) - Now taking full advantage of the OSS. Interrupts are mapped
12  *                to mostly match the A/UX interrupt scheme supported on the
13  *                VIA side. Also added support for enabling the ISM irq again
14  *                since we now have a functional IOP manager.
15  */
16
17 #include <linux/types.h>
18 #include <linux/kernel.h>
19 #include <linux/mm.h>
20 #include <linux/delay.h>
21 #include <linux/init.h>
22
23 #include <asm/bootinfo.h>
24 #include <asm/macintosh.h>
25 #include <asm/macints.h>
26 #include <asm/mac_via.h>
27 #include <asm/mac_oss.h>
28
29 int oss_present;
30 volatile struct mac_oss *oss;
31
32 static irqreturn_t oss_irq(int, void *);
33 static irqreturn_t oss_nubus_irq(int, void *);
34
35 extern irqreturn_t via1_irq(int, void *);
36
37 /*
38  * Initialize the OSS
39  *
40  * The OSS "detection" code is actually in via_init() which is always called
41  * before us. Thus we can count on oss_present being valid on entry.
42  */
43
44 void __init oss_init(void)
45 {
46         int i;
47
48         if (!oss_present) return;
49
50         oss = (struct mac_oss *) OSS_BASE;
51
52         /* Disable all interrupts. Unlike a VIA it looks like we    */
53         /* do this by setting the source's interrupt level to zero. */
54
55         for (i = 0; i <= OSS_NUM_SOURCES; i++) {
56                 oss->irq_level[i] = OSS_IRQLEV_DISABLED;
57         }
58         /* If we disable VIA1 here, we never really handle it... */
59         oss->irq_level[OSS_VIA1] = OSS_IRQLEV_VIA1;
60 }
61
62 /*
63  * Register the OSS and NuBus interrupt dispatchers.
64  */
65
66 void __init oss_register_interrupts(void)
67 {
68         if (request_irq(OSS_IRQLEV_SCSI, oss_irq, IRQ_FLG_LOCK,
69                         "scsi", (void *) oss))
70                 pr_err("Couldn't register %s interrupt\n", "scsi");
71         if (request_irq(OSS_IRQLEV_NUBUS, oss_nubus_irq, IRQ_FLG_LOCK,
72                         "nubus", (void *) oss))
73                 pr_err("Couldn't register %s interrupt\n", "nubus");
74         if (request_irq(OSS_IRQLEV_SOUND, oss_irq, IRQ_FLG_LOCK,
75                         "sound", (void *) oss))
76                 pr_err("Couldn't register %s interrupt\n", "sound");
77         if (request_irq(OSS_IRQLEV_VIA1, via1_irq, IRQ_FLG_LOCK,
78                         "via1", (void *) via1))
79                 pr_err("Couldn't register %s interrupt\n", "via1");
80 }
81
82 /*
83  * Initialize OSS for Nubus access
84  */
85
86 void __init oss_nubus_init(void)
87 {
88 }
89
90 /*
91  * Handle miscellaneous OSS interrupts. Right now that's just sound
92  * and SCSI; everything else is routed to its own autovector IRQ.
93  */
94
95 static irqreturn_t oss_irq(int irq, void *dev_id)
96 {
97         int events;
98
99         events = oss->irq_pending & (OSS_IP_SOUND|OSS_IP_SCSI);
100         if (!events)
101                 return IRQ_NONE;
102
103 #ifdef DEBUG_IRQS
104         if ((console_loglevel == 10) && !(events & OSS_IP_SCSI)) {
105                 printk("oss_irq: irq %d events = 0x%04X\n", irq,
106                         (int) oss->irq_pending);
107         }
108 #endif
109         /* FIXME: how do you clear a pending IRQ?    */
110
111         if (events & OSS_IP_SOUND) {
112                 oss->irq_pending &= ~OSS_IP_SOUND;
113                 /* FIXME: call sound handler */
114         } else if (events & OSS_IP_SCSI) {
115                 oss->irq_pending &= ~OSS_IP_SCSI;
116                 generic_handle_irq(IRQ_MAC_SCSI);
117         } else {
118                 /* FIXME: error check here? */
119         }
120         return IRQ_HANDLED;
121 }
122
123 /*
124  * Nubus IRQ handler, OSS style
125  *
126  * Unlike the VIA/RBV this is on its own autovector interrupt level.
127  */
128
129 static irqreturn_t oss_nubus_irq(int irq, void *dev_id)
130 {
131         int events, irq_bit, i;
132
133         events = oss->irq_pending & OSS_IP_NUBUS;
134         if (!events)
135                 return IRQ_NONE;
136
137 #ifdef DEBUG_NUBUS_INT
138         if (console_loglevel > 7) {
139                 printk("oss_nubus_irq: events = 0x%04X\n", events);
140         }
141 #endif
142         /* There are only six slots on the OSS, not seven */
143
144         i = 6;
145         irq_bit = 0x40;
146         do {
147                 --i;
148                 irq_bit >>= 1;
149                 if (events & irq_bit) {
150                         oss->irq_pending &= ~irq_bit;
151                         generic_handle_irq(NUBUS_SOURCE_BASE + i);
152                 }
153         } while(events & (irq_bit - 1));
154         return IRQ_HANDLED;
155 }
156
157 /*
158  * Enable an OSS interrupt
159  *
160  * It looks messy but it's rather straightforward. The switch() statement
161  * just maps the machspec interrupt numbers to the right OSS interrupt
162  * source (if the OSS handles that interrupt) and then sets the interrupt
163  * level for that source to nonzero, thus enabling the interrupt.
164  */
165
166 void oss_irq_enable(int irq) {
167 #ifdef DEBUG_IRQUSE
168         printk("oss_irq_enable(%d)\n", irq);
169 #endif
170         switch(irq) {
171                 case IRQ_MAC_SCC:
172                         oss->irq_level[OSS_IOPSCC] = OSS_IRQLEV_IOPSCC;
173                         break;
174                 case IRQ_MAC_ADB:
175                         oss->irq_level[OSS_IOPISM] = OSS_IRQLEV_IOPISM;
176                         break;
177                 case IRQ_MAC_SCSI:
178                         oss->irq_level[OSS_SCSI] = OSS_IRQLEV_SCSI;
179                         break;
180                 case IRQ_NUBUS_9:
181                 case IRQ_NUBUS_A:
182                 case IRQ_NUBUS_B:
183                 case IRQ_NUBUS_C:
184                 case IRQ_NUBUS_D:
185                 case IRQ_NUBUS_E:
186                         irq -= NUBUS_SOURCE_BASE;
187                         oss->irq_level[irq] = OSS_IRQLEV_NUBUS;
188                         break;
189 #ifdef DEBUG_IRQUSE
190                 default:
191                         printk("%s unknown irq %d\n", __func__, irq);
192                         break;
193 #endif
194         }
195 }
196
197 /*
198  * Disable an OSS interrupt
199  *
200  * Same as above except we set the source's interrupt level to zero,
201  * to disable the interrupt.
202  */
203
204 void oss_irq_disable(int irq) {
205 #ifdef DEBUG_IRQUSE
206         printk("oss_irq_disable(%d)\n", irq);
207 #endif
208         switch(irq) {
209                 case IRQ_MAC_SCC:
210                         oss->irq_level[OSS_IOPSCC] = OSS_IRQLEV_DISABLED;
211                         break;
212                 case IRQ_MAC_ADB:
213                         oss->irq_level[OSS_IOPISM] = OSS_IRQLEV_DISABLED;
214                         break;
215                 case IRQ_MAC_SCSI:
216                         oss->irq_level[OSS_SCSI] = OSS_IRQLEV_DISABLED;
217                         break;
218                 case IRQ_NUBUS_9:
219                 case IRQ_NUBUS_A:
220                 case IRQ_NUBUS_B:
221                 case IRQ_NUBUS_C:
222                 case IRQ_NUBUS_D:
223                 case IRQ_NUBUS_E:
224                         irq -= NUBUS_SOURCE_BASE;
225                         oss->irq_level[irq] = OSS_IRQLEV_DISABLED;
226                         break;
227 #ifdef DEBUG_IRQUSE
228                 default:
229                         printk("%s unknown irq %d\n", __func__, irq);
230                         break;
231 #endif
232         }
233 }
234
235 /*
236  * Clear an OSS interrupt
237  *
238  * Not sure if this works or not but it's the only method I could
239  * think of based on the contents of the mac_oss structure.
240  */
241
242 void oss_irq_clear(int irq) {
243         /* FIXME: how to do this on OSS? */
244         switch(irq) {
245                 case IRQ_MAC_SCC:
246                         oss->irq_pending &= ~OSS_IP_IOPSCC;
247                         break;
248                 case IRQ_MAC_ADB:
249                         oss->irq_pending &= ~OSS_IP_IOPISM;
250                         break;
251                 case IRQ_MAC_SCSI:
252                         oss->irq_pending &= ~OSS_IP_SCSI;
253                         break;
254                 case IRQ_NUBUS_9:
255                 case IRQ_NUBUS_A:
256                 case IRQ_NUBUS_B:
257                 case IRQ_NUBUS_C:
258                 case IRQ_NUBUS_D:
259                 case IRQ_NUBUS_E:
260                         irq -= NUBUS_SOURCE_BASE;
261                         oss->irq_pending &= ~(1 << irq);
262                         break;
263         }
264 }
265
266 /*
267  * Check to see if a specific OSS interrupt is pending
268  */
269
270 int oss_irq_pending(int irq)
271 {
272         switch(irq) {
273                 case IRQ_MAC_SCC:
274                         return oss->irq_pending & OSS_IP_IOPSCC;
275                         break;
276                 case IRQ_MAC_ADB:
277                         return oss->irq_pending & OSS_IP_IOPISM;
278                         break;
279                 case IRQ_MAC_SCSI:
280                         return oss->irq_pending & OSS_IP_SCSI;
281                         break;
282                 case IRQ_NUBUS_9:
283                 case IRQ_NUBUS_A:
284                 case IRQ_NUBUS_B:
285                 case IRQ_NUBUS_C:
286                 case IRQ_NUBUS_D:
287                 case IRQ_NUBUS_E:
288                         irq -= NUBUS_SOURCE_BASE;
289                         return oss->irq_pending & (1 << irq);
290                         break;
291         }
292         return 0;
293 }