2 * Driver for SoundBlaster 16/AWE32/AWE64 soundcards
3 * Copyright (c) by Jaroslav Kysela <perex@perex.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/isa.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@perex.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.");
132 static int isa_registered
;
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_isa_probe1(int dev
, struct device
*pdev
)
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
, pdev
);
543 if ((err
= snd_sb16_probe(card
, dev
)) < 0) {
547 dev_set_drvdata(pdev
, card
);
552 static int __devinit
snd_sb16_isa_match(struct device
*pdev
, unsigned int dev
)
554 return enable
[dev
] && !is_isapnp_selected(dev
);
557 static int __devinit
snd_sb16_isa_probe(struct device
*pdev
, unsigned int dev
)
560 static int possible_irqs
[] = {5, 9, 10, 7, -1};
561 static int possible_dmas8
[] = {1, 3, 0, -1};
562 static int possible_dmas16
[] = {5, 6, 7, -1};
564 if (irq
[dev
] == SNDRV_AUTO_IRQ
) {
565 if ((irq
[dev
] = snd_legacy_find_free_irq(possible_irqs
)) < 0) {
566 snd_printk(KERN_ERR PFX
"unable to find a free IRQ\n");
570 if (dma8
[dev
] == SNDRV_AUTO_DMA
) {
571 if ((dma8
[dev
] = snd_legacy_find_free_dma(possible_dmas8
)) < 0) {
572 snd_printk(KERN_ERR PFX
"unable to find a free 8-bit DMA\n");
576 if (dma16
[dev
] == SNDRV_AUTO_DMA
) {
577 if ((dma16
[dev
] = snd_legacy_find_free_dma(possible_dmas16
)) < 0) {
578 snd_printk(KERN_ERR PFX
"unable to find a free 16-bit DMA\n");
583 if (port
[dev
] != SNDRV_AUTO_PORT
)
584 return snd_sb16_isa_probe1(dev
, pdev
);
586 static int possible_ports
[] = {0x220, 0x240, 0x260, 0x280};
588 for (i
= 0; i
< ARRAY_SIZE(possible_ports
); i
++) {
589 port
[dev
] = possible_ports
[i
];
590 err
= snd_sb16_isa_probe1(dev
, pdev
);
598 static int __devexit
snd_sb16_isa_remove(struct device
*pdev
, unsigned int dev
)
600 snd_card_free(dev_get_drvdata(pdev
));
601 dev_set_drvdata(pdev
, NULL
);
606 static int snd_sb16_isa_suspend(struct device
*dev
, unsigned int n
,
609 return snd_sb16_suspend(dev_get_drvdata(dev
), state
);
612 static int snd_sb16_isa_resume(struct device
*dev
, unsigned int n
)
614 return snd_sb16_resume(dev_get_drvdata(dev
));
619 #define DEV_NAME "sbawe"
621 #define DEV_NAME "sb16"
624 static struct isa_driver snd_sb16_isa_driver
= {
625 .match
= snd_sb16_isa_match
,
626 .probe
= snd_sb16_isa_probe
,
627 .remove
= __devexit_p(snd_sb16_isa_remove
),
629 .suspend
= snd_sb16_isa_suspend
,
630 .resume
= snd_sb16_isa_resume
,
639 static int __devinit
snd_sb16_pnp_detect(struct pnp_card_link
*pcard
,
640 const struct pnp_card_device_id
*pid
)
643 struct snd_card
*card
;
646 for ( ; dev
< SNDRV_CARDS
; dev
++) {
647 if (!enable
[dev
] || !isapnp
[dev
])
649 card
= snd_sb16_card_new(dev
);
652 snd_card_set_dev(card
, &pcard
->card
->dev
);
653 if ((res
= snd_card_sb16_pnp(dev
, card
->private_data
, pcard
, pid
)) < 0 ||
654 (res
= snd_sb16_probe(card
, dev
)) < 0) {
658 pnp_set_card_drvdata(pcard
, card
);
666 static void __devexit
snd_sb16_pnp_remove(struct pnp_card_link
* pcard
)
668 snd_card_free(pnp_get_card_drvdata(pcard
));
669 pnp_set_card_drvdata(pcard
, NULL
);
673 static int snd_sb16_pnp_suspend(struct pnp_card_link
*pcard
, pm_message_t state
)
675 return snd_sb16_suspend(pnp_get_card_drvdata(pcard
), state
);
677 static int snd_sb16_pnp_resume(struct pnp_card_link
*pcard
)
679 return snd_sb16_resume(pnp_get_card_drvdata(pcard
));
683 static struct pnp_card_driver sb16_pnpc_driver
= {
684 .flags
= PNP_DRIVER_RES_DISABLE
,
690 .id_table
= snd_sb16_pnpids
,
691 .probe
= snd_sb16_pnp_detect
,
692 .remove
= __devexit_p(snd_sb16_pnp_remove
),
694 .suspend
= snd_sb16_pnp_suspend
,
695 .resume
= snd_sb16_pnp_resume
,
699 #endif /* CONFIG_PNP */
701 static int __init
alsa_card_sb16_init(void)
705 err
= isa_register_driver(&snd_sb16_isa_driver
, SNDRV_CARDS
);
710 err
= pnp_register_card_driver(&sb16_pnpc_driver
);
720 static void __exit
alsa_card_sb16_exit(void)
724 pnp_unregister_card_driver(&sb16_pnpc_driver
);
727 isa_unregister_driver(&snd_sb16_isa_driver
);
730 module_init(alsa_card_sb16_init
)
731 module_exit(alsa_card_sb16_exit
)