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