1 /* 2 * The driver for the Yamaha's DS1/DS1E cards 3 * Copyright (c) by Jaroslav Kysela <perex@suse.cz> 4 * 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 * 20 */ 21 22 #include <sound/driver.h> 23 #include <linux/init.h> 24 #include <linux/pci.h> 25 #include <linux/time.h> 26 #include <linux/moduleparam.h> 27 #include <sound/core.h> 28 #include <sound/ymfpci.h> 29 #include <sound/mpu401.h> 30 #include <sound/opl3.h> 31 #include <sound/initval.h> 32 33 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); 34 MODULE_DESCRIPTION("Yamaha DS-1 PCI"); 35 MODULE_LICENSE("GPL"); 36 MODULE_SUPPORTED_DEVICE("{{Yamaha,YMF724}," 37 "{Yamaha,YMF724F}," 38 "{Yamaha,YMF740}," 39 "{Yamaha,YMF740C}," 40 "{Yamaha,YMF744}," 41 "{Yamaha,YMF754}}"); 42 43 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 44 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 45 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ 46 static long fm_port[SNDRV_CARDS]; 47 static long mpu_port[SNDRV_CARDS]; 48 #ifdef SUPPORT_JOYSTICK 49 static long joystick_port[SNDRV_CARDS]; 50 #endif 51 static int rear_switch[SNDRV_CARDS]; 52 static int rear_swap[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 1 }; 53 54 module_param_array(index, int, NULL, 0444); 55 MODULE_PARM_DESC(index, "Index value for the Yamaha DS-1 PCI soundcard."); 56 module_param_array(id, charp, NULL, 0444); 57 MODULE_PARM_DESC(id, "ID string for the Yamaha DS-1 PCI soundcard."); 58 module_param_array(enable, bool, NULL, 0444); 59 MODULE_PARM_DESC(enable, "Enable Yamaha DS-1 soundcard."); 60 module_param_array(mpu_port, long, NULL, 0444); 61 MODULE_PARM_DESC(mpu_port, "MPU-401 Port."); 62 module_param_array(fm_port, long, NULL, 0444); 63 MODULE_PARM_DESC(fm_port, "FM OPL-3 Port."); 64 #ifdef SUPPORT_JOYSTICK 65 module_param_array(joystick_port, long, NULL, 0444); 66 MODULE_PARM_DESC(joystick_port, "Joystick port address"); 67 #endif 68 module_param_array(rear_switch, bool, NULL, 0444); 69 MODULE_PARM_DESC(rear_switch, "Enable shared rear/line-in switch"); 70 module_param_array(rear_swap, bool, NULL, 0444); 71 MODULE_PARM_DESC(rear_swap, "Swap rear channels (must be enabled for correct IEC958 (S/PDIF)) output"); 72 73 static struct pci_device_id snd_ymfpci_ids[] __devinitdata = { 74 { 0x1073, 0x0004, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* YMF724 */ 75 { 0x1073, 0x000d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* YMF724F */ 76 { 0x1073, 0x000a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* YMF740 */ 77 { 0x1073, 0x000c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* YMF740C */ 78 { 0x1073, 0x0010, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* YMF744 */ 79 { 0x1073, 0x0012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* YMF754 */ 80 { 0, } 81 }; 82 83 MODULE_DEVICE_TABLE(pci, snd_ymfpci_ids); 84 85 #ifdef SUPPORT_JOYSTICK 86 static int __devinit snd_ymfpci_create_gameport(struct snd_ymfpci *chip, int dev, 87 int legacy_ctrl, int legacy_ctrl2) 88 { 89 struct gameport *gp; 90 struct resource *r = NULL; 91 int io_port = joystick_port[dev]; 92 93 if (!io_port) 94 return -ENODEV; 95 96 if (chip->pci->device >= 0x0010) { /* YMF 744/754 */ 97 98 if (io_port == 1) { 99 /* auto-detect */ 100 if (!(io_port = pci_resource_start(chip->pci, 2))) 101 return -ENODEV; 102 } 103 } else { 104 if (io_port == 1) { 105 /* auto-detect */ 106 for (io_port = 0x201; io_port <= 0x205; io_port++) { 107 if (io_port == 0x203) 108 continue; 109 if ((r = request_region(io_port, 1, "YMFPCI gameport")) != NULL) 110 break; 111 } 112 if (!r) { 113 printk(KERN_ERR "ymfpci: no gameport ports available\n"); 114 return -EBUSY; 115 } 116 } 117 switch (io_port) { 118 case 0x201: legacy_ctrl2 |= 0 << 6; break; 119 case 0x202: legacy_ctrl2 |= 1 << 6; break; 120 case 0x204: legacy_ctrl2 |= 2 << 6; break; 121 case 0x205: legacy_ctrl2 |= 3 << 6; break; 122 default: 123 printk(KERN_ERR "ymfpci: invalid joystick port %#x", io_port); 124 return -EINVAL; 125 } 126 } 127 128 if (!r && !(r = request_region(io_port, 1, "YMFPCI gameport"))) { 129 printk(KERN_ERR "ymfpci: joystick port %#x is in use.\n", io_port); 130 return -EBUSY; 131 } 132 133 chip->gameport = gp = gameport_allocate_port(); 134 if (!gp) { 135 printk(KERN_ERR "ymfpci: cannot allocate memory for gameport\n"); 136 release_and_free_resource(r); 137 return -ENOMEM; 138 } 139 140 141 gameport_set_name(gp, "Yamaha YMF Gameport"); 142 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci)); 143 gameport_set_dev_parent(gp, &chip->pci->dev); 144 gp->io = io_port; 145 gameport_set_port_data(gp, r); 146 147 if (chip->pci->device >= 0x0010) /* YMF 744/754 */ 148 pci_write_config_word(chip->pci, PCIR_DSXG_JOYBASE, io_port); 149 150 pci_write_config_word(chip->pci, PCIR_DSXG_LEGACY, legacy_ctrl | YMFPCI_LEGACY_JPEN); 151 pci_write_config_word(chip->pci, PCIR_DSXG_ELEGACY, legacy_ctrl2); 152 153 gameport_register_port(chip->gameport); 154 155 return 0; 156 } 157 158 void snd_ymfpci_free_gameport(struct snd_ymfpci *chip) 159 { 160 if (chip->gameport) { 161 struct resource *r = gameport_get_port_data(chip->gameport); 162 163 gameport_unregister_port(chip->gameport); 164 chip->gameport = NULL; 165 166 release_and_free_resource(r); 167 } 168 } 169 #else 170 static inline int snd_ymfpci_create_gameport(struct snd_ymfpci *chip, int dev, int l, int l2) { return -ENOSYS; } 171 void snd_ymfpci_free_gameport(struct snd_ymfpci *chip) { } 172 #endif /* SUPPORT_JOYSTICK */ 173 174 static int __devinit snd_card_ymfpci_probe(struct pci_dev *pci, 175 const struct pci_device_id *pci_id) 176 { 177 static int dev; 178 struct snd_card *card; 179 struct resource *fm_res = NULL; 180 struct resource *mpu_res = NULL; 181 struct snd_ymfpci *chip; 182 struct snd_opl3 *opl3; 183 const char *str, *model; 184 int err; 185 u16 legacy_ctrl, legacy_ctrl2, old_legacy_ctrl; 186 187 if (dev >= SNDRV_CARDS) 188 return -ENODEV; 189 if (!enable[dev]) { 190 dev++; 191 return -ENOENT; 192 } 193 194 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); 195 if (card == NULL) 196 return -ENOMEM; 197 198 switch (pci_id->device) { 199 case 0x0004: str = "YMF724"; model = "DS-1"; break; 200 case 0x000d: str = "YMF724F"; model = "DS-1"; break; 201 case 0x000a: str = "YMF740"; model = "DS-1L"; break; 202 case 0x000c: str = "YMF740C"; model = "DS-1L"; break; 203 case 0x0010: str = "YMF744"; model = "DS-1S"; break; 204 case 0x0012: str = "YMF754"; model = "DS-1E"; break; 205 default: model = str = "???"; break; 206 } 207 208 legacy_ctrl = 0; 209 legacy_ctrl2 = 0x0800; /* SBEN = 0, SMOD = 01, LAD = 0 */ 210 211 if (pci_id->device >= 0x0010) { /* YMF 744/754 */ 212 if (fm_port[dev] == 1) { 213 /* auto-detect */ 214 fm_port[dev] = pci_resource_start(pci, 1); 215 } 216 if (fm_port[dev] > 0 && 217 (fm_res = request_region(fm_port[dev], 4, "YMFPCI OPL3")) != NULL) { 218 legacy_ctrl |= YMFPCI_LEGACY_FMEN; 219 pci_write_config_word(pci, PCIR_DSXG_FMBASE, fm_port[dev]); 220 } 221 if (mpu_port[dev] == 1) { 222 /* auto-detect */ 223 mpu_port[dev] = pci_resource_start(pci, 1) + 0x20; 224 } 225 if (mpu_port[dev] > 0 && 226 (mpu_res = request_region(mpu_port[dev], 2, "YMFPCI MPU401")) != NULL) { 227 legacy_ctrl |= YMFPCI_LEGACY_MEN; 228 pci_write_config_word(pci, PCIR_DSXG_MPU401BASE, mpu_port[dev]); 229 } 230 } else { 231 switch (fm_port[dev]) { 232 case 0x388: legacy_ctrl2 |= 0; break; 233 case 0x398: legacy_ctrl2 |= 1; break; 234 case 0x3a0: legacy_ctrl2 |= 2; break; 235 case 0x3a8: legacy_ctrl2 |= 3; break; 236 default: fm_port[dev] = 0; break; 237 } 238 if (fm_port[dev] > 0 && 239 (fm_res = request_region(fm_port[dev], 4, "YMFPCI OPL3")) != NULL) { 240 legacy_ctrl |= YMFPCI_LEGACY_FMEN; 241 } else { 242 legacy_ctrl2 &= ~YMFPCI_LEGACY2_FMIO; 243 fm_port[dev] = 0; 244 } 245 switch (mpu_port[dev]) { 246 case 0x330: legacy_ctrl2 |= 0 << 4; break; 247 case 0x300: legacy_ctrl2 |= 1 << 4; break; 248 case 0x332: legacy_ctrl2 |= 2 << 4; break; 249 case 0x334: legacy_ctrl2 |= 3 << 4; break; 250 default: mpu_port[dev] = 0; break; 251 } 252 if (mpu_port[dev] > 0 && 253 (mpu_res = request_region(mpu_port[dev], 2, "YMFPCI MPU401")) != NULL) { 254 legacy_ctrl |= YMFPCI_LEGACY_MEN; 255 } else { 256 legacy_ctrl2 &= ~YMFPCI_LEGACY2_MPUIO; 257 mpu_port[dev] = 0; 258 } 259 } 260 if (mpu_res) { 261 legacy_ctrl |= YMFPCI_LEGACY_MIEN; 262 legacy_ctrl2 |= YMFPCI_LEGACY2_IMOD; 263 } 264 pci_read_config_word(pci, PCIR_DSXG_LEGACY, &old_legacy_ctrl); 265 pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl); 266 pci_write_config_word(pci, PCIR_DSXG_ELEGACY, legacy_ctrl2); 267 if ((err = snd_ymfpci_create(card, pci, 268 old_legacy_ctrl, 269 &chip)) < 0) { 270 snd_card_free(card); 271 release_and_free_resource(mpu_res); 272 release_and_free_resource(fm_res); 273 return err; 274 } 275 chip->fm_res = fm_res; 276 chip->mpu_res = mpu_res; 277 card->private_data = chip; 278 279 strcpy(card->driver, str); 280 sprintf(card->shortname, "Yamaha %s (%s)", model, str); 281 sprintf(card->longname, "%s at 0x%lx, irq %i", 282 card->shortname, 283 chip->reg_area_phys, 284 chip->irq); 285 if ((err = snd_ymfpci_pcm(chip, 0, NULL)) < 0) { 286 snd_card_free(card); 287 return err; 288 } 289 if ((err = snd_ymfpci_pcm_spdif(chip, 1, NULL)) < 0) { 290 snd_card_free(card); 291 return err; 292 } 293 if ((err = snd_ymfpci_pcm_4ch(chip, 2, NULL)) < 0) { 294 snd_card_free(card); 295 return err; 296 } 297 if ((err = snd_ymfpci_pcm2(chip, 3, NULL)) < 0) { 298 snd_card_free(card); 299 return err; 300 } 301 if ((err = snd_ymfpci_mixer(chip, rear_switch[dev], rear_swap[dev])) < 0) { 302 snd_card_free(card); 303 return err; 304 } 305 if ((err = snd_ymfpci_timer(chip, 0)) < 0) { 306 snd_card_free(card); 307 return err; 308 } 309 if (chip->mpu_res) { 310 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_YMFPCI, 311 mpu_port[dev], 1, 312 pci->irq, 0, &chip->rawmidi)) < 0) { 313 printk(KERN_WARNING "ymfpci: cannot initialize MPU401 at 0x%lx, skipping...\n", mpu_port[dev]); 314 legacy_ctrl &= ~YMFPCI_LEGACY_MIEN; /* disable MPU401 irq */ 315 pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl); 316 } 317 } 318 if (chip->fm_res) { 319 if ((err = snd_opl3_create(card, 320 fm_port[dev], 321 fm_port[dev] + 2, 322 OPL3_HW_OPL3, 1, &opl3)) < 0) { 323 printk(KERN_WARNING "ymfpci: cannot initialize FM OPL3 at 0x%lx, skipping...\n", fm_port[dev]); 324 legacy_ctrl &= ~YMFPCI_LEGACY_FMEN; 325 pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl); 326 } else if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) { 327 snd_card_free(card); 328 snd_printk(KERN_ERR "cannot create opl3 hwdep\n"); 329 return err; 330 } 331 } 332 333 snd_ymfpci_create_gameport(chip, dev, legacy_ctrl, legacy_ctrl2); 334 335 if ((err = snd_card_register(card)) < 0) { 336 snd_card_free(card); 337 return err; 338 } 339 pci_set_drvdata(pci, card); 340 dev++; 341 return 0; 342 } 343 344 static void __devexit snd_card_ymfpci_remove(struct pci_dev *pci) 345 { 346 snd_card_free(pci_get_drvdata(pci)); 347 pci_set_drvdata(pci, NULL); 348 } 349 350 static struct pci_driver driver = { 351 .name = "Yamaha DS-1 PCI", 352 .id_table = snd_ymfpci_ids, 353 .probe = snd_card_ymfpci_probe, 354 .remove = __devexit_p(snd_card_ymfpci_remove), 355 #ifdef CONFIG_PM 356 .suspend = snd_ymfpci_suspend, 357 .resume = snd_ymfpci_resume, 358 #endif 359 }; 360 361 static int __init alsa_card_ymfpci_init(void) 362 { 363 return pci_register_driver(&driver); 364 } 365 366 static void __exit alsa_card_ymfpci_exit(void) 367 { 368 pci_unregister_driver(&driver); 369 } 370 371 module_init(alsa_card_ymfpci_init) 372 module_exit(alsa_card_ymfpci_exit) 373