1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <sound/driver.h>
23#include <linux/init.h>
24#include <linux/err.h>
25#include <linux/isa.h>
26#include <linux/slab.h>
27#include <linux/pnp.h>
28#include <linux/moduleparam.h>
29#include <sound/core.h>
30#include <sound/cs4231.h>
31#include <sound/mpu401.h>
32#include <sound/opl3.h>
33#include <sound/initval.h>
34
35MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
36MODULE_LICENSE("GPL");
37#ifdef CS4232
38MODULE_DESCRIPTION("Cirrus Logic CS4232");
39MODULE_SUPPORTED_DEVICE("{{Turtle Beach,TBS-2000},"
40 "{Turtle Beach,Tropez Plus},"
41 "{SIC CrystalWave 32},"
42 "{Hewlett Packard,Omnibook 5500},"
43 "{TerraTec,Maestro 32/96},"
44 "{Philips,PCA70PS}}");
45#else
46MODULE_DESCRIPTION("Cirrus Logic CS4235-9");
47MODULE_SUPPORTED_DEVICE("{{Crystal Semiconductors,CS4235},"
48 "{Crystal Semiconductors,CS4236},"
49 "{Crystal Semiconductors,CS4237},"
50 "{Crystal Semiconductors,CS4238},"
51 "{Crystal Semiconductors,CS4239},"
52 "{Acer,AW37},"
53 "{Acer,AW35/Pro},"
54 "{Crystal,3D},"
55 "{Crystal Computer,TidalWave128},"
56 "{Dell,Optiplex GX1},"
57 "{Dell,Workstation 400 sound},"
58 "{EliteGroup,P5TX-LA sound},"
59 "{Gallant,SC-70P},"
60 "{Gateway,E1000 Onboard CS4236B},"
61 "{Genius,Sound Maker 3DJ},"
62 "{Hewlett Packard,HP6330 sound},"
63 "{IBM,PC 300PL sound},"
64 "{IBM,Aptiva 2137 E24},"
65 "{IBM,IntelliStation M Pro},"
66 "{Intel,Marlin Spike Mobo CS4235},"
67 "{Intel PR440FX Onboard},"
68 "{Guillemot,MaxiSound 16 PnP},"
69 "{NewClear,3D},"
70 "{TerraTec,AudioSystem EWS64L/XL},"
71 "{Typhoon Soundsystem,CS4236B},"
72 "{Turtle Beach,Malibu},"
73 "{Unknown,Digital PC 5000 Onboard}}");
74#endif
75
76#ifdef CS4232
77#define IDENT "CS4232"
78#define DEV_NAME "cs4232"
79#else
80#define IDENT "CS4236+"
81#define DEV_NAME "cs4236"
82#endif
83
84static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
85static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
86static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP;
87#ifdef CONFIG_PNP
88static int isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
89#endif
90static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
91static long cport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
92static long mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
93static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
94static long sb_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
95static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
96static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
97static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
98static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
99
100module_param_array(index, int, NULL, 0444);
101MODULE_PARM_DESC(index, "Index value for " IDENT " soundcard.");
102module_param_array(id, charp, NULL, 0444);
103MODULE_PARM_DESC(id, "ID string for " IDENT " soundcard.");
104module_param_array(enable, bool, NULL, 0444);
105MODULE_PARM_DESC(enable, "Enable " IDENT " soundcard.");
106#ifdef CONFIG_PNP
107module_param_array(isapnp, bool, NULL, 0444);
108MODULE_PARM_DESC(isapnp, "ISA PnP detection for specified soundcard.");
109#endif
110module_param_array(port, long, NULL, 0444);
111MODULE_PARM_DESC(port, "Port # for " IDENT " driver.");
112module_param_array(cport, long, NULL, 0444);
113MODULE_PARM_DESC(cport, "Control port # for " IDENT " driver.");
114module_param_array(mpu_port, long, NULL, 0444);
115MODULE_PARM_DESC(mpu_port, "MPU-401 port # for " IDENT " driver.");
116module_param_array(fm_port, long, NULL, 0444);
117MODULE_PARM_DESC(fm_port, "FM port # for " IDENT " driver.");
118module_param_array(sb_port, long, NULL, 0444);
119MODULE_PARM_DESC(sb_port, "SB port # for " IDENT " driver (optional).");
120module_param_array(irq, int, NULL, 0444);
121MODULE_PARM_DESC(irq, "IRQ # for " IDENT " driver.");
122module_param_array(mpu_irq, int, NULL, 0444);
123MODULE_PARM_DESC(mpu_irq, "MPU-401 IRQ # for " IDENT " driver.");
124module_param_array(dma1, int, NULL, 0444);
125MODULE_PARM_DESC(dma1, "DMA1 # for " IDENT " driver.");
126module_param_array(dma2, int, NULL, 0444);
127MODULE_PARM_DESC(dma2, "DMA2 # for " IDENT " driver.");
128
129#ifdef CONFIG_PNP
130static int isa_registered;
131static int pnpc_registered;
132#ifdef CS4232
133static int pnp_registered;
134#endif
135#endif
136
137struct snd_card_cs4236 {
138 struct snd_cs4231 *chip;
139 struct resource *res_sb_port;
140#ifdef CONFIG_PNP
141 struct pnp_dev *wss;
142 struct pnp_dev *ctrl;
143 struct pnp_dev *mpu;
144#endif
145};
146
147#ifdef CONFIG_PNP
148
149#ifdef CS4232
150
151
152
153static const struct pnp_device_id snd_cs4232_pnpbiosids[] = {
154 { .id = "CSC0100" },
155 { .id = "CSC0000" },
156
157
158 { .id = "GIM0100" },
159 { .id = "" }
160};
161MODULE_DEVICE_TABLE(pnp, snd_cs4232_pnpbiosids);
162#endif
163
164#ifdef CS4232
165#define CS423X_ISAPNP_DRIVER "cs4232_isapnp"
166static struct pnp_card_device_id snd_cs423x_pnpids[] = {
167
168 { .id = "CSC0d32", .devs = { { "CSC0000" }, { "CSC0010" }, { "PNPb006" } } },
169
170 { .id = "CSC1a32", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
171
172 { .id = "CSC4232", .devs = { { "CSC0000" }, { "CSC0002" }, { "CSC0003" } } },
173
174 { .id = "CSC4236", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
175
176 { .id = "CSC7532", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSCb006" } } },
177
178 { .id = "CSC7632", .devs = { { "CSC0000" }, { "CSC0010" }, { "PNPb006" } } },
179
180 { .id = "CSCf032", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
181
182 { .id = "CSCe825", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC010f" } } },
183
184 { .id = "" }
185};
186#else
187#define CS423X_ISAPNP_DRIVER "cs4236_isapnp"
188static struct pnp_card_device_id snd_cs423x_pnpids[] = {
189
190 { .id = "CSC0225", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
191
192 { .id = "CSC0225", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } },
193
194 { .id = "CSC0225", .devs = { { "CSC0100" }, { "CSC0110" } } },
195
196 { .id = "CSC0437", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
197
198 { .id = "CSC0735", .devs = { { "CSC0000" }, { "CSC0010" } } },
199
200 { .id = "CSC0b35", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
201
202 { .id = "CSC0b36", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
203
204 { .id = "CSC1425", .devs = { { "CSC0100" }, { "CSC0110" } } },
205
206 { .id = "CSC1335", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
207
208 { .id = "CSC1525", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } },
209
210 { .id = "CSC1e37", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
211
212 { .id = "CSC4236", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
213
214 { .id = "CSC4237", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
215
216 { .id = "CSC4336", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
217
218 { .id = "CSC4536", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
219
220 { .id = "CSC4625", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } },
221
222 { .id = "CSC4637", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
223
224 { .id = "CSC4837", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
225
226 { .id = "CSC6835", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
227
228 { .id = "CSC6835", .devs = { { "CSC0000" }, { "CSC0010" } } },
229
230 { .id = "CSC6836", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
231
232 { .id = "CSC7537", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
233
234 { .id = "CSC8025", .devs = { { "CSC0100" }, { "CSC0110" }, { "CSC0103" } } },
235
236 { .id = "CSC8037", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
237
238 { .id = "CSCc835", .devs = { { "CSC0000" }, { "CSC0010" } } },
239
240 { .id = "CSC9836", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
241
242 { .id = "CSC9837", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
243
244 { .id = "CSCa836", .devs = { { "CSCa800" }, { "CSCa810" }, { "CSCa803" } } },
245
246 { .id = "CSCa836", .devs = { { "CSCa800" }, { "CSCa810" } } },
247
248 { .id = "CSCd925", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
249
250 { .id = "CSCd937", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
251
252 { .id = "CSCe825", .devs = { { "CSC0100" }, { "CSC0110" } } },
253
254 { .id = "CSC4825", .devs = { { "CSC0100" }, { "CSC0110" } } },
255
256 { .id = "CSCe835", .devs = { { "CSC0000" }, { "CSC0010" } } },
257
258 { .id = "CSCe836", .devs = { { "CSC0000" }, { "CSC0010" } } },
259
260 { .id = "CSCe936", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
261
262 { .id = "CSCf235", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
263
264 { .id = "CSCf238", .devs = { { "CSC0000" }, { "CSC0010" }, { "CSC0003" } } },
265
266 { .id = "" }
267};
268#endif
269
270MODULE_DEVICE_TABLE(pnp_card, snd_cs423x_pnpids);
271
272
273static int __devinit snd_cs423x_pnp_init_wss(int dev, struct pnp_dev *pdev,
274 struct pnp_resource_table *cfg)
275{
276 int err;
277
278 pnp_init_resource_table(cfg);
279 if (port[dev] != SNDRV_AUTO_PORT)
280 pnp_resource_change(&cfg->port_resource[0], port[dev], 4);
281 if (fm_port[dev] != SNDRV_AUTO_PORT && fm_port[dev] > 0)
282 pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4);
283 if (sb_port[dev] != SNDRV_AUTO_PORT)
284 pnp_resource_change(&cfg->port_resource[2], sb_port[dev], 16);
285 if (irq[dev] != SNDRV_AUTO_IRQ)
286 pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1);
287 if (dma1[dev] != SNDRV_AUTO_DMA)
288 pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1);
289 if (dma2[dev] != SNDRV_AUTO_DMA)
290 pnp_resource_change(&cfg->dma_resource[1], dma2[dev] < 0 ? 4 : dma2[dev], 1);
291 err = pnp_manual_config_dev(pdev, cfg, 0);
292 if (err < 0)
293 snd_printk(KERN_ERR IDENT " WSS PnP manual resources are invalid, using auto config\n");
294 err = pnp_activate_dev(pdev);
295 if (err < 0) {
296 printk(KERN_ERR IDENT " WSS PnP configure failed for WSS (out of resources?)\n");
297 return -EBUSY;
298 }
299 port[dev] = pnp_port_start(pdev, 0);
300 if (fm_port[dev] > 0)
301 fm_port[dev] = pnp_port_start(pdev, 1);
302 sb_port[dev] = pnp_port_start(pdev, 2);
303 irq[dev] = pnp_irq(pdev, 0);
304 dma1[dev] = pnp_dma(pdev, 0);
305 dma2[dev] = pnp_dma(pdev, 1) == 4 ? -1 : (int)pnp_dma(pdev, 1);
306 snd_printdd("isapnp WSS: wss port=0x%lx, fm port=0x%lx, sb port=0x%lx\n",
307 port[dev], fm_port[dev], sb_port[dev]);
308 snd_printdd("isapnp WSS: irq=%i, dma1=%i, dma2=%i\n",
309 irq[dev], dma1[dev], dma2[dev]);
310 return 0;
311}
312
313
314static int __devinit snd_cs423x_pnp_init_ctrl(int dev, struct pnp_dev *pdev,
315 struct pnp_resource_table *cfg)
316{
317 int err;
318
319 pnp_init_resource_table(cfg);
320 if (cport[dev] != SNDRV_AUTO_PORT)
321 pnp_resource_change(&cfg->port_resource[0], cport[dev], 8);
322 err = pnp_manual_config_dev(pdev, cfg, 0);
323 if (err < 0)
324 snd_printk(KERN_ERR IDENT " CTRL PnP manual resources are invalid, using auto config\n");
325 err = pnp_activate_dev(pdev);
326 if (err < 0) {
327 printk(KERN_ERR IDENT " CTRL PnP configure failed for WSS (out of resources?)\n");
328 return -EBUSY;
329 }
330 cport[dev] = pnp_port_start(pdev, 0);
331 snd_printdd("isapnp CTRL: control port=0x%lx\n", cport[dev]);
332 return 0;
333}
334
335
336static int __devinit snd_cs423x_pnp_init_mpu(int dev, struct pnp_dev *pdev,
337 struct pnp_resource_table *cfg)
338{
339 int err;
340
341 pnp_init_resource_table(cfg);
342 if (mpu_port[dev] != SNDRV_AUTO_PORT)
343 pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2);
344 if (mpu_irq[dev] != SNDRV_AUTO_IRQ && mpu_irq[dev] >= 0)
345 pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1);
346 err = pnp_manual_config_dev(pdev, cfg, 0);
347 if (err < 0)
348 snd_printk(KERN_ERR IDENT " MPU401 PnP manual resources are invalid, using auto config\n");
349 err = pnp_activate_dev(pdev);
350 if (err < 0) {
351 printk(KERN_ERR IDENT " MPU401 PnP configure failed for WSS (out of resources?)\n");
352 mpu_port[dev] = SNDRV_AUTO_PORT;
353 mpu_irq[dev] = SNDRV_AUTO_IRQ;
354 } else {
355 mpu_port[dev] = pnp_port_start(pdev, 0);
356 if (mpu_irq[dev] >= 0 &&
357 pnp_irq_valid(pdev, 0) && pnp_irq(pdev, 0) >= 0) {
358 mpu_irq[dev] = pnp_irq(pdev, 0);
359 } else {
360 mpu_irq[dev] = -1;
361 }
362 }
363 snd_printdd("isapnp MPU: port=0x%lx, irq=%i\n", mpu_port[dev], mpu_irq[dev]);
364 return 0;
365}
366
367#ifdef CS4232
368static int __devinit snd_card_cs4232_pnp(int dev, struct snd_card_cs4236 *acard,
369 struct pnp_dev *pdev)
370{
371 struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
372
373 if (!cfg)
374 return -ENOMEM;
375 if (snd_cs423x_pnp_init_wss(dev, acard->wss, cfg) < 0) {
376 kfree(cfg);
377 return -EBUSY;
378 }
379 kfree(cfg);
380 cport[dev] = -1;
381 return 0;
382}
383#endif
384
385static int __devinit snd_card_cs423x_pnpc(int dev, struct snd_card_cs4236 *acard,
386 struct pnp_card_link *card,
387 const struct pnp_card_device_id *id)
388{
389 struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
390
391 if (!cfg)
392 return -ENOMEM;
393
394 acard->wss = pnp_request_card_device(card, id->devs[0].id, NULL);
395 if (acard->wss == NULL)
396 goto error;
397 acard->ctrl = pnp_request_card_device(card, id->devs[1].id, NULL);
398 if (acard->ctrl == NULL)
399 goto error;
400 if (id->devs[2].id[0]) {
401 acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL);
402 if (acard->mpu == NULL)
403 goto error;
404 }
405
406
407 if (snd_cs423x_pnp_init_wss(dev, acard->wss, cfg) < 0)
408 goto error;
409
410
411 if (acard->ctrl && cport[dev] > 0) {
412 if (snd_cs423x_pnp_init_ctrl(dev, acard->ctrl, cfg) < 0)
413 goto error;
414 }
415
416 if (acard->mpu && mpu_port[dev] > 0) {
417 if (snd_cs423x_pnp_init_mpu(dev, acard->mpu, cfg) < 0)
418 goto error;
419 }
420 kfree(cfg);
421 return 0;
422
423 error:
424 kfree(cfg);
425 return -EBUSY;
426}
427#endif
428
429#ifdef CONFIG_PNP
430#define is_isapnp_selected(dev) isapnp[dev]
431#else
432#define is_isapnp_selected(dev) 0
433#endif
434
435static void snd_card_cs4236_free(struct snd_card *card)
436{
437 struct snd_card_cs4236 *acard = card->private_data;
438
439 release_and_free_resource(acard->res_sb_port);
440}
441
442static struct snd_card *snd_cs423x_card_new(int dev)
443{
444 struct snd_card *card;
445
446 card = snd_card_new(index[dev], id[dev], THIS_MODULE,
447 sizeof(struct snd_card_cs4236));
448 if (card == NULL)
449 return NULL;
450 card->private_free = snd_card_cs4236_free;
451 return card;
452}
453
454static int __devinit snd_cs423x_probe(struct snd_card *card, int dev)
455{
456 struct snd_card_cs4236 *acard;
457 struct snd_pcm *pcm;
458 struct snd_cs4231 *chip;
459 struct snd_opl3 *opl3;
460 int err;
461
462 acard = card->private_data;
463 if (sb_port[dev] > 0 && sb_port[dev] != SNDRV_AUTO_PORT)
464 if ((acard->res_sb_port = request_region(sb_port[dev], 16, IDENT " SB")) == NULL) {
465 printk(KERN_ERR IDENT ": unable to register SB port at 0x%lx\n", sb_port[dev]);
466 return -EBUSY;
467 }
468
469#ifdef CS4232
470 if ((err = snd_cs4231_create(card,
471 port[dev],
472 cport[dev],
473 irq[dev],
474 dma1[dev],
475 dma2[dev],
476 CS4231_HW_DETECT,
477 0,
478 &chip)) < 0)
479 return err;
480 acard->chip = chip;
481
482 if ((err = snd_cs4231_pcm(chip, 0, &pcm)) < 0)
483 return err;
484
485 if ((err = snd_cs4231_mixer(chip)) < 0)
486 return err;
487
488#else
489 if ((err = snd_cs4236_create(card,
490 port[dev],
491 cport[dev],
492 irq[dev],
493 dma1[dev],
494 dma2[dev],
495 CS4231_HW_DETECT,
496 0,
497 &chip)) < 0)
498 return err;
499 acard->chip = chip;
500
501 if ((err = snd_cs4236_pcm(chip, 0, &pcm)) < 0)
502 return err;
503
504 if ((err = snd_cs4236_mixer(chip)) < 0)
505 return err;
506#endif
507 strcpy(card->driver, pcm->name);
508 strcpy(card->shortname, pcm->name);
509 sprintf(card->longname, "%s at 0x%lx, irq %i, dma %i",
510 pcm->name,
511 chip->port,
512 irq[dev],
513 dma1[dev]);
514 if (dma2[dev] >= 0)
515 sprintf(card->longname + strlen(card->longname), "&%d", dma2[dev]);
516
517 if ((err = snd_cs4231_timer(chip, 0, NULL)) < 0)
518 return err;
519
520 if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) {
521 if (snd_opl3_create(card,
522 fm_port[dev], fm_port[dev] + 2,
523 OPL3_HW_OPL3_CS, 0, &opl3) < 0) {
524 printk(KERN_WARNING IDENT ": OPL3 not detected\n");
525 } else {
526 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0)
527 return err;
528 }
529 }
530
531 if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) {
532 if (mpu_irq[dev] == SNDRV_AUTO_IRQ)
533 mpu_irq[dev] = -1;
534 if (snd_mpu401_uart_new(card, 0, MPU401_HW_CS4232,
535 mpu_port[dev], 0,
536 mpu_irq[dev],
537 mpu_irq[dev] >= 0 ? IRQF_DISABLED : 0, NULL) < 0)
538 printk(KERN_WARNING IDENT ": MPU401 not detected\n");
539 }
540
541 return snd_card_register(card);
542}
543
544static int __devinit snd_cs423x_isa_match(struct device *pdev,
545 unsigned int dev)
546{
547 if (!enable[dev] || is_isapnp_selected(dev))
548 return 0;
549
550 if (port[dev] == SNDRV_AUTO_PORT) {
551 snd_printk(KERN_ERR "%s: please specify port\n", pdev->bus_id);
552 return 0;
553 }
554 if (cport[dev] == SNDRV_AUTO_PORT) {
555 snd_printk(KERN_ERR "%s: please specify cport\n", pdev->bus_id);
556 return 0;
557 }
558 if (irq[dev] == SNDRV_AUTO_IRQ) {
559 snd_printk(KERN_ERR "%s: please specify irq\n", pdev->bus_id);
560 return 0;
561 }
562 if (dma1[dev] == SNDRV_AUTO_DMA) {
563 snd_printk(KERN_ERR "%s: please specify dma1\n", pdev->bus_id);
564 return 0;
565 }
566 return 1;
567}
568
569static int __devinit snd_cs423x_isa_probe(struct device *pdev,
570 unsigned int dev)
571{
572 struct snd_card *card;
573 int err;
574
575 card = snd_cs423x_card_new(dev);
576 if (! card)
577 return -ENOMEM;
578 snd_card_set_dev(card, pdev);
579 if ((err = snd_cs423x_probe(card, dev)) < 0) {
580 snd_card_free(card);
581 return err;
582 }
583
584 dev_set_drvdata(pdev, card);
585 return 0;
586}
587
588static int __devexit snd_cs423x_isa_remove(struct device *pdev,
589 unsigned int dev)
590{
591 snd_card_free(dev_get_drvdata(pdev));
592 dev_set_drvdata(pdev, NULL);
593 return 0;
594}
595
596#ifdef CONFIG_PM
597static int snd_cs423x_suspend(struct snd_card *card)
598{
599 struct snd_card_cs4236 *acard = card->private_data;
600 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
601 acard->chip->suspend(acard->chip);
602 return 0;
603}
604
605static int snd_cs423x_resume(struct snd_card *card)
606{
607 struct snd_card_cs4236 *acard = card->private_data;
608 acard->chip->resume(acard->chip);
609 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
610 return 0;
611}
612
613static int snd_cs423x_isa_suspend(struct device *dev, unsigned int n,
614 pm_message_t state)
615{
616 return snd_cs423x_suspend(dev_get_drvdata(dev));
617}
618
619static int snd_cs423x_isa_resume(struct device *dev, unsigned int n)
620{
621 return snd_cs423x_resume(dev_get_drvdata(dev));
622}
623#endif
624
625static struct isa_driver cs423x_isa_driver = {
626 .match = snd_cs423x_isa_match,
627 .probe = snd_cs423x_isa_probe,
628 .remove = __devexit_p(snd_cs423x_isa_remove),
629#ifdef CONFIG_PM
630 .suspend = snd_cs423x_isa_suspend,
631 .resume = snd_cs423x_isa_resume,
632#endif
633 .driver = {
634 .name = DEV_NAME
635 },
636};
637
638
639#ifdef CONFIG_PNP
640#ifdef CS4232
641static int __devinit snd_cs4232_pnpbios_detect(struct pnp_dev *pdev,
642 const struct pnp_device_id *id)
643{
644 static int dev;
645 int err;
646 struct snd_card *card;
647
648 if (pnp_device_is_isapnp(pdev))
649 return -ENOENT;
650 for (; dev < SNDRV_CARDS; dev++) {
651 if (enable[dev] && isapnp[dev])
652 break;
653 }
654 if (dev >= SNDRV_CARDS)
655 return -ENODEV;
656
657 card = snd_cs423x_card_new(dev);
658 if (! card)
659 return -ENOMEM;
660 if ((err = snd_card_cs4232_pnp(dev, card->private_data, pdev)) < 0) {
661 printk(KERN_ERR "PnP BIOS detection failed for " IDENT "\n");
662 snd_card_free(card);
663 return err;
664 }
665 snd_card_set_dev(card, &pdev->dev);
666 if ((err = snd_cs423x_probe(card, dev)) < 0) {
667 snd_card_free(card);
668 return err;
669 }
670 pnp_set_drvdata(pdev, card);
671 dev++;
672 return 0;
673}
674
675static void __devexit snd_cs4232_pnp_remove(struct pnp_dev * pdev)
676{
677 snd_card_free(pnp_get_drvdata(pdev));
678 pnp_set_drvdata(pdev, NULL);
679}
680
681#ifdef CONFIG_PM
682static int snd_cs4232_pnp_suspend(struct pnp_dev *pdev, pm_message_t state)
683{
684 return snd_cs423x_suspend(pnp_get_drvdata(pdev));
685}
686
687static int snd_cs4232_pnp_resume(struct pnp_dev *pdev)
688{
689 return snd_cs423x_resume(pnp_get_drvdata(pdev));
690}
691#endif
692
693static struct pnp_driver cs4232_pnp_driver = {
694 .name = "cs4232-pnpbios",
695 .id_table = snd_cs4232_pnpbiosids,
696 .probe = snd_cs4232_pnpbios_detect,
697 .remove = __devexit_p(snd_cs4232_pnp_remove),
698#ifdef CONFIG_PM
699 .suspend = snd_cs4232_pnp_suspend,
700 .resume = snd_cs4232_pnp_resume,
701#endif
702};
703#endif
704
705static int __devinit snd_cs423x_pnpc_detect(struct pnp_card_link *pcard,
706 const struct pnp_card_device_id *pid)
707{
708 static int dev;
709 struct snd_card *card;
710 int res;
711
712 for ( ; dev < SNDRV_CARDS; dev++) {
713 if (enable[dev] && isapnp[dev])
714 break;
715 }
716 if (dev >= SNDRV_CARDS)
717 return -ENODEV;
718
719 card = snd_cs423x_card_new(dev);
720 if (! card)
721 return -ENOMEM;
722 if ((res = snd_card_cs423x_pnpc(dev, card->private_data, pcard, pid)) < 0) {
723 printk(KERN_ERR "isapnp detection failed and probing for " IDENT
724 " is not supported\n");
725 snd_card_free(card);
726 return res;
727 }
728 snd_card_set_dev(card, &pcard->card->dev);
729 if ((res = snd_cs423x_probe(card, dev)) < 0) {
730 snd_card_free(card);
731 return res;
732 }
733 pnp_set_card_drvdata(pcard, card);
734 dev++;
735 return 0;
736}
737
738static void __devexit snd_cs423x_pnpc_remove(struct pnp_card_link * pcard)
739{
740 snd_card_free(pnp_get_card_drvdata(pcard));
741 pnp_set_card_drvdata(pcard, NULL);
742}
743
744#ifdef CONFIG_PM
745static int snd_cs423x_pnpc_suspend(struct pnp_card_link *pcard, pm_message_t state)
746{
747 return snd_cs423x_suspend(pnp_get_card_drvdata(pcard));
748}
749
750static int snd_cs423x_pnpc_resume(struct pnp_card_link *pcard)
751{
752 return snd_cs423x_resume(pnp_get_card_drvdata(pcard));
753}
754#endif
755
756static struct pnp_card_driver cs423x_pnpc_driver = {
757 .flags = PNP_DRIVER_RES_DISABLE,
758 .name = CS423X_ISAPNP_DRIVER,
759 .id_table = snd_cs423x_pnpids,
760 .probe = snd_cs423x_pnpc_detect,
761 .remove = __devexit_p(snd_cs423x_pnpc_remove),
762#ifdef CONFIG_PM
763 .suspend = snd_cs423x_pnpc_suspend,
764 .resume = snd_cs423x_pnpc_resume,
765#endif
766};
767#endif
768
769static int __init alsa_card_cs423x_init(void)
770{
771 int err;
772
773 err = isa_register_driver(&cs423x_isa_driver, SNDRV_CARDS);
774#ifdef CONFIG_PNP
775 if (!err)
776 isa_registered = 1;
777#ifdef CS4232
778 err = pnp_register_driver(&cs4232_pnp_driver);
779 if (!err)
780 pnp_registered = 1;
781#endif
782 err = pnp_register_card_driver(&cs423x_pnpc_driver);
783 if (!err)
784 pnpc_registered = 1;
785#ifdef CS4232
786 if (pnp_registered)
787 err = 0;
788#endif
789 if (isa_registered)
790 err = 0;
791#endif
792 return err;
793}
794
795static void __exit alsa_card_cs423x_exit(void)
796{
797#ifdef CONFIG_PNP
798 if (pnpc_registered)
799 pnp_unregister_card_driver(&cs423x_pnpc_driver);
800#ifdef CS4232
801 if (pnp_registered)
802 pnp_unregister_driver(&cs4232_pnp_driver);
803#endif
804 if (isa_registered)
805#endif
806 isa_unregister_driver(&cs423x_isa_driver);
807}
808
809module_init(alsa_card_cs423x_init)
810module_exit(alsa_card_cs423x_exit)
811
