]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | irqreturn_t oss_irq(int, void *, struct pt_regs *); | |
34 | irqreturn_t oss_nubus_irq(int, void *, struct pt_regs *); | |
35 | ||
36 | extern irqreturn_t via1_irq(int, void *, struct pt_regs *); | |
37 | extern irqreturn_t 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 | ||
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 | ||
68 | void __init oss_register_interrupts(void) | |
69 | { | |
9c5f4afd | 70 | request_irq(OSS_IRQLEV_SCSI, oss_irq, IRQ_FLG_LOCK, |
1da177e4 | 71 | "scsi", (void *) oss); |
9c5f4afd | 72 | request_irq(OSS_IRQLEV_IOPSCC, mac_scc_dispatch, IRQ_FLG_LOCK, |
1da177e4 | 73 | "scc", mac_scc_dispatch); |
9c5f4afd | 74 | request_irq(OSS_IRQLEV_NUBUS, oss_nubus_irq, IRQ_FLG_LOCK, |
1da177e4 | 75 | "nubus", (void *) oss); |
9c5f4afd | 76 | request_irq(OSS_IRQLEV_SOUND, oss_irq, IRQ_FLG_LOCK, |
1da177e4 | 77 | "sound", (void *) oss); |
9c5f4afd | 78 | request_irq(OSS_IRQLEV_VIA1, via1_irq, IRQ_FLG_LOCK, |
1da177e4 LT |
79 | "via1", (void *) 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 | irqreturn_t 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) | |
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 | /* FIXME: call sound handler */ | |
113 | oss->irq_pending &= ~OSS_IP_SOUND; | |
114 | } else if (events & OSS_IP_SCSI) { | |
115 | oss->irq_level[OSS_SCSI] = OSS_IRQLEV_DISABLED; | |
9c5f4afd | 116 | m68k_handle_int(IRQ_MAC_SCSI, regs); |
1da177e4 LT |
117 | oss->irq_pending &= ~OSS_IP_SCSI; |
118 | oss->irq_level[OSS_SCSI] = OSS_IRQLEV_SCSI; | |
119 | } else { | |
120 | /* FIXME: error check here? */ | |
121 | } | |
122 | return IRQ_HANDLED; | |
123 | } | |
124 | ||
125 | /* | |
126 | * Nubus IRQ handler, OSS style | |
127 | * | |
128 | * Unlike the VIA/RBV this is on its own autovector interrupt level. | |
129 | */ | |
130 | ||
131 | irqreturn_t oss_nubus_irq(int irq, void *dev_id, struct pt_regs *regs) | |
132 | { | |
133 | int events, irq_bit, i; | |
134 | ||
135 | events = oss->irq_pending & OSS_IP_NUBUS; | |
136 | if (!events) | |
137 | return IRQ_NONE; | |
138 | ||
139 | #ifdef DEBUG_NUBUS_INT | |
140 | if (console_loglevel > 7) { | |
141 | printk("oss_nubus_irq: events = 0x%04X\n", events); | |
142 | } | |
143 | #endif | |
144 | /* There are only six slots on the OSS, not seven */ | |
145 | ||
146 | for (i = 0, irq_bit = 1 ; i < 6 ; i++, irq_bit <<= 1) { | |
147 | if (events & irq_bit) { | |
148 | oss->irq_level[i] = OSS_IRQLEV_DISABLED; | |
9c5f4afd | 149 | m68k_handle_int(NUBUS_SOURCE_BASE + i, regs); |
1da177e4 LT |
150 | oss->irq_pending &= ~irq_bit; |
151 | oss->irq_level[i] = OSS_IRQLEV_NUBUS; | |
152 | } | |
153 | } | |
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_SCC: | |
172 | case IRQ_SCCA: | |
173 | case IRQ_SCCB: | |
174 | oss->irq_level[OSS_IOPSCC] = OSS_IRQLEV_IOPSCC; | |
175 | break; | |
176 | case IRQ_MAC_ADB: | |
177 | oss->irq_level[OSS_IOPISM] = OSS_IRQLEV_IOPISM; | |
178 | break; | |
179 | case IRQ_MAC_SCSI: | |
180 | oss->irq_level[OSS_SCSI] = OSS_IRQLEV_SCSI; | |
181 | break; | |
182 | case IRQ_NUBUS_9: | |
183 | case IRQ_NUBUS_A: | |
184 | case IRQ_NUBUS_B: | |
185 | case IRQ_NUBUS_C: | |
186 | case IRQ_NUBUS_D: | |
187 | case IRQ_NUBUS_E: | |
188 | irq -= NUBUS_SOURCE_BASE; | |
189 | oss->irq_level[irq] = OSS_IRQLEV_NUBUS; | |
190 | break; | |
191 | #ifdef DEBUG_IRQUSE | |
192 | default: | |
193 | printk("%s unknown irq %d\n",__FUNCTION__, irq); | |
194 | break; | |
195 | #endif | |
196 | } | |
197 | } | |
198 | ||
199 | /* | |
200 | * Disable an OSS interrupt | |
201 | * | |
202 | * Same as above except we set the source's interrupt level to zero, | |
203 | * to disable the interrupt. | |
204 | */ | |
205 | ||
206 | void oss_irq_disable(int irq) { | |
207 | #ifdef DEBUG_IRQUSE | |
208 | printk("oss_irq_disable(%d)\n", irq); | |
209 | #endif | |
210 | switch(irq) { | |
211 | case IRQ_SCC: | |
212 | case IRQ_SCCA: | |
213 | case IRQ_SCCB: | |
214 | oss->irq_level[OSS_IOPSCC] = OSS_IRQLEV_DISABLED; | |
215 | break; | |
216 | case IRQ_MAC_ADB: | |
217 | oss->irq_level[OSS_IOPISM] = OSS_IRQLEV_DISABLED; | |
218 | break; | |
219 | case IRQ_MAC_SCSI: | |
220 | oss->irq_level[OSS_SCSI] = OSS_IRQLEV_DISABLED; | |
221 | break; | |
222 | case IRQ_NUBUS_9: | |
223 | case IRQ_NUBUS_A: | |
224 | case IRQ_NUBUS_B: | |
225 | case IRQ_NUBUS_C: | |
226 | case IRQ_NUBUS_D: | |
227 | case IRQ_NUBUS_E: | |
228 | irq -= NUBUS_SOURCE_BASE; | |
229 | oss->irq_level[irq] = OSS_IRQLEV_DISABLED; | |
230 | break; | |
231 | #ifdef DEBUG_IRQUSE | |
232 | default: | |
233 | printk("%s unknown irq %d\n", __FUNCTION__, irq); | |
234 | break; | |
235 | #endif | |
236 | } | |
237 | } | |
238 | ||
239 | /* | |
240 | * Clear an OSS interrupt | |
241 | * | |
242 | * Not sure if this works or not but it's the only method I could | |
243 | * think of based on the contents of the mac_oss structure. | |
244 | */ | |
245 | ||
246 | void oss_irq_clear(int irq) { | |
247 | /* FIXME: how to do this on OSS? */ | |
248 | switch(irq) { | |
249 | case IRQ_SCC: | |
250 | case IRQ_SCCA: | |
251 | case IRQ_SCCB: | |
252 | oss->irq_pending &= ~OSS_IP_IOPSCC; | |
253 | break; | |
254 | case IRQ_MAC_ADB: | |
255 | oss->irq_pending &= ~OSS_IP_IOPISM; | |
256 | break; | |
257 | case IRQ_MAC_SCSI: | |
258 | oss->irq_pending &= ~OSS_IP_SCSI; | |
259 | break; | |
260 | case IRQ_NUBUS_9: | |
261 | case IRQ_NUBUS_A: | |
262 | case IRQ_NUBUS_B: | |
263 | case IRQ_NUBUS_C: | |
264 | case IRQ_NUBUS_D: | |
265 | case IRQ_NUBUS_E: | |
266 | irq -= NUBUS_SOURCE_BASE; | |
267 | oss->irq_pending &= ~(1 << irq); | |
268 | break; | |
269 | } | |
270 | } | |
271 | ||
272 | /* | |
273 | * Check to see if a specific OSS interrupt is pending | |
274 | */ | |
275 | ||
276 | int oss_irq_pending(int irq) | |
277 | { | |
278 | switch(irq) { | |
279 | case IRQ_SCC: | |
280 | case IRQ_SCCA: | |
281 | case IRQ_SCCB: | |
282 | return oss->irq_pending & OSS_IP_IOPSCC; | |
283 | break; | |
284 | case IRQ_MAC_ADB: | |
285 | return oss->irq_pending & OSS_IP_IOPISM; | |
286 | break; | |
287 | case IRQ_MAC_SCSI: | |
288 | return oss->irq_pending & OSS_IP_SCSI; | |
289 | break; | |
290 | case IRQ_NUBUS_9: | |
291 | case IRQ_NUBUS_A: | |
292 | case IRQ_NUBUS_B: | |
293 | case IRQ_NUBUS_C: | |
294 | case IRQ_NUBUS_D: | |
295 | case IRQ_NUBUS_E: | |
296 | irq -= NUBUS_SOURCE_BASE; | |
297 | return oss->irq_pending & (1 << irq); | |
298 | break; | |
299 | } | |
300 | return 0; | |
301 | } |