diff options
Diffstat (limited to 'sound/oss/opl3sa2.c')
-rw-r--r-- | sound/oss/opl3sa2.c | 1129 |
1 files changed, 1129 insertions, 0 deletions
diff --git a/sound/oss/opl3sa2.c b/sound/oss/opl3sa2.c new file mode 100644 index 000000000000..7b4996e71576 --- /dev/null +++ b/sound/oss/opl3sa2.c | |||
@@ -0,0 +1,1129 @@ | |||
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 | ||