1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | card-opti92x-ad1848.c - driver for OPTi 82c92x based soundcards. |
4 | Copyright (C) 1998-2000 by Massimo Piccioni <dafastidio@libero.it> |
5 | |
6 | Part of this code was developed at the Italian Ministry of Air Defence, |
7 | Sixth Division (oh, che pace ...), Rome. |
8 | |
9 | Thanks to Maria Grazia Pollarini, Salvatore Vassallo. |
10 | |
11 | */ |
12 | |
13 | |
14 | #include <linux/init.h> |
15 | #include <linux/err.h> |
16 | #include <linux/isa.h> |
17 | #include <linux/delay.h> |
18 | #include <linux/pnp.h> |
19 | #include <linux/module.h> |
20 | #include <linux/io.h> |
21 | #include <asm/dma.h> |
22 | #include <sound/core.h> |
23 | #include <sound/tlv.h> |
24 | #include <sound/wss.h> |
25 | #include <sound/mpu401.h> |
26 | #include <sound/opl3.h> |
27 | #ifndef OPTi93X |
28 | #include <sound/opl4.h> |
29 | #endif |
30 | #define SNDRV_LEGACY_FIND_FREE_IOPORT |
31 | #define SNDRV_LEGACY_FIND_FREE_IRQ |
32 | #define SNDRV_LEGACY_FIND_FREE_DMA |
33 | #include <sound/initval.h> |
34 | |
35 | MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>" ); |
36 | MODULE_LICENSE("GPL" ); |
37 | #ifdef OPTi93X |
38 | MODULE_DESCRIPTION("OPTi93X" ); |
39 | #else /* OPTi93X */ |
40 | #ifdef CS4231 |
41 | MODULE_DESCRIPTION("OPTi92X - CS4231" ); |
42 | #else /* CS4231 */ |
43 | MODULE_DESCRIPTION("OPTi92X - AD1848" ); |
44 | #endif /* CS4231 */ |
45 | #endif /* OPTi93X */ |
46 | |
47 | static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */ |
48 | static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */ |
49 | //static bool enable = SNDRV_DEFAULT_ENABLE1; /* Enable this card */ |
50 | #ifdef CONFIG_PNP |
51 | static bool isapnp = true; /* Enable ISA PnP detection */ |
52 | #endif |
53 | static long port = SNDRV_DEFAULT_PORT1; /* 0x530,0xe80,0xf40,0x604 */ |
54 | static long mpu_port = SNDRV_DEFAULT_PORT1; /* 0x300,0x310,0x320,0x330 */ |
55 | static long fm_port = SNDRV_DEFAULT_PORT1; /* 0x388 */ |
56 | static int irq = SNDRV_DEFAULT_IRQ1; /* 5,7,9,10,11 */ |
57 | static int mpu_irq = SNDRV_DEFAULT_IRQ1; /* 5,7,9,10 */ |
58 | static int dma1 = SNDRV_DEFAULT_DMA1; /* 0,1,3 */ |
59 | #if defined(CS4231) || defined(OPTi93X) |
60 | static int dma2 = SNDRV_DEFAULT_DMA1; /* 0,1,3 */ |
61 | #endif /* CS4231 || OPTi93X */ |
62 | |
63 | module_param(index, int, 0444); |
64 | MODULE_PARM_DESC(index, "Index value for opti9xx based soundcard." ); |
65 | module_param(id, charp, 0444); |
66 | MODULE_PARM_DESC(id, "ID string for opti9xx based soundcard." ); |
67 | //module_param(enable, bool, 0444); |
68 | //MODULE_PARM_DESC(enable, "Enable opti9xx soundcard."); |
69 | #ifdef CONFIG_PNP |
70 | module_param(isapnp, bool, 0444); |
71 | MODULE_PARM_DESC(isapnp, "Enable ISA PnP detection for specified soundcard." ); |
72 | #endif |
73 | module_param_hw(port, long, ioport, 0444); |
74 | MODULE_PARM_DESC(port, "WSS port # for opti9xx driver." ); |
75 | module_param_hw(mpu_port, long, ioport, 0444); |
76 | MODULE_PARM_DESC(mpu_port, "MPU-401 port # for opti9xx driver." ); |
77 | module_param_hw(fm_port, long, ioport, 0444); |
78 | MODULE_PARM_DESC(fm_port, "FM port # for opti9xx driver." ); |
79 | module_param_hw(irq, int, irq, 0444); |
80 | MODULE_PARM_DESC(irq, "WSS irq # for opti9xx driver." ); |
81 | module_param_hw(mpu_irq, int, irq, 0444); |
82 | MODULE_PARM_DESC(mpu_irq, "MPU-401 irq # for opti9xx driver." ); |
83 | module_param_hw(dma1, int, dma, 0444); |
84 | MODULE_PARM_DESC(dma1, "1st dma # for opti9xx driver." ); |
85 | #if defined(CS4231) || defined(OPTi93X) |
86 | module_param_hw(dma2, int, dma, 0444); |
87 | MODULE_PARM_DESC(dma2, "2nd dma # for opti9xx driver." ); |
88 | #endif /* CS4231 || OPTi93X */ |
89 | |
90 | #define OPTi9XX_HW_82C928 1 |
91 | #define OPTi9XX_HW_82C929 2 |
92 | #define OPTi9XX_HW_82C924 3 |
93 | #define OPTi9XX_HW_82C925 4 |
94 | #define OPTi9XX_HW_82C930 5 |
95 | #define OPTi9XX_HW_82C931 6 |
96 | #define OPTi9XX_HW_82C933 7 |
97 | #define OPTi9XX_HW_LAST OPTi9XX_HW_82C933 |
98 | |
99 | #define OPTi9XX_MC_REG(n) n |
100 | |
101 | #ifdef OPTi93X |
102 | |
103 | #define OPTi93X_STATUS 0x02 |
104 | #define OPTi93X_PORT(chip, r) ((chip)->port + OPTi93X_##r) |
105 | |
106 | #define OPTi93X_IRQ_PLAYBACK 0x04 |
107 | #define OPTi93X_IRQ_CAPTURE 0x08 |
108 | |
109 | #endif /* OPTi93X */ |
110 | |
111 | struct snd_opti9xx { |
112 | unsigned short hardware; |
113 | unsigned char password; |
114 | char name[7]; |
115 | |
116 | unsigned long mc_base; |
117 | struct resource *res_mc_base; |
118 | unsigned long mc_base_size; |
119 | #ifdef OPTi93X |
120 | unsigned long mc_indir_index; |
121 | struct resource *res_mc_indir; |
122 | #endif /* OPTi93X */ |
123 | struct snd_wss *codec; |
124 | unsigned long pwd_reg; |
125 | |
126 | spinlock_t lock; |
127 | |
128 | long wss_base; |
129 | int irq; |
130 | }; |
131 | |
132 | static int snd_opti9xx_pnp_is_probed; |
133 | |
134 | #ifdef CONFIG_PNP |
135 | |
136 | static const struct pnp_card_device_id snd_opti9xx_pnpids[] = { |
137 | #ifndef OPTi93X |
138 | /* OPTi 82C924 */ |
139 | { .id = "OPT0924" , |
140 | .devs = { { "OPT0000" }, { "OPT0002" }, { "OPT0005" } }, |
141 | .driver_data = 0x0924 }, |
142 | /* OPTi 82C925 */ |
143 | { .id = "OPT0925" , |
144 | .devs = { { "OPT9250" }, { "OPT0002" }, { "OPT0005" } }, |
145 | .driver_data = 0x0925 }, |
146 | #else |
147 | /* OPTi 82C931/3 */ |
148 | { .id = "OPT0931" , .devs = { { "OPT9310" }, { "OPT0002" } }, |
149 | .driver_data = 0x0931 }, |
150 | #endif /* OPTi93X */ |
151 | { .id = "" } |
152 | }; |
153 | |
154 | MODULE_DEVICE_TABLE(pnp_card, snd_opti9xx_pnpids); |
155 | |
156 | #endif /* CONFIG_PNP */ |
157 | |
158 | #define DEV_NAME KBUILD_MODNAME |
159 | |
160 | static const char * const snd_opti9xx_names[] = { |
161 | "unknown" , |
162 | "82C928" , "82C929" , |
163 | "82C924" , "82C925" , |
164 | "82C930" , "82C931" , "82C933" |
165 | }; |
166 | |
167 | static int snd_opti9xx_init(struct snd_opti9xx *chip, |
168 | unsigned short hardware) |
169 | { |
170 | static const int opti9xx_mc_size[] = {7, 7, 10, 10, 2, 2, 2}; |
171 | |
172 | chip->hardware = hardware; |
173 | strcpy(p: chip->name, q: snd_opti9xx_names[hardware]); |
174 | |
175 | spin_lock_init(&chip->lock); |
176 | |
177 | chip->irq = -1; |
178 | |
179 | #ifndef OPTi93X |
180 | #ifdef CONFIG_PNP |
181 | if (isapnp && chip->mc_base) |
182 | /* PnP resource gives the least 10 bits */ |
183 | chip->mc_base |= 0xc00; |
184 | else |
185 | #endif /* CONFIG_PNP */ |
186 | { |
187 | chip->mc_base = 0xf8c; |
188 | chip->mc_base_size = opti9xx_mc_size[hardware]; |
189 | } |
190 | #else |
191 | chip->mc_base_size = opti9xx_mc_size[hardware]; |
192 | #endif |
193 | |
194 | switch (hardware) { |
195 | #ifndef OPTi93X |
196 | case OPTi9XX_HW_82C928: |
197 | case OPTi9XX_HW_82C929: |
198 | chip->password = (hardware == OPTi9XX_HW_82C928) ? 0xe2 : 0xe3; |
199 | chip->pwd_reg = 3; |
200 | break; |
201 | |
202 | case OPTi9XX_HW_82C924: |
203 | case OPTi9XX_HW_82C925: |
204 | chip->password = 0xe5; |
205 | chip->pwd_reg = 3; |
206 | break; |
207 | #else /* OPTi93X */ |
208 | |
209 | case OPTi9XX_HW_82C930: |
210 | case OPTi9XX_HW_82C931: |
211 | case OPTi9XX_HW_82C933: |
212 | chip->mc_base = (hardware == OPTi9XX_HW_82C930) ? 0xf8f : 0xf8d; |
213 | if (!chip->mc_indir_index) |
214 | chip->mc_indir_index = 0xe0e; |
215 | chip->password = 0xe4; |
216 | chip->pwd_reg = 0; |
217 | break; |
218 | #endif /* OPTi93X */ |
219 | |
220 | default: |
221 | snd_printk(KERN_ERR "chip %d not supported\n" , hardware); |
222 | return -ENODEV; |
223 | } |
224 | return 0; |
225 | } |
226 | |
227 | static unsigned char snd_opti9xx_read(struct snd_opti9xx *chip, |
228 | unsigned char reg) |
229 | { |
230 | unsigned long flags; |
231 | unsigned char retval = 0xff; |
232 | |
233 | spin_lock_irqsave(&chip->lock, flags); |
234 | outb(value: chip->password, port: chip->mc_base + chip->pwd_reg); |
235 | |
236 | switch (chip->hardware) { |
237 | #ifndef OPTi93X |
238 | case OPTi9XX_HW_82C924: |
239 | case OPTi9XX_HW_82C925: |
240 | if (reg > 7) { |
241 | outb(value: reg, port: chip->mc_base + 8); |
242 | outb(value: chip->password, port: chip->mc_base + chip->pwd_reg); |
243 | retval = inb(port: chip->mc_base + 9); |
244 | break; |
245 | } |
246 | fallthrough; |
247 | |
248 | case OPTi9XX_HW_82C928: |
249 | case OPTi9XX_HW_82C929: |
250 | retval = inb(port: chip->mc_base + reg); |
251 | break; |
252 | #else /* OPTi93X */ |
253 | |
254 | case OPTi9XX_HW_82C930: |
255 | case OPTi9XX_HW_82C931: |
256 | case OPTi9XX_HW_82C933: |
257 | outb(reg, chip->mc_indir_index); |
258 | outb(chip->password, chip->mc_base + chip->pwd_reg); |
259 | retval = inb(chip->mc_indir_index + 1); |
260 | break; |
261 | #endif /* OPTi93X */ |
262 | |
263 | default: |
264 | snd_printk(KERN_ERR "chip %d not supported\n" , chip->hardware); |
265 | } |
266 | |
267 | spin_unlock_irqrestore(lock: &chip->lock, flags); |
268 | return retval; |
269 | } |
270 | |
271 | static void snd_opti9xx_write(struct snd_opti9xx *chip, unsigned char reg, |
272 | unsigned char value) |
273 | { |
274 | unsigned long flags; |
275 | |
276 | spin_lock_irqsave(&chip->lock, flags); |
277 | outb(value: chip->password, port: chip->mc_base + chip->pwd_reg); |
278 | |
279 | switch (chip->hardware) { |
280 | #ifndef OPTi93X |
281 | case OPTi9XX_HW_82C924: |
282 | case OPTi9XX_HW_82C925: |
283 | if (reg > 7) { |
284 | outb(value: reg, port: chip->mc_base + 8); |
285 | outb(value: chip->password, port: chip->mc_base + chip->pwd_reg); |
286 | outb(value, port: chip->mc_base + 9); |
287 | break; |
288 | } |
289 | fallthrough; |
290 | |
291 | case OPTi9XX_HW_82C928: |
292 | case OPTi9XX_HW_82C929: |
293 | outb(value, port: chip->mc_base + reg); |
294 | break; |
295 | #else /* OPTi93X */ |
296 | |
297 | case OPTi9XX_HW_82C930: |
298 | case OPTi9XX_HW_82C931: |
299 | case OPTi9XX_HW_82C933: |
300 | outb(reg, chip->mc_indir_index); |
301 | outb(chip->password, chip->mc_base + chip->pwd_reg); |
302 | outb(value, chip->mc_indir_index + 1); |
303 | break; |
304 | #endif /* OPTi93X */ |
305 | |
306 | default: |
307 | snd_printk(KERN_ERR "chip %d not supported\n" , chip->hardware); |
308 | } |
309 | |
310 | spin_unlock_irqrestore(lock: &chip->lock, flags); |
311 | } |
312 | |
313 | |
314 | static inline void snd_opti9xx_write_mask(struct snd_opti9xx *chip, |
315 | unsigned char reg, unsigned char value, unsigned char mask) |
316 | { |
317 | unsigned char oldval = snd_opti9xx_read(chip, reg); |
318 | |
319 | snd_opti9xx_write(chip, reg, value: (oldval & ~mask) | (value & mask)); |
320 | } |
321 | |
322 | static int snd_opti9xx_configure(struct snd_opti9xx *chip, |
323 | long port, |
324 | int irq, int dma1, int dma2, |
325 | long mpu_port, int mpu_irq) |
326 | { |
327 | unsigned char wss_base_bits; |
328 | unsigned char irq_bits; |
329 | unsigned char dma_bits; |
330 | unsigned char mpu_port_bits = 0; |
331 | unsigned char mpu_irq_bits; |
332 | |
333 | switch (chip->hardware) { |
334 | #ifndef OPTi93X |
335 | case OPTi9XX_HW_82C924: |
336 | /* opti 929 mode (?), OPL3 clock output, audio enable */ |
337 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(4), value: 0xf0, mask: 0xfc); |
338 | /* enable wave audio */ |
339 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(6), value: 0x02, mask: 0x02); |
340 | fallthrough; |
341 | |
342 | case OPTi9XX_HW_82C925: |
343 | /* enable WSS mode */ |
344 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(1), value: 0x80, mask: 0x80); |
345 | /* OPL3 FM synthesis */ |
346 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2), value: 0x00, mask: 0x20); |
347 | /* disable Sound Blaster IRQ and DMA */ |
348 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(3), value: 0xf0, mask: 0xff); |
349 | #ifdef CS4231 |
350 | /* cs4231/4248 fix enabled */ |
351 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(5), 0x02, 0x02); |
352 | #else |
353 | /* cs4231/4248 fix disabled */ |
354 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(5), value: 0x00, mask: 0x02); |
355 | #endif /* CS4231 */ |
356 | break; |
357 | |
358 | case OPTi9XX_HW_82C928: |
359 | case OPTi9XX_HW_82C929: |
360 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(1), value: 0x80, mask: 0x80); |
361 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2), value: 0x00, mask: 0x20); |
362 | /* |
363 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(3), 0xa2, 0xae); |
364 | */ |
365 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(4), value: 0x00, mask: 0x0c); |
366 | #ifdef CS4231 |
367 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(5), 0x02, 0x02); |
368 | #else |
369 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(5), value: 0x00, mask: 0x02); |
370 | #endif /* CS4231 */ |
371 | break; |
372 | |
373 | #else /* OPTi93X */ |
374 | case OPTi9XX_HW_82C931: |
375 | /* disable 3D sound (set GPIO1 as output, low) */ |
376 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(20), 0x04, 0x0c); |
377 | fallthrough; |
378 | |
379 | case OPTi9XX_HW_82C933: |
380 | /* |
381 | * The BTC 1817DW has QS1000 wavetable which is connected |
382 | * to the serial digital input of the OPTI931. |
383 | */ |
384 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(21), 0x82, 0xff); |
385 | /* |
386 | * This bit sets OPTI931 to automaticaly select FM |
387 | * or digital input signal. |
388 | */ |
389 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(26), 0x01, 0x01); |
390 | fallthrough; |
391 | |
392 | case OPTi9XX_HW_82C930: |
393 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(6), 0x02, 0x03); |
394 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(3), 0x00, 0xff); |
395 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(4), 0x10 | |
396 | (chip->hardware == OPTi9XX_HW_82C930 ? 0x00 : 0x04), |
397 | 0x34); |
398 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(5), 0x20, 0xbf); |
399 | break; |
400 | #endif /* OPTi93X */ |
401 | |
402 | default: |
403 | snd_printk(KERN_ERR "chip %d not supported\n" , chip->hardware); |
404 | return -EINVAL; |
405 | } |
406 | |
407 | /* PnP resource says it decodes only 10 bits of address */ |
408 | switch (port & 0x3ff) { |
409 | case 0x130: |
410 | chip->wss_base = 0x530; |
411 | wss_base_bits = 0x00; |
412 | break; |
413 | case 0x204: |
414 | chip->wss_base = 0x604; |
415 | wss_base_bits = 0x03; |
416 | break; |
417 | case 0x280: |
418 | chip->wss_base = 0xe80; |
419 | wss_base_bits = 0x01; |
420 | break; |
421 | case 0x340: |
422 | chip->wss_base = 0xf40; |
423 | wss_base_bits = 0x02; |
424 | break; |
425 | default: |
426 | snd_printk(KERN_WARNING "WSS port 0x%lx not valid\n" , port); |
427 | goto __skip_base; |
428 | } |
429 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(1), value: wss_base_bits << 4, mask: 0x30); |
430 | |
431 | __skip_base: |
432 | switch (irq) { |
433 | //#ifdef OPTi93X |
434 | case 5: |
435 | irq_bits = 0x05; |
436 | break; |
437 | //#endif /* OPTi93X */ |
438 | case 7: |
439 | irq_bits = 0x01; |
440 | break; |
441 | case 9: |
442 | irq_bits = 0x02; |
443 | break; |
444 | case 10: |
445 | irq_bits = 0x03; |
446 | break; |
447 | case 11: |
448 | irq_bits = 0x04; |
449 | break; |
450 | default: |
451 | snd_printk(KERN_WARNING "WSS irq # %d not valid\n" , irq); |
452 | goto __skip_resources; |
453 | } |
454 | |
455 | switch (dma1) { |
456 | case 0: |
457 | dma_bits = 0x01; |
458 | break; |
459 | case 1: |
460 | dma_bits = 0x02; |
461 | break; |
462 | case 3: |
463 | dma_bits = 0x03; |
464 | break; |
465 | default: |
466 | snd_printk(KERN_WARNING "WSS dma1 # %d not valid\n" , dma1); |
467 | goto __skip_resources; |
468 | } |
469 | |
470 | #if defined(CS4231) || defined(OPTi93X) |
471 | if (dma1 == dma2) { |
472 | snd_printk(KERN_ERR "don't want to share dmas\n" ); |
473 | return -EBUSY; |
474 | } |
475 | |
476 | switch (dma2) { |
477 | case 0: |
478 | case 1: |
479 | break; |
480 | default: |
481 | snd_printk(KERN_WARNING "WSS dma2 # %d not valid\n" , dma2); |
482 | goto __skip_resources; |
483 | } |
484 | dma_bits |= 0x04; |
485 | #endif /* CS4231 || OPTi93X */ |
486 | |
487 | #ifndef OPTi93X |
488 | outb(value: irq_bits << 3 | dma_bits, port: chip->wss_base); |
489 | #else /* OPTi93X */ |
490 | snd_opti9xx_write(chip, OPTi9XX_MC_REG(3), (irq_bits << 3 | dma_bits)); |
491 | #endif /* OPTi93X */ |
492 | |
493 | __skip_resources: |
494 | if (chip->hardware > OPTi9XX_HW_82C928) { |
495 | switch (mpu_port) { |
496 | case 0: |
497 | case -1: |
498 | break; |
499 | case 0x300: |
500 | mpu_port_bits = 0x03; |
501 | break; |
502 | case 0x310: |
503 | mpu_port_bits = 0x02; |
504 | break; |
505 | case 0x320: |
506 | mpu_port_bits = 0x01; |
507 | break; |
508 | case 0x330: |
509 | mpu_port_bits = 0x00; |
510 | break; |
511 | default: |
512 | snd_printk(KERN_WARNING |
513 | "MPU-401 port 0x%lx not valid\n" , mpu_port); |
514 | goto __skip_mpu; |
515 | } |
516 | |
517 | switch (mpu_irq) { |
518 | case 5: |
519 | mpu_irq_bits = 0x02; |
520 | break; |
521 | case 7: |
522 | mpu_irq_bits = 0x03; |
523 | break; |
524 | case 9: |
525 | mpu_irq_bits = 0x00; |
526 | break; |
527 | case 10: |
528 | mpu_irq_bits = 0x01; |
529 | break; |
530 | default: |
531 | snd_printk(KERN_WARNING "MPU-401 irq # %d not valid\n" , |
532 | mpu_irq); |
533 | goto __skip_mpu; |
534 | } |
535 | |
536 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(6), |
537 | value: (mpu_port <= 0) ? 0x00 : |
538 | 0x80 | mpu_port_bits << 5 | mpu_irq_bits << 3, |
539 | mask: 0xf8); |
540 | } |
541 | __skip_mpu: |
542 | |
543 | return 0; |
544 | } |
545 | |
546 | #ifdef OPTi93X |
547 | |
548 | static const DECLARE_TLV_DB_SCALE(db_scale_5bit_3db_step, -9300, 300, 0); |
549 | static const DECLARE_TLV_DB_SCALE(db_scale_5bit, -4650, 150, 0); |
550 | static const DECLARE_TLV_DB_SCALE(db_scale_4bit_12db_max, -3300, 300, 0); |
551 | |
552 | static const struct snd_kcontrol_new snd_opti93x_controls[] = { |
553 | WSS_DOUBLE("Master Playback Switch" , 0, |
554 | OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 7, 7, 1, 1), |
555 | WSS_DOUBLE_TLV("Master Playback Volume" , 0, |
556 | OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 1, 1, 31, 1, |
557 | db_scale_5bit_3db_step), |
558 | WSS_DOUBLE_TLV("PCM Playback Volume" , 0, |
559 | CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 31, 1, |
560 | db_scale_5bit), |
561 | WSS_DOUBLE_TLV("FM Playback Volume" , 0, |
562 | CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 1, 1, 15, 1, |
563 | db_scale_4bit_12db_max), |
564 | WSS_DOUBLE("Line Playback Switch" , 0, |
565 | CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1), |
566 | WSS_DOUBLE_TLV("Line Playback Volume" , 0, |
567 | CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 15, 1, |
568 | db_scale_4bit_12db_max), |
569 | WSS_DOUBLE("Mic Playback Switch" , 0, |
570 | OPTi93X_MIC_LEFT_INPUT, OPTi93X_MIC_RIGHT_INPUT, 7, 7, 1, 1), |
571 | WSS_DOUBLE_TLV("Mic Playback Volume" , 0, |
572 | OPTi93X_MIC_LEFT_INPUT, OPTi93X_MIC_RIGHT_INPUT, 1, 1, 15, 1, |
573 | db_scale_4bit_12db_max), |
574 | WSS_DOUBLE_TLV("CD Playback Volume" , 0, |
575 | CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 1, 1, 15, 1, |
576 | db_scale_4bit_12db_max), |
577 | WSS_DOUBLE("Aux Playback Switch" , 0, |
578 | OPTi931_AUX_LEFT_INPUT, OPTi931_AUX_RIGHT_INPUT, 7, 7, 1, 1), |
579 | WSS_DOUBLE_TLV("Aux Playback Volume" , 0, |
580 | OPTi931_AUX_LEFT_INPUT, OPTi931_AUX_RIGHT_INPUT, 1, 1, 15, 1, |
581 | db_scale_4bit_12db_max), |
582 | }; |
583 | |
584 | static int snd_opti93x_mixer(struct snd_wss *chip) |
585 | { |
586 | struct snd_card *card; |
587 | unsigned int idx; |
588 | struct snd_ctl_elem_id id1, id2; |
589 | int err; |
590 | |
591 | if (snd_BUG_ON(!chip || !chip->pcm)) |
592 | return -EINVAL; |
593 | |
594 | card = chip->card; |
595 | |
596 | strcpy(card->mixername, chip->pcm->name); |
597 | |
598 | memset(&id1, 0, sizeof(id1)); |
599 | memset(&id2, 0, sizeof(id2)); |
600 | id1.iface = id2.iface = SNDRV_CTL_ELEM_IFACE_MIXER; |
601 | /* reassign AUX0 switch to CD */ |
602 | strcpy(id1.name, "Aux Playback Switch" ); |
603 | strcpy(id2.name, "CD Playback Switch" ); |
604 | err = snd_ctl_rename_id(card, &id1, &id2); |
605 | if (err < 0) { |
606 | snd_printk(KERN_ERR "Cannot rename opti93x control\n" ); |
607 | return err; |
608 | } |
609 | /* reassign AUX1 switch to FM */ |
610 | strcpy(id1.name, "Aux Playback Switch" ); id1.index = 1; |
611 | strcpy(id2.name, "FM Playback Switch" ); |
612 | err = snd_ctl_rename_id(card, &id1, &id2); |
613 | if (err < 0) { |
614 | snd_printk(KERN_ERR "Cannot rename opti93x control\n" ); |
615 | return err; |
616 | } |
617 | /* remove AUX1 volume */ |
618 | strcpy(id1.name, "Aux Playback Volume" ); id1.index = 1; |
619 | snd_ctl_remove_id(card, &id1); |
620 | |
621 | /* Replace WSS volume controls with OPTi93x volume controls */ |
622 | id1.index = 0; |
623 | for (idx = 0; idx < ARRAY_SIZE(snd_opti93x_controls); idx++) { |
624 | strcpy(id1.name, snd_opti93x_controls[idx].name); |
625 | snd_ctl_remove_id(card, &id1); |
626 | |
627 | err = snd_ctl_add(card, |
628 | snd_ctl_new1(&snd_opti93x_controls[idx], chip)); |
629 | if (err < 0) |
630 | return err; |
631 | } |
632 | return 0; |
633 | } |
634 | |
635 | static irqreturn_t snd_opti93x_interrupt(int irq, void *dev_id) |
636 | { |
637 | struct snd_opti9xx *chip = dev_id; |
638 | struct snd_wss *codec = chip->codec; |
639 | unsigned char status; |
640 | |
641 | if (!codec) |
642 | return IRQ_HANDLED; |
643 | |
644 | status = snd_opti9xx_read(chip, OPTi9XX_MC_REG(11)); |
645 | if ((status & OPTi93X_IRQ_PLAYBACK) && codec->playback_substream) |
646 | snd_pcm_period_elapsed(codec->playback_substream); |
647 | if ((status & OPTi93X_IRQ_CAPTURE) && codec->capture_substream) { |
648 | snd_wss_overrange(codec); |
649 | snd_pcm_period_elapsed(codec->capture_substream); |
650 | } |
651 | outb(0x00, OPTi93X_PORT(codec, STATUS)); |
652 | return IRQ_HANDLED; |
653 | } |
654 | |
655 | #endif /* OPTi93X */ |
656 | |
657 | static int snd_opti9xx_read_check(struct snd_card *card, |
658 | struct snd_opti9xx *chip) |
659 | { |
660 | unsigned char value; |
661 | #ifdef OPTi93X |
662 | unsigned long flags; |
663 | #endif |
664 | |
665 | chip->res_mc_base = |
666 | devm_request_region(card->dev, chip->mc_base, |
667 | chip->mc_base_size, "OPTi9xx MC" ); |
668 | if (!chip->res_mc_base) |
669 | return -EBUSY; |
670 | #ifndef OPTi93X |
671 | value = snd_opti9xx_read(chip, OPTi9XX_MC_REG(1)); |
672 | if (value != 0xff && value != inb(port: chip->mc_base + OPTi9XX_MC_REG(1))) |
673 | if (value == snd_opti9xx_read(chip, OPTi9XX_MC_REG(1))) |
674 | return 0; |
675 | #else /* OPTi93X */ |
676 | chip->res_mc_indir = |
677 | devm_request_region(card->dev, chip->mc_indir_index, 2, |
678 | "OPTi93x MC" ); |
679 | if (!chip->res_mc_indir) |
680 | return -EBUSY; |
681 | |
682 | spin_lock_irqsave(&chip->lock, flags); |
683 | outb(chip->password, chip->mc_base + chip->pwd_reg); |
684 | outb(((chip->mc_indir_index & 0x1f0) >> 4), chip->mc_base); |
685 | spin_unlock_irqrestore(&chip->lock, flags); |
686 | |
687 | value = snd_opti9xx_read(chip, OPTi9XX_MC_REG(7)); |
688 | snd_opti9xx_write(chip, OPTi9XX_MC_REG(7), 0xff - value); |
689 | if (snd_opti9xx_read(chip, OPTi9XX_MC_REG(7)) == 0xff - value) |
690 | return 0; |
691 | |
692 | devm_release_resource(card->dev, chip->res_mc_indir); |
693 | chip->res_mc_indir = NULL; |
694 | #endif /* OPTi93X */ |
695 | devm_release_resource(dev: card->dev, new: chip->res_mc_base); |
696 | chip->res_mc_base = NULL; |
697 | |
698 | return -ENODEV; |
699 | } |
700 | |
701 | static int snd_card_opti9xx_detect(struct snd_card *card, |
702 | struct snd_opti9xx *chip) |
703 | { |
704 | int i, err; |
705 | |
706 | #ifndef OPTi93X |
707 | for (i = OPTi9XX_HW_82C928; i < OPTi9XX_HW_82C930; i++) { |
708 | #else |
709 | for (i = OPTi9XX_HW_82C931; i >= OPTi9XX_HW_82C930; i--) { |
710 | #endif |
711 | err = snd_opti9xx_init(chip, hardware: i); |
712 | if (err < 0) |
713 | return err; |
714 | |
715 | err = snd_opti9xx_read_check(card, chip); |
716 | if (err == 0) |
717 | return 1; |
718 | #ifdef OPTi93X |
719 | chip->mc_indir_index = 0; |
720 | #endif |
721 | } |
722 | return -ENODEV; |
723 | } |
724 | |
725 | #ifdef CONFIG_PNP |
726 | static int snd_card_opti9xx_pnp(struct snd_opti9xx *chip, |
727 | struct pnp_card_link *card, |
728 | const struct pnp_card_device_id *pid) |
729 | { |
730 | struct pnp_dev *pdev; |
731 | int err; |
732 | struct pnp_dev *devmpu; |
733 | #ifndef OPTi93X |
734 | struct pnp_dev *devmc; |
735 | #endif |
736 | |
737 | pdev = pnp_request_card_device(clink: card, id: pid->devs[0].id, NULL); |
738 | if (pdev == NULL) |
739 | return -EBUSY; |
740 | |
741 | err = pnp_activate_dev(dev: pdev); |
742 | if (err < 0) { |
743 | snd_printk(KERN_ERR "AUDIO pnp configure failure: %d\n" , err); |
744 | return err; |
745 | } |
746 | |
747 | #ifdef OPTi93X |
748 | port = pnp_port_start(pdev, 0) - 4; |
749 | fm_port = pnp_port_start(pdev, 1) + 8; |
750 | /* adjust mc_indir_index - some cards report it at 0xe?d, |
751 | other at 0xe?c but it really is always at 0xe?e */ |
752 | chip->mc_indir_index = (pnp_port_start(pdev, 3) & ~0xf) | 0xe; |
753 | #else |
754 | devmc = pnp_request_card_device(clink: card, id: pid->devs[2].id, NULL); |
755 | if (devmc == NULL) |
756 | return -EBUSY; |
757 | |
758 | err = pnp_activate_dev(dev: devmc); |
759 | if (err < 0) { |
760 | snd_printk(KERN_ERR "MC pnp configure failure: %d\n" , err); |
761 | return err; |
762 | } |
763 | |
764 | port = pnp_port_start(dev: pdev, bar: 1); |
765 | fm_port = pnp_port_start(dev: pdev, bar: 2) + 8; |
766 | /* |
767 | * The MC(0) is never accessed and card does not |
768 | * include it in the PnP resource range. OPTI93x include it. |
769 | */ |
770 | chip->mc_base = pnp_port_start(dev: devmc, bar: 0) - 1; |
771 | chip->mc_base_size = pnp_port_len(dev: devmc, bar: 0) + 1; |
772 | #endif /* OPTi93X */ |
773 | irq = pnp_irq(dev: pdev, bar: 0); |
774 | dma1 = pnp_dma(dev: pdev, bar: 0); |
775 | #if defined(CS4231) || defined(OPTi93X) |
776 | dma2 = pnp_dma(pdev, 1); |
777 | #endif /* CS4231 || OPTi93X */ |
778 | |
779 | devmpu = pnp_request_card_device(clink: card, id: pid->devs[1].id, NULL); |
780 | |
781 | if (devmpu && mpu_port > 0) { |
782 | err = pnp_activate_dev(dev: devmpu); |
783 | if (err < 0) { |
784 | snd_printk(KERN_ERR "MPU401 pnp configure failure\n" ); |
785 | mpu_port = -1; |
786 | } else { |
787 | mpu_port = pnp_port_start(dev: devmpu, bar: 0); |
788 | mpu_irq = pnp_irq(dev: devmpu, bar: 0); |
789 | } |
790 | } |
791 | return pid->driver_data; |
792 | } |
793 | #endif /* CONFIG_PNP */ |
794 | |
795 | static int snd_opti9xx_probe(struct snd_card *card) |
796 | { |
797 | static const long possible_ports[] = {0x530, 0xe80, 0xf40, 0x604, -1}; |
798 | int error; |
799 | int xdma2; |
800 | struct snd_opti9xx *chip = card->private_data; |
801 | struct snd_wss *codec; |
802 | struct snd_rawmidi *rmidi; |
803 | struct snd_hwdep *synth; |
804 | |
805 | #if defined(CS4231) || defined(OPTi93X) |
806 | xdma2 = dma2; |
807 | #else |
808 | xdma2 = -1; |
809 | #endif |
810 | |
811 | if (port == SNDRV_AUTO_PORT) { |
812 | port = snd_legacy_find_free_ioport(port_table: possible_ports, size: 4); |
813 | if (port < 0) { |
814 | snd_printk(KERN_ERR "unable to find a free WSS port\n" ); |
815 | return -EBUSY; |
816 | } |
817 | } |
818 | error = snd_opti9xx_configure(chip, port, irq, dma1, dma2: xdma2, |
819 | mpu_port, mpu_irq); |
820 | if (error) |
821 | return error; |
822 | |
823 | error = snd_wss_create(card, port: chip->wss_base + 4, cport: -1, irq, dma1, dma2: xdma2, |
824 | #ifdef OPTi93X |
825 | WSS_HW_OPTI93X, WSS_HWSHARE_IRQ, |
826 | #else |
827 | WSS_HW_DETECT, hwshare: 0, |
828 | #endif |
829 | rchip: &codec); |
830 | if (error < 0) |
831 | return error; |
832 | chip->codec = codec; |
833 | error = snd_wss_pcm(chip: codec, device: 0); |
834 | if (error < 0) |
835 | return error; |
836 | error = snd_wss_mixer(chip: codec); |
837 | if (error < 0) |
838 | return error; |
839 | #ifdef OPTi93X |
840 | error = snd_opti93x_mixer(codec); |
841 | if (error < 0) |
842 | return error; |
843 | #endif |
844 | #ifdef CS4231 |
845 | error = snd_wss_timer(codec, 0); |
846 | if (error < 0) |
847 | return error; |
848 | #endif |
849 | #ifdef OPTi93X |
850 | error = devm_request_irq(card->dev, irq, snd_opti93x_interrupt, |
851 | 0, DEV_NAME" - WSS" , chip); |
852 | if (error < 0) { |
853 | snd_printk(KERN_ERR "opti9xx: can't grab IRQ %d\n" , irq); |
854 | return error; |
855 | } |
856 | #endif |
857 | chip->irq = irq; |
858 | card->sync_irq = chip->irq; |
859 | strcpy(p: card->driver, q: chip->name); |
860 | sprintf(buf: card->shortname, fmt: "OPTi %s" , card->driver); |
861 | #if defined(CS4231) || defined(OPTi93X) |
862 | scnprintf(card->longname, sizeof(card->longname), |
863 | "%s, %s at 0x%lx, irq %d, dma %d&%d" , |
864 | card->shortname, codec->pcm->name, |
865 | chip->wss_base + 4, irq, dma1, xdma2); |
866 | #else |
867 | scnprintf(buf: card->longname, size: sizeof(card->longname), |
868 | fmt: "%s, %s at 0x%lx, irq %d, dma %d" , |
869 | card->shortname, codec->pcm->name, chip->wss_base + 4, irq, |
870 | dma1); |
871 | #endif /* CS4231 || OPTi93X */ |
872 | |
873 | if (mpu_port <= 0 || mpu_port == SNDRV_AUTO_PORT) |
874 | rmidi = NULL; |
875 | else { |
876 | error = snd_mpu401_uart_new(card, device: 0, MPU401_HW_MPU401, |
877 | port: mpu_port, info_flags: 0, irq: mpu_irq, rrawmidi: &rmidi); |
878 | if (error) |
879 | snd_printk(KERN_WARNING "no MPU-401 device at 0x%lx?\n" , |
880 | mpu_port); |
881 | } |
882 | |
883 | if (fm_port > 0 && fm_port != SNDRV_AUTO_PORT) { |
884 | struct snd_opl3 *opl3 = NULL; |
885 | #ifndef OPTi93X |
886 | if (chip->hardware == OPTi9XX_HW_82C928 || |
887 | chip->hardware == OPTi9XX_HW_82C929 || |
888 | chip->hardware == OPTi9XX_HW_82C924) { |
889 | struct snd_opl4 *opl4; |
890 | /* assume we have an OPL4 */ |
891 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2), |
892 | value: 0x20, mask: 0x20); |
893 | if (snd_opl4_create(card, fm_port, pcm_port: fm_port - 8, |
894 | seq_device: 2, opl3: &opl3, opl4: &opl4) < 0) { |
895 | /* no luck, use OPL3 instead */ |
896 | snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2), |
897 | value: 0x00, mask: 0x20); |
898 | } |
899 | } |
900 | #endif /* !OPTi93X */ |
901 | if (!opl3 && snd_opl3_create(card, l_port: fm_port, r_port: fm_port + 2, |
902 | OPL3_HW_AUTO, integrated: 0, opl3: &opl3) < 0) { |
903 | snd_printk(KERN_WARNING "no OPL device at 0x%lx-0x%lx\n" , |
904 | fm_port, fm_port + 4 - 1); |
905 | } |
906 | if (opl3) { |
907 | error = snd_opl3_hwdep_new(opl3, device: 0, seq_device: 1, rhwdep: &synth); |
908 | if (error < 0) |
909 | return error; |
910 | } |
911 | } |
912 | |
913 | return snd_card_register(card); |
914 | } |
915 | |
916 | static int snd_opti9xx_card_new(struct device *pdev, struct snd_card **cardp) |
917 | { |
918 | struct snd_card *card; |
919 | int err; |
920 | |
921 | err = snd_devm_card_new(parent: pdev, idx: index, xid: id, THIS_MODULE, |
922 | extra_size: sizeof(struct snd_opti9xx), card_ret: &card); |
923 | if (err < 0) |
924 | return err; |
925 | *cardp = card; |
926 | return 0; |
927 | } |
928 | |
929 | static int snd_opti9xx_isa_match(struct device *devptr, |
930 | unsigned int dev) |
931 | { |
932 | #ifdef CONFIG_PNP |
933 | if (snd_opti9xx_pnp_is_probed) |
934 | return 0; |
935 | if (isapnp) |
936 | return 0; |
937 | #endif |
938 | return 1; |
939 | } |
940 | |
941 | static int snd_opti9xx_isa_probe(struct device *devptr, |
942 | unsigned int dev) |
943 | { |
944 | struct snd_card *card; |
945 | int error; |
946 | static const long possible_mpu_ports[] = {0x300, 0x310, 0x320, 0x330, -1}; |
947 | #ifdef OPTi93X |
948 | static const int possible_irqs[] = {5, 9, 10, 11, 7, -1}; |
949 | #else |
950 | static const int possible_irqs[] = {9, 10, 11, 7, -1}; |
951 | #endif /* OPTi93X */ |
952 | static const int possible_mpu_irqs[] = {5, 9, 10, 7, -1}; |
953 | static const int possible_dma1s[] = {3, 1, 0, -1}; |
954 | #if defined(CS4231) || defined(OPTi93X) |
955 | static const int possible_dma2s[][2] = {{1,-1}, {0,-1}, {-1,-1}, {0,-1}}; |
956 | #endif /* CS4231 || OPTi93X */ |
957 | |
958 | if (mpu_port == SNDRV_AUTO_PORT) { |
959 | mpu_port = snd_legacy_find_free_ioport(port_table: possible_mpu_ports, size: 2); |
960 | if (mpu_port < 0) { |
961 | snd_printk(KERN_ERR "unable to find a free MPU401 port\n" ); |
962 | return -EBUSY; |
963 | } |
964 | } |
965 | if (irq == SNDRV_AUTO_IRQ) { |
966 | irq = snd_legacy_find_free_irq(irq_table: possible_irqs); |
967 | if (irq < 0) { |
968 | snd_printk(KERN_ERR "unable to find a free IRQ\n" ); |
969 | return -EBUSY; |
970 | } |
971 | } |
972 | if (mpu_irq == SNDRV_AUTO_IRQ) { |
973 | mpu_irq = snd_legacy_find_free_irq(irq_table: possible_mpu_irqs); |
974 | if (mpu_irq < 0) { |
975 | snd_printk(KERN_ERR "unable to find a free MPU401 IRQ\n" ); |
976 | return -EBUSY; |
977 | } |
978 | } |
979 | if (dma1 == SNDRV_AUTO_DMA) { |
980 | dma1 = snd_legacy_find_free_dma(dma_table: possible_dma1s); |
981 | if (dma1 < 0) { |
982 | snd_printk(KERN_ERR "unable to find a free DMA1\n" ); |
983 | return -EBUSY; |
984 | } |
985 | } |
986 | #if defined(CS4231) || defined(OPTi93X) |
987 | if (dma2 == SNDRV_AUTO_DMA) { |
988 | dma2 = snd_legacy_find_free_dma(possible_dma2s[dma1 % 4]); |
989 | if (dma2 < 0) { |
990 | snd_printk(KERN_ERR "unable to find a free DMA2\n" ); |
991 | return -EBUSY; |
992 | } |
993 | } |
994 | #endif |
995 | |
996 | error = snd_opti9xx_card_new(pdev: devptr, cardp: &card); |
997 | if (error < 0) |
998 | return error; |
999 | |
1000 | error = snd_card_opti9xx_detect(card, chip: card->private_data); |
1001 | if (error < 0) |
1002 | return error; |
1003 | error = snd_opti9xx_probe(card); |
1004 | if (error < 0) |
1005 | return error; |
1006 | dev_set_drvdata(dev: devptr, data: card); |
1007 | return 0; |
1008 | } |
1009 | |
1010 | #ifdef CONFIG_PM |
1011 | static int snd_opti9xx_suspend(struct snd_card *card) |
1012 | { |
1013 | struct snd_opti9xx *chip = card->private_data; |
1014 | |
1015 | snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); |
1016 | chip->codec->suspend(chip->codec); |
1017 | return 0; |
1018 | } |
1019 | |
1020 | static int snd_opti9xx_resume(struct snd_card *card) |
1021 | { |
1022 | struct snd_opti9xx *chip = card->private_data; |
1023 | int error, xdma2; |
1024 | #if defined(CS4231) || defined(OPTi93X) |
1025 | xdma2 = dma2; |
1026 | #else |
1027 | xdma2 = -1; |
1028 | #endif |
1029 | |
1030 | error = snd_opti9xx_configure(chip, port, irq, dma1, dma2: xdma2, |
1031 | mpu_port, mpu_irq); |
1032 | if (error) |
1033 | return error; |
1034 | chip->codec->resume(chip->codec); |
1035 | snd_power_change_state(card, SNDRV_CTL_POWER_D0); |
1036 | return 0; |
1037 | } |
1038 | |
1039 | static int snd_opti9xx_isa_suspend(struct device *dev, unsigned int n, |
1040 | pm_message_t state) |
1041 | { |
1042 | return snd_opti9xx_suspend(card: dev_get_drvdata(dev)); |
1043 | } |
1044 | |
1045 | static int snd_opti9xx_isa_resume(struct device *dev, unsigned int n) |
1046 | { |
1047 | return snd_opti9xx_resume(card: dev_get_drvdata(dev)); |
1048 | } |
1049 | #endif |
1050 | |
1051 | static struct isa_driver snd_opti9xx_driver = { |
1052 | .match = snd_opti9xx_isa_match, |
1053 | .probe = snd_opti9xx_isa_probe, |
1054 | #ifdef CONFIG_PM |
1055 | .suspend = snd_opti9xx_isa_suspend, |
1056 | .resume = snd_opti9xx_isa_resume, |
1057 | #endif |
1058 | .driver = { |
1059 | .name = DEV_NAME |
1060 | }, |
1061 | }; |
1062 | |
1063 | #ifdef CONFIG_PNP |
1064 | static int snd_opti9xx_pnp_probe(struct pnp_card_link *pcard, |
1065 | const struct pnp_card_device_id *pid) |
1066 | { |
1067 | struct snd_card *card; |
1068 | int error, hw; |
1069 | struct snd_opti9xx *chip; |
1070 | |
1071 | if (snd_opti9xx_pnp_is_probed) |
1072 | return -EBUSY; |
1073 | if (! isapnp) |
1074 | return -ENODEV; |
1075 | error = snd_opti9xx_card_new(pdev: &pcard->card->dev, cardp: &card); |
1076 | if (error < 0) |
1077 | return error; |
1078 | chip = card->private_data; |
1079 | |
1080 | hw = snd_card_opti9xx_pnp(chip, card: pcard, pid); |
1081 | switch (hw) { |
1082 | case 0x0924: |
1083 | hw = OPTi9XX_HW_82C924; |
1084 | break; |
1085 | case 0x0925: |
1086 | hw = OPTi9XX_HW_82C925; |
1087 | break; |
1088 | case 0x0931: |
1089 | hw = OPTi9XX_HW_82C931; |
1090 | break; |
1091 | default: |
1092 | return -ENODEV; |
1093 | } |
1094 | |
1095 | error = snd_opti9xx_init(chip, hardware: hw); |
1096 | if (error) |
1097 | return error; |
1098 | error = snd_opti9xx_read_check(card, chip); |
1099 | if (error) { |
1100 | snd_printk(KERN_ERR "OPTI chip not found\n" ); |
1101 | return error; |
1102 | } |
1103 | error = snd_opti9xx_probe(card); |
1104 | if (error < 0) |
1105 | return error; |
1106 | pnp_set_card_drvdata(pcard, data: card); |
1107 | snd_opti9xx_pnp_is_probed = 1; |
1108 | return 0; |
1109 | } |
1110 | |
1111 | static void snd_opti9xx_pnp_remove(struct pnp_card_link *pcard) |
1112 | { |
1113 | snd_opti9xx_pnp_is_probed = 0; |
1114 | } |
1115 | |
1116 | #ifdef CONFIG_PM |
1117 | static int snd_opti9xx_pnp_suspend(struct pnp_card_link *pcard, |
1118 | pm_message_t state) |
1119 | { |
1120 | return snd_opti9xx_suspend(card: pnp_get_card_drvdata(pcard)); |
1121 | } |
1122 | |
1123 | static int snd_opti9xx_pnp_resume(struct pnp_card_link *pcard) |
1124 | { |
1125 | return snd_opti9xx_resume(card: pnp_get_card_drvdata(pcard)); |
1126 | } |
1127 | #endif |
1128 | |
1129 | static struct pnp_card_driver opti9xx_pnpc_driver = { |
1130 | .flags = PNP_DRIVER_RES_DISABLE, |
1131 | .name = DEV_NAME, |
1132 | .id_table = snd_opti9xx_pnpids, |
1133 | .probe = snd_opti9xx_pnp_probe, |
1134 | .remove = snd_opti9xx_pnp_remove, |
1135 | #ifdef CONFIG_PM |
1136 | .suspend = snd_opti9xx_pnp_suspend, |
1137 | .resume = snd_opti9xx_pnp_resume, |
1138 | #endif |
1139 | }; |
1140 | #endif |
1141 | |
1142 | #ifdef OPTi93X |
1143 | #define CHIP_NAME "82C93x" |
1144 | #else |
1145 | #define CHIP_NAME "82C92x" |
1146 | #endif |
1147 | |
1148 | static int __init alsa_card_opti9xx_init(void) |
1149 | { |
1150 | #ifdef CONFIG_PNP |
1151 | pnp_register_card_driver(drv: &opti9xx_pnpc_driver); |
1152 | if (snd_opti9xx_pnp_is_probed) |
1153 | return 0; |
1154 | pnp_unregister_card_driver(drv: &opti9xx_pnpc_driver); |
1155 | #endif |
1156 | return isa_register_driver(&snd_opti9xx_driver, 1); |
1157 | } |
1158 | |
1159 | static void __exit alsa_card_opti9xx_exit(void) |
1160 | { |
1161 | if (!snd_opti9xx_pnp_is_probed) { |
1162 | isa_unregister_driver(&snd_opti9xx_driver); |
1163 | return; |
1164 | } |
1165 | #ifdef CONFIG_PNP |
1166 | pnp_unregister_card_driver(drv: &opti9xx_pnpc_driver); |
1167 | #endif |
1168 | } |
1169 | |
1170 | module_init(alsa_card_opti9xx_init) |
1171 | module_exit(alsa_card_opti9xx_exit) |
1172 | |