Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * ALSA driver for the Aureal Vortex family of soundprocessors. |
| 3 | * Author: Manuel Jander (mjander@embedded.cl) |
| 4 | * |
| 5 | * This driver is the result of the OpenVortex Project from Savannah |
| 6 | * (savannah.nongnu.org/projects/openvortex). I would like to thank |
| 7 | * the developers of OpenVortex, Jeff Muizelaar and Kester Maddock, from |
| 8 | * whom i got plenty of help, and their codebase was invaluable. |
| 9 | * Thanks to the ALSA developers, they helped a lot working out |
| 10 | * the ALSA part. |
| 11 | * Thanks also to Sourceforge for maintaining the old binary drivers, |
| 12 | * and the forum, where developers could comunicate. |
| 13 | * |
| 14 | * Now at least i can play Legacy DOOM with MIDI music :-) |
| 15 | */ |
| 16 | |
| 17 | #include "au88x0.h" |
| 18 | #include <linux/init.h> |
| 19 | #include <linux/pci.h> |
| 20 | #include <linux/slab.h> |
| 21 | #include <linux/interrupt.h> |
| 22 | #include <linux/moduleparam.h> |
Tobias Klauser | 58da3a2 | 2005-12-01 11:14:00 +0100 | [diff] [blame] | 23 | #include <linux/dma-mapping.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | #include <sound/initval.h> |
| 25 | |
| 26 | // module parameters (see "Module Parameters") |
| 27 | static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; |
| 28 | static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; |
| 29 | static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; |
| 30 | static int pcifix[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 255 }; |
| 31 | |
| 32 | module_param_array(index, int, NULL, 0444); |
| 33 | MODULE_PARM_DESC(index, "Index value for " CARD_NAME " soundcard."); |
| 34 | module_param_array(id, charp, NULL, 0444); |
| 35 | MODULE_PARM_DESC(id, "ID string for " CARD_NAME " soundcard."); |
| 36 | module_param_array(enable, bool, NULL, 0444); |
| 37 | MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard."); |
| 38 | module_param_array(pcifix, int, NULL, 0444); |
| 39 | MODULE_PARM_DESC(pcifix, "Enable VIA-workaround for " CARD_NAME " soundcard."); |
| 40 | |
| 41 | MODULE_DESCRIPTION("Aureal vortex"); |
| 42 | MODULE_LICENSE("GPL"); |
| 43 | MODULE_SUPPORTED_DEVICE("{{Aureal Semiconductor Inc., Aureal Vortex Sound Processor}}"); |
| 44 | |
| 45 | MODULE_DEVICE_TABLE(pci, snd_vortex_ids); |
| 46 | |
| 47 | static void vortex_fix_latency(struct pci_dev *vortex) |
| 48 | { |
| 49 | int rc; |
| 50 | if (!(rc = pci_write_config_byte(vortex, 0x40, 0xff))) { |
| 51 | printk(KERN_INFO CARD_NAME |
| 52 | ": vortex latency is 0xff\n"); |
| 53 | } else { |
| 54 | printk(KERN_WARNING CARD_NAME |
| 55 | ": could not set vortex latency: pci error 0x%x\n", rc); |
| 56 | } |
| 57 | } |
| 58 | |
| 59 | static void vortex_fix_agp_bridge(struct pci_dev *via) |
| 60 | { |
| 61 | int rc; |
| 62 | u8 value; |
| 63 | |
| 64 | /* |
| 65 | * only set the bit (Extend PCI#2 Internal Master for |
| 66 | * Efficient Handling of Dummy Requests) if the can |
| 67 | * read the config and it is not already set |
| 68 | */ |
| 69 | |
| 70 | if (!(rc = pci_read_config_byte(via, 0x42, &value)) |
| 71 | && ((value & 0x10) |
| 72 | || !(rc = pci_write_config_byte(via, 0x42, value | 0x10)))) { |
| 73 | printk(KERN_INFO CARD_NAME |
| 74 | ": bridge config is 0x%x\n", value | 0x10); |
| 75 | } else { |
| 76 | printk(KERN_WARNING CARD_NAME |
| 77 | ": could not set vortex latency: pci error 0x%x\n", rc); |
| 78 | } |
| 79 | } |
| 80 | |
| 81 | static void __devinit snd_vortex_workaround(struct pci_dev *vortex, int fix) |
| 82 | { |
Jiri Slaby | 0dd119f | 2005-09-07 14:28:33 +0200 | [diff] [blame] | 83 | struct pci_dev *via = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 84 | |
| 85 | /* autodetect if workarounds are required */ |
| 86 | if (fix == 255) { |
| 87 | /* VIA KT133 */ |
Jiri Slaby | 0dd119f | 2005-09-07 14:28:33 +0200 | [diff] [blame] | 88 | via = pci_get_device(PCI_VENDOR_ID_VIA, |
| 89 | PCI_DEVICE_ID_VIA_8365_1, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | /* VIA Apollo */ |
| 91 | if (via == NULL) { |
Jiri Slaby | 0dd119f | 2005-09-07 14:28:33 +0200 | [diff] [blame] | 92 | via = pci_get_device(PCI_VENDOR_ID_VIA, |
| 93 | PCI_DEVICE_ID_VIA_82C598_1, NULL); |
| 94 | /* AMD Irongate */ |
| 95 | if (via == NULL) |
| 96 | via = pci_get_device(PCI_VENDOR_ID_AMD, |
| 97 | PCI_DEVICE_ID_AMD_FE_GATE_7007, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | } |
| 99 | if (via) { |
| 100 | printk(KERN_INFO CARD_NAME ": Activating latency workaround...\n"); |
| 101 | vortex_fix_latency(vortex); |
| 102 | vortex_fix_agp_bridge(via); |
| 103 | } |
| 104 | } else { |
| 105 | if (fix & 0x1) |
| 106 | vortex_fix_latency(vortex); |
Jiri Slaby | 0dd119f | 2005-09-07 14:28:33 +0200 | [diff] [blame] | 107 | if ((fix & 0x2) && (via = pci_get_device(PCI_VENDOR_ID_VIA, |
| 108 | PCI_DEVICE_ID_VIA_8365_1, NULL))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | vortex_fix_agp_bridge(via); |
Jiri Slaby | 0dd119f | 2005-09-07 14:28:33 +0200 | [diff] [blame] | 110 | if ((fix & 0x4) && (via = pci_get_device(PCI_VENDOR_ID_VIA, |
| 111 | PCI_DEVICE_ID_VIA_82C598_1, NULL))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | vortex_fix_agp_bridge(via); |
Jiri Slaby | 0dd119f | 2005-09-07 14:28:33 +0200 | [diff] [blame] | 113 | if ((fix & 0x8) && (via = pci_get_device(PCI_VENDOR_ID_AMD, |
| 114 | PCI_DEVICE_ID_AMD_FE_GATE_7007, NULL))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | vortex_fix_agp_bridge(via); |
| 116 | } |
Jiri Slaby | 0dd119f | 2005-09-07 14:28:33 +0200 | [diff] [blame] | 117 | pci_dev_put(via); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | } |
| 119 | |
| 120 | // component-destructor |
| 121 | // (see "Management of Cards and Components") |
Takashi Iwai | 2fd1687 | 2005-11-17 14:55:19 +0100 | [diff] [blame] | 122 | static int snd_vortex_dev_free(struct snd_device *device) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 123 | { |
| 124 | vortex_t *vortex = device->device_data; |
| 125 | |
| 126 | vortex_gameport_unregister(vortex); |
| 127 | vortex_core_shutdown(vortex); |
| 128 | // Take down PCI interface. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | free_irq(vortex->irq, vortex); |
Amol Lad | 8a238c7 | 2006-10-06 16:45:19 +0200 | [diff] [blame] | 130 | iounmap(vortex->mmio); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | pci_release_regions(vortex->pci_dev); |
| 132 | pci_disable_device(vortex->pci_dev); |
| 133 | kfree(vortex); |
| 134 | |
| 135 | return 0; |
| 136 | } |
| 137 | |
| 138 | // chip-specific constructor |
| 139 | // (see "Management of Cards and Components") |
| 140 | static int __devinit |
Takashi Iwai | 2fd1687 | 2005-11-17 14:55:19 +0100 | [diff] [blame] | 141 | snd_vortex_create(struct snd_card *card, struct pci_dev *pci, vortex_t ** rchip) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | { |
| 143 | vortex_t *chip; |
| 144 | int err; |
Takashi Iwai | 2fd1687 | 2005-11-17 14:55:19 +0100 | [diff] [blame] | 145 | static struct snd_device_ops ops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | .dev_free = snd_vortex_dev_free, |
| 147 | }; |
| 148 | |
| 149 | *rchip = NULL; |
| 150 | |
| 151 | // check PCI availability (DMA). |
| 152 | if ((err = pci_enable_device(pci)) < 0) |
| 153 | return err; |
Takashi Iwai | 97c67b6 | 2006-01-13 17:16:29 +0100 | [diff] [blame] | 154 | if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 || |
| 155 | pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 156 | printk(KERN_ERR "error to set DMA mask\n"); |
Takashi Iwai | 97c67b6 | 2006-01-13 17:16:29 +0100 | [diff] [blame] | 157 | pci_disable_device(pci); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 158 | return -ENXIO; |
| 159 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 160 | |
Takashi Iwai | e560d8d | 2005-09-09 14:21:46 +0200 | [diff] [blame] | 161 | chip = kzalloc(sizeof(*chip), GFP_KERNEL); |
Takashi Iwai | 97c67b6 | 2006-01-13 17:16:29 +0100 | [diff] [blame] | 162 | if (chip == NULL) { |
| 163 | pci_disable_device(pci); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | return -ENOMEM; |
Takashi Iwai | 97c67b6 | 2006-01-13 17:16:29 +0100 | [diff] [blame] | 165 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | |
| 167 | chip->card = card; |
| 168 | |
| 169 | // initialize the stuff |
| 170 | chip->pci_dev = pci; |
| 171 | chip->io = pci_resource_start(pci, 0); |
| 172 | chip->vendor = pci->vendor; |
| 173 | chip->device = pci->device; |
| 174 | chip->card = card; |
| 175 | chip->irq = -1; |
| 176 | |
| 177 | // (1) PCI resource allocation |
| 178 | // Get MMIO area |
| 179 | // |
| 180 | if ((err = pci_request_regions(pci, CARD_NAME_SHORT)) != 0) |
| 181 | goto regions_out; |
| 182 | |
Arjan van de Ven | 2f5ad54 | 2008-09-28 16:20:09 -0700 | [diff] [blame^] | 183 | chip->mmio = pci_ioremap_bar(pci, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | if (!chip->mmio) { |
| 185 | printk(KERN_ERR "MMIO area remap failed.\n"); |
| 186 | err = -ENOMEM; |
| 187 | goto ioremap_out; |
| 188 | } |
| 189 | |
| 190 | /* Init audio core. |
| 191 | * This must be done before we do request_irq otherwise we can get spurious |
Robert P. J. Day | 3a4fa0a | 2007-10-19 23:10:43 +0200 | [diff] [blame] | 192 | * interrupts that we do not handle properly and make a mess of things */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 193 | if ((err = vortex_core_init(chip)) != 0) { |
| 194 | printk(KERN_ERR "hw core init failed\n"); |
| 195 | goto core_out; |
| 196 | } |
| 197 | |
| 198 | if ((err = request_irq(pci->irq, vortex_interrupt, |
Takashi Iwai | 437a5a4 | 2006-11-21 12:14:23 +0100 | [diff] [blame] | 199 | IRQF_SHARED, CARD_NAME_SHORT, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | chip)) != 0) { |
| 201 | printk(KERN_ERR "cannot grab irq\n"); |
| 202 | goto irq_out; |
| 203 | } |
| 204 | chip->irq = pci->irq; |
| 205 | |
| 206 | pci_set_master(pci); |
| 207 | // End of PCI setup. |
| 208 | |
| 209 | // Register alsa root device. |
| 210 | if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { |
| 211 | goto alloc_out; |
| 212 | } |
| 213 | |
Takashi Iwai | 97c67b6 | 2006-01-13 17:16:29 +0100 | [diff] [blame] | 214 | snd_card_set_dev(card, &pci->dev); |
| 215 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 216 | *rchip = chip; |
| 217 | |
| 218 | return 0; |
| 219 | |
| 220 | alloc_out: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | free_irq(chip->irq, chip); |
| 222 | irq_out: |
| 223 | vortex_core_shutdown(chip); |
| 224 | core_out: |
| 225 | iounmap(chip->mmio); |
| 226 | ioremap_out: |
| 227 | pci_release_regions(chip->pci_dev); |
| 228 | regions_out: |
| 229 | pci_disable_device(chip->pci_dev); |
| 230 | //FIXME: this not the right place to unregister the gameport |
| 231 | vortex_gameport_unregister(chip); |
Jesper Juhl | 6ed44ad | 2007-08-06 14:05:27 +0200 | [diff] [blame] | 232 | kfree(chip); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | return err; |
| 234 | } |
| 235 | |
| 236 | // constructor -- see "Constructor" sub-section |
| 237 | static int __devinit |
| 238 | snd_vortex_probe(struct pci_dev *pci, const struct pci_device_id *pci_id) |
| 239 | { |
| 240 | static int dev; |
Takashi Iwai | 2fd1687 | 2005-11-17 14:55:19 +0100 | [diff] [blame] | 241 | struct snd_card *card; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | vortex_t *chip; |
| 243 | int err; |
| 244 | |
| 245 | // (1) |
| 246 | if (dev >= SNDRV_CARDS) |
| 247 | return -ENODEV; |
| 248 | if (!enable[dev]) { |
| 249 | dev++; |
| 250 | return -ENOENT; |
| 251 | } |
| 252 | // (2) |
| 253 | card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); |
| 254 | if (card == NULL) |
| 255 | return -ENOMEM; |
| 256 | |
| 257 | // (3) |
| 258 | if ((err = snd_vortex_create(card, pci, &chip)) < 0) { |
| 259 | snd_card_free(card); |
| 260 | return err; |
| 261 | } |
| 262 | snd_vortex_workaround(pci, pcifix[dev]); |
Alan Horstmann | 520290e | 2006-05-03 17:07:29 +0200 | [diff] [blame] | 263 | |
| 264 | // Card details needed in snd_vortex_midi |
| 265 | strcpy(card->driver, CARD_NAME_SHORT); |
| 266 | sprintf(card->shortname, "Aureal Vortex %s", CARD_NAME_SHORT); |
| 267 | sprintf(card->longname, "%s at 0x%lx irq %i", |
| 268 | card->shortname, chip->io, chip->irq); |
| 269 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 270 | // (4) Alloc components. |
| 271 | // ADB pcm. |
| 272 | if ((err = snd_vortex_new_pcm(chip, VORTEX_PCM_ADB, NR_ADB)) < 0) { |
| 273 | snd_card_free(card); |
| 274 | return err; |
| 275 | } |
| 276 | #ifndef CHIP_AU8820 |
| 277 | // ADB SPDIF |
| 278 | if ((err = snd_vortex_new_pcm(chip, VORTEX_PCM_SPDIF, 1)) < 0) { |
| 279 | snd_card_free(card); |
| 280 | return err; |
| 281 | } |
| 282 | // A3D |
| 283 | if ((err = snd_vortex_new_pcm(chip, VORTEX_PCM_A3D, NR_A3D)) < 0) { |
| 284 | snd_card_free(card); |
| 285 | return err; |
| 286 | } |
| 287 | #endif |
| 288 | /* |
| 289 | // ADB I2S |
| 290 | if ((err = snd_vortex_new_pcm(chip, VORTEX_PCM_I2S, 1)) < 0) { |
| 291 | snd_card_free(card); |
| 292 | return err; |
| 293 | } |
| 294 | */ |
| 295 | #ifndef CHIP_AU8810 |
| 296 | // WT pcm. |
| 297 | if ((err = snd_vortex_new_pcm(chip, VORTEX_PCM_WT, NR_WT)) < 0) { |
| 298 | snd_card_free(card); |
| 299 | return err; |
| 300 | } |
| 301 | #endif |
| 302 | // snd_ac97_mixer and Vortex mixer. |
| 303 | if ((err = snd_vortex_mixer(chip)) < 0) { |
| 304 | snd_card_free(card); |
| 305 | return err; |
| 306 | } |
| 307 | if ((err = snd_vortex_midi(chip)) < 0) { |
| 308 | snd_card_free(card); |
| 309 | return err; |
| 310 | } |
| 311 | |
| 312 | vortex_gameport_register(chip); |
| 313 | |
| 314 | #if 0 |
| 315 | if (snd_seq_device_new(card, 1, SNDRV_SEQ_DEV_ID_VORTEX_SYNTH, |
| 316 | sizeof(snd_vortex_synth_arg_t), &wave) < 0 |
| 317 | || wave == NULL) { |
Takashi Iwai | 99b359b | 2005-10-20 18:26:44 +0200 | [diff] [blame] | 318 | snd_printk(KERN_ERR "Can't initialize Aureal wavetable synth\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | } else { |
| 320 | snd_vortex_synth_arg_t *arg; |
| 321 | |
| 322 | arg = SNDRV_SEQ_DEVICE_ARGPTR(wave); |
| 323 | strcpy(wave->name, "Aureal Synth"); |
| 324 | arg->hwptr = vortex; |
| 325 | arg->index = 1; |
| 326 | arg->seq_ports = seq_ports[dev]; |
| 327 | arg->max_voices = max_synth_voices[dev]; |
| 328 | } |
| 329 | #endif |
| 330 | |
| 331 | // (5) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 332 | if ((err = pci_read_config_word(pci, PCI_DEVICE_ID, |
| 333 | &(chip->device))) < 0) { |
| 334 | snd_card_free(card); |
| 335 | return err; |
| 336 | } |
| 337 | if ((err = pci_read_config_word(pci, PCI_VENDOR_ID, |
| 338 | &(chip->vendor))) < 0) { |
| 339 | snd_card_free(card); |
| 340 | return err; |
| 341 | } |
Auke Kok | 44c1013 | 2007-06-08 15:46:36 -0700 | [diff] [blame] | 342 | chip->rev = pci->revision; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 343 | #ifdef CHIP_AU8830 |
| 344 | if ((chip->rev) != 0xfe && (chip->rev) != 0xfa) { |
| 345 | printk(KERN_ALERT |
| 346 | "vortex: The revision (%x) of your card has not been seen before.\n", |
| 347 | chip->rev); |
| 348 | printk(KERN_ALERT |
| 349 | "vortex: Please email the results of 'lspci -vv' to openvortex-dev@nongnu.org.\n"); |
| 350 | snd_card_free(card); |
| 351 | err = -ENODEV; |
| 352 | return err; |
| 353 | } |
| 354 | #endif |
| 355 | |
| 356 | // (6) |
| 357 | if ((err = snd_card_register(card)) < 0) { |
| 358 | snd_card_free(card); |
| 359 | return err; |
| 360 | } |
| 361 | // (7) |
| 362 | pci_set_drvdata(pci, card); |
| 363 | dev++; |
| 364 | vortex_connect_default(chip, 1); |
| 365 | vortex_enable_int(chip); |
| 366 | return 0; |
| 367 | } |
| 368 | |
| 369 | // destructor -- see "Destructor" sub-section |
| 370 | static void __devexit snd_vortex_remove(struct pci_dev *pci) |
| 371 | { |
| 372 | snd_card_free(pci_get_drvdata(pci)); |
| 373 | pci_set_drvdata(pci, NULL); |
| 374 | } |
| 375 | |
| 376 | // pci_driver definition |
| 377 | static struct pci_driver driver = { |
| 378 | .name = CARD_NAME_SHORT, |
| 379 | .id_table = snd_vortex_ids, |
| 380 | .probe = snd_vortex_probe, |
| 381 | .remove = __devexit_p(snd_vortex_remove), |
| 382 | }; |
| 383 | |
| 384 | // initialization of the module |
| 385 | static int __init alsa_card_vortex_init(void) |
| 386 | { |
Takashi Iwai | 01d25d4 | 2005-04-11 16:58:24 +0200 | [diff] [blame] | 387 | return pci_register_driver(&driver); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 388 | } |
| 389 | |
| 390 | // clean up the module |
| 391 | static void __exit alsa_card_vortex_exit(void) |
| 392 | { |
| 393 | pci_unregister_driver(&driver); |
| 394 | } |
| 395 | |
| 396 | module_init(alsa_card_vortex_init) |
| 397 | module_exit(alsa_card_vortex_exit) |