2 * Driver for SoundBlaster 16/AWE32/AWE64 soundcards
3 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
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.
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.
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
22 #include <sound/driver.h>
24 #include <linux/init.h>
25 #include <linux/slab.h>
26 #include <linux/pnp.h>
27 #include <linux/err.h>
28 #include <linux/platform_device.h>
29 #include <linux/moduleparam.h>
30 #include <sound/core.h>
32 #include <sound/sb16_csp.h>
33 #include <sound/mpu401.h>
34 #include <sound/opl3.h>
35 #include <sound/emu8000.h>
36 #include <sound/seq_device.h>
37 #define SNDRV_LEGACY_FIND_FREE_IRQ
38 #define SNDRV_LEGACY_FIND_FREE_DMA
39 #include <sound/initval.h>
47 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
48 MODULE_LICENSE("GPL");
50 MODULE_DESCRIPTION("Sound Blaster 16");
51 MODULE_SUPPORTED_DEVICE("{{Creative Labs,SB 16},"
52 "{Creative Labs,SB Vibra16S},"
53 "{Creative Labs,SB Vibra16C},"
54 "{Creative Labs,SB Vibra16CL},"
55 "{Creative Labs,SB Vibra16X}}");
57 MODULE_DESCRIPTION("Sound Blaster AWE");
58 MODULE_SUPPORTED_DEVICE("{{Creative Labs,SB AWE 32},"
59 "{Creative Labs,SB AWE 64},"
60 "{Creative Labs,SB AWE 64 Gold}}");
64 #define SNDRV_DEBUG_IRQ
67 #if defined(SNDRV_SBAWE) && (defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)))
68 #define SNDRV_SBAWE_EMU8000
71 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
72 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
73 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_ISAPNP
; /* Enable this card */
75 static int isapnp
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 1};
77 static long port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
; /* 0x220,0x240,0x260,0x280 */
78 static long mpu_port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
; /* 0x330,0x300 */
79 static long fm_port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
;
80 #ifdef SNDRV_SBAWE_EMU8000
81 static long awe_port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
;
83 static int irq
[SNDRV_CARDS
] = SNDRV_DEFAULT_IRQ
; /* 5,7,9,10 */
84 static int dma8
[SNDRV_CARDS
] = SNDRV_DEFAULT_DMA
; /* 0,1,3 */
85 static int dma16
[SNDRV_CARDS
] = SNDRV_DEFAULT_DMA
; /* 5,6,7 */
86 static int mic_agc
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 1};
87 #ifdef CONFIG_SND_SB16_CSP
88 static int csp
[SNDRV_CARDS
];
90 #ifdef SNDRV_SBAWE_EMU8000
91 static int seq_ports
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 4};
94 module_param_array(index
, int, NULL
, 0444);
95 MODULE_PARM_DESC(index
, "Index value for SoundBlaster 16 soundcard.");
96 module_param_array(id
, charp
, NULL
, 0444);
97 MODULE_PARM_DESC(id
, "ID string for SoundBlaster 16 soundcard.");
98 module_param_array(enable
, bool, NULL
, 0444);
99 MODULE_PARM_DESC(enable
, "Enable SoundBlaster 16 soundcard.");
101 module_param_array(isapnp
, bool, NULL
, 0444);
102 MODULE_PARM_DESC(isapnp
, "PnP detection for specified soundcard.");
104 module_param_array(port
, long, NULL
, 0444);
105 MODULE_PARM_DESC(port
, "Port # for SB16 driver.");
106 module_param_array(mpu_port
, long, NULL
, 0444);
107 MODULE_PARM_DESC(mpu_port
, "MPU-401 port # for SB16 driver.");
108 module_param_array(fm_port
, long, NULL
, 0444);
109 MODULE_PARM_DESC(fm_port
, "FM port # for SB16 PnP driver.");
110 #ifdef SNDRV_SBAWE_EMU8000
111 module_param_array(awe_port
, long, NULL
, 0444);
112 MODULE_PARM_DESC(awe_port
, "AWE port # for SB16 PnP driver.");
114 module_param_array(irq
, int, NULL
, 0444);
115 MODULE_PARM_DESC(irq
, "IRQ # for SB16 driver.");
116 module_param_array(dma8
, int, NULL
, 0444);
117 MODULE_PARM_DESC(dma8
, "8-bit DMA # for SB16 driver.");
118 module_param_array(dma16
, int, NULL
, 0444);
119 MODULE_PARM_DESC(dma16
, "16-bit DMA # for SB16 driver.");
120 module_param_array(mic_agc
, int, NULL
, 0444);
121 MODULE_PARM_DESC(mic_agc
, "Mic Auto-Gain-Control switch.");
122 #ifdef CONFIG_SND_SB16_CSP
123 module_param_array(csp
, int, NULL
, 0444);
124 MODULE_PARM_DESC(csp
, "ASP/CSP chip support.");
126 #ifdef SNDRV_SBAWE_EMU8000
127 module_param_array(seq_ports
, int, NULL
, 0444);
128 MODULE_PARM_DESC(seq_ports
, "Number of sequencer ports for WaveTable synth.");
131 static struct platform_device
*platform_devices
[SNDRV_CARDS
];
133 static int pnp_registered
;
136 struct snd_card_sb16
{
137 struct resource
*fm_res
; /* used to block FM i/o region for legacy cards */
142 #ifdef SNDRV_SBAWE_EMU8000
143 struct pnp_dev
*devwt
;
150 static struct pnp_card_device_id snd_sb16_pnpids
[] = {
152 /* Sound Blaster 16 PnP */
153 { .id
= "CTL0024", .devs
= { { "CTL0031" } } },
154 /* Sound Blaster 16 PnP */
155 { .id
= "CTL0025", .devs
= { { "CTL0031" } } },
156 /* Sound Blaster 16 PnP */
157 { .id
= "CTL0026", .devs
= { { "CTL0031" } } },
158 /* Sound Blaster 16 PnP */
159 { .id
= "CTL0027", .devs
= { { "CTL0031" } } },
160 /* Sound Blaster 16 PnP */
161 { .id
= "CTL0028", .devs
= { { "CTL0031" } } },
162 /* Sound Blaster 16 PnP */
163 { .id
= "CTL0029", .devs
= { { "CTL0031" } } },
164 /* Sound Blaster 16 PnP */
165 { .id
= "CTL002a", .devs
= { { "CTL0031" } } },
166 /* Sound Blaster 16 PnP */
167 /* Note: This card has also a CTL0051:StereoEnhance device!!! */
168 { .id
= "CTL002b", .devs
= { { "CTL0031" } } },
169 /* Sound Blaster 16 PnP */
170 { .id
= "CTL002c", .devs
= { { "CTL0031" } } },
171 /* Sound Blaster Vibra16S */
172 { .id
= "CTL0051", .devs
= { { "CTL0001" } } },
173 /* Sound Blaster Vibra16C */
174 { .id
= "CTL0070", .devs
= { { "CTL0001" } } },
175 /* Sound Blaster Vibra16CL - added by ctm@ardi.com */
176 { .id
= "CTL0080", .devs
= { { "CTL0041" } } },
177 /* Sound Blaster 16 'value' PnP. It says model ct4130 on the pcb, */
178 /* but ct4131 on a sticker on the board.. */
179 { .id
= "CTL0086", .devs
= { { "CTL0041" } } },
180 /* Sound Blaster Vibra16X */
181 { .id
= "CTL00f0", .devs
= { { "CTL0043" } } },
182 /* Sound Blaster 16 (Virtual PC 2004) */
183 { .id
= "tBA03b0", .devs
= { {.id
="PNPb003" } } },
184 #else /* SNDRV_SBAWE defined */
185 /* Sound Blaster AWE 32 PnP */
186 { .id
= "CTL0035", .devs
= { { "CTL0031" }, { "CTL0021" } } },
187 /* Sound Blaster AWE 32 PnP */
188 { .id
= "CTL0039", .devs
= { { "CTL0031" }, { "CTL0021" } } },
189 /* Sound Blaster AWE 32 PnP */
190 { .id
= "CTL0042", .devs
= { { "CTL0031" }, { "CTL0021" } } },
191 /* Sound Blaster AWE 32 PnP */
192 { .id
= "CTL0043", .devs
= { { "CTL0031" }, { "CTL0021" } } },
193 /* Sound Blaster AWE 32 PnP */
194 /* Note: This card has also a CTL0051:StereoEnhance device!!! */
195 { .id
= "CTL0044", .devs
= { { "CTL0031" }, { "CTL0021" } } },
196 /* Sound Blaster AWE 32 PnP */
197 /* Note: This card has also a CTL0051:StereoEnhance device!!! */
198 { .id
= "CTL0045", .devs
= { { "CTL0031" }, { "CTL0021" } } },
199 /* Sound Blaster AWE 32 PnP */
200 { .id
= "CTL0046", .devs
= { { "CTL0031" }, { "CTL0021" } } },
201 /* Sound Blaster AWE 32 PnP */
202 { .id
= "CTL0047", .devs
= { { "CTL0031" }, { "CTL0021" } } },
203 /* Sound Blaster AWE 32 PnP */
204 { .id
= "CTL0048", .devs
= { { "CTL0031" }, { "CTL0021" } } },
205 /* Sound Blaster AWE 32 PnP */
206 { .id
= "CTL0054", .devs
= { { "CTL0031" }, { "CTL0021" } } },
207 /* Sound Blaster AWE 32 PnP */
208 { .id
= "CTL009a", .devs
= { { "CTL0041" }, { "CTL0021" } } },
209 /* Sound Blaster AWE 32 PnP */
210 { .id
= "CTL009c", .devs
= { { "CTL0041" }, { "CTL0021" } } },
211 /* Sound Blaster 32 PnP */
212 { .id
= "CTL009f", .devs
= { { "CTL0041" }, { "CTL0021" } } },
213 /* Sound Blaster AWE 64 PnP */
214 { .id
= "CTL009d", .devs
= { { "CTL0042" }, { "CTL0022" } } },
215 /* Sound Blaster AWE 64 PnP Gold */
216 { .id
= "CTL009e", .devs
= { { "CTL0044" }, { "CTL0023" } } },
217 /* Sound Blaster AWE 64 PnP Gold */
218 { .id
= "CTL00b2", .devs
= { { "CTL0044" }, { "CTL0023" } } },
219 /* Sound Blaster AWE 64 PnP */
220 { .id
= "CTL00c1", .devs
= { { "CTL0042" }, { "CTL0022" } } },
221 /* Sound Blaster AWE 64 PnP */
222 { .id
= "CTL00c3", .devs
= { { "CTL0045" }, { "CTL0022" } } },
223 /* Sound Blaster AWE 64 PnP */
224 { .id
= "CTL00c5", .devs
= { { "CTL0045" }, { "CTL0022" } } },
225 /* Sound Blaster AWE 64 PnP */
226 { .id
= "CTL00c7", .devs
= { { "CTL0045" }, { "CTL0022" } } },
227 /* Sound Blaster AWE 64 PnP */
228 { .id
= "CTL00e4", .devs
= { { "CTL0045" }, { "CTL0022" } } },
229 /* Sound Blaster AWE 64 PnP */
230 { .id
= "CTL00e9", .devs
= { { "CTL0045" }, { "CTL0022" } } },
231 /* Sound Blaster 16 PnP (AWE) */
232 { .id
= "CTL00ed", .devs
= { { "CTL0041" }, { "CTL0070" } } },
233 /* Generic entries */
234 { .id
= "CTLXXXX" , .devs
= { { "CTL0031" }, { "CTL0021" } } },
235 { .id
= "CTLXXXX" , .devs
= { { "CTL0041" }, { "CTL0021" } } },
236 { .id
= "CTLXXXX" , .devs
= { { "CTL0042" }, { "CTL0022" } } },
237 { .id
= "CTLXXXX" , .devs
= { { "CTL0044" }, { "CTL0023" } } },
238 { .id
= "CTLXXXX" , .devs
= { { "CTL0045" }, { "CTL0022" } } },
239 #endif /* SNDRV_SBAWE */
243 MODULE_DEVICE_TABLE(pnp_card
, snd_sb16_pnpids
);
245 #endif /* CONFIG_PNP */
247 #ifdef SNDRV_SBAWE_EMU8000
248 #define DRIVER_NAME "snd-card-sbawe"
250 #define DRIVER_NAME "snd-card-sb16"
255 static int __devinit
snd_card_sb16_pnp(int dev
, struct snd_card_sb16
*acard
,
256 struct pnp_card_link
*card
,
257 const struct pnp_card_device_id
*id
)
259 struct pnp_dev
*pdev
;
260 struct pnp_resource_table
* cfg
= kmalloc(sizeof(struct pnp_resource_table
), GFP_KERNEL
);
265 acard
->dev
= pnp_request_card_device(card
, id
->devs
[0].id
, NULL
);
266 if (acard
->dev
== NULL
) {
270 #ifdef SNDRV_SBAWE_EMU8000
271 acard
->devwt
= pnp_request_card_device(card
, id
->devs
[1].id
, acard
->dev
);
273 /* Audio initialization */
276 pnp_init_resource_table(cfg
);
278 /* override resources */
280 if (port
[dev
] != SNDRV_AUTO_PORT
)
281 pnp_resource_change(&cfg
->port_resource
[0], port
[dev
], 16);
282 if (mpu_port
[dev
] != SNDRV_AUTO_PORT
)
283 pnp_resource_change(&cfg
->port_resource
[1], mpu_port
[dev
], 2);
284 if (fm_port
[dev
] != SNDRV_AUTO_PORT
)
285 pnp_resource_change(&cfg
->port_resource
[2], fm_port
[dev
], 4);
286 if (dma8
[dev
] != SNDRV_AUTO_DMA
)
287 pnp_resource_change(&cfg
->dma_resource
[0], dma8
[dev
], 1);
288 if (dma16
[dev
] != SNDRV_AUTO_DMA
)
289 pnp_resource_change(&cfg
->dma_resource
[1], dma16
[dev
], 1);
290 if (irq
[dev
] != SNDRV_AUTO_IRQ
)
291 pnp_resource_change(&cfg
->irq_resource
[0], irq
[dev
], 1);
292 if (pnp_manual_config_dev(pdev
, cfg
, 0) < 0)
293 snd_printk(KERN_ERR PFX
"AUDIO the requested resources are invalid, using auto config\n");
294 err
= pnp_activate_dev(pdev
);
296 snd_printk(KERN_ERR PFX
"AUDIO pnp configure failure\n");
300 port
[dev
] = pnp_port_start(pdev
, 0);
301 mpu_port
[dev
] = pnp_port_start(pdev
, 1);
302 fm_port
[dev
] = pnp_port_start(pdev
, 2);
303 dma8
[dev
] = pnp_dma(pdev
, 0);
304 dma16
[dev
] = pnp_dma(pdev
, 1);
305 irq
[dev
] = pnp_irq(pdev
, 0);
306 snd_printdd("pnp SB16: port=0x%lx, mpu port=0x%lx, fm port=0x%lx\n",
307 port
[dev
], mpu_port
[dev
], fm_port
[dev
]);
308 snd_printdd("pnp SB16: dma1=%i, dma2=%i, irq=%i\n",
309 dma8
[dev
], dma16
[dev
], irq
[dev
]);
310 #ifdef SNDRV_SBAWE_EMU8000
311 /* WaveTable initialization */
314 pnp_init_resource_table(cfg
);
316 /* override resources */
318 if (awe_port
[dev
] != SNDRV_AUTO_PORT
) {
319 pnp_resource_change(&cfg
->port_resource
[0], awe_port
[dev
], 4);
320 pnp_resource_change(&cfg
->port_resource
[1], awe_port
[dev
] + 0x400, 4);
321 pnp_resource_change(&cfg
->port_resource
[2], awe_port
[dev
] + 0x800, 4);
323 if ((pnp_manual_config_dev(pdev
, cfg
, 0)) < 0)
324 snd_printk(KERN_ERR PFX
"WaveTable the requested resources are invalid, using auto config\n");
325 err
= pnp_activate_dev(pdev
);
329 awe_port
[dev
] = pnp_port_start(pdev
, 0);
330 snd_printdd("pnp SB16: wavetable port=0x%llx\n",
331 (unsigned long long)pnp_port_start(pdev
, 0));
335 pnp_release_card_device(pdev
);
336 snd_printk(KERN_ERR PFX
"WaveTable pnp configure failure\n");
346 #endif /* CONFIG_PNP */
348 static void snd_sb16_free(struct snd_card
*card
)
350 struct snd_card_sb16
*acard
= card
->private_data
;
354 release_and_free_resource(acard
->fm_res
);
358 #define is_isapnp_selected(dev) isapnp[dev]
360 #define is_isapnp_selected(dev) 0
363 static struct snd_card
*snd_sb16_card_new(int dev
)
365 struct snd_card
*card
= snd_card_new(index
[dev
], id
[dev
], THIS_MODULE
,
366 sizeof(struct snd_card_sb16
));
369 card
->private_free
= snd_sb16_free
;
373 static int __devinit
snd_sb16_probe(struct snd_card
*card
, int dev
)
375 int xirq
, xdma8
, xdma16
;
377 struct snd_card_sb16
*acard
= card
->private_data
;
378 struct snd_opl3
*opl3
;
379 struct snd_hwdep
*synth
= NULL
;
380 #ifdef CONFIG_SND_SB16_CSP
381 struct snd_hwdep
*xcsp
= NULL
;
390 if ((err
= snd_sbdsp_create(card
,
393 snd_sb16dsp_interrupt
,
401 if (chip
->hardware
!= SB_HW_16
) {
402 snd_printk(KERN_ERR PFX
"SB 16 chip was not detected at 0x%lx\n", port
[dev
]);
405 chip
->mpu_port
= mpu_port
[dev
];
406 if (! is_isapnp_selected(dev
) && (err
= snd_sb16dsp_configure(chip
)) < 0)
409 if ((err
= snd_sb16dsp_pcm(chip
, 0, &chip
->pcm
)) < 0)
413 #ifdef SNDRV_SBAWE_EMU8000
414 awe_port
[dev
] > 0 ? "SB AWE" :
417 strcpy(card
->shortname
, chip
->name
);
418 sprintf(card
->longname
, "%s at 0x%lx, irq %i, dma ",
423 sprintf(card
->longname
+ strlen(card
->longname
), "%d", xdma8
);
425 sprintf(card
->longname
+ strlen(card
->longname
), "%s%d",
426 xdma8
>= 0 ? "&" : "", xdma16
);
428 if (chip
->mpu_port
> 0 && chip
->mpu_port
!= SNDRV_AUTO_PORT
) {
429 if ((err
= snd_mpu401_uart_new(card
, 0, MPU401_HW_SB
,
431 xirq
, 0, &chip
->rmidi
)) < 0)
433 chip
->rmidi_callback
= snd_mpu401_uart_interrupt
;
436 #ifdef SNDRV_SBAWE_EMU8000
437 if (awe_port
[dev
] == SNDRV_AUTO_PORT
)
438 awe_port
[dev
] = 0; /* disable */
441 if (fm_port
[dev
] > 0 && fm_port
[dev
] != SNDRV_AUTO_PORT
) {
442 if (snd_opl3_create(card
, fm_port
[dev
], fm_port
[dev
] + 2,
444 acard
->fm_res
!= NULL
|| fm_port
[dev
] == port
[dev
],
446 snd_printk(KERN_ERR PFX
"no OPL device at 0x%lx-0x%lx\n",
447 fm_port
[dev
], fm_port
[dev
] + 2);
449 #ifdef SNDRV_SBAWE_EMU8000
450 int seqdev
= awe_port
[dev
] > 0 ? 2 : 1;
454 if ((err
= snd_opl3_hwdep_new(opl3
, 0, seqdev
, &synth
)) < 0)
459 if ((err
= snd_sbmixer_new(chip
)) < 0)
462 #ifdef CONFIG_SND_SB16_CSP
463 /* CSP chip on SB16ASP/AWE32 */
464 if ((chip
->hardware
== SB_HW_16
) && csp
[dev
]) {
465 snd_sb_csp_new(chip
, synth
!= NULL
? 1 : 0, &xcsp
);
467 chip
->csp
= xcsp
->private_data
;
468 chip
->hardware
= SB_HW_16CSP
;
470 snd_printk(KERN_INFO PFX
"warning - CSP chip not detected on soundcard #%i\n", dev
+ 1);
474 #ifdef SNDRV_SBAWE_EMU8000
475 if (awe_port
[dev
] > 0) {
476 if ((err
= snd_emu8000_new(card
, 1, awe_port
[dev
],
477 seq_ports
[dev
], NULL
)) < 0) {
478 snd_printk(KERN_ERR PFX
"fatal error - EMU-8000 synthesizer not detected at 0x%lx\n", awe_port
[dev
]);
486 spin_lock_irqsave(&chip
->mixer_lock
, flags
);
487 snd_sbmixer_write(chip
, SB_DSP4_MIC_AGC
,
488 (snd_sbmixer_read(chip
, SB_DSP4_MIC_AGC
) & 0x01) |
489 (mic_agc
[dev
] ? 0x00 : 0x01));
490 spin_unlock_irqrestore(&chip
->mixer_lock
, flags
);
492 if ((err
= snd_card_register(card
)) < 0)
499 static int snd_sb16_suspend(struct snd_card
*card
, pm_message_t state
)
501 struct snd_card_sb16
*acard
= card
->private_data
;
502 struct snd_sb
*chip
= acard
->chip
;
504 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
505 snd_pcm_suspend_all(chip
->pcm
);
506 snd_sbmixer_suspend(chip
);
510 static int snd_sb16_resume(struct snd_card
*card
)
512 struct snd_card_sb16
*acard
= card
->private_data
;
513 struct snd_sb
*chip
= acard
->chip
;
515 snd_sbdsp_reset(chip
);
516 snd_sbmixer_resume(chip
);
517 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
522 static int __devinit
snd_sb16_nonpnp_probe1(int dev
, struct platform_device
*devptr
)
524 struct snd_card_sb16
*acard
;
525 struct snd_card
*card
;
528 card
= snd_sb16_card_new(dev
);
532 acard
= card
->private_data
;
533 /* non-PnP FM port address is hardwired with base port address */
534 fm_port
[dev
] = port
[dev
];
535 /* block the 0x388 port to avoid PnP conflicts */
536 acard
->fm_res
= request_region(0x388, 4, "SoundBlaster FM");
537 #ifdef SNDRV_SBAWE_EMU8000
538 /* non-PnP AWE port address is hardwired with base port address */
539 awe_port
[dev
] = port
[dev
] + 0x400;
542 snd_card_set_dev(card
, &devptr
->dev
);
543 if ((err
= snd_sb16_probe(card
, dev
)) < 0) {
547 platform_set_drvdata(devptr
, card
);
552 static int __devinit
snd_sb16_nonpnp_probe(struct platform_device
*pdev
)
556 static int possible_irqs
[] = {5, 9, 10, 7, -1};
557 static int possible_dmas8
[] = {1, 3, 0, -1};
558 static int possible_dmas16
[] = {5, 6, 7, -1};
560 if (irq
[dev
] == SNDRV_AUTO_IRQ
) {
561 if ((irq
[dev
] = snd_legacy_find_free_irq(possible_irqs
)) < 0) {
562 snd_printk(KERN_ERR PFX
"unable to find a free IRQ\n");
566 if (dma8
[dev
] == SNDRV_AUTO_DMA
) {
567 if ((dma8
[dev
] = snd_legacy_find_free_dma(possible_dmas8
)) < 0) {
568 snd_printk(KERN_ERR PFX
"unable to find a free 8-bit DMA\n");
572 if (dma16
[dev
] == SNDRV_AUTO_DMA
) {
573 if ((dma16
[dev
] = snd_legacy_find_free_dma(possible_dmas16
)) < 0) {
574 snd_printk(KERN_ERR PFX
"unable to find a free 16-bit DMA\n");
579 if (port
[dev
] != SNDRV_AUTO_PORT
)
580 return snd_sb16_nonpnp_probe1(dev
, pdev
);
582 static int possible_ports
[] = {0x220, 0x240, 0x260, 0x280};
584 for (i
= 0; i
< ARRAY_SIZE(possible_ports
); i
++) {
585 port
[dev
] = possible_ports
[i
];
586 err
= snd_sb16_nonpnp_probe1(dev
, pdev
);
594 static int __devexit
snd_sb16_nonpnp_remove(struct platform_device
*devptr
)
596 snd_card_free(platform_get_drvdata(devptr
));
597 platform_set_drvdata(devptr
, NULL
);
602 static int snd_sb16_nonpnp_suspend(struct platform_device
*dev
, pm_message_t state
)
604 return snd_sb16_suspend(platform_get_drvdata(dev
), state
);
607 static int snd_sb16_nonpnp_resume(struct platform_device
*dev
)
609 return snd_sb16_resume(platform_get_drvdata(dev
));
614 #define SND_SB16_DRIVER "snd_sbawe"
616 #define SND_SB16_DRIVER "snd_sb16"
619 static struct platform_driver snd_sb16_nonpnp_driver
= {
620 .probe
= snd_sb16_nonpnp_probe
,
621 .remove
= __devexit_p(snd_sb16_nonpnp_remove
),
623 .suspend
= snd_sb16_nonpnp_suspend
,
624 .resume
= snd_sb16_nonpnp_resume
,
627 .name
= SND_SB16_DRIVER
633 static unsigned int __devinitdata sb16_pnp_devices
;
635 static int __devinit
snd_sb16_pnp_detect(struct pnp_card_link
*pcard
,
636 const struct pnp_card_device_id
*pid
)
639 struct snd_card
*card
;
642 for ( ; dev
< SNDRV_CARDS
; dev
++) {
643 if (!enable
[dev
] || !isapnp
[dev
])
645 card
= snd_sb16_card_new(dev
);
648 snd_card_set_dev(card
, &pcard
->card
->dev
);
649 if ((res
= snd_card_sb16_pnp(dev
, card
->private_data
, pcard
, pid
)) < 0 ||
650 (res
= snd_sb16_probe(card
, dev
)) < 0) {
654 pnp_set_card_drvdata(pcard
, card
);
663 static void __devexit
snd_sb16_pnp_remove(struct pnp_card_link
* pcard
)
665 snd_card_free(pnp_get_card_drvdata(pcard
));
666 pnp_set_card_drvdata(pcard
, NULL
);
670 static int snd_sb16_pnp_suspend(struct pnp_card_link
*pcard
, pm_message_t state
)
672 return snd_sb16_suspend(pnp_get_card_drvdata(pcard
), state
);
674 static int snd_sb16_pnp_resume(struct pnp_card_link
*pcard
)
676 return snd_sb16_resume(pnp_get_card_drvdata(pcard
));
680 static struct pnp_card_driver sb16_pnpc_driver
= {
681 .flags
= PNP_DRIVER_RES_DISABLE
,
687 .id_table
= snd_sb16_pnpids
,
688 .probe
= snd_sb16_pnp_detect
,
689 .remove
= __devexit_p(snd_sb16_pnp_remove
),
691 .suspend
= snd_sb16_pnp_suspend
,
692 .resume
= snd_sb16_pnp_resume
,
696 #endif /* CONFIG_PNP */
698 static void __init_or_module
snd_sb16_unregister_all(void)
704 pnp_unregister_card_driver(&sb16_pnpc_driver
);
706 for (i
= 0; i
< ARRAY_SIZE(platform_devices
); ++i
)
707 platform_device_unregister(platform_devices
[i
]);
708 platform_driver_unregister(&snd_sb16_nonpnp_driver
);
711 static int __init
alsa_card_sb16_init(void)
713 int i
, err
, cards
= 0;
715 if ((err
= platform_driver_register(&snd_sb16_nonpnp_driver
)) < 0)
718 for (i
= 0; i
< SNDRV_CARDS
; i
++) {
719 struct platform_device
*device
;
720 if (! enable
[i
] || is_isapnp_selected(i
))
722 device
= platform_device_register_simple(SND_SB16_DRIVER
,
726 if (!platform_get_drvdata(device
)) {
727 platform_device_unregister(device
);
730 platform_devices
[i
] = device
;
734 /* PnP cards at last */
735 err
= pnp_register_card_driver(&sb16_pnpc_driver
);
738 cards
+= sb16_pnp_devices
;
744 snd_printk(KERN_ERR
"Sound Blaster 16 soundcard not found or device busy\n");
745 #ifdef SNDRV_SBAWE_EMU8000
746 snd_printk(KERN_ERR
"In case, if you have non-AWE card, try snd-sb16 module\n");
748 snd_printk(KERN_ERR
"In case, if you have AWE card, try snd-sbawe module\n");
751 snd_sb16_unregister_all();
757 static void __exit
alsa_card_sb16_exit(void)
759 snd_sb16_unregister_all();
762 module_init(alsa_card_sb16_init
)
763 module_exit(alsa_card_sb16_exit
)