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/pnp.h>
25 #include <linux/err.h>
26 #include <linux/isa.h>
27 #include <linux/moduleparam.h>
28 #include <sound/core.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>
35 #define SNDRV_LEGACY_FIND_FREE_IRQ
36 #define SNDRV_LEGACY_FIND_FREE_DMA
37 #include <sound/initval.h>
45 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
46 MODULE_LICENSE("GPL");
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}}");
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}}");
62 #if defined(SNDRV_SBAWE) && (defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && \
63 defined(CONFIG_SND_SEQUENCER_MODULE)))
64 #define SNDRV_SBAWE_EMU8000
67 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
68 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
69 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_ISAPNP
; /* Enable this card */
71 static int isapnp
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 1};
73 static long port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
; /* 0x220,0x240,0x260,0x280 */
74 static long mpu_port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
; /* 0x330,0x300 */
75 static long fm_port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
;
76 #ifdef SNDRV_SBAWE_EMU8000
77 static long awe_port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
;
79 static int irq
[SNDRV_CARDS
] = SNDRV_DEFAULT_IRQ
; /* 5,7,9,10 */
80 static int dma8
[SNDRV_CARDS
] = SNDRV_DEFAULT_DMA
; /* 0,1,3 */
81 static int dma16
[SNDRV_CARDS
] = SNDRV_DEFAULT_DMA
; /* 5,6,7 */
82 static int mic_agc
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 1};
83 #ifdef CONFIG_SND_SB16_CSP
84 static int csp
[SNDRV_CARDS
];
86 #ifdef SNDRV_SBAWE_EMU8000
87 static int seq_ports
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 4};
90 module_param_array(index
, int, NULL
, 0444);
91 MODULE_PARM_DESC(index
, "Index value for SoundBlaster 16 soundcard.");
92 module_param_array(id
, charp
, NULL
, 0444);
93 MODULE_PARM_DESC(id
, "ID string for SoundBlaster 16 soundcard.");
94 module_param_array(enable
, bool, NULL
, 0444);
95 MODULE_PARM_DESC(enable
, "Enable SoundBlaster 16 soundcard.");
97 module_param_array(isapnp
, bool, NULL
, 0444);
98 MODULE_PARM_DESC(isapnp
, "PnP detection for specified soundcard.");
100 module_param_array(port
, long, NULL
, 0444);
101 MODULE_PARM_DESC(port
, "Port # for SB16 driver.");
102 module_param_array(mpu_port
, long, NULL
, 0444);
103 MODULE_PARM_DESC(mpu_port
, "MPU-401 port # for SB16 driver.");
104 module_param_array(fm_port
, long, NULL
, 0444);
105 MODULE_PARM_DESC(fm_port
, "FM port # for SB16 PnP driver.");
106 #ifdef SNDRV_SBAWE_EMU8000
107 module_param_array(awe_port
, long, NULL
, 0444);
108 MODULE_PARM_DESC(awe_port
, "AWE port # for SB16 PnP driver.");
110 module_param_array(irq
, int, NULL
, 0444);
111 MODULE_PARM_DESC(irq
, "IRQ # for SB16 driver.");
112 module_param_array(dma8
, int, NULL
, 0444);
113 MODULE_PARM_DESC(dma8
, "8-bit DMA # for SB16 driver.");
114 module_param_array(dma16
, int, NULL
, 0444);
115 MODULE_PARM_DESC(dma16
, "16-bit DMA # for SB16 driver.");
116 module_param_array(mic_agc
, int, NULL
, 0444);
117 MODULE_PARM_DESC(mic_agc
, "Mic Auto-Gain-Control switch.");
118 #ifdef CONFIG_SND_SB16_CSP
119 module_param_array(csp
, int, NULL
, 0444);
120 MODULE_PARM_DESC(csp
, "ASP/CSP chip support.");
122 #ifdef SNDRV_SBAWE_EMU8000
123 module_param_array(seq_ports
, int, NULL
, 0444);
124 MODULE_PARM_DESC(seq_ports
, "Number of sequencer ports for WaveTable synth.");
128 static int isa_registered
;
129 static int pnp_registered
;
132 struct snd_card_sb16
{
133 struct resource
*fm_res
; /* used to block FM i/o region for legacy cards */
138 #ifdef SNDRV_SBAWE_EMU8000
139 struct pnp_dev
*devwt
;
146 static struct pnp_card_device_id snd_sb16_pnpids
[] = {
148 /* Sound Blaster 16 PnP */
149 { .id
= "CTL0024", .devs
= { { "CTL0031" } } },
150 /* Sound Blaster 16 PnP */
151 { .id
= "CTL0025", .devs
= { { "CTL0031" } } },
152 /* Sound Blaster 16 PnP */
153 { .id
= "CTL0026", .devs
= { { "CTL0031" } } },
154 /* Sound Blaster 16 PnP */
155 { .id
= "CTL0027", .devs
= { { "CTL0031" } } },
156 /* Sound Blaster 16 PnP */
157 { .id
= "CTL0028", .devs
= { { "CTL0031" } } },
158 /* Sound Blaster 16 PnP */
159 { .id
= "CTL0029", .devs
= { { "CTL0031" } } },
160 /* Sound Blaster 16 PnP */
161 { .id
= "CTL002a", .devs
= { { "CTL0031" } } },
162 /* Sound Blaster 16 PnP */
163 /* Note: This card has also a CTL0051:StereoEnhance device!!! */
164 { .id
= "CTL002b", .devs
= { { "CTL0031" } } },
165 /* Sound Blaster 16 PnP */
166 { .id
= "CTL002c", .devs
= { { "CTL0031" } } },
167 /* Sound Blaster Vibra16S */
168 { .id
= "CTL0051", .devs
= { { "CTL0001" } } },
169 /* Sound Blaster Vibra16C */
170 { .id
= "CTL0070", .devs
= { { "CTL0001" } } },
171 /* Sound Blaster Vibra16CL - added by ctm@ardi.com */
172 { .id
= "CTL0080", .devs
= { { "CTL0041" } } },
173 /* Sound Blaster 16 'value' PnP. It says model ct4130 on the pcb, */
174 /* but ct4131 on a sticker on the board.. */
175 { .id
= "CTL0086", .devs
= { { "CTL0041" } } },
176 /* Sound Blaster Vibra16X */
177 { .id
= "CTL00f0", .devs
= { { "CTL0043" } } },
178 /* Sound Blaster 16 (Virtual PC 2004) */
179 { .id
= "tBA03b0", .devs
= { {.id
="PNPb003" } } },
180 #else /* SNDRV_SBAWE defined */
181 /* Sound Blaster AWE 32 PnP */
182 { .id
= "CTL0035", .devs
= { { "CTL0031" }, { "CTL0021" } } },
183 /* Sound Blaster AWE 32 PnP */
184 { .id
= "CTL0039", .devs
= { { "CTL0031" }, { "CTL0021" } } },
185 /* Sound Blaster AWE 32 PnP */
186 { .id
= "CTL0042", .devs
= { { "CTL0031" }, { "CTL0021" } } },
187 /* Sound Blaster AWE 32 PnP */
188 { .id
= "CTL0043", .devs
= { { "CTL0031" }, { "CTL0021" } } },
189 /* Sound Blaster AWE 32 PnP */
190 /* Note: This card has also a CTL0051:StereoEnhance device!!! */
191 { .id
= "CTL0044", .devs
= { { "CTL0031" }, { "CTL0021" } } },
192 /* Sound Blaster AWE 32 PnP */
193 /* Note: This card has also a CTL0051:StereoEnhance device!!! */
194 { .id
= "CTL0045", .devs
= { { "CTL0031" }, { "CTL0021" } } },
195 /* Sound Blaster AWE 32 PnP */
196 { .id
= "CTL0046", .devs
= { { "CTL0031" }, { "CTL0021" } } },
197 /* Sound Blaster AWE 32 PnP */
198 { .id
= "CTL0047", .devs
= { { "CTL0031" }, { "CTL0021" } } },
199 /* Sound Blaster AWE 32 PnP */
200 { .id
= "CTL0048", .devs
= { { "CTL0031" }, { "CTL0021" } } },
201 /* Sound Blaster AWE 32 PnP */
202 { .id
= "CTL0054", .devs
= { { "CTL0031" }, { "CTL0021" } } },
203 /* Sound Blaster AWE 32 PnP */
204 { .id
= "CTL009a", .devs
= { { "CTL0041" }, { "CTL0021" } } },
205 /* Sound Blaster AWE 32 PnP */
206 { .id
= "CTL009c", .devs
= { { "CTL0041" }, { "CTL0021" } } },
207 /* Sound Blaster 32 PnP */
208 { .id
= "CTL009f", .devs
= { { "CTL0041" }, { "CTL0021" } } },
209 /* Sound Blaster AWE 64 PnP */
210 { .id
= "CTL009d", .devs
= { { "CTL0042" }, { "CTL0022" } } },
211 /* Sound Blaster AWE 64 PnP Gold */
212 { .id
= "CTL009e", .devs
= { { "CTL0044" }, { "CTL0023" } } },
213 /* Sound Blaster AWE 64 PnP Gold */
214 { .id
= "CTL00b2", .devs
= { { "CTL0044" }, { "CTL0023" } } },
215 /* Sound Blaster AWE 64 PnP */
216 { .id
= "CTL00c1", .devs
= { { "CTL0042" }, { "CTL0022" } } },
217 /* Sound Blaster AWE 64 PnP */
218 { .id
= "CTL00c3", .devs
= { { "CTL0045" }, { "CTL0022" } } },
219 /* Sound Blaster AWE 64 PnP */
220 { .id
= "CTL00c5", .devs
= { { "CTL0045" }, { "CTL0022" } } },
221 /* Sound Blaster AWE 64 PnP */
222 { .id
= "CTL00c7", .devs
= { { "CTL0045" }, { "CTL0022" } } },
223 /* Sound Blaster AWE 64 PnP */
224 { .id
= "CTL00e4", .devs
= { { "CTL0045" }, { "CTL0022" } } },
225 /* Sound Blaster AWE 64 PnP */
226 { .id
= "CTL00e9", .devs
= { { "CTL0045" }, { "CTL0022" } } },
227 /* Sound Blaster 16 PnP (AWE) */
228 { .id
= "CTL00ed", .devs
= { { "CTL0041" }, { "CTL0070" } } },
229 /* Generic entries */
230 { .id
= "CTLXXXX" , .devs
= { { "CTL0031" }, { "CTL0021" } } },
231 { .id
= "CTLXXXX" , .devs
= { { "CTL0041" }, { "CTL0021" } } },
232 { .id
= "CTLXXXX" , .devs
= { { "CTL0042" }, { "CTL0022" } } },
233 { .id
= "CTLXXXX" , .devs
= { { "CTL0044" }, { "CTL0023" } } },
234 { .id
= "CTLXXXX" , .devs
= { { "CTL0045" }, { "CTL0022" } } },
235 #endif /* SNDRV_SBAWE */
239 MODULE_DEVICE_TABLE(pnp_card
, snd_sb16_pnpids
);
241 #endif /* CONFIG_PNP */
243 #ifdef SNDRV_SBAWE_EMU8000
244 #define DRIVER_NAME "snd-card-sbawe"
246 #define DRIVER_NAME "snd-card-sb16"
251 static int __devinit
snd_card_sb16_pnp(int dev
, struct snd_card_sb16
*acard
,
252 struct pnp_card_link
*card
,
253 const struct pnp_card_device_id
*id
)
255 struct pnp_dev
*pdev
;
258 acard
->dev
= pnp_request_card_device(card
, id
->devs
[0].id
, NULL
);
259 if (acard
->dev
== NULL
)
262 #ifdef SNDRV_SBAWE_EMU8000
263 acard
->devwt
= pnp_request_card_device(card
, id
->devs
[1].id
, acard
->dev
);
265 /* Audio initialization */
268 err
= pnp_activate_dev(pdev
);
270 snd_printk(KERN_ERR PFX
"AUDIO pnp configure failure\n");
273 port
[dev
] = pnp_port_start(pdev
, 0);
274 mpu_port
[dev
] = pnp_port_start(pdev
, 1);
275 fm_port
[dev
] = pnp_port_start(pdev
, 2);
276 dma8
[dev
] = pnp_dma(pdev
, 0);
277 dma16
[dev
] = pnp_dma(pdev
, 1);
278 irq
[dev
] = pnp_irq(pdev
, 0);
279 snd_printdd("pnp SB16: port=0x%lx, mpu port=0x%lx, fm port=0x%lx\n",
280 port
[dev
], mpu_port
[dev
], fm_port
[dev
]);
281 snd_printdd("pnp SB16: dma1=%i, dma2=%i, irq=%i\n",
282 dma8
[dev
], dma16
[dev
], irq
[dev
]);
283 #ifdef SNDRV_SBAWE_EMU8000
284 /* WaveTable initialization */
287 err
= pnp_activate_dev(pdev
);
291 awe_port
[dev
] = pnp_port_start(pdev
, 0);
292 snd_printdd("pnp SB16: wavetable port=0x%llx\n",
293 (unsigned long long)pnp_port_start(pdev
, 0));
297 pnp_release_card_device(pdev
);
298 snd_printk(KERN_ERR PFX
"WaveTable pnp configure failure\n");
307 #endif /* CONFIG_PNP */
309 static void snd_sb16_free(struct snd_card
*card
)
311 struct snd_card_sb16
*acard
= card
->private_data
;
315 release_and_free_resource(acard
->fm_res
);
319 #define is_isapnp_selected(dev) isapnp[dev]
321 #define is_isapnp_selected(dev) 0
324 static int snd_sb16_card_new(int dev
, struct snd_card
**cardp
)
326 struct snd_card
*card
;
329 err
= snd_card_create(index
[dev
], id
[dev
], THIS_MODULE
,
330 sizeof(struct snd_card_sb16
), &card
);
333 card
->private_free
= snd_sb16_free
;
338 static int __devinit
snd_sb16_probe(struct snd_card
*card
, int dev
)
340 int xirq
, xdma8
, xdma16
;
342 struct snd_card_sb16
*acard
= card
->private_data
;
343 struct snd_opl3
*opl3
;
344 struct snd_hwdep
*synth
= NULL
;
345 #ifdef CONFIG_SND_SB16_CSP
346 struct snd_hwdep
*xcsp
= NULL
;
355 if ((err
= snd_sbdsp_create(card
,
358 snd_sb16dsp_interrupt
,
366 if (chip
->hardware
!= SB_HW_16
) {
367 snd_printk(KERN_ERR PFX
"SB 16 chip was not detected at 0x%lx\n", port
[dev
]);
370 chip
->mpu_port
= mpu_port
[dev
];
371 if (! is_isapnp_selected(dev
) && (err
= snd_sb16dsp_configure(chip
)) < 0)
374 if ((err
= snd_sb16dsp_pcm(chip
, 0, &chip
->pcm
)) < 0)
378 #ifdef SNDRV_SBAWE_EMU8000
379 awe_port
[dev
] > 0 ? "SB AWE" :
382 strcpy(card
->shortname
, chip
->name
);
383 sprintf(card
->longname
, "%s at 0x%lx, irq %i, dma ",
388 sprintf(card
->longname
+ strlen(card
->longname
), "%d", xdma8
);
390 sprintf(card
->longname
+ strlen(card
->longname
), "%s%d",
391 xdma8
>= 0 ? "&" : "", xdma16
);
393 if (chip
->mpu_port
> 0 && chip
->mpu_port
!= SNDRV_AUTO_PORT
) {
394 if ((err
= snd_mpu401_uart_new(card
, 0, MPU401_HW_SB
,
396 xirq
, 0, &chip
->rmidi
)) < 0)
398 chip
->rmidi_callback
= snd_mpu401_uart_interrupt
;
401 #ifdef SNDRV_SBAWE_EMU8000
402 if (awe_port
[dev
] == SNDRV_AUTO_PORT
)
403 awe_port
[dev
] = 0; /* disable */
406 if (fm_port
[dev
] > 0 && fm_port
[dev
] != SNDRV_AUTO_PORT
) {
407 if (snd_opl3_create(card
, fm_port
[dev
], fm_port
[dev
] + 2,
409 acard
->fm_res
!= NULL
|| fm_port
[dev
] == port
[dev
],
411 snd_printk(KERN_ERR PFX
"no OPL device at 0x%lx-0x%lx\n",
412 fm_port
[dev
], fm_port
[dev
] + 2);
414 #ifdef SNDRV_SBAWE_EMU8000
415 int seqdev
= awe_port
[dev
] > 0 ? 2 : 1;
419 if ((err
= snd_opl3_hwdep_new(opl3
, 0, seqdev
, &synth
)) < 0)
424 if ((err
= snd_sbmixer_new(chip
)) < 0)
427 #ifdef CONFIG_SND_SB16_CSP
428 /* CSP chip on SB16ASP/AWE32 */
429 if ((chip
->hardware
== SB_HW_16
) && csp
[dev
]) {
430 snd_sb_csp_new(chip
, synth
!= NULL
? 1 : 0, &xcsp
);
432 chip
->csp
= xcsp
->private_data
;
433 chip
->hardware
= SB_HW_16CSP
;
435 snd_printk(KERN_INFO PFX
"warning - CSP chip not detected on soundcard #%i\n", dev
+ 1);
439 #ifdef SNDRV_SBAWE_EMU8000
440 if (awe_port
[dev
] > 0) {
441 if ((err
= snd_emu8000_new(card
, 1, awe_port
[dev
],
442 seq_ports
[dev
], NULL
)) < 0) {
443 snd_printk(KERN_ERR PFX
"fatal error - EMU-8000 synthesizer not detected at 0x%lx\n", awe_port
[dev
]);
451 spin_lock_irqsave(&chip
->mixer_lock
, flags
);
452 snd_sbmixer_write(chip
, SB_DSP4_MIC_AGC
,
453 (snd_sbmixer_read(chip
, SB_DSP4_MIC_AGC
) & 0x01) |
454 (mic_agc
[dev
] ? 0x00 : 0x01));
455 spin_unlock_irqrestore(&chip
->mixer_lock
, flags
);
457 if ((err
= snd_card_register(card
)) < 0)
464 static int snd_sb16_suspend(struct snd_card
*card
, pm_message_t state
)
466 struct snd_card_sb16
*acard
= card
->private_data
;
467 struct snd_sb
*chip
= acard
->chip
;
469 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
470 snd_pcm_suspend_all(chip
->pcm
);
471 snd_sbmixer_suspend(chip
);
475 static int snd_sb16_resume(struct snd_card
*card
)
477 struct snd_card_sb16
*acard
= card
->private_data
;
478 struct snd_sb
*chip
= acard
->chip
;
480 snd_sbdsp_reset(chip
);
481 snd_sbmixer_resume(chip
);
482 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
487 static int __devinit
snd_sb16_isa_probe1(int dev
, struct device
*pdev
)
489 struct snd_card_sb16
*acard
;
490 struct snd_card
*card
;
493 err
= snd_sb16_card_new(dev
, &card
);
497 acard
= card
->private_data
;
498 /* non-PnP FM port address is hardwired with base port address */
499 fm_port
[dev
] = port
[dev
];
500 /* block the 0x388 port to avoid PnP conflicts */
501 acard
->fm_res
= request_region(0x388, 4, "SoundBlaster FM");
502 #ifdef SNDRV_SBAWE_EMU8000
503 /* non-PnP AWE port address is hardwired with base port address */
504 awe_port
[dev
] = port
[dev
] + 0x400;
507 snd_card_set_dev(card
, pdev
);
508 if ((err
= snd_sb16_probe(card
, dev
)) < 0) {
512 dev_set_drvdata(pdev
, card
);
517 static int __devinit
snd_sb16_isa_match(struct device
*pdev
, unsigned int dev
)
519 return enable
[dev
] && !is_isapnp_selected(dev
);
522 static int __devinit
snd_sb16_isa_probe(struct device
*pdev
, unsigned int dev
)
525 static int possible_irqs
[] = {5, 9, 10, 7, -1};
526 static int possible_dmas8
[] = {1, 3, 0, -1};
527 static int possible_dmas16
[] = {5, 6, 7, -1};
529 if (irq
[dev
] == SNDRV_AUTO_IRQ
) {
530 if ((irq
[dev
] = snd_legacy_find_free_irq(possible_irqs
)) < 0) {
531 snd_printk(KERN_ERR PFX
"unable to find a free IRQ\n");
535 if (dma8
[dev
] == SNDRV_AUTO_DMA
) {
536 if ((dma8
[dev
] = snd_legacy_find_free_dma(possible_dmas8
)) < 0) {
537 snd_printk(KERN_ERR PFX
"unable to find a free 8-bit DMA\n");
541 if (dma16
[dev
] == SNDRV_AUTO_DMA
) {
542 if ((dma16
[dev
] = snd_legacy_find_free_dma(possible_dmas16
)) < 0) {
543 snd_printk(KERN_ERR PFX
"unable to find a free 16-bit DMA\n");
548 if (port
[dev
] != SNDRV_AUTO_PORT
)
549 return snd_sb16_isa_probe1(dev
, pdev
);
551 static int possible_ports
[] = {0x220, 0x240, 0x260, 0x280};
553 for (i
= 0; i
< ARRAY_SIZE(possible_ports
); i
++) {
554 port
[dev
] = possible_ports
[i
];
555 err
= snd_sb16_isa_probe1(dev
, pdev
);
563 static int __devexit
snd_sb16_isa_remove(struct device
*pdev
, unsigned int dev
)
565 snd_card_free(dev_get_drvdata(pdev
));
566 dev_set_drvdata(pdev
, NULL
);
571 static int snd_sb16_isa_suspend(struct device
*dev
, unsigned int n
,
574 return snd_sb16_suspend(dev_get_drvdata(dev
), state
);
577 static int snd_sb16_isa_resume(struct device
*dev
, unsigned int n
)
579 return snd_sb16_resume(dev_get_drvdata(dev
));
584 #define DEV_NAME "sbawe"
586 #define DEV_NAME "sb16"
589 static struct isa_driver snd_sb16_isa_driver
= {
590 .match
= snd_sb16_isa_match
,
591 .probe
= snd_sb16_isa_probe
,
592 .remove
= __devexit_p(snd_sb16_isa_remove
),
594 .suspend
= snd_sb16_isa_suspend
,
595 .resume
= snd_sb16_isa_resume
,
604 static int __devinit
snd_sb16_pnp_detect(struct pnp_card_link
*pcard
,
605 const struct pnp_card_device_id
*pid
)
608 struct snd_card
*card
;
611 for ( ; dev
< SNDRV_CARDS
; dev
++) {
612 if (!enable
[dev
] || !isapnp
[dev
])
614 res
= snd_sb16_card_new(dev
, &card
);
617 snd_card_set_dev(card
, &pcard
->card
->dev
);
618 if ((res
= snd_card_sb16_pnp(dev
, card
->private_data
, pcard
, pid
)) < 0 ||
619 (res
= snd_sb16_probe(card
, dev
)) < 0) {
623 pnp_set_card_drvdata(pcard
, card
);
631 static void __devexit
snd_sb16_pnp_remove(struct pnp_card_link
* pcard
)
633 snd_card_free(pnp_get_card_drvdata(pcard
));
634 pnp_set_card_drvdata(pcard
, NULL
);
638 static int snd_sb16_pnp_suspend(struct pnp_card_link
*pcard
, pm_message_t state
)
640 return snd_sb16_suspend(pnp_get_card_drvdata(pcard
), state
);
642 static int snd_sb16_pnp_resume(struct pnp_card_link
*pcard
)
644 return snd_sb16_resume(pnp_get_card_drvdata(pcard
));
648 static struct pnp_card_driver sb16_pnpc_driver
= {
649 .flags
= PNP_DRIVER_RES_DISABLE
,
655 .id_table
= snd_sb16_pnpids
,
656 .probe
= snd_sb16_pnp_detect
,
657 .remove
= __devexit_p(snd_sb16_pnp_remove
),
659 .suspend
= snd_sb16_pnp_suspend
,
660 .resume
= snd_sb16_pnp_resume
,
664 #endif /* CONFIG_PNP */
666 static int __init
alsa_card_sb16_init(void)
670 err
= isa_register_driver(&snd_sb16_isa_driver
, SNDRV_CARDS
);
675 err
= pnp_register_card_driver(&sb16_pnpc_driver
);
685 static void __exit
alsa_card_sb16_exit(void)
689 pnp_unregister_card_driver(&sb16_pnpc_driver
);
692 isa_unregister_driver(&snd_sb16_isa_driver
);
695 module_init(alsa_card_sb16_init
)
696 module_exit(alsa_card_sb16_exit
)