Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
wavefront.c
Go to the documentation of this file.
1 /*
2  * ALSA card-level driver for Turtle Beach Wavefront cards
3  * (Maui,Tropez,Tropez+)
4  *
5  * Copyright (c) 1997-1999 by Paul Barton-Davis <[email protected]>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  */
21 
22 #include <linux/init.h>
23 #include <linux/interrupt.h>
24 #include <linux/err.h>
25 #include <linux/isa.h>
26 #include <linux/pnp.h>
27 #include <linux/module.h>
28 #include <sound/core.h>
29 #include <sound/initval.h>
30 #include <sound/opl3.h>
31 #include <sound/wss.h>
32 #include <sound/snd_wavefront.h>
33 
34 MODULE_AUTHOR("Paul Barton-Davis <[email protected]>");
35 MODULE_DESCRIPTION("Turtle Beach Wavefront");
36 MODULE_LICENSE("GPL");
37 MODULE_SUPPORTED_DEVICE("{{Turtle Beach,Maui/Tropez/Tropez+}}");
38 
39 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
40 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
41 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; /* Enable this card */
42 #ifdef CONFIG_PNP
43 static bool isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
44 #endif
45 static long cs4232_pcm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */
46 static int cs4232_pcm_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 5,7,9,11,12,15 */
47 static long cs4232_mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */
48 static int cs4232_mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 9,11,12,15 */
49 static long ics2115_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */
50 static int ics2115_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 2,9,11,12,15 */
51 static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */
52 static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 0,1,3,5,6,7 */
53 static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 0,1,3,5,6,7 */
54 static bool use_cs4232_midi[SNDRV_CARDS];
55 
56 module_param_array(index, int, NULL, 0444);
57 MODULE_PARM_DESC(index, "Index value for WaveFront soundcard.");
58 module_param_array(id, charp, NULL, 0444);
59 MODULE_PARM_DESC(id, "ID string for WaveFront soundcard.");
60 module_param_array(enable, bool, NULL, 0444);
61 MODULE_PARM_DESC(enable, "Enable WaveFront soundcard.");
62 #ifdef CONFIG_PNP
63 module_param_array(isapnp, bool, NULL, 0444);
64 MODULE_PARM_DESC(isapnp, "ISA PnP detection for WaveFront soundcards.");
65 #endif
66 module_param_array(cs4232_pcm_port, long, NULL, 0444);
67 MODULE_PARM_DESC(cs4232_pcm_port, "Port # for CS4232 PCM interface.");
68 module_param_array(cs4232_pcm_irq, int, NULL, 0444);
69 MODULE_PARM_DESC(cs4232_pcm_irq, "IRQ # for CS4232 PCM interface.");
70 module_param_array(dma1, int, NULL, 0444);
71 MODULE_PARM_DESC(dma1, "DMA1 # for CS4232 PCM interface.");
72 module_param_array(dma2, int, NULL, 0444);
73 MODULE_PARM_DESC(dma2, "DMA2 # for CS4232 PCM interface.");
74 module_param_array(cs4232_mpu_port, long, NULL, 0444);
75 MODULE_PARM_DESC(cs4232_mpu_port, "port # for CS4232 MPU-401 interface.");
76 module_param_array(cs4232_mpu_irq, int, NULL, 0444);
77 MODULE_PARM_DESC(cs4232_mpu_irq, "IRQ # for CS4232 MPU-401 interface.");
78 module_param_array(ics2115_irq, int, NULL, 0444);
79 MODULE_PARM_DESC(ics2115_irq, "IRQ # for ICS2115.");
80 module_param_array(ics2115_port, long, NULL, 0444);
81 MODULE_PARM_DESC(ics2115_port, "Port # for ICS2115.");
82 module_param_array(fm_port, long, NULL, 0444);
83 MODULE_PARM_DESC(fm_port, "FM port #.");
84 module_param_array(use_cs4232_midi, bool, NULL, 0444);
85 MODULE_PARM_DESC(use_cs4232_midi, "Use CS4232 MPU-401 interface (inaccessibly located inside your computer)");
86 
87 #ifdef CONFIG_PNP
88 static int isa_registered;
89 static int pnp_registered;
90 
91 static struct pnp_card_device_id snd_wavefront_pnpids[] = {
92  /* Tropez */
93  { .id = "CSC7532", .devs = { { "CSC0000" }, { "CSC0010" }, { "PnPb006" }, { "CSC0004" } } },
94  /* Tropez+ */
95  { .id = "CSC7632", .devs = { { "CSC0000" }, { "CSC0010" }, { "PnPb006" }, { "CSC0004" } } },
96  { .id = "" }
97 };
98 
99 MODULE_DEVICE_TABLE(pnp_card, snd_wavefront_pnpids);
100 
101 static int __devinit
102 snd_wavefront_pnp (int dev, snd_wavefront_card_t *acard, struct pnp_card_link *card,
103  const struct pnp_card_device_id *id)
104 {
105  struct pnp_dev *pdev;
106  int err;
107 
108  /* Check for each logical device. */
109 
110  /* CS4232 chip (aka "windows sound system") is logical device 0 */
111 
112  acard->wss = pnp_request_card_device(card, id->devs[0].id, NULL);
113  if (acard->wss == NULL)
114  return -EBUSY;
115 
116  /* there is a game port at logical device 1, but we ignore it completely */
117 
118  /* the control interface is logical device 2, but we ignore it
119  completely. in fact, nobody even seems to know what it
120  does.
121  */
122 
123  /* Only configure the CS4232 MIDI interface if its been
124  specifically requested. It is logical device 3.
125  */
126 
127  if (use_cs4232_midi[dev]) {
128  acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL);
129  if (acard->mpu == NULL)
130  return -EBUSY;
131  }
132 
133  /* The ICS2115 synth is logical device 4 */
134 
135  acard->synth = pnp_request_card_device(card, id->devs[3].id, NULL);
136  if (acard->synth == NULL)
137  return -EBUSY;
138 
139  /* PCM/FM initialization */
140 
141  pdev = acard->wss;
142 
143  /* An interesting note from the Tropez+ FAQ:
144 
145  Q. [Ports] Why is the base address of the WSS I/O ports off by 4?
146 
147  A. WSS I/O requires a block of 8 I/O addresses ("ports"). Of these, the first
148  4 are used to identify and configure the board. With the advent of PnP,
149  these first 4 addresses have become obsolete, and software applications
150  only use the last 4 addresses to control the codec chip. Therefore, the
151  base address setting "skips past" the 4 unused addresses.
152 
153  */
154 
155  err = pnp_activate_dev(pdev);
156  if (err < 0) {
157  snd_printk(KERN_ERR "PnP WSS pnp configure failure\n");
158  return err;
159  }
160 
161  cs4232_pcm_port[dev] = pnp_port_start(pdev, 0);
162  fm_port[dev] = pnp_port_start(pdev, 1);
163  dma1[dev] = pnp_dma(pdev, 0);
164  dma2[dev] = pnp_dma(pdev, 1);
165  cs4232_pcm_irq[dev] = pnp_irq(pdev, 0);
166 
167  /* Synth initialization */
168 
169  pdev = acard->synth;
170 
171  err = pnp_activate_dev(pdev);
172  if (err < 0) {
173  snd_printk(KERN_ERR "PnP ICS2115 pnp configure failure\n");
174  return err;
175  }
176 
177  ics2115_port[dev] = pnp_port_start(pdev, 0);
178  ics2115_irq[dev] = pnp_irq(pdev, 0);
179 
180  /* CS4232 MPU initialization. Configure this only if
181  explicitly requested, since its physically inaccessible and
182  consumes another IRQ.
183  */
184 
185  if (use_cs4232_midi[dev]) {
186 
187  pdev = acard->mpu;
188 
189  err = pnp_activate_dev(pdev);
190  if (err < 0) {
191  snd_printk(KERN_ERR "PnP MPU401 pnp configure failure\n");
192  cs4232_mpu_port[dev] = SNDRV_AUTO_PORT;
193  } else {
194  cs4232_mpu_port[dev] = pnp_port_start(pdev, 0);
195  cs4232_mpu_irq[dev] = pnp_irq(pdev, 0);
196  }
197 
198  snd_printk (KERN_INFO "CS4232 MPU: port=0x%lx, irq=%i\n",
199  cs4232_mpu_port[dev],
200  cs4232_mpu_irq[dev]);
201  }
202 
203  snd_printdd ("CS4232: pcm port=0x%lx, fm port=0x%lx, dma1=%i, dma2=%i, irq=%i\nICS2115: port=0x%lx, irq=%i\n",
204  cs4232_pcm_port[dev],
205  fm_port[dev],
206  dma1[dev],
207  dma2[dev],
208  cs4232_pcm_irq[dev],
209  ics2115_port[dev],
210  ics2115_irq[dev]);
211 
212  return 0;
213 }
214 
215 #endif /* CONFIG_PNP */
216 
217 static irqreturn_t snd_wavefront_ics2115_interrupt(int irq, void *dev_id)
218 {
219  snd_wavefront_card_t *acard;
220 
221  acard = (snd_wavefront_card_t *) dev_id;
222 
223  if (acard == NULL)
224  return IRQ_NONE;
225 
226  if (acard->wavefront.interrupts_are_midi) {
228  } else {
230  }
231  return IRQ_HANDLED;
232 }
233 
234 static struct snd_hwdep * __devinit
235 snd_wavefront_new_synth (struct snd_card *card,
236  int hw_dev,
237  snd_wavefront_card_t *acard)
238 {
239  struct snd_hwdep *wavefront_synth;
240 
241  if (snd_wavefront_detect (acard) < 0) {
242  return NULL;
243  }
244 
245  if (snd_wavefront_start (&acard->wavefront) < 0) {
246  return NULL;
247  }
248 
249  if (snd_hwdep_new(card, "WaveFront", hw_dev, &wavefront_synth) < 0)
250  return NULL;
251  strcpy (wavefront_synth->name,
252  "WaveFront (ICS2115) wavetable synthesizer");
253  wavefront_synth->ops.open = snd_wavefront_synth_open;
254  wavefront_synth->ops.release = snd_wavefront_synth_release;
255  wavefront_synth->ops.ioctl = snd_wavefront_synth_ioctl;
256 
257  return wavefront_synth;
258 }
259 
260 static struct snd_hwdep * __devinit
261 snd_wavefront_new_fx (struct snd_card *card,
262  int hw_dev,
263  snd_wavefront_card_t *acard,
264  unsigned long port)
265 
266 {
267  struct snd_hwdep *fx_processor;
268 
269  if (snd_wavefront_fx_start (&acard->wavefront)) {
270  snd_printk (KERN_ERR "cannot initialize YSS225 FX processor");
271  return NULL;
272  }
273 
274  if (snd_hwdep_new (card, "YSS225", hw_dev, &fx_processor) < 0)
275  return NULL;
276  sprintf (fx_processor->name, "YSS225 FX Processor at 0x%lx", port);
277  fx_processor->ops.open = snd_wavefront_fx_open;
278  fx_processor->ops.release = snd_wavefront_fx_release;
279  fx_processor->ops.ioctl = snd_wavefront_fx_ioctl;
280 
281  return fx_processor;
282 }
283 
284 static snd_wavefront_mpu_id internal_id = internal_mpu;
285 static snd_wavefront_mpu_id external_id = external_mpu;
286 
287 static struct snd_rawmidi *__devinit
288 snd_wavefront_new_midi (struct snd_card *card,
289  int midi_dev,
290  snd_wavefront_card_t *acard,
291  unsigned long port,
293 
294 {
295  struct snd_rawmidi *rmidi;
296  static int first = 1;
297 
298  if (first) {
299  first = 0;
300  acard->wavefront.midi.base = port;
301  if (snd_wavefront_midi_start (acard)) {
302  snd_printk (KERN_ERR "cannot initialize MIDI interface\n");
303  return NULL;
304  }
305  }
306 
307  if (snd_rawmidi_new (card, "WaveFront MIDI", midi_dev, 1, 1, &rmidi) < 0)
308  return NULL;
309 
310  if (mpu == internal_mpu) {
311  strcpy(rmidi->name, "WaveFront MIDI (Internal)");
312  rmidi->private_data = &internal_id;
313  } else {
314  strcpy(rmidi->name, "WaveFront MIDI (External)");
315  rmidi->private_data = &external_id;
316  }
317 
320 
324 
325  return rmidi;
326 }
327 
328 static void
329 snd_wavefront_free(struct snd_card *card)
330 {
332 
333  if (acard) {
335  if (acard->wavefront.irq > 0)
336  free_irq(acard->wavefront.irq, (void *)acard);
337  }
338 }
339 
340 static int snd_wavefront_card_new(int dev, struct snd_card **cardp)
341 {
342  struct snd_card *card;
343  snd_wavefront_card_t *acard;
344  int err;
345 
346  err = snd_card_create(index[dev], id[dev], THIS_MODULE,
347  sizeof(snd_wavefront_card_t), &card);
348  if (err < 0)
349  return err;
350 
351  acard = card->private_data;
352  acard->wavefront.irq = -1;
357  acard->wavefront.card = card;
358  card->private_free = snd_wavefront_free;
359 
360  *cardp = card;
361  return 0;
362 }
363 
364 static int __devinit
365 snd_wavefront_probe (struct snd_card *card, int dev)
366 {
367  snd_wavefront_card_t *acard = card->private_data;
368  struct snd_wss *chip;
369  struct snd_hwdep *wavefront_synth;
370  struct snd_rawmidi *ics2115_internal_rmidi = NULL;
371  struct snd_rawmidi *ics2115_external_rmidi = NULL;
372  struct snd_hwdep *fx_processor;
373  int hw_dev = 0, midi_dev = 0, err;
374 
375  /* --------- PCM --------------- */
376 
377  err = snd_wss_create(card, cs4232_pcm_port[dev], -1,
378  cs4232_pcm_irq[dev], dma1[dev], dma2[dev],
379  WSS_HW_DETECT, 0, &chip);
380  if (err < 0) {
381  snd_printk(KERN_ERR "can't allocate WSS device\n");
382  return err;
383  }
384 
385  err = snd_wss_pcm(chip, 0, NULL);
386  if (err < 0)
387  return err;
388 
389  err = snd_wss_timer(chip, 0, NULL);
390  if (err < 0)
391  return err;
392 
393  /* ---------- OPL3 synth --------- */
394 
395  if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) {
396  struct snd_opl3 *opl3;
397 
398  err = snd_opl3_create(card, fm_port[dev], fm_port[dev] + 2,
399  OPL3_HW_OPL3_CS, 0, &opl3);
400  if (err < 0) {
401  snd_printk (KERN_ERR "can't allocate or detect OPL3 synth\n");
402  return err;
403  }
404 
405  err = snd_opl3_hwdep_new(opl3, hw_dev, 1, NULL);
406  if (err < 0)
407  return err;
408  hw_dev++;
409  }
410 
411  /* ------- ICS2115 Wavetable synth ------- */
412 
413  acard->wavefront.res_base = request_region(ics2115_port[dev], 16,
414  "ICS2115");
415  if (acard->wavefront.res_base == NULL) {
416  snd_printk(KERN_ERR "unable to grab ICS2115 i/o region 0x%lx-0x%lx\n",
417  ics2115_port[dev], ics2115_port[dev] + 16 - 1);
418  return -EBUSY;
419  }
420  if (request_irq(ics2115_irq[dev], snd_wavefront_ics2115_interrupt,
421  0, "ICS2115", acard)) {
422  snd_printk(KERN_ERR "unable to use ICS2115 IRQ %d\n", ics2115_irq[dev]);
423  return -EBUSY;
424  }
425 
426  acard->wavefront.irq = ics2115_irq[dev];
427  acard->wavefront.base = ics2115_port[dev];
428 
429  wavefront_synth = snd_wavefront_new_synth(card, hw_dev, acard);
430  if (wavefront_synth == NULL) {
431  snd_printk (KERN_ERR "can't create WaveFront synth device\n");
432  return -ENOMEM;
433  }
434 
435  strcpy (wavefront_synth->name, "ICS2115 Wavetable MIDI Synthesizer");
436  wavefront_synth->iface = SNDRV_HWDEP_IFACE_ICS2115;
437  hw_dev++;
438 
439  /* --------- Mixer ------------ */
440 
441  err = snd_wss_mixer(chip);
442  if (err < 0) {
443  snd_printk (KERN_ERR "can't allocate mixer device\n");
444  return err;
445  }
446 
447  /* -------- CS4232 MPU-401 interface -------- */
448 
449  if (cs4232_mpu_port[dev] > 0 && cs4232_mpu_port[dev] != SNDRV_AUTO_PORT) {
450  err = snd_mpu401_uart_new(card, midi_dev, MPU401_HW_CS4232,
451  cs4232_mpu_port[dev], 0,
452  cs4232_mpu_irq[dev], NULL);
453  if (err < 0) {
454  snd_printk (KERN_ERR "can't allocate CS4232 MPU-401 device\n");
455  return err;
456  }
457  midi_dev++;
458  }
459 
460  /* ------ ICS2115 internal MIDI ------------ */
461 
462  if (ics2115_port[dev] > 0 && ics2115_port[dev] != SNDRV_AUTO_PORT) {
463  ics2115_internal_rmidi =
464  snd_wavefront_new_midi (card,
465  midi_dev,
466  acard,
467  ics2115_port[dev],
468  internal_mpu);
469  if (ics2115_internal_rmidi == NULL) {
470  snd_printk (KERN_ERR "can't setup ICS2115 internal MIDI device\n");
471  return -ENOMEM;
472  }
473  midi_dev++;
474  }
475 
476  /* ------ ICS2115 external MIDI ------------ */
477 
478  if (ics2115_port[dev] > 0 && ics2115_port[dev] != SNDRV_AUTO_PORT) {
479  ics2115_external_rmidi =
480  snd_wavefront_new_midi (card,
481  midi_dev,
482  acard,
483  ics2115_port[dev],
484  external_mpu);
485  if (ics2115_external_rmidi == NULL) {
486  snd_printk (KERN_ERR "can't setup ICS2115 external MIDI device\n");
487  return -ENOMEM;
488  }
489  midi_dev++;
490  }
491 
492  /* FX processor for Tropez+ */
493 
494  if (acard->wavefront.has_fx) {
495  fx_processor = snd_wavefront_new_fx (card,
496  hw_dev,
497  acard,
498  ics2115_port[dev]);
499  if (fx_processor == NULL) {
500  snd_printk (KERN_ERR "can't setup FX device\n");
501  return -ENOMEM;
502  }
503 
504  hw_dev++;
505 
506  strcpy(card->driver, "Tropez+");
507  strcpy(card->shortname, "Turtle Beach Tropez+");
508  } else {
509  /* Need a way to distinguish between Maui and Tropez */
510  strcpy(card->driver, "WaveFront");
511  strcpy(card->shortname, "Turtle Beach WaveFront");
512  }
513 
514  /* ----- Register the card --------- */
515 
516  /* Not safe to include "Turtle Beach" in longname, due to
517  length restrictions
518  */
519 
520  sprintf(card->longname, "%s PCM 0x%lx irq %d dma %d",
521  card->driver,
522  chip->port,
523  cs4232_pcm_irq[dev],
524  dma1[dev]);
525 
526  if (dma2[dev] >= 0 && dma2[dev] < 8)
527  sprintf(card->longname + strlen(card->longname), "&%d", dma2[dev]);
528 
529  if (cs4232_mpu_port[dev] > 0 && cs4232_mpu_port[dev] != SNDRV_AUTO_PORT) {
530  sprintf (card->longname + strlen (card->longname),
531  " MPU-401 0x%lx irq %d",
532  cs4232_mpu_port[dev],
533  cs4232_mpu_irq[dev]);
534  }
535 
536  sprintf (card->longname + strlen (card->longname),
537  " SYNTH 0x%lx irq %d",
538  ics2115_port[dev],
539  ics2115_irq[dev]);
540 
541  return snd_card_register(card);
542 }
543 
544 static int __devinit snd_wavefront_isa_match(struct device *pdev,
545  unsigned int dev)
546 {
547  if (!enable[dev])
548  return 0;
549 #ifdef CONFIG_PNP
550  if (isapnp[dev])
551  return 0;
552 #endif
553  if (cs4232_pcm_port[dev] == SNDRV_AUTO_PORT) {
554  snd_printk(KERN_ERR "specify CS4232 port\n");
555  return 0;
556  }
557  if (ics2115_port[dev] == SNDRV_AUTO_PORT) {
558  snd_printk(KERN_ERR "specify ICS2115 port\n");
559  return 0;
560  }
561  return 1;
562 }
563 
564 static int __devinit snd_wavefront_isa_probe(struct device *pdev,
565  unsigned int dev)
566 {
567  struct snd_card *card;
568  int err;
569 
570  err = snd_wavefront_card_new(dev, &card);
571  if (err < 0)
572  return err;
573  snd_card_set_dev(card, pdev);
574  if ((err = snd_wavefront_probe(card, dev)) < 0) {
575  snd_card_free(card);
576  return err;
577  }
578 
579  dev_set_drvdata(pdev, card);
580  return 0;
581 }
582 
583 static int __devexit snd_wavefront_isa_remove(struct device *devptr,
584  unsigned int dev)
585 {
587  dev_set_drvdata(devptr, NULL);
588  return 0;
589 }
590 
591 #define DEV_NAME "wavefront"
592 
593 static struct isa_driver snd_wavefront_driver = {
594  .match = snd_wavefront_isa_match,
595  .probe = snd_wavefront_isa_probe,
596  .remove = __devexit_p(snd_wavefront_isa_remove),
597  /* FIXME: suspend, resume */
598  .driver = {
599  .name = DEV_NAME
600  },
601 };
602 
603 
604 #ifdef CONFIG_PNP
605 static int __devinit snd_wavefront_pnp_detect(struct pnp_card_link *pcard,
606  const struct pnp_card_device_id *pid)
607 {
608  static int dev;
609  struct snd_card *card;
610  int res;
611 
612  for ( ; dev < SNDRV_CARDS; dev++) {
613  if (enable[dev] && isapnp[dev])
614  break;
615  }
616  if (dev >= SNDRV_CARDS)
617  return -ENODEV;
618 
619  res = snd_wavefront_card_new(dev, &card);
620  if (res < 0)
621  return res;
622 
623  if (snd_wavefront_pnp (dev, card->private_data, pcard, pid) < 0) {
624  if (cs4232_pcm_port[dev] == SNDRV_AUTO_PORT) {
625  snd_printk (KERN_ERR "isapnp detection failed\n");
626  snd_card_free (card);
627  return -ENODEV;
628  }
629  }
630  snd_card_set_dev(card, &pcard->card->dev);
631 
632  if ((res = snd_wavefront_probe(card, dev)) < 0)
633  return res;
634 
635  pnp_set_card_drvdata(pcard, card);
636  dev++;
637  return 0;
638 }
639 
640 static void __devexit snd_wavefront_pnp_remove(struct pnp_card_link * pcard)
641 {
642  snd_card_free(pnp_get_card_drvdata(pcard));
643  pnp_set_card_drvdata(pcard, NULL);
644 }
645 
646 static struct pnp_card_driver wavefront_pnpc_driver = {
648  .name = "wavefront",
649  .id_table = snd_wavefront_pnpids,
650  .probe = snd_wavefront_pnp_detect,
651  .remove = __devexit_p(snd_wavefront_pnp_remove),
652  /* FIXME: suspend,resume */
653 };
654 
655 #endif /* CONFIG_PNP */
656 
657 static int __init alsa_card_wavefront_init(void)
658 {
659  int err;
660 
661  err = isa_register_driver(&snd_wavefront_driver, SNDRV_CARDS);
662 #ifdef CONFIG_PNP
663  if (!err)
664  isa_registered = 1;
665 
666  err = pnp_register_card_driver(&wavefront_pnpc_driver);
667  if (!err)
668  pnp_registered = 1;
669 
670  if (isa_registered)
671  err = 0;
672 #endif
673  return err;
674 }
675 
676 static void __exit alsa_card_wavefront_exit(void)
677 {
678 #ifdef CONFIG_PNP
679  if (pnp_registered)
680  pnp_unregister_card_driver(&wavefront_pnpc_driver);
681  if (isa_registered)
682 #endif
683  isa_unregister_driver(&snd_wavefront_driver);
684 }
685 
686 module_init(alsa_card_wavefront_init)
687 module_exit(alsa_card_wavefront_exit)