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
23 #include <linux/init.h>
24 #include <linux/slab.h>
25 #include <linux/pnp.h>
26 #include <linux/err.h>
27 #include <linux/isa.h>
28 #include <linux/moduleparam.h>
29 #include <sound/core.h>
31 #include <sound/sb16_csp.h>
32 #include <sound/mpu401.h>
33 #include <sound/opl3.h>
34 #include <sound/emu8000.h>
35 #include <sound/seq_device.h>
36 #define SNDRV_LEGACY_FIND_FREE_IRQ
37 #define SNDRV_LEGACY_FIND_FREE_DMA
38 #include <sound/initval.h>
46 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
47 MODULE_LICENSE("GPL");
49 MODULE_DESCRIPTION("Sound Blaster 16");
50 MODULE_SUPPORTED_DEVICE("{{Creative Labs,SB 16},"
51 "{Creative Labs,SB Vibra16S},"
52 "{Creative Labs,SB Vibra16C},"
53 "{Creative Labs,SB Vibra16CL},"
54 "{Creative Labs,SB Vibra16X}}");
56 MODULE_DESCRIPTION("Sound Blaster AWE");
57 MODULE_SUPPORTED_DEVICE("{{Creative Labs,SB AWE 32},"
58 "{Creative Labs,SB AWE 64},"
59 "{Creative Labs,SB AWE 64 Gold}}");
63 #define SNDRV_DEBUG_IRQ
66 #if defined(SNDRV_SBAWE) && (defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE)))
67 #define SNDRV_SBAWE_EMU8000
70 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
71 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
72 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_ISAPNP
; /* Enable this card */
74 static int isapnp
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 1};
76 static long port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
; /* 0x220,0x240,0x260,0x280 */
77 static long mpu_port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
; /* 0x330,0x300 */
78 static long fm_port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
;
79 #ifdef SNDRV_SBAWE_EMU8000
80 static long awe_port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
;
82 static int irq
[SNDRV_CARDS
] = SNDRV_DEFAULT_IRQ
; /* 5,7,9,10 */
83 static int dma8
[SNDRV_CARDS
] = SNDRV_DEFAULT_DMA
; /* 0,1,3 */
84 static int dma16
[SNDRV_CARDS
] = SNDRV_DEFAULT_DMA
; /* 5,6,7 */
85 static int mic_agc
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 1};
86 #ifdef CONFIG_SND_SB16_CSP
87 static int csp
[SNDRV_CARDS
];
89 #ifdef SNDRV_SBAWE_EMU8000
90 static int seq_ports
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 4};
93 module_param_array(index
, int, NULL
, 0444);
94 MODULE_PARM_DESC(index
, "Index value for SoundBlaster 16 soundcard.");
95 module_param_array(id
, charp
, NULL
, 0444);
96 MODULE_PARM_DESC(id
, "ID string for SoundBlaster 16 soundcard.");
97 module_param_array(enable
, bool, NULL
, 0444);
98 MODULE_PARM_DESC(enable
, "Enable SoundBlaster 16 soundcard.");
100 module_param_array(isapnp
, bool, NULL
, 0444);
101 MODULE_PARM_DESC(isapnp
, "PnP detection for specified soundcard.");
103 module_param_array(port
, long, NULL
, 0444);
104 MODULE_PARM_DESC(port
, "Port # for SB16 driver.");
105 module_param_array(mpu_port
, long, NULL
, 0444);
106 MODULE_PARM_DESC(mpu_port
, "MPU-401 port # for SB16 driver.");
107 module_param_array(fm_port
, long, NULL
, 0444);
108 MODULE_PARM_DESC(fm_port
, "FM port # for SB16 PnP driver.");
109 #ifdef SNDRV_SBAWE_EMU8000
110 module_param_array(awe_port
, long, NULL
, 0444);
111 MODULE_PARM_DESC(awe_port
, "AWE port # for SB16 PnP driver.");
113 module_param_array(irq
, int, NULL
, 0444);
114 MODULE_PARM_DESC(irq
, "IRQ # for SB16 driver.");
115 module_param_array(dma8
, int, NULL
, 0444);
116 MODULE_PARM_DESC(dma8
, "8-bit DMA # for SB16 driver.");
117 module_param_array(dma16
, int, NULL
, 0444);
118 MODULE_PARM_DESC(dma16
, "16-bit DMA # for SB16 driver.");
119 module_param_array(mic_agc
, int, NULL
, 0444);
120 MODULE_PARM_DESC(mic_agc
, "Mic Auto-Gain-Control switch.");
121 #ifdef CONFIG_SND_SB16_CSP
122 module_param_array(csp
, int, NULL
, 0444);
123 MODULE_PARM_DESC(csp
, "ASP/CSP chip support.");
125 #ifdef SNDRV_SBAWE_EMU8000
126 module_param_array(seq_ports
, int, NULL
, 0444);
127 MODULE_PARM_DESC(seq_ports
, "Number of sequencer ports for WaveTable synth.");
131 static int isa_registered
;
132 static int pnp_registered
;
135 struct snd_card_sb16
{
136 struct resource
*fm_res
; /* used to block FM i/o region for legacy cards */
141 #ifdef SNDRV_SBAWE_EMU8000
142 struct pnp_dev
*devwt
;
149 static struct pnp_card_device_id snd_sb16_pnpids
[] = {
151 /* Sound Blaster 16 PnP */
152 { .id
= "CTL0024", .devs
= { { "CTL0031" } } },
153 /* Sound Blaster 16 PnP */
154 { .id
= "CTL0025", .devs
= { { "CTL0031" } } },
155 /* Sound Blaster 16 PnP */
156 { .id
= "CTL0026", .devs
= { { "CTL0031" } } },
157 /* Sound Blaster 16 PnP */
158 { .id
= "CTL0027", .devs
= { { "CTL0031" } } },
159 /* Sound Blaster 16 PnP */
160 { .id
= "CTL0028", .devs
= { { "CTL0031" } } },
161 /* Sound Blaster 16 PnP */
162 { .id
= "CTL0029", .devs
= { { "CTL0031" } } },
163 /* Sound Blaster 16 PnP */
164 { .id
= "CTL002a", .devs
= { { "CTL0031" } } },
165 /* Sound Blaster 16 PnP */
166 /* Note: This card has also a CTL0051:StereoEnhance device!!! */
167 { .id
= "CTL002b", .devs
= { { "CTL0031" } } },
168 /* Sound Blaster 16 PnP */
169 { .id
= "CTL002c", .devs
= { { "CTL0031" } } },
170 /* Sound Blaster Vibra16S */
171 { .id
= "CTL0051", .devs
= { { "CTL0001" } } },
172 /* Sound Blaster Vibra16C */
173 { .id
= "CTL0070", .devs
= { { "CTL0001" } } },
174 /* Sound Blaster Vibra16CL - added by ctm@ardi.com */
175 { .id
= "CTL0080", .devs
= { { "CTL0041" } } },
176 /* Sound Blaster 16 'value' PnP. It says model ct4130 on the pcb, */
177 /* but ct4131 on a sticker on the board.. */
178 { .id
= "CTL0086", .devs
= { { "CTL0041" } } },
179 /* Sound Blaster Vibra16X */
180 { .id
= "CTL00f0", .devs
= { { "CTL0043" } } },
181 /* Sound Blaster 16 (Virtual PC 2004) */
182 { .id
= "tBA03b0", .devs
= { {.id
="PNPb003" } } },
183 #else /* SNDRV_SBAWE defined */
184 /* Sound Blaster AWE 32 PnP */
185 { .id
= "CTL0035", .devs
= { { "CTL0031" }, { "CTL0021" } } },
186 /* Sound Blaster AWE 32 PnP */
187 { .id
= "CTL0039", .devs
= { { "CTL0031" }, { "CTL0021" } } },
188 /* Sound Blaster AWE 32 PnP */
189 { .id
= "CTL0042", .devs
= { { "CTL0031" }, { "CTL0021" } } },
190 /* Sound Blaster AWE 32 PnP */
191 { .id
= "CTL0043", .devs
= { { "CTL0031" }, { "CTL0021" } } },
192 /* Sound Blaster AWE 32 PnP */
193 /* Note: This card has also a CTL0051:StereoEnhance device!!! */
194 { .id
= "CTL0044", .devs
= { { "CTL0031" }, { "CTL0021" } } },
195 /* Sound Blaster AWE 32 PnP */
196 /* Note: This card has also a CTL0051:StereoEnhance device!!! */
197 { .id
= "CTL0045", .devs
= { { "CTL0031" }, { "CTL0021" } } },
198 /* Sound Blaster AWE 32 PnP */
199 { .id
= "CTL0046", .devs
= { { "CTL0031" }, { "CTL0021" } } },
200 /* Sound Blaster AWE 32 PnP */
201 { .id
= "CTL0047", .devs
= { { "CTL0031" }, { "CTL0021" } } },
202 /* Sound Blaster AWE 32 PnP */
203 { .id
= "CTL0048", .devs
= { { "CTL0031" }, { "CTL0021" } } },
204 /* Sound Blaster AWE 32 PnP */
205 { .id
= "CTL0054", .devs
= { { "CTL0031" }, { "CTL0021" } } },
206 /* Sound Blaster AWE 32 PnP */
207 { .id
= "CTL009a", .devs
= { { "CTL0041" }, { "CTL0021" } } },
208 /* Sound Blaster AWE 32 PnP */
209 { .id
= "CTL009c", .devs
= { { "CTL0041" }, { "CTL0021" } } },
210 /* Sound Blaster 32 PnP */
211 { .id
= "CTL009f", .devs
= { { "CTL0041" }, { "CTL0021" } } },
212 /* Sound Blaster AWE 64 PnP */
213 { .id
= "CTL009d", .devs
= { { "CTL0042" }, { "CTL0022" } } },
214 /* Sound Blaster AWE 64 PnP Gold */
215 { .id
= "CTL009e", .devs
= { { "CTL0044" }, { "CTL0023" } } },
216 /* Sound Blaster AWE 64 PnP Gold */
217 { .id
= "CTL00b2", .devs
= { { "CTL0044" }, { "CTL0023" } } },
218 /* Sound Blaster AWE 64 PnP */
219 { .id
= "CTL00c1", .devs
= { { "CTL0042" }, { "CTL0022" } } },
220 /* Sound Blaster AWE 64 PnP */
221 { .id
= "CTL00c3", .devs
= { { "CTL0045" }, { "CTL0022" } } },
222 /* Sound Blaster AWE 64 PnP */
223 { .id
= "CTL00c5", .devs
= { { "CTL0045" }, { "CTL0022" } } },
224 /* Sound Blaster AWE 64 PnP */
225 { .id
= "CTL00c7", .devs
= { { "CTL0045" }, { "CTL0022" } } },
226 /* Sound Blaster AWE 64 PnP */
227 { .id
= "CTL00e4", .devs
= { { "CTL0045" }, { "CTL0022" } } },
228 /* Sound Blaster AWE 64 PnP */
229 { .id
= "CTL00e9", .devs
= { { "CTL0045" }, { "CTL0022" } } },
230 /* Sound Blaster 16 PnP (AWE) */
231 { .id
= "CTL00ed", .devs
= { { "CTL0041" }, { "CTL0070" } } },
232 /* Generic entries */
233 { .id
= "CTLXXXX" , .devs
= { { "CTL0031" }, { "CTL0021" } } },
234 { .id
= "CTLXXXX" , .devs
= { { "CTL0041" }, { "CTL0021" } } },
235 { .id
= "CTLXXXX" , .devs
= { { "CTL0042" }, { "CTL0022" } } },
236 { .id
= "CTLXXXX" , .devs
= { { "CTL0044" }, { "CTL0023" } } },
237 { .id
= "CTLXXXX" , .devs
= { { "CTL0045" }, { "CTL0022" } } },
238 #endif /* SNDRV_SBAWE */
242 MODULE_DEVICE_TABLE(pnp_card
, snd_sb16_pnpids
);
244 #endif /* CONFIG_PNP */
246 #ifdef SNDRV_SBAWE_EMU8000
247 #define DRIVER_NAME "snd-card-sbawe"
249 #define DRIVER_NAME "snd-card-sb16"
254 static int __devinit
snd_card_sb16_pnp(int dev
, struct snd_card_sb16
*acard
,
255 struct pnp_card_link
*card
,
256 const struct pnp_card_device_id
*id
)
258 struct pnp_dev
*pdev
;
261 acard
->dev
= pnp_request_card_device(card
, id
->devs
[0].id
, NULL
);
262 if (acard
->dev
== NULL
)
265 #ifdef SNDRV_SBAWE_EMU8000
266 acard
->devwt
= pnp_request_card_device(card
, id
->devs
[1].id
, acard
->dev
);
268 /* Audio initialization */
271 err
= pnp_activate_dev(pdev
);
273 snd_printk(KERN_ERR PFX
"AUDIO pnp configure failure\n");
276 port
[dev
] = pnp_port_start(pdev
, 0);
277 mpu_port
[dev
] = pnp_port_start(pdev
, 1);
278 fm_port
[dev
] = pnp_port_start(pdev
, 2);
279 dma8
[dev
] = pnp_dma(pdev
, 0);
280 dma16
[dev
] = pnp_dma(pdev
, 1);
281 irq
[dev
] = pnp_irq(pdev
, 0);
282 snd_printdd("pnp SB16: port=0x%lx, mpu port=0x%lx, fm port=0x%lx\n",
283 port
[dev
], mpu_port
[dev
], fm_port
[dev
]);
284 snd_printdd("pnp SB16: dma1=%i, dma2=%i, irq=%i\n",
285 dma8
[dev
], dma16
[dev
], irq
[dev
]);
286 #ifdef SNDRV_SBAWE_EMU8000
287 /* WaveTable initialization */
290 err
= pnp_activate_dev(pdev
);
294 awe_port
[dev
] = pnp_port_start(pdev
, 0);
295 snd_printdd("pnp SB16: wavetable port=0x%llx\n",
296 (unsigned long long)pnp_port_start(pdev
, 0));
300 pnp_release_card_device(pdev
);
301 snd_printk(KERN_ERR PFX
"WaveTable pnp configure failure\n");
310 #endif /* CONFIG_PNP */
312 static void snd_sb16_free(struct snd_card
*card
)
314 struct snd_card_sb16
*acard
= card
->private_data
;
318 release_and_free_resource(acard
->fm_res
);
322 #define is_isapnp_selected(dev) isapnp[dev]
324 #define is_isapnp_selected(dev) 0
327 static struct snd_card
*snd_sb16_card_new(int dev
)
329 struct snd_card
*card
;
332 err
= snd_card_create(index
[dev
], id
[dev
], THIS_MODULE
,
333 sizeof(struct snd_card_sb16
), &card
);
336 card
->private_free
= snd_sb16_free
;
340 static int __devinit
snd_sb16_probe(struct snd_card
*card
, int dev
)
342 int xirq
, xdma8
, xdma16
;
344 struct snd_card_sb16
*acard
= card
->private_data
;
345 struct snd_opl3
*opl3
;
346 struct snd_hwdep
*synth
= NULL
;
347 #ifdef CONFIG_SND_SB16_CSP
348 struct snd_hwdep
*xcsp
= NULL
;
357 if ((err
= snd_sbdsp_create(card
,
360 snd_sb16dsp_interrupt
,
368 if (chip
->hardware
!= SB_HW_16
) {
369 snd_printk(KERN_ERR PFX
"SB 16 chip was not detected at 0x%lx\n", port
[dev
]);
372 chip
->mpu_port
= mpu_port
[dev
];
373 if (! is_isapnp_selected(dev
) && (err
= snd_sb16dsp_configure(chip
)) < 0)
376 if ((err
= snd_sb16dsp_pcm(chip
, 0, &chip
->pcm
)) < 0)
380 #ifdef SNDRV_SBAWE_EMU8000
381 awe_port
[dev
] > 0 ? "SB AWE" :
384 strcpy(card
->shortname
, chip
->name
);
385 sprintf(card
->longname
, "%s at 0x%lx, irq %i, dma ",
390 sprintf(card
->longname
+ strlen(card
->longname
), "%d", xdma8
);
392 sprintf(card
->longname
+ strlen(card
->longname
), "%s%d",
393 xdma8
>= 0 ? "&" : "", xdma16
);
395 if (chip
->mpu_port
> 0 && chip
->mpu_port
!= SNDRV_AUTO_PORT
) {
396 if ((err
= snd_mpu401_uart_new(card
, 0, MPU401_HW_SB
,
398 xirq
, 0, &chip
->rmidi
)) < 0)
400 chip
->rmidi_callback
= snd_mpu401_uart_interrupt
;
403 #ifdef SNDRV_SBAWE_EMU8000
404 if (awe_port
[dev
] == SNDRV_AUTO_PORT
)
405 awe_port
[dev
] = 0; /* disable */
408 if (fm_port
[dev
] > 0 && fm_port
[dev
] != SNDRV_AUTO_PORT
) {
409 if (snd_opl3_create(card
, fm_port
[dev
], fm_port
[dev
] + 2,
411 acard
->fm_res
!= NULL
|| fm_port
[dev
] == port
[dev
],
413 snd_printk(KERN_ERR PFX
"no OPL device at 0x%lx-0x%lx\n",
414 fm_port
[dev
], fm_port
[dev
] + 2);
416 #ifdef SNDRV_SBAWE_EMU8000
417 int seqdev
= awe_port
[dev
] > 0 ? 2 : 1;
421 if ((err
= snd_opl3_hwdep_new(opl3
, 0, seqdev
, &synth
)) < 0)
426 if ((err
= snd_sbmixer_new(chip
)) < 0)
429 #ifdef CONFIG_SND_SB16_CSP
430 /* CSP chip on SB16ASP/AWE32 */
431 if ((chip
->hardware
== SB_HW_16
) && csp
[dev
]) {
432 snd_sb_csp_new(chip
, synth
!= NULL
? 1 : 0, &xcsp
);
434 chip
->csp
= xcsp
->private_data
;
435 chip
->hardware
= SB_HW_16CSP
;
437 snd_printk(KERN_INFO PFX
"warning - CSP chip not detected on soundcard #%i\n", dev
+ 1);
441 #ifdef SNDRV_SBAWE_EMU8000
442 if (awe_port
[dev
] > 0) {
443 if ((err
= snd_emu8000_new(card
, 1, awe_port
[dev
],
444 seq_ports
[dev
], NULL
)) < 0) {
445 snd_printk(KERN_ERR PFX
"fatal error - EMU-8000 synthesizer not detected at 0x%lx\n", awe_port
[dev
]);
453 spin_lock_irqsave(&chip
->mixer_lock
, flags
);
454 snd_sbmixer_write(chip
, SB_DSP4_MIC_AGC
,
455 (snd_sbmixer_read(chip
, SB_DSP4_MIC_AGC
) & 0x01) |
456 (mic_agc
[dev
] ? 0x00 : 0x01));
457 spin_unlock_irqrestore(&chip
->mixer_lock
, flags
);
459 if ((err
= snd_card_register(card
)) < 0)
466 static int snd_sb16_suspend(struct snd_card
*card
, pm_message_t state
)
468 struct snd_card_sb16
*acard
= card
->private_data
;
469 struct snd_sb
*chip
= acard
->chip
;
471 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
472 snd_pcm_suspend_all(chip
->pcm
);
473 snd_sbmixer_suspend(chip
);
477 static int snd_sb16_resume(struct snd_card
*card
)
479 struct snd_card_sb16
*acard
= card
->private_data
;
480 struct snd_sb
*chip
= acard
->chip
;
482 snd_sbdsp_reset(chip
);
483 snd_sbmixer_resume(chip
);
484 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
489 static int __devinit
snd_sb16_isa_probe1(int dev
, struct device
*pdev
)
491 struct snd_card_sb16
*acard
;
492 struct snd_card
*card
;
495 card
= snd_sb16_card_new(dev
);
499 acard
= card
->private_data
;
500 /* non-PnP FM port address is hardwired with base port address */
501 fm_port
[dev
] = port
[dev
];
502 /* block the 0x388 port to avoid PnP conflicts */
503 acard
->fm_res
= request_region(0x388, 4, "SoundBlaster FM");
504 #ifdef SNDRV_SBAWE_EMU8000
505 /* non-PnP AWE port address is hardwired with base port address */
506 awe_port
[dev
] = port
[dev
] + 0x400;
509 snd_card_set_dev(card
, pdev
);
510 if ((err
= snd_sb16_probe(card
, dev
)) < 0) {
514 dev_set_drvdata(pdev
, card
);
519 static int __devinit
snd_sb16_isa_match(struct device
*pdev
, unsigned int dev
)
521 return enable
[dev
] && !is_isapnp_selected(dev
);
524 static int __devinit
snd_sb16_isa_probe(struct device
*pdev
, unsigned int dev
)
527 static int possible_irqs
[] = {5, 9, 10, 7, -1};
528 static int possible_dmas8
[] = {1, 3, 0, -1};
529 static int possible_dmas16
[] = {5, 6, 7, -1};
531 if (irq
[dev
] == SNDRV_AUTO_IRQ
) {
532 if ((irq
[dev
] = snd_legacy_find_free_irq(possible_irqs
)) < 0) {
533 snd_printk(KERN_ERR PFX
"unable to find a free IRQ\n");
537 if (dma8
[dev
] == SNDRV_AUTO_DMA
) {
538 if ((dma8
[dev
] = snd_legacy_find_free_dma(possible_dmas8
)) < 0) {
539 snd_printk(KERN_ERR PFX
"unable to find a free 8-bit DMA\n");
543 if (dma16
[dev
] == SNDRV_AUTO_DMA
) {
544 if ((dma16
[dev
] = snd_legacy_find_free_dma(possible_dmas16
)) < 0) {
545 snd_printk(KERN_ERR PFX
"unable to find a free 16-bit DMA\n");
550 if (port
[dev
] != SNDRV_AUTO_PORT
)
551 return snd_sb16_isa_probe1(dev
, pdev
);
553 static int possible_ports
[] = {0x220, 0x240, 0x260, 0x280};
555 for (i
= 0; i
< ARRAY_SIZE(possible_ports
); i
++) {
556 port
[dev
] = possible_ports
[i
];
557 err
= snd_sb16_isa_probe1(dev
, pdev
);
565 static int __devexit
snd_sb16_isa_remove(struct device
*pdev
, unsigned int dev
)
567 snd_card_free(dev_get_drvdata(pdev
));
568 dev_set_drvdata(pdev
, NULL
);
573 static int snd_sb16_isa_suspend(struct device
*dev
, unsigned int n
,
576 return snd_sb16_suspend(dev_get_drvdata(dev
), state
);
579 static int snd_sb16_isa_resume(struct device
*dev
, unsigned int n
)
581 return snd_sb16_resume(dev_get_drvdata(dev
));
586 #define DEV_NAME "sbawe"
588 #define DEV_NAME "sb16"
591 static struct isa_driver snd_sb16_isa_driver
= {
592 .match
= snd_sb16_isa_match
,
593 .probe
= snd_sb16_isa_probe
,
594 .remove
= __devexit_p(snd_sb16_isa_remove
),
596 .suspend
= snd_sb16_isa_suspend
,
597 .resume
= snd_sb16_isa_resume
,
606 static int __devinit
snd_sb16_pnp_detect(struct pnp_card_link
*pcard
,
607 const struct pnp_card_device_id
*pid
)
610 struct snd_card
*card
;
613 for ( ; dev
< SNDRV_CARDS
; dev
++) {
614 if (!enable
[dev
] || !isapnp
[dev
])
616 card
= snd_sb16_card_new(dev
);
619 snd_card_set_dev(card
, &pcard
->card
->dev
);
620 if ((res
= snd_card_sb16_pnp(dev
, card
->private_data
, pcard
, pid
)) < 0 ||
621 (res
= snd_sb16_probe(card
, dev
)) < 0) {
625 pnp_set_card_drvdata(pcard
, card
);
633 static void __devexit
snd_sb16_pnp_remove(struct pnp_card_link
* pcard
)
635 snd_card_free(pnp_get_card_drvdata(pcard
));
636 pnp_set_card_drvdata(pcard
, NULL
);
640 static int snd_sb16_pnp_suspend(struct pnp_card_link
*pcard
, pm_message_t state
)
642 return snd_sb16_suspend(pnp_get_card_drvdata(pcard
), state
);
644 static int snd_sb16_pnp_resume(struct pnp_card_link
*pcard
)
646 return snd_sb16_resume(pnp_get_card_drvdata(pcard
));
650 static struct pnp_card_driver sb16_pnpc_driver
= {
651 .flags
= PNP_DRIVER_RES_DISABLE
,
657 .id_table
= snd_sb16_pnpids
,
658 .probe
= snd_sb16_pnp_detect
,
659 .remove
= __devexit_p(snd_sb16_pnp_remove
),
661 .suspend
= snd_sb16_pnp_suspend
,
662 .resume
= snd_sb16_pnp_resume
,
666 #endif /* CONFIG_PNP */
668 static int __init
alsa_card_sb16_init(void)
672 err
= isa_register_driver(&snd_sb16_isa_driver
, SNDRV_CARDS
);
677 err
= pnp_register_card_driver(&sb16_pnpc_driver
);
687 static void __exit
alsa_card_sb16_exit(void)
691 pnp_unregister_card_driver(&sb16_pnpc_driver
);
694 isa_unregister_driver(&snd_sb16_isa_driver
);
697 module_init(alsa_card_sb16_init
)
698 module_exit(alsa_card_sb16_exit
)