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 fulll 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/machw.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 void oss_irq(int, void *, struct pt_regs *);
34 void oss_nubus_irq(int, void *, struct pt_regs *);
35
36 extern void via1_irq(int, void *, struct pt_regs *);
37 extern void mac_scc_dispatch(int, void *, struct pt_regs *);
38
39 /*
40 * Initialize the OSS
41 *
42 * The OSS "detection" code is actually in via_init() which is always called
43 * before us. Thus we can count on oss_present being valid on entry.
44 */
45
oss_init(void)46 void __init oss_init(void)
47 {
48 int i;
49
50 if (!oss_present) return;
51
52 oss = (struct mac_oss *) OSS_BASE;
53
54 /* Disable all interrupts. Unlike a VIA it looks like we */
55 /* do this by setting the source's interrupt level to zero. */
56
57 for (i = 0; i <= OSS_NUM_SOURCES; i++) {
58 oss->irq_level[i] = OSS_IRQLEV_DISABLED;
59 }
60 /* If we disable VIA1 here, we never really handle it... */
61 oss->irq_level[OSS_VIA1] = OSS_IRQLEV_VIA1;
62 }
63
64 /*
65 * Register the OSS and NuBus interrupt dispatchers.
66 */
67
oss_register_interrupts(void)68 void __init oss_register_interrupts(void)
69 {
70 sys_request_irq(OSS_IRQLEV_SCSI, oss_irq, IRQ_FLG_LOCK,
71 "scsi", (void *) oss);
72 sys_request_irq(OSS_IRQLEV_IOPSCC, mac_scc_dispatch, IRQ_FLG_LOCK,
73 "scc", mac_scc_dispatch);
74 sys_request_irq(OSS_IRQLEV_NUBUS, oss_nubus_irq, IRQ_FLG_LOCK,
75 "nubus", (void *) oss);
76 sys_request_irq(OSS_IRQLEV_SOUND, oss_irq, IRQ_FLG_LOCK,
77 "sound", (void *) oss);
78 sys_request_irq(OSS_IRQLEV_VIA1, via1_irq, IRQ_FLG_LOCK,
79 "via1", (void *) via1);
80 }
81
82 /*
83 * Initialize OSS for Nubus access
84 */
85
oss_nubus_init(void)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
oss_irq(int irq,void * dev_id,struct pt_regs * regs)95 void oss_irq(int irq, void *dev_id, struct pt_regs *regs)
96 {
97 int events;
98
99 events = oss->irq_pending & (OSS_IP_SOUND|OSS_IP_SCSI);
100 if (!events) return;
101
102 #ifdef DEBUG_IRQS
103 if ((console_loglevel == 10) && !(events & OSS_IP_SCSI)) {
104 printk("oss_irq: irq %d events = 0x%04X\n", irq,
105 (int) oss->irq_pending);
106 }
107 #endif
108 /* FIXME: how do you clear a pending IRQ? */
109
110 if (events & OSS_IP_SOUND) {
111 /* FIXME: call sound handler */
112 oss->irq_pending &= ~OSS_IP_SOUND;
113 } else if (events & OSS_IP_SCSI) {
114 oss->irq_level[OSS_SCSI] = OSS_IRQLEV_DISABLED;
115 mac_do_irq_list(IRQ_MAC_SCSI, regs);
116 oss->irq_pending &= ~OSS_IP_SCSI;
117 oss->irq_level[OSS_SCSI] = OSS_IRQLEV_SCSI;
118 } else {
119 /* FIXME: error check here? */
120 }
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
oss_nubus_irq(int irq,void * dev_id,struct pt_regs * regs)129 void oss_nubus_irq(int irq, void *dev_id, struct pt_regs *regs)
130 {
131 int events, irq_bit, i;
132
133 events = oss->irq_pending & OSS_IP_NUBUS;
134 if (!events) return;
135
136 #ifdef DEBUG_NUBUS_INT
137 if (console_loglevel > 7) {
138 printk("oss_nubus_irq: events = 0x%04X\n", events);
139 }
140 #endif
141 /* There are only six slots on the OSS, not seven */
142
143 for (i = 0, irq_bit = 1 ; i < 6 ; i++, irq_bit <<= 1) {
144 if (events & irq_bit) {
145 oss->irq_level[i] = OSS_IRQLEV_DISABLED;
146 mac_do_irq_list(NUBUS_SOURCE_BASE + i, regs);
147 oss->irq_pending &= ~irq_bit;
148 oss->irq_level[i] = OSS_IRQLEV_NUBUS;
149 }
150 }
151 }
152
153 /*
154 * Enable an OSS interrupt
155 *
156 * It looks messy but it's rather straightforward. The switch() statement
157 * just maps the machspec interrupt numbers to the right OSS interrupt
158 * source (if the OSS handles that interrupt) and then sets the interrupt
159 * level for that source to nonzero, thus enabling the interrupt.
160 */
161
oss_irq_enable(int irq)162 void oss_irq_enable(int irq) {
163 #ifdef DEBUG_IRQUSE
164 printk("oss_irq_enable(%d)\n", irq);
165 #endif
166 switch(irq) {
167 case IRQ_SCC:
168 case IRQ_SCCA:
169 case IRQ_SCCB:
170 oss->irq_level[OSS_IOPSCC] = OSS_IRQLEV_IOPSCC;
171 break;
172 case IRQ_MAC_ADB:
173 oss->irq_level[OSS_IOPISM] = OSS_IRQLEV_IOPISM;
174 break;
175 case IRQ_MAC_SCSI:
176 oss->irq_level[OSS_SCSI] = OSS_IRQLEV_SCSI;
177 break;
178 case IRQ_NUBUS_9:
179 case IRQ_NUBUS_A:
180 case IRQ_NUBUS_B:
181 case IRQ_NUBUS_C:
182 case IRQ_NUBUS_D:
183 case IRQ_NUBUS_E:
184 irq -= NUBUS_SOURCE_BASE;
185 oss->irq_level[irq] = OSS_IRQLEV_NUBUS;
186 break;
187 #ifdef DEBUG_IRQUSE
188 default:
189 printk("%s unknown irq %d\n",__FUNCTION__, irq);
190 break;
191 #endif
192 }
193 }
194
195 /*
196 * Disable an OSS interrupt
197 *
198 * Same as above except we set the source's interrupt level to zero,
199 * to disable the interrupt.
200 */
201
oss_irq_disable(int irq)202 void oss_irq_disable(int irq) {
203 #ifdef DEBUG_IRQUSE
204 printk("oss_irq_disable(%d)\n", irq);
205 #endif
206 switch(irq) {
207 case IRQ_SCC:
208 case IRQ_SCCA:
209 case IRQ_SCCB:
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", __FUNCTION__, 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
oss_irq_clear(int irq)242 void oss_irq_clear(int irq) {
243 /* FIXME: how to do this on OSS? */
244 switch(irq) {
245 case IRQ_SCC:
246 case IRQ_SCCA:
247 case IRQ_SCCB:
248 oss->irq_pending &= ~OSS_IP_IOPSCC;
249 break;
250 case IRQ_MAC_ADB:
251 oss->irq_pending &= ~OSS_IP_IOPISM;
252 break;
253 case IRQ_MAC_SCSI:
254 oss->irq_pending &= ~OSS_IP_SCSI;
255 break;
256 case IRQ_NUBUS_9:
257 case IRQ_NUBUS_A:
258 case IRQ_NUBUS_B:
259 case IRQ_NUBUS_C:
260 case IRQ_NUBUS_D:
261 case IRQ_NUBUS_E:
262 irq -= NUBUS_SOURCE_BASE;
263 oss->irq_pending &= ~(1 << irq);
264 break;
265 }
266 }
267
268 /*
269 * Check to see if a specific OSS interrupt is pending
270 */
271
oss_irq_pending(int irq)272 int oss_irq_pending(int irq)
273 {
274 switch(irq) {
275 case IRQ_SCC:
276 case IRQ_SCCA:
277 case IRQ_SCCB:
278 return oss->irq_pending & OSS_IP_IOPSCC;
279 break;
280 case IRQ_MAC_ADB:
281 return oss->irq_pending & OSS_IP_IOPISM;
282 break;
283 case IRQ_MAC_SCSI:
284 return oss->irq_pending & OSS_IP_SCSI;
285 break;
286 case IRQ_NUBUS_9:
287 case IRQ_NUBUS_A:
288 case IRQ_NUBUS_B:
289 case IRQ_NUBUS_C:
290 case IRQ_NUBUS_D:
291 case IRQ_NUBUS_E:
292 irq -= NUBUS_SOURCE_BASE;
293 return oss->irq_pending & (1 << irq);
294 break;
295 }
296 return 0;
297 }
298