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