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-XG 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 53 module_param_array(index, int, NULL, 0444); 54 MODULE_PARM_DESC(index, "Index value for the Yamaha DS-XG PCI soundcard."); 55 module_param_array(id, charp, NULL, 0444); 56 MODULE_PARM_DESC(id, "ID string for the Yamaha DS-XG PCI soundcard."); 57 module_param_array(enable, bool, NULL, 0444); 58 MODULE_PARM_DESC(enable, "Enable Yamaha DS-XG soundcard."); 59 module_param_array(mpu_port, long, NULL, 0444); 60 MODULE_PARM_DESC(mpu_port, "MPU-401 Port."); 61 module_param_array(fm_port, long, NULL, 0444); 62 MODULE_PARM_DESC(fm_port, "FM OPL-3 Port."); 63 #ifdef SUPPORT_JOYSTICK 64 module_param_array(joystick_port, long, NULL, 0444); 65 MODULE_PARM_DESC(joystick_port, "Joystick port address"); 66 #endif 67 module_param_array(rear_switch, bool, NULL, 0444); 68 MODULE_PARM_DESC(rear_switch, "Enable shared rear/line-in switch"); 69 70 static struct pci_device_id snd_ymfpci_ids[] = { 71 { 0x1073, 0x0004, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* YMF724 */ 72 { 0x1073, 0x000d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* YMF724F */ 73 { 0x1073, 0x000a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* YMF740 */ 74 { 0x1073, 0x000c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* YMF740C */ 75 { 0x1073, 0x0010, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* YMF744 */ 76 { 0x1073, 0x0012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* YMF754 */ 77 { 0, } 78 }; 79 80 MODULE_DEVICE_TABLE(pci, snd_ymfpci_ids); 81 82 #ifdef SUPPORT_JOYSTICK 83 static int __devinit snd_ymfpci_create_gameport(ymfpci_t *chip, int dev, 84 int legacy_ctrl, int legacy_ctrl2) 85 { 86 struct gameport *gp; 87 struct resource *r = NULL; 88 int io_port = joystick_port[dev]; 89 90 if (!io_port) 91 return -ENODEV; 92 93 if (chip->pci->device >= 0x0010) { /* YMF 744/754 */ 94 95 if (io_port == 1) { 96 /* auto-detect */ 97 if (!(io_port = pci_resource_start(chip->pci, 2))) 98 return -ENODEV; 99 } 100 } else { 101 if (io_port == 1) { 102 /* auto-detect */ 103 for (io_port = 0x201; io_port <= 0x205; io_port++) { 104 if (io_port == 0x203) 105 continue; 106 if ((r = request_region(io_port, 1, "YMFPCI gameport")) != NULL) 107 break; 108 } 109 if (!r) { 110 printk(KERN_ERR "ymfpci: no gameport ports available\n"); 111 return -EBUSY; 112 } 113 } 114 switch (io_port) { 115 case 0x201: legacy_ctrl2 |= 0 << 6; break; 116 case 0x202: legacy_ctrl2 |= 1 << 6; break; 117 case 0x204: legacy_ctrl2 |= 2 << 6; break; 118 case 0x205: legacy_ctrl2 |= 3 << 6; break; 119 default: 120 printk(KERN_ERR "ymfpci: invalid joystick port %#x", io_port); 121 return -EINVAL; 122 } 123 } 124 125 if (!r && !(r = request_region(io_port, 1, "YMFPCI gameport"))) { 126 printk(KERN_ERR "ymfpci: joystick port %#x is in use.\n", io_port); 127 return -EBUSY; 128 } 129 130 chip->gameport = gp = gameport_allocate_port(); 131 if (!gp) { 132 printk(KERN_ERR "ymfpci: cannot allocate memory for gameport\n"); 133 release_resource(r); 134 kfree_nocheck(r); 135 return -ENOMEM; 136 } 137 138 139 gameport_set_name(gp, "Yamaha YMF Gameport"); 140 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci)); 141 gameport_set_dev_parent(gp, &chip->pci->dev); 142 gp->io = io_port; 143 gameport_set_port_data(gp, r); 144 145 if (chip->pci->device >= 0x0010) /* YMF 744/754 */ 146 pci_write_config_word(chip->pci, PCIR_DSXG_JOYBASE, io_port); 147 148 pci_write_config_word(chip->pci, PCIR_DSXG_LEGACY, legacy_ctrl | YMFPCI_LEGACY_JPEN); 149 pci_write_config_word(chip->pci, PCIR_DSXG_ELEGACY, legacy_ctrl2); 150 151 gameport_register_port(chip->gameport); 152 153 return 0; 154 } 155 156 void snd_ymfpci_free_gameport(ymfpci_t *chip) 157 { 158 if (chip->gameport) { 159 struct resource *r = gameport_get_port_data(chip->gameport); 160 161 gameport_unregister_port(chip->gameport); 162 chip->gameport = NULL; 163 164 release_resource(r); 165 kfree_nocheck(r); 166 } 167 } 168 #else 169 static inline int snd_ymfpci_create_gameport(ymfpci_t *chip, int dev, int l, int l2) { return -ENOSYS; } 170 void snd_ymfpci_free_gameport(ymfpci_t *chip) { } 171 #endif /* SUPPORT_JOYSTICK */ 172 173 static int __devinit snd_card_ymfpci_probe(struct pci_dev *pci, 174 const struct pci_device_id *pci_id) 175 { 176 static int dev; 177 snd_card_t *card; 178 struct resource *fm_res = NULL; 179 struct resource *mpu_res = NULL; 180 ymfpci_t *chip; 181 opl3_t *opl3; 182 char *str; 183 int err; 184 u16 legacy_ctrl, legacy_ctrl2, old_legacy_ctrl; 185 186 if (dev >= SNDRV_CARDS) 187 return -ENODEV; 188 if (!enable[dev]) { 189 dev++; 190 return -ENOENT; 191 } 192 193 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); 194 if (card == NULL) 195 return -ENOMEM; 196 197 switch (pci_id->device) { 198 case 0x0004: str = "YMF724"; break; 199 case 0x000d: str = "YMF724F"; break; 200 case 0x000a: str = "YMF740"; break; 201 case 0x000c: str = "YMF740C"; break; 202 case 0x0010: str = "YMF744"; break; 203 case 0x0012: str = "YMF754"; break; 204 default: str = "???"; break; 205 } 206 207 legacy_ctrl = 0; 208 legacy_ctrl2 = 0x0800; /* SBEN = 0, SMOD = 01, LAD = 0 */ 209 210 if (pci_id->device >= 0x0010) { /* YMF 744/754 */ 211 if (fm_port[dev] == 1) { 212 /* auto-detect */ 213 fm_port[dev] = pci_resource_start(pci, 1); 214 } 215 if (fm_port[dev] > 0 && 216 (fm_res = request_region(fm_port[dev], 4, "YMFPCI OPL3")) != NULL) { 217 legacy_ctrl |= YMFPCI_LEGACY_FMEN; 218 pci_write_config_word(pci, PCIR_DSXG_FMBASE, fm_port[dev]); 219 } 220 if (mpu_port[dev] == 1) { 221 /* auto-detect */ 222 mpu_port[dev] = pci_resource_start(pci, 1) + 0x20; 223 } 224 if (mpu_port[dev] > 0 && 225 (mpu_res = request_region(mpu_port[dev], 2, "YMFPCI MPU401")) != NULL) { 226 legacy_ctrl |= YMFPCI_LEGACY_MEN; 227 pci_write_config_word(pci, PCIR_DSXG_MPU401BASE, mpu_port[dev]); 228 } 229 } else { 230 switch (fm_port[dev]) { 231 case 0x388: legacy_ctrl2 |= 0; break; 232 case 0x398: legacy_ctrl2 |= 1; break; 233 case 0x3a0: legacy_ctrl2 |= 2; break; 234 case 0x3a8: legacy_ctrl2 |= 3; break; 235 default: fm_port[dev] = 0; break; 236 } 237 if (fm_port[dev] > 0 && 238 (fm_res = request_region(fm_port[dev], 4, "YMFPCI OPL3")) != NULL) { 239 legacy_ctrl |= YMFPCI_LEGACY_FMEN; 240 } else { 241 legacy_ctrl2 &= ~YMFPCI_LEGACY2_FMIO; 242 fm_port[dev] = 0; 243 } 244 switch (mpu_port[dev]) { 245 case 0x330: legacy_ctrl2 |= 0 << 4; break; 246 case 0x300: legacy_ctrl2 |= 1 << 4; break; 247 case 0x332: legacy_ctrl2 |= 2 << 4; break; 248 case 0x334: legacy_ctrl2 |= 3 << 4; break; 249 default: mpu_port[dev] = 0; break; 250 } 251 if (mpu_port[dev] > 0 && 252 (mpu_res = request_region(mpu_port[dev], 2, "YMFPCI MPU401")) != NULL) { 253 legacy_ctrl |= YMFPCI_LEGACY_MEN; 254 } else { 255 legacy_ctrl2 &= ~YMFPCI_LEGACY2_MPUIO; 256 mpu_port[dev] = 0; 257 } 258 } 259 if (mpu_res) { 260 legacy_ctrl |= YMFPCI_LEGACY_MIEN; 261 legacy_ctrl2 |= YMFPCI_LEGACY2_IMOD; 262 } 263 pci_read_config_word(pci, PCIR_DSXG_LEGACY, &old_legacy_ctrl); 264 pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl); 265 pci_write_config_word(pci, PCIR_DSXG_ELEGACY, legacy_ctrl2); 266 if ((err = snd_ymfpci_create(card, pci, 267 old_legacy_ctrl, 268 &chip)) < 0) { 269 snd_card_free(card); 270 if (mpu_res) { 271 release_resource(mpu_res); 272 kfree_nocheck(mpu_res); 273 } 274 if (fm_res) { 275 release_resource(fm_res); 276 kfree_nocheck(fm_res); 277 } 278 return err; 279 } 280 chip->fm_res = fm_res; 281 chip->mpu_res = mpu_res; 282 strcpy(card->driver, str); 283 sprintf(card->shortname, "Yamaha DS-XG (%s)", str); 284 sprintf(card->longname, "%s at 0x%lx, irq %i", 285 card->shortname, 286 chip->reg_area_phys, 287 chip->irq); 288 if ((err = snd_ymfpci_pcm(chip, 0, NULL)) < 0) { 289 snd_card_free(card); 290 return err; 291 } 292 if ((err = snd_ymfpci_pcm_spdif(chip, 1, NULL)) < 0) { 293 snd_card_free(card); 294 return err; 295 } 296 if ((err = snd_ymfpci_pcm_4ch(chip, 2, NULL)) < 0) { 297 snd_card_free(card); 298 return err; 299 } 300 if ((err = snd_ymfpci_pcm2(chip, 3, NULL)) < 0) { 301 snd_card_free(card); 302 return err; 303 } 304 if ((err = snd_ymfpci_mixer(chip, rear_switch[dev])) < 0) { 305 snd_card_free(card); 306 return err; 307 } 308 if ((err = snd_ymfpci_timer(chip, 0)) < 0) { 309 snd_card_free(card); 310 return err; 311 } 312 if (chip->mpu_res) { 313 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_YMFPCI, 314 mpu_port[dev], 1, 315 pci->irq, 0, &chip->rawmidi)) < 0) { 316 printk(KERN_WARNING "ymfpci: cannot initialize MPU401 at 0x%lx, skipping...\n", mpu_port[dev]); 317 legacy_ctrl &= ~YMFPCI_LEGACY_MIEN; /* disable MPU401 irq */ 318 pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl); 319 } 320 } 321 if (chip->fm_res) { 322 if ((err = snd_opl3_create(card, 323 fm_port[dev], 324 fm_port[dev] + 2, 325 OPL3_HW_OPL3, 1, &opl3)) < 0) { 326 printk(KERN_WARNING "ymfpci: cannot initialize FM OPL3 at 0x%lx, skipping...\n", fm_port[dev]); 327 legacy_ctrl &= ~YMFPCI_LEGACY_FMEN; 328 pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl); 329 } else if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) { 330 snd_card_free(card); 331 snd_printk("cannot create opl3 hwdep\n"); 332 return err; 333 } 334 } 335 336 snd_ymfpci_create_gameport(chip, dev, legacy_ctrl, legacy_ctrl2); 337 338 if ((err = snd_card_register(card)) < 0) { 339 snd_card_free(card); 340 return err; 341 } 342 pci_set_drvdata(pci, card); 343 dev++; 344 return 0; 345 } 346 347 static void __devexit snd_card_ymfpci_remove(struct pci_dev *pci) 348 { 349 snd_card_free(pci_get_drvdata(pci)); 350 pci_set_drvdata(pci, NULL); 351 } 352 353 static struct pci_driver driver = { 354 .name = "Yamaha DS-XG PCI", 355 .owner = THIS_MODULE, 356 .id_table = snd_ymfpci_ids, 357 .probe = snd_card_ymfpci_probe, 358 .remove = __devexit_p(snd_card_ymfpci_remove), 359 SND_PCI_PM_CALLBACKS 360 }; 361 362 static int __init alsa_card_ymfpci_init(void) 363 { 364 return pci_register_driver(&driver); 365 } 366 367 static void __exit alsa_card_ymfpci_exit(void) 368 { 369 pci_unregister_driver(&driver); 370 } 371 372 module_init(alsa_card_ymfpci_init) 373 module_exit(alsa_card_ymfpci_exit) 374