Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: GPL/alsa-kernel/isa/cmi8330.c@ 18

Last change on this file since 18 was 18, checked in by vladest, 20 years ago
initial import
File size: 18.0 KB

Line
1	/*
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
5	*
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.
10	*
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.
15	*
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., 675 Mass Ave, Cambridge, MA 02139, USA.
19	*
20	*/
21
22	/*
23	* NOTES
24	*
25	* The extended registers contain mixer settings which are largely
26	* untapped for the time being.
27	*
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.
30	*
31	* To quickly load the module,
32	*
33	* modprobe -a snd-card-cmi8330 snd_sbport=0x220 snd_sbirq=5 snd_sbdma8=1
34	* snd_sbdma16=5 snd_wssport=0x530 snd_wssirq=11 snd_wssdma=0
35	*
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
40	* to some extent.
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.
44	*/
45
46	#define SNDRV_MAIN_OBJECT_FILE
47
48	#include <sound/driver.h>
49	#include <sound/ad1848.h>
50	#include <sound/sb.h>
51	#define SNDRV_GET_ID
52	#include <sound/initval.h>
53
54	EXPORT_NO_SYMBOLS;
55	MODULE_DESCRIPTION("C-Media CMI8330");
56	MODULE_CLASSES("{sound}");
57	MODULE_DEVICES("{{C-Media,CMI8330,isapnp:{CMI0001,@@@0001,@X@0001}}}");
58
59	static int snd_index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
60	static char *snd_id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
61	static int snd_enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;
62	#ifdef __ISAPNP__
63	#ifdef TARGET_OS2
64	static int snd_isapnp[SNDRV_CARDS] = {REPEAT_SNDRV(1)};
65	#else
66	static int snd_isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
67	#endif
68	#endif
69	static long snd_sbport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
70	static int snd_sbirq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
71	static int snd_sbdma8[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
72	static int snd_sbdma16[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
73	static long snd_wssport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
74	static int snd_wssirq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
75	static int snd_wssdma[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
76
77	MODULE_AUTHOR("George Talusan <gstalusan@uwaterloo.ca>");
78	MODULE_PARM(snd_index, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
79	MODULE_PARM_DESC(snd_index, "Index value for CMI8330 soundcard.");
80	MODULE_PARM_SYNTAX(snd_index, SNDRV_INDEX_DESC);
81	MODULE_PARM(snd_id, "1-" __MODULE_STRING(SNDRV_CARDS) "s");
82	MODULE_PARM_DESC(snd_id, "ID string for CMI8330 soundcard.");
83	MODULE_PARM_SYNTAX(snd_id, SNDRV_ID_DESC);
84	MODULE_PARM(snd_enable, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
85	MODULE_PARM_DESC(snd_enable, "Enable CMI8330 soundcard.");
86	MODULE_PARM_SYNTAX(snd_enable, SNDRV_ENABLE_DESC);
87	#ifdef __ISAPNP__
88	MODULE_PARM(snd_isapnp, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
89	MODULE_PARM_DESC(snd_isapnp, "ISA PnP detection for specified soundcard.");
90	MODULE_PARM_SYNTAX(snd_isapnp, SNDRV_ISAPNP_DESC);
91	#endif
92
93	MODULE_PARM(snd_sbport, "1-" __MODULE_STRING(SNDRV_CARDS) "l");
94	MODULE_PARM_DESC(snd_sbport, "Port # for CMI8330 SB driver.");
95	MODULE_PARM_SYNTAX(snd_sbport, SNDRV_ENABLED ",allows:{{0x220,0x280,0x20}},prefers:{0x220},base:16,dialog:list");
96	MODULE_PARM(snd_sbirq, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
97	MODULE_PARM_DESC(snd_sbirq, "IRQ # for CMI8330 SB driver.");
98	MODULE_PARM_SYNTAX(snd_sbirq, SNDRV_ENABLED ",allows:{{5},{7},{9},{10},{11},{12}},prefers:{5},dialog:list");
99	MODULE_PARM(snd_sbdma8, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
100	MODULE_PARM_DESC(snd_sbdma8, "DMA8 for CMI8330 SB driver.");
101	MODULE_PARM_SYNTAX(snd_sbdma8, SNDRV_DMA8_DESC ",prefers:{1}");
102	MODULE_PARM(snd_sbdma16, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
103	MODULE_PARM_DESC(snd_sbdma16, "DMA16 for CMI8330 SB driver.");
104	MODULE_PARM_SYNTAX(snd_sbdma16, SNDRV_ENABLED ",allows:{{5},{7}},prefers:{5},dialog:list");
105
106	MODULE_PARM(snd_wssport, "1-" __MODULE_STRING(SNDRV_CARDS) "l");
107	MODULE_PARM_DESC(snd_wssport, "Port # for CMI8330 WSS driver.");
108	MODULE_PARM_SYNTAX(snd_wssport, SNDRV_ENABLED ",allows:{{0x530},{0xe80,0xf40,0xc0}},prefers:{0x530},base:16,dialog:list");
109	MODULE_PARM(snd_wssirq, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
110	MODULE_PARM_DESC(snd_wssirq, "IRQ # for CMI8330 WSS driver.");
111	MODULE_PARM_SYNTAX(snd_wssirq, SNDRV_ENABLED ",allows:{{5},{7},{9},{10},{11},{12}},prefers:{11},dialog:list");
112	MODULE_PARM(snd_wssdma, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
113	MODULE_PARM_DESC(snd_wssdma, "DMA for CMI8330 WSS driver.");
114	MODULE_PARM_SYNTAX(snd_wssdma, SNDRV_DMA8_DESC ",prefers:{0}");
115
116	#define CMI8330_RMUX3D 16
117	#define CMI8330_MUTEMUX 17
118	#define CMI8330_OUTPUTVOL 18
119	#define CMI8330_MASTVOL 19
120	#define CMI8330_LINVOL 20
121	#define CMI8330_CDINVOL 21
122	#define CMI8330_WAVVOL 22
123	#define CMI8330_RECMUX 23
124	#define CMI8330_WAVGAIN 24
125	#define CMI8330_LINGAIN 25
126	#define CMI8330_CDINGAIN 26
127
128	static unsigned char snd_cmi8330_image[((CMI8330_CDINGAIN)-16) + 1] =
129	{
130	0x0, /* 16 - recording mux */
131	0x40, /* 17 - mute mux */
132	0x0, /* 18 - vol */
133	0x0, /* 19 - master volume */
134	0x0, /* 20 - line-in volume */
135	0x0, /* 21 - cd-in volume */
136	0x0, /* 22 - wave volume */
137	0x0, /* 23 - mute/rec mux */
138	0x0, /* 24 - wave rec gain */
139	0x0, /* 25 - line-in rec gain */
140	0x0 /* 26 - cd-in rec gain */
141	};
142
143	struct snd_cmi8330 {
144	#ifdef __ISAPNP__
145	struct isapnp_dev *cap;
146	struct isapnp_dev *play;
147	#endif
148	};
149
150	static snd_card_t *snd_cmi8330_cards[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
151
152	#ifdef __ISAPNP__
153
154	static struct isapnp_card *snd_cmi8330_isapnp_cards[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
155	static const struct isapnp_card_id *snd_cmi8330_isapnp_id[SNDRV_CARDS] __devinitdata = SNDRV_DEFAULT_PTR;
156
157	#ifdef TARGET_OS2
158	#define ISAPNP_CMI8330(_va, _vb, _vc, _device, _audio1, _audio2) \
159	{ \
160	0, ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
161	{ ISAPNP_DEVICE_ID('@', '@', '@', _audio1), \
162	ISAPNP_DEVICE_ID('@', 'X', '@', _audio2), } \
163	}
164	#else
165	#define ISAPNP_CMI8330(_va, _vb, _vc, _device, _audio1, _audio2) \
166	{ \
167	ISAPNP_CARD_ID(_va, _vb, _vc, _device), \
168	devs : { ISAPNP_DEVICE_ID('@', '@', '@', _audio1), \
169	ISAPNP_DEVICE_ID('@', 'X', '@', _audio2), } \
170	}
171	#endif
172
173	static struct isapnp_card_id snd_cmi8330_pnpids[] __devinitdata =
174	{
175	ISAPNP_CMI8330('C','M','I',0x0001,0x0001,0x0001),
176	{ ISAPNP_CARD_END, }
177	};
178
179	ISAPNP_CARD_TABLE(snd_cmi8330_pnpids);
180
181	#endif
182
183	#define CMI8330_CONTROLS (sizeof(snd_cmi8330_controls)/sizeof(snd_kcontrol_new_t))
184
185	static snd_kcontrol_new_t snd_cmi8330_controls[] __devinitdata = {
186	AD1848_DOUBLE("Master Playback Volume", 0, CMI8330_MASTVOL, CMI8330_MASTVOL, 4, 0, 15, 0),
187	AD1848_SINGLE("Loud Playback Switch", 0, CMI8330_MUTEMUX, 6, 1, 1),
188	AD1848_DOUBLE("PCM Playback Switch", 0, AD1848_LEFT_OUTPUT, AD1848_RIGHT_OUTPUT, 7, 7, 1, 1),
189	AD1848_DOUBLE("PCM Playback Volume", 0, AD1848_LEFT_OUTPUT, AD1848_RIGHT_OUTPUT, 0, 0, 63, 0),
190	AD1848_DOUBLE("Line Playback Switch", 0, CMI8330_MUTEMUX, CMI8330_MUTEMUX, 4, 3, 1, 0),
191	AD1848_DOUBLE("Line Playback Volume", 0, CMI8330_LINVOL, CMI8330_LINVOL, 4, 0, 15, 0),
192	AD1848_DOUBLE("Line Capture Switch", 0, CMI8330_RMUX3D, CMI8330_RMUX3D, 2, 1, 1, 0),
193	AD1848_DOUBLE("Line Capture Volume", 0, CMI8330_LINGAIN, CMI8330_LINGAIN, 4, 0, 15, 0),
194	AD1848_DOUBLE("CD Playback Switch", 0, CMI8330_MUTEMUX, CMI8330_MUTEMUX, 2, 1, 1, 0),
195	AD1848_DOUBLE("CD Capture Switch", 0, CMI8330_RMUX3D, CMI8330_RMUX3D, 4, 3, 1, 0),
196	AD1848_DOUBLE("CD Playback Volume", 0, CMI8330_CDINVOL, CMI8330_CDINVOL, 4, 0, 15, 0),
197	AD1848_DOUBLE("CD Capture Switch", 0, CMI8330_CDINGAIN, CMI8330_CDINGAIN, 4, 0, 15, 0),
198	AD1848_SINGLE("Mic Playback Switch", 0, CMI8330_MUTEMUX, 0, 1, 0),
199	AD1848_SINGLE("Mic Playback Volume", 0, CMI8330_OUTPUTVOL, 0, 7, 0),
200	AD1848_SINGLE("Mic Capture Switch", 0, CMI8330_RMUX3D, 0, 1, 0),
201	AD1848_SINGLE("Mic Capture Volume", 0, CMI8330_OUTPUTVOL, 5, 7, 0),
202	AD1848_DOUBLE("Wavetable Playback Switch", 0, CMI8330_RECMUX, CMI8330_RECMUX, 1, 0, 1, 0),
203	AD1848_DOUBLE("Wavetable Playback Volume", 0, CMI8330_WAVVOL, CMI8330_WAVVOL, 4, 0, 15, 0),
204	AD1848_DOUBLE("Wavetable Capture Switch", 0, CMI8330_RECMUX, CMI8330_RECMUX, 5, 4, 1, 0),
205	AD1848_DOUBLE("Wavetable Capture Volume", 0, CMI8330_WAVGAIN, CMI8330_WAVGAIN, 4, 0, 15, 0),
206	AD1848_SINGLE("3D Control - Switch", 0, CMI8330_RMUX3D, 5, 1, 1),
207	AD1848_SINGLE("PC Speaker Playback Volume", 0, CMI8330_OUTPUTVOL, 3, 3, 0),
208	AD1848_SINGLE("FM Playback Switch", 0, CMI8330_RECMUX, 3, 1, 1),
209	AD1848_SINGLE("IEC958 Input Capture Switch", 0, CMI8330_RMUX3D, 7, 1, 1),
210	AD1848_SINGLE("IEC958 Input Playback Switch", 0, CMI8330_MUTEMUX, 7, 1, 1),
211	};
212
213	static int __init snd_cmi8330_mixer(snd_card_t card, ad1848_t chip)
214	{
215	int idx, err;
216
217	strcpy(card->mixername, "CMI8330/C3D");
218
219	for (idx = 0; idx < CMI8330_CONTROLS; idx++)
220	if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_cmi8330_controls[idx], chip))) < 0)
221	return err;
222
223	return 0;
224	}
225
226	#ifdef __ISAPNP__
227	static int __init snd_cmi8330_isapnp(int dev, struct snd_cmi8330 *acard)
228	{
229	const struct isapnp_card_id *id = snd_cmi8330_isapnp_id[dev];
230	struct isapnp_card *card = snd_cmi8330_isapnp_cards[dev];
231	struct isapnp_dev *pdev;
232
233	acard->cap = isapnp_find_dev(card, id->devs[0].vendor, id->devs[0].function, NULL);
234	if (acard->cap->active) {
235	acard->cap = NULL;
236	return -EBUSY;
237	}
238	acard->play = isapnp_find_dev(card, id->devs[1].vendor, id->devs[1].function, NULL);
239	if (acard->play->active) {
240	acard->cap = acard->play = NULL;
241	return -EBUSY;
242	}
243
244	pdev = acard->cap;
245	if (pdev->prepare(pdev)<0)
246	return -EAGAIN;
247	/* allocate AD1848 resources */
248	if (snd_wssport[dev] != SNDRV_AUTO_PORT)
249	isapnp_resource_change(&pdev->resource[0], snd_wssport[dev], 8);
250	if (snd_wssdma[dev] != SNDRV_AUTO_DMA)
251	isapnp_resource_change(&pdev->dma_resource[0], snd_wssdma[dev], 1);
252	if (snd_wssirq[dev] != SNDRV_AUTO_IRQ)
253	isapnp_resource_change(&pdev->irq_resource[0], snd_wssirq[dev], 1);
254
255	if (pdev->activate(pdev)<0) {
256	snd_printk("(AD1848) PnP configure failure\n");
257	return -EBUSY;
258	}
259	snd_wssport[dev] = pdev->resource[0].start;
260	snd_wssdma[dev] = pdev->dma_resource[0].start;
261	snd_wssirq[dev] = pdev->irq_resource[0].start;
262
263	/* allocate SB16 resources */
264	pdev = acard->play;
265	if (pdev->prepare(pdev)<0) {
266	acard->cap->deactivate(acard->cap);
267	return -EAGAIN;
268	}
269	if (snd_sbport[dev] != SNDRV_AUTO_PORT)
270	isapnp_resource_change(&pdev->resource[0], snd_sbport[dev], 16);
271	if (snd_sbdma8[dev] != SNDRV_AUTO_DMA)
272	isapnp_resource_change(&pdev->dma_resource[0], snd_sbdma8[dev], 1);
273	if (snd_sbdma16[dev] != SNDRV_AUTO_DMA)
274	isapnp_resource_change(&pdev->dma_resource[1], snd_sbdma16[dev], 1);
275	if (snd_sbirq[dev] != SNDRV_AUTO_IRQ)
276	isapnp_resource_change(&pdev->irq_resource[0], snd_sbirq[dev], 1);
277
278	if (pdev->activate(pdev)<0) {
279	snd_printk("CMI8330/C3D (SB16) PnP configure failure\n");
280	acard->cap->deactivate(acard->cap);
281	return -EBUSY;
282	}
283	snd_sbport[dev] = pdev->resource[0].start;
284	snd_sbdma8[dev] = pdev->dma_resource[0].start;
285	snd_sbdma16[dev] = pdev->dma_resource[1].start;
286	snd_sbirq[dev] = pdev->irq_resource[0].start;
287
288	return 0;
289	}
290
291	static void snd_cmi8330_deactivate(struct snd_cmi8330 *acard)
292	{
293	if (acard->cap) {
294	acard->cap->deactivate(acard->cap);
295	acard->cap = NULL;
296	}
297	if (acard->play) {
298	acard->play->deactivate(acard->play);
299	acard->play = NULL;
300	}
301	}
302	#endif
303
304	static void snd_cmi8330_free(snd_card_t *card)
305	{
306	struct snd_cmi8330 acard = (struct snd_cmi8330 )card->private_data;
307
308	if (acard) {
309	#ifdef __ISAPNP__
310	snd_cmi8330_deactivate(acard);
311	#endif
312	}
313	}
314
315	static int __init snd_cmi8330_probe(int dev)
316	{
317	snd_card_t *card;
318	struct snd_cmi8330 *acard;
319	ad1848_t *chip_wss;
320	sb_t *chip_sb;
321	unsigned long flags;
322	int i, err;
323	snd_pcm_t pcm, wss_pcm, *sb_pcm;
324	snd_pcm_str_t *pstr;
325
326	#ifdef __ISAPNP__
327	if (!snd_isapnp[dev]) {
328	#endif
329	if (snd_wssport[dev] == SNDRV_AUTO_PORT) {
330	snd_printk("specify snd_wssport\n");
331	return -EINVAL;
332	}
333	if (snd_sbport[dev] == SNDRV_AUTO_PORT) {
334	snd_printk("specify snd_sbport\n");
335	return -EINVAL;
336	}
337	#ifdef __ISAPNP__
338	}
339	#endif
340	card = snd_card_new(snd_index[dev], snd_id[dev], THIS_MODULE,
341	sizeof(struct snd_cmi8330));
342	if (card == NULL) {
343	snd_printk("could not get a new card\n");
344	return -ENOMEM;
345	}
346	acard = (struct snd_cmi8330 *)card->private_data;
347	card->private_free = snd_cmi8330_free;
348
349	#ifdef __ISAPNP__
350	if (snd_isapnp[dev] && (err = snd_cmi8330_isapnp(dev, acard)) < 0) {
351	snd_printk("PnP detection failed\n");
352	snd_card_free(card);
353	return err;
354	}
355	#endif
356
357	if ((err = snd_ad1848_create(card,
358	snd_wssport[dev] + 4,
359	snd_wssirq[dev],
360	snd_wssdma[dev],
361	AD1848_HW_DETECT,
362	&chip_wss)) < 0) {
363	snd_printk("(AD1848) device busy??\n");
364	snd_card_free(card);
365	return err;
366	}
367	if (chip_wss->hardware != AD1848_HW_CMI8330) {
368	snd_printk("(AD1848) not found during probe\n");
369	snd_card_free(card);
370	return -ENODEV;
371	}
372	if ((err = snd_ad1848_pcm(chip_wss, 0, &wss_pcm)) < 0) {
373	snd_printk("(AD1848) no enough memory??\n");
374	snd_card_free(card);
375	return err;
376	}
377
378	if ((err = snd_sbdsp_create(card, snd_sbport[dev],
379	snd_sbirq[dev],
380	snd_sb16dsp_interrupt,
381	snd_sbdma8[dev],
382	snd_sbdma16[dev],
383	SB_HW_AUTO, &chip_sb)) < 0) {
384	snd_printk("(SB16) device busy??\n");
385	snd_card_free(card);
386	return err;
387	}
388	if ((err = snd_sb16dsp_pcm(chip_sb, 1, &sb_pcm)) < 0) {
389	snd_printk("(SB16) no enough memory??\n");
390	snd_card_free(card);
391	return err;
392	}
393
394	if (chip_sb->hardware != SB_HW_16) {
395	snd_printk("(SB16) not found during probe\n");
396	snd_card_free(card);
397	return -ENODEV;
398	}
399
400	memcpy(&chip_wss->image[16], &snd_cmi8330_image, sizeof(snd_cmi8330_image));
401
402	spin_lock_irqsave(&chip_wss->reg_lock, flags);
403	snd_ad1848_out(chip_wss, AD1848_MISC_INFO, /* switch on MODE2 */
404	chip_wss->image[AD1848_MISC_INFO] \|= 0x40);
405	spin_unlock_irqrestore(&chip_wss->reg_lock, flags);
406
407	if ((err = snd_cmi8330_mixer(card, chip_wss)) < 0) {
408	snd_printk("failed to create mixers\n");
409	snd_card_free(card);
410	return err;
411	}
412	spin_lock_irqsave(&chip_wss->reg_lock, flags);
413	for (i = CMI8330_RMUX3D; i <= CMI8330_CDINGAIN; i++)
414	snd_ad1848_out(chip_wss, i, chip_wss->image[i]);
415	spin_unlock_irqrestore(&chip_wss->reg_lock, flags);
416
417	/*
418	* KLUDGE ALERT
419	* disable AD1848 playback
420	* disable SB16 capture
421	*/
422	pcm = wss_pcm;
423	pstr = &pcm->streams[SNDRV_PCM_STREAM_PLAYBACK];
424	snd_magic_kfree(pstr->substream);
425	pstr->substream = 0;
426	pstr->substream_count = 0;
427
428	pcm = sb_pcm;
429	pstr = &pcm->streams[SNDRV_PCM_STREAM_CAPTURE];
430	snd_magic_kfree(pstr->substream);
431	pstr->substream = 0;
432	pstr->substream_count = 0;
433
434	strcpy(card->driver, "CMI8330/C3D");
435	strcpy(card->shortname, "C-Media CMI8330/C3D");
436	sprintf(card->longname, "%s at 0x%lx, irq %d, dma %d",
437	wss_pcm->name,
438	chip_wss->port,
439	snd_wssirq[dev],
440	snd_wssdma[dev]);
441
442	if ((err = snd_card_register(card)) < 0) {
443	snd_card_free(card);
444	return err;
445	}
446
447	snd_cmi8330_cards[dev] = card;
448	return 0;
449	}
450
451	static void __exit alsa_card_cmi8330_exit(void)
452	{
453	int i;
454
455	for (i = 0; i < SNDRV_CARDS; i++)
456	snd_card_free(snd_cmi8330_cards[i]);
457	}
458
459	#ifdef __ISAPNP__
460	static int __init snd_cmi8330_isapnp_detect(struct isapnp_card *card,
461	const struct isapnp_card_id *id)
462	{
463	static int dev = 0;
464	int res;
465
466	for ( ; dev < SNDRV_CARDS; dev++) {
467	if (!snd_enable[dev] \|\| !snd_isapnp[dev])
468	continue;
469	snd_cmi8330_isapnp_cards[dev] = card;
470	snd_cmi8330_isapnp_id[dev] = id;
471	res = snd_cmi8330_probe(dev);
472	if (res < 0)
473	return res;
474	dev++;
475	return 0;
476	}
477	return -ENODEV;
478	}
479	#endif /* __ISAPNP__ */
480
481	static int __init alsa_card_cmi8330_init(void)
482	{
483	int dev, cards = 0;
484
485	for (dev = 0; dev < SNDRV_CARDS; dev++) {
486	if (!snd_enable[dev])
487	continue;
488	#ifdef __ISAPNP__
489	if (snd_isapnp[dev])
490	continue;
491	#endif
492	if (snd_cmi8330_probe(dev) >= 0)
493	cards++;
494	}
495	#ifdef __ISAPNP__
496	cards += isapnp_probe_cards(snd_cmi8330_pnpids, snd_cmi8330_isapnp_detect);
497	#endif
498
499	if (!cards) {
500	#ifdef MODULE
501	snd_printk("CMI8330 not found or device busy\n");
502	#endif
503	return -ENODEV;
504	}
505	return 0;
506	}
507
508	module_init(alsa_card_cmi8330_init)
509	module_exit(alsa_card_cmi8330_exit)
510
511	#ifndef MODULE
512
513	/* format is: snd-card-cmi8330=snd_enable,snd_index,snd_id,snd_isapnp,
514	snd_sbport,snd_sbirq,
515	snd_sbdma8,snd_sbdma16,
516	snd_wssport,snd_wssirq,
517	snd_wssdma */
518
519	static int __init alsa_card_cmi8330_setup(char *str)
520	{
521	static unsigned __initdata nr_dev = 0;
522	int __attribute__ ((__unused__)) pnp = INT_MAX;
523
524	if (nr_dev >= SNDRV_CARDS)
525	return 0;
526	(void)(get_option(&str,&snd_enable[nr_dev]) == 2 &&
527	get_option(&str,&snd_index[nr_dev]) == 2 &&
528	get_id(&str,&snd_id[nr_dev]) == 2 &&
529	get_option(&str,&pnp) == 2 &&
530	get_option(&str,(int *)&snd_sbport[nr_dev]) == 2 &&
531	get_option(&str,&snd_sbirq[nr_dev]) == 2 &&
532	get_option(&str,&snd_sbdma8[nr_dev]) == 2 &&
533	get_option(&str,&snd_sbdma16[nr_dev]) == 2 &&
534	get_option(&str,&snd_wssport[nr_dev]) == 2 &&
535	get_option(&str,&snd_wssirq[nr_dev]) == 2 &&
536	get_option(&str,&snd_wssdma[nr_dev]) == 2);
537	#ifdef __ISAPNP__
538	if (pnp != INT_MAX)
539	snd_isapnp[nr_dev] = pnp;
540	#endif
541	nr_dev++;
542	return 1;
543	}
544
545	__setup("snd-card-cmi8330=", alsa_card_cmi8330_setup);
546
547	#endif /* ifndef MODULE */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: