1 /* 2 card-azt2320.c - driver for Aztech Systems AZT2320 based soundcards. 3 Copyright (C) 1999-2000 by Massimo Piccioni <dafastidio@libero.it> 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 2 of the License, or 8 (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the Free Software 17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 */ 19 20 /* 21 This driver should provide support for most Aztech AZT2320 based cards. 22 Several AZT2316 chips are also supported/tested, but autoprobe doesn't 23 work: all module option have to be set. 24 25 No docs available for us at Aztech headquarters !!! Unbelievable ... 26 No other help obtained. 27 28 Thanks to Rainer Wiesner <rainer.wiesner@01019freenet.de> for the WSS 29 activation method (full-duplex audio!). 30 */ 31 32 #include <sound/driver.h> 33 #include <asm/io.h> 34 #include <linux/delay.h> 35 #include <linux/init.h> 36 #include <linux/time.h> 37 #include <linux/wait.h> 38 #include <linux/pnp.h> 39 #include <linux/moduleparam.h> 40 #include <sound/core.h> 41 #include <sound/initval.h> 42 #include <sound/cs4231.h> 43 #include <sound/mpu401.h> 44 #include <sound/opl3.h> 45 46 #define PFX "azt2320: " 47 48 MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>"); 49 MODULE_DESCRIPTION("Aztech Systems AZT2320"); 50 MODULE_LICENSE("GPL"); 51 MODULE_SUPPORTED_DEVICE("{{Aztech Systems,PRO16V}," 52 "{Aztech Systems,AZT2320}," 53 "{Aztech Systems,AZT3300}," 54 "{Aztech Systems,AZT2320}," 55 "{Aztech Systems,AZT3000}}"); 56 57 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 58 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 59 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_ISAPNP; /* Enable this card */ 60 static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ 61 static long wss_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ 62 static long mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ 63 static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* PnP setup */ 64 static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* Pnp setup */ 65 static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* Pnp setup */ 66 static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* PnP setup */ 67 static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* PnP setup */ 68 69 module_param_array(index, int, NULL, 0444); 70 MODULE_PARM_DESC(index, "Index value for azt2320 based soundcard."); 71 module_param_array(id, charp, NULL, 0444); 72 MODULE_PARM_DESC(id, "ID string for azt2320 based soundcard."); 73 module_param_array(enable, bool, NULL, 0444); 74 MODULE_PARM_DESC(enable, "Enable azt2320 based soundcard."); 75 module_param_array(port, long, NULL, 0444); 76 MODULE_PARM_DESC(port, "Port # for azt2320 driver."); 77 module_param_array(wss_port, long, NULL, 0444); 78 MODULE_PARM_DESC(wss_port, "WSS Port # for azt2320 driver."); 79 module_param_array(mpu_port, long, NULL, 0444); 80 MODULE_PARM_DESC(mpu_port, "MPU-401 port # for azt2320 driver."); 81 module_param_array(fm_port, long, NULL, 0444); 82 MODULE_PARM_DESC(fm_port, "FM port # for azt2320 driver."); 83 module_param_array(irq, int, NULL, 0444); 84 MODULE_PARM_DESC(irq, "IRQ # for azt2320 driver."); 85 module_param_array(mpu_irq, int, NULL, 0444); 86 MODULE_PARM_DESC(mpu_irq, "MPU-401 IRQ # for azt2320 driver."); 87 module_param_array(dma1, int, NULL, 0444); 88 MODULE_PARM_DESC(dma1, "1st DMA # for azt2320 driver."); 89 module_param_array(dma2, int, NULL, 0444); 90 MODULE_PARM_DESC(dma2, "2nd DMA # for azt2320 driver."); 91 92 struct snd_card_azt2320 { 93 int dev_no; 94 struct pnp_dev *dev; 95 struct pnp_dev *devmpu; 96 struct snd_cs4231 *chip; 97 }; 98 99 static struct pnp_card_device_id snd_azt2320_pnpids[] = { 100 /* PRO16V */ 101 { .id = "AZT1008", .devs = { { "AZT1008" }, { "AZT2001" }, } }, 102 /* Aztech Sound Galaxy 16 */ 103 { .id = "AZT2320", .devs = { { "AZT0001" }, { "AZT0002" }, } }, 104 /* Packard Bell Sound III 336 AM/SP */ 105 { .id = "AZT3000", .devs = { { "AZT1003" }, { "AZT2001" }, } }, 106 /* AT3300 */ 107 { .id = "AZT3002", .devs = { { "AZT1004" }, { "AZT2001" }, } }, 108 /* --- */ 109 { .id = "AZT3005", .devs = { { "AZT1003" }, { "AZT2001" }, } }, 110 /* --- */ 111 { .id = "AZT3011", .devs = { { "AZT1003" }, { "AZT2001" }, } }, 112 { .id = "" } /* end */ 113 }; 114 115 MODULE_DEVICE_TABLE(pnp_card, snd_azt2320_pnpids); 116 117 #define DRIVER_NAME "snd-card-azt2320" 118 119 static int __devinit snd_card_azt2320_pnp(int dev, struct snd_card_azt2320 *acard, 120 struct pnp_card_link *card, 121 const struct pnp_card_device_id *id) 122 { 123 struct pnp_dev *pdev; 124 struct pnp_resource_table * cfg = kmalloc(sizeof(struct pnp_resource_table), GFP_KERNEL); 125 int err; 126 127 if (!cfg) 128 return -ENOMEM; 129 130 acard->dev = pnp_request_card_device(card, id->devs[0].id, NULL); 131 if (acard->dev == NULL) { 132 kfree(cfg); 133 return -ENODEV; 134 } 135 136 acard->devmpu = pnp_request_card_device(card, id->devs[1].id, NULL); 137 138 pdev = acard->dev; 139 pnp_init_resource_table(cfg); 140 141 /* override resources */ 142 if (port[dev] != SNDRV_AUTO_PORT) 143 pnp_resource_change(&cfg->port_resource[0], port[dev], 16); 144 if (fm_port[dev] != SNDRV_AUTO_PORT) 145 pnp_resource_change(&cfg->port_resource[1], fm_port[dev], 4); 146 if (wss_port[dev] != SNDRV_AUTO_PORT) 147 pnp_resource_change(&cfg->port_resource[2], wss_port[dev], 4); 148 if (dma1[dev] != SNDRV_AUTO_DMA) 149 pnp_resource_change(&cfg->dma_resource[0], dma1[dev], 1); 150 if (dma2[dev] != SNDRV_AUTO_DMA) 151 pnp_resource_change(&cfg->dma_resource[1], dma2[dev], 1); 152 if (irq[dev] != SNDRV_AUTO_IRQ) 153 pnp_resource_change(&cfg->irq_resource[0], irq[dev], 1); 154 if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0) 155 snd_printk(KERN_ERR PFX "AUDIO the requested resources are invalid, using auto config\n"); 156 157 err = pnp_activate_dev(pdev); 158 if (err < 0) { 159 snd_printk(KERN_ERR PFX "AUDIO pnp configure failure\n"); 160 kfree(cfg); 161 return err; 162 } 163 port[dev] = pnp_port_start(pdev, 0); 164 fm_port[dev] = pnp_port_start(pdev, 1); 165 wss_port[dev] = pnp_port_start(pdev, 2); 166 dma1[dev] = pnp_dma(pdev, 0); 167 dma2[dev] = pnp_dma(pdev, 1); 168 irq[dev] = pnp_irq(pdev, 0); 169 170 pdev = acard->devmpu; 171 if (pdev != NULL) { 172 pnp_init_resource_table(cfg); 173 if (mpu_port[dev] != SNDRV_AUTO_PORT) 174 pnp_resource_change(&cfg->port_resource[0], mpu_port[dev], 2); 175 if (mpu_irq[dev] != SNDRV_AUTO_IRQ) 176 pnp_resource_change(&cfg->irq_resource[0], mpu_irq[dev], 1); 177 if ((pnp_manual_config_dev(pdev, cfg, 0)) < 0) 178 snd_printk(KERN_ERR PFX "MPU401 the requested resources are invalid, using auto config\n"); 179 err = pnp_activate_dev(pdev); 180 if (err < 0) 181 goto __mpu_error; 182 mpu_port[dev] = pnp_port_start(pdev, 0); 183 mpu_irq[dev] = pnp_irq(pdev, 0); 184 } else { 185 __mpu_error: 186 if (pdev) { 187 pnp_release_card_device(pdev); 188 snd_printk(KERN_ERR PFX "MPU401 pnp configure failure, skipping\n"); 189 } 190 acard->devmpu = NULL; 191 mpu_port[dev] = -1; 192 } 193 194 kfree (cfg); 195 return 0; 196 } 197 198 /* same of snd_sbdsp_command by Jaroslav Kysela */ 199 static int __devinit snd_card_azt2320_command(unsigned long port, unsigned char val) 200 { 201 int i; 202 unsigned long limit; 203 204 limit = jiffies + HZ / 10; 205 for (i = 50000; i && time_after(limit, jiffies); i--) 206 if (!(inb(port + 0x0c) & 0x80)) { 207 outb(val, port + 0x0c); 208 return 0; 209 } 210 return -EBUSY; 211 } 212 213 static int __devinit snd_card_azt2320_enable_wss(unsigned long port) 214 { 215 int error; 216 217 if ((error = snd_card_azt2320_command(port, 0x09))) 218 return error; 219 if ((error = snd_card_azt2320_command(port, 0x00))) 220 return error; 221 222 mdelay(5); 223 return 0; 224 } 225 226 static int __devinit snd_card_azt2320_probe(int dev, 227 struct pnp_card_link *pcard, 228 const struct pnp_card_device_id *pid) 229 { 230 int error; 231 struct snd_card *card; 232 struct snd_card_azt2320 *acard; 233 struct snd_cs4231 *chip; 234 struct snd_opl3 *opl3; 235 236 if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE, 237 sizeof(struct snd_card_azt2320))) == NULL) 238 return -ENOMEM; 239 acard = (struct snd_card_azt2320 *)card->private_data; 240 241 if ((error = snd_card_azt2320_pnp(dev, acard, pcard, pid))) { 242 snd_card_free(card); 243 return error; 244 } 245 snd_card_set_dev(card, &pcard->card->dev); 246 247 if ((error = snd_card_azt2320_enable_wss(port[dev]))) { 248 snd_card_free(card); 249 return error; 250 } 251 252 if ((error = snd_cs4231_create(card, wss_port[dev], -1, 253 irq[dev], 254 dma1[dev], 255 dma2[dev], 256 CS4231_HW_DETECT, 0, &chip)) < 0) { 257 snd_card_free(card); 258 return error; 259 } 260 261 strcpy(card->driver, "AZT2320"); 262 strcpy(card->shortname, "Aztech AZT2320"); 263 sprintf(card->longname, "%s, WSS at 0x%lx, irq %i, dma %i&%i", 264 card->shortname, chip->port, irq[dev], dma1[dev], dma2[dev]); 265 266 if ((error = snd_cs4231_pcm(chip, 0, NULL)) < 0) { 267 snd_card_free(card); 268 return error; 269 } 270 if ((error = snd_cs4231_mixer(chip)) < 0) { 271 snd_card_free(card); 272 return error; 273 } 274 if ((error = snd_cs4231_timer(chip, 0, NULL)) < 0) { 275 snd_card_free(card); 276 return error; 277 } 278 279 if (mpu_port[dev] > 0 && mpu_port[dev] != SNDRV_AUTO_PORT) { 280 if (snd_mpu401_uart_new(card, 0, MPU401_HW_AZT2320, 281 mpu_port[dev], 0, 282 mpu_irq[dev], IRQF_DISABLED, 283 NULL) < 0) 284 snd_printk(KERN_ERR PFX "no MPU-401 device at 0x%lx\n", mpu_port[dev]); 285 } 286 287 if (fm_port[dev] > 0 && fm_port[dev] != SNDRV_AUTO_PORT) { 288 if (snd_opl3_create(card, 289 fm_port[dev], fm_port[dev] + 2, 290 OPL3_HW_AUTO, 0, &opl3) < 0) { 291 snd_printk(KERN_ERR PFX "no OPL device at 0x%lx-0x%lx\n", 292 fm_port[dev], fm_port[dev] + 2); 293 } else { 294 if ((error = snd_opl3_timer_new(opl3, 1, 2)) < 0) { 295 snd_card_free(card); 296 return error; 297 } 298 if ((error = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) { 299 snd_card_free(card); 300 return error; 301 } 302 } 303 } 304 305 if ((error = snd_card_register(card)) < 0) { 306 snd_card_free(card); 307 return error; 308 } 309 pnp_set_card_drvdata(pcard, card); 310 return 0; 311 } 312 313 static unsigned int __devinitdata azt2320_devices; 314 315 static int __devinit snd_azt2320_pnp_detect(struct pnp_card_link *card, 316 const struct pnp_card_device_id *id) 317 { 318 static int dev; 319 int res; 320 321 for ( ; dev < SNDRV_CARDS; dev++) { 322 if (!enable[dev]) 323 continue; 324 res = snd_card_azt2320_probe(dev, card, id); 325 if (res < 0) 326 return res; 327 dev++; 328 azt2320_devices++; 329 return 0; 330 } 331 return -ENODEV; 332 } 333 334 static void __devexit snd_azt2320_pnp_remove(struct pnp_card_link * pcard) 335 { 336 snd_card_free(pnp_get_card_drvdata(pcard)); 337 pnp_set_card_drvdata(pcard, NULL); 338 } 339 340 #ifdef CONFIG_PM 341 static int snd_azt2320_pnp_suspend(struct pnp_card_link *pcard, pm_message_t state) 342 { 343 struct snd_card *card = pnp_get_card_drvdata(pcard); 344 struct snd_card_azt2320 *acard = card->private_data; 345 struct snd_cs4231 *chip = acard->chip; 346 347 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 348 chip->suspend(chip); 349 return 0; 350 } 351 352 static int snd_azt2320_pnp_resume(struct pnp_card_link *pcard) 353 { 354 struct snd_card *card = pnp_get_card_drvdata(pcard); 355 struct snd_card_azt2320 *acard = card->private_data; 356 struct snd_cs4231 *chip = acard->chip; 357 358 chip->resume(chip); 359 snd_power_change_state(card, SNDRV_CTL_POWER_D0); 360 return 0; 361 } 362 #endif 363 364 static struct pnp_card_driver azt2320_pnpc_driver = { 365 .flags = PNP_DRIVER_RES_DISABLE, 366 .name = "azt2320", 367 .id_table = snd_azt2320_pnpids, 368 .probe = snd_azt2320_pnp_detect, 369 .remove = __devexit_p(snd_azt2320_pnp_remove), 370 #ifdef CONFIG_PM 371 .suspend = snd_azt2320_pnp_suspend, 372 .resume = snd_azt2320_pnp_resume, 373 #endif 374 }; 375 376 static int __init alsa_card_azt2320_init(void) 377 { 378 int err; 379 380 err = pnp_register_card_driver(&azt2320_pnpc_driver); 381 if (err) 382 return err; 383 384 if (!azt2320_devices) { 385 pnp_unregister_card_driver(&azt2320_pnpc_driver); 386 #ifdef MODULE 387 snd_printk(KERN_ERR "no AZT2320 based soundcards found\n"); 388 #endif 389 return -ENODEV; 390 } 391 return 0; 392 } 393 394 static void __exit alsa_card_azt2320_exit(void) 395 { 396 pnp_unregister_card_driver(&azt2320_pnpc_driver); 397 } 398 399 module_init(alsa_card_azt2320_init) 400 module_exit(alsa_card_azt2320_exit) 401