2 * Driver for C-Media's CMI8330 soundcards.
3 * Copyright (c) by George Talusan <gstalusan@uwaterloo.ca>
4 * http://www.undergrad.math.uwaterloo.ca/~gstalusa
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
25 * The extended registers contain mixer settings which are largely
26 * untapped for the time being.
28 * MPU401 and SPDIF are not supported yet. I don't have the hardware
29 * to aid in coding and testing, so I won't bother.
31 * To quickly load the module,
33 * modprobe -a snd-cmi8330 sbport=0x220 sbirq=5 sbdma8=1
34 * sbdma16=5 wssport=0x530 wssirq=11 wssdma=0
36 * This card has two mixers and two PCM devices. I've cheesed it such
37 * that recording and playback can be done through the same device.
38 * The driver "magically" routes the capturing to the AD1848 codec,
39 * and playback to the SB16 codec. This allows for full-duplex mode
41 * The utilities in alsa-utils are aware of both devices, so passing
42 * the appropriate parameters to amixer and alsactl will give you
43 * full control over both mixers.
46 #include <sound/driver.h>
47 #include <linux/init.h>
48 #include <linux/err.h>
49 #include <linux/isa.h>
50 #include <linux/slab.h>
51 #include <linux/pnp.h>
52 #include <linux/moduleparam.h>
53 #include <sound/core.h>
54 #include <sound/ad1848.h>
56 #include <sound/initval.h>
60 /* #define ENABLE_SB_MIXER */
61 #define PLAYBACK_ON_SB
65 MODULE_AUTHOR("George Talusan <gstalusan@uwaterloo.ca>");
66 MODULE_DESCRIPTION("C-Media CMI8330");
67 MODULE_LICENSE("GPL");
68 MODULE_SUPPORTED_DEVICE("{{C-Media,CMI8330,isapnp:{CMI0001,@@@0001,@X@0001}}}");
70 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
;
71 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
;
72 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_ISAPNP
;
74 static int isapnp
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = 1};
76 static long sbport
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
;
77 static int sbirq
[SNDRV_CARDS
] = SNDRV_DEFAULT_IRQ
;
78 static int sbdma8
[SNDRV_CARDS
] = SNDRV_DEFAULT_DMA
;
79 static int sbdma16
[SNDRV_CARDS
] = SNDRV_DEFAULT_DMA
;
80 static long wssport
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
;
81 static int wssirq
[SNDRV_CARDS
] = SNDRV_DEFAULT_IRQ
;
82 static int wssdma
[SNDRV_CARDS
] = SNDRV_DEFAULT_DMA
;
84 module_param_array(index
, int, NULL
, 0444);
85 MODULE_PARM_DESC(index
, "Index value for CMI8330 soundcard.");
86 module_param_array(id
, charp
, NULL
, 0444);
87 MODULE_PARM_DESC(id
, "ID string for CMI8330 soundcard.");
88 module_param_array(enable
, bool, NULL
, 0444);
89 MODULE_PARM_DESC(enable
, "Enable CMI8330 soundcard.");
91 module_param_array(isapnp
, bool, NULL
, 0444);
92 MODULE_PARM_DESC(isapnp
, "PnP detection for specified soundcard.");
95 module_param_array(sbport
, long, NULL
, 0444);
96 MODULE_PARM_DESC(sbport
, "Port # for CMI8330 SB driver.");
97 module_param_array(sbirq
, int, NULL
, 0444);
98 MODULE_PARM_DESC(sbirq
, "IRQ # for CMI8330 SB driver.");
99 module_param_array(sbdma8
, int, NULL
, 0444);
100 MODULE_PARM_DESC(sbdma8
, "DMA8 for CMI8330 SB driver.");
101 module_param_array(sbdma16
, int, NULL
, 0444);
102 MODULE_PARM_DESC(sbdma16
, "DMA16 for CMI8330 SB driver.");
104 module_param_array(wssport
, long, NULL
, 0444);
105 MODULE_PARM_DESC(wssport
, "Port # for CMI8330 WSS driver.");
106 module_param_array(wssirq
, int, NULL
, 0444);
107 MODULE_PARM_DESC(wssirq
, "IRQ # for CMI8330 WSS driver.");
108 module_param_array(wssdma
, int, NULL
, 0444);
109 MODULE_PARM_DESC(wssdma
, "DMA for CMI8330 WSS driver.");
112 static int pnp_registered
;
115 #define CMI8330_RMUX3D 16
116 #define CMI8330_MUTEMUX 17
117 #define CMI8330_OUTPUTVOL 18
118 #define CMI8330_MASTVOL 19
119 #define CMI8330_LINVOL 20
120 #define CMI8330_CDINVOL 21
121 #define CMI8330_WAVVOL 22
122 #define CMI8330_RECMUX 23
123 #define CMI8330_WAVGAIN 24
124 #define CMI8330_LINGAIN 25
125 #define CMI8330_CDINGAIN 26
127 static unsigned char snd_cmi8330_image
[((CMI8330_CDINGAIN
)-16) + 1] =
129 0x40, /* 16 - recording mux (SB-mixer-enabled) */
130 #ifdef ENABLE_SB_MIXER
131 0x40, /* 17 - mute mux (Mode2) */
133 0x0, /* 17 - mute mux */
136 0x0, /* 19 - master volume */
137 0x0, /* 20 - line-in volume */
138 0x0, /* 21 - cd-in volume */
139 0x0, /* 22 - wave volume */
140 0x0, /* 23 - mute/rec mux */
141 0x0, /* 24 - wave rec gain */
142 0x0, /* 25 - line-in rec gain */
143 0x0 /* 26 - cd-in rec gain */
146 typedef int (*snd_pcm_open_callback_t
)(struct snd_pcm_substream
*);
151 struct pnp_dev
*play
;
153 struct snd_card
*card
;
154 struct snd_ad1848
*wss
;
158 struct snd_cmi8330_stream
{
159 struct snd_pcm_ops ops
;
160 snd_pcm_open_callback_t open
;
161 void *private_data
; /* sb or wss */
167 static struct pnp_card_device_id snd_cmi8330_pnpids
[] = {
168 { .id
= "CMI0001", .devs
= { { "@@@0001" }, { "@X@0001" } } },
172 MODULE_DEVICE_TABLE(pnp_card
, snd_cmi8330_pnpids
);
177 static struct ad1848_mix_elem snd_cmi8330_controls
[] __devinitdata
= {
178 AD1848_DOUBLE("Master Playback Volume", 0, CMI8330_MASTVOL
, CMI8330_MASTVOL
, 4, 0, 15, 0),
179 AD1848_SINGLE("Loud Playback Switch", 0, CMI8330_MUTEMUX
, 6, 1, 1),
180 AD1848_DOUBLE("PCM Playback Switch", 0, AD1848_LEFT_OUTPUT
, AD1848_RIGHT_OUTPUT
, 7, 7, 1, 1),
181 AD1848_DOUBLE("PCM Playback Volume", 0, AD1848_LEFT_OUTPUT
, AD1848_RIGHT_OUTPUT
, 0, 0, 63, 1),
182 AD1848_DOUBLE("Line Playback Switch", 0, CMI8330_MUTEMUX
, CMI8330_MUTEMUX
, 4, 3, 1, 0),
183 AD1848_DOUBLE("Line Playback Volume", 0, CMI8330_LINVOL
, CMI8330_LINVOL
, 4, 0, 15, 0),
184 AD1848_DOUBLE("Line Capture Switch", 0, CMI8330_RMUX3D
, CMI8330_RMUX3D
, 2, 1, 1, 0),
185 AD1848_DOUBLE("Line Capture Volume", 0, CMI8330_LINGAIN
, CMI8330_LINGAIN
, 4, 0, 15, 0),
186 AD1848_DOUBLE("CD Playback Switch", 0, CMI8330_MUTEMUX
, CMI8330_MUTEMUX
, 2, 1, 1, 0),
187 AD1848_DOUBLE("CD Capture Switch", 0, CMI8330_RMUX3D
, CMI8330_RMUX3D
, 4, 3, 1, 0),
188 AD1848_DOUBLE("CD Playback Volume", 0, CMI8330_CDINVOL
, CMI8330_CDINVOL
, 4, 0, 15, 0),
189 AD1848_DOUBLE("CD Capture Volume", 0, CMI8330_CDINGAIN
, CMI8330_CDINGAIN
, 4, 0, 15, 0),
190 AD1848_SINGLE("Mic Playback Switch", 0, CMI8330_MUTEMUX
, 0, 1, 0),
191 AD1848_SINGLE("Mic Playback Volume", 0, CMI8330_OUTPUTVOL
, 0, 7, 0),
192 AD1848_SINGLE("Mic Capture Switch", 0, CMI8330_RMUX3D
, 0, 1, 0),
193 AD1848_SINGLE("Mic Capture Volume", 0, CMI8330_OUTPUTVOL
, 5, 7, 0),
194 AD1848_DOUBLE("Wavetable Playback Switch", 0, CMI8330_RECMUX
, CMI8330_RECMUX
, 1, 0, 1, 0),
195 AD1848_DOUBLE("Wavetable Playback Volume", 0, CMI8330_WAVVOL
, CMI8330_WAVVOL
, 4, 0, 15, 0),
196 AD1848_DOUBLE("Wavetable Capture Switch", 0, CMI8330_RECMUX
, CMI8330_RECMUX
, 5, 4, 1, 0),
197 AD1848_DOUBLE("Wavetable Capture Volume", 0, CMI8330_WAVGAIN
, CMI8330_WAVGAIN
, 4, 0, 15, 0),
198 AD1848_SINGLE("3D Control - Switch", 0, CMI8330_RMUX3D
, 5, 1, 1),
199 AD1848_SINGLE("PC Speaker Playback Volume", 0, CMI8330_OUTPUTVOL
, 3, 3, 0),
200 AD1848_SINGLE("FM Playback Switch", 0, CMI8330_RECMUX
, 3, 1, 1),
201 AD1848_SINGLE(SNDRV_CTL_NAME_IEC958("Input ",CAPTURE
,SWITCH
), 0, CMI8330_RMUX3D
, 7, 1, 1),
202 AD1848_SINGLE(SNDRV_CTL_NAME_IEC958("Input ",PLAYBACK
,SWITCH
), 0, CMI8330_MUTEMUX
, 7, 1, 1),
205 #ifdef ENABLE_SB_MIXER
206 static struct sbmix_elem cmi8330_sb_mixers
[] __devinitdata
= {
207 SB_DOUBLE("SB Master Playback Volume", SB_DSP4_MASTER_DEV
, (SB_DSP4_MASTER_DEV
+ 1), 3, 3, 31),
208 SB_DOUBLE("Tone Control - Bass", SB_DSP4_BASS_DEV
, (SB_DSP4_BASS_DEV
+ 1), 4, 4, 15),
209 SB_DOUBLE("Tone Control - Treble", SB_DSP4_TREBLE_DEV
, (SB_DSP4_TREBLE_DEV
+ 1), 4, 4, 15),
210 SB_DOUBLE("SB PCM Playback Volume", SB_DSP4_PCM_DEV
, (SB_DSP4_PCM_DEV
+ 1), 3, 3, 31),
211 SB_DOUBLE("SB Synth Playback Volume", SB_DSP4_SYNTH_DEV
, (SB_DSP4_SYNTH_DEV
+ 1), 3, 3, 31),
212 SB_DOUBLE("SB CD Playback Switch", SB_DSP4_OUTPUT_SW
, SB_DSP4_OUTPUT_SW
, 2, 1, 1),
213 SB_DOUBLE("SB CD Playback Volume", SB_DSP4_CD_DEV
, (SB_DSP4_CD_DEV
+ 1), 3, 3, 31),
214 SB_DOUBLE("SB Line Playback Switch", SB_DSP4_OUTPUT_SW
, SB_DSP4_OUTPUT_SW
, 4, 3, 1),
215 SB_DOUBLE("SB Line Playback Volume", SB_DSP4_LINE_DEV
, (SB_DSP4_LINE_DEV
+ 1), 3, 3, 31),
216 SB_SINGLE("SB Mic Playback Switch", SB_DSP4_OUTPUT_SW
, 0, 1),
217 SB_SINGLE("SB Mic Playback Volume", SB_DSP4_MIC_DEV
, 3, 31),
218 SB_SINGLE("SB PC Speaker Volume", SB_DSP4_SPEAKER_DEV
, 6, 3),
219 SB_DOUBLE("SB Capture Volume", SB_DSP4_IGAIN_DEV
, (SB_DSP4_IGAIN_DEV
+ 1), 6, 6, 3),
220 SB_DOUBLE("SB Playback Volume", SB_DSP4_OGAIN_DEV
, (SB_DSP4_OGAIN_DEV
+ 1), 6, 6, 3),
221 SB_SINGLE("SB Mic Auto Gain", SB_DSP4_MIC_AGC
, 0, 1),
224 static unsigned char cmi8330_sb_init_values
[][2] __devinitdata
= {
225 { SB_DSP4_MASTER_DEV
+ 0, 0 },
226 { SB_DSP4_MASTER_DEV
+ 1, 0 },
227 { SB_DSP4_PCM_DEV
+ 0, 0 },
228 { SB_DSP4_PCM_DEV
+ 1, 0 },
229 { SB_DSP4_SYNTH_DEV
+ 0, 0 },
230 { SB_DSP4_SYNTH_DEV
+ 1, 0 },
231 { SB_DSP4_INPUT_LEFT
, 0 },
232 { SB_DSP4_INPUT_RIGHT
, 0 },
233 { SB_DSP4_OUTPUT_SW
, 0 },
234 { SB_DSP4_SPEAKER_DEV
, 0 },
238 static int __devinit
cmi8330_add_sb_mixers(struct snd_sb
*chip
)
243 spin_lock_irqsave(&chip
->mixer_lock
, flags
);
244 snd_sbmixer_write(chip
, 0x00, 0x00); /* mixer reset */
245 spin_unlock_irqrestore(&chip
->mixer_lock
, flags
);
247 /* mute and zero volume channels */
248 for (idx
= 0; idx
< ARRAY_SIZE(cmi8330_sb_init_values
); idx
++) {
249 spin_lock_irqsave(&chip
->mixer_lock
, flags
);
250 snd_sbmixer_write(chip
, cmi8330_sb_init_values
[idx
][0],
251 cmi8330_sb_init_values
[idx
][1]);
252 spin_unlock_irqrestore(&chip
->mixer_lock
, flags
);
255 for (idx
= 0; idx
< ARRAY_SIZE(cmi8330_sb_mixers
); idx
++) {
256 if ((err
= snd_sbmixer_add_ctl_elem(chip
, &cmi8330_sb_mixers
[idx
])) < 0)
263 static int __devinit
snd_cmi8330_mixer(struct snd_card
*card
, struct snd_cmi8330
*acard
)
268 strcpy(card
->mixername
, "CMI8330/C3D");
270 for (idx
= 0; idx
< ARRAY_SIZE(snd_cmi8330_controls
); idx
++) {
271 if ((err
= snd_ad1848_add_ctl_elem(acard
->wss
, &snd_cmi8330_controls
[idx
])) < 0)
275 #ifdef ENABLE_SB_MIXER
276 if ((err
= cmi8330_add_sb_mixers(acard
->sb
)) < 0)
283 static int __devinit
snd_cmi8330_pnp(int dev
, struct snd_cmi8330
*acard
,
284 struct pnp_card_link
*card
,
285 const struct pnp_card_device_id
*id
)
287 struct pnp_dev
*pdev
;
288 struct pnp_resource_table
* cfg
= kmalloc(sizeof(struct pnp_resource_table
), GFP_KERNEL
);
293 acard
->cap
= pnp_request_card_device(card
, id
->devs
[0].id
, NULL
);
294 if (acard
->cap
== NULL
) {
298 acard
->play
= pnp_request_card_device(card
, id
->devs
[1].id
, NULL
);
299 if (acard
->play
== NULL
) {
305 pnp_init_resource_table(cfg
);
306 /* allocate AD1848 resources */
307 if (wssport
[dev
] != SNDRV_AUTO_PORT
)
308 pnp_resource_change(&cfg
->port_resource
[0], wssport
[dev
], 8);
309 if (wssdma
[dev
] != SNDRV_AUTO_DMA
)
310 pnp_resource_change(&cfg
->dma_resource
[0], wssdma
[dev
], 1);
311 if (wssirq
[dev
] != SNDRV_AUTO_IRQ
)
312 pnp_resource_change(&cfg
->irq_resource
[0], wssirq
[dev
], 1);
314 err
= pnp_manual_config_dev(pdev
, cfg
, 0);
316 snd_printk(KERN_ERR
"CMI8330/C3D (AD1848) PnP manual resources are invalid, using auto config\n");
317 err
= pnp_activate_dev(pdev
);
319 snd_printk(KERN_ERR
"CMI8330/C3D (AD1848) PnP configure failure\n");
323 wssport
[dev
] = pnp_port_start(pdev
, 0);
324 wssdma
[dev
] = pnp_dma(pdev
, 0);
325 wssirq
[dev
] = pnp_irq(pdev
, 0);
327 /* allocate SB16 resources */
329 pnp_init_resource_table(cfg
);
330 if (sbport
[dev
] != SNDRV_AUTO_PORT
)
331 pnp_resource_change(&cfg
->port_resource
[0], sbport
[dev
], 16);
332 if (sbdma8
[dev
] != SNDRV_AUTO_DMA
)
333 pnp_resource_change(&cfg
->dma_resource
[0], sbdma8
[dev
], 1);
334 if (sbdma16
[dev
] != SNDRV_AUTO_DMA
)
335 pnp_resource_change(&cfg
->dma_resource
[1], sbdma16
[dev
], 1);
336 if (sbirq
[dev
] != SNDRV_AUTO_IRQ
)
337 pnp_resource_change(&cfg
->irq_resource
[0], sbirq
[dev
], 1);
339 err
= pnp_manual_config_dev(pdev
, cfg
, 0);
341 snd_printk(KERN_ERR
"CMI8330/C3D (SB16) PnP manual resources are invalid, using auto config\n");
342 err
= pnp_activate_dev(pdev
);
344 snd_printk(KERN_ERR
"CMI8330/C3D (SB16) PnP configure failure\n");
348 sbport
[dev
] = pnp_port_start(pdev
, 0);
349 sbdma8
[dev
] = pnp_dma(pdev
, 0);
350 sbdma16
[dev
] = pnp_dma(pdev
, 1);
351 sbirq
[dev
] = pnp_irq(pdev
, 0);
361 * since we call the different chip interfaces for playback and capture
362 * directions, we need a trick.
364 * - copy the ops for each direction into a local record.
365 * - replace the open callback with the new one, which replaces the
366 * substream->private_data with the corresponding chip instance
367 * and calls again the original open callback of the chip.
371 #ifdef PLAYBACK_ON_SB
372 #define CMI_SB_STREAM SNDRV_PCM_STREAM_PLAYBACK
373 #define CMI_AD_STREAM SNDRV_PCM_STREAM_CAPTURE
375 #define CMI_SB_STREAM SNDRV_PCM_STREAM_CAPTURE
376 #define CMI_AD_STREAM SNDRV_PCM_STREAM_PLAYBACK
379 static int snd_cmi8330_playback_open(struct snd_pcm_substream
*substream
)
381 struct snd_cmi8330
*chip
= snd_pcm_substream_chip(substream
);
383 /* replace the private_data and call the original open callback */
384 substream
->private_data
= chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].private_data
;
385 return chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].open(substream
);
388 static int snd_cmi8330_capture_open(struct snd_pcm_substream
*substream
)
390 struct snd_cmi8330
*chip
= snd_pcm_substream_chip(substream
);
392 /* replace the private_data and call the original open callback */
393 substream
->private_data
= chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
].private_data
;
394 return chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
].open(substream
);
397 static int __devinit
snd_cmi8330_pcm(struct snd_card
*card
, struct snd_cmi8330
*chip
)
400 const struct snd_pcm_ops
*ops
;
402 static snd_pcm_open_callback_t cmi_open_callbacks
[2] = {
403 snd_cmi8330_playback_open
,
404 snd_cmi8330_capture_open
407 if ((err
= snd_pcm_new(card
, "CMI8330", 0, 1, 1, &pcm
)) < 0)
409 strcpy(pcm
->name
, "CMI8330");
410 pcm
->private_data
= chip
;
413 ops
= snd_sb16dsp_get_pcm_ops(CMI_SB_STREAM
);
414 chip
->streams
[CMI_SB_STREAM
].ops
= *ops
;
415 chip
->streams
[CMI_SB_STREAM
].open
= ops
->open
;
416 chip
->streams
[CMI_SB_STREAM
].ops
.open
= cmi_open_callbacks
[CMI_SB_STREAM
];
417 chip
->streams
[CMI_SB_STREAM
].private_data
= chip
->sb
;
420 ops
= snd_ad1848_get_pcm_ops(CMI_AD_STREAM
);
421 chip
->streams
[CMI_AD_STREAM
].ops
= *ops
;
422 chip
->streams
[CMI_AD_STREAM
].open
= ops
->open
;
423 chip
->streams
[CMI_AD_STREAM
].ops
.open
= cmi_open_callbacks
[CMI_AD_STREAM
];
424 chip
->streams
[CMI_AD_STREAM
].private_data
= chip
->wss
;
426 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].ops
);
427 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
].ops
);
429 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
439 static int snd_cmi8330_suspend(struct snd_card
*card
)
441 struct snd_cmi8330
*acard
= card
->private_data
;
443 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
444 snd_pcm_suspend_all(acard
->pcm
);
445 acard
->wss
->suspend(acard
->wss
);
446 snd_sbmixer_suspend(acard
->sb
);
450 static int snd_cmi8330_resume(struct snd_card
*card
)
452 struct snd_cmi8330
*acard
= card
->private_data
;
454 snd_sbdsp_reset(acard
->sb
);
455 snd_sbmixer_suspend(acard
->sb
);
456 acard
->wss
->resume(acard
->wss
);
457 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
467 #define is_isapnp_selected(dev) isapnp[dev]
469 #define is_isapnp_selected(dev) 0
472 #define PFX "cmi8330: "
474 static struct snd_card
*snd_cmi8330_card_new(int dev
)
476 struct snd_card
*card
;
477 struct snd_cmi8330
*acard
;
479 card
= snd_card_new(index
[dev
], id
[dev
], THIS_MODULE
,
480 sizeof(struct snd_cmi8330
));
482 snd_printk(KERN_ERR PFX
"could not get a new card\n");
485 acard
= card
->private_data
;
490 static int __devinit
snd_cmi8330_probe(struct snd_card
*card
, int dev
)
492 struct snd_cmi8330
*acard
;
495 acard
= card
->private_data
;
496 if ((err
= snd_ad1848_create(card
,
502 snd_printk(KERN_ERR PFX
"(AD1848) device busy??\n");
505 if (acard
->wss
->hardware
!= AD1848_HW_CMI8330
) {
506 snd_printk(KERN_ERR PFX
"(AD1848) not found during probe\n");
510 if ((err
= snd_sbdsp_create(card
, sbport
[dev
],
512 snd_sb16dsp_interrupt
,
515 SB_HW_AUTO
, &acard
->sb
)) < 0) {
516 snd_printk(KERN_ERR PFX
"(SB16) device busy??\n");
519 if (acard
->sb
->hardware
!= SB_HW_16
) {
520 snd_printk(KERN_ERR PFX
"(SB16) not found during probe\n");
524 snd_ad1848_out(acard
->wss
, AD1848_MISC_INFO
, 0x40); /* switch on MODE2 */
525 for (i
= CMI8330_RMUX3D
; i
<= CMI8330_CDINGAIN
; i
++)
526 snd_ad1848_out(acard
->wss
, i
, snd_cmi8330_image
[i
- CMI8330_RMUX3D
]);
528 if ((err
= snd_cmi8330_mixer(card
, acard
)) < 0) {
529 snd_printk(KERN_ERR PFX
"failed to create mixers\n");
533 if ((err
= snd_cmi8330_pcm(card
, acard
)) < 0) {
534 snd_printk(KERN_ERR PFX
"failed to create pcms\n");
538 strcpy(card
->driver
, "CMI8330/C3D");
539 strcpy(card
->shortname
, "C-Media CMI8330/C3D");
540 sprintf(card
->longname
, "%s at 0x%lx, irq %d, dma %d",
546 return snd_card_register(card
);
549 static int __devinit
snd_cmi8330_isa_match(struct device
*pdev
,
552 if (!enable
[dev
] || is_isapnp_selected(dev
))
554 if (wssport
[dev
] == SNDRV_AUTO_PORT
) {
555 snd_printk(KERN_ERR PFX
"specify wssport\n");
558 if (sbport
[dev
] == SNDRV_AUTO_PORT
) {
559 snd_printk(KERN_ERR PFX
"specify sbport\n");
565 static int __devinit
snd_cmi8330_isa_probe(struct device
*pdev
,
568 struct snd_card
*card
;
571 card
= snd_cmi8330_card_new(dev
);
574 snd_card_set_dev(card
, pdev
);
575 if ((err
= snd_cmi8330_probe(card
, dev
)) < 0) {
579 dev_set_drvdata(pdev
, card
);
583 static int __devexit
snd_cmi8330_isa_remove(struct device
*devptr
,
586 snd_card_free(dev_get_drvdata(devptr
));
587 dev_set_drvdata(devptr
, NULL
);
592 static int snd_cmi8330_isa_suspend(struct device
*dev
, unsigned int n
,
595 return snd_cmi8330_suspend(dev_get_drvdata(dev
));
598 static int snd_cmi8330_isa_resume(struct device
*dev
, unsigned int n
)
600 return snd_cmi8330_resume(dev_get_drvdata(dev
));
604 #define DEV_NAME "cmi8330"
606 static struct isa_driver snd_cmi8330_driver
= {
607 .match
= snd_cmi8330_isa_match
,
608 .probe
= snd_cmi8330_isa_probe
,
609 .remove
= __devexit_p(snd_cmi8330_isa_remove
),
611 .suspend
= snd_cmi8330_isa_suspend
,
612 .resume
= snd_cmi8330_isa_resume
,
621 static int __devinit
snd_cmi8330_pnp_detect(struct pnp_card_link
*pcard
,
622 const struct pnp_card_device_id
*pid
)
625 struct snd_card
*card
;
628 for ( ; dev
< SNDRV_CARDS
; dev
++) {
629 if (enable
[dev
] && isapnp
[dev
])
632 if (dev
>= SNDRV_CARDS
)
635 card
= snd_cmi8330_card_new(dev
);
638 if ((res
= snd_cmi8330_pnp(dev
, card
->private_data
, pcard
, pid
)) < 0) {
639 snd_printk(KERN_ERR PFX
"PnP detection failed\n");
643 snd_card_set_dev(card
, &pcard
->card
->dev
);
644 if ((res
= snd_cmi8330_probe(card
, dev
)) < 0) {
648 pnp_set_card_drvdata(pcard
, card
);
653 static void __devexit
snd_cmi8330_pnp_remove(struct pnp_card_link
* pcard
)
655 snd_card_free(pnp_get_card_drvdata(pcard
));
656 pnp_set_card_drvdata(pcard
, NULL
);
660 static int snd_cmi8330_pnp_suspend(struct pnp_card_link
*pcard
, pm_message_t state
)
662 return snd_cmi8330_suspend(pnp_get_card_drvdata(pcard
));
665 static int snd_cmi8330_pnp_resume(struct pnp_card_link
*pcard
)
667 return snd_cmi8330_resume(pnp_get_card_drvdata(pcard
));
671 static struct pnp_card_driver cmi8330_pnpc_driver
= {
672 .flags
= PNP_DRIVER_RES_DISABLE
,
674 .id_table
= snd_cmi8330_pnpids
,
675 .probe
= snd_cmi8330_pnp_detect
,
676 .remove
= __devexit_p(snd_cmi8330_pnp_remove
),
678 .suspend
= snd_cmi8330_pnp_suspend
,
679 .resume
= snd_cmi8330_pnp_resume
,
682 #endif /* CONFIG_PNP */
684 static int __init
alsa_card_cmi8330_init(void)
688 err
= isa_register_driver(&snd_cmi8330_driver
, SNDRV_CARDS
);
692 err
= pnp_register_card_driver(&cmi8330_pnpc_driver
);
699 static void __exit
alsa_card_cmi8330_exit(void)
703 pnp_unregister_card_driver(&cmi8330_pnpc_driver
);
705 isa_unregister_driver(&snd_cmi8330_driver
);
708 module_init(alsa_card_cmi8330_init
)
709 module_exit(alsa_card_cmi8330_exit
)