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