Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * sound/pas2_card.c | |
3 | * | |
4 | * Detection routine for the Pro Audio Spectrum cards. | |
5 | */ | |
6 | ||
7 | #include <linux/config.h> | |
8 | #include <linux/init.h> | |
9 | #include <linux/interrupt.h> | |
10 | #include <linux/module.h> | |
11 | #include <linux/spinlock.h> | |
12 | #include "sound_config.h" | |
13 | ||
14 | #include "pas2.h" | |
15 | #include "sb.h" | |
16 | ||
17 | static unsigned char dma_bits[] = { | |
18 | 4, 1, 2, 3, 0, 5, 6, 7 | |
19 | }; | |
20 | ||
21 | static unsigned char irq_bits[] = { | |
22 | 0, 0, 1, 2, 3, 4, 5, 6, 0, 1, 7, 8, 9, 0, 10, 11 | |
23 | }; | |
24 | ||
25 | static unsigned char sb_irq_bits[] = { | |
26 | 0x00, 0x00, 0x08, 0x10, 0x00, 0x18, 0x00, 0x20, | |
27 | 0x00, 0x08, 0x28, 0x30, 0x38, 0, 0 | |
28 | }; | |
29 | ||
30 | static unsigned char sb_dma_bits[] = { | |
31 | 0x00, 0x40, 0x80, 0xC0, 0, 0, 0, 0 | |
32 | }; | |
33 | ||
34 | /* | |
35 | * The Address Translation code is used to convert I/O register addresses to | |
36 | * be relative to the given base -register | |
37 | */ | |
38 | ||
39 | int pas_translate_code = 0; | |
40 | static int pas_intr_mask; | |
41 | static int pas_irq; | |
42 | static int pas_sb_base; | |
43 | DEFINE_SPINLOCK(pas_lock); | |
44 | #ifndef CONFIG_PAS_JOYSTICK | |
45 | static int joystick; | |
46 | #else | |
47 | static int joystick = 1; | |
48 | #endif | |
49 | #ifdef SYMPHONY_PAS | |
50 | static int symphony = 1; | |
51 | #else | |
52 | static int symphony; | |
53 | #endif | |
54 | #ifdef BROKEN_BUS_CLOCK | |
55 | static int broken_bus_clock = 1; | |
56 | #else | |
57 | static int broken_bus_clock; | |
58 | #endif | |
59 | ||
60 | static struct address_info cfg; | |
61 | static struct address_info cfg2; | |
62 | ||
63 | char pas_model = 0; | |
64 | static char *pas_model_names[] = { | |
65 | "", | |
66 | "Pro AudioSpectrum+", | |
67 | "CDPC", | |
68 | "Pro AudioSpectrum 16", | |
69 | "Pro AudioSpectrum 16D" | |
70 | }; | |
71 | ||
72 | /* | |
73 | * pas_read() and pas_write() are equivalents of inb and outb | |
74 | * These routines perform the I/O address translation required | |
75 | * to support other than the default base address | |
76 | */ | |
77 | ||
78 | extern void mix_write(unsigned char data, int ioaddr); | |
79 | ||
80 | unsigned char pas_read(int ioaddr) | |
81 | { | |
82 | return inb(ioaddr + pas_translate_code); | |
83 | } | |
84 | ||
85 | void pas_write(unsigned char data, int ioaddr) | |
86 | { | |
87 | outb((data), ioaddr + pas_translate_code); | |
88 | } | |
89 | ||
90 | /******************* Begin of the Interrupt Handler ********************/ | |
91 | ||
92 | static irqreturn_t pasintr(int irq, void *dev_id, struct pt_regs *dummy) | |
93 | { | |
94 | int status; | |
95 | ||
96 | status = pas_read(0x0B89); | |
97 | pas_write(status, 0x0B89); /* Clear interrupt */ | |
98 | ||
99 | if (status & 0x08) | |
100 | { | |
101 | pas_pcm_interrupt(status, 1); | |
102 | status &= ~0x08; | |
103 | } | |
104 | if (status & 0x10) | |
105 | { | |
106 | pas_midi_interrupt(); | |
107 | status &= ~0x10; | |
108 | } | |
109 | return IRQ_HANDLED; | |
110 | } | |
111 | ||
112 | int pas_set_intr(int mask) | |
113 | { | |
114 | if (!mask) | |
115 | return 0; | |
116 | ||
117 | pas_intr_mask |= mask; | |
118 | ||
119 | pas_write(pas_intr_mask, 0x0B8B); | |
120 | return 0; | |
121 | } | |
122 | ||
123 | int pas_remove_intr(int mask) | |
124 | { | |
125 | if (!mask) | |
126 | return 0; | |
127 | ||
128 | pas_intr_mask &= ~mask; | |
129 | pas_write(pas_intr_mask, 0x0B8B); | |
130 | ||
131 | return 0; | |
132 | } | |
133 | ||
134 | /******************* End of the Interrupt handler **********************/ | |
135 | ||
136 | /******************* Begin of the Initialization Code ******************/ | |
137 | ||
138 | static int __init config_pas_hw(struct address_info *hw_config) | |
139 | { | |
140 | char ok = 1; | |
141 | unsigned int_ptrs; /* scsi/sound interrupt pointers */ | |
142 | ||
143 | pas_irq = hw_config->irq; | |
144 | ||
145 | pas_write(0x00, 0x0B8B); | |
146 | pas_write(0x36, 0x138B); | |
147 | pas_write(0x36, 0x1388); | |
148 | pas_write(0, 0x1388); | |
149 | pas_write(0x74, 0x138B); | |
150 | pas_write(0x74, 0x1389); | |
151 | pas_write(0, 0x1389); | |
152 | ||
153 | pas_write(0x80 | 0x40 | 0x20 | 1, 0x0B8A); | |
154 | pas_write(0x80 | 0x20 | 0x10 | 0x08 | 0x01, 0xF8A); | |
155 | pas_write(0x01 | 0x02 | 0x04 | 0x10 /* | |
156 | * | | |
157 | * 0x80 | |
158 | */ , 0xB88); | |
159 | ||
160 | pas_write(0x80 | |
161 | | joystick?0x40:0 | |
162 | ,0xF388); | |
163 | ||
164 | if (pas_irq < 0 || pas_irq > 15) | |
165 | { | |
166 | printk(KERN_ERR "PAS16: Invalid IRQ %d", pas_irq); | |
167 | hw_config->irq=-1; | |
168 | ok = 0; | |
169 | } | |
170 | else | |
171 | { | |
172 | int_ptrs = pas_read(0xF38A); | |
173 | int_ptrs = (int_ptrs & 0xf0) | irq_bits[pas_irq]; | |
174 | pas_write(int_ptrs, 0xF38A); | |
175 | if (!irq_bits[pas_irq]) | |
176 | { | |
177 | printk(KERN_ERR "PAS16: Invalid IRQ %d", pas_irq); | |
178 | hw_config->irq=-1; | |
179 | ok = 0; | |
180 | } | |
181 | else | |
182 | { | |
183 | if (request_irq(pas_irq, pasintr, 0, "PAS16",hw_config) < 0) { | |
184 | printk(KERN_ERR "PAS16: Cannot allocate IRQ %d\n",pas_irq); | |
185 | hw_config->irq=-1; | |
186 | ok = 0; | |
187 | } | |
188 | } | |
189 | } | |
190 | ||
191 | if (hw_config->dma < 0 || hw_config->dma > 7) | |
192 | { | |
193 | printk(KERN_ERR "PAS16: Invalid DMA selection %d", hw_config->dma); | |
194 | hw_config->dma=-1; | |
195 | ok = 0; | |
196 | } | |
197 | else | |
198 | { | |
199 | pas_write(dma_bits[hw_config->dma], 0xF389); | |
200 | if (!dma_bits[hw_config->dma]) | |
201 | { | |
202 | printk(KERN_ERR "PAS16: Invalid DMA selection %d", hw_config->dma); | |
203 | hw_config->dma=-1; | |
204 | ok = 0; | |
205 | } | |
206 | else | |
207 | { | |
208 | if (sound_alloc_dma(hw_config->dma, "PAS16")) | |
209 | { | |
210 | printk(KERN_ERR "pas2_card.c: Can't allocate DMA channel\n"); | |
211 | hw_config->dma=-1; | |
212 | ok = 0; | |
213 | } | |
214 | } | |
215 | } | |
216 | ||
217 | /* | |
218 | * This fixes the timing problems of the PAS due to the Symphony chipset | |
219 | * as per Media Vision. Only define this if your PAS doesn't work correctly. | |
220 | */ | |
221 | ||
222 | if(symphony) | |
223 | { | |
224 | outb((0x05), 0xa8); | |
225 | outb((0x60), 0xa9); | |
226 | } | |
227 | ||
228 | if(broken_bus_clock) | |
229 | pas_write(0x01 | 0x10 | 0x20 | 0x04, 0x8388); | |
230 | else | |
231 | /* | |
232 | * pas_write(0x01, 0x8388); | |
233 | */ | |
234 | pas_write(0x01 | 0x10 | 0x20, 0x8388); | |
235 | ||
236 | pas_write(0x18, 0x838A); /* ??? */ | |
237 | pas_write(0x20 | 0x01, 0x0B8A); /* Mute off, filter = 17.897 kHz */ | |
238 | pas_write(8, 0xBF8A); | |
239 | ||
240 | mix_write(0x80 | 5, 0x078B); | |
241 | mix_write(5, 0x078B); | |
242 | ||
243 | { | |
244 | struct address_info *sb_config; | |
245 | ||
246 | sb_config = &cfg2; | |
247 | if (sb_config->io_base) | |
248 | { | |
249 | unsigned char irq_dma; | |
250 | ||
251 | /* | |
252 | * Turn on Sound Blaster compatibility | |
253 | * bit 1 = SB emulation | |
254 | * bit 0 = MPU401 emulation (CDPC only :-( ) | |
255 | */ | |
256 | ||
257 | pas_write(0x02, 0xF788); | |
258 | ||
259 | /* | |
260 | * "Emulation address" | |
261 | */ | |
262 | ||
263 | pas_write((sb_config->io_base >> 4) & 0x0f, 0xF789); | |
264 | pas_sb_base = sb_config->io_base; | |
265 | ||
266 | if (!sb_dma_bits[sb_config->dma]) | |
267 | printk(KERN_ERR "PAS16 Warning: Invalid SB DMA %d\n\n", sb_config->dma); | |
268 | ||
269 | if (!sb_irq_bits[sb_config->irq]) | |
270 | printk(KERN_ERR "PAS16 Warning: Invalid SB IRQ %d\n\n", sb_config->irq); | |
271 | ||
272 | irq_dma = sb_dma_bits[sb_config->dma] | | |
273 | sb_irq_bits[sb_config->irq]; | |
274 | ||
275 | pas_write(irq_dma, 0xFB8A); | |
276 | } | |
277 | else | |
278 | pas_write(0x00, 0xF788); | |
279 | } | |
280 | ||
281 | if (!ok) | |
282 | printk(KERN_WARNING "PAS16: Driver not enabled\n"); | |
283 | ||
284 | return ok; | |
285 | } | |
286 | ||
287 | static int __init detect_pas_hw(struct address_info *hw_config) | |
288 | { | |
289 | unsigned char board_id, foo; | |
290 | ||
291 | /* | |
292 | * WARNING: Setting an option like W:1 or so that disables warm boot reset | |
293 | * of the card will screw up this detect code something fierce. Adding code | |
294 | * to handle this means possibly interfering with other cards on the bus if | |
295 | * you have something on base port 0x388. SO be forewarned. | |
296 | */ | |
297 | ||
298 | outb((0xBC), 0x9A01); /* Activate first board */ | |
299 | outb((hw_config->io_base >> 2), 0x9A01); /* Set base address */ | |
300 | pas_translate_code = hw_config->io_base - 0x388; | |
301 | pas_write(1, 0xBF88); /* Select one wait states */ | |
302 | ||
303 | board_id = pas_read(0x0B8B); | |
304 | ||
305 | if (board_id == 0xff) | |
306 | return 0; | |
307 | ||
308 | /* | |
309 | * We probably have a PAS-series board, now check for a PAS16-series board | |
310 | * by trying to change the board revision bits. PAS16-series hardware won't | |
311 | * let you do this - the bits are read-only. | |
312 | */ | |
313 | ||
314 | foo = board_id ^ 0xe0; | |
315 | ||
316 | pas_write(foo, 0x0B8B); | |
317 | foo = pas_read(0x0B8B); | |
318 | pas_write(board_id, 0x0B8B); | |
319 | ||
320 | if (board_id != foo) | |
321 | return 0; | |
322 | ||
323 | pas_model = pas_read(0xFF88); | |
324 | ||
325 | return pas_model; | |
326 | } | |
327 | ||
328 | static void __init attach_pas_card(struct address_info *hw_config) | |
329 | { | |
330 | pas_irq = hw_config->irq; | |
331 | ||
332 | if (detect_pas_hw(hw_config)) | |
333 | { | |
334 | ||
335 | if ((pas_model = pas_read(0xFF88))) | |
336 | { | |
337 | char temp[100]; | |
338 | ||
339 | sprintf(temp, | |
340 | "%s rev %d", pas_model_names[(int) pas_model], | |
341 | pas_read(0x2789)); | |
342 | conf_printf(temp, hw_config); | |
343 | } | |
344 | if (config_pas_hw(hw_config)) | |
345 | { | |
346 | pas_pcm_init(hw_config); | |
347 | pas_midi_init(); | |
348 | pas_init_mixer(); | |
349 | } | |
350 | } | |
351 | } | |
352 | ||
353 | static inline int __init probe_pas(struct address_info *hw_config) | |
354 | { | |
355 | return detect_pas_hw(hw_config); | |
356 | } | |
357 | ||
358 | static void __exit unload_pas(struct address_info *hw_config) | |
359 | { | |
360 | extern int pas_audiodev; | |
361 | extern int pas2_mididev; | |
362 | ||
363 | if (hw_config->dma>0) | |
364 | sound_free_dma(hw_config->dma); | |
365 | if (hw_config->irq>0) | |
366 | free_irq(hw_config->irq, hw_config); | |
367 | ||
368 | if(pas_audiodev!=-1) | |
369 | sound_unload_mixerdev(audio_devs[pas_audiodev]->mixer_dev); | |
370 | if(pas2_mididev!=-1) | |
371 | sound_unload_mididev(pas2_mididev); | |
372 | if(pas_audiodev!=-1) | |
373 | sound_unload_audiodev(pas_audiodev); | |
374 | } | |
375 | ||
376 | static int __initdata io = -1; | |
377 | static int __initdata irq = -1; | |
378 | static int __initdata dma = -1; | |
379 | static int __initdata dma16 = -1; /* Set this for modules that need it */ | |
380 | ||
381 | static int __initdata sb_io = 0; | |
382 | static int __initdata sb_irq = -1; | |
383 | static int __initdata sb_dma = -1; | |
384 | static int __initdata sb_dma16 = -1; | |
385 | ||
386 | module_param(io, int, 0); | |
387 | module_param(irq, int, 0); | |
388 | module_param(dma, int, 0); | |
389 | module_param(dma16, int, 0); | |
390 | ||
391 | module_param(sb_io, int, 0); | |
392 | module_param(sb_irq, int, 0); | |
393 | module_param(sb_dma, int, 0); | |
394 | module_param(sb_dma16, int, 0); | |
395 | ||
396 | module_param(joystick, bool, 0); | |
397 | module_param(symphony, bool, 0); | |
398 | module_param(broken_bus_clock, bool, 0); | |
399 | ||
400 | MODULE_LICENSE("GPL"); | |
401 | ||
402 | static int __init init_pas2(void) | |
403 | { | |
404 | printk(KERN_INFO "Pro Audio Spectrum driver Copyright (C) by Hannu Savolainen 1993-1996\n"); | |
405 | ||
406 | cfg.io_base = io; | |
407 | cfg.irq = irq; | |
408 | cfg.dma = dma; | |
409 | cfg.dma2 = dma16; | |
410 | ||
411 | cfg2.io_base = sb_io; | |
412 | cfg2.irq = sb_irq; | |
413 | cfg2.dma = sb_dma; | |
414 | cfg2.dma2 = sb_dma16; | |
415 | ||
416 | if (cfg.io_base == -1 || cfg.dma == -1 || cfg.irq == -1) { | |
417 | printk(KERN_INFO "I/O, IRQ, DMA and type are mandatory\n"); | |
418 | return -EINVAL; | |
419 | } | |
420 | ||
421 | if (!probe_pas(&cfg)) | |
422 | return -ENODEV; | |
423 | attach_pas_card(&cfg); | |
424 | ||
425 | return 0; | |
426 | } | |
427 | ||
428 | static void __exit cleanup_pas2(void) | |
429 | { | |
430 | unload_pas(&cfg); | |
431 | } | |
432 | ||
433 | module_init(init_pas2); | |
434 | module_exit(cleanup_pas2); | |
435 | ||
436 | #ifndef MODULE | |
437 | static int __init setup_pas2(char *str) | |
438 | { | |
439 | /* io, irq, dma, dma2, sb_io, sb_irq, sb_dma, sb_dma2 */ | |
440 | int ints[9]; | |
441 | ||
442 | str = get_options(str, ARRAY_SIZE(ints), ints); | |
443 | ||
444 | io = ints[1]; | |
445 | irq = ints[2]; | |
446 | dma = ints[3]; | |
447 | dma16 = ints[4]; | |
448 | ||
449 | sb_io = ints[5]; | |
450 | sb_irq = ints[6]; | |
451 | sb_dma = ints[7]; | |
452 | sb_dma16 = ints[8]; | |
453 | ||
454 | return 1; | |
455 | } | |
456 | ||
457 | __setup("pas2=", setup_pas2); | |
458 | #endif |