[PATCH] opl3sa2: MODULE_PARM_DESC
[linux-2.6.git] / sound / oss / opl3sa2.c
1 /*
2  * sound/opl3sa2.c
3  *
4  * A low level driver for Yamaha OPL3-SA2 and SA3 cards.
5  * NOTE: All traces of the name OPL3-SAx have now (December 2000) been
6  *       removed from the driver code, as an email exchange with Yamaha
7  *       provided the information that the YMF-719 is indeed just a
8  *       re-badged 715.
9  *
10  * Copyright 1998-2001 Scott Murray <scott@spiteful.org>
11  *
12  * Originally based on the CS4232 driver (in cs4232.c) by Hannu Savolainen
13  * and others.  Now incorporates code/ideas from pss.c, also by Hannu
14  * Savolainen.  Both of those files are distributed with the following
15  * license:
16  *
17  * "Copyright (C) by Hannu Savolainen 1993-1997
18  *
19  *  OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
20  *  Version 2 (June 1991). See the "COPYING" file distributed with this software
21  *  for more info."
22  *
23  * As such, in accordance with the above license, this file, opl3sa2.c, is
24  * distributed under the GNU GENERAL PUBLIC LICENSE (GPL) Version 2 (June 1991).
25  * See the "COPYING" file distributed with this software for more information.
26  *
27  * Change History
28  * --------------
29  * Scott Murray            Original driver (Jun 14, 1998)
30  * Paul J.Y. Lahaie        Changed probing / attach code order
31  * Scott Murray            Added mixer support (Dec 03, 1998)
32  * Scott Murray            Changed detection code to be more forgiving,
33  *                         added force option as last resort,
34  *                         fixed ioctl return values. (Dec 30, 1998)
35  * Scott Murray            Simpler detection code should work all the time now
36  *                         (with thanks to Ben Hutchings for the heuristic),
37  *                         removed now unnecessary force option. (Jan 5, 1999)
38  * Christoph Hellwig       Adapted to module_init/module_exit (Mar 4, 2000)
39  * Scott Murray            Reworked SA2 versus SA3 mixer code, updated chipset
40  *                         version detection code (again!). (Dec 5, 2000)
41  * Scott Murray            Adjusted master volume mixer scaling. (Dec 6, 2000)
42  * Scott Murray            Based on a patch by Joel Yliluoma (aka Bisqwit),
43  *                         integrated wide mixer and adjusted mic, bass, treble
44  *                         scaling. (Dec 6, 2000)
45  * Scott Murray            Based on a patch by Peter Englmaier, integrated
46  *                         ymode and loopback options. (Dec 6, 2000)
47  * Scott Murray            Inspired by a patch by Peter Englmaier, and based on
48  *                         what ALSA does, added initialization code for the
49  *                         default DMA and IRQ settings. (Dec 6, 2000)
50  * Scott Murray            Added some more checks to the card detection code,
51  *                         based on what ALSA does. (Dec 12, 2000)
52  * Scott Murray            Inspired by similar patches from John Fremlin,
53  *                         Jim Radford, Mike Rolig, and Ingmar Steen, added 2.4
54  *                         ISA PnP API support, mainly based on bits from
55  *                         sb_card.c and awe_wave.c. (Dec 12, 2000)
56  * Scott Murray            Some small cleanups to the init code output.
57  *                         (Jan 7, 2001)
58  * Zwane Mwaikambo         Added PM support. (Dec 4 2001)
59  *
60  * Adam Belay              Converted driver to new PnP Layer (Oct 12, 2002)
61  * Zwane Mwaikambo         Code, data structure cleanups. (Feb 15 2002)
62  * Zwane Mwaikambo         Free resources during auxiliary device probe
63  *                         failures (Apr 29 2002)
64  *   
65  */
66
67 #include <linux/config.h>
68 #include <linux/pnp.h>
69 #include <linux/init.h>
70 #include <linux/module.h>
71 #include <linux/delay.h>
72 #include <linux/pm.h>
73 #include "sound_config.h"
74
75 #include "ad1848.h"
76 #include "mpu401.h"
77
78 #define OPL3SA2_MODULE_NAME     "opl3sa2"
79 #define PFX                     OPL3SA2_MODULE_NAME ": "
80
81 /* Useful control port indexes: */
82 #define OPL3SA2_PM           0x01
83 #define OPL3SA2_SYS_CTRL     0x02
84 #define OPL3SA2_IRQ_CONFIG   0x03
85 #define OPL3SA2_DMA_CONFIG   0x06
86 #define OPL3SA2_MASTER_LEFT  0x07
87 #define OPL3SA2_MASTER_RIGHT 0x08
88 #define OPL3SA2_MIC          0x09
89 #define OPL3SA2_MISC         0x0A
90
91 #define OPL3SA3_WIDE         0x14
92 #define OPL3SA3_BASS         0x15
93 #define OPL3SA3_TREBLE       0x16
94
95 /* Useful constants: */
96 #define DEFAULT_VOLUME 50
97 #define DEFAULT_MIC    50
98 #define DEFAULT_TIMBRE 0
99
100 /* Power saving modes */
101 #define OPL3SA2_PM_MODE0        0x00
102 #define OPL3SA2_PM_MODE1        0x04    /* PSV */
103 #define OPL3SA2_PM_MODE2        0x05    /* PSV | PDX */
104 #define OPL3SA2_PM_MODE3        0x27    /* ADOWN | PSV | PDN | PDX */
105
106
107 /* For checking against what the card returns: */
108 #define VERSION_UNKNOWN 0
109 #define VERSION_YMF711  1
110 #define VERSION_YMF715  2
111 #define VERSION_YMF715B 3
112 #define VERSION_YMF715E 4
113 /* also assuming that anything > 4 but <= 7 is a 715E */
114
115 /* Chipset type constants for use below */
116 #define CHIPSET_UNKNOWN -1
117 #define CHIPSET_OPL3SA2 0
118 #define CHIPSET_OPL3SA3 1
119 static const char *CHIPSET_TABLE[] = {"OPL3-SA2", "OPL3-SA3"};
120
121 #ifdef CONFIG_PNP
122 #define OPL3SA2_CARDS_MAX 4
123 #else
124 #define OPL3SA2_CARDS_MAX 1
125 #endif
126
127 /* This should be pretty obvious */
128 static int opl3sa2_cards_num;
129
130 typedef struct {
131         /* device resources */
132         unsigned short cfg_port;
133         struct address_info cfg;
134         struct address_info cfg_mss;
135         struct address_info cfg_mpu;
136 #ifdef CONFIG_PNP
137         /* PnP Stuff */
138         struct pnp_dev* pdev;
139         int activated;                  /* Whether said devices have been activated */
140 #endif
141 #ifdef CONFIG_PM
142         unsigned int    in_suspend;
143         struct pm_dev   *pmdev;
144 #endif
145         unsigned int    card;
146         int             chipset;        /* What's my version(s)? */
147         char            *chipset_name;
148
149         /* mixer data */
150         int             mixer;
151         unsigned int    volume_l;
152         unsigned int    volume_r;
153         unsigned int    mic;
154         unsigned int    bass_l;
155         unsigned int    bass_r;
156         unsigned int    treble_l;
157         unsigned int    treble_r;
158         unsigned int    wide_l;
159         unsigned int    wide_r;
160 } opl3sa2_state_t;
161 static opl3sa2_state_t opl3sa2_state[OPL3SA2_CARDS_MAX];
162
163         
164
165 /* Our parameters */
166 static int __initdata io        = -1;
167 static int __initdata mss_io    = -1;
168 static int __initdata mpu_io    = -1;
169 static int __initdata irq       = -1;
170 static int __initdata dma       = -1;
171 static int __initdata dma2      = -1;
172 static int __initdata ymode     = -1;
173 static int __initdata loopback  = -1;
174
175 #ifdef CONFIG_PNP
176 /* PnP specific parameters */
177 static int __initdata isapnp = 1;
178 static int __initdata multiple = 1;
179
180 /* Whether said devices have been activated */
181 static int opl3sa2_activated[OPL3SA2_CARDS_MAX];
182 #else
183 static int __initdata isapnp; /* = 0 */
184 static int __initdata multiple; /* = 0 */
185 #endif
186
187 MODULE_DESCRIPTION("Module for OPL3-SA2 and SA3 sound cards (uses AD1848 MSS driver).");
188 MODULE_AUTHOR("Scott Murray <scott@spiteful.org>");
189 MODULE_LICENSE("GPL");
190
191
192 module_param(io, int, 0);
193 MODULE_PARM_DESC(io, "Set I/O base of OPL3-SA2 or SA3 card (usually 0x370.  Address must be even and must be from 0x100 to 0xFFE)");
194
195 module_param(mss_io, int, 0);
196 MODULE_PARM_DESC(mss_io, "Set MSS (audio) I/O base (0x530, 0xE80, or other. Address must end in 0 or 4 and must be from 0x530 to 0xF48)");
197
198 module_param(mpu_io, int, 0);
199 MODULE_PARM_DESC(mpu_io, "Set MIDI I/O base (0x330 or other. Address must be even and must be from 0x300 to 0x334)");
200
201 module_param(irq, int, 0);
202 MODULE_PARM_DESC(irq, "Set MSS (audio) IRQ (5, 7, 9, 10, 11, 12)");
203
204 module_param(dma, int, 0);
205 MODULE_PARM_DESC(dma, "Set MSS (audio) first DMA channel (0, 1, 3)");
206
207 module_param(dma2, int, 0);
208 MODULE_PARM_DESC(dma2, "Set MSS (audio) second DMA channel (0, 1, 3)");
209
210 module_param(ymode, int, 0);
211 MODULE_PARM_DESC(ymode, "Set Yamaha 3D enhancement mode (0 = Desktop/Normal, 1 = Notebook PC (1), 2 = Notebook PC (2), 3 = Hi-Fi)");
212
213 module_param(loopback, int, 0);
214 MODULE_PARM_DESC(loopback, "Set A/D input source. Useful for echo cancellation (0 = Mic Rch (default), 1 = Mono output loopback)");
215
216 #ifdef CONFIG_PNP
217 module_param(isapnp, bool, 0);
218 MODULE_PARM_DESC(isapnp, "When set to 0, ISA PnP support will be disabled");
219
220 module_param(multiple, bool, 0);
221 MODULE_PARM_DESC(multiple, "When set to 0, will not search for multiple cards");
222 #endif
223
224
225 /*
226  * Standard read and write functions
227 */
228
229 static inline void opl3sa2_write(unsigned short port,
230                                  unsigned char  index,
231                                  unsigned char  data)
232 {
233         outb_p(index, port);
234         outb(data, port + 1);
235 }
236
237
238 static inline void opl3sa2_read(unsigned short port,
239                                 unsigned char  index,
240                                 unsigned char* data)
241 {
242         outb_p(index, port);
243         *data = inb(port + 1);
244 }
245
246
247 /*
248  * All of the mixer functions...
249  */
250
251 static void opl3sa2_set_volume(opl3sa2_state_t* devc, int left, int right)
252 {
253         static unsigned char scale[101] = {
254                 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e,
255                 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0c,
256                 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b,
257                 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09,
258                 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08,
259                 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06,
260                 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
261                 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03,
262                 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01,
263                 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
264                 0x00
265         };
266         unsigned char vol;
267
268         vol = scale[left];
269
270         /* If level is zero, turn on mute */
271         if(!left)
272                 vol |= 0x80;
273
274         opl3sa2_write(devc->cfg_port, OPL3SA2_MASTER_LEFT, vol);
275
276         vol = scale[right];
277
278         /* If level is zero, turn on mute */
279         if(!right)
280                 vol |= 0x80;
281
282         opl3sa2_write(devc->cfg_port, OPL3SA2_MASTER_RIGHT, vol);
283 }
284
285
286 static void opl3sa2_set_mic(opl3sa2_state_t* devc, int level)
287 {
288         unsigned char vol = 0x1F;
289
290         if((level >= 0) && (level <= 100))
291                 vol = 0x1F - (unsigned char) (32 * level / 101);
292
293         /* If level is zero, turn on mute */
294         if(!level)
295                 vol |= 0x80;
296
297         opl3sa2_write(devc->cfg_port, OPL3SA2_MIC, vol);
298 }
299
300
301 static void opl3sa3_set_bass(opl3sa2_state_t* devc, int left, int right)
302 {
303         unsigned char bass;
304
305         bass = left ? ((unsigned char) (8 * left / 101)) : 0; 
306         bass |= (right ? ((unsigned char) (8 * right / 101)) : 0) << 4;
307
308         opl3sa2_write(devc->cfg_port, OPL3SA3_BASS, bass);
309 }
310
311
312 static void opl3sa3_set_treble(opl3sa2_state_t* devc, int left, int right)
313 {       
314         unsigned char treble;
315
316         treble = left ? ((unsigned char) (8 * left / 101)) : 0; 
317         treble |= (right ? ((unsigned char) (8 * right / 101)) : 0) << 4;
318
319         opl3sa2_write(devc->cfg_port, OPL3SA3_TREBLE, treble);
320 }
321
322
323
324
325 static void opl3sa2_mixer_reset(opl3sa2_state_t* devc)
326 {
327         if (devc) {
328                 opl3sa2_set_volume(devc, DEFAULT_VOLUME, DEFAULT_VOLUME);
329                 devc->volume_l = devc->volume_r = DEFAULT_VOLUME;
330
331                 opl3sa2_set_mic(devc, DEFAULT_MIC);
332                 devc->mic = DEFAULT_MIC;
333
334                 if (devc->chipset == CHIPSET_OPL3SA3) {
335                         opl3sa3_set_bass(devc, DEFAULT_TIMBRE, DEFAULT_TIMBRE);
336                         devc->bass_l = devc->bass_r = DEFAULT_TIMBRE;
337                         opl3sa3_set_treble(devc, DEFAULT_TIMBRE, DEFAULT_TIMBRE);
338                         devc->treble_l = devc->treble_r = DEFAULT_TIMBRE;
339                 }
340         }
341 }
342
343 /* Currently only used for power management */
344 #ifdef CONFIG_PM
345 static void opl3sa2_mixer_restore(opl3sa2_state_t* devc)
346 {
347         if (devc) {
348                 opl3sa2_set_volume(devc, devc->volume_l, devc->volume_r);
349                 opl3sa2_set_mic(devc, devc->mic);
350
351                 if (devc->chipset == CHIPSET_OPL3SA3) {
352                         opl3sa3_set_bass(devc, devc->bass_l, devc->bass_r);
353                         opl3sa3_set_treble(devc, devc->treble_l, devc->treble_r);
354                 }
355         }
356 }
357 #endif
358
359 static inline void arg_to_vol_mono(unsigned int vol, int* value)
360 {
361         int left;
362         
363         left = vol & 0x00ff;
364         if (left > 100)
365                 left = 100;
366         *value = left;
367 }
368
369
370 static inline void arg_to_vol_stereo(unsigned int vol, int* aleft, int* aright)
371 {
372         arg_to_vol_mono(vol, aleft);
373         arg_to_vol_mono(vol >> 8, aright);
374 }
375
376
377 static inline int ret_vol_mono(int vol)
378 {
379         return ((vol << 8) | vol);
380 }
381
382
383 static inline int ret_vol_stereo(int left, int right)
384 {
385         return ((right << 8) | left);
386 }
387
388
389 static int opl3sa2_mixer_ioctl(int dev, unsigned int cmd, void __user *arg)
390 {
391         int retval, value, cmdf = cmd & 0xff;
392         int __user *p = (int __user *)arg;
393
394         opl3sa2_state_t* devc = &opl3sa2_state[dev];
395         
396         switch (cmdf) {
397                 case SOUND_MIXER_VOLUME:
398                 case SOUND_MIXER_MIC:
399                 case SOUND_MIXER_DEVMASK:
400                 case SOUND_MIXER_STEREODEVS: 
401                 case SOUND_MIXER_RECMASK:
402                 case SOUND_MIXER_RECSRC:
403                 case SOUND_MIXER_CAPS: 
404                         break;
405
406                 default:
407                         return -EINVAL;
408         }
409         
410         if (((cmd >> 8) & 0xff) != 'M')
411                 return -EINVAL;
412                 
413         retval = 0;
414         if (_SIOC_DIR (cmd) & _SIOC_WRITE) {
415                 switch (cmdf) {
416                         case SOUND_MIXER_VOLUME:
417                                 retval = get_user(value, (unsigned __user *) arg);
418                                 if (retval)
419                                         break;
420                                 arg_to_vol_stereo(value, &devc->volume_l, &devc->volume_r);
421                                 opl3sa2_set_volume(devc, devc->volume_l, devc->volume_r);
422                                 value = ret_vol_stereo(devc->volume_l, devc->volume_r);
423                                 retval = put_user(value, p);
424                                 break;
425                   
426                         case SOUND_MIXER_MIC:
427                                 retval = get_user(value, (unsigned __user *) arg);
428                                 if (retval)
429                                         break;
430                                 arg_to_vol_mono(value, &devc->mic);
431                                 opl3sa2_set_mic(devc, devc->mic);
432                                 value = ret_vol_mono(devc->mic);
433                                 retval = put_user(value, p);
434                                 break;
435
436                         default:
437                                 retval = -EINVAL;
438                 }
439         }
440         else {
441                 /*
442                  * Return parameters
443                  */
444                 switch (cmdf) {
445                         case SOUND_MIXER_DEVMASK:
446                                 retval = put_user(SOUND_MASK_VOLUME | SOUND_MASK_MIC, p);
447                                 break;
448                   
449                         case SOUND_MIXER_STEREODEVS:
450                                 retval = put_user(SOUND_MASK_VOLUME, p);
451                                 break;
452                   
453                         case SOUND_MIXER_RECMASK:
454                                 /* No recording devices */
455                                 retval = put_user(0, p);
456                                 break;
457
458                         case SOUND_MIXER_CAPS:
459                                 retval = put_user(SOUND_CAP_EXCL_INPUT, p);
460                                 break;
461
462                         case SOUND_MIXER_RECSRC:
463                                 /* No recording source */
464                                 retval = put_user(0, p);
465                                 break;
466
467                         case SOUND_MIXER_VOLUME:
468                                 value = ret_vol_stereo(devc->volume_l, devc->volume_r);
469                                 retval = put_user(value, p);
470                                 break;
471                           
472                         case SOUND_MIXER_MIC:
473                                 value = ret_vol_mono(devc->mic);
474                                 put_user(value, p);
475                                 break;
476
477                         default:
478                                 retval = -EINVAL;
479                 }
480         }
481         return retval;
482 }
483 /* opl3sa2_mixer_ioctl end */
484
485
486 static int opl3sa3_mixer_ioctl(int dev, unsigned int cmd, void __user * arg)
487 {
488         int value, retval, cmdf = cmd & 0xff;
489
490         opl3sa2_state_t* devc = &opl3sa2_state[dev];
491
492         switch (cmdf) {
493         case SOUND_MIXER_BASS:
494                 value = ret_vol_stereo(devc->bass_l, devc->bass_r);
495                 retval = put_user(value, (int __user *) arg);
496                 break;
497                 
498         case SOUND_MIXER_TREBLE:
499                 value = ret_vol_stereo(devc->treble_l, devc->treble_r);
500                 retval = put_user(value, (int __user *) arg);
501                 break;
502
503         case SOUND_MIXER_DIGITAL1:
504                 value = ret_vol_stereo(devc->wide_l, devc->wide_r);
505                 retval = put_user(value, (int __user *) arg);
506                 break;
507
508         default:
509                 retval = -EINVAL;
510         }
511         return retval;
512 }
513 /* opl3sa3_mixer_ioctl end */
514
515
516 static struct mixer_operations opl3sa2_mixer_operations =
517 {
518         .owner  = THIS_MODULE,
519         .id     = "OPL3-SA2",
520         .name   = "Yamaha OPL3-SA2",
521         .ioctl  = opl3sa2_mixer_ioctl
522 };
523
524 static struct mixer_operations opl3sa3_mixer_operations =
525 {
526         .owner  = THIS_MODULE,
527         .id     = "OPL3-SA3",
528         .name   = "Yamaha OPL3-SA3",
529         .ioctl  = opl3sa3_mixer_ioctl
530 };
531
532 /* End of mixer-related stuff */
533
534
535 /*
536  * Component probe, attach, unload functions
537  */
538
539 static inline void __exit unload_opl3sa2_mpu(struct address_info *hw_config)
540 {
541         unload_mpu401(hw_config);
542 }
543
544
545 static void __init attach_opl3sa2_mss(struct address_info* hw_config, struct resource *ports)
546 {
547         int initial_mixers;
548
549         initial_mixers = num_mixers;
550         attach_ms_sound(hw_config, ports, THIS_MODULE); /* Slot 0 */
551         if (hw_config->slots[0] != -1) {
552                 /* Did the MSS driver install? */
553                 if(num_mixers == (initial_mixers + 1)) {
554                         /* The MSS mixer is installed, reroute mixers appropiately */
555                         AD1848_REROUTE(SOUND_MIXER_LINE1, SOUND_MIXER_CD);
556                         AD1848_REROUTE(SOUND_MIXER_LINE2, SOUND_MIXER_SYNTH);
557                         AD1848_REROUTE(SOUND_MIXER_LINE3, SOUND_MIXER_LINE);
558                 }
559                 else {
560                         printk(KERN_ERR PFX "MSS mixer not installed?\n");
561                 }
562         }
563 }
564
565
566 static inline void __exit unload_opl3sa2_mss(struct address_info* hw_config)
567 {
568         unload_ms_sound(hw_config);
569 }
570
571
572 static int __init probe_opl3sa2(struct address_info* hw_config, int card)
573 {
574         unsigned char misc;
575         unsigned char tmp;
576         unsigned char version;
577
578         /*
579          * Try and allocate our I/O port range.
580          */
581         if (!request_region(hw_config->io_base, 2, OPL3SA2_MODULE_NAME)) {
582                 printk(KERN_ERR PFX "Control I/O port %#x not free\n",
583                        hw_config->io_base);
584                 goto out_nodev;
585         }
586
587         /*
588          * Check if writing to the read-only version bits of the miscellaneous
589          * register succeeds or not (it should not).
590          */
591         opl3sa2_read(hw_config->io_base, OPL3SA2_MISC, &misc);
592         opl3sa2_write(hw_config->io_base, OPL3SA2_MISC, misc ^ 0x07);
593         opl3sa2_read(hw_config->io_base, OPL3SA2_MISC, &tmp);
594         if(tmp != misc) {
595                 printk(KERN_ERR PFX "Control I/O port %#x is not a YMF7xx chipset!\n",
596                        hw_config->io_base);
597                 goto out_region;
598         }
599
600         /*
601          * Check if the MIC register is accessible.
602          */
603         opl3sa2_read(hw_config->io_base, OPL3SA2_MIC, &tmp);
604         opl3sa2_write(hw_config->io_base, OPL3SA2_MIC, 0x8a);
605         opl3sa2_read(hw_config->io_base, OPL3SA2_MIC, &tmp);
606         if((tmp & 0x9f) != 0x8a) {
607                 printk(KERN_ERR
608                        PFX "Control I/O port %#x is not a YMF7xx chipset!\n",
609                        hw_config->io_base);
610                 goto out_region;
611         }
612         opl3sa2_write(hw_config->io_base, OPL3SA2_MIC, tmp);
613
614         /*
615          * Determine chipset type (SA2 or SA3)
616          *
617          * This is done by looking at the chipset version in the lower 3 bits
618          * of the miscellaneous register.
619          */
620         version = misc & 0x07;
621         printk(KERN_DEBUG PFX "Chipset version = %#x\n", version);
622         switch (version) {
623                 case 0:
624                         opl3sa2_state[card].chipset = CHIPSET_UNKNOWN;
625                         printk(KERN_ERR
626                                PFX "Unknown Yamaha audio controller version\n");
627                         break;
628
629                 case VERSION_YMF711:
630                         opl3sa2_state[card].chipset = CHIPSET_OPL3SA2;
631                         printk(KERN_INFO PFX "Found OPL3-SA2 (YMF711)\n");
632                         break;
633
634                 case VERSION_YMF715:
635                         opl3sa2_state[card].chipset = CHIPSET_OPL3SA3;
636                         printk(KERN_INFO
637                                PFX "Found OPL3-SA3 (YMF715 or YMF719)\n");
638                         break;
639
640                 case VERSION_YMF715B:
641                         opl3sa2_state[card].chipset = CHIPSET_OPL3SA3;
642                         printk(KERN_INFO
643                                PFX "Found OPL3-SA3 (YMF715B or YMF719B)\n");
644                         break;
645
646                 case VERSION_YMF715E:
647                 default:
648                         opl3sa2_state[card].chipset = CHIPSET_OPL3SA3;
649                         printk(KERN_INFO
650                                PFX "Found OPL3-SA3 (YMF715E or YMF719E)\n");
651                         break;
652         }
653
654         if (opl3sa2_state[card].chipset != CHIPSET_UNKNOWN) {
655                 /* Generate a pretty name */
656                 opl3sa2_state[card].chipset_name = (char *)CHIPSET_TABLE[opl3sa2_state[card].chipset];
657                 return 0;
658         }
659
660 out_region:
661         release_region(hw_config->io_base, 2);
662 out_nodev:
663         return -ENODEV;
664 }
665
666
667 static void __init attach_opl3sa2(struct address_info* hw_config, int card)
668 {
669         /* Initialize IRQ configuration to IRQ-B: -, IRQ-A: WSS+MPU+OPL3 */
670         opl3sa2_write(hw_config->io_base, OPL3SA2_IRQ_CONFIG, 0x0d);
671
672         /* Initialize DMA configuration */
673         if(hw_config->dma2 == hw_config->dma) {
674                 /* Want DMA configuration DMA-B: -, DMA-A: WSS-P+WSS-R */
675                 opl3sa2_write(hw_config->io_base, OPL3SA2_DMA_CONFIG, 0x03);
676         }
677         else {
678                 /* Want DMA configuration DMA-B: WSS-R, DMA-A: WSS-P */
679                 opl3sa2_write(hw_config->io_base, OPL3SA2_DMA_CONFIG, 0x21);
680         }
681 }
682
683
684 static void __init attach_opl3sa2_mixer(struct address_info *hw_config, int card)
685 {
686         struct mixer_operations* mixer_operations;
687         opl3sa2_state_t* devc = &opl3sa2_state[card];
688
689         /* Install master mixer */
690         if (devc->chipset == CHIPSET_OPL3SA3) {
691                 mixer_operations = &opl3sa3_mixer_operations;
692         }
693         else {
694                 mixer_operations = &opl3sa2_mixer_operations;
695         }
696
697         devc->cfg_port = hw_config->io_base;
698         devc->mixer = sound_install_mixer(MIXER_DRIVER_VERSION,
699                                           mixer_operations->name,
700                                           mixer_operations,
701                                           sizeof(struct mixer_operations),
702                                           devc);
703         if(devc->mixer < 0) {
704                 printk(KERN_ERR PFX "Could not install %s master mixer\n",
705                          mixer_operations->name);
706         }
707         else {
708                         opl3sa2_mixer_reset(devc);
709
710         }
711 }
712
713
714 static void opl3sa2_clear_slots(struct address_info* hw_config)
715 {
716         int i;
717
718         for(i = 0; i < 6; i++) {
719                 hw_config->slots[i] = -1;
720         }
721 }
722
723
724 static void __init opl3sa2_set_ymode(struct address_info* hw_config, int ymode)
725 {
726         /*
727          * Set the Yamaha 3D enhancement mode (aka Ymersion) if asked to and
728          * it's supported.
729          *
730          * 0: Desktop (aka normal)   5-12 cm speakers
731          * 1: Notebook PC mode 1     3 cm speakers
732          * 2: Notebook PC mode 2     1.5 cm speakers
733          * 3: Hi-fi                  16-38 cm speakers
734          */
735         if(ymode >= 0 && ymode <= 3) {
736                 unsigned char sys_ctrl;
737
738                 opl3sa2_read(hw_config->io_base, OPL3SA2_SYS_CTRL, &sys_ctrl);
739                 sys_ctrl = (sys_ctrl & 0xcf) | ((ymode & 3) << 4);
740                 opl3sa2_write(hw_config->io_base, OPL3SA2_SYS_CTRL, sys_ctrl);
741         }
742         else {
743                 printk(KERN_ERR PFX "not setting ymode, it must be one of 0,1,2,3\n");
744         }
745 }
746
747
748 static void __init opl3sa2_set_loopback(struct address_info* hw_config, int loopback)
749 {
750         if(loopback >= 0 && loopback <= 1) {
751                 unsigned char misc;
752
753                 opl3sa2_read(hw_config->io_base, OPL3SA2_MISC, &misc);
754                 misc = (misc & 0xef) | ((loopback & 1) << 4);
755                 opl3sa2_write(hw_config->io_base, OPL3SA2_MISC, misc);
756         }
757         else {
758                 printk(KERN_ERR PFX "not setting loopback, it must be either 0 or 1\n");
759         }
760 }
761
762
763 static void __exit unload_opl3sa2(struct address_info* hw_config, int card)
764 {
765         /* Release control ports */
766         release_region(hw_config->io_base, 2);
767
768         /* Unload mixer */
769         if(opl3sa2_state[card].mixer >= 0)
770                 sound_unload_mixerdev(opl3sa2_state[card].mixer);
771
772 }
773
774 #ifdef CONFIG_PNP
775 static struct pnp_device_id pnp_opl3sa2_list[] = {
776         {.id = "YMH0021", .driver_data = 0},
777         {.id = ""}
778 };
779
780 MODULE_DEVICE_TABLE(pnp, pnp_opl3sa2_list);
781
782 static int opl3sa2_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id)
783 {
784         int card = opl3sa2_cards_num;
785
786         /* we don't actually want to return an error as the user may have specified
787          * no multiple card search
788          */
789
790         if (opl3sa2_cards_num == OPL3SA2_CARDS_MAX)
791                 return 0;
792         opl3sa2_activated[card] = 1;
793
794         /* Our own config: */
795         opl3sa2_state[card].cfg.io_base = pnp_port_start(dev, 4);
796         opl3sa2_state[card].cfg.irq     = pnp_irq(dev, 0);
797         opl3sa2_state[card].cfg.dma     = pnp_dma(dev, 0);
798         opl3sa2_state[card].cfg.dma2    = pnp_dma(dev, 1);
799
800         /* The MSS config: */
801         opl3sa2_state[card].cfg_mss.io_base      = pnp_port_start(dev, 1);
802         opl3sa2_state[card].cfg_mss.irq          = pnp_irq(dev, 0);
803         opl3sa2_state[card].cfg_mss.dma          = pnp_dma(dev, 0);
804         opl3sa2_state[card].cfg_mss.dma2         = pnp_dma(dev, 1);
805         opl3sa2_state[card].cfg_mss.card_subtype = 1; /* No IRQ or DMA setup */
806
807         opl3sa2_state[card].cfg_mpu.io_base       = pnp_port_start(dev, 3);
808         opl3sa2_state[card].cfg_mpu.irq           = pnp_irq(dev, 0);
809         opl3sa2_state[card].cfg_mpu.dma           = -1;
810         opl3sa2_state[card].cfg_mpu.dma2          = -1;
811         opl3sa2_state[card].cfg_mpu.always_detect = 1; /* It's there, so use shared IRQs */
812
813         /* Call me paranoid: */
814         opl3sa2_clear_slots(&opl3sa2_state[card].cfg);
815         opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mss);
816         opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mpu);
817
818         opl3sa2_state[card].pdev = dev;
819         opl3sa2_cards_num++;
820
821         return 0;
822 }
823
824 static struct pnp_driver opl3sa2_driver = {
825         .name           = "opl3sa2",
826         .id_table       = pnp_opl3sa2_list,
827         .probe          = opl3sa2_pnp_probe,
828 };
829
830 #endif /* CONFIG_PNP */
831
832 /* End of component functions */
833
834 #ifdef CONFIG_PM
835 static DEFINE_SPINLOCK(opl3sa2_lock);
836
837 /* Power Management support functions */
838 static int opl3sa2_suspend(struct pm_dev *pdev, unsigned int pm_mode)
839 {
840         unsigned long flags;
841         opl3sa2_state_t *p;
842
843         if (!pdev)
844                 return -EINVAL;
845
846         spin_lock_irqsave(&opl3sa2_lock,flags);
847
848         p = (opl3sa2_state_t *) pdev->data;
849         switch (pm_mode) {
850         case 1:
851                 pm_mode = OPL3SA2_PM_MODE1;
852                 break;
853         case 2:
854                 pm_mode = OPL3SA2_PM_MODE2;
855                 break;
856         case 3:
857                 pm_mode = OPL3SA2_PM_MODE3;
858                 break;
859         default:
860                 /* we don't know howto handle this... */
861                 spin_unlock_irqrestore(&opl3sa2_lock, flags);
862                 return -EBUSY;
863         }
864
865         p->in_suspend = 1;
866
867         /* its supposed to automute before suspending, so we won't bother */
868         opl3sa2_write(p->cfg_port, OPL3SA2_PM, pm_mode);
869         /* wait a while for the clock oscillator to stabilise */
870         mdelay(10);
871
872         spin_unlock_irqrestore(&opl3sa2_lock,flags);
873         return 0;
874 }
875
876 static int opl3sa2_resume(struct pm_dev *pdev)
877 {
878         unsigned long flags;
879         opl3sa2_state_t *p;
880
881         if (!pdev)
882                 return -EINVAL;
883
884         p = (opl3sa2_state_t *) pdev->data;
885         spin_lock_irqsave(&opl3sa2_lock,flags);
886
887         /* I don't think this is necessary */
888         opl3sa2_write(p->cfg_port, OPL3SA2_PM, OPL3SA2_PM_MODE0);
889         opl3sa2_mixer_restore(p);
890         p->in_suspend = 0;
891
892         spin_unlock_irqrestore(&opl3sa2_lock,flags);
893         return 0;
894 }
895
896 static int opl3sa2_pm_callback(struct pm_dev *pdev, pm_request_t rqst, void *data)
897 {
898         unsigned long mode = (unsigned  long)data;
899
900         switch (rqst) {
901                 case PM_SUSPEND:
902                         return opl3sa2_suspend(pdev, mode);
903
904                 case PM_RESUME:
905                         return opl3sa2_resume(pdev);
906         }
907         return 0;
908 }
909 #endif /* CONFIG_PM */
910
911 /*
912  * Install OPL3-SA2 based card(s).
913  *
914  * Need to have ad1848 and mpu401 loaded ready.
915  */
916 static int __init init_opl3sa2(void)
917 {
918         int card, max;
919
920         /* Sanitize isapnp and multiple settings */
921         isapnp = isapnp != 0 ? 1 : 0;
922         multiple = multiple != 0 ? 1 : 0;
923
924         max = (multiple && isapnp) ? OPL3SA2_CARDS_MAX : 1;
925
926 #ifdef CONFIG_PNP
927         if (isapnp){
928                 pnp_register_driver(&opl3sa2_driver);
929                 if(!opl3sa2_cards_num){
930                         printk(KERN_INFO PFX "No PnP cards found\n");
931                         isapnp = 0;
932                 }
933                 max = opl3sa2_cards_num;
934         }
935 #endif
936
937         for (card = 0; card < max; card++) {
938                 /* If a user wants an I/O then assume they meant it */
939                 struct resource *ports;
940                 int base;
941                 
942                 if (!isapnp) {
943                         if (io == -1 || irq == -1 || dma == -1 ||
944                             dma2 == -1 || mss_io == -1) {
945                                 printk(KERN_ERR
946                                        PFX "io, mss_io, irq, dma, and dma2 must be set\n");
947                                 return -EINVAL;
948                         }
949                         opl3sa2_cards_num++;
950
951                         /*
952                          * Our own config:
953                          * (NOTE: IRQ and DMA aren't used, so they're set to
954                          *  give pretty output from conf_printf. :)
955                          */
956                         opl3sa2_state[card].cfg.io_base = io;
957                         opl3sa2_state[card].cfg.irq     = irq;
958                         opl3sa2_state[card].cfg.dma     = dma;
959                         opl3sa2_state[card].cfg.dma2    = dma2;
960         
961                         /* The MSS config: */
962                         opl3sa2_state[card].cfg_mss.io_base      = mss_io;
963                         opl3sa2_state[card].cfg_mss.irq          = irq;
964                         opl3sa2_state[card].cfg_mss.dma          = dma;
965                         opl3sa2_state[card].cfg_mss.dma2         = dma2;
966                         opl3sa2_state[card].cfg_mss.card_subtype = 1; /* No IRQ or DMA setup */
967
968                         opl3sa2_state[card].cfg_mpu.io_base       = mpu_io;
969                         opl3sa2_state[card].cfg_mpu.irq           = irq;
970                         opl3sa2_state[card].cfg_mpu.dma           = -1;
971                         opl3sa2_state[card].cfg_mpu.always_detect = 1; /* Use shared IRQs */
972
973                         /* Call me paranoid: */
974                         opl3sa2_clear_slots(&opl3sa2_state[card].cfg);
975                         opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mss);
976                         opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mpu);
977                 }
978
979                 /* FIXME: leak */
980                 if (probe_opl3sa2(&opl3sa2_state[card].cfg, card))
981                         return -ENODEV;
982
983                 base = opl3sa2_state[card].cfg_mss.io_base;
984
985                 if (!request_region(base, 4, "WSS config"))
986                         goto failed;
987
988                 ports = request_region(base + 4, 4, "ad1848");
989                 if (!ports)
990                         goto failed2;
991
992                 if (!probe_ms_sound(&opl3sa2_state[card].cfg_mss, ports)) {
993                         /*
994                          * If one or more cards are already registered, don't
995                          * return an error but print a warning.  Note, this
996                          * should never really happen unless the hardware or
997                          * ISA PnP screwed up.
998                          */
999                         release_region(base + 4, 4);
1000                 failed2:
1001                         release_region(base, 4);
1002                 failed:
1003                         release_region(opl3sa2_state[card].cfg.io_base, 2);
1004
1005                         if (opl3sa2_cards_num) {
1006                                 printk(KERN_WARNING
1007                                        PFX "There was a problem probing one "
1008                                        " of the ISA PNP cards, continuing\n");
1009                                 opl3sa2_cards_num--;
1010                                 continue;
1011                         } else
1012                                 return -ENODEV;
1013                 }
1014
1015                 attach_opl3sa2(&opl3sa2_state[card].cfg, card);
1016                 conf_printf(opl3sa2_state[card].chipset_name, &opl3sa2_state[card].cfg);
1017                 attach_opl3sa2_mixer(&opl3sa2_state[card].cfg, card);
1018                 attach_opl3sa2_mss(&opl3sa2_state[card].cfg_mss, ports);
1019
1020                 /* ewww =) */
1021                 opl3sa2_state[card].card = card;
1022 #ifdef CONFIG_PM
1023                 /* register our power management capabilities */
1024                 opl3sa2_state[card].pmdev = pm_register(PM_ISA_DEV, card, opl3sa2_pm_callback);
1025                 if (opl3sa2_state[card].pmdev)
1026                         opl3sa2_state[card].pmdev->data = &opl3sa2_state[card];
1027 #endif /* CONFIG_PM */
1028
1029                 /*
1030                  * Set the Yamaha 3D enhancement mode (aka Ymersion) if asked to and
1031                  * it's supported.
1032                  */
1033                 if (ymode != -1) {
1034                         if (opl3sa2_state[card].chipset == CHIPSET_OPL3SA2) {
1035                                 printk(KERN_ERR
1036                                        PFX "ymode not supported on OPL3-SA2\n");
1037                         }
1038                         else {
1039                                 opl3sa2_set_ymode(&opl3sa2_state[card].cfg, ymode);
1040                         }
1041                 }
1042
1043
1044                 /* Set A/D input to Mono loopback if asked to. */
1045                 if (loopback != -1) {
1046                         opl3sa2_set_loopback(&opl3sa2_state[card].cfg, loopback);
1047                 }
1048                 
1049                 /* Attach MPU if we've been asked to do so, failure isn't fatal */
1050                 if (opl3sa2_state[card].cfg_mpu.io_base != -1) {
1051                         int base = opl3sa2_state[card].cfg_mpu.io_base;
1052                         struct resource *ports;
1053                         ports = request_region(base, 2, "mpu401");
1054                         if (!ports)
1055                                 goto out;
1056                         if (!probe_mpu401(&opl3sa2_state[card].cfg_mpu, ports)) {
1057                                 release_region(base, 2);
1058                                 goto out;
1059                         }
1060                         if (attach_mpu401(&opl3sa2_state[card].cfg_mpu, THIS_MODULE)) {
1061                                 printk(KERN_ERR PFX "failed to attach MPU401\n");
1062                                 opl3sa2_state[card].cfg_mpu.slots[1] = -1;
1063                         }
1064                 }
1065         }
1066
1067 out:
1068         if (isapnp) {
1069                 printk(KERN_NOTICE PFX "%d PnP card(s) found.\n", opl3sa2_cards_num);
1070         }
1071
1072         return 0;
1073 }
1074
1075
1076 /*
1077  * Uninstall OPL3-SA2 based card(s).
1078  */
1079 static void __exit cleanup_opl3sa2(void)
1080 {
1081         int card;
1082
1083         for(card = 0; card < opl3sa2_cards_num; card++) {
1084 #ifdef CONFIG_PM
1085                 if (opl3sa2_state[card].pmdev)
1086                         pm_unregister(opl3sa2_state[card].pmdev);
1087 #endif
1088                 if (opl3sa2_state[card].cfg_mpu.slots[1] != -1) {
1089                         unload_opl3sa2_mpu(&opl3sa2_state[card].cfg_mpu);
1090                 }
1091                 unload_opl3sa2_mss(&opl3sa2_state[card].cfg_mss);
1092                 unload_opl3sa2(&opl3sa2_state[card].cfg, card);
1093 #ifdef CONFIG_PNP
1094                 pnp_unregister_driver(&opl3sa2_driver);
1095 #endif
1096         }
1097 }
1098
1099 module_init(init_opl3sa2);
1100 module_exit(cleanup_opl3sa2);
1101
1102 #ifndef MODULE
1103 static int __init setup_opl3sa2(char *str)
1104 {
1105         /* io, irq, dma, dma2,... */
1106 #ifdef CONFIG_PNP
1107         int ints[11];
1108 #else
1109         int ints[9];
1110 #endif
1111         str = get_options(str, ARRAY_SIZE(ints), ints);
1112         
1113         io       = ints[1];
1114         irq      = ints[2];
1115         dma      = ints[3];
1116         dma2     = ints[4];
1117         mss_io   = ints[5];
1118         mpu_io   = ints[6];
1119         ymode    = ints[7];
1120         loopback = ints[8];
1121 #ifdef CONFIG_PNP
1122         isapnp   = ints[9];
1123         multiple = ints[10];
1124 #endif
1125         return 1;
1126 }
1127
1128 __setup("opl3sa2=", setup_opl3sa2);
1129 #endif