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/platform_device.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.");
111 #define CMI8330_RMUX3D 16
112 #define CMI8330_MUTEMUX 17
113 #define CMI8330_OUTPUTVOL 18
114 #define CMI8330_MASTVOL 19
115 #define CMI8330_LINVOL 20
116 #define CMI8330_CDINVOL 21
117 #define CMI8330_WAVVOL 22
118 #define CMI8330_RECMUX 23
119 #define CMI8330_WAVGAIN 24
120 #define CMI8330_LINGAIN 25
121 #define CMI8330_CDINGAIN 26
123 static unsigned char snd_cmi8330_image
[((CMI8330_CDINGAIN
)-16) + 1] =
125 0x40, /* 16 - recording mux (SB-mixer-enabled) */
126 #ifdef ENABLE_SB_MIXER
127 0x40, /* 17 - mute mux (Mode2) */
129 0x0, /* 17 - mute mux */
132 0x0, /* 19 - master volume */
133 0x0, /* 20 - line-in volume */
134 0x0, /* 21 - cd-in volume */
135 0x0, /* 22 - wave volume */
136 0x0, /* 23 - mute/rec mux */
137 0x0, /* 24 - wave rec gain */
138 0x0, /* 25 - line-in rec gain */
139 0x0 /* 26 - cd-in rec gain */
142 typedef int (*snd_pcm_open_callback_t
)(struct snd_pcm_substream
*);
147 struct pnp_dev
*play
;
149 struct snd_card
*card
;
150 struct snd_ad1848
*wss
;
154 struct snd_cmi8330_stream
{
155 struct snd_pcm_ops ops
;
156 snd_pcm_open_callback_t open
;
157 void *private_data
; /* sb or wss */
163 static struct pnp_card_device_id snd_cmi8330_pnpids
[] = {
164 { .id
= "CMI0001", .devs
= { { "@@@0001" }, { "@X@0001" } } },
168 MODULE_DEVICE_TABLE(pnp_card
, snd_cmi8330_pnpids
);
173 static struct ad1848_mix_elem snd_cmi8330_controls
[] __initdata
= {
174 AD1848_DOUBLE("Master Playback Volume", 0, CMI8330_MASTVOL
, CMI8330_MASTVOL
, 4, 0, 15, 0),
175 AD1848_SINGLE("Loud Playback Switch", 0, CMI8330_MUTEMUX
, 6, 1, 1),
176 AD1848_DOUBLE("PCM Playback Switch", 0, AD1848_LEFT_OUTPUT
, AD1848_RIGHT_OUTPUT
, 7, 7, 1, 1),
177 AD1848_DOUBLE("PCM Playback Volume", 0, AD1848_LEFT_OUTPUT
, AD1848_RIGHT_OUTPUT
, 0, 0, 63, 1),
178 AD1848_DOUBLE("Line Playback Switch", 0, CMI8330_MUTEMUX
, CMI8330_MUTEMUX
, 4, 3, 1, 0),
179 AD1848_DOUBLE("Line Playback Volume", 0, CMI8330_LINVOL
, CMI8330_LINVOL
, 4, 0, 15, 0),
180 AD1848_DOUBLE("Line Capture Switch", 0, CMI8330_RMUX3D
, CMI8330_RMUX3D
, 2, 1, 1, 0),
181 AD1848_DOUBLE("Line Capture Volume", 0, CMI8330_LINGAIN
, CMI8330_LINGAIN
, 4, 0, 15, 0),
182 AD1848_DOUBLE("CD Playback Switch", 0, CMI8330_MUTEMUX
, CMI8330_MUTEMUX
, 2, 1, 1, 0),
183 AD1848_DOUBLE("CD Capture Switch", 0, CMI8330_RMUX3D
, CMI8330_RMUX3D
, 4, 3, 1, 0),
184 AD1848_DOUBLE("CD Playback Volume", 0, CMI8330_CDINVOL
, CMI8330_CDINVOL
, 4, 0, 15, 0),
185 AD1848_DOUBLE("CD Capture Volume", 0, CMI8330_CDINGAIN
, CMI8330_CDINGAIN
, 4, 0, 15, 0),
186 AD1848_SINGLE("Mic Playback Switch", 0, CMI8330_MUTEMUX
, 0, 1, 0),
187 AD1848_SINGLE("Mic Playback Volume", 0, CMI8330_OUTPUTVOL
, 0, 7, 0),
188 AD1848_SINGLE("Mic Capture Switch", 0, CMI8330_RMUX3D
, 0, 1, 0),
189 AD1848_SINGLE("Mic Capture Volume", 0, CMI8330_OUTPUTVOL
, 5, 7, 0),
190 AD1848_DOUBLE("Wavetable Playback Switch", 0, CMI8330_RECMUX
, CMI8330_RECMUX
, 1, 0, 1, 0),
191 AD1848_DOUBLE("Wavetable Playback Volume", 0, CMI8330_WAVVOL
, CMI8330_WAVVOL
, 4, 0, 15, 0),
192 AD1848_DOUBLE("Wavetable Capture Switch", 0, CMI8330_RECMUX
, CMI8330_RECMUX
, 5, 4, 1, 0),
193 AD1848_DOUBLE("Wavetable Capture Volume", 0, CMI8330_WAVGAIN
, CMI8330_WAVGAIN
, 4, 0, 15, 0),
194 AD1848_SINGLE("3D Control - Switch", 0, CMI8330_RMUX3D
, 5, 1, 1),
195 AD1848_SINGLE("PC Speaker Playback Volume", 0, CMI8330_OUTPUTVOL
, 3, 3, 0),
196 AD1848_SINGLE("FM Playback Switch", 0, CMI8330_RECMUX
, 3, 1, 1),
197 AD1848_SINGLE(SNDRV_CTL_NAME_IEC958("Input ",CAPTURE
,SWITCH
), 0, CMI8330_RMUX3D
, 7, 1, 1),
198 AD1848_SINGLE(SNDRV_CTL_NAME_IEC958("Input ",PLAYBACK
,SWITCH
), 0, CMI8330_MUTEMUX
, 7, 1, 1),
201 #ifdef ENABLE_SB_MIXER
202 static struct sbmix_elem cmi8330_sb_mixers
[] __initdata
= {
203 SB_DOUBLE("SB Master Playback Volume", SB_DSP4_MASTER_DEV
, (SB_DSP4_MASTER_DEV
+ 1), 3, 3, 31),
204 SB_DOUBLE("Tone Control - Bass", SB_DSP4_BASS_DEV
, (SB_DSP4_BASS_DEV
+ 1), 4, 4, 15),
205 SB_DOUBLE("Tone Control - Treble", SB_DSP4_TREBLE_DEV
, (SB_DSP4_TREBLE_DEV
+ 1), 4, 4, 15),
206 SB_DOUBLE("SB PCM Playback Volume", SB_DSP4_PCM_DEV
, (SB_DSP4_PCM_DEV
+ 1), 3, 3, 31),
207 SB_DOUBLE("SB Synth Playback Volume", SB_DSP4_SYNTH_DEV
, (SB_DSP4_SYNTH_DEV
+ 1), 3, 3, 31),
208 SB_DOUBLE("SB CD Playback Switch", SB_DSP4_OUTPUT_SW
, SB_DSP4_OUTPUT_SW
, 2, 1, 1),
209 SB_DOUBLE("SB CD Playback Volume", SB_DSP4_CD_DEV
, (SB_DSP4_CD_DEV
+ 1), 3, 3, 31),
210 SB_DOUBLE("SB Line Playback Switch", SB_DSP4_OUTPUT_SW
, SB_DSP4_OUTPUT_SW
, 4, 3, 1),
211 SB_DOUBLE("SB Line Playback Volume", SB_DSP4_LINE_DEV
, (SB_DSP4_LINE_DEV
+ 1), 3, 3, 31),
212 SB_SINGLE("SB Mic Playback Switch", SB_DSP4_OUTPUT_SW
, 0, 1),
213 SB_SINGLE("SB Mic Playback Volume", SB_DSP4_MIC_DEV
, 3, 31),
214 SB_SINGLE("SB PC Speaker Volume", SB_DSP4_SPEAKER_DEV
, 6, 3),
215 SB_DOUBLE("SB Capture Volume", SB_DSP4_IGAIN_DEV
, (SB_DSP4_IGAIN_DEV
+ 1), 6, 6, 3),
216 SB_DOUBLE("SB Playback Volume", SB_DSP4_OGAIN_DEV
, (SB_DSP4_OGAIN_DEV
+ 1), 6, 6, 3),
217 SB_SINGLE("SB Mic Auto Gain", SB_DSP4_MIC_AGC
, 0, 1),
220 static unsigned char cmi8330_sb_init_values
[][2] __initdata
= {
221 { SB_DSP4_MASTER_DEV
+ 0, 0 },
222 { SB_DSP4_MASTER_DEV
+ 1, 0 },
223 { SB_DSP4_PCM_DEV
+ 0, 0 },
224 { SB_DSP4_PCM_DEV
+ 1, 0 },
225 { SB_DSP4_SYNTH_DEV
+ 0, 0 },
226 { SB_DSP4_SYNTH_DEV
+ 1, 0 },
227 { SB_DSP4_INPUT_LEFT
, 0 },
228 { SB_DSP4_INPUT_RIGHT
, 0 },
229 { SB_DSP4_OUTPUT_SW
, 0 },
230 { SB_DSP4_SPEAKER_DEV
, 0 },
234 static int __devinit
cmi8330_add_sb_mixers(struct snd_sb
*chip
)
239 spin_lock_irqsave(&chip
->mixer_lock
, flags
);
240 snd_sbmixer_write(chip
, 0x00, 0x00); /* mixer reset */
241 spin_unlock_irqrestore(&chip
->mixer_lock
, flags
);
243 /* mute and zero volume channels */
244 for (idx
= 0; idx
< ARRAY_SIZE(cmi8330_sb_init_values
); idx
++) {
245 spin_lock_irqsave(&chip
->mixer_lock
, flags
);
246 snd_sbmixer_write(chip
, cmi8330_sb_init_values
[idx
][0],
247 cmi8330_sb_init_values
[idx
][1]);
248 spin_unlock_irqrestore(&chip
->mixer_lock
, flags
);
251 for (idx
= 0; idx
< ARRAY_SIZE(cmi8330_sb_mixers
); idx
++) {
252 if ((err
= snd_sbmixer_add_ctl_elem(chip
, &cmi8330_sb_mixers
[idx
])) < 0)
259 static int __devinit
snd_cmi8330_mixer(struct snd_card
*card
, struct snd_cmi8330
*acard
)
264 strcpy(card
->mixername
, "CMI8330/C3D");
266 for (idx
= 0; idx
< ARRAY_SIZE(snd_cmi8330_controls
); idx
++) {
267 if ((err
= snd_ad1848_add_ctl_elem(acard
->wss
, &snd_cmi8330_controls
[idx
])) < 0)
271 #ifdef ENABLE_SB_MIXER
272 if ((err
= cmi8330_add_sb_mixers(acard
->sb
)) < 0)
279 static int __devinit
snd_cmi8330_pnp(int dev
, struct snd_cmi8330
*acard
,
280 struct pnp_card_link
*card
,
281 const struct pnp_card_device_id
*id
)
283 struct pnp_dev
*pdev
;
284 struct pnp_resource_table
* cfg
= kmalloc(sizeof(struct pnp_resource_table
), GFP_KERNEL
);
287 acard
->cap
= pnp_request_card_device(card
, id
->devs
[0].id
, NULL
);
288 if (acard
->cap
== NULL
) {
292 acard
->play
= pnp_request_card_device(card
, id
->devs
[1].id
, NULL
);
293 if (acard
->play
== NULL
) {
299 pnp_init_resource_table(cfg
);
300 /* allocate AD1848 resources */
301 if (wssport
[dev
] != SNDRV_AUTO_PORT
)
302 pnp_resource_change(&cfg
->port_resource
[0], wssport
[dev
], 8);
303 if (wssdma
[dev
] != SNDRV_AUTO_DMA
)
304 pnp_resource_change(&cfg
->dma_resource
[0], wssdma
[dev
], 1);
305 if (wssirq
[dev
] != SNDRV_AUTO_IRQ
)
306 pnp_resource_change(&cfg
->irq_resource
[0], wssirq
[dev
], 1);
308 err
= pnp_manual_config_dev(pdev
, cfg
, 0);
310 snd_printk(KERN_ERR
"CMI8330/C3D (AD1848) PnP manual resources are invalid, using auto config\n");
311 err
= pnp_activate_dev(pdev
);
313 snd_printk(KERN_ERR
"CMI8330/C3D (AD1848) PnP configure failure\n");
317 wssport
[dev
] = pnp_port_start(pdev
, 0);
318 wssdma
[dev
] = pnp_dma(pdev
, 0);
319 wssirq
[dev
] = pnp_irq(pdev
, 0);
321 /* allocate SB16 resources */
323 pnp_init_resource_table(cfg
);
324 if (sbport
[dev
] != SNDRV_AUTO_PORT
)
325 pnp_resource_change(&cfg
->port_resource
[0], sbport
[dev
], 16);
326 if (sbdma8
[dev
] != SNDRV_AUTO_DMA
)
327 pnp_resource_change(&cfg
->dma_resource
[0], sbdma8
[dev
], 1);
328 if (sbdma16
[dev
] != SNDRV_AUTO_DMA
)
329 pnp_resource_change(&cfg
->dma_resource
[1], sbdma16
[dev
], 1);
330 if (sbirq
[dev
] != SNDRV_AUTO_IRQ
)
331 pnp_resource_change(&cfg
->irq_resource
[0], sbirq
[dev
], 1);
333 err
= pnp_manual_config_dev(pdev
, cfg
, 0);
335 snd_printk(KERN_ERR
"CMI8330/C3D (SB16) PnP manual resources are invalid, using auto config\n");
336 err
= pnp_activate_dev(pdev
);
338 snd_printk(KERN_ERR
"CMI8330/C3D (SB16) PnP configure failure\n");
342 sbport
[dev
] = pnp_port_start(pdev
, 0);
343 sbdma8
[dev
] = pnp_dma(pdev
, 0);
344 sbdma16
[dev
] = pnp_dma(pdev
, 1);
345 sbirq
[dev
] = pnp_irq(pdev
, 0);
355 * since we call the different chip interfaces for playback and capture
356 * directions, we need a trick.
358 * - copy the ops for each direction into a local record.
359 * - replace the open callback with the new one, which replaces the
360 * substream->private_data with the corresponding chip instance
361 * and calls again the original open callback of the chip.
365 #ifdef PLAYBACK_ON_SB
366 #define CMI_SB_STREAM SNDRV_PCM_STREAM_PLAYBACK
367 #define CMI_AD_STREAM SNDRV_PCM_STREAM_CAPTURE
369 #define CMI_SB_STREAM SNDRV_PCM_STREAM_CAPTURE
370 #define CMI_AD_STREAM SNDRV_PCM_STREAM_PLAYBACK
373 static int snd_cmi8330_playback_open(struct snd_pcm_substream
*substream
)
375 struct snd_cmi8330
*chip
= snd_pcm_substream_chip(substream
);
377 /* replace the private_data and call the original open callback */
378 substream
->private_data
= chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].private_data
;
379 return chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].open(substream
);
382 static int snd_cmi8330_capture_open(struct snd_pcm_substream
*substream
)
384 struct snd_cmi8330
*chip
= snd_pcm_substream_chip(substream
);
386 /* replace the private_data and call the original open callback */
387 substream
->private_data
= chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
].private_data
;
388 return chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
].open(substream
);
391 static int __devinit
snd_cmi8330_pcm(struct snd_card
*card
, struct snd_cmi8330
*chip
)
394 const struct snd_pcm_ops
*ops
;
396 static snd_pcm_open_callback_t cmi_open_callbacks
[2] = {
397 snd_cmi8330_playback_open
,
398 snd_cmi8330_capture_open
401 if ((err
= snd_pcm_new(card
, "CMI8330", 0, 1, 1, &pcm
)) < 0)
403 strcpy(pcm
->name
, "CMI8330");
404 pcm
->private_data
= chip
;
407 ops
= snd_sb16dsp_get_pcm_ops(CMI_SB_STREAM
);
408 chip
->streams
[CMI_SB_STREAM
].ops
= *ops
;
409 chip
->streams
[CMI_SB_STREAM
].open
= ops
->open
;
410 chip
->streams
[CMI_SB_STREAM
].ops
.open
= cmi_open_callbacks
[CMI_SB_STREAM
];
411 chip
->streams
[CMI_SB_STREAM
].private_data
= chip
->sb
;
414 ops
= snd_ad1848_get_pcm_ops(CMI_AD_STREAM
);
415 chip
->streams
[CMI_AD_STREAM
].ops
= *ops
;
416 chip
->streams
[CMI_AD_STREAM
].open
= ops
->open
;
417 chip
->streams
[CMI_AD_STREAM
].ops
.open
= cmi_open_callbacks
[CMI_AD_STREAM
];
418 chip
->streams
[CMI_AD_STREAM
].private_data
= chip
->wss
;
420 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &chip
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].ops
);
421 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &chip
->streams
[SNDRV_PCM_STREAM_CAPTURE
].ops
);
423 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
433 static int snd_cmi8330_suspend(struct snd_card
*card
)
435 struct snd_cmi8330
*acard
= card
->private_data
;
437 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
438 snd_pcm_suspend_all(acard
->pcm
);
439 acard
->wss
->suspend(acard
->wss
);
440 snd_sbmixer_suspend(acard
->sb
);
444 static int snd_cmi8330_resume(struct snd_card
*card
)
446 struct snd_cmi8330
*acard
= card
->private_data
;
448 snd_sbdsp_reset(acard
->sb
);
449 snd_sbmixer_suspend(acard
->sb
);
450 acard
->wss
->resume(acard
->wss
);
451 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
461 #define is_isapnp_selected(dev) isapnp[dev]
463 #define is_isapnp_selected(dev) 0
466 #define PFX "cmi8330: "
468 static struct snd_card
*snd_cmi8330_card_new(int dev
)
470 struct snd_card
*card
;
471 struct snd_cmi8330
*acard
;
473 card
= snd_card_new(index
[dev
], id
[dev
], THIS_MODULE
,
474 sizeof(struct snd_cmi8330
));
476 snd_printk(KERN_ERR PFX
"could not get a new card\n");
479 acard
= card
->private_data
;
484 static int __devinit
snd_cmi8330_probe(struct snd_card
*card
, int dev
)
486 struct snd_cmi8330
*acard
;
489 acard
= card
->private_data
;
490 if ((err
= snd_ad1848_create(card
,
496 snd_printk(KERN_ERR PFX
"(AD1848) device busy??\n");
499 if (acard
->wss
->hardware
!= AD1848_HW_CMI8330
) {
500 snd_printk(KERN_ERR PFX
"(AD1848) not found during probe\n");
504 if ((err
= snd_sbdsp_create(card
, sbport
[dev
],
506 snd_sb16dsp_interrupt
,
509 SB_HW_AUTO
, &acard
->sb
)) < 0) {
510 snd_printk(KERN_ERR PFX
"(SB16) device busy??\n");
513 if (acard
->sb
->hardware
!= SB_HW_16
) {
514 snd_printk(KERN_ERR PFX
"(SB16) not found during probe\n");
518 snd_ad1848_out(acard
->wss
, AD1848_MISC_INFO
, 0x40); /* switch on MODE2 */
519 for (i
= CMI8330_RMUX3D
; i
<= CMI8330_CDINGAIN
; i
++)
520 snd_ad1848_out(acard
->wss
, i
, snd_cmi8330_image
[i
- CMI8330_RMUX3D
]);
522 if ((err
= snd_cmi8330_mixer(card
, acard
)) < 0) {
523 snd_printk(KERN_ERR PFX
"failed to create mixers\n");
527 if ((err
= snd_cmi8330_pcm(card
, acard
)) < 0) {
528 snd_printk(KERN_ERR PFX
"failed to create pcms\n");
532 strcpy(card
->driver
, "CMI8330/C3D");
533 strcpy(card
->shortname
, "C-Media CMI8330/C3D");
534 sprintf(card
->longname
, "%s at 0x%lx, irq %d, dma %d",
540 return snd_card_register(card
);
543 static int __init
snd_cmi8330_nonpnp_probe(struct platform_device
*pdev
)
545 struct snd_card
*card
;
549 if (wssport
[dev
] == SNDRV_AUTO_PORT
) {
550 snd_printk(KERN_ERR PFX
"specify wssport\n");
553 if (sbport
[dev
] == SNDRV_AUTO_PORT
) {
554 snd_printk(KERN_ERR PFX
"specify sbport\n");
558 card
= snd_cmi8330_card_new(dev
);
561 snd_card_set_dev(card
, &pdev
->dev
);
562 if ((err
= snd_cmi8330_probe(card
, dev
)) < 0) {
566 platform_set_drvdata(pdev
, card
);
570 static int snd_cmi8330_nonpnp_remove(struct platform_device
*devptr
)
572 snd_card_free(platform_get_drvdata(devptr
));
573 platform_set_drvdata(devptr
, NULL
);
578 static int snd_cmi8330_nonpnp_suspend(struct platform_device
*dev
, pm_message_t state
)
580 return snd_cmi8330_suspend(platform_get_drvdata(dev
));
583 static int snd_cmi8330_nonpnp_resume(struct platform_device
*dev
)
585 return snd_cmi8330_resume(platform_get_drvdata(dev
));
589 #define CMI8330_DRIVER "snd_cmi8330"
591 static struct platform_driver snd_cmi8330_driver
= {
592 .probe
= snd_cmi8330_nonpnp_probe
,
593 .remove
= snd_cmi8330_nonpnp_remove
,
595 .suspend
= snd_cmi8330_nonpnp_suspend
,
596 .resume
= snd_cmi8330_nonpnp_resume
,
599 .name
= CMI8330_DRIVER
605 static int __devinit
snd_cmi8330_pnp_detect(struct pnp_card_link
*pcard
,
606 const struct pnp_card_device_id
*pid
)
609 struct snd_card
*card
;
612 for ( ; dev
< SNDRV_CARDS
; dev
++) {
613 if (enable
[dev
] && isapnp
[dev
])
616 if (dev
>= SNDRV_CARDS
)
619 card
= snd_cmi8330_card_new(dev
);
622 if ((res
= snd_cmi8330_pnp(dev
, card
->private_data
, pcard
, pid
)) < 0) {
623 snd_printk(KERN_ERR PFX
"PnP detection failed\n");
627 snd_card_set_dev(card
, &pcard
->card
->dev
);
628 if ((res
= snd_cmi8330_probe(card
, dev
)) < 0) {
632 pnp_set_card_drvdata(pcard
, card
);
637 static void __devexit
snd_cmi8330_pnp_remove(struct pnp_card_link
* pcard
)
639 snd_card_free(pnp_get_card_drvdata(pcard
));
640 pnp_set_card_drvdata(pcard
, NULL
);
644 static int snd_cmi8330_pnp_suspend(struct pnp_card_link
*pcard
, pm_message_t state
)
646 return snd_cmi8330_suspend(pnp_get_card_drvdata(pcard
));
649 static int snd_cmi8330_pnp_resume(struct pnp_card_link
*pcard
)
651 return snd_cmi8330_resume(pnp_get_card_drvdata(pcard
));
655 static struct pnp_card_driver cmi8330_pnpc_driver
= {
656 .flags
= PNP_DRIVER_RES_DISABLE
,
658 .id_table
= snd_cmi8330_pnpids
,
659 .probe
= snd_cmi8330_pnp_detect
,
660 .remove
= __devexit_p(snd_cmi8330_pnp_remove
),
662 .suspend
= snd_cmi8330_pnp_suspend
,
663 .resume
= snd_cmi8330_pnp_resume
,
666 #endif /* CONFIG_PNP */
668 static int __init
alsa_card_cmi8330_init(void)
670 int i
, err
, cards
= 0;
672 if ((err
= platform_driver_register(&snd_cmi8330_driver
)) < 0)
675 for (i
= 0; i
< SNDRV_CARDS
&& enable
[i
]; i
++) {
676 struct platform_device
*device
;
677 if (is_isapnp_selected(i
))
679 device
= platform_device_register_simple(CMI8330_DRIVER
,
681 if (IS_ERR(device
)) {
682 err
= PTR_ERR(device
);
683 platform_driver_unregister(&snd_cmi8330_driver
);
689 err
= pnp_register_card_driver(&cmi8330_pnpc_driver
);
694 pnp_unregister_card_driver(&cmi8330_pnpc_driver
);
695 platform_driver_unregister(&snd_cmi8330_driver
);
697 snd_printk(KERN_ERR
"CMI8330 not found or device busy\n");
704 static void __exit
alsa_card_cmi8330_exit(void)
706 pnp_unregister_card_driver(&cmi8330_pnpc_driver
);
707 platform_driver_unregister(&snd_cmi8330_driver
);
710 module_init(alsa_card_cmi8330_init
)
711 module_exit(alsa_card_cmi8330_exit
)