1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 card-opti92x-ad1848.c - driver for OPTi 82c92x based soundcards. 4 Copyright (C) 1998-2000 by Massimo Piccioni <dafastidio@libero.it> 5 6 Part of this code was developed at the Italian Ministry of Air Defence, 7 Sixth Division (oh, che pace ...), Rome. 8 9 Thanks to Maria Grazia Pollarini, Salvatore Vassallo. 10 11 */ 12 13 14 #include <linux/init.h> 15 #include <linux/err.h> 16 #include <linux/isa.h> 17 #include <linux/delay.h> 18 #include <linux/pnp.h> 19 #include <linux/module.h> 20 #include <linux/io.h> 21 #include <asm/dma.h> 22 #include <sound/core.h> 23 #include <sound/tlv.h> 24 #include <sound/wss.h> 25 #include <sound/mpu401.h> 26 #include <sound/opl3.h> 27 #ifndef OPTi93X 28 #include <sound/opl4.h> 29 #endif 30 #define SNDRV_LEGACY_FIND_FREE_IOPORT 31 #define SNDRV_LEGACY_FIND_FREE_IRQ 32 #define SNDRV_LEGACY_FIND_FREE_DMA 33 #include <sound/initval.h> 34 35 MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>"); 36 MODULE_LICENSE("GPL"); 37 #ifdef OPTi93X 38 MODULE_DESCRIPTION("OPTi93X"); 39 #else /* OPTi93X */ 40 #ifdef CS4231 41 MODULE_DESCRIPTION("OPTi92X - CS4231"); 42 #else /* CS4231 */ 43 MODULE_DESCRIPTION("OPTi92X - AD1848"); 44 #endif /* CS4231 */ 45 #endif /* OPTi93X */ 46 47 static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */ 48 static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */ 49 //static bool enable = SNDRV_DEFAULT_ENABLE1; /* Enable this card */ 50 #ifdef CONFIG_PNP 51 static bool isapnp = true; /* Enable ISA PnP detection */ 52 #endif 53 static long port = SNDRV_DEFAULT_PORT1; /* 0x530,0xe80,0xf40,0x604 */ 54 static long mpu_port = SNDRV_DEFAULT_PORT1; /* 0x300,0x310,0x320,0x330 */ 55 static long fm_port = SNDRV_DEFAULT_PORT1; /* 0x388 */ 56 static int irq = SNDRV_DEFAULT_IRQ1; /* 5,7,9,10,11 */ 57 static int mpu_irq = SNDRV_DEFAULT_IRQ1; /* 5,7,9,10 */ 58 static int dma1 = SNDRV_DEFAULT_DMA1; /* 0,1,3 */ 59 #if defined(CS4231) || defined(OPTi93X) 60 static int dma2 = SNDRV_DEFAULT_DMA1; /* 0,1,3 */ 61 #endif /* CS4231 || OPTi93X */ 62 63 module_param(index, int, 0444); 64 MODULE_PARM_DESC(index, "Index value for opti9xx based soundcard."); 65 module_param(id, charp, 0444); 66 MODULE_PARM_DESC(id, "ID string for opti9xx based soundcard."); 67 //module_param(enable, bool, 0444); 68 //MODULE_PARM_DESC(enable, "Enable opti9xx soundcard."); 69 #ifdef CONFIG_PNP 70 module_param(isapnp, bool, 0444); 71 MODULE_PARM_DESC(isapnp, "Enable ISA PnP detection for specified soundcard."); 72 #endif 73 module_param_hw(port, long, ioport, 0444); 74 MODULE_PARM_DESC(port, "WSS port # for opti9xx driver."); 75 module_param_hw(mpu_port, long, ioport, 0444); 76 MODULE_PARM_DESC(mpu_port, "MPU-401 port # for opti9xx driver."); 77 module_param_hw(fm_port, long, ioport, 0444); 78 MODULE_PARM_DESC(fm_port, "FM port # for opti9xx driver."); 79 module_param_hw(irq, int, irq, 0444); 80 MODULE_PARM_DESC(irq, "WSS irq # for opti9xx driver."); 81 module_param_hw(mpu_irq, int, irq, 0444); 82 MODULE_PARM_DESC(mpu_irq, "MPU-401 irq # for opti9xx driver."); 83 module_param_hw(dma1, int, dma, 0444); 84 MODULE_PARM_DESC(dma1, "1st dma # for opti9xx driver."); 85 #if defined(CS4231) || defined(OPTi93X) 86 module_param_hw(dma2, int, dma, 0444); 87 MODULE_PARM_DESC(dma2, "2nd dma # for opti9xx driver."); 88 #endif /* CS4231 || OPTi93X */ 89 90 #define OPTi9XX_HW_82C928 1 91 #define OPTi9XX_HW_82C929 2 92 #define OPTi9XX_HW_82C924 3 93 #define OPTi9XX_HW_82C925 4 94 #define OPTi9XX_HW_82C930 5 95 #define OPTi9XX_HW_82C931 6 96 #define OPTi9XX_HW_82C933 7 97 #define OPTi9XX_HW_LAST OPTi9XX_HW_82C933 98 99 #define OPTi9XX_MC_REG(n) n 100 101 #ifdef OPTi93X 102 103 #define OPTi93X_STATUS 0x02 104 #define OPTi93X_PORT(chip, r) ((chip)->port + OPTi93X_##r) 105 106 #define OPTi93X_IRQ_PLAYBACK 0x04 107 #define OPTi93X_IRQ_CAPTURE 0x08 108 109 #endif /* OPTi93X */ 110 111 struct snd_opti9xx { 112 unsigned short hardware; 113 unsigned char password; 114 char name[7]; 115 116 unsigned long mc_base; 117 struct resource *res_mc_base; 118 unsigned long mc_base_size; 119 #ifdef OPTi93X 120 unsigned long mc_indir_index; 121 struct resource *res_mc_indir; 122 #endif /* OPTi93X */ 123 struct snd_wss *codec; 124 unsigned long pwd_reg; 125 126 spinlock_t lock; 127 128 long wss_base; 129 int irq; 130 }; 131 132 static int snd_opti9xx_pnp_is_probed; 133 134 #ifdef CONFIG_PNP 135 136 static const struct pnp_card_device_id snd_opti9xx_pnpids[] = { 137 #ifndef OPTi93X 138 /* OPTi 82C924 */ 139 { .id = "OPT0924", 140 .devs = { { "OPT0000" }, { "OPT0002" }, { "OPT0005" } }, 141 .driver_data = 0x0924 }, 142 /* OPTi 82C925 */ 143 { .id = "OPT0925", 144 .devs = { { "OPT9250" }, { "OPT0002" }, { "OPT0005" } }, 145 .driver_data = 0x0925 }, 146 #else 147 /* OPTi 82C931/3 */ 148 { .id = "OPT0931", .devs = { { "OPT9310" }, { "OPT0002" } }, 149 .driver_data = 0x0931 }, 150 #endif /* OPTi93X */ 151 { .id = "" } 152 }; 153 154 MODULE_DEVICE_TABLE(pnp_card, snd_opti9xx_pnpids); 155 156 #endif /* CONFIG_PNP */ 157 158 #define DEV_NAME KBUILD_MODNAME 159 160 static const char * const snd_opti9xx_names[] = { 161 "unknown", 162 "82C928", "82C929", 163 "82C924", "82C925", 164 "82C930", "82C931", "82C933" 165 }; 166 167 static int snd_opti9xx_init(struct snd_opti9xx *chip, 168 unsigned short hardware) 169 { 170 static const int opti9xx_mc_size[] = {7, 7, 10, 10, 2, 2, 2}; 171 172 chip->hardware = hardware; 173 strcpy(chip->name, snd_opti9xx_names[hardware]); 174 175 spin_lock_init(&chip->lock); 176 177 chip->irq = -1; 178 179 #ifndef OPTi93X 180 #ifdef CONFIG_PNP 181 if (isapnp && chip->mc_base) 182 /* PnP resource gives the least 10 bits */ 183 chip->mc_base |= 0xc00; 184 else 185 #endif /* CONFIG_PNP */ 186 { 187 chip->mc_base = 0xf8c; 188 chip->mc_base_size = opti9xx_mc_size[hardware]; 189 } 190 #else 191 chip->mc_base_size = opti9xx_mc_size[hardware]; 192 #endif 193 194 switch (hardware) { 195 #ifndef OPTi93X 196 case OPTi9XX_HW_82C928: 197 case OPTi9XX_HW_82C929: 198 chip->password = (hardware == OPTi9XX_HW_82C928) ? 0xe2 : 0xe3; 199 chip->pwd_reg = 3; 200 break; 201 202 case OPTi9XX_HW_82C924: 203 case OPTi9XX_HW_82C925: 204 chip->password = 0xe5; 205 chip->pwd_reg = 3; 206 break; 207 #else /* OPTi93X */ 208 209 case OPTi9XX_HW_82C930: 210 case OPTi9XX_HW_82C931: 211 case OPTi9XX_HW_82C933: 212 chip->mc_base = (hardware == OPTi9XX_HW_82C930) ? 0xf8f : 0xf8d; 213 if (!chip->mc_indir_index) 214 chip->mc_indir_index = 0xe0e; 215 chip->password = 0xe4; 216 chip->pwd_reg = 0; 217 break; 218 #endif /* OPTi93X */ 219 220 default: 221 snd_printk(KERN_ERR "chip %d not supported\n", hardware); 222 return -ENODEV; 223 } 224 return 0; 225 } 226 227 static unsigned char snd_opti9xx_read(struct snd_opti9xx *chip, 228 unsigned char reg) 229 { 230 unsigned long flags; 231 unsigned char retval = 0xff; 232 233 spin_lock_irqsave(&chip->lock, flags); 234 outb(chip->password, chip->mc_base + chip->pwd_reg); 235 236 switch (chip->hardware) { 237 #ifndef OPTi93X 238 case OPTi9XX_HW_82C924: 239 case OPTi9XX_HW_82C925: 240 if (reg > 7) { 241 outb(reg, chip->mc_base + 8); 242 outb(chip->password, chip->mc_base + chip->pwd_reg); 243 retval = inb(chip->mc_base + 9); 244 break; 245 } 246 fallthrough; 247 248 case OPTi9XX_HW_82C928: 249 case OPTi9XX_HW_82C929: 250 retval = inb(chip->mc_base + reg); 251 break; 252 #else /* OPTi93X */ 253 254 case OPTi9XX_HW_82C930: 255 case OPTi9XX_HW_82C931: 256 case OPTi9XX_HW_82C933: 257 outb(reg, chip->mc_indir_index); 258 outb(chip->password, chip->mc_base + chip->pwd_reg); 259 retval = inb(chip->mc_indir_index + 1); 260 break; 261 #endif /* OPTi93X */ 262 263 default: 264 snd_printk(KERN_ERR "chip %d not supported\n", chip->hardware); 265 } 266 267 spin_unlock_irqrestore(&chip->lock, flags); 268 return retval; 269 } 270 271 static void snd_opti9xx_write(struct snd_opti9xx *chip, unsigned char reg, 272 unsigned char value) 273 { 274 unsigned long flags; 275 276 spin_lock_irqsave(&chip->lock, flags); 277 outb(chip->password, chip->mc_base + chip->pwd_reg); 278 279 switch (chip->hardware) { 280 #ifndef OPTi93X 281 case OPTi9XX_HW_82C924: 282 case OPTi9XX_HW_82C925: 283 if (reg > 7) { 284 outb(reg, chip->mc_base + 8); 285 outb(chip->password, chip->mc_base + chip->pwd_reg); 286 outb(value, chip->mc_base + 9); 287 break; 288 } 289 fallthrough; 290 291 case OPTi9XX_HW_82C928: 292 case OPTi9XX_HW_82C929: 293 outb(value, chip->mc_base + reg); 294 break; 295 #else /* OPTi93X */ 296 297 case OPTi9XX_HW_82C930: 298 case OPTi9XX_HW_82C931: 299 case OPTi9XX_HW_82C933: 300 outb(reg, chip->mc_indir_index); 301 outb(chip->password, chip->mc_base + chip->pwd_reg); 302 outb(value, chip->mc_indir_index + 1); 303 break; 304 #endif /* OPTi93X */ 305 306 default: 307 snd_printk(KERN_ERR "chip %d not supported\n", chip->hardware); 308 } 309 310 spin_unlock_irqrestore(&chip->lock, flags); 311 } 312 313 314 static inline void snd_opti9xx_write_mask(struct snd_opti9xx *chip, 315 unsigned char reg, unsigned char value, unsigned char mask) 316 { 317 unsigned char oldval = snd_opti9xx_read(chip, reg); 318 319 snd_opti9xx_write(chip, reg, (oldval & ~mask) | (value & mask)); 320 } 321 322 static int snd_opti9xx_configure(struct snd_opti9xx *chip, 323 long port, 324 int irq, int dma1, int dma2, 325 long mpu_port, int mpu_irq) 326 { 327 unsigned char wss_base_bits; 328 unsigned char irq_bits; 329 unsigned char dma_bits; 330 unsigned char mpu_port_bits = 0; 331 unsigned char mpu_irq_bits; 332 333 switch (chip->hardware) { 334 #ifndef OPTi93X 335 case OPTi9XX_HW_82C924: 336 /* opti 929 mode (?), OPL3 clock output, audio enable */ 337 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(4), 0xf0, 0xfc); 338 /* enable wave audio */ 339 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(6), 0x02, 0x02); 340 fallthrough; 341 342 case OPTi9XX_HW_82C925: 343 /* enable WSS mode */ 344 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(1), 0x80, 0x80); 345 /* OPL3 FM synthesis */ 346 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2), 0x00, 0x20); 347 /* disable Sound Blaster IRQ and DMA */ 348 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(3), 0xf0, 0xff); 349 #ifdef CS4231 350 /* cs4231/4248 fix enabled */ 351 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(5), 0x02, 0x02); 352 #else 353 /* cs4231/4248 fix disabled */ 354 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(5), 0x00, 0x02); 355 #endif /* CS4231 */ 356 break; 357 358 case OPTi9XX_HW_82C928: 359 case OPTi9XX_HW_82C929: 360 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(1), 0x80, 0x80); 361 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2), 0x00, 0x20); 362 /* 363 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(3), 0xa2, 0xae); 364 */ 365 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(4), 0x00, 0x0c); 366 #ifdef CS4231 367 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(5), 0x02, 0x02); 368 #else 369 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(5), 0x00, 0x02); 370 #endif /* CS4231 */ 371 break; 372 373 #else /* OPTi93X */ 374 case OPTi9XX_HW_82C931: 375 /* disable 3D sound (set GPIO1 as output, low) */ 376 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(20), 0x04, 0x0c); 377 fallthrough; 378 379 case OPTi9XX_HW_82C933: 380 /* 381 * The BTC 1817DW has QS1000 wavetable which is connected 382 * to the serial digital input of the OPTI931. 383 */ 384 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(21), 0x82, 0xff); 385 /* 386 * This bit sets OPTI931 to automaticaly select FM 387 * or digital input signal. 388 */ 389 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(26), 0x01, 0x01); 390 fallthrough; 391 392 case OPTi9XX_HW_82C930: 393 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(6), 0x02, 0x03); 394 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(3), 0x00, 0xff); 395 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(4), 0x10 | 396 (chip->hardware == OPTi9XX_HW_82C930 ? 0x00 : 0x04), 397 0x34); 398 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(5), 0x20, 0xbf); 399 break; 400 #endif /* OPTi93X */ 401 402 default: 403 snd_printk(KERN_ERR "chip %d not supported\n", chip->hardware); 404 return -EINVAL; 405 } 406 407 /* PnP resource says it decodes only 10 bits of address */ 408 switch (port & 0x3ff) { 409 case 0x130: 410 chip->wss_base = 0x530; 411 wss_base_bits = 0x00; 412 break; 413 case 0x204: 414 chip->wss_base = 0x604; 415 wss_base_bits = 0x03; 416 break; 417 case 0x280: 418 chip->wss_base = 0xe80; 419 wss_base_bits = 0x01; 420 break; 421 case 0x340: 422 chip->wss_base = 0xf40; 423 wss_base_bits = 0x02; 424 break; 425 default: 426 snd_printk(KERN_WARNING "WSS port 0x%lx not valid\n", port); 427 goto __skip_base; 428 } 429 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(1), wss_base_bits << 4, 0x30); 430 431 __skip_base: 432 switch (irq) { 433 //#ifdef OPTi93X 434 case 5: 435 irq_bits = 0x05; 436 break; 437 //#endif /* OPTi93X */ 438 case 7: 439 irq_bits = 0x01; 440 break; 441 case 9: 442 irq_bits = 0x02; 443 break; 444 case 10: 445 irq_bits = 0x03; 446 break; 447 case 11: 448 irq_bits = 0x04; 449 break; 450 default: 451 snd_printk(KERN_WARNING "WSS irq # %d not valid\n", irq); 452 goto __skip_resources; 453 } 454 455 switch (dma1) { 456 case 0: 457 dma_bits = 0x01; 458 break; 459 case 1: 460 dma_bits = 0x02; 461 break; 462 case 3: 463 dma_bits = 0x03; 464 break; 465 default: 466 snd_printk(KERN_WARNING "WSS dma1 # %d not valid\n", dma1); 467 goto __skip_resources; 468 } 469 470 #if defined(CS4231) || defined(OPTi93X) 471 if (dma1 == dma2) { 472 snd_printk(KERN_ERR "don't want to share dmas\n"); 473 return -EBUSY; 474 } 475 476 switch (dma2) { 477 case 0: 478 case 1: 479 break; 480 default: 481 snd_printk(KERN_WARNING "WSS dma2 # %d not valid\n", dma2); 482 goto __skip_resources; 483 } 484 dma_bits |= 0x04; 485 #endif /* CS4231 || OPTi93X */ 486 487 #ifndef OPTi93X 488 outb(irq_bits << 3 | dma_bits, chip->wss_base); 489 #else /* OPTi93X */ 490 snd_opti9xx_write(chip, OPTi9XX_MC_REG(3), (irq_bits << 3 | dma_bits)); 491 #endif /* OPTi93X */ 492 493 __skip_resources: 494 if (chip->hardware > OPTi9XX_HW_82C928) { 495 switch (mpu_port) { 496 case 0: 497 case -1: 498 break; 499 case 0x300: 500 mpu_port_bits = 0x03; 501 break; 502 case 0x310: 503 mpu_port_bits = 0x02; 504 break; 505 case 0x320: 506 mpu_port_bits = 0x01; 507 break; 508 case 0x330: 509 mpu_port_bits = 0x00; 510 break; 511 default: 512 snd_printk(KERN_WARNING 513 "MPU-401 port 0x%lx not valid\n", mpu_port); 514 goto __skip_mpu; 515 } 516 517 switch (mpu_irq) { 518 case 5: 519 mpu_irq_bits = 0x02; 520 break; 521 case 7: 522 mpu_irq_bits = 0x03; 523 break; 524 case 9: 525 mpu_irq_bits = 0x00; 526 break; 527 case 10: 528 mpu_irq_bits = 0x01; 529 break; 530 default: 531 snd_printk(KERN_WARNING "MPU-401 irq # %d not valid\n", 532 mpu_irq); 533 goto __skip_mpu; 534 } 535 536 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(6), 537 (mpu_port <= 0) ? 0x00 : 538 0x80 | mpu_port_bits << 5 | mpu_irq_bits << 3, 539 0xf8); 540 } 541 __skip_mpu: 542 543 return 0; 544 } 545 546 #ifdef OPTi93X 547 548 static const DECLARE_TLV_DB_SCALE(db_scale_5bit_3db_step, -9300, 300, 0); 549 static const DECLARE_TLV_DB_SCALE(db_scale_5bit, -4650, 150, 0); 550 static const DECLARE_TLV_DB_SCALE(db_scale_4bit_12db_max, -3300, 300, 0); 551 552 static const struct snd_kcontrol_new snd_opti93x_controls[] = { 553 WSS_DOUBLE("Master Playback Switch", 0, 554 OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 7, 7, 1, 1), 555 WSS_DOUBLE_TLV("Master Playback Volume", 0, 556 OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 1, 1, 31, 1, 557 db_scale_5bit_3db_step), 558 WSS_DOUBLE_TLV("PCM Playback Volume", 0, 559 CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 31, 1, 560 db_scale_5bit), 561 WSS_DOUBLE_TLV("FM Playback Volume", 0, 562 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 1, 1, 15, 1, 563 db_scale_4bit_12db_max), 564 WSS_DOUBLE("Line Playback Switch", 0, 565 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1), 566 WSS_DOUBLE_TLV("Line Playback Volume", 0, 567 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 15, 1, 568 db_scale_4bit_12db_max), 569 WSS_DOUBLE("Mic Playback Switch", 0, 570 OPTi93X_MIC_LEFT_INPUT, OPTi93X_MIC_RIGHT_INPUT, 7, 7, 1, 1), 571 WSS_DOUBLE_TLV("Mic Playback Volume", 0, 572 OPTi93X_MIC_LEFT_INPUT, OPTi93X_MIC_RIGHT_INPUT, 1, 1, 15, 1, 573 db_scale_4bit_12db_max), 574 WSS_DOUBLE_TLV("CD Playback Volume", 0, 575 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 1, 1, 15, 1, 576 db_scale_4bit_12db_max), 577 WSS_DOUBLE("Aux Playback Switch", 0, 578 OPTi931_AUX_LEFT_INPUT, OPTi931_AUX_RIGHT_INPUT, 7, 7, 1, 1), 579 WSS_DOUBLE_TLV("Aux Playback Volume", 0, 580 OPTi931_AUX_LEFT_INPUT, OPTi931_AUX_RIGHT_INPUT, 1, 1, 15, 1, 581 db_scale_4bit_12db_max), 582 }; 583 584 static int snd_opti93x_mixer(struct snd_wss *chip) 585 { 586 struct snd_card *card; 587 unsigned int idx; 588 struct snd_ctl_elem_id id1, id2; 589 int err; 590 591 if (snd_BUG_ON(!chip || !chip->pcm)) 592 return -EINVAL; 593 594 card = chip->card; 595 596 strcpy(card->mixername, chip->pcm->name); 597 598 memset(&id1, 0, sizeof(id1)); 599 memset(&id2, 0, sizeof(id2)); 600 id1.iface = id2.iface = SNDRV_CTL_ELEM_IFACE_MIXER; 601 /* reassign AUX0 switch to CD */ 602 strcpy(id1.name, "Aux Playback Switch"); 603 strcpy(id2.name, "CD Playback Switch"); 604 err = snd_ctl_rename_id(card, &id1, &id2); 605 if (err < 0) { 606 snd_printk(KERN_ERR "Cannot rename opti93x control\n"); 607 return err; 608 } 609 /* reassign AUX1 switch to FM */ 610 strcpy(id1.name, "Aux Playback Switch"); id1.index = 1; 611 strcpy(id2.name, "FM Playback Switch"); 612 err = snd_ctl_rename_id(card, &id1, &id2); 613 if (err < 0) { 614 snd_printk(KERN_ERR "Cannot rename opti93x control\n"); 615 return err; 616 } 617 /* remove AUX1 volume */ 618 strcpy(id1.name, "Aux Playback Volume"); id1.index = 1; 619 snd_ctl_remove_id(card, &id1); 620 621 /* Replace WSS volume controls with OPTi93x volume controls */ 622 id1.index = 0; 623 for (idx = 0; idx < ARRAY_SIZE(snd_opti93x_controls); idx++) { 624 strcpy(id1.name, snd_opti93x_controls[idx].name); 625 snd_ctl_remove_id(card, &id1); 626 627 err = snd_ctl_add(card, 628 snd_ctl_new1(&snd_opti93x_controls[idx], chip)); 629 if (err < 0) 630 return err; 631 } 632 return 0; 633 } 634 635 static irqreturn_t snd_opti93x_interrupt(int irq, void *dev_id) 636 { 637 struct snd_opti9xx *chip = dev_id; 638 struct snd_wss *codec = chip->codec; 639 unsigned char status; 640 641 if (!codec) 642 return IRQ_HANDLED; 643 644 status = snd_opti9xx_read(chip, OPTi9XX_MC_REG(11)); 645 if ((status & OPTi93X_IRQ_PLAYBACK) && codec->playback_substream) 646 snd_pcm_period_elapsed(codec->playback_substream); 647 if ((status & OPTi93X_IRQ_CAPTURE) && codec->capture_substream) { 648 snd_wss_overrange(codec); 649 snd_pcm_period_elapsed(codec->capture_substream); 650 } 651 outb(0x00, OPTi93X_PORT(codec, STATUS)); 652 return IRQ_HANDLED; 653 } 654 655 #endif /* OPTi93X */ 656 657 static int snd_opti9xx_read_check(struct snd_card *card, 658 struct snd_opti9xx *chip) 659 { 660 unsigned char value; 661 #ifdef OPTi93X 662 unsigned long flags; 663 #endif 664 665 chip->res_mc_base = 666 devm_request_region(card->dev, chip->mc_base, 667 chip->mc_base_size, "OPTi9xx MC"); 668 if (!chip->res_mc_base) 669 return -EBUSY; 670 #ifndef OPTi93X 671 value = snd_opti9xx_read(chip, OPTi9XX_MC_REG(1)); 672 if (value != 0xff && value != inb(chip->mc_base + OPTi9XX_MC_REG(1))) 673 if (value == snd_opti9xx_read(chip, OPTi9XX_MC_REG(1))) 674 return 0; 675 #else /* OPTi93X */ 676 chip->res_mc_indir = 677 devm_request_region(card->dev, chip->mc_indir_index, 2, 678 "OPTi93x MC"); 679 if (!chip->res_mc_indir) 680 return -EBUSY; 681 682 spin_lock_irqsave(&chip->lock, flags); 683 outb(chip->password, chip->mc_base + chip->pwd_reg); 684 outb(((chip->mc_indir_index & 0x1f0) >> 4), chip->mc_base); 685 spin_unlock_irqrestore(&chip->lock, flags); 686 687 value = snd_opti9xx_read(chip, OPTi9XX_MC_REG(7)); 688 snd_opti9xx_write(chip, OPTi9XX_MC_REG(7), 0xff - value); 689 if (snd_opti9xx_read(chip, OPTi9XX_MC_REG(7)) == 0xff - value) 690 return 0; 691 692 devm_release_resource(card->dev, chip->res_mc_indir); 693 chip->res_mc_indir = NULL; 694 #endif /* OPTi93X */ 695 devm_release_resource(card->dev, chip->res_mc_base); 696 chip->res_mc_base = NULL; 697 698 return -ENODEV; 699 } 700 701 static int snd_card_opti9xx_detect(struct snd_card *card, 702 struct snd_opti9xx *chip) 703 { 704 int i, err; 705 706 #ifndef OPTi93X 707 for (i = OPTi9XX_HW_82C928; i < OPTi9XX_HW_82C930; i++) { 708 #else 709 for (i = OPTi9XX_HW_82C931; i >= OPTi9XX_HW_82C930; i--) { 710 #endif 711 err = snd_opti9xx_init(chip, i); 712 if (err < 0) 713 return err; 714 715 err = snd_opti9xx_read_check(card, chip); 716 if (err == 0) 717 return 1; 718 #ifdef OPTi93X 719 chip->mc_indir_index = 0; 720 #endif 721 } 722 return -ENODEV; 723 } 724 725 #ifdef CONFIG_PNP 726 static int snd_card_opti9xx_pnp(struct snd_opti9xx *chip, 727 struct pnp_card_link *card, 728 const struct pnp_card_device_id *pid) 729 { 730 struct pnp_dev *pdev; 731 int err; 732 struct pnp_dev *devmpu; 733 #ifndef OPTi93X 734 struct pnp_dev *devmc; 735 #endif 736 737 pdev = pnp_request_card_device(card, pid->devs[0].id, NULL); 738 if (pdev == NULL) 739 return -EBUSY; 740 741 err = pnp_activate_dev(pdev); 742 if (err < 0) { 743 snd_printk(KERN_ERR "AUDIO pnp configure failure: %d\n", err); 744 return err; 745 } 746 747 #ifdef OPTi93X 748 port = pnp_port_start(pdev, 0) - 4; 749 fm_port = pnp_port_start(pdev, 1) + 8; 750 /* adjust mc_indir_index - some cards report it at 0xe?d, 751 other at 0xe?c but it really is always at 0xe?e */ 752 chip->mc_indir_index = (pnp_port_start(pdev, 3) & ~0xf) | 0xe; 753 #else 754 devmc = pnp_request_card_device(card, pid->devs[2].id, NULL); 755 if (devmc == NULL) 756 return -EBUSY; 757 758 err = pnp_activate_dev(devmc); 759 if (err < 0) { 760 snd_printk(KERN_ERR "MC pnp configure failure: %d\n", err); 761 return err; 762 } 763 764 port = pnp_port_start(pdev, 1); 765 fm_port = pnp_port_start(pdev, 2) + 8; 766 /* 767 * The MC(0) is never accessed and card does not 768 * include it in the PnP resource range. OPTI93x include it. 769 */ 770 chip->mc_base = pnp_port_start(devmc, 0) - 1; 771 chip->mc_base_size = pnp_port_len(devmc, 0) + 1; 772 #endif /* OPTi93X */ 773 irq = pnp_irq(pdev, 0); 774 dma1 = pnp_dma(pdev, 0); 775 #if defined(CS4231) || defined(OPTi93X) 776 dma2 = pnp_dma(pdev, 1); 777 #endif /* CS4231 || OPTi93X */ 778 779 devmpu = pnp_request_card_device(card, pid->devs[1].id, NULL); 780 781 if (devmpu && mpu_port > 0) { 782 err = pnp_activate_dev(devmpu); 783 if (err < 0) { 784 snd_printk(KERN_ERR "MPU401 pnp configure failure\n"); 785 mpu_port = -1; 786 } else { 787 mpu_port = pnp_port_start(devmpu, 0); 788 mpu_irq = pnp_irq(devmpu, 0); 789 } 790 } 791 return pid->driver_data; 792 } 793 #endif /* CONFIG_PNP */ 794 795 static int snd_opti9xx_probe(struct snd_card *card) 796 { 797 static const long possible_ports[] = {0x530, 0xe80, 0xf40, 0x604, -1}; 798 int error; 799 int xdma2; 800 struct snd_opti9xx *chip = card->private_data; 801 struct snd_wss *codec; 802 struct snd_rawmidi *rmidi; 803 struct snd_hwdep *synth; 804 805 #if defined(CS4231) || defined(OPTi93X) 806 xdma2 = dma2; 807 #else 808 xdma2 = -1; 809 #endif 810 811 if (port == SNDRV_AUTO_PORT) { 812 port = snd_legacy_find_free_ioport(possible_ports, 4); 813 if (port < 0) { 814 snd_printk(KERN_ERR "unable to find a free WSS port\n"); 815 return -EBUSY; 816 } 817 } 818 error = snd_opti9xx_configure(chip, port, irq, dma1, xdma2, 819 mpu_port, mpu_irq); 820 if (error) 821 return error; 822 823 error = snd_wss_create(card, chip->wss_base + 4, -1, irq, dma1, xdma2, 824 #ifdef OPTi93X 825 WSS_HW_OPTI93X, WSS_HWSHARE_IRQ, 826 #else 827 WSS_HW_DETECT, 0, 828 #endif 829 &codec); 830 if (error < 0) 831 return error; 832 chip->codec = codec; 833 error = snd_wss_pcm(codec, 0); 834 if (error < 0) 835 return error; 836 error = snd_wss_mixer(codec); 837 if (error < 0) 838 return error; 839 #ifdef OPTi93X 840 error = snd_opti93x_mixer(codec); 841 if (error < 0) 842 return error; 843 #endif 844 #ifdef CS4231 845 error = snd_wss_timer(codec, 0); 846 if (error < 0) 847 return error; 848 #endif 849 #ifdef OPTi93X 850 error = devm_request_irq(card->dev, irq, snd_opti93x_interrupt, 851 0, DEV_NAME" - WSS", chip); 852 if (error < 0) { 853 snd_printk(KERN_ERR "opti9xx: can't grab IRQ %d\n", irq); 854 return error; 855 } 856 #endif 857 chip->irq = irq; 858 card->sync_irq = chip->irq; 859 strcpy(card->driver, chip->name); 860 sprintf(card->shortname, "OPTi %s", card->driver); 861 #if defined(CS4231) || defined(OPTi93X) 862 scnprintf(card->longname, sizeof(card->longname), 863 "%s, %s at 0x%lx, irq %d, dma %d&%d", 864 card->shortname, codec->pcm->name, 865 chip->wss_base + 4, irq, dma1, xdma2); 866 #else 867 scnprintf(card->longname, sizeof(card->longname), 868 "%s, %s at 0x%lx, irq %d, dma %d", 869 card->shortname, codec->pcm->name, chip->wss_base + 4, irq, 870 dma1); 871 #endif /* CS4231 || OPTi93X */ 872 873 if (mpu_port <= 0 || mpu_port == SNDRV_AUTO_PORT) 874 rmidi = NULL; 875 else { 876 error = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, 877 mpu_port, 0, mpu_irq, &rmidi); 878 if (error) 879 snd_printk(KERN_WARNING "no MPU-401 device at 0x%lx?\n", 880 mpu_port); 881 } 882 883 if (fm_port > 0 && fm_port != SNDRV_AUTO_PORT) { 884 struct snd_opl3 *opl3 = NULL; 885 #ifndef OPTi93X 886 if (chip->hardware == OPTi9XX_HW_82C928 || 887 chip->hardware == OPTi9XX_HW_82C929 || 888 chip->hardware == OPTi9XX_HW_82C924) { 889 struct snd_opl4 *opl4; 890 /* assume we have an OPL4 */ 891 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2), 892 0x20, 0x20); 893 if (snd_opl4_create(card, fm_port, fm_port - 8, 894 2, &opl3, &opl4) < 0) { 895 /* no luck, use OPL3 instead */ 896 snd_opti9xx_write_mask(chip, OPTi9XX_MC_REG(2), 897 0x00, 0x20); 898 } 899 } 900 #endif /* !OPTi93X */ 901 if (!opl3 && snd_opl3_create(card, fm_port, fm_port + 2, 902 OPL3_HW_AUTO, 0, &opl3) < 0) { 903 snd_printk(KERN_WARNING "no OPL device at 0x%lx-0x%lx\n", 904 fm_port, fm_port + 4 - 1); 905 } 906 if (opl3) { 907 error = snd_opl3_hwdep_new(opl3, 0, 1, &synth); 908 if (error < 0) 909 return error; 910 } 911 } 912 913 return snd_card_register(card); 914 } 915 916 static int snd_opti9xx_card_new(struct device *pdev, struct snd_card **cardp) 917 { 918 struct snd_card *card; 919 int err; 920 921 err = snd_devm_card_new(pdev, index, id, THIS_MODULE, 922 sizeof(struct snd_opti9xx), &card); 923 if (err < 0) 924 return err; 925 *cardp = card; 926 return 0; 927 } 928 929 static int snd_opti9xx_isa_match(struct device *devptr, 930 unsigned int dev) 931 { 932 #ifdef CONFIG_PNP 933 if (snd_opti9xx_pnp_is_probed) 934 return 0; 935 if (isapnp) 936 return 0; 937 #endif 938 return 1; 939 } 940 941 static int snd_opti9xx_isa_probe(struct device *devptr, 942 unsigned int dev) 943 { 944 struct snd_card *card; 945 int error; 946 static const long possible_mpu_ports[] = {0x300, 0x310, 0x320, 0x330, -1}; 947 #ifdef OPTi93X 948 static const int possible_irqs[] = {5, 9, 10, 11, 7, -1}; 949 #else 950 static const int possible_irqs[] = {9, 10, 11, 7, -1}; 951 #endif /* OPTi93X */ 952 static const int possible_mpu_irqs[] = {5, 9, 10, 7, -1}; 953 static const int possible_dma1s[] = {3, 1, 0, -1}; 954 #if defined(CS4231) || defined(OPTi93X) 955 static const int possible_dma2s[][2] = {{1,-1}, {0,-1}, {-1,-1}, {0,-1}}; 956 #endif /* CS4231 || OPTi93X */ 957 958 if (mpu_port == SNDRV_AUTO_PORT) { 959 mpu_port = snd_legacy_find_free_ioport(possible_mpu_ports, 2); 960 if (mpu_port < 0) { 961 snd_printk(KERN_ERR "unable to find a free MPU401 port\n"); 962 return -EBUSY; 963 } 964 } 965 if (irq == SNDRV_AUTO_IRQ) { 966 irq = snd_legacy_find_free_irq(possible_irqs); 967 if (irq < 0) { 968 snd_printk(KERN_ERR "unable to find a free IRQ\n"); 969 return -EBUSY; 970 } 971 } 972 if (mpu_irq == SNDRV_AUTO_IRQ) { 973 mpu_irq = snd_legacy_find_free_irq(possible_mpu_irqs); 974 if (mpu_irq < 0) { 975 snd_printk(KERN_ERR "unable to find a free MPU401 IRQ\n"); 976 return -EBUSY; 977 } 978 } 979 if (dma1 == SNDRV_AUTO_DMA) { 980 dma1 = snd_legacy_find_free_dma(possible_dma1s); 981 if (dma1 < 0) { 982 snd_printk(KERN_ERR "unable to find a free DMA1\n"); 983 return -EBUSY; 984 } 985 } 986 #if defined(CS4231) || defined(OPTi93X) 987 if (dma2 == SNDRV_AUTO_DMA) { 988 dma2 = snd_legacy_find_free_dma(possible_dma2s[dma1 % 4]); 989 if (dma2 < 0) { 990 snd_printk(KERN_ERR "unable to find a free DMA2\n"); 991 return -EBUSY; 992 } 993 } 994 #endif 995 996 error = snd_opti9xx_card_new(devptr, &card); 997 if (error < 0) 998 return error; 999 1000 error = snd_card_opti9xx_detect(card, card->private_data); 1001 if (error < 0) 1002 return error; 1003 error = snd_opti9xx_probe(card); 1004 if (error < 0) 1005 return error; 1006 dev_set_drvdata(devptr, card); 1007 return 0; 1008 } 1009 1010 #ifdef CONFIG_PM 1011 static int snd_opti9xx_suspend(struct snd_card *card) 1012 { 1013 struct snd_opti9xx *chip = card->private_data; 1014 1015 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 1016 chip->codec->suspend(chip->codec); 1017 return 0; 1018 } 1019 1020 static int snd_opti9xx_resume(struct snd_card *card) 1021 { 1022 struct snd_opti9xx *chip = card->private_data; 1023 int error, xdma2; 1024 #if defined(CS4231) || defined(OPTi93X) 1025 xdma2 = dma2; 1026 #else 1027 xdma2 = -1; 1028 #endif 1029 1030 error = snd_opti9xx_configure(chip, port, irq, dma1, xdma2, 1031 mpu_port, mpu_irq); 1032 if (error) 1033 return error; 1034 chip->codec->resume(chip->codec); 1035 snd_power_change_state(card, SNDRV_CTL_POWER_D0); 1036 return 0; 1037 } 1038 1039 static int snd_opti9xx_isa_suspend(struct device *dev, unsigned int n, 1040 pm_message_t state) 1041 { 1042 return snd_opti9xx_suspend(dev_get_drvdata(dev)); 1043 } 1044 1045 static int snd_opti9xx_isa_resume(struct device *dev, unsigned int n) 1046 { 1047 return snd_opti9xx_resume(dev_get_drvdata(dev)); 1048 } 1049 #endif 1050 1051 static struct isa_driver snd_opti9xx_driver = { 1052 .match = snd_opti9xx_isa_match, 1053 .probe = snd_opti9xx_isa_probe, 1054 #ifdef CONFIG_PM 1055 .suspend = snd_opti9xx_isa_suspend, 1056 .resume = snd_opti9xx_isa_resume, 1057 #endif 1058 .driver = { 1059 .name = DEV_NAME 1060 }, 1061 }; 1062 1063 #ifdef CONFIG_PNP 1064 static int snd_opti9xx_pnp_probe(struct pnp_card_link *pcard, 1065 const struct pnp_card_device_id *pid) 1066 { 1067 struct snd_card *card; 1068 int error, hw; 1069 struct snd_opti9xx *chip; 1070 1071 if (snd_opti9xx_pnp_is_probed) 1072 return -EBUSY; 1073 if (! isapnp) 1074 return -ENODEV; 1075 error = snd_opti9xx_card_new(&pcard->card->dev, &card); 1076 if (error < 0) 1077 return error; 1078 chip = card->private_data; 1079 1080 hw = snd_card_opti9xx_pnp(chip, pcard, pid); 1081 switch (hw) { 1082 case 0x0924: 1083 hw = OPTi9XX_HW_82C924; 1084 break; 1085 case 0x0925: 1086 hw = OPTi9XX_HW_82C925; 1087 break; 1088 case 0x0931: 1089 hw = OPTi9XX_HW_82C931; 1090 break; 1091 default: 1092 return -ENODEV; 1093 } 1094 1095 error = snd_opti9xx_init(chip, hw); 1096 if (error) 1097 return error; 1098 error = snd_opti9xx_read_check(card, chip); 1099 if (error) { 1100 snd_printk(KERN_ERR "OPTI chip not found\n"); 1101 return error; 1102 } 1103 error = snd_opti9xx_probe(card); 1104 if (error < 0) 1105 return error; 1106 pnp_set_card_drvdata(pcard, card); 1107 snd_opti9xx_pnp_is_probed = 1; 1108 return 0; 1109 } 1110 1111 static void snd_opti9xx_pnp_remove(struct pnp_card_link *pcard) 1112 { 1113 snd_opti9xx_pnp_is_probed = 0; 1114 } 1115 1116 #ifdef CONFIG_PM 1117 static int snd_opti9xx_pnp_suspend(struct pnp_card_link *pcard, 1118 pm_message_t state) 1119 { 1120 return snd_opti9xx_suspend(pnp_get_card_drvdata(pcard)); 1121 } 1122 1123 static int snd_opti9xx_pnp_resume(struct pnp_card_link *pcard) 1124 { 1125 return snd_opti9xx_resume(pnp_get_card_drvdata(pcard)); 1126 } 1127 #endif 1128 1129 static struct pnp_card_driver opti9xx_pnpc_driver = { 1130 .flags = PNP_DRIVER_RES_DISABLE, 1131 .name = DEV_NAME, 1132 .id_table = snd_opti9xx_pnpids, 1133 .probe = snd_opti9xx_pnp_probe, 1134 .remove = snd_opti9xx_pnp_remove, 1135 #ifdef CONFIG_PM 1136 .suspend = snd_opti9xx_pnp_suspend, 1137 .resume = snd_opti9xx_pnp_resume, 1138 #endif 1139 }; 1140 #endif 1141 1142 #ifdef OPTi93X 1143 #define CHIP_NAME "82C93x" 1144 #else 1145 #define CHIP_NAME "82C92x" 1146 #endif 1147 1148 static int __init alsa_card_opti9xx_init(void) 1149 { 1150 #ifdef CONFIG_PNP 1151 pnp_register_card_driver(&opti9xx_pnpc_driver); 1152 if (snd_opti9xx_pnp_is_probed) 1153 return 0; 1154 pnp_unregister_card_driver(&opti9xx_pnpc_driver); 1155 #endif 1156 return isa_register_driver(&snd_opti9xx_driver, 1); 1157 } 1158 1159 static void __exit alsa_card_opti9xx_exit(void) 1160 { 1161 if (!snd_opti9xx_pnp_is_probed) { 1162 isa_unregister_driver(&snd_opti9xx_driver); 1163 return; 1164 } 1165 #ifdef CONFIG_PNP 1166 pnp_unregister_card_driver(&opti9xx_pnpc_driver); 1167 #endif 1168 } 1169 1170 module_init(alsa_card_opti9xx_init) 1171 module_exit(alsa_card_opti9xx_exit) 1172