]>
Commit | Line | Data |
---|---|---|
1a59d1b8 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
1da177e4 | 2 | /* |
69eb8882 | 3 | * Driver for C-Media's CMI8330 and CMI8329 soundcards. |
1da177e4 LT |
4 | * Copyright (c) by George Talusan <gstalusan@uwaterloo.ca> |
5 | * http://www.undergrad.math.uwaterloo.ca/~gstalusa | |
1da177e4 LT |
6 | */ |
7 | ||
8 | /* | |
9 | * NOTES | |
10 | * | |
11 | * The extended registers contain mixer settings which are largely | |
12 | * untapped for the time being. | |
13 | * | |
14 | * MPU401 and SPDIF are not supported yet. I don't have the hardware | |
15 | * to aid in coding and testing, so I won't bother. | |
16 | * | |
17 | * To quickly load the module, | |
18 | * | |
19 | * modprobe -a snd-cmi8330 sbport=0x220 sbirq=5 sbdma8=1 | |
c97dff84 | 20 | * sbdma16=5 wssport=0x530 wssirq=11 wssdma=0 fmport=0x388 |
1da177e4 LT |
21 | * |
22 | * This card has two mixers and two PCM devices. I've cheesed it such | |
23 | * that recording and playback can be done through the same device. | |
74a0094c | 24 | * The driver "magically" routes the capturing to the AD1848 codec, |
1da177e4 LT |
25 | * and playback to the SB16 codec. This allows for full-duplex mode |
26 | * to some extent. | |
27 | * The utilities in alsa-utils are aware of both devices, so passing | |
28 | * the appropriate parameters to amixer and alsactl will give you | |
29 | * full control over both mixers. | |
30 | */ | |
31 | ||
1da177e4 | 32 | #include <linux/init.h> |
acdcbc15 | 33 | #include <linux/err.h> |
5e24c1c1 | 34 | #include <linux/isa.h> |
1da177e4 | 35 | #include <linux/pnp.h> |
65a77217 | 36 | #include <linux/module.h> |
1da177e4 | 37 | #include <sound/core.h> |
760fc6b8 | 38 | #include <sound/wss.h> |
48972cc5 | 39 | #include <sound/opl3.h> |
c97dff84 | 40 | #include <sound/mpu401.h> |
1da177e4 LT |
41 | #include <sound/sb.h> |
42 | #include <sound/initval.h> | |
43 | ||
44 | /* | |
45 | */ | |
46 | /* #define ENABLE_SB_MIXER */ | |
47 | #define PLAYBACK_ON_SB | |
48 | ||
49 | /* | |
50 | */ | |
51 | MODULE_AUTHOR("George Talusan <gstalusan@uwaterloo.ca>"); | |
69eb8882 | 52 | MODULE_DESCRIPTION("C-Media CMI8330/CMI8329"); |
1da177e4 LT |
53 | MODULE_LICENSE("GPL"); |
54 | MODULE_SUPPORTED_DEVICE("{{C-Media,CMI8330,isapnp:{CMI0001,@@@0001,@X@0001}}}"); | |
55 | ||
56 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; | |
57 | static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; | |
a67ff6a5 | 58 | static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; |
1da177e4 | 59 | #ifdef CONFIG_PNP |
a67ff6a5 | 60 | static bool isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; |
1da177e4 LT |
61 | #endif |
62 | static long sbport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; | |
63 | static int sbirq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; | |
64 | static int sbdma8[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; | |
65 | static int sbdma16[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; | |
66 | static long wssport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; | |
67 | static int wssirq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; | |
68 | static int wssdma[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; | |
48972cc5 | 69 | static long fmport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; |
c97dff84 KH |
70 | static long mpuport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; |
71 | static int mpuirq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; | |
1da177e4 LT |
72 | |
73 | module_param_array(index, int, NULL, 0444); | |
69eb8882 | 74 | MODULE_PARM_DESC(index, "Index value for CMI8330/CMI8329 soundcard."); |
1da177e4 | 75 | module_param_array(id, charp, NULL, 0444); |
69eb8882 | 76 | MODULE_PARM_DESC(id, "ID string for CMI8330/CMI8329 soundcard."); |
1da177e4 | 77 | module_param_array(enable, bool, NULL, 0444); |
69eb8882 | 78 | MODULE_PARM_DESC(enable, "Enable CMI8330/CMI8329 soundcard."); |
1da177e4 LT |
79 | #ifdef CONFIG_PNP |
80 | module_param_array(isapnp, bool, NULL, 0444); | |
81 | MODULE_PARM_DESC(isapnp, "PnP detection for specified soundcard."); | |
82 | #endif | |
83 | ||
e992ef57 | 84 | module_param_hw_array(sbport, long, ioport, NULL, 0444); |
69eb8882 | 85 | MODULE_PARM_DESC(sbport, "Port # for CMI8330/CMI8329 SB driver."); |
e992ef57 | 86 | module_param_hw_array(sbirq, int, irq, NULL, 0444); |
69eb8882 | 87 | MODULE_PARM_DESC(sbirq, "IRQ # for CMI8330/CMI8329 SB driver."); |
e992ef57 | 88 | module_param_hw_array(sbdma8, int, dma, NULL, 0444); |
69eb8882 | 89 | MODULE_PARM_DESC(sbdma8, "DMA8 for CMI8330/CMI8329 SB driver."); |
e992ef57 | 90 | module_param_hw_array(sbdma16, int, dma, NULL, 0444); |
69eb8882 | 91 | MODULE_PARM_DESC(sbdma16, "DMA16 for CMI8330/CMI8329 SB driver."); |
1da177e4 | 92 | |
e992ef57 | 93 | module_param_hw_array(wssport, long, ioport, NULL, 0444); |
69eb8882 | 94 | MODULE_PARM_DESC(wssport, "Port # for CMI8330/CMI8329 WSS driver."); |
e992ef57 | 95 | module_param_hw_array(wssirq, int, irq, NULL, 0444); |
69eb8882 | 96 | MODULE_PARM_DESC(wssirq, "IRQ # for CMI8330/CMI8329 WSS driver."); |
e992ef57 | 97 | module_param_hw_array(wssdma, int, dma, NULL, 0444); |
69eb8882 | 98 | MODULE_PARM_DESC(wssdma, "DMA for CMI8330/CMI8329 WSS driver."); |
1da177e4 | 99 | |
e992ef57 | 100 | module_param_hw_array(fmport, long, ioport, NULL, 0444); |
69eb8882 | 101 | MODULE_PARM_DESC(fmport, "FM port # for CMI8330/CMI8329 driver."); |
e992ef57 | 102 | module_param_hw_array(mpuport, long, ioport, NULL, 0444); |
69eb8882 | 103 | MODULE_PARM_DESC(mpuport, "MPU-401 port # for CMI8330/CMI8329 driver."); |
e992ef57 | 104 | module_param_hw_array(mpuirq, int, irq, NULL, 0444); |
69eb8882 | 105 | MODULE_PARM_DESC(mpuirq, "IRQ # for CMI8330/CMI8329 MPU-401 port."); |
59b1b34f | 106 | #ifdef CONFIG_PNP |
609d7694 | 107 | static int isa_registered; |
f7a9275d | 108 | static int pnp_registered; |
59b1b34f | 109 | #endif |
f7a9275d | 110 | |
1da177e4 LT |
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 | |
122 | ||
123 | static unsigned char snd_cmi8330_image[((CMI8330_CDINGAIN)-16) + 1] = | |
124 | { | |
125 | 0x40, /* 16 - recording mux (SB-mixer-enabled) */ | |
126 | #ifdef ENABLE_SB_MIXER | |
127 | 0x40, /* 17 - mute mux (Mode2) */ | |
128 | #else | |
129 | 0x0, /* 17 - mute mux */ | |
130 | #endif | |
131 | 0x0, /* 18 - vol */ | |
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 */ | |
140 | }; | |
141 | ||
e3561703 | 142 | typedef int (*snd_pcm_open_callback_t)(struct snd_pcm_substream *); |
1da177e4 | 143 | |
69eb8882 OZ |
144 | enum card_type { |
145 | CMI8330, | |
146 | CMI8329 | |
147 | }; | |
148 | ||
1da177e4 LT |
149 | struct snd_cmi8330 { |
150 | #ifdef CONFIG_PNP | |
151 | struct pnp_dev *cap; | |
152 | struct pnp_dev *play; | |
c97dff84 | 153 | struct pnp_dev *mpu; |
1da177e4 | 154 | #endif |
e3561703 | 155 | struct snd_card *card; |
241b3ee7 | 156 | struct snd_wss *wss; |
e3561703 | 157 | struct snd_sb *sb; |
1da177e4 | 158 | |
e3561703 | 159 | struct snd_pcm *pcm; |
1da177e4 | 160 | struct snd_cmi8330_stream { |
e3561703 | 161 | struct snd_pcm_ops ops; |
1da177e4 LT |
162 | snd_pcm_open_callback_t open; |
163 | void *private_data; /* sb or wss */ | |
164 | } streams[2]; | |
69eb8882 OZ |
165 | |
166 | enum card_type type; | |
1da177e4 LT |
167 | }; |
168 | ||
1da177e4 LT |
169 | #ifdef CONFIG_PNP |
170 | ||
06891ec6 | 171 | static const struct pnp_card_device_id snd_cmi8330_pnpids[] = { |
69eb8882 | 172 | { .id = "CMI0001", .devs = { { "@X@0001" }, { "@@@0001" }, { "@H@0001" }, { "A@@0001" } } }, |
c97dff84 | 173 | { .id = "CMI0001", .devs = { { "@@@0001" }, { "@X@0001" }, { "@H@0001" } } }, |
1da177e4 LT |
174 | { .id = "" } |
175 | }; | |
176 | ||
177 | MODULE_DEVICE_TABLE(pnp_card, snd_cmi8330_pnpids); | |
178 | ||
179 | #endif | |
180 | ||
181 | ||
1bff292e | 182 | static struct snd_kcontrol_new snd_cmi8330_controls[] = { |
0c5e3e98 KH |
183 | WSS_DOUBLE("Master Playback Volume", 0, |
184 | CMI8330_MASTVOL, CMI8330_MASTVOL, 4, 0, 15, 0), | |
185 | WSS_SINGLE("Loud Playback Switch", 0, | |
186 | CMI8330_MUTEMUX, 6, 1, 1), | |
187 | WSS_DOUBLE("PCM Playback Switch", 0, | |
760fc6b8 | 188 | CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1), |
0c5e3e98 | 189 | WSS_DOUBLE("PCM Playback Volume", 0, |
760fc6b8 | 190 | CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1), |
0c5e3e98 KH |
191 | WSS_DOUBLE("Line Playback Switch", 0, |
192 | CMI8330_MUTEMUX, CMI8330_MUTEMUX, 4, 3, 1, 0), | |
193 | WSS_DOUBLE("Line Playback Volume", 0, | |
194 | CMI8330_LINVOL, CMI8330_LINVOL, 4, 0, 15, 0), | |
195 | WSS_DOUBLE("Line Capture Switch", 0, | |
196 | CMI8330_RMUX3D, CMI8330_RMUX3D, 2, 1, 1, 0), | |
197 | WSS_DOUBLE("Line Capture Volume", 0, | |
198 | CMI8330_LINGAIN, CMI8330_LINGAIN, 4, 0, 15, 0), | |
199 | WSS_DOUBLE("CD Playback Switch", 0, | |
200 | CMI8330_MUTEMUX, CMI8330_MUTEMUX, 2, 1, 1, 0), | |
201 | WSS_DOUBLE("CD Capture Switch", 0, | |
202 | CMI8330_RMUX3D, CMI8330_RMUX3D, 4, 3, 1, 0), | |
203 | WSS_DOUBLE("CD Playback Volume", 0, | |
204 | CMI8330_CDINVOL, CMI8330_CDINVOL, 4, 0, 15, 0), | |
205 | WSS_DOUBLE("CD Capture Volume", 0, | |
206 | CMI8330_CDINGAIN, CMI8330_CDINGAIN, 4, 0, 15, 0), | |
207 | WSS_SINGLE("Mic Playback Switch", 0, | |
208 | CMI8330_MUTEMUX, 0, 1, 0), | |
209 | WSS_SINGLE("Mic Playback Volume", 0, | |
210 | CMI8330_OUTPUTVOL, 0, 7, 0), | |
211 | WSS_SINGLE("Mic Capture Switch", 0, | |
212 | CMI8330_RMUX3D, 0, 1, 0), | |
213 | WSS_SINGLE("Mic Capture Volume", 0, | |
214 | CMI8330_OUTPUTVOL, 5, 7, 0), | |
215 | WSS_DOUBLE("Wavetable Playback Switch", 0, | |
216 | CMI8330_RECMUX, CMI8330_RECMUX, 1, 0, 1, 0), | |
217 | WSS_DOUBLE("Wavetable Playback Volume", 0, | |
218 | CMI8330_WAVVOL, CMI8330_WAVVOL, 4, 0, 15, 0), | |
219 | WSS_DOUBLE("Wavetable Capture Switch", 0, | |
220 | CMI8330_RECMUX, CMI8330_RECMUX, 5, 4, 1, 0), | |
221 | WSS_DOUBLE("Wavetable Capture Volume", 0, | |
222 | CMI8330_WAVGAIN, CMI8330_WAVGAIN, 4, 0, 15, 0), | |
223 | WSS_SINGLE("3D Control - Switch", 0, | |
224 | CMI8330_RMUX3D, 5, 1, 1), | |
d355c82a | 225 | WSS_SINGLE("Beep Playback Volume", 0, |
0c5e3e98 | 226 | CMI8330_OUTPUTVOL, 3, 3, 0), |
48972cc5 KH |
227 | WSS_DOUBLE("FM Playback Switch", 0, |
228 | CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1), | |
229 | WSS_DOUBLE("FM Playback Volume", 0, | |
230 | CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1), | |
0c5e3e98 KH |
231 | WSS_SINGLE(SNDRV_CTL_NAME_IEC958("Input ", CAPTURE, SWITCH), 0, |
232 | CMI8330_RMUX3D, 7, 1, 1), | |
233 | WSS_SINGLE(SNDRV_CTL_NAME_IEC958("Input ", PLAYBACK, SWITCH), 0, | |
234 | CMI8330_MUTEMUX, 7, 1, 1), | |
1da177e4 LT |
235 | }; |
236 | ||
237 | #ifdef ENABLE_SB_MIXER | |
1bff292e | 238 | static struct sbmix_elem cmi8330_sb_mixers[] = { |
1da177e4 LT |
239 | SB_DOUBLE("SB Master Playback Volume", SB_DSP4_MASTER_DEV, (SB_DSP4_MASTER_DEV + 1), 3, 3, 31), |
240 | SB_DOUBLE("Tone Control - Bass", SB_DSP4_BASS_DEV, (SB_DSP4_BASS_DEV + 1), 4, 4, 15), | |
241 | SB_DOUBLE("Tone Control - Treble", SB_DSP4_TREBLE_DEV, (SB_DSP4_TREBLE_DEV + 1), 4, 4, 15), | |
242 | SB_DOUBLE("SB PCM Playback Volume", SB_DSP4_PCM_DEV, (SB_DSP4_PCM_DEV + 1), 3, 3, 31), | |
243 | SB_DOUBLE("SB Synth Playback Volume", SB_DSP4_SYNTH_DEV, (SB_DSP4_SYNTH_DEV + 1), 3, 3, 31), | |
244 | SB_DOUBLE("SB CD Playback Switch", SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 2, 1, 1), | |
245 | SB_DOUBLE("SB CD Playback Volume", SB_DSP4_CD_DEV, (SB_DSP4_CD_DEV + 1), 3, 3, 31), | |
246 | SB_DOUBLE("SB Line Playback Switch", SB_DSP4_OUTPUT_SW, SB_DSP4_OUTPUT_SW, 4, 3, 1), | |
247 | SB_DOUBLE("SB Line Playback Volume", SB_DSP4_LINE_DEV, (SB_DSP4_LINE_DEV + 1), 3, 3, 31), | |
248 | SB_SINGLE("SB Mic Playback Switch", SB_DSP4_OUTPUT_SW, 0, 1), | |
249 | SB_SINGLE("SB Mic Playback Volume", SB_DSP4_MIC_DEV, 3, 31), | |
d355c82a | 250 | SB_SINGLE("SB Beep Volume", SB_DSP4_SPEAKER_DEV, 6, 3), |
1da177e4 LT |
251 | SB_DOUBLE("SB Capture Volume", SB_DSP4_IGAIN_DEV, (SB_DSP4_IGAIN_DEV + 1), 6, 6, 3), |
252 | SB_DOUBLE("SB Playback Volume", SB_DSP4_OGAIN_DEV, (SB_DSP4_OGAIN_DEV + 1), 6, 6, 3), | |
253 | SB_SINGLE("SB Mic Auto Gain", SB_DSP4_MIC_AGC, 0, 1), | |
254 | }; | |
255 | ||
1bff292e | 256 | static unsigned char cmi8330_sb_init_values[][2] = { |
1da177e4 LT |
257 | { SB_DSP4_MASTER_DEV + 0, 0 }, |
258 | { SB_DSP4_MASTER_DEV + 1, 0 }, | |
259 | { SB_DSP4_PCM_DEV + 0, 0 }, | |
260 | { SB_DSP4_PCM_DEV + 1, 0 }, | |
261 | { SB_DSP4_SYNTH_DEV + 0, 0 }, | |
262 | { SB_DSP4_SYNTH_DEV + 1, 0 }, | |
263 | { SB_DSP4_INPUT_LEFT, 0 }, | |
264 | { SB_DSP4_INPUT_RIGHT, 0 }, | |
265 | { SB_DSP4_OUTPUT_SW, 0 }, | |
266 | { SB_DSP4_SPEAKER_DEV, 0 }, | |
267 | }; | |
268 | ||
269 | ||
1bff292e | 270 | static int cmi8330_add_sb_mixers(struct snd_sb *chip) |
1da177e4 LT |
271 | { |
272 | int idx, err; | |
273 | unsigned long flags; | |
274 | ||
275 | spin_lock_irqsave(&chip->mixer_lock, flags); | |
276 | snd_sbmixer_write(chip, 0x00, 0x00); /* mixer reset */ | |
277 | spin_unlock_irqrestore(&chip->mixer_lock, flags); | |
278 | ||
279 | /* mute and zero volume channels */ | |
280 | for (idx = 0; idx < ARRAY_SIZE(cmi8330_sb_init_values); idx++) { | |
281 | spin_lock_irqsave(&chip->mixer_lock, flags); | |
282 | snd_sbmixer_write(chip, cmi8330_sb_init_values[idx][0], | |
283 | cmi8330_sb_init_values[idx][1]); | |
284 | spin_unlock_irqrestore(&chip->mixer_lock, flags); | |
285 | } | |
286 | ||
287 | for (idx = 0; idx < ARRAY_SIZE(cmi8330_sb_mixers); idx++) { | |
288 | if ((err = snd_sbmixer_add_ctl_elem(chip, &cmi8330_sb_mixers[idx])) < 0) | |
289 | return err; | |
290 | } | |
291 | return 0; | |
292 | } | |
293 | #endif | |
294 | ||
1bff292e | 295 | static int snd_cmi8330_mixer(struct snd_card *card, struct snd_cmi8330 *acard) |
1da177e4 LT |
296 | { |
297 | unsigned int idx; | |
298 | int err; | |
299 | ||
69eb8882 | 300 | strcpy(card->mixername, (acard->type == CMI8329) ? "CMI8329" : "CMI8330/C3D"); |
1da177e4 LT |
301 | |
302 | for (idx = 0; idx < ARRAY_SIZE(snd_cmi8330_controls); idx++) { | |
0c5e3e98 KH |
303 | err = snd_ctl_add(card, |
304 | snd_ctl_new1(&snd_cmi8330_controls[idx], | |
305 | acard->wss)); | |
306 | if (err < 0) | |
1da177e4 LT |
307 | return err; |
308 | } | |
309 | ||
310 | #ifdef ENABLE_SB_MIXER | |
311 | if ((err = cmi8330_add_sb_mixers(acard->sb)) < 0) | |
312 | return err; | |
313 | #endif | |
314 | return 0; | |
315 | } | |
316 | ||
317 | #ifdef CONFIG_PNP | |
1bff292e BP |
318 | static int snd_cmi8330_pnp(int dev, struct snd_cmi8330 *acard, |
319 | struct pnp_card_link *card, | |
320 | const struct pnp_card_device_id *id) | |
1da177e4 LT |
321 | { |
322 | struct pnp_dev *pdev; | |
1da177e4 LT |
323 | int err; |
324 | ||
69eb8882 OZ |
325 | /* CMI8329 has a device with ID A@@0001, CMI8330 does not */ |
326 | acard->type = (id->devs[3].id[0]) ? CMI8329 : CMI8330; | |
327 | ||
1da177e4 | 328 | acard->cap = pnp_request_card_device(card, id->devs[0].id, NULL); |
109c53f8 | 329 | if (acard->cap == NULL) |
1da177e4 | 330 | return -EBUSY; |
109c53f8 | 331 | |
1da177e4 | 332 | acard->play = pnp_request_card_device(card, id->devs[1].id, NULL); |
109c53f8 | 333 | if (acard->play == NULL) |
1da177e4 | 334 | return -EBUSY; |
1da177e4 | 335 | |
c97dff84 | 336 | acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL); |
c2a30d71 | 337 | if (acard->mpu == NULL) |
c97dff84 KH |
338 | return -EBUSY; |
339 | ||
1da177e4 | 340 | pdev = acard->cap; |
109c53f8 | 341 | |
1da177e4 LT |
342 | err = pnp_activate_dev(pdev); |
343 | if (err < 0) { | |
69eb8882 | 344 | snd_printk(KERN_ERR "AD1848 PnP configure failure\n"); |
1da177e4 LT |
345 | return -EBUSY; |
346 | } | |
347 | wssport[dev] = pnp_port_start(pdev, 0); | |
348 | wssdma[dev] = pnp_dma(pdev, 0); | |
349 | wssirq[dev] = pnp_irq(pdev, 0); | |
0b959167 | 350 | if (pnp_port_start(pdev, 1)) |
69eb8882 | 351 | fmport[dev] = pnp_port_start(pdev, 1); |
1da177e4 LT |
352 | |
353 | /* allocate SB16 resources */ | |
354 | pdev = acard->play; | |
109c53f8 | 355 | |
1da177e4 LT |
356 | err = pnp_activate_dev(pdev); |
357 | if (err < 0) { | |
69eb8882 | 358 | snd_printk(KERN_ERR "SB16 PnP configure failure\n"); |
1da177e4 LT |
359 | return -EBUSY; |
360 | } | |
361 | sbport[dev] = pnp_port_start(pdev, 0); | |
362 | sbdma8[dev] = pnp_dma(pdev, 0); | |
363 | sbdma16[dev] = pnp_dma(pdev, 1); | |
364 | sbirq[dev] = pnp_irq(pdev, 0); | |
0b959167 OZ |
365 | /* On CMI8239, the OPL3 port might be present in SB16 PnP resources */ |
366 | if (fmport[dev] == SNDRV_AUTO_PORT) { | |
367 | if (pnp_port_start(pdev, 1)) | |
368 | fmport[dev] = pnp_port_start(pdev, 1); | |
369 | else | |
370 | fmport[dev] = 0x388; /* Or hardwired */ | |
371 | } | |
1da177e4 | 372 | |
c97dff84 KH |
373 | /* allocate MPU-401 resources */ |
374 | pdev = acard->mpu; | |
375 | ||
376 | err = pnp_activate_dev(pdev); | |
72b43cf1 OZ |
377 | if (err < 0) |
378 | snd_printk(KERN_ERR "MPU-401 PnP configure failure: will be disabled\n"); | |
379 | else { | |
380 | mpuport[dev] = pnp_port_start(pdev, 0); | |
381 | mpuirq[dev] = pnp_irq(pdev, 0); | |
c97dff84 | 382 | } |
1da177e4 LT |
383 | return 0; |
384 | } | |
385 | #endif | |
386 | ||
387 | /* | |
388 | * PCM interface | |
389 | * | |
390 | * since we call the different chip interfaces for playback and capture | |
391 | * directions, we need a trick. | |
392 | * | |
393 | * - copy the ops for each direction into a local record. | |
394 | * - replace the open callback with the new one, which replaces the | |
395 | * substream->private_data with the corresponding chip instance | |
396 | * and calls again the original open callback of the chip. | |
397 | * | |
398 | */ | |
399 | ||
400 | #ifdef PLAYBACK_ON_SB | |
401 | #define CMI_SB_STREAM SNDRV_PCM_STREAM_PLAYBACK | |
402 | #define CMI_AD_STREAM SNDRV_PCM_STREAM_CAPTURE | |
403 | #else | |
404 | #define CMI_SB_STREAM SNDRV_PCM_STREAM_CAPTURE | |
405 | #define CMI_AD_STREAM SNDRV_PCM_STREAM_PLAYBACK | |
406 | #endif | |
407 | ||
e3561703 | 408 | static int snd_cmi8330_playback_open(struct snd_pcm_substream *substream) |
1da177e4 LT |
409 | { |
410 | struct snd_cmi8330 *chip = snd_pcm_substream_chip(substream); | |
411 | ||
412 | /* replace the private_data and call the original open callback */ | |
413 | substream->private_data = chip->streams[SNDRV_PCM_STREAM_PLAYBACK].private_data; | |
414 | return chip->streams[SNDRV_PCM_STREAM_PLAYBACK].open(substream); | |
415 | } | |
416 | ||
e3561703 | 417 | static int snd_cmi8330_capture_open(struct snd_pcm_substream *substream) |
1da177e4 LT |
418 | { |
419 | struct snd_cmi8330 *chip = snd_pcm_substream_chip(substream); | |
420 | ||
421 | /* replace the private_data and call the original open callback */ | |
422 | substream->private_data = chip->streams[SNDRV_PCM_STREAM_CAPTURE].private_data; | |
423 | return chip->streams[SNDRV_PCM_STREAM_CAPTURE].open(substream); | |
424 | } | |
425 | ||
1bff292e | 426 | static int snd_cmi8330_pcm(struct snd_card *card, struct snd_cmi8330 *chip) |
1da177e4 | 427 | { |
e3561703 TI |
428 | struct snd_pcm *pcm; |
429 | const struct snd_pcm_ops *ops; | |
1da177e4 LT |
430 | int err; |
431 | static snd_pcm_open_callback_t cmi_open_callbacks[2] = { | |
432 | snd_cmi8330_playback_open, | |
433 | snd_cmi8330_capture_open | |
434 | }; | |
435 | ||
69eb8882 | 436 | if ((err = snd_pcm_new(card, (chip->type == CMI8329) ? "CMI8329" : "CMI8330", 0, 1, 1, &pcm)) < 0) |
1da177e4 | 437 | return err; |
69eb8882 | 438 | strcpy(pcm->name, (chip->type == CMI8329) ? "CMI8329" : "CMI8330"); |
1da177e4 | 439 | pcm->private_data = chip; |
1da177e4 LT |
440 | |
441 | /* SB16 */ | |
442 | ops = snd_sb16dsp_get_pcm_ops(CMI_SB_STREAM); | |
443 | chip->streams[CMI_SB_STREAM].ops = *ops; | |
444 | chip->streams[CMI_SB_STREAM].open = ops->open; | |
445 | chip->streams[CMI_SB_STREAM].ops.open = cmi_open_callbacks[CMI_SB_STREAM]; | |
446 | chip->streams[CMI_SB_STREAM].private_data = chip->sb; | |
447 | ||
448 | /* AD1848 */ | |
ead893c0 | 449 | ops = snd_wss_get_pcm_ops(CMI_AD_STREAM); |
1da177e4 LT |
450 | chip->streams[CMI_AD_STREAM].ops = *ops; |
451 | chip->streams[CMI_AD_STREAM].open = ops->open; | |
452 | chip->streams[CMI_AD_STREAM].ops.open = cmi_open_callbacks[CMI_AD_STREAM]; | |
453 | chip->streams[CMI_AD_STREAM].private_data = chip->wss; | |
454 | ||
455 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &chip->streams[SNDRV_PCM_STREAM_PLAYBACK].ops); | |
456 | snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &chip->streams[SNDRV_PCM_STREAM_CAPTURE].ops); | |
457 | ||
458 | snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, | |
0b6a2c9c | 459 | card->dev, |
1da177e4 LT |
460 | 64*1024, 128*1024); |
461 | chip->pcm = pcm; | |
462 | ||
463 | return 0; | |
464 | } | |
465 | ||
466 | ||
acdcbc15 TI |
467 | #ifdef CONFIG_PM |
468 | static int snd_cmi8330_suspend(struct snd_card *card) | |
469 | { | |
470 | struct snd_cmi8330 *acard = card->private_data; | |
471 | ||
472 | snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); | |
acdcbc15 TI |
473 | acard->wss->suspend(acard->wss); |
474 | snd_sbmixer_suspend(acard->sb); | |
475 | return 0; | |
476 | } | |
477 | ||
478 | static int snd_cmi8330_resume(struct snd_card *card) | |
479 | { | |
480 | struct snd_cmi8330 *acard = card->private_data; | |
481 | ||
482 | snd_sbdsp_reset(acard->sb); | |
483 | snd_sbmixer_suspend(acard->sb); | |
484 | acard->wss->resume(acard->wss); | |
485 | snd_power_change_state(card, SNDRV_CTL_POWER_D0); | |
486 | return 0; | |
487 | } | |
488 | #endif | |
489 | ||
490 | ||
1da177e4 LT |
491 | /* |
492 | */ | |
493 | ||
43bcd973 TI |
494 | #ifdef CONFIG_PNP |
495 | #define is_isapnp_selected(dev) isapnp[dev] | |
496 | #else | |
497 | #define is_isapnp_selected(dev) 0 | |
498 | #endif | |
499 | ||
500 | #define PFX "cmi8330: " | |
501 | ||
4323cc4d TI |
502 | static int snd_cmi8330_card_new(struct device *pdev, int dev, |
503 | struct snd_card **cardp) | |
1da177e4 | 504 | { |
e3561703 | 505 | struct snd_card *card; |
1da177e4 | 506 | struct snd_cmi8330 *acard; |
c95eadd2 | 507 | int err; |
43bcd973 | 508 | |
4323cc4d TI |
509 | err = snd_card_new(pdev, index[dev], id[dev], THIS_MODULE, |
510 | sizeof(struct snd_cmi8330), &card); | |
c95eadd2 | 511 | if (err < 0) { |
43bcd973 | 512 | snd_printk(KERN_ERR PFX "could not get a new card\n"); |
c95eadd2 | 513 | return err; |
1da177e4 | 514 | } |
acdcbc15 | 515 | acard = card->private_data; |
1da177e4 | 516 | acard->card = card; |
c95eadd2 TI |
517 | *cardp = card; |
518 | return 0; | |
acdcbc15 | 519 | } |
1da177e4 | 520 | |
1bff292e | 521 | static int snd_cmi8330_probe(struct snd_card *card, int dev) |
acdcbc15 TI |
522 | { |
523 | struct snd_cmi8330 *acard; | |
524 | int i, err; | |
48972cc5 | 525 | struct snd_opl3 *opl3; |
1da177e4 | 526 | |
acdcbc15 | 527 | acard = card->private_data; |
760fc6b8 KH |
528 | err = snd_wss_create(card, wssport[dev] + 4, -1, |
529 | wssirq[dev], | |
530 | wssdma[dev], -1, | |
531 | WSS_HW_DETECT, 0, &acard->wss); | |
532 | if (err < 0) { | |
69eb8882 | 533 | snd_printk(KERN_ERR PFX "AD1848 device busy??\n"); |
acdcbc15 | 534 | return err; |
1da177e4 | 535 | } |
ece11c9b | 536 | if (acard->wss->hardware != WSS_HW_CMI8330) { |
69eb8882 | 537 | snd_printk(KERN_ERR PFX "AD1848 not found during probe\n"); |
acdcbc15 | 538 | return -ENODEV; |
1da177e4 LT |
539 | } |
540 | ||
541 | if ((err = snd_sbdsp_create(card, sbport[dev], | |
542 | sbirq[dev], | |
543 | snd_sb16dsp_interrupt, | |
544 | sbdma8[dev], | |
545 | sbdma16[dev], | |
546 | SB_HW_AUTO, &acard->sb)) < 0) { | |
69eb8882 | 547 | snd_printk(KERN_ERR PFX "SB16 device busy??\n"); |
acdcbc15 | 548 | return err; |
1da177e4 LT |
549 | } |
550 | if (acard->sb->hardware != SB_HW_16) { | |
69eb8882 | 551 | snd_printk(KERN_ERR PFX "SB16 not found during probe\n"); |
acdcbc15 | 552 | return err; |
1da177e4 LT |
553 | } |
554 | ||
760fc6b8 | 555 | snd_wss_out(acard->wss, CS4231_MISC_INFO, 0x40); /* switch on MODE2 */ |
1da177e4 | 556 | for (i = CMI8330_RMUX3D; i <= CMI8330_CDINGAIN; i++) |
760fc6b8 KH |
557 | snd_wss_out(acard->wss, i, |
558 | snd_cmi8330_image[i - CMI8330_RMUX3D]); | |
1da177e4 LT |
559 | |
560 | if ((err = snd_cmi8330_mixer(card, acard)) < 0) { | |
43bcd973 | 561 | snd_printk(KERN_ERR PFX "failed to create mixers\n"); |
acdcbc15 | 562 | return err; |
1da177e4 LT |
563 | } |
564 | ||
565 | if ((err = snd_cmi8330_pcm(card, acard)) < 0) { | |
43bcd973 | 566 | snd_printk(KERN_ERR PFX "failed to create pcms\n"); |
acdcbc15 | 567 | return err; |
1da177e4 | 568 | } |
48972cc5 KH |
569 | if (fmport[dev] != SNDRV_AUTO_PORT) { |
570 | if (snd_opl3_create(card, | |
571 | fmport[dev], fmport[dev] + 2, | |
572 | OPL3_HW_AUTO, 0, &opl3) < 0) { | |
573 | snd_printk(KERN_ERR PFX | |
574 | "no OPL device at 0x%lx-0x%lx ?\n", | |
575 | fmport[dev], fmport[dev] + 2); | |
576 | } else { | |
48972cc5 KH |
577 | err = snd_opl3_hwdep_new(opl3, 0, 1, NULL); |
578 | if (err < 0) | |
579 | return err; | |
580 | } | |
581 | } | |
582 | ||
c97dff84 KH |
583 | if (mpuport[dev] != SNDRV_AUTO_PORT) { |
584 | if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, | |
585 | mpuport[dev], 0, mpuirq[dev], | |
dba8b469 | 586 | NULL) < 0) |
c97dff84 KH |
587 | printk(KERN_ERR PFX "no MPU-401 device at 0x%lx.\n", |
588 | mpuport[dev]); | |
589 | } | |
1da177e4 | 590 | |
69eb8882 OZ |
591 | strcpy(card->driver, (acard->type == CMI8329) ? "CMI8329" : "CMI8330/C3D"); |
592 | strcpy(card->shortname, (acard->type == CMI8329) ? "C-Media CMI8329" : "C-Media CMI8330/C3D"); | |
1da177e4 LT |
593 | sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d", |
594 | card->shortname, | |
595 | acard->wss->port, | |
596 | wssirq[dev], | |
597 | wssdma[dev]); | |
598 | ||
acdcbc15 TI |
599 | return snd_card_register(card); |
600 | } | |
601 | ||
1bff292e BP |
602 | static int snd_cmi8330_isa_match(struct device *pdev, |
603 | unsigned int dev) | |
acdcbc15 | 604 | { |
5e24c1c1 TI |
605 | if (!enable[dev] || is_isapnp_selected(dev)) |
606 | return 0; | |
acdcbc15 TI |
607 | if (wssport[dev] == SNDRV_AUTO_PORT) { |
608 | snd_printk(KERN_ERR PFX "specify wssport\n"); | |
5e24c1c1 | 609 | return 0; |
acdcbc15 TI |
610 | } |
611 | if (sbport[dev] == SNDRV_AUTO_PORT) { | |
612 | snd_printk(KERN_ERR PFX "specify sbport\n"); | |
5e24c1c1 | 613 | return 0; |
acdcbc15 | 614 | } |
5e24c1c1 TI |
615 | return 1; |
616 | } | |
617 | ||
1bff292e BP |
618 | static int snd_cmi8330_isa_probe(struct device *pdev, |
619 | unsigned int dev) | |
5e24c1c1 TI |
620 | { |
621 | struct snd_card *card; | |
622 | int err; | |
1da177e4 | 623 | |
4323cc4d | 624 | err = snd_cmi8330_card_new(pdev, dev, &card); |
c95eadd2 TI |
625 | if (err < 0) |
626 | return err; | |
acdcbc15 TI |
627 | if ((err = snd_cmi8330_probe(card, dev)) < 0) { |
628 | snd_card_free(card); | |
629 | return err; | |
630 | } | |
5e24c1c1 | 631 | dev_set_drvdata(pdev, card); |
1da177e4 | 632 | return 0; |
acdcbc15 TI |
633 | } |
634 | ||
1bff292e BP |
635 | static int snd_cmi8330_isa_remove(struct device *devptr, |
636 | unsigned int dev) | |
acdcbc15 | 637 | { |
5e24c1c1 | 638 | snd_card_free(dev_get_drvdata(devptr)); |
acdcbc15 TI |
639 | return 0; |
640 | } | |
43bcd973 | 641 | |
acdcbc15 | 642 | #ifdef CONFIG_PM |
5e24c1c1 TI |
643 | static int snd_cmi8330_isa_suspend(struct device *dev, unsigned int n, |
644 | pm_message_t state) | |
acdcbc15 | 645 | { |
5e24c1c1 | 646 | return snd_cmi8330_suspend(dev_get_drvdata(dev)); |
1da177e4 LT |
647 | } |
648 | ||
5e24c1c1 | 649 | static int snd_cmi8330_isa_resume(struct device *dev, unsigned int n) |
acdcbc15 | 650 | { |
5e24c1c1 | 651 | return snd_cmi8330_resume(dev_get_drvdata(dev)); |
acdcbc15 TI |
652 | } |
653 | #endif | |
654 | ||
83c51c0a | 655 | #define DEV_NAME "cmi8330" |
acdcbc15 | 656 | |
5e24c1c1 TI |
657 | static struct isa_driver snd_cmi8330_driver = { |
658 | .match = snd_cmi8330_isa_match, | |
659 | .probe = snd_cmi8330_isa_probe, | |
1bff292e | 660 | .remove = snd_cmi8330_isa_remove, |
acdcbc15 | 661 | #ifdef CONFIG_PM |
5e24c1c1 TI |
662 | .suspend = snd_cmi8330_isa_suspend, |
663 | .resume = snd_cmi8330_isa_resume, | |
acdcbc15 TI |
664 | #endif |
665 | .driver = { | |
83c51c0a | 666 | .name = DEV_NAME |
acdcbc15 TI |
667 | }, |
668 | }; | |
669 | ||
670 | ||
1da177e4 | 671 | #ifdef CONFIG_PNP |
1bff292e BP |
672 | static int snd_cmi8330_pnp_detect(struct pnp_card_link *pcard, |
673 | const struct pnp_card_device_id *pid) | |
1da177e4 LT |
674 | { |
675 | static int dev; | |
acdcbc15 | 676 | struct snd_card *card; |
1da177e4 LT |
677 | int res; |
678 | ||
679 | for ( ; dev < SNDRV_CARDS; dev++) { | |
acdcbc15 TI |
680 | if (enable[dev] && isapnp[dev]) |
681 | break; | |
682 | } | |
683 | if (dev >= SNDRV_CARDS) | |
684 | return -ENODEV; | |
685 | ||
4323cc4d | 686 | res = snd_cmi8330_card_new(&pcard->card->dev, dev, &card); |
c95eadd2 TI |
687 | if (res < 0) |
688 | return res; | |
acdcbc15 TI |
689 | if ((res = snd_cmi8330_pnp(dev, card->private_data, pcard, pid)) < 0) { |
690 | snd_printk(KERN_ERR PFX "PnP detection failed\n"); | |
691 | snd_card_free(card); | |
692 | return res; | |
693 | } | |
acdcbc15 TI |
694 | if ((res = snd_cmi8330_probe(card, dev)) < 0) { |
695 | snd_card_free(card); | |
696 | return res; | |
1da177e4 | 697 | } |
acdcbc15 TI |
698 | pnp_set_card_drvdata(pcard, card); |
699 | dev++; | |
700 | return 0; | |
1da177e4 LT |
701 | } |
702 | ||
1bff292e | 703 | static void snd_cmi8330_pnp_remove(struct pnp_card_link *pcard) |
1da177e4 | 704 | { |
acdcbc15 TI |
705 | snd_card_free(pnp_get_card_drvdata(pcard)); |
706 | pnp_set_card_drvdata(pcard, NULL); | |
707 | } | |
1da177e4 | 708 | |
acdcbc15 TI |
709 | #ifdef CONFIG_PM |
710 | static int snd_cmi8330_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state) | |
711 | { | |
712 | return snd_cmi8330_suspend(pnp_get_card_drvdata(pcard)); | |
1da177e4 LT |
713 | } |
714 | ||
acdcbc15 TI |
715 | static int snd_cmi8330_pnp_resume(struct pnp_card_link *pcard) |
716 | { | |
717 | return snd_cmi8330_resume(pnp_get_card_drvdata(pcard)); | |
718 | } | |
719 | #endif | |
720 | ||
1da177e4 LT |
721 | static struct pnp_card_driver cmi8330_pnpc_driver = { |
722 | .flags = PNP_DRIVER_RES_DISABLE, | |
723 | .name = "cmi8330", | |
724 | .id_table = snd_cmi8330_pnpids, | |
725 | .probe = snd_cmi8330_pnp_detect, | |
1bff292e | 726 | .remove = snd_cmi8330_pnp_remove, |
acdcbc15 TI |
727 | #ifdef CONFIG_PM |
728 | .suspend = snd_cmi8330_pnp_suspend, | |
729 | .resume = snd_cmi8330_pnp_resume, | |
730 | #endif | |
1da177e4 LT |
731 | }; |
732 | #endif /* CONFIG_PNP */ | |
733 | ||
734 | static int __init alsa_card_cmi8330_init(void) | |
735 | { | |
5e24c1c1 | 736 | int err; |
1da177e4 | 737 | |
5e24c1c1 | 738 | err = isa_register_driver(&snd_cmi8330_driver, SNDRV_CARDS); |
59b1b34f | 739 | #ifdef CONFIG_PNP |
609d7694 RH |
740 | if (!err) |
741 | isa_registered = 1; | |
742 | ||
acdcbc15 | 743 | err = pnp_register_card_driver(&cmi8330_pnpc_driver); |
5e24c1c1 | 744 | if (!err) |
f7a9275d | 745 | pnp_registered = 1; |
609d7694 RH |
746 | |
747 | if (isa_registered) | |
748 | err = 0; | |
59b1b34f | 749 | #endif |
609d7694 | 750 | return err; |
1da177e4 LT |
751 | } |
752 | ||
753 | static void __exit alsa_card_cmi8330_exit(void) | |
754 | { | |
5e24c1c1 TI |
755 | #ifdef CONFIG_PNP |
756 | if (pnp_registered) | |
757 | pnp_unregister_card_driver(&cmi8330_pnpc_driver); | |
609d7694 RH |
758 | |
759 | if (isa_registered) | |
5e24c1c1 | 760 | #endif |
609d7694 | 761 | isa_unregister_driver(&snd_cmi8330_driver); |
1da177e4 LT |
762 | } |
763 | ||
764 | module_init(alsa_card_cmi8330_init) | |
765 | module_exit(alsa_card_cmi8330_exit) |