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 */ |
| 53 | static int use_cs4232_midi[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0}; |
| 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 | |
| 266 | static irqreturn_t snd_wavefront_ics2115_interrupt(int irq, |
| 267 | void *dev_id, |
| 268 | struct pt_regs *regs) |
| 269 | { |
| 270 | snd_wavefront_card_t *acard; |
| 271 | |
| 272 | acard = (snd_wavefront_card_t *) dev_id; |
| 273 | |
| 274 | if (acard == NULL) |
| 275 | return IRQ_NONE; |
| 276 | |
| 277 | if (acard->wavefront.interrupts_are_midi) { |
| 278 | snd_wavefront_midi_interrupt (acard); |
| 279 | } else { |
| 280 | snd_wavefront_internal_interrupt (acard); |
| 281 | } |
| 282 | return IRQ_HANDLED; |
| 283 | } |
| 284 | |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 285 | static struct snd_hwdep * __devinit |
| 286 | snd_wavefront_new_synth (struct snd_card *card, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 287 | int hw_dev, |
| 288 | snd_wavefront_card_t *acard) |
| 289 | { |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 290 | struct snd_hwdep *wavefront_synth; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 291 | |
| 292 | if (snd_wavefront_detect (acard) < 0) { |
| 293 | return NULL; |
| 294 | } |
| 295 | |
| 296 | if (snd_wavefront_start (&acard->wavefront) < 0) { |
| 297 | return NULL; |
| 298 | } |
| 299 | |
| 300 | if (snd_hwdep_new(card, "WaveFront", hw_dev, &wavefront_synth) < 0) |
| 301 | return NULL; |
| 302 | strcpy (wavefront_synth->name, |
| 303 | "WaveFront (ICS2115) wavetable synthesizer"); |
| 304 | wavefront_synth->ops.open = snd_wavefront_synth_open; |
| 305 | wavefront_synth->ops.release = snd_wavefront_synth_release; |
| 306 | wavefront_synth->ops.ioctl = snd_wavefront_synth_ioctl; |
| 307 | |
| 308 | return wavefront_synth; |
| 309 | } |
| 310 | |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 311 | static struct snd_hwdep * __devinit |
| 312 | snd_wavefront_new_fx (struct snd_card *card, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 313 | int hw_dev, |
| 314 | snd_wavefront_card_t *acard, |
| 315 | unsigned long port) |
| 316 | |
| 317 | { |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 318 | struct snd_hwdep *fx_processor; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | |
| 320 | if (snd_wavefront_fx_start (&acard->wavefront)) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 321 | snd_printk (KERN_ERR "cannot initialize YSS225 FX processor"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 322 | return NULL; |
| 323 | } |
| 324 | |
| 325 | if (snd_hwdep_new (card, "YSS225", hw_dev, &fx_processor) < 0) |
| 326 | return NULL; |
| 327 | sprintf (fx_processor->name, "YSS225 FX Processor at 0x%lx", port); |
| 328 | fx_processor->ops.open = snd_wavefront_fx_open; |
| 329 | fx_processor->ops.release = snd_wavefront_fx_release; |
| 330 | fx_processor->ops.ioctl = snd_wavefront_fx_ioctl; |
| 331 | |
| 332 | return fx_processor; |
| 333 | } |
| 334 | |
| 335 | static snd_wavefront_mpu_id internal_id = internal_mpu; |
| 336 | static snd_wavefront_mpu_id external_id = external_mpu; |
| 337 | |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 338 | static struct snd_rawmidi *__devinit |
| 339 | snd_wavefront_new_midi (struct snd_card *card, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 340 | int midi_dev, |
| 341 | snd_wavefront_card_t *acard, |
| 342 | unsigned long port, |
| 343 | snd_wavefront_mpu_id mpu) |
| 344 | |
| 345 | { |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 346 | struct snd_rawmidi *rmidi; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 347 | static int first = 1; |
| 348 | |
| 349 | if (first) { |
| 350 | first = 0; |
| 351 | acard->wavefront.midi.base = port; |
| 352 | if (snd_wavefront_midi_start (acard)) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 353 | snd_printk (KERN_ERR "cannot initialize MIDI interface\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 354 | return NULL; |
| 355 | } |
| 356 | } |
| 357 | |
| 358 | if (snd_rawmidi_new (card, "WaveFront MIDI", midi_dev, 1, 1, &rmidi) < 0) |
| 359 | return NULL; |
| 360 | |
| 361 | if (mpu == internal_mpu) { |
| 362 | strcpy(rmidi->name, "WaveFront MIDI (Internal)"); |
| 363 | rmidi->private_data = &internal_id; |
| 364 | } else { |
| 365 | strcpy(rmidi->name, "WaveFront MIDI (External)"); |
| 366 | rmidi->private_data = &external_id; |
| 367 | } |
| 368 | |
| 369 | snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_wavefront_midi_output); |
| 370 | snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_wavefront_midi_input); |
| 371 | |
| 372 | rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | |
| 373 | SNDRV_RAWMIDI_INFO_INPUT | |
| 374 | SNDRV_RAWMIDI_INFO_DUPLEX; |
| 375 | |
| 376 | return rmidi; |
| 377 | } |
| 378 | |
| 379 | static void |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 380 | snd_wavefront_free(struct snd_card *card) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 381 | { |
| 382 | snd_wavefront_card_t *acard = (snd_wavefront_card_t *)card->private_data; |
| 383 | |
| 384 | if (acard) { |
Takashi Iwai | b1d5776 | 2005-10-10 11:56:31 +0200 | [diff] [blame] | 385 | release_and_free_resource(acard->wavefront.res_base); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 386 | if (acard->wavefront.irq > 0) |
| 387 | free_irq(acard->wavefront.irq, (void *)acard); |
| 388 | } |
| 389 | } |
| 390 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 391 | static struct snd_card *snd_wavefront_card_new(int dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 392 | { |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 393 | struct snd_card *card; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 394 | snd_wavefront_card_t *acard; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 395 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 396 | card = snd_card_new (index[dev], id[dev], THIS_MODULE, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 397 | sizeof(snd_wavefront_card_t)); |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 398 | if (card == NULL) |
| 399 | return NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 400 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 401 | acard = card->private_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 402 | acard->wavefront.irq = -1; |
| 403 | spin_lock_init(&acard->wavefront.irq_lock); |
| 404 | init_waitqueue_head(&acard->wavefront.interrupt_sleeper); |
| 405 | spin_lock_init(&acard->wavefront.midi.open); |
| 406 | spin_lock_init(&acard->wavefront.midi.virtual); |
| 407 | card->private_free = snd_wavefront_free; |
| 408 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 409 | return card; |
| 410 | } |
| 411 | |
| 412 | static int __devinit |
| 413 | snd_wavefront_probe (struct snd_card *card, int dev) |
| 414 | { |
| 415 | snd_wavefront_card_t *acard = card->private_data; |
| 416 | struct snd_cs4231 *chip; |
| 417 | struct snd_hwdep *wavefront_synth; |
| 418 | struct snd_rawmidi *ics2115_internal_rmidi = NULL; |
| 419 | struct snd_rawmidi *ics2115_external_rmidi = NULL; |
| 420 | struct snd_hwdep *fx_processor; |
| 421 | int hw_dev = 0, midi_dev = 0, err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 422 | |
| 423 | /* --------- PCM --------------- */ |
| 424 | |
| 425 | if ((err = snd_cs4231_create (card, |
| 426 | cs4232_pcm_port[dev], |
| 427 | -1, |
| 428 | cs4232_pcm_irq[dev], |
| 429 | dma1[dev], |
| 430 | dma2[dev], |
| 431 | CS4231_HW_DETECT, 0, &chip)) < 0) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 432 | snd_printk (KERN_ERR "can't allocate CS4231 device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 433 | return err; |
| 434 | } |
| 435 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 436 | if ((err = snd_cs4231_pcm (chip, 0, NULL)) < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 437 | return err; |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 438 | |
| 439 | if ((err = snd_cs4231_timer (chip, 0, NULL)) < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 440 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 441 | |
| 442 | /* ---------- OPL3 synth --------- */ |
| 443 | |
| 444 | if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) { |
Takashi Iwai | 542172f | 2005-11-17 14:39:06 +0100 | [diff] [blame] | 445 | struct snd_opl3 *opl3; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 446 | |
| 447 | if ((err = snd_opl3_create(card, |
| 448 | fm_port[dev], |
| 449 | fm_port[dev] + 2, |
| 450 | OPL3_HW_OPL3_CS, |
| 451 | 0, &opl3)) < 0) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 452 | snd_printk (KERN_ERR "can't allocate or detect OPL3 synth\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 453 | return err; |
| 454 | } |
| 455 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 456 | if ((err = snd_opl3_hwdep_new(opl3, hw_dev, 1, NULL)) < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 457 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 458 | hw_dev++; |
| 459 | } |
| 460 | |
| 461 | /* ------- ICS2115 Wavetable synth ------- */ |
| 462 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 463 | if ((acard->wavefront.res_base = request_region(ics2115_port[dev], 16, |
| 464 | "ICS2115")) == NULL) { |
| 465 | snd_printk(KERN_ERR "unable to grab ICS2115 i/o region 0x%lx-0x%lx\n", |
| 466 | ics2115_port[dev], ics2115_port[dev] + 16 - 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 467 | return -EBUSY; |
| 468 | } |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 469 | if (request_irq(ics2115_irq[dev], snd_wavefront_ics2115_interrupt, |
| 470 | SA_INTERRUPT, "ICS2115", acard)) { |
| 471 | 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] | 472 | return -EBUSY; |
| 473 | } |
| 474 | |
| 475 | acard->wavefront.irq = ics2115_irq[dev]; |
| 476 | acard->wavefront.base = ics2115_port[dev]; |
| 477 | |
| 478 | if ((wavefront_synth = snd_wavefront_new_synth (card, hw_dev, acard)) == NULL) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 479 | snd_printk (KERN_ERR "can't create WaveFront synth device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 480 | return -ENOMEM; |
| 481 | } |
| 482 | |
| 483 | strcpy (wavefront_synth->name, "ICS2115 Wavetable MIDI Synthesizer"); |
| 484 | wavefront_synth->iface = SNDRV_HWDEP_IFACE_ICS2115; |
| 485 | hw_dev++; |
| 486 | |
| 487 | /* --------- Mixer ------------ */ |
| 488 | |
| 489 | if ((err = snd_cs4231_mixer(chip)) < 0) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 490 | snd_printk (KERN_ERR "can't allocate mixer device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 491 | return err; |
| 492 | } |
| 493 | |
| 494 | /* -------- CS4232 MPU-401 interface -------- */ |
| 495 | |
| 496 | if (cs4232_mpu_port[dev] > 0 && cs4232_mpu_port[dev] != SNDRV_AUTO_PORT) { |
| 497 | if ((err = snd_mpu401_uart_new(card, midi_dev, MPU401_HW_CS4232, |
| 498 | cs4232_mpu_port[dev], 0, |
| 499 | cs4232_mpu_irq[dev], |
| 500 | SA_INTERRUPT, |
| 501 | NULL)) < 0) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 502 | snd_printk (KERN_ERR "can't allocate CS4232 MPU-401 device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 503 | return err; |
| 504 | } |
| 505 | midi_dev++; |
| 506 | } |
| 507 | |
| 508 | /* ------ ICS2115 internal MIDI ------------ */ |
| 509 | |
| 510 | if (ics2115_port[dev] > 0 && ics2115_port[dev] != SNDRV_AUTO_PORT) { |
| 511 | ics2115_internal_rmidi = |
| 512 | snd_wavefront_new_midi (card, |
| 513 | midi_dev, |
| 514 | acard, |
| 515 | ics2115_port[dev], |
| 516 | internal_mpu); |
| 517 | if (ics2115_internal_rmidi == NULL) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 518 | snd_printk (KERN_ERR "can't setup ICS2115 internal MIDI device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 519 | return -ENOMEM; |
| 520 | } |
| 521 | midi_dev++; |
| 522 | } |
| 523 | |
| 524 | /* ------ ICS2115 external MIDI ------------ */ |
| 525 | |
| 526 | if (ics2115_port[dev] > 0 && ics2115_port[dev] != SNDRV_AUTO_PORT) { |
| 527 | ics2115_external_rmidi = |
| 528 | snd_wavefront_new_midi (card, |
| 529 | midi_dev, |
| 530 | acard, |
| 531 | ics2115_port[dev], |
| 532 | external_mpu); |
| 533 | if (ics2115_external_rmidi == NULL) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 534 | snd_printk (KERN_ERR "can't setup ICS2115 external MIDI device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 535 | return -ENOMEM; |
| 536 | } |
| 537 | midi_dev++; |
| 538 | } |
| 539 | |
| 540 | /* FX processor for Tropez+ */ |
| 541 | |
| 542 | if (acard->wavefront.has_fx) { |
| 543 | fx_processor = snd_wavefront_new_fx (card, |
| 544 | hw_dev, |
| 545 | acard, |
| 546 | ics2115_port[dev]); |
| 547 | if (fx_processor == NULL) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 548 | snd_printk (KERN_ERR "can't setup FX device\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 549 | return -ENOMEM; |
| 550 | } |
| 551 | |
| 552 | hw_dev++; |
| 553 | |
| 554 | strcpy(card->driver, "Tropez+"); |
| 555 | strcpy(card->shortname, "Turtle Beach Tropez+"); |
| 556 | } else { |
| 557 | /* Need a way to distinguish between Maui and Tropez */ |
| 558 | strcpy(card->driver, "WaveFront"); |
| 559 | strcpy(card->shortname, "Turtle Beach WaveFront"); |
| 560 | } |
| 561 | |
| 562 | /* ----- Register the card --------- */ |
| 563 | |
| 564 | /* Not safe to include "Turtle Beach" in longname, due to |
| 565 | length restrictions |
| 566 | */ |
| 567 | |
| 568 | sprintf(card->longname, "%s PCM 0x%lx irq %d dma %d", |
| 569 | card->driver, |
| 570 | chip->port, |
| 571 | cs4232_pcm_irq[dev], |
| 572 | dma1[dev]); |
| 573 | |
| 574 | if (dma2[dev] >= 0 && dma2[dev] < 8) |
| 575 | sprintf(card->longname + strlen(card->longname), "&%d", dma2[dev]); |
| 576 | |
| 577 | if (cs4232_mpu_port[dev] > 0 && cs4232_mpu_port[dev] != SNDRV_AUTO_PORT) { |
| 578 | sprintf (card->longname + strlen (card->longname), |
| 579 | " MPU-401 0x%lx irq %d", |
| 580 | cs4232_mpu_port[dev], |
| 581 | cs4232_mpu_irq[dev]); |
| 582 | } |
| 583 | |
| 584 | sprintf (card->longname + strlen (card->longname), |
| 585 | " SYNTH 0x%lx irq %d", |
| 586 | ics2115_port[dev], |
| 587 | ics2115_irq[dev]); |
| 588 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 589 | return snd_card_register(card); |
| 590 | } |
| 591 | |
Bjorn Helgaas | c94ded6 | 2006-03-27 01:17:18 -0800 | [diff] [blame] | 592 | static int __devinit snd_wavefront_nonpnp_probe(struct platform_device *pdev) |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 593 | { |
| 594 | int dev = pdev->id; |
| 595 | struct snd_card *card; |
| 596 | int err; |
| 597 | |
| 598 | if (cs4232_pcm_port[dev] == SNDRV_AUTO_PORT) { |
| 599 | snd_printk("specify CS4232 port\n"); |
| 600 | return -EINVAL; |
| 601 | } |
| 602 | if (ics2115_port[dev] == SNDRV_AUTO_PORT) { |
| 603 | snd_printk("specify ICS2115 port\n"); |
| 604 | return -ENODEV; |
Takashi Iwai | 43bcd97 | 2005-09-05 17:19:20 +0200 | [diff] [blame] | 605 | } |
| 606 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 607 | card = snd_wavefront_card_new(dev); |
| 608 | if (! card) |
| 609 | return -ENOMEM; |
| 610 | snd_card_set_dev(card, &pdev->dev); |
| 611 | if ((err = snd_wavefront_probe(card, dev)) < 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 612 | snd_card_free(card); |
| 613 | return err; |
| 614 | } |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 615 | |
| 616 | platform_set_drvdata(pdev, card); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 617 | return 0; |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 618 | } |
| 619 | |
| 620 | static int __devexit snd_wavefront_nonpnp_remove(struct platform_device *devptr) |
| 621 | { |
| 622 | snd_card_free(platform_get_drvdata(devptr)); |
| 623 | platform_set_drvdata(devptr, NULL); |
| 624 | return 0; |
| 625 | } |
| 626 | |
| 627 | #define WAVEFRONT_DRIVER "snd_wavefront" |
| 628 | |
| 629 | static struct platform_driver snd_wavefront_driver = { |
| 630 | .probe = snd_wavefront_nonpnp_probe, |
| 631 | .remove = __devexit_p(snd_wavefront_nonpnp_remove), |
| 632 | /* FIXME: suspend, resume */ |
| 633 | .driver = { |
| 634 | .name = WAVEFRONT_DRIVER |
| 635 | }, |
| 636 | }; |
| 637 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 638 | |
| 639 | #ifdef CONFIG_PNP |
Bjorn Helgaas | c94ded6 | 2006-03-27 01:17:18 -0800 | [diff] [blame] | 640 | static unsigned int __devinitdata wavefront_pnp_devices; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 641 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 642 | static int __devinit snd_wavefront_pnp_detect(struct pnp_card_link *pcard, |
| 643 | const struct pnp_card_device_id *pid) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 644 | { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 645 | static int dev; |
| 646 | struct snd_card *card; |
| 647 | int res; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 648 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 649 | for ( ; dev < SNDRV_CARDS; dev++) { |
| 650 | if (enable[dev] && isapnp[dev]) |
| 651 | break; |
| 652 | } |
| 653 | if (dev >= SNDRV_CARDS) |
| 654 | return -ENODEV; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 655 | |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 656 | card = snd_wavefront_card_new(dev); |
| 657 | if (! card) |
| 658 | return -ENOMEM; |
| 659 | |
| 660 | if (snd_wavefront_pnp (dev, card->private_data, pcard, pid) < 0) { |
| 661 | if (cs4232_pcm_port[dev] == SNDRV_AUTO_PORT) { |
| 662 | snd_printk (KERN_ERR "isapnp detection failed\n"); |
| 663 | snd_card_free (card); |
| 664 | return -ENODEV; |
| 665 | } |
| 666 | } |
| 667 | snd_card_set_dev(card, &pcard->card->dev); |
| 668 | |
| 669 | if ((res = snd_wavefront_probe(card, dev)) < 0) |
| 670 | return res; |
| 671 | |
| 672 | pnp_set_card_drvdata(pcard, card); |
| 673 | dev++; |
Bjorn Helgaas | c94ded6 | 2006-03-27 01:17:18 -0800 | [diff] [blame] | 674 | wavefront_pnp_devices++; |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 675 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 676 | } |
| 677 | |
| 678 | static void __devexit snd_wavefront_pnp_remove(struct pnp_card_link * pcard) |
| 679 | { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 680 | snd_card_free(pnp_get_card_drvdata(pcard)); |
| 681 | pnp_set_card_drvdata(pcard, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 682 | } |
| 683 | |
| 684 | static struct pnp_card_driver wavefront_pnpc_driver = { |
| 685 | .flags = PNP_DRIVER_RES_DISABLE, |
| 686 | .name = "wavefront", |
| 687 | .id_table = snd_wavefront_pnpids, |
| 688 | .probe = snd_wavefront_pnp_detect, |
| 689 | .remove = __devexit_p(snd_wavefront_pnp_remove), |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 690 | /* FIXME: suspend,resume */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 691 | }; |
| 692 | |
| 693 | #endif /* CONFIG_PNP */ |
| 694 | |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 695 | static void __init_or_module snd_wavefront_unregister_all(void) |
| 696 | { |
| 697 | int i; |
| 698 | |
Takashi Iwai | 59b1b34 | 2006-01-04 15:06:44 +0100 | [diff] [blame] | 699 | #ifdef CONFIG_PNP |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 700 | if (pnp_registered) |
| 701 | pnp_unregister_card_driver(&wavefront_pnpc_driver); |
Takashi Iwai | 59b1b34 | 2006-01-04 15:06:44 +0100 | [diff] [blame] | 702 | #endif |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 703 | for (i = 0; i < ARRAY_SIZE(platform_devices); ++i) |
| 704 | platform_device_unregister(platform_devices[i]); |
| 705 | platform_driver_unregister(&snd_wavefront_driver); |
| 706 | } |
| 707 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 708 | static int __init alsa_card_wavefront_init(void) |
| 709 | { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 710 | int i, err, cards = 0; |
| 711 | |
| 712 | if ((err = platform_driver_register(&snd_wavefront_driver)) < 0) |
| 713 | return err; |
| 714 | |
Takashi Iwai | 8278ca8 | 2006-02-20 11:57:34 +0100 | [diff] [blame] | 715 | for (i = 0; i < SNDRV_CARDS; i++) { |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 716 | struct platform_device *device; |
Takashi Iwai | 8278ca8 | 2006-02-20 11:57:34 +0100 | [diff] [blame] | 717 | if (! enable[i]) |
| 718 | continue; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 719 | #ifdef CONFIG_PNP |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 720 | if (isapnp[i]) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 721 | continue; |
| 722 | #endif |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 723 | device = platform_device_register_simple(WAVEFRONT_DRIVER, |
| 724 | i, NULL, 0); |
| 725 | if (IS_ERR(device)) { |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 726 | err = PTR_ERR(device); |
| 727 | goto errout; |
Takashi Iwai | d29b761 | 2005-11-17 17:14:11 +0100 | [diff] [blame] | 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 |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 745 | err = -ENODEV; |
| 746 | goto errout; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 747 | } |
| 748 | return 0; |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 749 | |
| 750 | errout: |
| 751 | snd_wavefront_unregister_all(); |
| 752 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 753 | } |
| 754 | |
| 755 | static void __exit alsa_card_wavefront_exit(void) |
| 756 | { |
Clemens Ladisch | f7a9275 | 2005-12-07 09:13:42 +0100 | [diff] [blame] | 757 | snd_wavefront_unregister_all(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 758 | } |
| 759 | |
| 760 | module_init(alsa_card_wavefront_init) |
| 761 | module_exit(alsa_card_wavefront_exit) |