2 * Driver for AMD InterWave soundcard
3 * Copyright (c) by Jaroslav Kysela <perex@suse.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
20 * 1999/07/22 Erik Inge Bolso <knan@mo.himolde.no>
21 * * mixer group handlers
25 #include <sound/driver.h>
26 #include <linux/init.h>
27 #include <linux/err.h>
28 #include <linux/platform_device.h>
29 #include <linux/delay.h>
30 #include <linux/slab.h>
31 #include <linux/pnp.h>
32 #include <linux/moduleparam.h>
34 #include <sound/core.h>
35 #include <sound/gus.h>
36 #include <sound/cs4231.h>
38 #include <sound/tea6330t.h>
40 #define SNDRV_LEGACY_FIND_FREE_IRQ
41 #define SNDRV_LEGACY_FIND_FREE_DMA
42 #include <sound/initval.h>
44 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
45 MODULE_LICENSE("GPL");
47 MODULE_DESCRIPTION("AMD InterWave");
48 MODULE_SUPPORTED_DEVICE("{{Gravis,UltraSound Plug & Play},"
51 "{Dynasonix,Dynasonix Pro},"
52 "{Panasonic,PCA761AW}}");
54 MODULE_DESCRIPTION("AMD InterWave STB with TEA6330T");
55 MODULE_SUPPORTED_DEVICE("{{AMD,InterWave STB with TEA6330T}}");
58 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
59 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
60 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_ISAPNP
; /* Enable this card */
62 static int isapnp
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 1};
64 static long port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
; /* 0x210,0x220,0x230,0x240,0x250,0x260 */
66 static long port_tc
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
; /* 0x350,0x360,0x370,0x380 */
68 static int irq
[SNDRV_CARDS
] = SNDRV_DEFAULT_IRQ
; /* 2,3,5,9,11,12,15 */
69 static int dma1
[SNDRV_CARDS
] = SNDRV_DEFAULT_DMA
; /* 0,1,3,5,6,7 */
70 static int dma2
[SNDRV_CARDS
] = SNDRV_DEFAULT_DMA
; /* 0,1,3,5,6,7 */
71 static int joystick_dac
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 29};
72 /* 0 to 31, (0.59V-4.52V or 0.389V-2.98V) */
73 static int midi
[SNDRV_CARDS
];
74 static int pcm_channels
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 2};
75 static int effect
[SNDRV_CARDS
];
78 #define PFX "interwave-stb: "
79 #define INTERWAVE_DRIVER "snd_interwave_stb"
80 #define INTERWAVE_PNP_DRIVER "interwave-stb"
82 #define PFX "interwave: "
83 #define INTERWAVE_DRIVER "snd_interwave"
84 #define INTERWAVE_PNP_DRIVER "interwave"
87 module_param_array(index
, int, NULL
, 0444);
88 MODULE_PARM_DESC(index
, "Index value for InterWave soundcard.");
89 module_param_array(id
, charp
, NULL
, 0444);
90 MODULE_PARM_DESC(id
, "ID string for InterWave soundcard.");
91 module_param_array(enable
, bool, NULL
, 0444);
92 MODULE_PARM_DESC(enable
, "Enable InterWave soundcard.");
94 module_param_array(isapnp
, bool, NULL
, 0444);
95 MODULE_PARM_DESC(isapnp
, "ISA PnP detection for specified soundcard.");
97 module_param_array(port
, long, NULL
, 0444);
98 MODULE_PARM_DESC(port
, "Port # for InterWave driver.");
100 module_param_array(port_tc
, long, NULL
, 0444);
101 MODULE_PARM_DESC(port_tc
, "Tone control (TEA6330T - i2c bus) port # for InterWave driver.");
103 module_param_array(irq
, int, NULL
, 0444);
104 MODULE_PARM_DESC(irq
, "IRQ # for InterWave driver.");
105 module_param_array(dma1
, int, NULL
, 0444);
106 MODULE_PARM_DESC(dma1
, "DMA1 # for InterWave driver.");
107 module_param_array(dma2
, int, NULL
, 0444);
108 MODULE_PARM_DESC(dma2
, "DMA2 # for InterWave driver.");
109 module_param_array(joystick_dac
, int, NULL
, 0444);
110 MODULE_PARM_DESC(joystick_dac
, "Joystick DAC level 0.59V-4.52V or 0.389V-2.98V for InterWave driver.");
111 module_param_array(midi
, int, NULL
, 0444);
112 MODULE_PARM_DESC(midi
, "MIDI UART enable for InterWave driver.");
113 module_param_array(pcm_channels
, int, NULL
, 0444);
114 MODULE_PARM_DESC(pcm_channels
, "Reserved PCM channels for InterWave driver.");
115 module_param_array(effect
, int, NULL
, 0444);
116 MODULE_PARM_DESC(effect
, "Effects enable for InterWave driver.");
118 static struct platform_device
*platform_devices
[SNDRV_CARDS
];
119 static int pnp_registered
;
121 struct snd_interwave
{
123 struct snd_card
*card
;
124 struct snd_gus_card
*gus
;
125 struct snd_cs4231
*cs4231
;
127 struct resource
*i2c_res
;
129 unsigned short gus_status_reg
;
130 unsigned short pcm_status_reg
;
134 struct pnp_dev
*devtc
;
142 static struct pnp_card_device_id snd_interwave_pnpids
[] = {
144 /* Gravis UltraSound Plug & Play */
145 { .id
= "GRV0001", .devs
= { { .id
= "GRV0000" } } },
146 /* STB SoundRage32 */
147 { .id
= "STB011a", .devs
= { { .id
= "STB0010" } } },
149 { .id
= "DXP3201", .devs
= { { .id
= "DXP0010" } } },
151 /* This device also have CDC1117:DynaSonix Pro Audio Effects Processor */
152 { .id
= "CDC1111", .devs
= { { .id
= "CDC1112" } } },
153 /* Panasonic PCA761AW Audio Card */
154 { .id
= "ADV55ff", .devs
= { { .id
= "ADV0010" } } },
155 /* InterWave STB without TEA6330T */
156 { .id
= "ADV550a", .devs
= { { .id
= "ADV0010" } } },
158 /* InterWave STB with TEA6330T */
159 { .id
= "ADV550a", .devs
= { { .id
= "ADV0010" }, { .id
= "ADV0015" } } },
164 MODULE_DEVICE_TABLE(pnp_card
, snd_interwave_pnpids
);
166 #endif /* CONFIG_PNP */
170 static void snd_interwave_i2c_setlines(struct snd_i2c_bus
*bus
, int ctrl
, int data
)
172 unsigned long port
= bus
->private_value
;
175 printk("i2c_setlines - 0x%lx <- %i,%i\n", port
, ctrl
, data
);
177 outb((data
<< 1) | ctrl
, port
);
181 static int snd_interwave_i2c_getclockline(struct snd_i2c_bus
*bus
)
183 unsigned long port
= bus
->private_value
;
188 printk("i2c_getclockline - 0x%lx -> %i\n", port
, res
);
193 static int snd_interwave_i2c_getdataline(struct snd_i2c_bus
*bus
, int ack
)
195 unsigned long port
= bus
->private_value
;
200 res
= (inb(port
) & 2) >> 1;
202 printk("i2c_getdataline - 0x%lx -> %i\n", port
, res
);
207 static struct snd_i2c_bit_ops snd_interwave_i2c_bit_ops
= {
208 .setlines
= snd_interwave_i2c_setlines
,
209 .getclock
= snd_interwave_i2c_getclockline
,
210 .getdata
= snd_interwave_i2c_getdataline
,
213 static int __devinit
snd_interwave_detect_stb(struct snd_interwave
*iwcard
,
214 struct snd_gus_card
* gus
, int dev
,
215 struct snd_i2c_bus
**rbus
)
218 struct snd_i2c_bus
*bus
;
219 struct snd_card
*card
= iwcard
->card
;
225 if (port
== SNDRV_AUTO_PORT
) {
227 if (gus
->gf1
.port
== 0x250) {
230 while (port
<= 0x380) {
231 if ((iwcard
->i2c_res
= request_region(port
, 1, "InterWave (I2C bus)")) != NULL
)
236 iwcard
->i2c_res
= request_region(port
, 1, "InterWave (I2C bus)");
238 if (iwcard
->i2c_res
== NULL
) {
239 snd_printk(KERN_ERR
"interwave: can't grab i2c bus port\n");
243 sprintf(name
, "InterWave-%i", card
->number
);
244 if ((err
= snd_i2c_bus_create(card
, name
, NULL
, &bus
)) < 0)
246 bus
->private_value
= port
;
247 bus
->hw_ops
.bit
= &snd_interwave_i2c_bit_ops
;
248 if ((err
= snd_tea6330t_detect(bus
, 0)) < 0)
255 static int __devinit
snd_interwave_detect(struct snd_interwave
*iwcard
,
256 struct snd_gus_card
* gus
,
259 , struct snd_i2c_bus
**rbus
264 unsigned char rev1
, rev2
;
267 snd_gf1_i_write8(gus
, SNDRV_GF1_GB_RESET
, 0); /* reset GF1 */
268 if (((d
= snd_gf1_i_look8(gus
, SNDRV_GF1_GB_RESET
)) & 0x07) != 0) {
269 snd_printdd("[0x%lx] check 1 failed - 0x%x\n", gus
->gf1
.port
, d
);
273 snd_gf1_i_write8(gus
, SNDRV_GF1_GB_RESET
, 1); /* release reset */
275 if (((d
= snd_gf1_i_look8(gus
, SNDRV_GF1_GB_RESET
)) & 0x07) != 1) {
276 snd_printdd("[0x%lx] check 2 failed - 0x%x\n", gus
->gf1
.port
, d
);
279 spin_lock_irqsave(&gus
->reg_lock
, flags
);
280 rev1
= snd_gf1_look8(gus
, SNDRV_GF1_GB_VERSION_NUMBER
);
281 snd_gf1_write8(gus
, SNDRV_GF1_GB_VERSION_NUMBER
, ~rev1
);
282 rev2
= snd_gf1_look8(gus
, SNDRV_GF1_GB_VERSION_NUMBER
);
283 snd_gf1_write8(gus
, SNDRV_GF1_GB_VERSION_NUMBER
, rev1
);
284 spin_unlock_irqrestore(&gus
->reg_lock
, flags
);
285 snd_printdd("[0x%lx] InterWave check - rev1=0x%x, rev2=0x%x\n", gus
->gf1
.port
, rev1
, rev2
);
286 if ((rev1
& 0xf0) == (rev2
& 0xf0) &&
287 (rev1
& 0x0f) != (rev2
& 0x0f)) {
288 snd_printdd("[0x%lx] InterWave check - passed\n", gus
->gf1
.port
);
290 strcpy(gus
->card
->shortname
, "AMD InterWave");
291 gus
->revision
= rev1
>> 4;
293 return 0; /* ok.. We have an InterWave board */
295 return snd_interwave_detect_stb(iwcard
, gus
, dev
, rbus
);
298 snd_printdd("[0x%lx] InterWave check - failed\n", gus
->gf1
.port
);
302 static irqreturn_t
snd_interwave_interrupt(int irq
, void *dev_id
)
304 struct snd_interwave
*iwcard
= dev_id
;
310 if (inb(iwcard
->gus_status_reg
)) {
312 snd_gus_interrupt(irq
, iwcard
->gus
);
315 if (inb(iwcard
->pcm_status_reg
) & 0x01) { /* IRQ bit is set? */
317 snd_cs4231_interrupt(irq
, iwcard
->cs4231
);
320 } while (loop
&& --max
> 0);
321 return IRQ_RETVAL(handled
);
324 static void __devinit
snd_interwave_reset(struct snd_gus_card
* gus
)
326 snd_gf1_write8(gus
, SNDRV_GF1_GB_RESET
, 0x00);
328 snd_gf1_write8(gus
, SNDRV_GF1_GB_RESET
, 0x01);
332 static void __devinit
snd_interwave_bank_sizes(struct snd_gus_card
* gus
, int *sizes
)
338 for (idx
= 0; idx
< 4; idx
++) {
341 for (local
= idx
<< 22;
342 local
< (idx
<< 22) + 0x400000;
343 local
+= 0x40000, d
++) {
344 snd_gf1_poke(gus
, local
, d
);
345 snd_gf1_poke(gus
, local
+ 1, d
+ 1);
347 printk("d = 0x%x, local = 0x%x, local + 1 = 0x%x, idx << 22 = 0x%x\n",
349 snd_gf1_peek(gus
, local
),
350 snd_gf1_peek(gus
, local
+ 1),
351 snd_gf1_peek(gus
, idx
<< 22));
353 if (snd_gf1_peek(gus
, local
) != d
||
354 snd_gf1_peek(gus
, local
+ 1) != d
+ 1 ||
355 snd_gf1_peek(gus
, idx
<< 22) != 0x55)
361 printk("sizes: %i %i %i %i\n", sizes
[0], sizes
[1], sizes
[2], sizes
[3]);
366 /* 000 */ unsigned char iwave
[8];
367 /* 008 */ unsigned char rom_hdr_revision
;
368 /* 009 */ unsigned char series_number
;
369 /* 010 */ unsigned char series_name
[16];
370 /* 026 */ unsigned char date
[10];
371 /* 036 */ unsigned short vendor_revision_major
;
372 /* 038 */ unsigned short vendor_revision_minor
;
373 /* 040 */ unsigned int rom_size
;
374 /* 044 */ unsigned char copyright
[128];
375 /* 172 */ unsigned char vendor_name
[64];
376 /* 236 */ unsigned char rom_description
[128];
377 /* 364 */ unsigned char pad
[147];
378 /* 511 */ unsigned char csum
;
381 static void __devinit
snd_interwave_detect_memory(struct snd_gus_card
* gus
)
383 static unsigned int lmc
[13] =
385 0x00000001, 0x00000101, 0x01010101, 0x00000401,
386 0x04040401, 0x00040101, 0x04040101, 0x00000004,
387 0x00000404, 0x04040404, 0x00000010, 0x00001010,
392 unsigned int i
, lmct
;
394 unsigned char iwave
[8];
397 snd_interwave_reset(gus
);
398 snd_gf1_write8(gus
, SNDRV_GF1_GB_GLOBAL_MODE
, snd_gf1_read8(gus
, SNDRV_GF1_GB_GLOBAL_MODE
) | 0x01); /* enhanced mode */
399 snd_gf1_write8(gus
, SNDRV_GF1_GB_MEMORY_CONTROL
, 0x01); /* DRAM I/O cycles selected */
400 snd_gf1_write16(gus
, SNDRV_GF1_GW_MEMORY_CONFIG
, (snd_gf1_look16(gus
, SNDRV_GF1_GW_MEMORY_CONFIG
) & 0xff10) | 0x004c);
401 /* ok.. simple test of memory size */
403 snd_gf1_poke(gus
, 0, 0x55);
404 snd_gf1_poke(gus
, 1, 0xaa);
406 if (snd_gf1_peek(gus
, 0) == 0x55 && snd_gf1_peek(gus
, 1) == 0xaa)
408 if (0) /* ok.. for testing of 0k RAM */
411 snd_interwave_bank_sizes(gus
, psizes
);
412 lmct
= (psizes
[3] << 24) | (psizes
[2] << 16) |
413 (psizes
[1] << 8) | psizes
[0];
415 printk("lmct = 0x%08x\n", lmct
);
417 for (i
= 0; i
< ARRAY_SIZE(lmc
); i
++)
418 if (lmct
== lmc
[i
]) {
420 printk("found !!! %i\n", i
);
422 snd_gf1_write16(gus
, SNDRV_GF1_GW_MEMORY_CONFIG
, (snd_gf1_look16(gus
, SNDRV_GF1_GW_MEMORY_CONFIG
) & 0xfff0) | i
);
423 snd_interwave_bank_sizes(gus
, psizes
);
426 if (i
>= ARRAY_SIZE(lmc
) && !gus
->gf1
.enh_mode
)
427 snd_gf1_write16(gus
, SNDRV_GF1_GW_MEMORY_CONFIG
, (snd_gf1_look16(gus
, SNDRV_GF1_GW_MEMORY_CONFIG
) & 0xfff0) | 2);
428 for (i
= 0; i
< 4; i
++) {
429 gus
->gf1
.mem_alloc
.banks_8
[i
].address
=
430 gus
->gf1
.mem_alloc
.banks_16
[i
].address
= i
<< 22;
431 gus
->gf1
.mem_alloc
.banks_8
[i
].size
=
432 gus
->gf1
.mem_alloc
.banks_16
[i
].size
= psizes
[i
] << 18;
437 gus
->gf1
.memory
= pages
;
439 snd_gf1_write8(gus
, SNDRV_GF1_GB_MEMORY_CONTROL
, 0x03); /* select ROM */
440 snd_gf1_write16(gus
, SNDRV_GF1_GW_MEMORY_CONFIG
, (snd_gf1_look16(gus
, SNDRV_GF1_GW_MEMORY_CONFIG
) & 0xff1f) | (4 << 5));
441 gus
->gf1
.rom_banks
= 0;
442 gus
->gf1
.rom_memory
= 0;
443 for (bank_pos
= 0; bank_pos
< 16L * 1024L * 1024L; bank_pos
+= 4L * 1024L * 1024L) {
444 for (i
= 0; i
< 8; ++i
)
445 iwave
[i
] = snd_gf1_peek(gus
, bank_pos
+ i
);
446 #ifdef CONFIG_SND_DEBUG_ROM
447 printk(KERN_DEBUG
"ROM at 0x%06x = %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n", bank_pos
,
448 iwave
[0], iwave
[1], iwave
[2], iwave
[3],
449 iwave
[4], iwave
[5], iwave
[6], iwave
[7]);
451 if (strncmp(iwave
, "INTRWAVE", 8))
452 continue; /* first check */
454 for (i
= 0; i
< sizeof(struct rom_hdr
); i
++)
455 csum
+= snd_gf1_peek(gus
, bank_pos
+ i
);
456 #ifdef CONFIG_SND_DEBUG_ROM
457 printk(KERN_DEBUG
"ROM checksum = 0x%x (computed)\n", csum
);
460 continue; /* not valid rom */
461 gus
->gf1
.rom_banks
++;
462 gus
->gf1
.rom_present
|= 1 << (bank_pos
>> 22);
463 gus
->gf1
.rom_memory
= snd_gf1_peek(gus
, bank_pos
+ 40) |
464 (snd_gf1_peek(gus
, bank_pos
+ 41) << 8) |
465 (snd_gf1_peek(gus
, bank_pos
+ 42) << 16) |
466 (snd_gf1_peek(gus
, bank_pos
+ 43) << 24);
469 if (gus
->gf1
.rom_memory
> 0) {
470 if (gus
->gf1
.rom_banks
== 1 && gus
->gf1
.rom_present
== 8)
471 gus
->card
->type
= SNDRV_CARD_TYPE_IW_DYNASONIC
;
474 snd_gf1_write8(gus
, SNDRV_GF1_GB_MEMORY_CONTROL
, 0x00); /* select RAM */
476 if (!gus
->gf1
.enh_mode
)
477 snd_interwave_reset(gus
);
480 static void __devinit
snd_interwave_init(int dev
, struct snd_gus_card
* gus
)
484 /* ok.. some InterWave specific initialization */
485 spin_lock_irqsave(&gus
->reg_lock
, flags
);
486 snd_gf1_write8(gus
, SNDRV_GF1_GB_SOUND_BLASTER_CONTROL
, 0x00);
487 snd_gf1_write8(gus
, SNDRV_GF1_GB_COMPATIBILITY
, 0x1f);
488 snd_gf1_write8(gus
, SNDRV_GF1_GB_DECODE_CONTROL
, 0x49);
489 snd_gf1_write8(gus
, SNDRV_GF1_GB_VERSION_NUMBER
, 0x11);
490 snd_gf1_write8(gus
, SNDRV_GF1_GB_MPU401_CONTROL_A
, 0x00);
491 snd_gf1_write8(gus
, SNDRV_GF1_GB_MPU401_CONTROL_B
, 0x30);
492 snd_gf1_write8(gus
, SNDRV_GF1_GB_EMULATION_IRQ
, 0x00);
493 spin_unlock_irqrestore(&gus
->reg_lock
, flags
);
498 gus
->joystick_dac
= joystick_dac
[dev
];
502 static struct snd_kcontrol_new snd_interwave_controls
[] = {
503 CS4231_DOUBLE("Master Playback Switch", 0, CS4231_LINE_LEFT_OUTPUT
, CS4231_LINE_RIGHT_OUTPUT
, 7, 7, 1, 1),
504 CS4231_DOUBLE("Master Playback Volume", 0, CS4231_LINE_LEFT_OUTPUT
, CS4231_LINE_RIGHT_OUTPUT
, 0, 0, 31, 1),
505 CS4231_DOUBLE("Mic Playback Switch", 0, CS4231_LEFT_MIC_INPUT
, CS4231_RIGHT_MIC_INPUT
, 7, 7, 1, 1),
506 CS4231_DOUBLE("Mic Playback Volume", 0, CS4231_LEFT_MIC_INPUT
, CS4231_RIGHT_MIC_INPUT
, 0, 0, 31, 1)
509 static int __devinit
snd_interwave_mixer(struct snd_cs4231
*chip
)
511 struct snd_card
*card
= chip
->card
;
512 struct snd_ctl_elem_id id1
, id2
;
516 memset(&id1
, 0, sizeof(id1
));
517 memset(&id2
, 0, sizeof(id2
));
518 id1
.iface
= id2
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
520 /* remove mono microphone controls */
521 strcpy(id1
.name
, "Mic Playback Switch");
522 if ((err
= snd_ctl_remove_id(card
, &id1
)) < 0)
524 strcpy(id1
.name
, "Mic Playback Volume");
525 if ((err
= snd_ctl_remove_id(card
, &id1
)) < 0)
528 /* add new master and mic controls */
529 for (idx
= 0; idx
< ARRAY_SIZE(snd_interwave_controls
); idx
++)
530 if ((err
= snd_ctl_add(card
, snd_ctl_new1(&snd_interwave_controls
[idx
], chip
))) < 0)
532 snd_cs4231_out(chip
, CS4231_LINE_LEFT_OUTPUT
, 0x9f);
533 snd_cs4231_out(chip
, CS4231_LINE_RIGHT_OUTPUT
, 0x9f);
534 snd_cs4231_out(chip
, CS4231_LEFT_MIC_INPUT
, 0x9f);
535 snd_cs4231_out(chip
, CS4231_RIGHT_MIC_INPUT
, 0x9f);
536 /* reassign AUXA to SYNTHESIZER */
537 strcpy(id1
.name
, "Aux Playback Switch");
538 strcpy(id2
.name
, "Synth Playback Switch");
539 if ((err
= snd_ctl_rename_id(card
, &id1
, &id2
)) < 0)
541 strcpy(id1
.name
, "Aux Playback Volume");
542 strcpy(id2
.name
, "Synth Playback Volume");
543 if ((err
= snd_ctl_rename_id(card
, &id1
, &id2
)) < 0)
545 /* reassign AUXB to CD */
546 strcpy(id1
.name
, "Aux Playback Switch"); id1
.index
= 1;
547 strcpy(id2
.name
, "CD Playback Switch");
548 if ((err
= snd_ctl_rename_id(card
, &id1
, &id2
)) < 0)
550 strcpy(id1
.name
, "Aux Playback Volume");
551 strcpy(id2
.name
, "CD Playback Volume");
552 if ((err
= snd_ctl_rename_id(card
, &id1
, &id2
)) < 0)
559 static int __devinit
snd_interwave_pnp(int dev
, struct snd_interwave
*iwcard
,
560 struct pnp_card_link
*card
,
561 const struct pnp_card_device_id
*id
)
563 struct pnp_dev
*pdev
;
564 struct pnp_resource_table
* cfg
= kmalloc(sizeof(struct pnp_resource_table
), GFP_KERNEL
);
569 iwcard
->dev
= pnp_request_card_device(card
, id
->devs
[0].id
, NULL
);
570 if (iwcard
->dev
== NULL
) {
575 iwcard
->devtc
= pnp_request_card_device(card
, id
->devs
[1].id
, NULL
);
576 if (iwcard
->devtc
== NULL
) {
581 /* Synth & Codec initialization */
583 pnp_init_resource_table(cfg
);
584 if (port
[dev
] != SNDRV_AUTO_PORT
) {
585 pnp_resource_change(&cfg
->port_resource
[0], port
[dev
], 16);
586 pnp_resource_change(&cfg
->port_resource
[1], port
[dev
] + 0x100, 12);
587 pnp_resource_change(&cfg
->port_resource
[2], port
[dev
] + 0x10c, 4);
589 if (dma1
[dev
] != SNDRV_AUTO_DMA
)
590 pnp_resource_change(&cfg
->dma_resource
[0], dma1
[dev
], 1);
591 if (dma2
[dev
] != SNDRV_AUTO_DMA
)
592 pnp_resource_change(&cfg
->dma_resource
[1], dma2
[dev
], 1);
594 pnp_resource_change(&cfg
->dma_resource
[1], 4, 1);
595 if (irq
[dev
] != SNDRV_AUTO_IRQ
)
596 pnp_resource_change(&cfg
->irq_resource
[0], irq
[dev
], 1);
597 if (pnp_manual_config_dev(pdev
, cfg
, 0) < 0)
598 snd_printk(KERN_ERR
"InterWave - Synth - the requested resources are invalid, using auto config\n");
599 err
= pnp_activate_dev(pdev
);
602 snd_printk(KERN_ERR
"InterWave PnP configure failure (out of resources?)\n");
605 if (pnp_port_start(pdev
, 0) + 0x100 != pnp_port_start(pdev
, 1) ||
606 pnp_port_start(pdev
, 0) + 0x10c != pnp_port_start(pdev
, 2)) {
608 snd_printk(KERN_ERR
"PnP configure failure (wrong ports)\n");
611 port
[dev
] = pnp_port_start(pdev
, 0);
612 dma1
[dev
] = pnp_dma(pdev
, 0);
614 dma2
[dev
] = pnp_dma(pdev
, 1);
615 irq
[dev
] = pnp_irq(pdev
, 0);
616 snd_printdd("isapnp IW: sb port=0x%llx, gf1 port=0x%llx, codec port=0x%llx\n",
617 (unsigned long long)pnp_port_start(pdev
, 0),
618 (unsigned long long)pnp_port_start(pdev
, 1),
619 (unsigned long long)pnp_port_start(pdev
, 2));
620 snd_printdd("isapnp IW: dma1=%i, dma2=%i, irq=%i\n", dma1
[dev
], dma2
[dev
], irq
[dev
]);
622 /* Tone Control initialization */
623 pdev
= iwcard
->devtc
;
624 pnp_init_resource_table(cfg
);
625 if (port_tc
[dev
] != SNDRV_AUTO_PORT
)
626 pnp_resource_change(&cfg
->port_resource
[0], port_tc
[dev
], 1);
627 if (pnp_manual_config_dev(pdev
, cfg
, 0) < 0)
628 snd_printk(KERN_ERR
"InterWave - ToneControl - the requested resources are invalid, using auto config\n");
629 err
= pnp_activate_dev(pdev
);
632 snd_printk(KERN_ERR
"InterWave ToneControl PnP configure failure (out of resources?)\n");
635 port_tc
[dev
] = pnp_port_start(pdev
, 0);
636 snd_printdd("isapnp IW: tone control port=0x%lx\n", port_tc
[dev
]);
641 #endif /* CONFIG_PNP */
643 static void snd_interwave_free(struct snd_card
*card
)
645 struct snd_interwave
*iwcard
= card
->private_data
;
650 release_and_free_resource(iwcard
->i2c_res
);
652 if (iwcard
->irq
>= 0)
653 free_irq(iwcard
->irq
, (void *)iwcard
);
656 static struct snd_card
*snd_interwave_card_new(int dev
)
658 struct snd_card
*card
;
659 struct snd_interwave
*iwcard
;
661 card
= snd_card_new(index
[dev
], id
[dev
], THIS_MODULE
,
662 sizeof(struct snd_interwave
));
665 iwcard
= card
->private_data
;
668 card
->private_free
= snd_interwave_free
;
672 static int __devinit
snd_interwave_probe(struct snd_card
*card
, int dev
)
674 int xirq
, xdma1
, xdma2
;
675 struct snd_interwave
*iwcard
= card
->private_data
;
676 struct snd_cs4231
*cs4231
;
677 struct snd_gus_card
*gus
;
679 struct snd_i2c_bus
*i2c_bus
;
689 if ((err
= snd_gus_create(card
,
693 pcm_channels
[dev
], effect
[dev
], &gus
)) < 0)
696 if ((err
= snd_interwave_detect(iwcard
, gus
, dev
703 iwcard
->gus_status_reg
= gus
->gf1
.reg_irqstat
;
704 iwcard
->pcm_status_reg
= gus
->gf1
.port
+ 0x10c + 2;
706 snd_interwave_init(dev
, gus
);
707 snd_interwave_detect_memory(gus
);
708 if ((err
= snd_gus_initialize(gus
)) < 0)
711 if (request_irq(xirq
, snd_interwave_interrupt
, IRQF_DISABLED
,
712 "InterWave", iwcard
)) {
713 snd_printk(KERN_ERR PFX
"unable to grab IRQ %d\n", xirq
);
718 if ((err
= snd_cs4231_create(card
,
719 gus
->gf1
.port
+ 0x10c, -1, xirq
,
720 xdma2
< 0 ? xdma1
: xdma2
, xdma1
,
723 CS4231_HWSHARE_DMA1
|
728 if ((err
= snd_cs4231_pcm(cs4231
, 0, &pcm
)) < 0)
731 sprintf(pcm
->name
+ strlen(pcm
->name
), " rev %c", gus
->revision
+ 'A');
732 strcat(pcm
->name
, " (codec)");
734 if ((err
= snd_cs4231_timer(cs4231
, 2, NULL
)) < 0)
737 if ((err
= snd_cs4231_mixer(cs4231
)) < 0)
740 if (pcm_channels
[dev
] > 0) {
741 if ((err
= snd_gf1_pcm_new(gus
, 1, 1, NULL
)) < 0)
744 if ((err
= snd_interwave_mixer(cs4231
)) < 0)
749 struct snd_ctl_elem_id id1
, id2
;
750 memset(&id1
, 0, sizeof(id1
));
751 memset(&id2
, 0, sizeof(id2
));
752 id1
.iface
= id2
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
753 strcpy(id1
.name
, "Master Playback Switch");
754 strcpy(id2
.name
, id1
.name
);
756 if ((err
= snd_ctl_rename_id(card
, &id1
, &id2
)) < 0)
758 strcpy(id1
.name
, "Master Playback Volume");
759 strcpy(id2
.name
, id1
.name
);
760 if ((err
= snd_ctl_rename_id(card
, &id1
, &id2
)) < 0)
762 if ((err
= snd_tea6330t_update_mixer(card
, i2c_bus
, 0, 1)) < 0)
767 gus
->uart_enable
= midi
[dev
];
768 if ((err
= snd_gf1_rawmidi_new(gus
, 0, NULL
)) < 0)
772 str
= "AMD InterWave";
773 if (gus
->gf1
.rom_banks
== 1 && gus
->gf1
.rom_present
== 8)
774 str
= "Dynasonic 3-D";
776 str
= "InterWave STB";
778 strcpy(card
->driver
, str
);
779 strcpy(card
->shortname
, str
);
780 sprintf(card
->longname
, "%s at 0x%lx, irq %i, dma %d",
786 sprintf(card
->longname
+ strlen(card
->longname
), "&%d", xdma2
);
788 if ((err
= snd_card_register(card
)) < 0)
791 iwcard
->cs4231
= cs4231
;
796 static int __devinit
snd_interwave_nonpnp_probe1(int dev
, struct platform_device
*devptr
)
798 struct snd_card
*card
;
801 card
= snd_interwave_card_new(dev
);
805 snd_card_set_dev(card
, &devptr
->dev
);
806 if ((err
= snd_interwave_probe(card
, dev
)) < 0) {
810 platform_set_drvdata(devptr
, card
);
814 static int __devinit
snd_interwave_nonpnp_probe(struct platform_device
*pdev
)
818 static int possible_irqs
[] = {5, 11, 12, 9, 7, 15, 3, -1};
819 static int possible_dmas
[] = {0, 1, 3, 5, 6, 7, -1};
821 if (irq
[dev
] == SNDRV_AUTO_IRQ
) {
822 if ((irq
[dev
] = snd_legacy_find_free_irq(possible_irqs
)) < 0) {
823 snd_printk(KERN_ERR PFX
"unable to find a free IRQ\n");
827 if (dma1
[dev
] == SNDRV_AUTO_DMA
) {
828 if ((dma1
[dev
] = snd_legacy_find_free_dma(possible_dmas
)) < 0) {
829 snd_printk(KERN_ERR PFX
"unable to find a free DMA1\n");
833 if (dma2
[dev
] == SNDRV_AUTO_DMA
) {
834 if ((dma2
[dev
] = snd_legacy_find_free_dma(possible_dmas
)) < 0) {
835 snd_printk(KERN_ERR PFX
"unable to find a free DMA2\n");
840 if (port
[dev
] != SNDRV_AUTO_PORT
)
841 return snd_interwave_nonpnp_probe1(dev
, pdev
);
843 static long possible_ports
[] = {0x210, 0x220, 0x230, 0x240, 0x250, 0x260};
845 for (i
= 0; i
< ARRAY_SIZE(possible_ports
); i
++) {
846 port
[dev
] = possible_ports
[i
];
847 err
= snd_interwave_nonpnp_probe1(dev
, pdev
);
855 static int __devexit
snd_interwave_nonpnp_remove(struct platform_device
*devptr
)
857 snd_card_free(platform_get_drvdata(devptr
));
858 platform_set_drvdata(devptr
, NULL
);
862 static struct platform_driver snd_interwave_driver
= {
863 .probe
= snd_interwave_nonpnp_probe
,
864 .remove
= __devexit_p(snd_interwave_nonpnp_remove
),
865 /* FIXME: suspend,resume */
867 .name
= INTERWAVE_DRIVER
872 static unsigned int __devinitdata interwave_pnp_devices
;
874 static int __devinit
snd_interwave_pnp_detect(struct pnp_card_link
*pcard
,
875 const struct pnp_card_device_id
*pid
)
878 struct snd_card
*card
;
881 for ( ; dev
< SNDRV_CARDS
; dev
++) {
882 if (enable
[dev
] && isapnp
[dev
])
885 if (dev
>= SNDRV_CARDS
)
888 card
= snd_interwave_card_new(dev
);
892 if ((res
= snd_interwave_pnp(dev
, card
->private_data
, pcard
, pid
)) < 0) {
896 snd_card_set_dev(card
, &pcard
->card
->dev
);
897 if ((res
= snd_interwave_probe(card
, dev
)) < 0) {
901 pnp_set_card_drvdata(pcard
, card
);
903 interwave_pnp_devices
++;
907 static void __devexit
snd_interwave_pnp_remove(struct pnp_card_link
* pcard
)
909 snd_card_free(pnp_get_card_drvdata(pcard
));
910 pnp_set_card_drvdata(pcard
, NULL
);
913 static struct pnp_card_driver interwave_pnpc_driver
= {
914 .flags
= PNP_DRIVER_RES_DISABLE
,
915 .name
= INTERWAVE_PNP_DRIVER
,
916 .id_table
= snd_interwave_pnpids
,
917 .probe
= snd_interwave_pnp_detect
,
918 .remove
= __devexit_p(snd_interwave_pnp_remove
),
919 /* FIXME: suspend,resume */
922 #endif /* CONFIG_PNP */
924 static void __init_or_module
snd_interwave_unregister_all(void)
929 pnp_unregister_card_driver(&interwave_pnpc_driver
);
930 for (i
= 0; i
< ARRAY_SIZE(platform_devices
); ++i
)
931 platform_device_unregister(platform_devices
[i
]);
932 platform_driver_unregister(&snd_interwave_driver
);
935 static int __init
alsa_card_interwave_init(void)
937 int i
, err
, cards
= 0;
939 if ((err
= platform_driver_register(&snd_interwave_driver
)) < 0)
942 for (i
= 0; i
< SNDRV_CARDS
; i
++) {
943 struct platform_device
*device
;
950 device
= platform_device_register_simple(INTERWAVE_DRIVER
,
954 if (!platform_get_drvdata(device
)) {
955 platform_device_unregister(device
);
958 platform_devices
[i
] = device
;
963 err
= pnp_register_card_driver(&interwave_pnpc_driver
);
966 cards
+= interwave_pnp_devices
;;
971 printk(KERN_ERR
"InterWave soundcard not found or device busy\n");
973 snd_interwave_unregister_all();
979 static void __exit
alsa_card_interwave_exit(void)
981 snd_interwave_unregister_all();
984 module_init(alsa_card_interwave_init
)
985 module_exit(alsa_card_interwave_exit
)