Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 <pbd@op.net> |
| 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 <sound/driver.h> |
| 23 | #include <linux/init.h> |
| 24 | #include <linux/interrupt.h> |
| 25 | #include <linux/slab.h> |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 26 | #include <linux/err.h> |
| 27 | #include <linux/platform_device.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | #include <linux/pnp.h> |
| 29 | #include <linux/moduleparam.h> |
| 30 | #include <sound/core.h> |
| 31 | #include <sound/initval.h> |
| 32 | #include <sound/opl3.h> |
| 33 | #include <sound/snd_wavefront.h> |
| 34 | |
| 35 | MODULE_AUTHOR("Paul Barton-Davis <pbd@op.net>"); |
| 36 | MODULE_DESCRIPTION("Turtle Beach Wavefront"); |
| 37 | MODULE_LICENSE("GPL"); |
| 38 | MODULE_SUPPORTED_DEVICE("{{Turtle Beach,Maui/Tropez/Tropez+}}"); |
| 39 | |
| 40 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ |
| 41 | static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ |
| 42 | static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; /* Enable this card */ |
| 43 | static int isapnp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1}; |
| 44 | static long cs4232_pcm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ |
| 45 | static int cs4232_pcm_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 5,7,9,11,12,15 */ |
| 46 | static long cs4232_mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ |
| 47 | static int cs4232_mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 9,11,12,15 */ |
| 48 | static long ics2115_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ |
| 49 | static int ics2115_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 2,9,11,12,15 */ |
| 50 | static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ |
| 51 | static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 0,1,3,5,6,7 */ |
| 52 | static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 0,1,3,5,6,7 */ |
Takashi Iwai | 6581f4e | 2006-05-17 17:14:51 +0200 | [diff] [blame] | 53 | static int use_cs4232_midi[SNDRV_CARDS]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | |
| 55 | module_param_array(index, int, NULL, 0444); |
| 56 | MODULE_PARM_DESC(index, "Index value for WaveFront soundcard."); |
| 57 | module_param_array(id, charp, NULL, 0444); |
| 58 | MODULE_PARM_DESC(id, "ID string for WaveFront soundcard."); |
| 59 | module_param_array(enable, bool, NULL, 0444); |
| 60 | MODULE_PARM_DESC(enable, "Enable WaveFront soundcard."); |
| 61 | #ifdef CONFIG_PNP |
| 62 | module_param_array(isapnp, bool, NULL, 0444); |
| 63 | MODULE_PARM_DESC(isapnp, "ISA PnP detection for WaveFront soundcards."); |
| 64 | #endif |
| 65 | module_param_array(cs4232_pcm_port, long, NULL, 0444); |
| 66 | MODULE_PARM_DESC(cs4232_pcm_port, "Port # for CS4232 PCM interface."); |
| 67 | module_param_array(cs4232_pcm_irq, int, NULL, 0444); |
| 68 | MODULE_PARM_DESC(cs4232_pcm_irq, "IRQ # for CS4232 PCM interface."); |
| 69 | module_param_array(dma1, int, NULL, 0444); |
| 70 | MODULE_PARM_DESC(dma1, "DMA1 # for CS4232 PCM interface."); |
| 71 | module_param_array(dma2, int, NULL, 0444); |
| 72 | MODULE_PARM_DESC(dma2, "DMA2 # for CS4232 PCM interface."); |
| 73 | module_param_array(cs4232_mpu_port, long, NULL, 0444); |
| 74 | MODULE_PARM_DESC(cs4232_mpu_port, "port # for CS4232 MPU-401 interface."); |
| 75 | module_param_array(cs4232_mpu_irq, int, NULL, 0444); |
| 76 | MODULE_PARM_DESC(cs4232_mpu_irq, "IRQ # for CS4232 MPU-401 interface."); |
| 77 | module_param_array(ics2115_irq, int, NULL, 0444); |
| 78 | MODULE_PARM_DESC(ics2115_irq, "IRQ # for ICS2115."); |
| 79 | module_param_array(ics2115_port, long, NULL, 0444); |
| 80 | MODULE_PARM_DESC(ics2115_port, "Port # for ICS2115."); |
| 81 | module_param_array(fm_port, long, NULL, 0444); |
| 82 | MODULE_PARM_DESC(fm_port, "FM port #."); |
| 83 | module_param_array(use_cs4232_midi, bool, NULL, 0444); |
| 84 | MODULE_PARM_DESC(use_cs4232_midi, "Use CS4232 MPU-401 interface (inaccessibly located inside your computer)"); |
| 85 | |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 86 | static struct platform_device *platform_devices[SNDRV_CARDS]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | |
| 88 | #ifdef CONFIG_PNP |
Takashi Iwai | 59b1b34 | 2006-01-04 15:06:44 +0100 | [diff] [blame] | 89 | static int pnp_registered; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | struct pnp_resource_table *cfg = kmalloc(sizeof(*cfg), GFP_KERNEL); |
| 107 | int err; |
| 108 | |
| 109 | if (!cfg) |
| 110 | return -ENOMEM; |
| 111 | |
| 112 | /* Check for each logical device. */ |
| 113 | |
| 114 | /* CS4232 chip (aka "windows sound system") is logical device 0 */ |
| 115 | |
| 116 | acard->wss = pnp_request_card_device(card, id->devs[0].id, NULL); |
| 117 | if (acard->wss == NULL) { |
| 118 | kfree(cfg); |
| 119 | return -EBUSY; |
| 120 | } |
| 121 | |
| 122 | /* there is a game port at logical device 1, but we ignore it completely */ |
| 123 | |
| 124 | /* the control interface is logical device 2, but we ignore it |
| 125 | completely. in fact, nobody even seems to know what it |
| 126 | does. |
| 127 | */ |
| 128 | |
| 129 | /* Only configure the CS4232 MIDI interface if its been |
| 130 | specifically requested. It is logical device 3. |
| 131 | */ |
| 132 | |
| 133 | if (use_cs4232_midi[dev]) { |
| 134 | acard->mpu = pnp_request_card_device(card, id->devs[2].id, NULL); |
| 135 | if (acard->mpu == NULL) { |
| 136 | kfree(cfg); |
| 137 | return -EBUSY; |
| 138 | } |
| 139 | } |
| 140 | |
| 141 | /* The ICS2115 synth is logical device 4 */ |
| 142 | |
| 143 | acard->synth = pnp_request_card_device(card, id->devs[3].id, NULL); |
| 144 | if (acard->synth == NULL) { |
| 145 | kfree(cfg); |
| 146 | return -EBUSY; |
| 147 | } |
| 148 | |
| 149 | /* PCM/FM initialization */ |
| 150 | |
| 151 | pdev = acard->wss; |
| 152 | |
| 153 | pnp_init_resource_table(cfg); |
| 154 | |
| 155 | /* An interesting note from the Tropez+ FAQ: |
| 156 | |
| 157 | Q. [Ports] Why is the base address of the WSS I/O ports off by 4? |
| 158 | |
| 159 | A. WSS I/O requires a block of 8 I/O addresses ("ports"). Of these, the first |
| 160 | 4 are used to identify and configure the board. With the advent of PnP, |
| 161 | these first 4 addresses have become obsolete, and software applications |
| 162 | only use the last 4 addresses to control the codec chip. Therefore, the |
| 163 | base address setting "skips past" the 4 unused addresses. |
| 164 | |
| 165 | */ |
| 166 | |
| 167 | if (cs4232_pcm_port[dev] != SNDRV_AUTO_PORT) |
| 168 | pnp_resource_change(&cfg->port_resource[0], cs4232_pcm_port[dev], 4); |
| 169 | if (fm_port[dev] != SNDRV_AUTO_PORT) |
| 170 | pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4); |
| 171 | if (dma1[dev] != SNDRV_AUTO_DMA) |
| 172 | pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1); |
| 173 | if (dma2[dev] != SNDRV_AUTO_DMA) |
| 174 | pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1); |
| 175 | if (cs4232_pcm_irq[dev] != SNDRV_AUTO_IRQ) |
| 176 | pnp_resource_change(&cfg->irq_resource[0], cs4232_pcm_irq[dev], 1); |
| 177 | |
| 178 | if (pnp_manual_config_dev(pdev, cfg, 0) < 0) |
| 179 | snd_printk(KERN_ERR "PnP WSS the requested resources are invalid, using auto config\n"); |
| 180 | err = pnp_activate_dev(pdev); |
| 181 | if (err < 0) { |
| 182 | snd_printk(KERN_ERR "PnP WSS pnp configure failure\n"); |
| 183 | kfree(cfg); |
| 184 | return err; |
| 185 | } |
| 186 | |
| 187 | cs4232_pcm_port[dev] = pnp_port_start(pdev, 0); |
| 188 | fm_port[dev] = pnp_port_start(pdev, 1); |
| 189 | dma1[dev] = pnp_dma(pdev, 0); |
| 190 | dma2[dev] = pnp_dma(pdev, 1); |
| 191 | cs4232_pcm_irq[dev] = pnp_irq(pdev, 0); |
| 192 | |
| 193 | /* Synth initialization */ |
| 194 | |
| 195 | pdev = acard->synth; |
| 196 | |
| 197 | pnp_init_resource_table(cfg); |
| 198 | |
| 199 | if (ics2115_port[dev] != SNDRV_AUTO_PORT) { |
| 200 | pnp_resource_change(&cfg->port_resource[0], ics2115_port[dev], 16); |
| 201 | } |
| 202 | |
| 203 | if (ics2115_port[dev] != SNDRV_AUTO_IRQ) { |
| 204 | pnp_resource_change(&cfg->irq_resource[0], ics2115_irq[dev], 1); |
| 205 | } |
| 206 | |
| 207 | if (pnp_manual_config_dev(pdev, cfg, 0) < 0) |
| 208 | snd_printk(KERN_ERR "PnP ICS2115 the requested resources are invalid, using auto config\n"); |
| 209 | err = pnp_activate_dev(pdev); |
| 210 | if (err < 0) { |
| 211 | snd_printk(KERN_ERR "PnP ICS2115 pnp configure failure\n"); |
| 212 | kfree(cfg); |
| 213 | return err; |
| 214 | } |
| 215 | |
| 216 | ics2115_port[dev] = pnp_port_start(pdev, 0); |
| 217 | ics2115_irq[dev] = pnp_irq(pdev, 0); |
| 218 | |
| 219 | /* CS4232 MPU initialization. Configure this only if |
| 220 | explicitly requested, since its physically inaccessible and |
| 221 | consumes another IRQ. |
| 222 | */ |
| 223 | |
| 224 | if (use_cs4232_midi[dev]) { |
| 225 | |
| 226 | pdev = acard->mpu; |
| 227 | |
| 228 | pnp_init_resource_table(cfg); |
| 229 | |
| 230 | if (cs4232_mpu_port[dev] != SNDRV_AUTO_PORT) |
| 231 | pnp_resource_change(&cfg->port_resource[0], cs4232_mpu_port[dev], 2); |
| 232 | if (cs4232_mpu_irq[dev] != SNDRV_AUTO_IRQ) |
| 233 | pnp_resource_change(&cfg->port_resource[0], cs4232_mpu_irq[dev], 1); |
| 234 | |
| 235 | if (pnp_manual_config_dev(pdev, cfg, 0) < 0) |
| 236 | snd_printk(KERN_ERR "PnP MPU401 the requested resources are invalid, using auto config\n"); |
| 237 | err = pnp_activate_dev(pdev); |
| 238 | if (err < 0) { |
| 239 | snd_printk(KERN_ERR "PnP MPU401 pnp configure failure\n"); |
| 240 | cs4232_mpu_port[dev] = SNDRV_AUTO_PORT; |
| 241 | } else { |
| 242 | cs4232_mpu_port[dev] = pnp_port_start(pdev, 0); |
| 243 | cs4232_mpu_irq[dev] = pnp_irq(pdev, 0); |
| 244 | } |
| 245 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 246 | snd_printk (KERN_INFO "CS4232 MPU: port=0x%lx, irq=%i\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | cs4232_mpu_port[dev], |
| 248 | cs4232_mpu_irq[dev]); |
| 249 | } |
| 250 | |
| 251 | snd_printdd ("CS4232: pcm port=0x%lx, fm port=0x%lx, dma1=%i, dma2=%i, irq=%i\nICS2115: port=0x%lx, irq=%i\n", |
| 252 | cs4232_pcm_port[dev], |
| 253 | fm_port[dev], |
| 254 | dma1[dev], |
| 255 | dma2[dev], |
| 256 | cs4232_pcm_irq[dev], |
| 257 | ics2115_port[dev], |
| 258 | ics2115_irq[dev]); |
| 259 | |
| 260 | kfree(cfg); |
| 261 | return 0; |
| 262 | } |
| 263 | |
| 264 | #endif /* CONFIG_PNP */ |
| 265 | |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame^] | 266 | static irqreturn_t snd_wavefront_ics2115_interrupt(int irq, void *dev_id) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 267 | { |
| 268 | snd_wavefront_card_t *acard; |
| 269 | |
| 270 | acard = (snd_wavefront_card_t *) dev_id; |
| 271 | |
| 272 | if (acard == NULL) |
| 273 | return IRQ_NONE; |
| 274 | |
| 275 | if (acard->wavefront.interrupts_are_midi) { |
| 276 | snd_wavefront_midi_interrupt (acard); |
| 277 | } else { |
| 278 | snd_wavefront_internal_interrupt (acard); |
| 279 | } |
| 280 | return IRQ_HANDLED; |
| 281 | } |
| 282 | |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 283 | static struct snd_hwdep * __devinit |
| 284 | snd_wavefront_new_synth (struct snd_card *card, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 285 | int hw_dev, |
| 286 | snd_wavefront_card_t *acard) |
| 287 | { |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 288 | struct snd_hwdep *wavefront_synth; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 289 | |
| 290 | if (snd_wavefront_detect (acard) < 0) { |
| 291 | return NULL; |
| 292 | } |
| 293 | |
| 294 | if (snd_wavefront_start (&acard->wavefront) < 0) { |
| 295 | return NULL; |
| 296 | } |
| 297 | |
| 298 | if (snd_hwdep_new(card, "WaveFront", hw_dev, &wavefront_synth) < 0) |
| 299 | return NULL; |
| 300 | strcpy (wavefront_synth->name, |
| 301 | "WaveFront (ICS2115) wavetable synthesizer"); |
| 302 | wavefront_synth->ops.open = snd_wavefront_synth_open; |
| 303 | wavefront_synth->ops.release = snd_wavefront_synth_release; |
| 304 | wavefront_synth->ops.ioctl = snd_wavefront_synth_ioctl; |
| 305 | |
| 306 | return wavefront_synth; |
| 307 | } |
| 308 | |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 309 | static struct snd_hwdep * __devinit |
| 310 | snd_wavefront_new_fx (struct snd_card *card, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 311 | int hw_dev, |
| 312 | snd_wavefront_card_t *acard, |
| 313 | unsigned long port) |
| 314 | |
| 315 | { |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 316 | struct snd_hwdep *fx_processor; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 317 | |
| 318 | if (snd_wavefront_fx_start (&acard->wavefront)) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 319 | snd_printk (KERN_ERR "cannot initialize YSS225 FX processor"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | return NULL; |
| 321 | } |
| 322 | |
| 323 | if (snd_hwdep_new (card, "YSS225", hw_dev, &fx_processor) < 0) |
| 324 | return NULL; |
| 325 | sprintf (fx_processor->name, "YSS225 FX Processor at 0x%lx", port); |
| 326 | fx_processor->ops.open = snd_wavefront_fx_open; |
| 327 | fx_processor->ops.release = snd_wavefront_fx_release; |
| 328 | fx_processor->ops.ioctl = snd_wavefront_fx_ioctl; |
| 329 | |
| 330 | return fx_processor; |
| 331 | } |
| 332 | |
| 333 | static snd_wavefront_mpu_id internal_id = internal_mpu; |
| 334 | static snd_wavefront_mpu_id external_id = external_mpu; |
| 335 | |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 336 | static struct snd_rawmidi *__devinit |
| 337 | snd_wavefront_new_midi (struct snd_card *card, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 338 | int midi_dev, |
| 339 | snd_wavefront_card_t *acard, |
| 340 | unsigned long port, |
| 341 | snd_wavefront_mpu_id mpu) |
| 342 | |
| 343 | { |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 344 | struct snd_rawmidi *rmidi; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 345 | static int first = 1; |
| 346 | |
| 347 | if (first) { |
| 348 | first = 0; |
| 349 | acard->wavefront.midi.base = port; |
| 350 | if (snd_wavefront_midi_start (acard)) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 351 | snd_printk (KERN_ERR "cannot initialize MIDI interface\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 352 | return NULL; |
| 353 | } |
| 354 | } |
| 355 | |
| 356 | if (snd_rawmidi_new (card, "WaveFront MIDI", midi_dev, 1, 1, &rmidi) < 0) |
| 357 | return NULL; |
| 358 | |
| 359 | if (mpu == internal_mpu) { |
| 360 | strcpy(rmidi->name, "WaveFront MIDI (Internal)"); |
| 361 | rmidi->private_data = &internal_id; |
| 362 | } else { |
| 363 | strcpy(rmidi->name, "WaveFront MIDI (External)"); |
| 364 | rmidi->private_data = &external_id; |
| 365 | } |
| 366 | |
| 367 | snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_wavefront_midi_output); |
| 368 | snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_wavefront_midi_input); |
| 369 | |
| 370 | rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | |
| 371 | SNDRV_RAWMIDI_INFO_INPUT | |
| 372 | SNDRV_RAWMIDI_INFO_DUPLEX; |
| 373 | |
| 374 | return rmidi; |
| 375 | } |
| 376 | |
| 377 | static void |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 378 | snd_wavefront_free(struct snd_card *card) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 379 | { |
| 380 | snd_wavefront_card_t *acard = (snd_wavefront_card_t *)card->private_data; |
| 381 | |
| 382 | if (acard) { |
Takashi Iwai | b1d5776 | 2005-10-10 11:56:31 +0200 | [diff] [blame] | 383 | release_and_free_resource(acard->wavefront.res_base); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 384 | if (acard->wavefront.irq > 0) |
| 385 | free_irq(acard->wavefront.irq, (void *)acard); |
| 386 | } |
| 387 | } |
| 388 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 389 | static struct snd_card *snd_wavefront_card_new(int dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | { |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 391 | struct snd_card *card; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 392 | snd_wavefront_card_t *acard; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 393 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 394 | card = snd_card_new (index[dev], id[dev], THIS_MODULE, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 395 | sizeof(snd_wavefront_card_t)); |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 396 | if (card == NULL) |
| 397 | return NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 398 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 399 | acard = card->private_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 400 | acard->wavefront.irq = -1; |
| 401 | spin_lock_init(&acard->wavefront.irq_lock); |
| 402 | init_waitqueue_head(&acard->wavefront.interrupt_sleeper); |
| 403 | spin_lock_init(&acard->wavefront.midi.open); |
| 404 | spin_lock_init(&acard->wavefront.midi.virtual); |
| 405 | card->private_free = snd_wavefront_free; |
| 406 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 407 | return card; |
| 408 | } |
| 409 | |
| 410 | static int __devinit |
| 411 | snd_wavefront_probe (struct snd_card *card, int dev) |
| 412 | { |
| 413 | snd_wavefront_card_t *acard = card->private_data; |
| 414 | struct snd_cs4231 *chip; |
| 415 | struct snd_hwdep *wavefront_synth; |
| 416 | struct snd_rawmidi *ics2115_internal_rmidi = NULL; |
| 417 | struct snd_rawmidi *ics2115_external_rmidi = NULL; |
| 418 | struct snd_hwdep *fx_processor; |
| 419 | int hw_dev = 0, midi_dev = 0, err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 420 | |
| 421 | /* --------- PCM --------------- */ |
| 422 | |
| 423 | if ((err = snd_cs4231_create (card, |
| 424 | cs4232_pcm_port[dev], |
| 425 | -1, |
| 426 | cs4232_pcm_irq[dev], |
| 427 | dma1[dev], |
| 428 | dma2[dev], |
| 429 | CS4231_HW_DETECT, 0, &chip)) < 0) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 430 | snd_printk (KERN_ERR "can't allocate CS4231 device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 431 | return err; |
| 432 | } |
| 433 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 434 | if ((err = snd_cs4231_pcm (chip, 0, NULL)) < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 435 | return err; |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 436 | |
| 437 | if ((err = snd_cs4231_timer (chip, 0, NULL)) < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 438 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 439 | |
| 440 | /* ---------- OPL3 synth --------- */ |
| 441 | |
| 442 | if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) { |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 443 | struct snd_opl3 *opl3; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 444 | |
| 445 | if ((err = snd_opl3_create(card, |
| 446 | fm_port[dev], |
| 447 | fm_port[dev] + 2, |
| 448 | OPL3_HW_OPL3_CS, |
| 449 | 0, &opl3)) < 0) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 450 | snd_printk (KERN_ERR "can't allocate or detect OPL3 synth\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 451 | return err; |
| 452 | } |
| 453 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 454 | if ((err = snd_opl3_hwdep_new(opl3, hw_dev, 1, NULL)) < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 455 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 456 | hw_dev++; |
| 457 | } |
| 458 | |
| 459 | /* ------- ICS2115 Wavetable synth ------- */ |
| 460 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 461 | if ((acard->wavefront.res_base = request_region(ics2115_port[dev], 16, |
| 462 | "ICS2115")) == NULL) { |
| 463 | snd_printk(KERN_ERR "unable to grab ICS2115 i/o region 0x%lx-0x%lx\n", |
| 464 | ics2115_port[dev], ics2115_port[dev] + 16 - 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 465 | return -EBUSY; |
| 466 | } |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 467 | if (request_irq(ics2115_irq[dev], snd_wavefront_ics2115_interrupt, |
Thomas Gleixner | 65ca68b | 2006-07-01 19:29:46 -0700 | [diff] [blame] | 468 | IRQF_DISABLED, "ICS2115", acard)) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 469 | snd_printk(KERN_ERR "unable to use ICS2115 IRQ %d\n", ics2115_irq[dev]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 470 | return -EBUSY; |
| 471 | } |
| 472 | |
| 473 | acard->wavefront.irq = ics2115_irq[dev]; |
| 474 | acard->wavefront.base = ics2115_port[dev]; |
| 475 | |
| 476 | if ((wavefront_synth = snd_wavefront_new_synth (card, hw_dev, acard)) == NULL) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 477 | snd_printk (KERN_ERR "can't create WaveFront synth device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 478 | return -ENOMEM; |
| 479 | } |
| 480 | |
| 481 | strcpy (wavefront_synth->name, "ICS2115 Wavetable MIDI Synthesizer"); |
| 482 | wavefront_synth->iface = SNDRV_HWDEP_IFACE_ICS2115; |
| 483 | hw_dev++; |
| 484 | |
| 485 | /* --------- Mixer ------------ */ |
| 486 | |
| 487 | if ((err = snd_cs4231_mixer(chip)) < 0) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 488 | snd_printk (KERN_ERR "can't allocate mixer device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 489 | return err; |
| 490 | } |
| 491 | |
| 492 | /* -------- CS4232 MPU-401 interface -------- */ |
| 493 | |
| 494 | if (cs4232_mpu_port[dev] > 0 && cs4232_mpu_port[dev] != SNDRV_AUTO_PORT) { |
| 495 | if ((err = snd_mpu401_uart_new(card, midi_dev, MPU401_HW_CS4232, |
| 496 | cs4232_mpu_port[dev], 0, |
| 497 | cs4232_mpu_irq[dev], |
Thomas Gleixner | 65ca68b | 2006-07-01 19:29:46 -0700 | [diff] [blame] | 498 | IRQF_DISABLED, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 499 | NULL)) < 0) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 500 | snd_printk (KERN_ERR "can't allocate CS4232 MPU-401 device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 501 | return err; |
| 502 | } |
| 503 | midi_dev++; |
| 504 | } |
| 505 | |
| 506 | /* ------ ICS2115 internal MIDI ------------ */ |
| 507 | |
| 508 | if (ics2115_port[dev] > 0 && ics2115_port[dev] != SNDRV_AUTO_PORT) { |
| 509 | ics2115_internal_rmidi = |
| 510 | snd_wavefront_new_midi (card, |
| 511 | midi_dev, |
| 512 | acard, |
| 513 | ics2115_port[dev], |
| 514 | internal_mpu); |
| 515 | if (ics2115_internal_rmidi == NULL) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 516 | snd_printk (KERN_ERR "can't setup ICS2115 internal MIDI device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 517 | return -ENOMEM; |
| 518 | } |
| 519 | midi_dev++; |
| 520 | } |
| 521 | |
| 522 | /* ------ ICS2115 external MIDI ------------ */ |
| 523 | |
| 524 | if (ics2115_port[dev] > 0 && ics2115_port[dev] != SNDRV_AUTO_PORT) { |
| 525 | ics2115_external_rmidi = |
| 526 | snd_wavefront_new_midi (card, |
| 527 | midi_dev, |
| 528 | acard, |
| 529 | ics2115_port[dev], |
| 530 | external_mpu); |
| 531 | if (ics2115_external_rmidi == NULL) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 532 | snd_printk (KERN_ERR "can't setup ICS2115 external MIDI device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 533 | return -ENOMEM; |
| 534 | } |
| 535 | midi_dev++; |
| 536 | } |
| 537 | |
| 538 | /* FX processor for Tropez+ */ |
| 539 | |
| 540 | if (acard->wavefront.has_fx) { |
| 541 | fx_processor = snd_wavefront_new_fx (card, |
| 542 | hw_dev, |
| 543 | acard, |
| 544 | ics2115_port[dev]); |
| 545 | if (fx_processor == NULL) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 546 | snd_printk (KERN_ERR "can't setup FX device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 547 | return -ENOMEM; |
| 548 | } |
| 549 | |
| 550 | hw_dev++; |
| 551 | |
| 552 | strcpy(card->driver, "Tropez+"); |
| 553 | strcpy(card->shortname, "Turtle Beach Tropez+"); |
| 554 | } else { |
| 555 | /* Need a way to distinguish between Maui and Tropez */ |
| 556 | strcpy(card->driver, "WaveFront"); |
| 557 | strcpy(card->shortname, "Turtle Beach WaveFront"); |
| 558 | } |
| 559 | |
| 560 | /* ----- Register the card --------- */ |
| 561 | |
| 562 | /* Not safe to include "Turtle Beach" in longname, due to |
| 563 | length restrictions |
| 564 | */ |
| 565 | |
| 566 | sprintf(card->longname, "%s PCM 0x%lx irq %d dma %d", |
| 567 | card->driver, |
| 568 | chip->port, |
| 569 | cs4232_pcm_irq[dev], |
| 570 | dma1[dev]); |
| 571 | |
| 572 | if (dma2[dev] >= 0 && dma2[dev] < 8) |
| 573 | sprintf(card->longname + strlen(card->longname), "&%d", dma2[dev]); |
| 574 | |
| 575 | if (cs4232_mpu_port[dev] > 0 && cs4232_mpu_port[dev] != SNDRV_AUTO_PORT) { |
| 576 | sprintf (card->longname + strlen (card->longname), |
| 577 | " MPU-401 0x%lx irq %d", |
| 578 | cs4232_mpu_port[dev], |
| 579 | cs4232_mpu_irq[dev]); |
| 580 | } |
| 581 | |
| 582 | sprintf (card->longname + strlen (card->longname), |
| 583 | " SYNTH 0x%lx irq %d", |
| 584 | ics2115_port[dev], |
| 585 | ics2115_irq[dev]); |
| 586 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 587 | return snd_card_register(card); |
| 588 | } |
| 589 | |
Bjorn Helgaas | c94ded6 | 2006-03-27 01:17:18 -0800 | [diff] [blame] | 590 | static int __devinit snd_wavefront_nonpnp_probe(struct platform_device *pdev) |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 591 | { |
| 592 | int dev = pdev->id; |
| 593 | struct snd_card *card; |
| 594 | int err; |
| 595 | |
| 596 | if (cs4232_pcm_port[dev] == SNDRV_AUTO_PORT) { |
| 597 | snd_printk("specify CS4232 port\n"); |
| 598 | return -EINVAL; |
| 599 | } |
| 600 | if (ics2115_port[dev] == SNDRV_AUTO_PORT) { |
| 601 | snd_printk("specify ICS2115 port\n"); |
| 602 | return -ENODEV; |
Takashi Iwai | 43bcd97 | 2005-09-05 17:19:20 +0200 | [diff] [blame] | 603 | } |
| 604 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 605 | card = snd_wavefront_card_new(dev); |
| 606 | if (! card) |
| 607 | return -ENOMEM; |
| 608 | snd_card_set_dev(card, &pdev->dev); |
| 609 | if ((err = snd_wavefront_probe(card, dev)) < 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 610 | snd_card_free(card); |
| 611 | return err; |
| 612 | } |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 613 | |
| 614 | platform_set_drvdata(pdev, card); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 615 | return 0; |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 616 | } |
| 617 | |
| 618 | static int __devexit snd_wavefront_nonpnp_remove(struct platform_device *devptr) |
| 619 | { |
| 620 | snd_card_free(platform_get_drvdata(devptr)); |
| 621 | platform_set_drvdata(devptr, NULL); |
| 622 | return 0; |
| 623 | } |
| 624 | |
| 625 | #define WAVEFRONT_DRIVER "snd_wavefront" |
| 626 | |
| 627 | static struct platform_driver snd_wavefront_driver = { |
| 628 | .probe = snd_wavefront_nonpnp_probe, |
| 629 | .remove = __devexit_p(snd_wavefront_nonpnp_remove), |
| 630 | /* FIXME: suspend, resume */ |
| 631 | .driver = { |
| 632 | .name = WAVEFRONT_DRIVER |
| 633 | }, |
| 634 | }; |
| 635 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 636 | |
| 637 | #ifdef CONFIG_PNP |
Bjorn Helgaas | c94ded6 | 2006-03-27 01:17:18 -0800 | [diff] [blame] | 638 | static unsigned int __devinitdata wavefront_pnp_devices; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 639 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 640 | static int __devinit snd_wavefront_pnp_detect(struct pnp_card_link *pcard, |
| 641 | const struct pnp_card_device_id *pid) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 642 | { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 643 | static int dev; |
| 644 | struct snd_card *card; |
| 645 | int res; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 646 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 647 | for ( ; dev < SNDRV_CARDS; dev++) { |
| 648 | if (enable[dev] && isapnp[dev]) |
| 649 | break; |
| 650 | } |
| 651 | if (dev >= SNDRV_CARDS) |
| 652 | return -ENODEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 653 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 654 | card = snd_wavefront_card_new(dev); |
| 655 | if (! card) |
| 656 | return -ENOMEM; |
| 657 | |
| 658 | if (snd_wavefront_pnp (dev, card->private_data, pcard, pid) < 0) { |
| 659 | if (cs4232_pcm_port[dev] == SNDRV_AUTO_PORT) { |
| 660 | snd_printk (KERN_ERR "isapnp detection failed\n"); |
| 661 | snd_card_free (card); |
| 662 | return -ENODEV; |
| 663 | } |
| 664 | } |
| 665 | snd_card_set_dev(card, &pcard->card->dev); |
| 666 | |
| 667 | if ((res = snd_wavefront_probe(card, dev)) < 0) |
| 668 | return res; |
| 669 | |
| 670 | pnp_set_card_drvdata(pcard, card); |
| 671 | dev++; |
Bjorn Helgaas | c94ded6 | 2006-03-27 01:17:18 -0800 | [diff] [blame] | 672 | wavefront_pnp_devices++; |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 673 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 674 | } |
| 675 | |
| 676 | static void __devexit snd_wavefront_pnp_remove(struct pnp_card_link * pcard) |
| 677 | { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 678 | snd_card_free(pnp_get_card_drvdata(pcard)); |
| 679 | pnp_set_card_drvdata(pcard, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 680 | } |
| 681 | |
| 682 | static struct pnp_card_driver wavefront_pnpc_driver = { |
| 683 | .flags = PNP_DRIVER_RES_DISABLE, |
| 684 | .name = "wavefront", |
| 685 | .id_table = snd_wavefront_pnpids, |
| 686 | .probe = snd_wavefront_pnp_detect, |
| 687 | .remove = __devexit_p(snd_wavefront_pnp_remove), |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 688 | /* FIXME: suspend,resume */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 689 | }; |
| 690 | |
| 691 | #endif /* CONFIG_PNP */ |
| 692 | |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 693 | static void __init_or_module snd_wavefront_unregister_all(void) |
| 694 | { |
| 695 | int i; |
| 696 | |
Takashi Iwai | 59b1b34 | 2006-01-04 15:06:44 +0100 | [diff] [blame] | 697 | #ifdef CONFIG_PNP |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 698 | if (pnp_registered) |
| 699 | pnp_unregister_card_driver(&wavefront_pnpc_driver); |
Takashi Iwai | 59b1b34 | 2006-01-04 15:06:44 +0100 | [diff] [blame] | 700 | #endif |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 701 | for (i = 0; i < ARRAY_SIZE(platform_devices); ++i) |
| 702 | platform_device_unregister(platform_devices[i]); |
| 703 | platform_driver_unregister(&snd_wavefront_driver); |
| 704 | } |
| 705 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 706 | static int __init alsa_card_wavefront_init(void) |
| 707 | { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 708 | int i, err, cards = 0; |
| 709 | |
| 710 | if ((err = platform_driver_register(&snd_wavefront_driver)) < 0) |
| 711 | return err; |
| 712 | |
Takashi Iwai | 8278ca8 | 2006-02-20 11:57:34 +0100 | [diff] [blame] | 713 | for (i = 0; i < SNDRV_CARDS; i++) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 714 | struct platform_device *device; |
Takashi Iwai | 8278ca8 | 2006-02-20 11:57:34 +0100 | [diff] [blame] | 715 | if (! enable[i]) |
| 716 | continue; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 717 | #ifdef CONFIG_PNP |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 718 | if (isapnp[i]) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 719 | continue; |
| 720 | #endif |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 721 | device = platform_device_register_simple(WAVEFRONT_DRIVER, |
| 722 | i, NULL, 0); |
Rene Herman | d0ac642 | 2006-04-11 14:08:33 +0200 | [diff] [blame] | 723 | if (IS_ERR(device)) |
| 724 | continue; |
Rene Herman | dcccdd9 | 2006-04-11 14:09:37 +0200 | [diff] [blame] | 725 | if (!platform_get_drvdata(device)) { |
| 726 | platform_device_unregister(device); |
| 727 | continue; |
| 728 | } |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 729 | platform_devices[i] = device; |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 730 | cards++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 731 | } |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 732 | |
Takashi Iwai | 59b1b34 | 2006-01-04 15:06:44 +0100 | [diff] [blame] | 733 | #ifdef CONFIG_PNP |
Bjorn Helgaas | c94ded6 | 2006-03-27 01:17:18 -0800 | [diff] [blame] | 734 | err = pnp_register_card_driver(&wavefront_pnpc_driver); |
| 735 | if (!err) { |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 736 | pnp_registered = 1; |
Bjorn Helgaas | c94ded6 | 2006-03-27 01:17:18 -0800 | [diff] [blame] | 737 | cards += wavefront_pnp_devices; |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 738 | } |
Takashi Iwai | 59b1b34 | 2006-01-04 15:06:44 +0100 | [diff] [blame] | 739 | #endif |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 740 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 741 | if (!cards) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 742 | #ifdef MODULE |
| 743 | printk (KERN_ERR "No WaveFront cards found or devices busy\n"); |
| 744 | #endif |
Rene Herman | d0ac642 | 2006-04-11 14:08:33 +0200 | [diff] [blame] | 745 | snd_wavefront_unregister_all(); |
| 746 | return -ENODEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 747 | } |
| 748 | return 0; |
| 749 | } |
| 750 | |
| 751 | static void __exit alsa_card_wavefront_exit(void) |
| 752 | { |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 753 | snd_wavefront_unregister_all(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 754 | } |
| 755 | |
| 756 | module_init(alsa_card_wavefront_init) |
| 757 | module_exit(alsa_card_wavefront_exit) |