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