1 /* 2 * Driver for ESS Solo-1 (ES1938, ES1946, ES1969) soundcard 3 * Copyright (c) by Jaromir Koutek <miri@punknet.cz>, 4 * Jaroslav Kysela <perex@suse.cz>, 5 * Thomas Sailer <sailer@ife.ee.ethz.ch>, 6 * Abramo Bagnara <abramo@alsa-project.org>, 7 * Markus Gruber <gruber@eikon.tum.de> 8 * 9 * Rewritten from sonicvibes.c source. 10 * 11 * TODO: 12 * Rewrite better spinlocks 13 * 14 * 15 * This program is free software; you can redistribute it and/or modify 16 * it under the terms of the GNU General Public License as published by 17 * the Free Software Foundation; either version 2 of the License, or 18 * (at your option) any later version. 19 * 20 * This program is distributed in the hope that it will be useful, 21 * but WITHOUT ANY WARRANTY; without even the implied warranty of 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 23 * GNU General Public License for more details. 24 * 25 * You should have received a copy of the GNU General Public License 26 * along with this program; if not, write to the Free Software 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 28 * 29 */ 30 31 /* 32 NOTES: 33 - Capture data is written unaligned starting from dma_base + 1 so I need to 34 disable mmap and to add a copy callback. 35 - After several cycle of the following: 36 while : ; do arecord -d1 -f cd -t raw | aplay -f cd ; done 37 a "playback write error (DMA or IRQ trouble?)" may happen. 38 This is due to playback interrupts not generated. 39 I suspect a timing issue. 40 - Sometimes the interrupt handler is invoked wrongly during playback. 41 This generates some harmless "Unexpected hw_pointer: wrong interrupt 42 acknowledge". 43 I've seen that using small period sizes. 44 Reproducible with: 45 mpg123 test.mp3 & 46 hdparm -t -T /dev/hda 47 */ 48 49 50 #include <sound/driver.h> 51 #include <linux/init.h> 52 #include <linux/interrupt.h> 53 #include <linux/pci.h> 54 #include <linux/slab.h> 55 #include <linux/gameport.h> 56 #include <linux/moduleparam.h> 57 #include <linux/delay.h> 58 #include <sound/core.h> 59 #include <sound/control.h> 60 #include <sound/pcm.h> 61 #include <sound/opl3.h> 62 #include <sound/mpu401.h> 63 #include <sound/initval.h> 64 65 #include <asm/io.h> 66 67 MODULE_AUTHOR("Jaromir Koutek <miri@punknet.cz>"); 68 MODULE_DESCRIPTION("ESS Solo-1"); 69 MODULE_LICENSE("GPL"); 70 MODULE_SUPPORTED_DEVICE("{{ESS,ES1938}," 71 "{ESS,ES1946}," 72 "{ESS,ES1969}," 73 "{TerraTec,128i PCI}}"); 74 75 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE)) 76 #define SUPPORT_JOYSTICK 1 77 #endif 78 79 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 80 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 81 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ 82 83 module_param_array(index, int, NULL, 0444); 84 MODULE_PARM_DESC(index, "Index value for ESS Solo-1 soundcard."); 85 module_param_array(id, charp, NULL, 0444); 86 MODULE_PARM_DESC(id, "ID string for ESS Solo-1 soundcard."); 87 module_param_array(enable, bool, NULL, 0444); 88 MODULE_PARM_DESC(enable, "Enable ESS Solo-1 soundcard."); 89 90 #define SLIO_REG(chip, x) ((chip)->io_port + ESSIO_REG_##x) 91 92 #define SLDM_REG(chip, x) ((chip)->ddma_port + ESSDM_REG_##x) 93 94 #define SLSB_REG(chip, x) ((chip)->sb_port + ESSSB_REG_##x) 95 96 #define SL_PCI_LEGACYCONTROL 0x40 97 #define SL_PCI_CONFIG 0x50 98 #define SL_PCI_DDMACONTROL 0x60 99 100 #define ESSIO_REG_AUDIO2DMAADDR 0 101 #define ESSIO_REG_AUDIO2DMACOUNT 4 102 #define ESSIO_REG_AUDIO2MODE 6 103 #define ESSIO_REG_IRQCONTROL 7 104 105 #define ESSDM_REG_DMAADDR 0x00 106 #define ESSDM_REG_DMACOUNT 0x04 107 #define ESSDM_REG_DMACOMMAND 0x08 108 #define ESSDM_REG_DMASTATUS 0x08 109 #define ESSDM_REG_DMAMODE 0x0b 110 #define ESSDM_REG_DMACLEAR 0x0d 111 #define ESSDM_REG_DMAMASK 0x0f 112 113 #define ESSSB_REG_FMLOWADDR 0x00 114 #define ESSSB_REG_FMHIGHADDR 0x02 115 #define ESSSB_REG_MIXERADDR 0x04 116 #define ESSSB_REG_MIXERDATA 0x05 117 118 #define ESSSB_IREG_AUDIO1 0x14 119 #define ESSSB_IREG_MICMIX 0x1a 120 #define ESSSB_IREG_RECSRC 0x1c 121 #define ESSSB_IREG_MASTER 0x32 122 #define ESSSB_IREG_FM 0x36 123 #define ESSSB_IREG_AUXACD 0x38 124 #define ESSSB_IREG_AUXB 0x3a 125 #define ESSSB_IREG_PCSPEAKER 0x3c 126 #define ESSSB_IREG_LINE 0x3e 127 #define ESSSB_IREG_SPATCONTROL 0x50 128 #define ESSSB_IREG_SPATLEVEL 0x52 129 #define ESSSB_IREG_MASTER_LEFT 0x60 130 #define ESSSB_IREG_MASTER_RIGHT 0x62 131 #define ESSSB_IREG_MPU401CONTROL 0x64 132 #define ESSSB_IREG_MICMIXRECORD 0x68 133 #define ESSSB_IREG_AUDIO2RECORD 0x69 134 #define ESSSB_IREG_AUXACDRECORD 0x6a 135 #define ESSSB_IREG_FMRECORD 0x6b 136 #define ESSSB_IREG_AUXBRECORD 0x6c 137 #define ESSSB_IREG_MONO 0x6d 138 #define ESSSB_IREG_LINERECORD 0x6e 139 #define ESSSB_IREG_MONORECORD 0x6f 140 #define ESSSB_IREG_AUDIO2SAMPLE 0x70 141 #define ESSSB_IREG_AUDIO2MODE 0x71 142 #define ESSSB_IREG_AUDIO2FILTER 0x72 143 #define ESSSB_IREG_AUDIO2TCOUNTL 0x74 144 #define ESSSB_IREG_AUDIO2TCOUNTH 0x76 145 #define ESSSB_IREG_AUDIO2CONTROL1 0x78 146 #define ESSSB_IREG_AUDIO2CONTROL2 0x7a 147 #define ESSSB_IREG_AUDIO2 0x7c 148 149 #define ESSSB_REG_RESET 0x06 150 151 #define ESSSB_REG_READDATA 0x0a 152 #define ESSSB_REG_WRITEDATA 0x0c 153 #define ESSSB_REG_READSTATUS 0x0c 154 155 #define ESSSB_REG_STATUS 0x0e 156 157 #define ESS_CMD_EXTSAMPLERATE 0xa1 158 #define ESS_CMD_FILTERDIV 0xa2 159 #define ESS_CMD_DMACNTRELOADL 0xa4 160 #define ESS_CMD_DMACNTRELOADH 0xa5 161 #define ESS_CMD_ANALOGCONTROL 0xa8 162 #define ESS_CMD_IRQCONTROL 0xb1 163 #define ESS_CMD_DRQCONTROL 0xb2 164 #define ESS_CMD_RECLEVEL 0xb4 165 #define ESS_CMD_SETFORMAT 0xb6 166 #define ESS_CMD_SETFORMAT2 0xb7 167 #define ESS_CMD_DMACONTROL 0xb8 168 #define ESS_CMD_DMATYPE 0xb9 169 #define ESS_CMD_OFFSETLEFT 0xba 170 #define ESS_CMD_OFFSETRIGHT 0xbb 171 #define ESS_CMD_READREG 0xc0 172 #define ESS_CMD_ENABLEEXT 0xc6 173 #define ESS_CMD_PAUSEDMA 0xd0 174 #define ESS_CMD_ENABLEAUDIO1 0xd1 175 #define ESS_CMD_STOPAUDIO1 0xd3 176 #define ESS_CMD_AUDIO1STATUS 0xd8 177 #define ESS_CMD_CONTDMA 0xd4 178 #define ESS_CMD_TESTIRQ 0xf2 179 180 #define ESS_RECSRC_MIC 0 181 #define ESS_RECSRC_AUXACD 2 182 #define ESS_RECSRC_AUXB 5 183 #define ESS_RECSRC_LINE 6 184 #define ESS_RECSRC_NONE 7 185 186 #define DAC1 0x01 187 #define ADC1 0x02 188 #define DAC2 0x04 189 190 /* 191 192 */ 193 194 #define SAVED_REG_SIZE 32 /* max. number of registers to save */ 195 196 struct es1938 { 197 int irq; 198 199 unsigned long io_port; 200 unsigned long sb_port; 201 unsigned long vc_port; 202 unsigned long mpu_port; 203 unsigned long game_port; 204 unsigned long ddma_port; 205 206 unsigned char irqmask; 207 unsigned char revision; 208 209 struct snd_kcontrol *hw_volume; 210 struct snd_kcontrol *hw_switch; 211 struct snd_kcontrol *master_volume; 212 struct snd_kcontrol *master_switch; 213 214 struct pci_dev *pci; 215 struct snd_card *card; 216 struct snd_pcm *pcm; 217 struct snd_pcm_substream *capture_substream; 218 struct snd_pcm_substream *playback1_substream; 219 struct snd_pcm_substream *playback2_substream; 220 struct snd_rawmidi *rmidi; 221 222 unsigned int dma1_size; 223 unsigned int dma2_size; 224 unsigned int dma1_start; 225 unsigned int dma2_start; 226 unsigned int dma1_shift; 227 unsigned int dma2_shift; 228 unsigned int active; 229 230 spinlock_t reg_lock; 231 spinlock_t mixer_lock; 232 struct snd_info_entry *proc_entry; 233 234 #ifdef SUPPORT_JOYSTICK 235 struct gameport *gameport; 236 #endif 237 #ifdef CONFIG_PM 238 unsigned char saved_regs[SAVED_REG_SIZE]; 239 #endif 240 }; 241 242 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs); 243 244 static struct pci_device_id snd_es1938_ids[] = { 245 { 0x125d, 0x1969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* Solo-1 */ 246 { 0, } 247 }; 248 249 MODULE_DEVICE_TABLE(pci, snd_es1938_ids); 250 251 #define RESET_LOOP_TIMEOUT 0x10000 252 #define WRITE_LOOP_TIMEOUT 0x10000 253 #define GET_LOOP_TIMEOUT 0x01000 254 255 #undef REG_DEBUG 256 /* ----------------------------------------------------------------- 257 * Write to a mixer register 258 * -----------------------------------------------------------------*/ 259 static void snd_es1938_mixer_write(struct es1938 *chip, unsigned char reg, unsigned char val) 260 { 261 unsigned long flags; 262 spin_lock_irqsave(&chip->mixer_lock, flags); 263 outb(reg, SLSB_REG(chip, MIXERADDR)); 264 outb(val, SLSB_REG(chip, MIXERDATA)); 265 spin_unlock_irqrestore(&chip->mixer_lock, flags); 266 #ifdef REG_DEBUG 267 snd_printk(KERN_DEBUG "Mixer reg %02x set to %02x\n", reg, val); 268 #endif 269 } 270 271 /* ----------------------------------------------------------------- 272 * Read from a mixer register 273 * -----------------------------------------------------------------*/ 274 static int snd_es1938_mixer_read(struct es1938 *chip, unsigned char reg) 275 { 276 int data; 277 unsigned long flags; 278 spin_lock_irqsave(&chip->mixer_lock, flags); 279 outb(reg, SLSB_REG(chip, MIXERADDR)); 280 data = inb(SLSB_REG(chip, MIXERDATA)); 281 spin_unlock_irqrestore(&chip->mixer_lock, flags); 282 #ifdef REG_DEBUG 283 snd_printk(KERN_DEBUG "Mixer reg %02x now is %02x\n", reg, data); 284 #endif 285 return data; 286 } 287 288 /* ----------------------------------------------------------------- 289 * Write to some bits of a mixer register (return old value) 290 * -----------------------------------------------------------------*/ 291 static int snd_es1938_mixer_bits(struct es1938 *chip, unsigned char reg, 292 unsigned char mask, unsigned char val) 293 { 294 unsigned long flags; 295 unsigned char old, new, oval; 296 spin_lock_irqsave(&chip->mixer_lock, flags); 297 outb(reg, SLSB_REG(chip, MIXERADDR)); 298 old = inb(SLSB_REG(chip, MIXERDATA)); 299 oval = old & mask; 300 if (val != oval) { 301 new = (old & ~mask) | (val & mask); 302 outb(new, SLSB_REG(chip, MIXERDATA)); 303 #ifdef REG_DEBUG 304 snd_printk(KERN_DEBUG "Mixer reg %02x was %02x, set to %02x\n", 305 reg, old, new); 306 #endif 307 } 308 spin_unlock_irqrestore(&chip->mixer_lock, flags); 309 return oval; 310 } 311 312 /* ----------------------------------------------------------------- 313 * Write command to Controller Registers 314 * -----------------------------------------------------------------*/ 315 static void snd_es1938_write_cmd(struct es1938 *chip, unsigned char cmd) 316 { 317 int i; 318 unsigned char v; 319 for (i = 0; i < WRITE_LOOP_TIMEOUT; i++) { 320 if (!(v = inb(SLSB_REG(chip, READSTATUS)) & 0x80)) { 321 outb(cmd, SLSB_REG(chip, WRITEDATA)); 322 return; 323 } 324 } 325 printk(KERN_ERR "snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v); 326 } 327 328 /* ----------------------------------------------------------------- 329 * Read the Read Data Buffer 330 * -----------------------------------------------------------------*/ 331 static int snd_es1938_get_byte(struct es1938 *chip) 332 { 333 int i; 334 unsigned char v; 335 for (i = GET_LOOP_TIMEOUT; i; i--) 336 if ((v = inb(SLSB_REG(chip, STATUS))) & 0x80) 337 return inb(SLSB_REG(chip, READDATA)); 338 snd_printk(KERN_ERR "get_byte timeout: status 0x02%x\n", v); 339 return -ENODEV; 340 } 341 342 /* ----------------------------------------------------------------- 343 * Write value cmd register 344 * -----------------------------------------------------------------*/ 345 static void snd_es1938_write(struct es1938 *chip, unsigned char reg, unsigned char val) 346 { 347 unsigned long flags; 348 spin_lock_irqsave(&chip->reg_lock, flags); 349 snd_es1938_write_cmd(chip, reg); 350 snd_es1938_write_cmd(chip, val); 351 spin_unlock_irqrestore(&chip->reg_lock, flags); 352 #ifdef REG_DEBUG 353 snd_printk(KERN_DEBUG "Reg %02x set to %02x\n", reg, val); 354 #endif 355 } 356 357 /* ----------------------------------------------------------------- 358 * Read data from cmd register and return it 359 * -----------------------------------------------------------------*/ 360 static unsigned char snd_es1938_read(struct es1938 *chip, unsigned char reg) 361 { 362 unsigned char val; 363 unsigned long flags; 364 spin_lock_irqsave(&chip->reg_lock, flags); 365 snd_es1938_write_cmd(chip, ESS_CMD_READREG); 366 snd_es1938_write_cmd(chip, reg); 367 val = snd_es1938_get_byte(chip); 368 spin_unlock_irqrestore(&chip->reg_lock, flags); 369 #ifdef REG_DEBUG 370 snd_printk(KERN_DEBUG "Reg %02x now is %02x\n", reg, val); 371 #endif 372 return val; 373 } 374 375 /* ----------------------------------------------------------------- 376 * Write data to cmd register and return old value 377 * -----------------------------------------------------------------*/ 378 static int snd_es1938_bits(struct es1938 *chip, unsigned char reg, unsigned char mask, 379 unsigned char val) 380 { 381 unsigned long flags; 382 unsigned char old, new, oval; 383 spin_lock_irqsave(&chip->reg_lock, flags); 384 snd_es1938_write_cmd(chip, ESS_CMD_READREG); 385 snd_es1938_write_cmd(chip, reg); 386 old = snd_es1938_get_byte(chip); 387 oval = old & mask; 388 if (val != oval) { 389 snd_es1938_write_cmd(chip, reg); 390 new = (old & ~mask) | (val & mask); 391 snd_es1938_write_cmd(chip, new); 392 #ifdef REG_DEBUG 393 snd_printk(KERN_DEBUG "Reg %02x was %02x, set to %02x\n", 394 reg, old, new); 395 #endif 396 } 397 spin_unlock_irqrestore(&chip->reg_lock, flags); 398 return oval; 399 } 400 401 /* -------------------------------------------------------------------- 402 * Reset the chip 403 * --------------------------------------------------------------------*/ 404 static void snd_es1938_reset(struct es1938 *chip) 405 { 406 int i; 407 408 outb(3, SLSB_REG(chip, RESET)); 409 inb(SLSB_REG(chip, RESET)); 410 outb(0, SLSB_REG(chip, RESET)); 411 for (i = 0; i < RESET_LOOP_TIMEOUT; i++) { 412 if (inb(SLSB_REG(chip, STATUS)) & 0x80) { 413 if (inb(SLSB_REG(chip, READDATA)) == 0xaa) 414 goto __next; 415 } 416 } 417 snd_printk(KERN_ERR "ESS Solo-1 reset failed\n"); 418 419 __next: 420 snd_es1938_write_cmd(chip, ESS_CMD_ENABLEEXT); 421 422 /* Demand transfer DMA: 4 bytes per DMA request */ 423 snd_es1938_write(chip, ESS_CMD_DMATYPE, 2); 424 425 /* Change behaviour of register A1 426 4x oversampling 427 2nd channel DAC asynchronous */ 428 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2MODE, 0x32); 429 /* enable/select DMA channel and IRQ channel */ 430 snd_es1938_bits(chip, ESS_CMD_IRQCONTROL, 0xf0, 0x50); 431 snd_es1938_bits(chip, ESS_CMD_DRQCONTROL, 0xf0, 0x50); 432 snd_es1938_write_cmd(chip, ESS_CMD_ENABLEAUDIO1); 433 /* Set spatializer parameters to recommended values */ 434 snd_es1938_mixer_write(chip, 0x54, 0x8f); 435 snd_es1938_mixer_write(chip, 0x56, 0x95); 436 snd_es1938_mixer_write(chip, 0x58, 0x94); 437 snd_es1938_mixer_write(chip, 0x5a, 0x80); 438 } 439 440 /* -------------------------------------------------------------------- 441 * Reset the FIFOs 442 * --------------------------------------------------------------------*/ 443 static void snd_es1938_reset_fifo(struct es1938 *chip) 444 { 445 outb(2, SLSB_REG(chip, RESET)); 446 outb(0, SLSB_REG(chip, RESET)); 447 } 448 449 static struct snd_ratnum clocks[2] = { 450 { 451 .num = 793800, 452 .den_min = 1, 453 .den_max = 128, 454 .den_step = 1, 455 }, 456 { 457 .num = 768000, 458 .den_min = 1, 459 .den_max = 128, 460 .den_step = 1, 461 } 462 }; 463 464 static struct snd_pcm_hw_constraint_ratnums hw_constraints_clocks = { 465 .nrats = 2, 466 .rats = clocks, 467 }; 468 469 470 static void snd_es1938_rate_set(struct es1938 *chip, 471 struct snd_pcm_substream *substream, 472 int mode) 473 { 474 unsigned int bits, div0; 475 struct snd_pcm_runtime *runtime = substream->runtime; 476 if (runtime->rate_num == clocks[0].num) 477 bits = 128 - runtime->rate_den; 478 else 479 bits = 256 - runtime->rate_den; 480 481 /* set filter register */ 482 div0 = 256 - 7160000*20/(8*82*runtime->rate); 483 484 if (mode == DAC2) { 485 snd_es1938_mixer_write(chip, 0x70, bits); 486 snd_es1938_mixer_write(chip, 0x72, div0); 487 } else { 488 snd_es1938_write(chip, 0xA1, bits); 489 snd_es1938_write(chip, 0xA2, div0); 490 } 491 } 492 493 /* -------------------------------------------------------------------- 494 * Configure Solo1 builtin DMA Controller 495 * --------------------------------------------------------------------*/ 496 497 static void snd_es1938_playback1_setdma(struct es1938 *chip) 498 { 499 outb(0x00, SLIO_REG(chip, AUDIO2MODE)); 500 outl(chip->dma2_start, SLIO_REG(chip, AUDIO2DMAADDR)); 501 outw(0, SLIO_REG(chip, AUDIO2DMACOUNT)); 502 outw(chip->dma2_size, SLIO_REG(chip, AUDIO2DMACOUNT)); 503 } 504 505 static void snd_es1938_playback2_setdma(struct es1938 *chip) 506 { 507 /* Enable DMA controller */ 508 outb(0xc4, SLDM_REG(chip, DMACOMMAND)); 509 /* 1. Master reset */ 510 outb(0, SLDM_REG(chip, DMACLEAR)); 511 /* 2. Mask DMA */ 512 outb(1, SLDM_REG(chip, DMAMASK)); 513 outb(0x18, SLDM_REG(chip, DMAMODE)); 514 outl(chip->dma1_start, SLDM_REG(chip, DMAADDR)); 515 outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT)); 516 /* 3. Unmask DMA */ 517 outb(0, SLDM_REG(chip, DMAMASK)); 518 } 519 520 static void snd_es1938_capture_setdma(struct es1938 *chip) 521 { 522 /* Enable DMA controller */ 523 outb(0xc4, SLDM_REG(chip, DMACOMMAND)); 524 /* 1. Master reset */ 525 outb(0, SLDM_REG(chip, DMACLEAR)); 526 /* 2. Mask DMA */ 527 outb(1, SLDM_REG(chip, DMAMASK)); 528 outb(0x14, SLDM_REG(chip, DMAMODE)); 529 outl(chip->dma1_start, SLDM_REG(chip, DMAADDR)); 530 outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT)); 531 /* 3. Unmask DMA */ 532 outb(0, SLDM_REG(chip, DMAMASK)); 533 } 534 535 /* ---------------------------------------------------------------------- 536 * 537 * *** PCM part *** 538 */ 539 540 static int snd_es1938_capture_trigger(struct snd_pcm_substream *substream, 541 int cmd) 542 { 543 struct es1938 *chip = snd_pcm_substream_chip(substream); 544 int val; 545 switch (cmd) { 546 case SNDRV_PCM_TRIGGER_START: 547 case SNDRV_PCM_TRIGGER_RESUME: 548 val = 0x0f; 549 chip->active |= ADC1; 550 break; 551 case SNDRV_PCM_TRIGGER_STOP: 552 case SNDRV_PCM_TRIGGER_SUSPEND: 553 val = 0x00; 554 chip->active &= ~ADC1; 555 break; 556 default: 557 return -EINVAL; 558 } 559 snd_es1938_write(chip, ESS_CMD_DMACONTROL, val); 560 return 0; 561 } 562 563 static int snd_es1938_playback1_trigger(struct snd_pcm_substream *substream, 564 int cmd) 565 { 566 struct es1938 *chip = snd_pcm_substream_chip(substream); 567 switch (cmd) { 568 case SNDRV_PCM_TRIGGER_START: 569 case SNDRV_PCM_TRIGGER_RESUME: 570 /* According to the documentation this should be: 571 0x13 but that value may randomly swap stereo channels */ 572 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x92); 573 udelay(10); 574 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x93); 575 /* This two stage init gives the FIFO -> DAC connection time to 576 * settle before first data from DMA flows in. This should ensure 577 * no swapping of stereo channels. Report a bug if otherwise :-) */ 578 outb(0x0a, SLIO_REG(chip, AUDIO2MODE)); 579 chip->active |= DAC2; 580 break; 581 case SNDRV_PCM_TRIGGER_STOP: 582 case SNDRV_PCM_TRIGGER_SUSPEND: 583 outb(0, SLIO_REG(chip, AUDIO2MODE)); 584 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0); 585 chip->active &= ~DAC2; 586 break; 587 default: 588 return -EINVAL; 589 } 590 return 0; 591 } 592 593 static int snd_es1938_playback2_trigger(struct snd_pcm_substream *substream, 594 int cmd) 595 { 596 struct es1938 *chip = snd_pcm_substream_chip(substream); 597 int val; 598 switch (cmd) { 599 case SNDRV_PCM_TRIGGER_START: 600 case SNDRV_PCM_TRIGGER_RESUME: 601 val = 5; 602 chip->active |= DAC1; 603 break; 604 case SNDRV_PCM_TRIGGER_STOP: 605 case SNDRV_PCM_TRIGGER_SUSPEND: 606 val = 0; 607 chip->active &= ~DAC1; 608 break; 609 default: 610 return -EINVAL; 611 } 612 snd_es1938_write(chip, ESS_CMD_DMACONTROL, val); 613 return 0; 614 } 615 616 static int snd_es1938_playback_trigger(struct snd_pcm_substream *substream, 617 int cmd) 618 { 619 switch (substream->number) { 620 case 0: 621 return snd_es1938_playback1_trigger(substream, cmd); 622 case 1: 623 return snd_es1938_playback2_trigger(substream, cmd); 624 } 625 snd_BUG(); 626 return -EINVAL; 627 } 628 629 /* -------------------------------------------------------------------- 630 * First channel for Extended Mode Audio 1 ADC Operation 631 * --------------------------------------------------------------------*/ 632 static int snd_es1938_capture_prepare(struct snd_pcm_substream *substream) 633 { 634 struct es1938 *chip = snd_pcm_substream_chip(substream); 635 struct snd_pcm_runtime *runtime = substream->runtime; 636 int u, is8, mono; 637 unsigned int size = snd_pcm_lib_buffer_bytes(substream); 638 unsigned int count = snd_pcm_lib_period_bytes(substream); 639 640 chip->dma1_size = size; 641 chip->dma1_start = runtime->dma_addr; 642 643 mono = (runtime->channels > 1) ? 0 : 1; 644 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1; 645 u = snd_pcm_format_unsigned(runtime->format); 646 647 chip->dma1_shift = 2 - mono - is8; 648 649 snd_es1938_reset_fifo(chip); 650 651 /* program type */ 652 snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1)); 653 654 /* set clock and counters */ 655 snd_es1938_rate_set(chip, substream, ADC1); 656 657 count = 0x10000 - count; 658 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff); 659 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8); 660 661 /* initialize and configure ADC */ 662 snd_es1938_write(chip, ESS_CMD_SETFORMAT2, u ? 0x51 : 0x71); 663 snd_es1938_write(chip, ESS_CMD_SETFORMAT2, 0x90 | 664 (u ? 0x00 : 0x20) | 665 (is8 ? 0x00 : 0x04) | 666 (mono ? 0x40 : 0x08)); 667 668 // snd_es1938_reset_fifo(chip); 669 670 /* 11. configure system interrupt controller and DMA controller */ 671 snd_es1938_capture_setdma(chip); 672 673 return 0; 674 } 675 676 677 /* ------------------------------------------------------------------------------ 678 * Second Audio channel DAC Operation 679 * ------------------------------------------------------------------------------*/ 680 static int snd_es1938_playback1_prepare(struct snd_pcm_substream *substream) 681 { 682 struct es1938 *chip = snd_pcm_substream_chip(substream); 683 struct snd_pcm_runtime *runtime = substream->runtime; 684 int u, is8, mono; 685 unsigned int size = snd_pcm_lib_buffer_bytes(substream); 686 unsigned int count = snd_pcm_lib_period_bytes(substream); 687 688 chip->dma2_size = size; 689 chip->dma2_start = runtime->dma_addr; 690 691 mono = (runtime->channels > 1) ? 0 : 1; 692 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1; 693 u = snd_pcm_format_unsigned(runtime->format); 694 695 chip->dma2_shift = 2 - mono - is8; 696 697 snd_es1938_reset_fifo(chip); 698 699 /* set clock and counters */ 700 snd_es1938_rate_set(chip, substream, DAC2); 701 702 count >>= 1; 703 count = 0x10000 - count; 704 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTL, count & 0xff); 705 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTH, count >> 8); 706 707 /* initialize and configure Audio 2 DAC */ 708 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) | 709 (mono ? 0 : 2) | (is8 ? 0 : 1)); 710 711 /* program DMA */ 712 snd_es1938_playback1_setdma(chip); 713 714 return 0; 715 } 716 717 static int snd_es1938_playback2_prepare(struct snd_pcm_substream *substream) 718 { 719 struct es1938 *chip = snd_pcm_substream_chip(substream); 720 struct snd_pcm_runtime *runtime = substream->runtime; 721 int u, is8, mono; 722 unsigned int size = snd_pcm_lib_buffer_bytes(substream); 723 unsigned int count = snd_pcm_lib_period_bytes(substream); 724 725 chip->dma1_size = size; 726 chip->dma1_start = runtime->dma_addr; 727 728 mono = (runtime->channels > 1) ? 0 : 1; 729 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1; 730 u = snd_pcm_format_unsigned(runtime->format); 731 732 chip->dma1_shift = 2 - mono - is8; 733 734 count = 0x10000 - count; 735 736 /* reset */ 737 snd_es1938_reset_fifo(chip); 738 739 snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1)); 740 741 /* set clock and counters */ 742 snd_es1938_rate_set(chip, substream, DAC1); 743 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff); 744 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8); 745 746 /* initialized and configure DAC */ 747 snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x80 : 0x00); 748 snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x51 : 0x71); 749 snd_es1938_write(chip, ESS_CMD_SETFORMAT2, 750 0x90 | (mono ? 0x40 : 0x08) | 751 (is8 ? 0x00 : 0x04) | (u ? 0x00 : 0x20)); 752 753 /* program DMA */ 754 snd_es1938_playback2_setdma(chip); 755 756 return 0; 757 } 758 759 static int snd_es1938_playback_prepare(struct snd_pcm_substream *substream) 760 { 761 switch (substream->number) { 762 case 0: 763 return snd_es1938_playback1_prepare(substream); 764 case 1: 765 return snd_es1938_playback2_prepare(substream); 766 } 767 snd_BUG(); 768 return -EINVAL; 769 } 770 771 static snd_pcm_uframes_t snd_es1938_capture_pointer(struct snd_pcm_substream *substream) 772 { 773 struct es1938 *chip = snd_pcm_substream_chip(substream); 774 size_t ptr; 775 size_t old, new; 776 #if 1 777 /* This stuff is *needed*, don't ask why - AB */ 778 old = inw(SLDM_REG(chip, DMACOUNT)); 779 while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old) 780 old = new; 781 ptr = chip->dma1_size - 1 - new; 782 #else 783 ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start; 784 #endif 785 return ptr >> chip->dma1_shift; 786 } 787 788 static snd_pcm_uframes_t snd_es1938_playback1_pointer(struct snd_pcm_substream *substream) 789 { 790 struct es1938 *chip = snd_pcm_substream_chip(substream); 791 size_t ptr; 792 #if 1 793 ptr = chip->dma2_size - inw(SLIO_REG(chip, AUDIO2DMACOUNT)); 794 #else 795 ptr = inl(SLIO_REG(chip, AUDIO2DMAADDR)) - chip->dma2_start; 796 #endif 797 return ptr >> chip->dma2_shift; 798 } 799 800 static snd_pcm_uframes_t snd_es1938_playback2_pointer(struct snd_pcm_substream *substream) 801 { 802 struct es1938 *chip = snd_pcm_substream_chip(substream); 803 size_t ptr; 804 size_t old, new; 805 #if 1 806 /* This stuff is *needed*, don't ask why - AB */ 807 old = inw(SLDM_REG(chip, DMACOUNT)); 808 while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old) 809 old = new; 810 ptr = chip->dma1_size - 1 - new; 811 #else 812 ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start; 813 #endif 814 return ptr >> chip->dma1_shift; 815 } 816 817 static snd_pcm_uframes_t snd_es1938_playback_pointer(struct snd_pcm_substream *substream) 818 { 819 switch (substream->number) { 820 case 0: 821 return snd_es1938_playback1_pointer(substream); 822 case 1: 823 return snd_es1938_playback2_pointer(substream); 824 } 825 snd_BUG(); 826 return -EINVAL; 827 } 828 829 static int snd_es1938_capture_copy(struct snd_pcm_substream *substream, 830 int channel, 831 snd_pcm_uframes_t pos, 832 void __user *dst, 833 snd_pcm_uframes_t count) 834 { 835 struct snd_pcm_runtime *runtime = substream->runtime; 836 struct es1938 *chip = snd_pcm_substream_chip(substream); 837 pos <<= chip->dma1_shift; 838 count <<= chip->dma1_shift; 839 snd_assert(pos + count <= chip->dma1_size, return -EINVAL); 840 if (pos + count < chip->dma1_size) { 841 if (copy_to_user(dst, runtime->dma_area + pos + 1, count)) 842 return -EFAULT; 843 } else { 844 if (copy_to_user(dst, runtime->dma_area + pos + 1, count - 1)) 845 return -EFAULT; 846 if (put_user(runtime->dma_area[0], ((unsigned char __user *)dst) + count - 1)) 847 return -EFAULT; 848 } 849 return 0; 850 } 851 852 /* 853 * buffer management 854 */ 855 static int snd_es1938_pcm_hw_params(struct snd_pcm_substream *substream, 856 struct snd_pcm_hw_params *hw_params) 857 858 { 859 int err; 860 861 if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0) 862 return err; 863 return 0; 864 } 865 866 static int snd_es1938_pcm_hw_free(struct snd_pcm_substream *substream) 867 { 868 return snd_pcm_lib_free_pages(substream); 869 } 870 871 /* ---------------------------------------------------------------------- 872 * Audio1 Capture (ADC) 873 * ----------------------------------------------------------------------*/ 874 static struct snd_pcm_hardware snd_es1938_capture = 875 { 876 .info = (SNDRV_PCM_INFO_INTERLEAVED | 877 SNDRV_PCM_INFO_BLOCK_TRANSFER), 878 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | 879 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE), 880 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 881 .rate_min = 6000, 882 .rate_max = 48000, 883 .channels_min = 1, 884 .channels_max = 2, 885 .buffer_bytes_max = 0x8000, /* DMA controller screws on higher values */ 886 .period_bytes_min = 64, 887 .period_bytes_max = 0x8000, 888 .periods_min = 1, 889 .periods_max = 1024, 890 .fifo_size = 256, 891 }; 892 893 /* ----------------------------------------------------------------------- 894 * Audio2 Playback (DAC) 895 * -----------------------------------------------------------------------*/ 896 static struct snd_pcm_hardware snd_es1938_playback = 897 { 898 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 899 SNDRV_PCM_INFO_BLOCK_TRANSFER | 900 SNDRV_PCM_INFO_MMAP_VALID), 901 .formats = (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | 902 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE), 903 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 904 .rate_min = 6000, 905 .rate_max = 48000, 906 .channels_min = 1, 907 .channels_max = 2, 908 .buffer_bytes_max = 0x8000, /* DMA controller screws on higher values */ 909 .period_bytes_min = 64, 910 .period_bytes_max = 0x8000, 911 .periods_min = 1, 912 .periods_max = 1024, 913 .fifo_size = 256, 914 }; 915 916 static int snd_es1938_capture_open(struct snd_pcm_substream *substream) 917 { 918 struct es1938 *chip = snd_pcm_substream_chip(substream); 919 struct snd_pcm_runtime *runtime = substream->runtime; 920 921 if (chip->playback2_substream) 922 return -EAGAIN; 923 chip->capture_substream = substream; 924 runtime->hw = snd_es1938_capture; 925 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 926 &hw_constraints_clocks); 927 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00); 928 return 0; 929 } 930 931 static int snd_es1938_playback_open(struct snd_pcm_substream *substream) 932 { 933 struct es1938 *chip = snd_pcm_substream_chip(substream); 934 struct snd_pcm_runtime *runtime = substream->runtime; 935 936 switch (substream->number) { 937 case 0: 938 chip->playback1_substream = substream; 939 break; 940 case 1: 941 if (chip->capture_substream) 942 return -EAGAIN; 943 chip->playback2_substream = substream; 944 break; 945 default: 946 snd_BUG(); 947 return -EINVAL; 948 } 949 runtime->hw = snd_es1938_playback; 950 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 951 &hw_constraints_clocks); 952 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00); 953 return 0; 954 } 955 956 static int snd_es1938_capture_close(struct snd_pcm_substream *substream) 957 { 958 struct es1938 *chip = snd_pcm_substream_chip(substream); 959 960 chip->capture_substream = NULL; 961 return 0; 962 } 963 964 static int snd_es1938_playback_close(struct snd_pcm_substream *substream) 965 { 966 struct es1938 *chip = snd_pcm_substream_chip(substream); 967 968 switch (substream->number) { 969 case 0: 970 chip->playback1_substream = NULL; 971 break; 972 case 1: 973 chip->playback2_substream = NULL; 974 break; 975 default: 976 snd_BUG(); 977 return -EINVAL; 978 } 979 return 0; 980 } 981 982 static struct snd_pcm_ops snd_es1938_playback_ops = { 983 .open = snd_es1938_playback_open, 984 .close = snd_es1938_playback_close, 985 .ioctl = snd_pcm_lib_ioctl, 986 .hw_params = snd_es1938_pcm_hw_params, 987 .hw_free = snd_es1938_pcm_hw_free, 988 .prepare = snd_es1938_playback_prepare, 989 .trigger = snd_es1938_playback_trigger, 990 .pointer = snd_es1938_playback_pointer, 991 }; 992 993 static struct snd_pcm_ops snd_es1938_capture_ops = { 994 .open = snd_es1938_capture_open, 995 .close = snd_es1938_capture_close, 996 .ioctl = snd_pcm_lib_ioctl, 997 .hw_params = snd_es1938_pcm_hw_params, 998 .hw_free = snd_es1938_pcm_hw_free, 999 .prepare = snd_es1938_capture_prepare, 1000 .trigger = snd_es1938_capture_trigger, 1001 .pointer = snd_es1938_capture_pointer, 1002 .copy = snd_es1938_capture_copy, 1003 }; 1004 1005 static int __devinit snd_es1938_new_pcm(struct es1938 *chip, int device) 1006 { 1007 struct snd_pcm *pcm; 1008 int err; 1009 1010 if ((err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm)) < 0) 1011 return err; 1012 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1938_playback_ops); 1013 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1938_capture_ops); 1014 1015 pcm->private_data = chip; 1016 pcm->info_flags = 0; 1017 strcpy(pcm->name, "ESS Solo-1"); 1018 1019 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 1020 snd_dma_pci_data(chip->pci), 64*1024, 64*1024); 1021 1022 chip->pcm = pcm; 1023 return 0; 1024 } 1025 1026 /* ------------------------------------------------------------------- 1027 * 1028 * *** Mixer part *** 1029 */ 1030 1031 static int snd_es1938_info_mux(struct snd_kcontrol *kcontrol, 1032 struct snd_ctl_elem_info *uinfo) 1033 { 1034 static char *texts[8] = { 1035 "Mic", "Mic Master", "CD", "AOUT", 1036 "Mic1", "Mix", "Line", "Master" 1037 }; 1038 1039 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1040 uinfo->count = 1; 1041 uinfo->value.enumerated.items = 8; 1042 if (uinfo->value.enumerated.item > 7) 1043 uinfo->value.enumerated.item = 7; 1044 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 1045 return 0; 1046 } 1047 1048 static int snd_es1938_get_mux(struct snd_kcontrol *kcontrol, 1049 struct snd_ctl_elem_value *ucontrol) 1050 { 1051 struct es1938 *chip = snd_kcontrol_chip(kcontrol); 1052 ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07; 1053 return 0; 1054 } 1055 1056 static int snd_es1938_put_mux(struct snd_kcontrol *kcontrol, 1057 struct snd_ctl_elem_value *ucontrol) 1058 { 1059 struct es1938 *chip = snd_kcontrol_chip(kcontrol); 1060 unsigned char val = ucontrol->value.enumerated.item[0]; 1061 1062 if (val > 7) 1063 return -EINVAL; 1064 return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val; 1065 } 1066 1067 static int snd_es1938_info_spatializer_enable(struct snd_kcontrol *kcontrol, 1068 struct snd_ctl_elem_info *uinfo) 1069 { 1070 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 1071 uinfo->count = 1; 1072 uinfo->value.integer.min = 0; 1073 uinfo->value.integer.max = 1; 1074 return 0; 1075 } 1076 1077 static int snd_es1938_get_spatializer_enable(struct snd_kcontrol *kcontrol, 1078 struct snd_ctl_elem_value *ucontrol) 1079 { 1080 struct es1938 *chip = snd_kcontrol_chip(kcontrol); 1081 unsigned char val = snd_es1938_mixer_read(chip, 0x50); 1082 ucontrol->value.integer.value[0] = !!(val & 8); 1083 return 0; 1084 } 1085 1086 static int snd_es1938_put_spatializer_enable(struct snd_kcontrol *kcontrol, 1087 struct snd_ctl_elem_value *ucontrol) 1088 { 1089 struct es1938 *chip = snd_kcontrol_chip(kcontrol); 1090 unsigned char oval, nval; 1091 int change; 1092 nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04; 1093 oval = snd_es1938_mixer_read(chip, 0x50) & 0x0c; 1094 change = nval != oval; 1095 if (change) { 1096 snd_es1938_mixer_write(chip, 0x50, nval & ~0x04); 1097 snd_es1938_mixer_write(chip, 0x50, nval); 1098 } 1099 return change; 1100 } 1101 1102 static int snd_es1938_info_hw_volume(struct snd_kcontrol *kcontrol, 1103 struct snd_ctl_elem_info *uinfo) 1104 { 1105 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1106 uinfo->count = 2; 1107 uinfo->value.integer.min = 0; 1108 uinfo->value.integer.max = 63; 1109 return 0; 1110 } 1111 1112 static int snd_es1938_get_hw_volume(struct snd_kcontrol *kcontrol, 1113 struct snd_ctl_elem_value *ucontrol) 1114 { 1115 struct es1938 *chip = snd_kcontrol_chip(kcontrol); 1116 ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f; 1117 ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f; 1118 return 0; 1119 } 1120 1121 static int snd_es1938_info_hw_switch(struct snd_kcontrol *kcontrol, 1122 struct snd_ctl_elem_info *uinfo) 1123 { 1124 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 1125 uinfo->count = 2; 1126 uinfo->value.integer.min = 0; 1127 uinfo->value.integer.max = 1; 1128 return 0; 1129 } 1130 1131 static int snd_es1938_get_hw_switch(struct snd_kcontrol *kcontrol, 1132 struct snd_ctl_elem_value *ucontrol) 1133 { 1134 struct es1938 *chip = snd_kcontrol_chip(kcontrol); 1135 ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40); 1136 ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40); 1137 return 0; 1138 } 1139 1140 static void snd_es1938_hwv_free(struct snd_kcontrol *kcontrol) 1141 { 1142 struct es1938 *chip = snd_kcontrol_chip(kcontrol); 1143 chip->master_volume = NULL; 1144 chip->master_switch = NULL; 1145 chip->hw_volume = NULL; 1146 chip->hw_switch = NULL; 1147 } 1148 1149 static int snd_es1938_reg_bits(struct es1938 *chip, unsigned char reg, 1150 unsigned char mask, unsigned char val) 1151 { 1152 if (reg < 0xa0) 1153 return snd_es1938_mixer_bits(chip, reg, mask, val); 1154 else 1155 return snd_es1938_bits(chip, reg, mask, val); 1156 } 1157 1158 static int snd_es1938_reg_read(struct es1938 *chip, unsigned char reg) 1159 { 1160 if (reg < 0xa0) 1161 return snd_es1938_mixer_read(chip, reg); 1162 else 1163 return snd_es1938_read(chip, reg); 1164 } 1165 1166 #define ES1938_SINGLE(xname, xindex, reg, shift, mask, invert) \ 1167 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \ 1168 .info = snd_es1938_info_single, \ 1169 .get = snd_es1938_get_single, .put = snd_es1938_put_single, \ 1170 .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } 1171 1172 static int snd_es1938_info_single(struct snd_kcontrol *kcontrol, 1173 struct snd_ctl_elem_info *uinfo) 1174 { 1175 int mask = (kcontrol->private_value >> 16) & 0xff; 1176 1177 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER; 1178 uinfo->count = 1; 1179 uinfo->value.integer.min = 0; 1180 uinfo->value.integer.max = mask; 1181 return 0; 1182 } 1183 1184 static int snd_es1938_get_single(struct snd_kcontrol *kcontrol, 1185 struct snd_ctl_elem_value *ucontrol) 1186 { 1187 struct es1938 *chip = snd_kcontrol_chip(kcontrol); 1188 int reg = kcontrol->private_value & 0xff; 1189 int shift = (kcontrol->private_value >> 8) & 0xff; 1190 int mask = (kcontrol->private_value >> 16) & 0xff; 1191 int invert = (kcontrol->private_value >> 24) & 0xff; 1192 int val; 1193 1194 val = snd_es1938_reg_read(chip, reg); 1195 ucontrol->value.integer.value[0] = (val >> shift) & mask; 1196 if (invert) 1197 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0]; 1198 return 0; 1199 } 1200 1201 static int snd_es1938_put_single(struct snd_kcontrol *kcontrol, 1202 struct snd_ctl_elem_value *ucontrol) 1203 { 1204 struct es1938 *chip = snd_kcontrol_chip(kcontrol); 1205 int reg = kcontrol->private_value & 0xff; 1206 int shift = (kcontrol->private_value >> 8) & 0xff; 1207 int mask = (kcontrol->private_value >> 16) & 0xff; 1208 int invert = (kcontrol->private_value >> 24) & 0xff; 1209 unsigned char val; 1210 1211 val = (ucontrol->value.integer.value[0] & mask); 1212 if (invert) 1213 val = mask - val; 1214 mask <<= shift; 1215 val <<= shift; 1216 return snd_es1938_reg_bits(chip, reg, mask, val) != val; 1217 } 1218 1219 #define ES1938_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \ 1220 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \ 1221 .info = snd_es1938_info_double, \ 1222 .get = snd_es1938_get_double, .put = snd_es1938_put_double, \ 1223 .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) } 1224 1225 static int snd_es1938_info_double(struct snd_kcontrol *kcontrol, 1226 struct snd_ctl_elem_info *uinfo) 1227 { 1228 int mask = (kcontrol->private_value >> 24) & 0xff; 1229 1230 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER; 1231 uinfo->count = 2; 1232 uinfo->value.integer.min = 0; 1233 uinfo->value.integer.max = mask; 1234 return 0; 1235 } 1236 1237 static int snd_es1938_get_double(struct snd_kcontrol *kcontrol, 1238 struct snd_ctl_elem_value *ucontrol) 1239 { 1240 struct es1938 *chip = snd_kcontrol_chip(kcontrol); 1241 int left_reg = kcontrol->private_value & 0xff; 1242 int right_reg = (kcontrol->private_value >> 8) & 0xff; 1243 int shift_left = (kcontrol->private_value >> 16) & 0x07; 1244 int shift_right = (kcontrol->private_value >> 19) & 0x07; 1245 int mask = (kcontrol->private_value >> 24) & 0xff; 1246 int invert = (kcontrol->private_value >> 22) & 1; 1247 unsigned char left, right; 1248 1249 left = snd_es1938_reg_read(chip, left_reg); 1250 if (left_reg != right_reg) 1251 right = snd_es1938_reg_read(chip, right_reg); 1252 else 1253 right = left; 1254 ucontrol->value.integer.value[0] = (left >> shift_left) & mask; 1255 ucontrol->value.integer.value[1] = (right >> shift_right) & mask; 1256 if (invert) { 1257 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0]; 1258 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1]; 1259 } 1260 return 0; 1261 } 1262 1263 static int snd_es1938_put_double(struct snd_kcontrol *kcontrol, 1264 struct snd_ctl_elem_value *ucontrol) 1265 { 1266 struct es1938 *chip = snd_kcontrol_chip(kcontrol); 1267 int left_reg = kcontrol->private_value & 0xff; 1268 int right_reg = (kcontrol->private_value >> 8) & 0xff; 1269 int shift_left = (kcontrol->private_value >> 16) & 0x07; 1270 int shift_right = (kcontrol->private_value >> 19) & 0x07; 1271 int mask = (kcontrol->private_value >> 24) & 0xff; 1272 int invert = (kcontrol->private_value >> 22) & 1; 1273 int change; 1274 unsigned char val1, val2, mask1, mask2; 1275 1276 val1 = ucontrol->value.integer.value[0] & mask; 1277 val2 = ucontrol->value.integer.value[1] & mask; 1278 if (invert) { 1279 val1 = mask - val1; 1280 val2 = mask - val2; 1281 } 1282 val1 <<= shift_left; 1283 val2 <<= shift_right; 1284 mask1 = mask << shift_left; 1285 mask2 = mask << shift_right; 1286 if (left_reg != right_reg) { 1287 change = 0; 1288 if (snd_es1938_reg_bits(chip, left_reg, mask1, val1) != val1) 1289 change = 1; 1290 if (snd_es1938_reg_bits(chip, right_reg, mask2, val2) != val2) 1291 change = 1; 1292 } else { 1293 change = (snd_es1938_reg_bits(chip, left_reg, mask1 | mask2, 1294 val1 | val2) != (val1 | val2)); 1295 } 1296 return change; 1297 } 1298 1299 static struct snd_kcontrol_new snd_es1938_controls[] = { 1300 ES1938_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0), 1301 ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1), 1302 { 1303 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1304 .name = "Hardware Master Playback Volume", 1305 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1306 .info = snd_es1938_info_hw_volume, 1307 .get = snd_es1938_get_hw_volume, 1308 }, 1309 { 1310 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1311 .name = "Hardware Master Playback Switch", 1312 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1313 .info = snd_es1938_info_hw_switch, 1314 .get = snd_es1938_get_hw_switch, 1315 }, 1316 ES1938_SINGLE("Hardware Volume Split", 0, 0x64, 7, 1, 0), 1317 ES1938_DOUBLE("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0), 1318 ES1938_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0), 1319 ES1938_DOUBLE("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0), 1320 ES1938_DOUBLE("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0), 1321 ES1938_DOUBLE("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0), 1322 ES1938_DOUBLE("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0), 1323 ES1938_DOUBLE("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0), 1324 ES1938_SINGLE("PC Speaker Volume", 0, 0x3c, 0, 7, 0), 1325 ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0), 1326 ES1938_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1), 1327 { 1328 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1329 .name = "Capture Source", 1330 .info = snd_es1938_info_mux, 1331 .get = snd_es1938_get_mux, 1332 .put = snd_es1938_put_mux, 1333 }, 1334 ES1938_DOUBLE("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0), 1335 ES1938_DOUBLE("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0), 1336 ES1938_DOUBLE("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0), 1337 ES1938_DOUBLE("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0), 1338 ES1938_DOUBLE("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0), 1339 ES1938_DOUBLE("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0), 1340 ES1938_DOUBLE("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0), 1341 ES1938_DOUBLE("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0), 1342 ES1938_DOUBLE("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0), 1343 ES1938_DOUBLE("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0), 1344 ES1938_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0), 1345 { 1346 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1347 .name = "3D Control - Switch", 1348 .info = snd_es1938_info_spatializer_enable, 1349 .get = snd_es1938_get_spatializer_enable, 1350 .put = snd_es1938_put_spatializer_enable, 1351 }, 1352 ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0) 1353 }; 1354 1355 1356 /* ---------------------------------------------------------------------------- */ 1357 /* ---------------------------------------------------------------------------- */ 1358 1359 /* 1360 * initialize the chip - used by resume callback, too 1361 */ 1362 static void snd_es1938_chip_init(struct es1938 *chip) 1363 { 1364 /* reset chip */ 1365 snd_es1938_reset(chip); 1366 1367 /* configure native mode */ 1368 1369 /* enable bus master */ 1370 pci_set_master(chip->pci); 1371 1372 /* disable legacy audio */ 1373 pci_write_config_word(chip->pci, SL_PCI_LEGACYCONTROL, 0x805f); 1374 1375 /* set DDMA base */ 1376 pci_write_config_word(chip->pci, SL_PCI_DDMACONTROL, chip->ddma_port | 1); 1377 1378 /* set DMA/IRQ policy */ 1379 pci_write_config_dword(chip->pci, SL_PCI_CONFIG, 0); 1380 1381 /* enable Audio 1, Audio 2, MPU401 IRQ and HW volume IRQ*/ 1382 outb(0xf0, SLIO_REG(chip, IRQCONTROL)); 1383 1384 /* reset DMA */ 1385 outb(0, SLDM_REG(chip, DMACLEAR)); 1386 } 1387 1388 #ifdef CONFIG_PM 1389 /* 1390 * PM support 1391 */ 1392 1393 static unsigned char saved_regs[SAVED_REG_SIZE+1] = { 1394 0x14, 0x1a, 0x1c, 0x3a, 0x3c, 0x3e, 0x36, 0x38, 1395 0x50, 0x52, 0x60, 0x61, 0x62, 0x63, 0x64, 0x68, 1396 0x69, 0x6a, 0x6b, 0x6d, 0x6e, 0x6f, 0x7c, 0x7d, 1397 0xa8, 0xb4, 1398 }; 1399 1400 1401 static int es1938_suspend(struct pci_dev *pci, pm_message_t state) 1402 { 1403 struct snd_card *card = pci_get_drvdata(pci); 1404 struct es1938 *chip = card->private_data; 1405 unsigned char *s, *d; 1406 1407 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); 1408 snd_pcm_suspend_all(chip->pcm); 1409 1410 /* save mixer-related registers */ 1411 for (s = saved_regs, d = chip->saved_regs; *s; s++, d++) 1412 *d = snd_es1938_reg_read(chip, *s); 1413 1414 outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */ 1415 if (chip->irq >= 0) 1416 free_irq(chip->irq, chip); 1417 pci_disable_device(pci); 1418 pci_save_state(pci); 1419 return 0; 1420 } 1421 1422 static int es1938_resume(struct pci_dev *pci) 1423 { 1424 struct snd_card *card = pci_get_drvdata(pci); 1425 struct es1938 *chip = card->private_data; 1426 unsigned char *s, *d; 1427 1428 pci_restore_state(pci); 1429 pci_enable_device(pci); 1430 request_irq(pci->irq, snd_es1938_interrupt, 1431 SA_INTERRUPT|SA_SHIRQ, "ES1938", chip); 1432 chip->irq = pci->irq; 1433 snd_es1938_chip_init(chip); 1434 1435 /* restore mixer-related registers */ 1436 for (s = saved_regs, d = chip->saved_regs; *s; s++, d++) { 1437 if (*s < 0xa0) 1438 snd_es1938_mixer_write(chip, *s, *d); 1439 else 1440 snd_es1938_write(chip, *s, *d); 1441 } 1442 1443 snd_power_change_state(card, SNDRV_CTL_POWER_D0); 1444 return 0; 1445 } 1446 #endif /* CONFIG_PM */ 1447 1448 #ifdef SUPPORT_JOYSTICK 1449 static int __devinit snd_es1938_create_gameport(struct es1938 *chip) 1450 { 1451 struct gameport *gp; 1452 1453 chip->gameport = gp = gameport_allocate_port(); 1454 if (!gp) { 1455 printk(KERN_ERR "es1938: cannot allocate memory for gameport\n"); 1456 return -ENOMEM; 1457 } 1458 1459 gameport_set_name(gp, "ES1938"); 1460 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci)); 1461 gameport_set_dev_parent(gp, &chip->pci->dev); 1462 gp->io = chip->game_port; 1463 1464 gameport_register_port(gp); 1465 1466 return 0; 1467 } 1468 1469 static void snd_es1938_free_gameport(struct es1938 *chip) 1470 { 1471 if (chip->gameport) { 1472 gameport_unregister_port(chip->gameport); 1473 chip->gameport = NULL; 1474 } 1475 } 1476 #else 1477 static inline int snd_es1938_create_gameport(struct es1938 *chip) { return -ENOSYS; } 1478 static inline void snd_es1938_free_gameport(struct es1938 *chip) { } 1479 #endif /* SUPPORT_JOYSTICK */ 1480 1481 static int snd_es1938_free(struct es1938 *chip) 1482 { 1483 /* disable irqs */ 1484 outb(0x00, SLIO_REG(chip, IRQCONTROL)); 1485 if (chip->rmidi) 1486 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); 1487 1488 snd_es1938_free_gameport(chip); 1489 1490 if (chip->irq >= 0) 1491 free_irq(chip->irq, chip); 1492 pci_release_regions(chip->pci); 1493 pci_disable_device(chip->pci); 1494 kfree(chip); 1495 return 0; 1496 } 1497 1498 static int snd_es1938_dev_free(struct snd_device *device) 1499 { 1500 struct es1938 *chip = device->device_data; 1501 return snd_es1938_free(chip); 1502 } 1503 1504 static int __devinit snd_es1938_create(struct snd_card *card, 1505 struct pci_dev * pci, 1506 struct es1938 ** rchip) 1507 { 1508 struct es1938 *chip; 1509 int err; 1510 static struct snd_device_ops ops = { 1511 .dev_free = snd_es1938_dev_free, 1512 }; 1513 1514 *rchip = NULL; 1515 1516 /* enable PCI device */ 1517 if ((err = pci_enable_device(pci)) < 0) 1518 return err; 1519 /* check, if we can restrict PCI DMA transfers to 24 bits */ 1520 if (pci_set_dma_mask(pci, 0x00ffffff) < 0 || 1521 pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) { 1522 snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n"); 1523 pci_disable_device(pci); 1524 return -ENXIO; 1525 } 1526 1527 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 1528 if (chip == NULL) { 1529 pci_disable_device(pci); 1530 return -ENOMEM; 1531 } 1532 spin_lock_init(&chip->reg_lock); 1533 spin_lock_init(&chip->mixer_lock); 1534 chip->card = card; 1535 chip->pci = pci; 1536 if ((err = pci_request_regions(pci, "ESS Solo-1")) < 0) { 1537 kfree(chip); 1538 pci_disable_device(pci); 1539 return err; 1540 } 1541 chip->io_port = pci_resource_start(pci, 0); 1542 chip->sb_port = pci_resource_start(pci, 1); 1543 chip->vc_port = pci_resource_start(pci, 2); 1544 chip->mpu_port = pci_resource_start(pci, 3); 1545 chip->game_port = pci_resource_start(pci, 4); 1546 if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ, 1547 "ES1938", chip)) { 1548 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); 1549 snd_es1938_free(chip); 1550 return -EBUSY; 1551 } 1552 chip->irq = pci->irq; 1553 #ifdef ES1938_DDEBUG 1554 snd_printk(KERN_DEBUG "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n", 1555 chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port); 1556 #endif 1557 1558 chip->ddma_port = chip->vc_port + 0x00; /* fix from Thomas Sailer */ 1559 1560 snd_es1938_chip_init(chip); 1561 1562 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { 1563 snd_es1938_free(chip); 1564 return err; 1565 } 1566 1567 snd_card_set_dev(card, &pci->dev); 1568 1569 *rchip = chip; 1570 return 0; 1571 } 1572 1573 /* -------------------------------------------------------------------- 1574 * Interrupt handler 1575 * -------------------------------------------------------------------- */ 1576 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs) 1577 { 1578 struct es1938 *chip = dev_id; 1579 unsigned char status, audiostatus; 1580 int handled = 0; 1581 1582 status = inb(SLIO_REG(chip, IRQCONTROL)); 1583 #if 0 1584 printk("Es1938debug - interrupt status: =0x%x\n", status); 1585 #endif 1586 1587 /* AUDIO 1 */ 1588 if (status & 0x10) { 1589 #if 0 1590 printk("Es1938debug - AUDIO channel 1 interrupt\n"); 1591 printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n", 1592 inw(SLDM_REG(chip, DMACOUNT))); 1593 printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n", 1594 inl(SLDM_REG(chip, DMAADDR))); 1595 printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n", 1596 inl(SLDM_REG(chip, DMASTATUS))); 1597 #endif 1598 /* clear irq */ 1599 handled = 1; 1600 audiostatus = inb(SLSB_REG(chip, STATUS)); 1601 if (chip->active & ADC1) 1602 snd_pcm_period_elapsed(chip->capture_substream); 1603 else if (chip->active & DAC1) 1604 snd_pcm_period_elapsed(chip->playback2_substream); 1605 } 1606 1607 /* AUDIO 2 */ 1608 if (status & 0x20) { 1609 #if 0 1610 printk("Es1938debug - AUDIO channel 2 interrupt\n"); 1611 printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n", 1612 inw(SLIO_REG(chip, AUDIO2DMACOUNT))); 1613 printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n", 1614 inl(SLIO_REG(chip, AUDIO2DMAADDR))); 1615 1616 #endif 1617 /* clear irq */ 1618 handled = 1; 1619 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0); 1620 if (chip->active & DAC2) 1621 snd_pcm_period_elapsed(chip->playback1_substream); 1622 } 1623 1624 /* Hardware volume */ 1625 if (status & 0x40) { 1626 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80; 1627 handled = 1; 1628 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id); 1629 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id); 1630 if (!split) { 1631 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 1632 &chip->master_switch->id); 1633 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 1634 &chip->master_volume->id); 1635 } 1636 /* ack interrupt */ 1637 snd_es1938_mixer_write(chip, 0x66, 0x00); 1638 } 1639 1640 /* MPU401 */ 1641 if (status & 0x80) { 1642 // the following line is evil! It switches off MIDI interrupt handling after the first interrupt received. 1643 // replacing the last 0 by 0x40 works for ESS-Solo1, but just doing nothing works as well! 1644 // andreas@flying-snail.de 1645 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */ 1646 if (chip->rmidi) { 1647 handled = 1; 1648 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs); 1649 } 1650 } 1651 return IRQ_RETVAL(handled); 1652 } 1653 1654 #define ES1938_DMA_SIZE 64 1655 1656 static int __devinit snd_es1938_mixer(struct es1938 *chip) 1657 { 1658 struct snd_card *card; 1659 unsigned int idx; 1660 int err; 1661 1662 card = chip->card; 1663 1664 strcpy(card->mixername, "ESS Solo-1"); 1665 1666 for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) { 1667 struct snd_kcontrol *kctl; 1668 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip); 1669 switch (idx) { 1670 case 0: 1671 chip->master_volume = kctl; 1672 kctl->private_free = snd_es1938_hwv_free; 1673 break; 1674 case 1: 1675 chip->master_switch = kctl; 1676 kctl->private_free = snd_es1938_hwv_free; 1677 break; 1678 case 2: 1679 chip->hw_volume = kctl; 1680 kctl->private_free = snd_es1938_hwv_free; 1681 break; 1682 case 3: 1683 chip->hw_switch = kctl; 1684 kctl->private_free = snd_es1938_hwv_free; 1685 break; 1686 } 1687 if ((err = snd_ctl_add(card, kctl)) < 0) 1688 return err; 1689 } 1690 return 0; 1691 } 1692 1693 1694 static int __devinit snd_es1938_probe(struct pci_dev *pci, 1695 const struct pci_device_id *pci_id) 1696 { 1697 static int dev; 1698 struct snd_card *card; 1699 struct es1938 *chip; 1700 struct snd_opl3 *opl3; 1701 int idx, err; 1702 1703 if (dev >= SNDRV_CARDS) 1704 return -ENODEV; 1705 if (!enable[dev]) { 1706 dev++; 1707 return -ENOENT; 1708 } 1709 1710 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); 1711 if (card == NULL) 1712 return -ENOMEM; 1713 for (idx = 0; idx < 5; idx++) { 1714 if (pci_resource_start(pci, idx) == 0 || 1715 !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) { 1716 snd_card_free(card); 1717 return -ENODEV; 1718 } 1719 } 1720 if ((err = snd_es1938_create(card, pci, &chip)) < 0) { 1721 snd_card_free(card); 1722 return err; 1723 } 1724 card->private_data = chip; 1725 1726 strcpy(card->driver, "ES1938"); 1727 strcpy(card->shortname, "ESS ES1938 (Solo-1)"); 1728 sprintf(card->longname, "%s rev %i, irq %i", 1729 card->shortname, 1730 chip->revision, 1731 chip->irq); 1732 1733 if ((err = snd_es1938_new_pcm(chip, 0)) < 0) { 1734 snd_card_free(card); 1735 return err; 1736 } 1737 if ((err = snd_es1938_mixer(chip)) < 0) { 1738 snd_card_free(card); 1739 return err; 1740 } 1741 if (snd_opl3_create(card, 1742 SLSB_REG(chip, FMLOWADDR), 1743 SLSB_REG(chip, FMHIGHADDR), 1744 OPL3_HW_OPL3, 1, &opl3) < 0) { 1745 printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n", 1746 SLSB_REG(chip, FMLOWADDR)); 1747 } else { 1748 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) { 1749 snd_card_free(card); 1750 return err; 1751 } 1752 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) { 1753 snd_card_free(card); 1754 return err; 1755 } 1756 } 1757 if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, 1758 chip->mpu_port, 1, chip->irq, 0, &chip->rmidi) < 0) { 1759 printk(KERN_ERR "es1938: unable to initialize MPU-401\n"); 1760 } else { 1761 // this line is vital for MIDI interrupt handling on ess-solo1 1762 // andreas@flying-snail.de 1763 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40); 1764 } 1765 1766 snd_es1938_create_gameport(chip); 1767 1768 if ((err = snd_card_register(card)) < 0) { 1769 snd_card_free(card); 1770 return err; 1771 } 1772 1773 pci_set_drvdata(pci, card); 1774 dev++; 1775 return 0; 1776 } 1777 1778 static void __devexit snd_es1938_remove(struct pci_dev *pci) 1779 { 1780 snd_card_free(pci_get_drvdata(pci)); 1781 pci_set_drvdata(pci, NULL); 1782 } 1783 1784 static struct pci_driver driver = { 1785 .name = "ESS ES1938 (Solo-1)", 1786 .id_table = snd_es1938_ids, 1787 .probe = snd_es1938_probe, 1788 .remove = __devexit_p(snd_es1938_remove), 1789 #ifdef CONFIG_PM 1790 .suspend = es1938_suspend, 1791 .resume = es1938_resume, 1792 #endif 1793 }; 1794 1795 static int __init alsa_card_es1938_init(void) 1796 { 1797 return pci_register_driver(&driver); 1798 } 1799 1800 static void __exit alsa_card_es1938_exit(void) 1801 { 1802 pci_unregister_driver(&driver); 1803 } 1804 1805 module_init(alsa_card_es1938_init) 1806 module_exit(alsa_card_es1938_exit) 1807