Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Driver for SoundBlaster 16/AWE32/AWE64 soundcards | |
c1017a4c | 3 | * Copyright (c) by Jaroslav Kysela <perex@perex.cz> |
1da177e4 LT |
4 | * |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation; either version 2 of the License, or | |
9 | * (at your option) any later version. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
17 | * along with this program; if not, write to the Free Software | |
18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
19 | * | |
20 | */ | |
21 | ||
1da177e4 LT |
22 | #include <asm/dma.h> |
23 | #include <linux/init.h> | |
1da177e4 | 24 | #include <linux/pnp.h> |
6f045616 | 25 | #include <linux/err.h> |
5e24c1c1 | 26 | #include <linux/isa.h> |
65a77217 | 27 | #include <linux/module.h> |
1da177e4 LT |
28 | #include <sound/core.h> |
29 | #include <sound/sb.h> | |
30 | #include <sound/sb16_csp.h> | |
31 | #include <sound/mpu401.h> | |
32 | #include <sound/opl3.h> | |
33 | #include <sound/emu8000.h> | |
34 | #include <sound/seq_device.h> | |
1da177e4 LT |
35 | #define SNDRV_LEGACY_FIND_FREE_IRQ |
36 | #define SNDRV_LEGACY_FIND_FREE_DMA | |
37 | #include <sound/initval.h> | |
38 | ||
39 | #ifdef SNDRV_SBAWE | |
40 | #define PFX "sbawe: " | |
41 | #else | |
42 | #define PFX "sb16: " | |
43 | #endif | |
44 | ||
c1017a4c | 45 | MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); |
1da177e4 LT |
46 | MODULE_LICENSE("GPL"); |
47 | #ifndef SNDRV_SBAWE | |
48 | MODULE_DESCRIPTION("Sound Blaster 16"); | |
49 | MODULE_SUPPORTED_DEVICE("{{Creative Labs,SB 16}," | |
50 | "{Creative Labs,SB Vibra16S}," | |
51 | "{Creative Labs,SB Vibra16C}," | |
52 | "{Creative Labs,SB Vibra16CL}," | |
53 | "{Creative Labs,SB Vibra16X}}"); | |
54 | #else | |
55 | MODULE_DESCRIPTION("Sound Blaster AWE"); | |
56 | MODULE_SUPPORTED_DEVICE("{{Creative Labs,SB AWE 32}," | |
57 | "{Creative Labs,SB AWE 64}," | |
58 | "{Creative Labs,SB AWE 64 Gold}}"); | |
59 | #endif | |
60 | ||
61 | #if 0 | |
62 | #define SNDRV_DEBUG_IRQ | |
63 | #endif | |
64 | ||
65 | #if defined(SNDRV_SBAWE) && (defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))) | |
66 | #define SNDRV_SBAWE_EMU8000 | |
67 | #endif | |
68 | ||
69 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ | |
70 | static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ | |
a67ff6a5 | 71 | static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */ |
1da177e4 | 72 | #ifdef CONFIG_PNP |
a67ff6a5 | 73 | static bool isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; |
1da177e4 LT |
74 | #endif |
75 | static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* 0x220,0x240,0x260,0x280 */ | |
76 | static long mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* 0x330,0x300 */ | |
77 | static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; | |
78 | #ifdef SNDRV_SBAWE_EMU8000 | |
79 | static long awe_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; | |
80 | #endif | |
81 | static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 5,7,9,10 */ | |
82 | static int dma8[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 0,1,3 */ | |
83 | static int dma16[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 5,6,7 */ | |
84 | static int mic_agc[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; | |
85 | #ifdef CONFIG_SND_SB16_CSP | |
6581f4e7 | 86 | static int csp[SNDRV_CARDS]; |
1da177e4 LT |
87 | #endif |
88 | #ifdef SNDRV_SBAWE_EMU8000 | |
89 | static int seq_ports[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 4}; | |
90 | #endif | |
91 | ||
92 | module_param_array(index, int, NULL, 0444); | |
93 | MODULE_PARM_DESC(index, "Index value for SoundBlaster 16 soundcard."); | |
94 | module_param_array(id, charp, NULL, 0444); | |
95 | MODULE_PARM_DESC(id, "ID string for SoundBlaster 16 soundcard."); | |
96 | module_param_array(enable, bool, NULL, 0444); | |
97 | MODULE_PARM_DESC(enable, "Enable SoundBlaster 16 soundcard."); | |
98 | #ifdef CONFIG_PNP | |
99 | module_param_array(isapnp, bool, NULL, 0444); | |
100 | MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard."); | |
101 | #endif | |
102 | module_param_array(port, long, NULL, 0444); | |
103 | MODULE_PARM_DESC(port, "Port # for SB16 driver."); | |
104 | module_param_array(mpu_port, long, NULL, 0444); | |
105 | MODULE_PARM_DESC(mpu_port, "MPU-401 port # for SB16 driver."); | |
106 | module_param_array(fm_port, long, NULL, 0444); | |
107 | MODULE_PARM_DESC(fm_port, "FM port # for SB16 PnP driver."); | |
108 | #ifdef SNDRV_SBAWE_EMU8000 | |
109 | module_param_array(awe_port, long, NULL, 0444); | |
110 | MODULE_PARM_DESC(awe_port, "AWE port # for SB16 PnP driver."); | |
111 | #endif | |
112 | module_param_array(irq, int, NULL, 0444); | |
113 | MODULE_PARM_DESC(irq, "IRQ # for SB16 driver."); | |
114 | module_param_array(dma8, int, NULL, 0444); | |
115 | MODULE_PARM_DESC(dma8, "8-bit DMA # for SB16 driver."); | |
116 | module_param_array(dma16, int, NULL, 0444); | |
117 | MODULE_PARM_DESC(dma16, "16-bit DMA # for SB16 driver."); | |
118 | module_param_array(mic_agc, int, NULL, 0444); | |
119 | MODULE_PARM_DESC(mic_agc, "Mic Auto-Gain-Control switch."); | |
120 | #ifdef CONFIG_SND_SB16_CSP | |
121 | module_param_array(csp, int, NULL, 0444); | |
122 | MODULE_PARM_DESC(csp, "ASP/CSP chip support."); | |
123 | #endif | |
124 | #ifdef SNDRV_SBAWE_EMU8000 | |
125 | module_param_array(seq_ports, int, NULL, 0444); | |
126 | MODULE_PARM_DESC(seq_ports, "Number of sequencer ports for WaveTable synth."); | |
127 | #endif | |
128 | ||
f7a9275d | 129 | #ifdef CONFIG_PNP |
609d7694 | 130 | static int isa_registered; |
f7a9275d CL |
131 | static int pnp_registered; |
132 | #endif | |
133 | ||
1da177e4 LT |
134 | struct snd_card_sb16 { |
135 | struct resource *fm_res; /* used to block FM i/o region for legacy cards */ | |
6f045616 | 136 | struct snd_sb *chip; |
1da177e4 LT |
137 | #ifdef CONFIG_PNP |
138 | int dev_no; | |
139 | struct pnp_dev *dev; | |
140 | #ifdef SNDRV_SBAWE_EMU8000 | |
141 | struct pnp_dev *devwt; | |
142 | #endif | |
143 | #endif | |
144 | }; | |
145 | ||
1da177e4 LT |
146 | #ifdef CONFIG_PNP |
147 | ||
148 | static struct pnp_card_device_id snd_sb16_pnpids[] = { | |
149 | #ifndef SNDRV_SBAWE | |
150 | /* Sound Blaster 16 PnP */ | |
151 | { .id = "CTL0024", .devs = { { "CTL0031" } } }, | |
152 | /* Sound Blaster 16 PnP */ | |
153 | { .id = "CTL0025", .devs = { { "CTL0031" } } }, | |
154 | /* Sound Blaster 16 PnP */ | |
155 | { .id = "CTL0026", .devs = { { "CTL0031" } } }, | |
156 | /* Sound Blaster 16 PnP */ | |
157 | { .id = "CTL0027", .devs = { { "CTL0031" } } }, | |
158 | /* Sound Blaster 16 PnP */ | |
159 | { .id = "CTL0028", .devs = { { "CTL0031" } } }, | |
160 | /* Sound Blaster 16 PnP */ | |
161 | { .id = "CTL0029", .devs = { { "CTL0031" } } }, | |
162 | /* Sound Blaster 16 PnP */ | |
163 | { .id = "CTL002a", .devs = { { "CTL0031" } } }, | |
164 | /* Sound Blaster 16 PnP */ | |
165 | /* Note: This card has also a CTL0051:StereoEnhance device!!! */ | |
166 | { .id = "CTL002b", .devs = { { "CTL0031" } } }, | |
167 | /* Sound Blaster 16 PnP */ | |
168 | { .id = "CTL002c", .devs = { { "CTL0031" } } }, | |
169 | /* Sound Blaster Vibra16S */ | |
170 | { .id = "CTL0051", .devs = { { "CTL0001" } } }, | |
171 | /* Sound Blaster Vibra16C */ | |
172 | { .id = "CTL0070", .devs = { { "CTL0001" } } }, | |
173 | /* Sound Blaster Vibra16CL - added by ctm@ardi.com */ | |
174 | { .id = "CTL0080", .devs = { { "CTL0041" } } }, | |
175 | /* Sound Blaster 16 'value' PnP. It says model ct4130 on the pcb, */ | |
176 | /* but ct4131 on a sticker on the board.. */ | |
177 | { .id = "CTL0086", .devs = { { "CTL0041" } } }, | |
178 | /* Sound Blaster Vibra16X */ | |
179 | { .id = "CTL00f0", .devs = { { "CTL0043" } } }, | |
80faf041 TI |
180 | /* Sound Blaster 16 (Virtual PC 2004) */ |
181 | { .id = "tBA03b0", .devs = { {.id="PNPb003" } } }, | |
1da177e4 LT |
182 | #else /* SNDRV_SBAWE defined */ |
183 | /* Sound Blaster AWE 32 PnP */ | |
184 | { .id = "CTL0035", .devs = { { "CTL0031" }, { "CTL0021" } } }, | |
185 | /* Sound Blaster AWE 32 PnP */ | |
186 | { .id = "CTL0039", .devs = { { "CTL0031" }, { "CTL0021" } } }, | |
187 | /* Sound Blaster AWE 32 PnP */ | |
188 | { .id = "CTL0042", .devs = { { "CTL0031" }, { "CTL0021" } } }, | |
189 | /* Sound Blaster AWE 32 PnP */ | |
190 | { .id = "CTL0043", .devs = { { "CTL0031" }, { "CTL0021" } } }, | |
191 | /* Sound Blaster AWE 32 PnP */ | |
192 | /* Note: This card has also a CTL0051:StereoEnhance device!!! */ | |
193 | { .id = "CTL0044", .devs = { { "CTL0031" }, { "CTL0021" } } }, | |
194 | /* Sound Blaster AWE 32 PnP */ | |
195 | /* Note: This card has also a CTL0051:StereoEnhance device!!! */ | |
196 | { .id = "CTL0045", .devs = { { "CTL0031" }, { "CTL0021" } } }, | |
197 | /* Sound Blaster AWE 32 PnP */ | |
198 | { .id = "CTL0046", .devs = { { "CTL0031" }, { "CTL0021" } } }, | |
199 | /* Sound Blaster AWE 32 PnP */ | |
200 | { .id = "CTL0047", .devs = { { "CTL0031" }, { "CTL0021" } } }, | |
201 | /* Sound Blaster AWE 32 PnP */ | |
202 | { .id = "CTL0048", .devs = { { "CTL0031" }, { "CTL0021" } } }, | |
203 | /* Sound Blaster AWE 32 PnP */ | |
204 | { .id = "CTL0054", .devs = { { "CTL0031" }, { "CTL0021" } } }, | |
205 | /* Sound Blaster AWE 32 PnP */ | |
206 | { .id = "CTL009a", .devs = { { "CTL0041" }, { "CTL0021" } } }, | |
207 | /* Sound Blaster AWE 32 PnP */ | |
208 | { .id = "CTL009c", .devs = { { "CTL0041" }, { "CTL0021" } } }, | |
209 | /* Sound Blaster 32 PnP */ | |
210 | { .id = "CTL009f", .devs = { { "CTL0041" }, { "CTL0021" } } }, | |
211 | /* Sound Blaster AWE 64 PnP */ | |
212 | { .id = "CTL009d", .devs = { { "CTL0042" }, { "CTL0022" } } }, | |
213 | /* Sound Blaster AWE 64 PnP Gold */ | |
214 | { .id = "CTL009e", .devs = { { "CTL0044" }, { "CTL0023" } } }, | |
215 | /* Sound Blaster AWE 64 PnP Gold */ | |
216 | { .id = "CTL00b2", .devs = { { "CTL0044" }, { "CTL0023" } } }, | |
217 | /* Sound Blaster AWE 64 PnP */ | |
218 | { .id = "CTL00c1", .devs = { { "CTL0042" }, { "CTL0022" } } }, | |
219 | /* Sound Blaster AWE 64 PnP */ | |
220 | { .id = "CTL00c3", .devs = { { "CTL0045" }, { "CTL0022" } } }, | |
221 | /* Sound Blaster AWE 64 PnP */ | |
222 | { .id = "CTL00c5", .devs = { { "CTL0045" }, { "CTL0022" } } }, | |
223 | /* Sound Blaster AWE 64 PnP */ | |
224 | { .id = "CTL00c7", .devs = { { "CTL0045" }, { "CTL0022" } } }, | |
225 | /* Sound Blaster AWE 64 PnP */ | |
226 | { .id = "CTL00e4", .devs = { { "CTL0045" }, { "CTL0022" } } }, | |
227 | /* Sound Blaster AWE 64 PnP */ | |
228 | { .id = "CTL00e9", .devs = { { "CTL0045" }, { "CTL0022" } } }, | |
229 | /* Sound Blaster 16 PnP (AWE) */ | |
230 | { .id = "CTL00ed", .devs = { { "CTL0041" }, { "CTL0070" } } }, | |
231 | /* Generic entries */ | |
232 | { .id = "CTLXXXX" , .devs = { { "CTL0031" }, { "CTL0021" } } }, | |
233 | { .id = "CTLXXXX" , .devs = { { "CTL0041" }, { "CTL0021" } } }, | |
234 | { .id = "CTLXXXX" , .devs = { { "CTL0042" }, { "CTL0022" } } }, | |
235 | { .id = "CTLXXXX" , .devs = { { "CTL0044" }, { "CTL0023" } } }, | |
236 | { .id = "CTLXXXX" , .devs = { { "CTL0045" }, { "CTL0022" } } }, | |
237 | #endif /* SNDRV_SBAWE */ | |
1da177e4 LT |
238 | { .id = "", } |
239 | }; | |
240 | ||
241 | MODULE_DEVICE_TABLE(pnp_card, snd_sb16_pnpids); | |
242 | ||
243 | #endif /* CONFIG_PNP */ | |
244 | ||
245 | #ifdef SNDRV_SBAWE_EMU8000 | |
246 | #define DRIVER_NAME "snd-card-sbawe" | |
247 | #else | |
248 | #define DRIVER_NAME "snd-card-sb16" | |
249 | #endif | |
250 | ||
251 | #ifdef CONFIG_PNP | |
252 | ||
253 | static int __devinit snd_card_sb16_pnp(int dev, struct snd_card_sb16 *acard, | |
254 | struct pnp_card_link *card, | |
255 | const struct pnp_card_device_id *id) | |
256 | { | |
257 | struct pnp_dev *pdev; | |
1da177e4 LT |
258 | int err; |
259 | ||
1da177e4 | 260 | acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL); |
109c53f8 | 261 | if (acard->dev == NULL) |
1da177e4 | 262 | return -ENODEV; |
109c53f8 | 263 | |
1da177e4 LT |
264 | #ifdef SNDRV_SBAWE_EMU8000 |
265 | acard->devwt = pnp_request_card_device(card, id->devs[1].id, acard->dev); | |
266 | #endif | |
267 | /* Audio initialization */ | |
268 | pdev = acard->dev; | |
269 | ||
1da177e4 LT |
270 | err = pnp_activate_dev(pdev); |
271 | if (err < 0) { | |
272 | snd_printk(KERN_ERR PFX "AUDIO pnp configure failure\n"); | |
1da177e4 LT |
273 | return err; |
274 | } | |
275 | port[dev] = pnp_port_start(pdev, 0); | |
276 | mpu_port[dev] = pnp_port_start(pdev, 1); | |
277 | fm_port[dev] = pnp_port_start(pdev, 2); | |
278 | dma8[dev] = pnp_dma(pdev, 0); | |
279 | dma16[dev] = pnp_dma(pdev, 1); | |
280 | irq[dev] = pnp_irq(pdev, 0); | |
281 | snd_printdd("pnp SB16: port=0x%lx, mpu port=0x%lx, fm port=0x%lx\n", | |
282 | port[dev], mpu_port[dev], fm_port[dev]); | |
283 | snd_printdd("pnp SB16: dma1=%i, dma2=%i, irq=%i\n", | |
284 | dma8[dev], dma16[dev], irq[dev]); | |
285 | #ifdef SNDRV_SBAWE_EMU8000 | |
286 | /* WaveTable initialization */ | |
287 | pdev = acard->devwt; | |
288 | if (pdev != NULL) { | |
1da177e4 LT |
289 | err = pnp_activate_dev(pdev); |
290 | if (err < 0) { | |
291 | goto __wt_error; | |
292 | } | |
293 | awe_port[dev] = pnp_port_start(pdev, 0); | |
aa0a2ddc GKH |
294 | snd_printdd("pnp SB16: wavetable port=0x%llx\n", |
295 | (unsigned long long)pnp_port_start(pdev, 0)); | |
1da177e4 LT |
296 | } else { |
297 | __wt_error: | |
298 | if (pdev) { | |
299 | pnp_release_card_device(pdev); | |
300 | snd_printk(KERN_ERR PFX "WaveTable pnp configure failure\n"); | |
301 | } | |
302 | acard->devwt = NULL; | |
303 | awe_port[dev] = -1; | |
304 | } | |
305 | #endif | |
1da177e4 LT |
306 | return 0; |
307 | } | |
308 | ||
309 | #endif /* CONFIG_PNP */ | |
310 | ||
029d64b0 | 311 | static void snd_sb16_free(struct snd_card *card) |
1da177e4 | 312 | { |
6f045616 | 313 | struct snd_card_sb16 *acard = card->private_data; |
1da177e4 LT |
314 | |
315 | if (acard == NULL) | |
316 | return; | |
b1d5776d | 317 | release_and_free_resource(acard->fm_res); |
1da177e4 LT |
318 | } |
319 | ||
43bcd973 TI |
320 | #ifdef CONFIG_PNP |
321 | #define is_isapnp_selected(dev) isapnp[dev] | |
322 | #else | |
323 | #define is_isapnp_selected(dev) 0 | |
324 | #endif | |
325 | ||
3e7fb9f7 | 326 | static int snd_sb16_card_new(int dev, struct snd_card **cardp) |
6f045616 | 327 | { |
c95eadd2 TI |
328 | struct snd_card *card; |
329 | int err; | |
330 | ||
331 | err = snd_card_create(index[dev], id[dev], THIS_MODULE, | |
332 | sizeof(struct snd_card_sb16), &card); | |
333 | if (err < 0) | |
3e7fb9f7 | 334 | return err; |
6f045616 | 335 | card->private_free = snd_sb16_free; |
3e7fb9f7 TI |
336 | *cardp = card; |
337 | return 0; | |
6f045616 TI |
338 | } |
339 | ||
312fef30 | 340 | static int __devinit snd_sb16_probe(struct snd_card *card, int dev) |
1da177e4 | 341 | { |
1da177e4 | 342 | int xirq, xdma8, xdma16; |
029d64b0 | 343 | struct snd_sb *chip; |
6f045616 | 344 | struct snd_card_sb16 *acard = card->private_data; |
029d64b0 TI |
345 | struct snd_opl3 *opl3; |
346 | struct snd_hwdep *synth = NULL; | |
1da177e4 | 347 | #ifdef CONFIG_SND_SB16_CSP |
029d64b0 | 348 | struct snd_hwdep *xcsp = NULL; |
1da177e4 LT |
349 | #endif |
350 | unsigned long flags; | |
351 | int err; | |
352 | ||
1da177e4 LT |
353 | xirq = irq[dev]; |
354 | xdma8 = dma8[dev]; | |
355 | xdma16 = dma16[dev]; | |
1da177e4 LT |
356 | |
357 | if ((err = snd_sbdsp_create(card, | |
358 | port[dev], | |
359 | xirq, | |
360 | snd_sb16dsp_interrupt, | |
361 | xdma8, | |
362 | xdma16, | |
363 | SB_HW_AUTO, | |
43bcd973 | 364 | &chip)) < 0) |
6f045616 | 365 | return err; |
43bcd973 | 366 | |
6f045616 | 367 | acard->chip = chip; |
1da177e4 | 368 | if (chip->hardware != SB_HW_16) { |
43bcd973 | 369 | snd_printk(KERN_ERR PFX "SB 16 chip was not detected at 0x%lx\n", port[dev]); |
6f045616 | 370 | return -ENODEV; |
1da177e4 LT |
371 | } |
372 | chip->mpu_port = mpu_port[dev]; | |
43bcd973 | 373 | if (! is_isapnp_selected(dev) && (err = snd_sb16dsp_configure(chip)) < 0) |
6f045616 | 374 | return err; |
43bcd973 | 375 | |
6f045616 TI |
376 | if ((err = snd_sb16dsp_pcm(chip, 0, &chip->pcm)) < 0) |
377 | return err; | |
1da177e4 LT |
378 | |
379 | strcpy(card->driver, | |
380 | #ifdef SNDRV_SBAWE_EMU8000 | |
381 | awe_port[dev] > 0 ? "SB AWE" : | |
382 | #endif | |
383 | "SB16"); | |
384 | strcpy(card->shortname, chip->name); | |
385 | sprintf(card->longname, "%s at 0x%lx, irq %i, dma ", | |
386 | chip->name, | |
387 | chip->port, | |
388 | xirq); | |
389 | if (xdma8 >= 0) | |
390 | sprintf(card->longname + strlen(card->longname), "%d", xdma8); | |
391 | if (xdma16 >= 0) | |
392 | sprintf(card->longname + strlen(card->longname), "%s%d", | |
393 | xdma8 >= 0 ? "&" : "", xdma16); | |
394 | ||
395 | if (chip->mpu_port > 0 && chip->mpu_port != SNDRV_AUTO_PORT) { | |
396 | if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_SB, | |
dba8b469 CL |
397 | chip->mpu_port, |
398 | MPU401_INFO_IRQ_HOOK, -1, | |
399 | &chip->rmidi)) < 0) | |
6f045616 | 400 | return err; |
1da177e4 LT |
401 | chip->rmidi_callback = snd_mpu401_uart_interrupt; |
402 | } | |
403 | ||
404 | #ifdef SNDRV_SBAWE_EMU8000 | |
405 | if (awe_port[dev] == SNDRV_AUTO_PORT) | |
406 | awe_port[dev] = 0; /* disable */ | |
407 | #endif | |
408 | ||
409 | if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) { | |
410 | if (snd_opl3_create(card, fm_port[dev], fm_port[dev] + 2, | |
411 | OPL3_HW_OPL3, | |
412 | acard->fm_res != NULL || fm_port[dev] == port[dev], | |
413 | &opl3) < 0) { | |
414 | snd_printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n", | |
415 | fm_port[dev], fm_port[dev] + 2); | |
416 | } else { | |
417 | #ifdef SNDRV_SBAWE_EMU8000 | |
418 | int seqdev = awe_port[dev] > 0 ? 2 : 1; | |
419 | #else | |
420 | int seqdev = 1; | |
421 | #endif | |
43bcd973 | 422 | if ((err = snd_opl3_hwdep_new(opl3, 0, seqdev, &synth)) < 0) |
6f045616 | 423 | return err; |
1da177e4 LT |
424 | } |
425 | } | |
426 | ||
43bcd973 | 427 | if ((err = snd_sbmixer_new(chip)) < 0) |
6f045616 | 428 | return err; |
1da177e4 LT |
429 | |
430 | #ifdef CONFIG_SND_SB16_CSP | |
431 | /* CSP chip on SB16ASP/AWE32 */ | |
432 | if ((chip->hardware == SB_HW_16) && csp[dev]) { | |
433 | snd_sb_csp_new(chip, synth != NULL ? 1 : 0, &xcsp); | |
434 | if (xcsp) { | |
435 | chip->csp = xcsp->private_data; | |
436 | chip->hardware = SB_HW_16CSP; | |
437 | } else { | |
438 | snd_printk(KERN_INFO PFX "warning - CSP chip not detected on soundcard #%i\n", dev + 1); | |
439 | } | |
440 | } | |
441 | #endif | |
442 | #ifdef SNDRV_SBAWE_EMU8000 | |
443 | if (awe_port[dev] > 0) { | |
43bcd973 TI |
444 | if ((err = snd_emu8000_new(card, 1, awe_port[dev], |
445 | seq_ports[dev], NULL)) < 0) { | |
1da177e4 | 446 | snd_printk(KERN_ERR PFX "fatal error - EMU-8000 synthesizer not detected at 0x%lx\n", awe_port[dev]); |
43bcd973 | 447 | |
6f045616 | 448 | return err; |
1da177e4 LT |
449 | } |
450 | } | |
451 | #endif | |
452 | ||
453 | /* setup Mic AGC */ | |
454 | spin_lock_irqsave(&chip->mixer_lock, flags); | |
455 | snd_sbmixer_write(chip, SB_DSP4_MIC_AGC, | |
456 | (snd_sbmixer_read(chip, SB_DSP4_MIC_AGC) & 0x01) | | |
457 | (mic_agc[dev] ? 0x00 : 0x01)); | |
458 | spin_unlock_irqrestore(&chip->mixer_lock, flags); | |
459 | ||
43bcd973 | 460 | if ((err = snd_card_register(card)) < 0) |
6f045616 | 461 | return err; |
43bcd973 | 462 | |
1da177e4 | 463 | return 0; |
6f045616 TI |
464 | } |
465 | ||
466 | #ifdef CONFIG_PM | |
467 | static int snd_sb16_suspend(struct snd_card *card, pm_message_t state) | |
468 | { | |
469 | struct snd_card_sb16 *acard = card->private_data; | |
470 | struct snd_sb *chip = acard->chip; | |
43bcd973 | 471 | |
6f045616 TI |
472 | snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); |
473 | snd_pcm_suspend_all(chip->pcm); | |
474 | snd_sbmixer_suspend(chip); | |
475 | return 0; | |
1da177e4 LT |
476 | } |
477 | ||
6f045616 | 478 | static int snd_sb16_resume(struct snd_card *card) |
1da177e4 | 479 | { |
6f045616 TI |
480 | struct snd_card_sb16 *acard = card->private_data; |
481 | struct snd_sb *chip = acard->chip; | |
1da177e4 | 482 | |
6f045616 TI |
483 | snd_sbdsp_reset(chip); |
484 | snd_sbmixer_resume(chip); | |
485 | snd_power_change_state(card, SNDRV_CTL_POWER_D0); | |
486 | return 0; | |
487 | } | |
488 | #endif | |
489 | ||
5e24c1c1 | 490 | static int __devinit snd_sb16_isa_probe1(int dev, struct device *pdev) |
6f045616 TI |
491 | { |
492 | struct snd_card_sb16 *acard; | |
493 | struct snd_card *card; | |
494 | int err; | |
495 | ||
3e7fb9f7 TI |
496 | err = snd_sb16_card_new(dev, &card); |
497 | if (err < 0) | |
498 | return err; | |
6f045616 TI |
499 | |
500 | acard = card->private_data; | |
501 | /* non-PnP FM port address is hardwired with base port address */ | |
502 | fm_port[dev] = port[dev]; | |
503 | /* block the 0x388 port to avoid PnP conflicts */ | |
504 | acard->fm_res = request_region(0x388, 4, "SoundBlaster FM"); | |
505 | #ifdef SNDRV_SBAWE_EMU8000 | |
506 | /* non-PnP AWE port address is hardwired with base port address */ | |
507 | awe_port[dev] = port[dev] + 0x400; | |
508 | #endif | |
509 | ||
5e24c1c1 | 510 | snd_card_set_dev(card, pdev); |
6f045616 TI |
511 | if ((err = snd_sb16_probe(card, dev)) < 0) { |
512 | snd_card_free(card); | |
513 | return err; | |
1da177e4 | 514 | } |
5e24c1c1 | 515 | dev_set_drvdata(pdev, card); |
6f045616 | 516 | return 0; |
1da177e4 LT |
517 | } |
518 | ||
6f045616 | 519 | |
5e24c1c1 TI |
520 | static int __devinit snd_sb16_isa_match(struct device *pdev, unsigned int dev) |
521 | { | |
522 | return enable[dev] && !is_isapnp_selected(dev); | |
523 | } | |
524 | ||
525 | static int __devinit snd_sb16_isa_probe(struct device *pdev, unsigned int dev) | |
6f045616 | 526 | { |
6f045616 TI |
527 | int err; |
528 | static int possible_irqs[] = {5, 9, 10, 7, -1}; | |
529 | static int possible_dmas8[] = {1, 3, 0, -1}; | |
530 | static int possible_dmas16[] = {5, 6, 7, -1}; | |
531 | ||
532 | if (irq[dev] == SNDRV_AUTO_IRQ) { | |
533 | if ((irq[dev] = snd_legacy_find_free_irq(possible_irqs)) < 0) { | |
534 | snd_printk(KERN_ERR PFX "unable to find a free IRQ\n"); | |
535 | return -EBUSY; | |
536 | } | |
537 | } | |
538 | if (dma8[dev] == SNDRV_AUTO_DMA) { | |
539 | if ((dma8[dev] = snd_legacy_find_free_dma(possible_dmas8)) < 0) { | |
540 | snd_printk(KERN_ERR PFX "unable to find a free 8-bit DMA\n"); | |
541 | return -EBUSY; | |
542 | } | |
543 | } | |
544 | if (dma16[dev] == SNDRV_AUTO_DMA) { | |
545 | if ((dma16[dev] = snd_legacy_find_free_dma(possible_dmas16)) < 0) { | |
546 | snd_printk(KERN_ERR PFX "unable to find a free 16-bit DMA\n"); | |
547 | return -EBUSY; | |
548 | } | |
549 | } | |
550 | ||
551 | if (port[dev] != SNDRV_AUTO_PORT) | |
5e24c1c1 | 552 | return snd_sb16_isa_probe1(dev, pdev); |
6f045616 TI |
553 | else { |
554 | static int possible_ports[] = {0x220, 0x240, 0x260, 0x280}; | |
555 | int i; | |
556 | for (i = 0; i < ARRAY_SIZE(possible_ports); i++) { | |
557 | port[dev] = possible_ports[i]; | |
5e24c1c1 | 558 | err = snd_sb16_isa_probe1(dev, pdev); |
6f045616 TI |
559 | if (! err) |
560 | return 0; | |
561 | } | |
562 | return err; | |
563 | } | |
564 | } | |
565 | ||
5e24c1c1 | 566 | static int __devexit snd_sb16_isa_remove(struct device *pdev, unsigned int dev) |
6f045616 | 567 | { |
5e24c1c1 TI |
568 | snd_card_free(dev_get_drvdata(pdev)); |
569 | dev_set_drvdata(pdev, NULL); | |
6f045616 TI |
570 | return 0; |
571 | } | |
572 | ||
573 | #ifdef CONFIG_PM | |
5e24c1c1 TI |
574 | static int snd_sb16_isa_suspend(struct device *dev, unsigned int n, |
575 | pm_message_t state) | |
6f045616 | 576 | { |
5e24c1c1 | 577 | return snd_sb16_suspend(dev_get_drvdata(dev), state); |
6f045616 TI |
578 | } |
579 | ||
5e24c1c1 | 580 | static int snd_sb16_isa_resume(struct device *dev, unsigned int n) |
6f045616 | 581 | { |
5e24c1c1 | 582 | return snd_sb16_resume(dev_get_drvdata(dev)); |
6f045616 TI |
583 | } |
584 | #endif | |
585 | ||
586 | #ifdef SNDRV_SBAWE | |
83c51c0a | 587 | #define DEV_NAME "sbawe" |
6f045616 | 588 | #else |
83c51c0a | 589 | #define DEV_NAME "sb16" |
6f045616 TI |
590 | #endif |
591 | ||
5e24c1c1 TI |
592 | static struct isa_driver snd_sb16_isa_driver = { |
593 | .match = snd_sb16_isa_match, | |
594 | .probe = snd_sb16_isa_probe, | |
595 | .remove = __devexit_p(snd_sb16_isa_remove), | |
6f045616 | 596 | #ifdef CONFIG_PM |
5e24c1c1 TI |
597 | .suspend = snd_sb16_isa_suspend, |
598 | .resume = snd_sb16_isa_resume, | |
6f045616 TI |
599 | #endif |
600 | .driver = { | |
83c51c0a | 601 | .name = DEV_NAME |
6f045616 TI |
602 | }, |
603 | }; | |
604 | ||
605 | ||
1da177e4 | 606 | #ifdef CONFIG_PNP |
6f045616 TI |
607 | static int __devinit snd_sb16_pnp_detect(struct pnp_card_link *pcard, |
608 | const struct pnp_card_device_id *pid) | |
1da177e4 LT |
609 | { |
610 | static int dev; | |
6f045616 | 611 | struct snd_card *card; |
1da177e4 LT |
612 | int res; |
613 | ||
614 | for ( ; dev < SNDRV_CARDS; dev++) { | |
615 | if (!enable[dev] || !isapnp[dev]) | |
616 | continue; | |
3e7fb9f7 TI |
617 | res = snd_sb16_card_new(dev, &card); |
618 | if (res < 0) | |
619 | return res; | |
6f045616 TI |
620 | snd_card_set_dev(card, &pcard->card->dev); |
621 | if ((res = snd_card_sb16_pnp(dev, card->private_data, pcard, pid)) < 0 || | |
622 | (res = snd_sb16_probe(card, dev)) < 0) { | |
623 | snd_card_free(card); | |
1da177e4 | 624 | return res; |
6f045616 TI |
625 | } |
626 | pnp_set_card_drvdata(pcard, card); | |
1da177e4 LT |
627 | dev++; |
628 | return 0; | |
629 | } | |
630 | ||
631 | return -ENODEV; | |
632 | } | |
633 | ||
634 | static void __devexit snd_sb16_pnp_remove(struct pnp_card_link * pcard) | |
635 | { | |
6f045616 TI |
636 | snd_card_free(pnp_get_card_drvdata(pcard)); |
637 | pnp_set_card_drvdata(pcard, NULL); | |
638 | } | |
1da177e4 | 639 | |
6f045616 TI |
640 | #ifdef CONFIG_PM |
641 | static int snd_sb16_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state) | |
642 | { | |
643 | return snd_sb16_suspend(pnp_get_card_drvdata(pcard), state); | |
1da177e4 | 644 | } |
6f045616 TI |
645 | static int snd_sb16_pnp_resume(struct pnp_card_link *pcard) |
646 | { | |
647 | return snd_sb16_resume(pnp_get_card_drvdata(pcard)); | |
648 | } | |
649 | #endif | |
1da177e4 LT |
650 | |
651 | static struct pnp_card_driver sb16_pnpc_driver = { | |
652 | .flags = PNP_DRIVER_RES_DISABLE, | |
6f045616 TI |
653 | #ifdef SNDRV_SBAWE |
654 | .name = "sbawe", | |
655 | #else | |
1da177e4 | 656 | .name = "sb16", |
6f045616 | 657 | #endif |
1da177e4 LT |
658 | .id_table = snd_sb16_pnpids, |
659 | .probe = snd_sb16_pnp_detect, | |
660 | .remove = __devexit_p(snd_sb16_pnp_remove), | |
6f045616 TI |
661 | #ifdef CONFIG_PM |
662 | .suspend = snd_sb16_pnp_suspend, | |
663 | .resume = snd_sb16_pnp_resume, | |
664 | #endif | |
1da177e4 LT |
665 | }; |
666 | ||
667 | #endif /* CONFIG_PNP */ | |
668 | ||
669 | static int __init alsa_card_sb16_init(void) | |
670 | { | |
5e24c1c1 | 671 | int err; |
1da177e4 | 672 | |
5e24c1c1 | 673 | err = isa_register_driver(&snd_sb16_isa_driver, SNDRV_CARDS); |
1da177e4 | 674 | #ifdef CONFIG_PNP |
609d7694 RH |
675 | if (!err) |
676 | isa_registered = 1; | |
677 | ||
312fef30 | 678 | err = pnp_register_card_driver(&sb16_pnpc_driver); |
5e24c1c1 | 679 | if (!err) |
f7a9275d | 680 | pnp_registered = 1; |
609d7694 RH |
681 | |
682 | if (isa_registered) | |
683 | err = 0; | |
1da177e4 | 684 | #endif |
609d7694 | 685 | return err; |
1da177e4 LT |
686 | } |
687 | ||
688 | static void __exit alsa_card_sb16_exit(void) | |
689 | { | |
5e24c1c1 TI |
690 | #ifdef CONFIG_PNP |
691 | if (pnp_registered) | |
692 | pnp_unregister_card_driver(&sb16_pnpc_driver); | |
609d7694 | 693 | if (isa_registered) |
5e24c1c1 | 694 | #endif |
609d7694 | 695 | isa_unregister_driver(&snd_sb16_isa_driver); |
1da177e4 LT |
696 | } |
697 | ||
698 | module_init(alsa_card_sb16_init) | |
699 | module_exit(alsa_card_sb16_exit) |