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(mss_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
1130
|
This page was automatically generated by the
LXR engine.
|