?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
BUG_ON() Conversion in mm/swap_state.c
[firewire-audio.git] / sound / oss / opl3sa2.c
blob0e161c6a04770c313ed157a1d99acc8b2b349fc9
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 "sound_config.h"
73
74 #include "ad1848.h"
75 #include "mpu401.h"
76
77 #define OPL3SA2_MODULE_NAME "opl3sa2"
78 #define PFX OPL3SA2_MODULE_NAME ": "
79
80 /* Useful control port indexes: */
81 #define OPL3SA2_PM 0x01
82 #define OPL3SA2_SYS_CTRL 0x02
83 #define OPL3SA2_IRQ_CONFIG 0x03
84 #define OPL3SA2_DMA_CONFIG 0x06
85 #define OPL3SA2_MASTER_LEFT 0x07
86 #define OPL3SA2_MASTER_RIGHT 0x08
87 #define OPL3SA2_MIC 0x09
88 #define OPL3SA2_MISC 0x0A
89
90 #define OPL3SA3_WIDE 0x14
91 #define OPL3SA3_BASS 0x15
92 #define OPL3SA3_TREBLE 0x16
93
94 /* Useful constants: */
95 #define DEFAULT_VOLUME 50
96 #define DEFAULT_MIC 50
97 #define DEFAULT_TIMBRE 0
98
99 /* Power saving modes */
100 #define OPL3SA2_PM_MODE0 0x00
101 #define OPL3SA2_PM_MODE1 0x04 /* PSV */
102 #define OPL3SA2_PM_MODE2 0x05 /* PSV | PDX */
103 #define OPL3SA2_PM_MODE3 0x27 /* ADOWN | PSV | PDN | PDX */
104
105
106 /* For checking against what the card returns: */
107 #define VERSION_UNKNOWN 0
108 #define VERSION_YMF711 1
109 #define VERSION_YMF715 2
110 #define VERSION_YMF715B 3
111 #define VERSION_YMF715E 4
112 /* also assuming that anything > 4 but <= 7 is a 715E */
113
114 /* Chipset type constants for use below */
115 #define CHIPSET_UNKNOWN -1
116 #define CHIPSET_OPL3SA2 0
117 #define CHIPSET_OPL3SA3 1
118 static const char *CHIPSET_TABLE[] = {"OPL3-SA2", "OPL3-SA3"};
119
120 #ifdef CONFIG_PNP
121 #define OPL3SA2_CARDS_MAX 4
122 #else
123 #define OPL3SA2_CARDS_MAX 1
124 #endif
125
126 /* This should be pretty obvious */
127 static int opl3sa2_cards_num;
128
129 typedef struct {
130 /* device resources */
131 unsigned short cfg_port;
132 struct address_info cfg;
133 struct address_info cfg_mss;
134 struct address_info cfg_mpu;
135 #ifdef CONFIG_PNP
136 /* PnP Stuff */
137 struct pnp_dev* pdev;
138 int activated; /* Whether said devices have been activated */
139 #endif
140 unsigned int card;
141 int chipset; /* What's my version(s)? */
142 char *chipset_name;
143
144 /* mixer data */
145 int mixer;
146 unsigned int volume_l;
147 unsigned int volume_r;
148 unsigned int mic;
149 unsigned int bass_l;
150 unsigned int bass_r;
151 unsigned int treble_l;
152 unsigned int treble_r;
153 unsigned int wide_l;
154 unsigned int wide_r;
155 } opl3sa2_state_t;
156 static opl3sa2_state_t opl3sa2_state[OPL3SA2_CARDS_MAX];
157
158
159
160 /* Our parameters */
161 static int __initdata io = -1;
162 static int __initdata mss_io = -1;
163 static int __initdata mpu_io = -1;
164 static int __initdata irq = -1;
165 static int __initdata dma = -1;
166 static int __initdata dma2 = -1;
167 static int __initdata ymode = -1;
168 static int __initdata loopback = -1;
169
170 #ifdef CONFIG_PNP
171 /* PnP specific parameters */
172 static int __initdata isapnp = 1;
173 static int __initdata multiple = 1;
174
175 /* Whether said devices have been activated */
176 static int opl3sa2_activated[OPL3SA2_CARDS_MAX];
177 #else
178 static int __initdata isapnp; /* = 0 */
179 static int __initdata multiple; /* = 0 */
180 #endif
181
182 MODULE_DESCRIPTION("Module for OPL3-SA2 and SA3 sound cards (uses AD1848 MSS driver).");
183 MODULE_AUTHOR("Scott Murray <scott@spiteful.org>");
184 MODULE_LICENSE("GPL");
185
186
187 module_param(io, int, 0);
188 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)");
189
190 module_param(mss_io, int, 0);
191 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)");
192
193 module_param(mpu_io, int, 0);
194 MODULE_PARM_DESC(mpu_io, "Set MIDI I/O base (0x330 or other. Address must be even and must be from 0x300 to 0x334)");
195
196 module_param(irq, int, 0);
197 MODULE_PARM_DESC(irq, "Set MSS (audio) IRQ (5, 7, 9, 10, 11, 12)");
198
199 module_param(dma, int, 0);
200 MODULE_PARM_DESC(dma, "Set MSS (audio) first DMA channel (0, 1, 3)");
201
202 module_param(dma2, int, 0);
203 MODULE_PARM_DESC(dma2, "Set MSS (audio) second DMA channel (0, 1, 3)");
204
205 module_param(ymode, int, 0);
206 MODULE_PARM_DESC(ymode, "Set Yamaha 3D enhancement mode (0 = Desktop/Normal, 1 = Notebook PC (1), 2 = Notebook PC (2), 3 = Hi-Fi)");
207
208 module_param(loopback, int, 0);
209 MODULE_PARM_DESC(loopback, "Set A/D input source. Useful for echo cancellation (0 = Mic Rch (default), 1 = Mono output loopback)");
210
211 #ifdef CONFIG_PNP
212 module_param(isapnp, bool, 0);
213 MODULE_PARM_DESC(isapnp, "When set to 0, ISA PnP support will be disabled");
214
215 module_param(multiple, bool, 0);
216 MODULE_PARM_DESC(multiple, "When set to 0, will not search for multiple cards");
217 #endif
218
219
220 /*
221 * Standard read and write functions
222 */
223
224 static inline void opl3sa2_write(unsigned short port,
225 unsigned char index,
226 unsigned char data)
227 {
228 outb_p(index, port);
229 outb(data, port + 1);
230 }
231
232
233 static inline void opl3sa2_read(unsigned short port,
234 unsigned char index,
235 unsigned char* data)
236 {
237 outb_p(index, port);
238 *data = inb(port + 1);
239 }
240
241
242 /*
243 * All of the mixer functions...
244 */
245
246 static void opl3sa2_set_volume(opl3sa2_state_t* devc, int left, int right)
247 {
248 static unsigned char scale[101] = {
249 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e,
250 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0c,
251 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b,
252 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09,
253 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08,
254 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06,
255 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
256 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03,
257 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01,
258 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
259 0x00
260 };
261 unsigned char vol;
262
263 vol = scale[left];
264
265 /* If level is zero, turn on mute */
266 if(!left)
267 vol |= 0x80;
268
269 opl3sa2_write(devc->cfg_port, OPL3SA2_MASTER_LEFT, vol);
270
271 vol = scale[right];
272
273 /* If level is zero, turn on mute */
274 if(!right)
275 vol |= 0x80;
276
277 opl3sa2_write(devc->cfg_port, OPL3SA2_MASTER_RIGHT, vol);
278 }
279
280
281 static void opl3sa2_set_mic(opl3sa2_state_t* devc, int level)
282 {
283 unsigned char vol = 0x1F;
284
285 if((level >= 0) && (level <= 100))
286 vol = 0x1F - (unsigned char) (32 * level / 101);
287
288 /* If level is zero, turn on mute */
289 if(!level)
290 vol |= 0x80;
291
292 opl3sa2_write(devc->cfg_port, OPL3SA2_MIC, vol);
293 }
294
295
296 static void opl3sa3_set_bass(opl3sa2_state_t* devc, int left, int right)
297 {
298 unsigned char bass;
299
300 bass = left ? ((unsigned char) (8 * left / 101)) : 0;
301 bass |= (right ? ((unsigned char) (8 * right / 101)) : 0) << 4;
302
303 opl3sa2_write(devc->cfg_port, OPL3SA3_BASS, bass);
304 }
305
306
307 static void opl3sa3_set_treble(opl3sa2_state_t* devc, int left, int right)
308 {
309 unsigned char treble;
310
311 treble = left ? ((unsigned char) (8 * left / 101)) : 0;
312 treble |= (right ? ((unsigned char) (8 * right / 101)) : 0) << 4;
313
314 opl3sa2_write(devc->cfg_port, OPL3SA3_TREBLE, treble);
315 }
316
317
318
319
320 static void opl3sa2_mixer_reset(opl3sa2_state_t* devc)
321 {
322 if (devc) {
323 opl3sa2_set_volume(devc, DEFAULT_VOLUME, DEFAULT_VOLUME);
324 devc->volume_l = devc->volume_r = DEFAULT_VOLUME;
325
326 opl3sa2_set_mic(devc, DEFAULT_MIC);
327 devc->mic = DEFAULT_MIC;
328
329 if (devc->chipset == CHIPSET_OPL3SA3) {
330 opl3sa3_set_bass(devc, DEFAULT_TIMBRE, DEFAULT_TIMBRE);
331 devc->bass_l = devc->bass_r = DEFAULT_TIMBRE;
332 opl3sa3_set_treble(devc, DEFAULT_TIMBRE, DEFAULT_TIMBRE);
333 devc->treble_l = devc->treble_r = DEFAULT_TIMBRE;
334 }
335 }
336 }
337
338 static inline void arg_to_vol_mono(unsigned int vol, int* value)
339 {
340 int left;
341
342 left = vol & 0x00ff;
343 if (left > 100)
344 left = 100;
345 *value = left;
346 }
347
348
349 static inline void arg_to_vol_stereo(unsigned int vol, int* aleft, int* aright)
350 {
351 arg_to_vol_mono(vol, aleft);
352 arg_to_vol_mono(vol >> 8, aright);
353 }
354
355
356 static inline int ret_vol_mono(int vol)
357 {
358 return ((vol << 8) | vol);
359 }
360
361
362 static inline int ret_vol_stereo(int left, int right)
363 {
364 return ((right << 8) | left);
365 }
366
367
368 static int opl3sa2_mixer_ioctl(int dev, unsigned int cmd, void __user *arg)
369 {
370 int retval, value, cmdf = cmd & 0xff;
371 int __user *p = (int __user *)arg;
372
373 opl3sa2_state_t* devc = &opl3sa2_state[dev];
374
375 switch (cmdf) {
376 case SOUND_MIXER_VOLUME:
377 case SOUND_MIXER_MIC:
378 case SOUND_MIXER_DEVMASK:
379 case SOUND_MIXER_STEREODEVS:
380 case SOUND_MIXER_RECMASK:
381 case SOUND_MIXER_RECSRC:
382 case SOUND_MIXER_CAPS:
383 break;
384
385 default:
386 return -EINVAL;
387 }
388
389 if (((cmd >> 8) & 0xff) != 'M')
390 return -EINVAL;
391
392 retval = 0;
393 if (_SIOC_DIR (cmd) & _SIOC_WRITE) {
394 switch (cmdf) {
395 case SOUND_MIXER_VOLUME:
396 retval = get_user(value, (unsigned __user *) arg);
397 if (retval)
398 break;
399 arg_to_vol_stereo(value, &devc->volume_l, &devc->volume_r);
400 opl3sa2_set_volume(devc, devc->volume_l, devc->volume_r);
401 value = ret_vol_stereo(devc->volume_l, devc->volume_r);
402 retval = put_user(value, p);
403 break;
404
405 case SOUND_MIXER_MIC:
406 retval = get_user(value, (unsigned __user *) arg);
407 if (retval)
408 break;
409 arg_to_vol_mono(value, &devc->mic);
410 opl3sa2_set_mic(devc, devc->mic);
411 value = ret_vol_mono(devc->mic);
412 retval = put_user(value, p);
413 break;
414
415 default:
416 retval = -EINVAL;
417 }
418 }
419 else {
420 /*
421 * Return parameters
422 */
423 switch (cmdf) {
424 case SOUND_MIXER_DEVMASK:
425 retval = put_user(SOUND_MASK_VOLUME | SOUND_MASK_MIC, p);
426 break;
427
428 case SOUND_MIXER_STEREODEVS:
429 retval = put_user(SOUND_MASK_VOLUME, p);
430 break;
431
432 case SOUND_MIXER_RECMASK:
433 /* No recording devices */
434 retval = put_user(0, p);
435 break;
436
437 case SOUND_MIXER_CAPS:
438 retval = put_user(SOUND_CAP_EXCL_INPUT, p);
439 break;
440
441 case SOUND_MIXER_RECSRC:
442 /* No recording source */
443 retval = put_user(0, p);
444 break;
445
446 case SOUND_MIXER_VOLUME:
447 value = ret_vol_stereo(devc->volume_l, devc->volume_r);
448 retval = put_user(value, p);
449 break;
450
451 case SOUND_MIXER_MIC:
452 value = ret_vol_mono(devc->mic);
453 put_user(value, p);
454 break;
455
456 default:
457 retval = -EINVAL;
458 }
459 }
460 return retval;
461 }
462 /* opl3sa2_mixer_ioctl end */
463
464
465 static int opl3sa3_mixer_ioctl(int dev, unsigned int cmd, void __user * arg)
466 {
467 int value, retval, cmdf = cmd & 0xff;
468
469 opl3sa2_state_t* devc = &opl3sa2_state[dev];
470
471 switch (cmdf) {
472 case SOUND_MIXER_BASS:
473 value = ret_vol_stereo(devc->bass_l, devc->bass_r);
474 retval = put_user(value, (int __user *) arg);
475 break;
476
477 case SOUND_MIXER_TREBLE:
478 value = ret_vol_stereo(devc->treble_l, devc->treble_r);
479 retval = put_user(value, (int __user *) arg);
480 break;
481
482 case SOUND_MIXER_DIGITAL1:
483 value = ret_vol_stereo(devc->wide_l, devc->wide_r);
484 retval = put_user(value, (int __user *) arg);
485 break;
486
487 default:
488 retval = -EINVAL;
489 }
490 return retval;
491 }
492 /* opl3sa3_mixer_ioctl end */
493
494
495 static struct mixer_operations opl3sa2_mixer_operations =
496 {
497 .owner = THIS_MODULE,
498 .id = "OPL3-SA2",
499 .name = "Yamaha OPL3-SA2",
500 .ioctl = opl3sa2_mixer_ioctl
501 };
502
503 static struct mixer_operations opl3sa3_mixer_operations =
504 {
505 .owner = THIS_MODULE,
506 .id = "OPL3-SA3",
507 .name = "Yamaha OPL3-SA3",
508 .ioctl = opl3sa3_mixer_ioctl
509 };
510
511 /* End of mixer-related stuff */
512
513
514 /*
515 * Component probe, attach, unload functions
516 */
517
518 static inline void __exit unload_opl3sa2_mpu(struct address_info *hw_config)
519 {
520 unload_mpu401(hw_config);
521 }
522
523
524 static void __init attach_opl3sa2_mss(struct address_info* hw_config, struct resource *ports)
525 {
526 int initial_mixers;
527
528 initial_mixers = num_mixers;
529 attach_ms_sound(hw_config, ports, THIS_MODULE); /* Slot 0 */
530 if (hw_config->slots[0] != -1) {
531 /* Did the MSS driver install? */
532 if(num_mixers == (initial_mixers + 1)) {
533 /* The MSS mixer is installed, reroute mixers appropriately */
534 AD1848_REROUTE(SOUND_MIXER_LINE1, SOUND_MIXER_CD);
535 AD1848_REROUTE(SOUND_MIXER_LINE2, SOUND_MIXER_SYNTH);
536 AD1848_REROUTE(SOUND_MIXER_LINE3, SOUND_MIXER_LINE);
537 }
538 else {
539 printk(KERN_ERR PFX "MSS mixer not installed?\n");
540 }
541 }
542 }
543
544
545 static inline void __exit unload_opl3sa2_mss(struct address_info* hw_config)
546 {
547 unload_ms_sound(hw_config);
548 }
549
550
551 static int __init probe_opl3sa2(struct address_info* hw_config, int card)
552 {
553 unsigned char misc;
554 unsigned char tmp;
555 unsigned char version;
556
557 /*
558 * Try and allocate our I/O port range.
559 */
560 if (!request_region(hw_config->io_base, 2, OPL3SA2_MODULE_NAME)) {
561 printk(KERN_ERR PFX "Control I/O port %#x not free\n",
562 hw_config->io_base);
563 goto out_nodev;
564 }
565
566 /*
567 * Check if writing to the read-only version bits of the miscellaneous
568 * register succeeds or not (it should not).
569 */
570 opl3sa2_read(hw_config->io_base, OPL3SA2_MISC, &misc);
571 opl3sa2_write(hw_config->io_base, OPL3SA2_MISC, misc ^ 0x07);
572 opl3sa2_read(hw_config->io_base, OPL3SA2_MISC, &tmp);
573 if(tmp != misc) {
574 printk(KERN_ERR PFX "Control I/O port %#x is not a YMF7xx chipset!\n",
575 hw_config->io_base);
576 goto out_region;
577 }
578
579 /*
580 * Check if the MIC register is accessible.
581 */
582 opl3sa2_read(hw_config->io_base, OPL3SA2_MIC, &tmp);
583 opl3sa2_write(hw_config->io_base, OPL3SA2_MIC, 0x8a);
584 opl3sa2_read(hw_config->io_base, OPL3SA2_MIC, &tmp);
585 if((tmp & 0x9f) != 0x8a) {
586 printk(KERN_ERR
587 PFX "Control I/O port %#x is not a YMF7xx chipset!\n",
588 hw_config->io_base);
589 goto out_region;
590 }
591 opl3sa2_write(hw_config->io_base, OPL3SA2_MIC, tmp);
592
593 /*
594 * Determine chipset type (SA2 or SA3)
595 *
596 * This is done by looking at the chipset version in the lower 3 bits
597 * of the miscellaneous register.
598 */
599 version = misc & 0x07;
600 printk(KERN_DEBUG PFX "Chipset version = %#x\n", version);
601 switch (version) {
602 case 0:
603 opl3sa2_state[card].chipset = CHIPSET_UNKNOWN;
604 printk(KERN_ERR
605 PFX "Unknown Yamaha audio controller version\n");
606 break;
607
608 case VERSION_YMF711:
609 opl3sa2_state[card].chipset = CHIPSET_OPL3SA2;
610 printk(KERN_INFO PFX "Found OPL3-SA2 (YMF711)\n");
611 break;
612
613 case VERSION_YMF715:
614 opl3sa2_state[card].chipset = CHIPSET_OPL3SA3;
615 printk(KERN_INFO
616 PFX "Found OPL3-SA3 (YMF715 or YMF719)\n");
617 break;
618
619 case VERSION_YMF715B:
620 opl3sa2_state[card].chipset = CHIPSET_OPL3SA3;
621 printk(KERN_INFO
622 PFX "Found OPL3-SA3 (YMF715B or YMF719B)\n");
623 break;
624
625 case VERSION_YMF715E:
626 default:
627 opl3sa2_state[card].chipset = CHIPSET_OPL3SA3;
628 printk(KERN_INFO
629 PFX "Found OPL3-SA3 (YMF715E or YMF719E)\n");
630 break;
631 }
632
633 if (opl3sa2_state[card].chipset != CHIPSET_UNKNOWN) {
634 /* Generate a pretty name */
635 opl3sa2_state[card].chipset_name = (char *)CHIPSET_TABLE[opl3sa2_state[card].chipset];
636 return 0;
637 }
638
639 out_region:
640 release_region(hw_config->io_base, 2);
641 out_nodev:
642 return -ENODEV;
643 }
644
645
646 static void __init attach_opl3sa2(struct address_info* hw_config, int card)
647 {
648 /* Initialize IRQ configuration to IRQ-B: -, IRQ-A: WSS+MPU+OPL3 */
649 opl3sa2_write(hw_config->io_base, OPL3SA2_IRQ_CONFIG, 0x0d);
650
651 /* Initialize DMA configuration */
652 if(hw_config->dma2 == hw_config->dma) {
653 /* Want DMA configuration DMA-B: -, DMA-A: WSS-P+WSS-R */
654 opl3sa2_write(hw_config->io_base, OPL3SA2_DMA_CONFIG, 0x03);
655 }
656 else {
657 /* Want DMA configuration DMA-B: WSS-R, DMA-A: WSS-P */
658 opl3sa2_write(hw_config->io_base, OPL3SA2_DMA_CONFIG, 0x21);
659 }
660 }
661
662
663 static void __init attach_opl3sa2_mixer(struct address_info *hw_config, int card)
664 {
665 struct mixer_operations* mixer_operations;
666 opl3sa2_state_t* devc = &opl3sa2_state[card];
667
668 /* Install master mixer */
669 if (devc->chipset == CHIPSET_OPL3SA3) {
670 mixer_operations = &opl3sa3_mixer_operations;
671 }
672 else {
673 mixer_operations = &opl3sa2_mixer_operations;
674 }
675
676 devc->cfg_port = hw_config->io_base;
677 devc->mixer = sound_install_mixer(MIXER_DRIVER_VERSION,
678 mixer_operations->name,
679 mixer_operations,
680 sizeof(struct mixer_operations),
681 devc);
682 if(devc->mixer < 0) {
683 printk(KERN_ERR PFX "Could not install %s master mixer\n",
684 mixer_operations->name);
685 }
686 else {
687 opl3sa2_mixer_reset(devc);
688
689 }
690 }
691
692
693 static void opl3sa2_clear_slots(struct address_info* hw_config)
694 {
695 int i;
696
697 for(i = 0; i < 6; i++) {
698 hw_config->slots[i] = -1;
699 }
700 }
701
702
703 static void __init opl3sa2_set_ymode(struct address_info* hw_config, int ymode)
704 {
705 /*
706 * Set the Yamaha 3D enhancement mode (aka Ymersion) if asked to and
707 * it's supported.
708 *
709 * 0: Desktop (aka normal) 5-12 cm speakers
710 * 1: Notebook PC mode 1 3 cm speakers
711 * 2: Notebook PC mode 2 1.5 cm speakers
712 * 3: Hi-fi 16-38 cm speakers
713 */
714 if(ymode >= 0 && ymode <= 3) {
715 unsigned char sys_ctrl;
716
717 opl3sa2_read(hw_config->io_base, OPL3SA2_SYS_CTRL, &sys_ctrl);
718 sys_ctrl = (sys_ctrl & 0xcf) | ((ymode & 3) << 4);
719 opl3sa2_write(hw_config->io_base, OPL3SA2_SYS_CTRL, sys_ctrl);
720 }
721 else {
722 printk(KERN_ERR PFX "not setting ymode, it must be one of 0,1,2,3\n");
723 }
724 }
725
726
727 static void __init opl3sa2_set_loopback(struct address_info* hw_config, int loopback)
728 {
729 if(loopback >= 0 && loopback <= 1) {
730 unsigned char misc;
731
732 opl3sa2_read(hw_config->io_base, OPL3SA2_MISC, &misc);
733 misc = (misc & 0xef) | ((loopback & 1) << 4);
734 opl3sa2_write(hw_config->io_base, OPL3SA2_MISC, misc);
735 }
736 else {
737 printk(KERN_ERR PFX "not setting loopback, it must be either 0 or 1\n");
738 }
739 }
740
741
742 static void __exit unload_opl3sa2(struct address_info* hw_config, int card)
743 {
744 /* Release control ports */
745 release_region(hw_config->io_base, 2);
746
747 /* Unload mixer */
748 if(opl3sa2_state[card].mixer >= 0)
749 sound_unload_mixerdev(opl3sa2_state[card].mixer);
750
751 }
752
753 #ifdef CONFIG_PNP
754 static struct pnp_device_id pnp_opl3sa2_list[] = {
755 {.id = "YMH0021", .driver_data = 0},
756 {.id = ""}
757 };
758
759 MODULE_DEVICE_TABLE(pnp, pnp_opl3sa2_list);
760
761 static int opl3sa2_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id)
762 {
763 int card = opl3sa2_cards_num;
764
765 /* we don't actually want to return an error as the user may have specified
766 * no multiple card search
767 */
768
769 if (opl3sa2_cards_num == OPL3SA2_CARDS_MAX)
770 return 0;
771 opl3sa2_activated[card] = 1;
772
773 /* Our own config: */
774 opl3sa2_state[card].cfg.io_base = pnp_port_start(dev, 4);
775 opl3sa2_state[card].cfg.irq = pnp_irq(dev, 0);
776 opl3sa2_state[card].cfg.dma = pnp_dma(dev, 0);
777 opl3sa2_state[card].cfg.dma2 = pnp_dma(dev, 1);
778
779 /* The MSS config: */
780 opl3sa2_state[card].cfg_mss.io_base = pnp_port_start(dev, 1);
781 opl3sa2_state[card].cfg_mss.irq = pnp_irq(dev, 0);
782 opl3sa2_state[card].cfg_mss.dma = pnp_dma(dev, 0);
783 opl3sa2_state[card].cfg_mss.dma2 = pnp_dma(dev, 1);
784 opl3sa2_state[card].cfg_mss.card_subtype = 1; /* No IRQ or DMA setup */
785
786 opl3sa2_state[card].cfg_mpu.io_base = pnp_port_start(dev, 3);
787 opl3sa2_state[card].cfg_mpu.irq = pnp_irq(dev, 0);
788 opl3sa2_state[card].cfg_mpu.dma = -1;
789 opl3sa2_state[card].cfg_mpu.dma2 = -1;
790 opl3sa2_state[card].cfg_mpu.always_detect = 1; /* It's there, so use shared IRQs */
791
792 /* Call me paranoid: */
793 opl3sa2_clear_slots(&opl3sa2_state[card].cfg);
794 opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mss);
795 opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mpu);
796
797 opl3sa2_state[card].pdev = dev;
798 opl3sa2_cards_num++;
799
800 return 0;
801 }
802
803 static struct pnp_driver opl3sa2_driver = {
804 .name = "opl3sa2",
805 .id_table = pnp_opl3sa2_list,
806 .probe = opl3sa2_pnp_probe,
807 };
808
809 #endif /* CONFIG_PNP */
810
811 /* End of component functions */
812
813 /*
814 * Install OPL3-SA2 based card(s).
815 *
816 * Need to have ad1848 and mpu401 loaded ready.
817 */
818 static int __init init_opl3sa2(void)
819 {
820 int card, max;
821
822 /* Sanitize isapnp and multiple settings */
823 isapnp = isapnp != 0 ? 1 : 0;
824 multiple = multiple != 0 ? 1 : 0;
825
826 max = (multiple && isapnp) ? OPL3SA2_CARDS_MAX : 1;
827
828 #ifdef CONFIG_PNP
829 if (isapnp){
830 pnp_register_driver(&opl3sa2_driver);
831 if(!opl3sa2_cards_num){
832 printk(KERN_INFO PFX "No PnP cards found\n");
833 isapnp = 0;
834 }
835 max = opl3sa2_cards_num;
836 }
837 #endif
838
839 for (card = 0; card < max; card++) {
840 /* If a user wants an I/O then assume they meant it */
841 struct resource *ports;
842 int base;
843
844 if (!isapnp) {
845 if (io == -1 || irq == -1 || dma == -1 ||
846 dma2 == -1 || mss_io == -1) {
847 printk(KERN_ERR
848 PFX "io, mss_io, irq, dma, and dma2 must be set\n");
849 return -EINVAL;
850 }
851 opl3sa2_cards_num++;
852
853 /*
854 * Our own config:
855 * (NOTE: IRQ and DMA aren't used, so they're set to
856 * give pretty output from conf_printf. :)
857 */
858 opl3sa2_state[card].cfg.io_base = io;
859 opl3sa2_state[card].cfg.irq = irq;
860 opl3sa2_state[card].cfg.dma = dma;
861 opl3sa2_state[card].cfg.dma2 = dma2;
862
863 /* The MSS config: */
864 opl3sa2_state[card].cfg_mss.io_base = mss_io;
865 opl3sa2_state[card].cfg_mss.irq = irq;
866 opl3sa2_state[card].cfg_mss.dma = dma;
867 opl3sa2_state[card].cfg_mss.dma2 = dma2;
868 opl3sa2_state[card].cfg_mss.card_subtype = 1; /* No IRQ or DMA setup */
869
870 opl3sa2_state[card].cfg_mpu.io_base = mpu_io;
871 opl3sa2_state[card].cfg_mpu.irq = irq;
872 opl3sa2_state[card].cfg_mpu.dma = -1;
873 opl3sa2_state[card].cfg_mpu.always_detect = 1; /* Use shared IRQs */
874
875 /* Call me paranoid: */
876 opl3sa2_clear_slots(&opl3sa2_state[card].cfg);
877 opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mss);
878 opl3sa2_clear_slots(&opl3sa2_state[card].cfg_mpu);
879 }
880
881 /* FIXME: leak */
882 if (probe_opl3sa2(&opl3sa2_state[card].cfg, card))
883 return -ENODEV;
884
885 base = opl3sa2_state[card].cfg_mss.io_base;
886
887 if (!request_region(base, 4, "WSS config"))
888 goto failed;
889
890 ports = request_region(base + 4, 4, "ad1848");
891 if (!ports)
892 goto failed2;
893
894 if (!probe_ms_sound(&opl3sa2_state[card].cfg_mss, ports)) {
895 /*
896 * If one or more cards are already registered, don't
897 * return an error but print a warning. Note, this
898 * should never really happen unless the hardware or
899 * ISA PnP screwed up.
900 */
901 release_region(base + 4, 4);
902 failed2:
903 release_region(base, 4);
904 failed:
905 release_region(opl3sa2_state[card].cfg.io_base, 2);
906
907 if (opl3sa2_cards_num) {
908 printk(KERN_WARNING
909 PFX "There was a problem probing one "
910 " of the ISA PNP cards, continuing\n");
911 opl3sa2_cards_num--;
912 continue;
913 } else
914 return -ENODEV;
915 }
916
917 attach_opl3sa2(&opl3sa2_state[card].cfg, card);
918 conf_printf(opl3sa2_state[card].chipset_name, &opl3sa2_state[card].cfg);
919 attach_opl3sa2_mixer(&opl3sa2_state[card].cfg, card);
920 attach_opl3sa2_mss(&opl3sa2_state[card].cfg_mss, ports);
921
922 /* ewww =) */
923 opl3sa2_state[card].card = card;
924
925 /*
926 * Set the Yamaha 3D enhancement mode (aka Ymersion) if asked to and
927 * it's supported.
928 */
929 if (ymode != -1) {
930 if (opl3sa2_state[card].chipset == CHIPSET_OPL3SA2) {
931 printk(KERN_ERR
932 PFX "ymode not supported on OPL3-SA2\n");
933 }
934 else {
935 opl3sa2_set_ymode(&opl3sa2_state[card].cfg, ymode);
936 }
937 }
938
939
940 /* Set A/D input to Mono loopback if asked to. */
941 if (loopback != -1) {
942 opl3sa2_set_loopback(&opl3sa2_state[card].cfg, loopback);
943 }
944
945 /* Attach MPU if we've been asked to do so, failure isn't fatal */
946 if (opl3sa2_state[card].cfg_mpu.io_base != -1) {
947 int base = opl3sa2_state[card].cfg_mpu.io_base;
948 struct resource *ports;
949 ports = request_region(base, 2, "mpu401");
950 if (!ports)
951 goto out;
952 if (!probe_mpu401(&opl3sa2_state[card].cfg_mpu, ports)) {
953 release_region(base, 2);
954 goto out;
955 }
956 if (attach_mpu401(&opl3sa2_state[card].cfg_mpu, THIS_MODULE)) {
957 printk(KERN_ERR PFX "failed to attach MPU401\n");
958 opl3sa2_state[card].cfg_mpu.slots[1] = -1;
959 }
960 }
961 }
962
963 out:
964 if (isapnp) {
965 printk(KERN_NOTICE PFX "%d PnP card(s) found.\n", opl3sa2_cards_num);
966 }
967
968 return 0;
969 }
970
971
972 /*
973 * Uninstall OPL3-SA2 based card(s).
974 */
975 static void __exit cleanup_opl3sa2(void)
976 {
977 int card;
978
979 for(card = 0; card < opl3sa2_cards_num; card++) {
980 if (opl3sa2_state[card].cfg_mpu.slots[1] != -1) {
981 unload_opl3sa2_mpu(&opl3sa2_state[card].cfg_mpu);
982 }
983 unload_opl3sa2_mss(&opl3sa2_state[card].cfg_mss);
984 unload_opl3sa2(&opl3sa2_state[card].cfg, card);
985 #ifdef CONFIG_PNP
986 pnp_unregister_driver(&opl3sa2_driver);
987 #endif
988 }
989 }
990
991 module_init(init_opl3sa2);
992 module_exit(cleanup_opl3sa2);
993
994 #ifndef MODULE
995 static int __init setup_opl3sa2(char *str)
996 {
997 /* io, irq, dma, dma2,... */
998 #ifdef CONFIG_PNP
999 int ints[11];
1000 #else
1001 int ints[9];
1002 #endif
1003 str = get_options(str, ARRAY_SIZE(ints), ints);
1004
1005 io = ints[1];
1006 irq = ints[2];
1007 dma = ints[3];
1008 dma2 = ints[4];
1009 mss_io = ints[5];
1010 mpu_io = ints[6];
1011 ymode = ints[7];
1012 loopback = ints[8];
1013 #ifdef CONFIG_PNP
1014 isapnp = ints[9];
1015 multiple = ints[10];
1016 #endif
1017 return 1;
1018 }
1019
1020 __setup("opl3sa2=", setup_opl3sa2);
1021 #endif
AMDTP streaming driver for the Linux FireWire stack (Juju)