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 typedef struct _snd_es1938 es1938_t; 195 196 #define SAVED_REG_SIZE 32 /* max. number of registers to save */ 197 198 struct _snd_es1938 { 199 int irq; 200 201 unsigned long io_port; 202 unsigned long sb_port; 203 unsigned long vc_port; 204 unsigned long mpu_port; 205 unsigned long game_port; 206 unsigned long ddma_port; 207 208 unsigned char irqmask; 209 unsigned char revision; 210 211 snd_kcontrol_t *hw_volume; 212 snd_kcontrol_t *hw_switch; 213 snd_kcontrol_t *master_volume; 214 snd_kcontrol_t *master_switch; 215 216 struct pci_dev *pci; 217 snd_card_t *card; 218 snd_pcm_t *pcm; 219 snd_pcm_substream_t *capture_substream; 220 snd_pcm_substream_t *playback1_substream; 221 snd_pcm_substream_t *playback2_substream; 222 snd_kmixer_t *mixer; 223 snd_rawmidi_t *rmidi; 224 225 unsigned int dma1_size; 226 unsigned int dma2_size; 227 unsigned int dma1_start; 228 unsigned int dma2_start; 229 unsigned int dma1_shift; 230 unsigned int dma2_shift; 231 unsigned int active; 232 233 spinlock_t reg_lock; 234 spinlock_t mixer_lock; 235 snd_info_entry_t *proc_entry; 236 237 #ifdef SUPPORT_JOYSTICK 238 struct gameport *gameport; 239 #endif 240 #ifdef CONFIG_PM 241 unsigned char saved_regs[SAVED_REG_SIZE]; 242 #endif 243 }; 244 245 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs); 246 247 static struct pci_device_id snd_es1938_ids[] = { 248 { 0x125d, 0x1969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* Solo-1 */ 249 { 0, } 250 }; 251 252 MODULE_DEVICE_TABLE(pci, snd_es1938_ids); 253 254 #define RESET_LOOP_TIMEOUT 0x10000 255 #define WRITE_LOOP_TIMEOUT 0x10000 256 #define GET_LOOP_TIMEOUT 0x01000 257 258 #undef REG_DEBUG 259 /* ----------------------------------------------------------------- 260 * Write to a mixer register 261 * -----------------------------------------------------------------*/ 262 static void snd_es1938_mixer_write(es1938_t *chip, unsigned char reg, unsigned char val) 263 { 264 unsigned long flags; 265 spin_lock_irqsave(&chip->mixer_lock, flags); 266 outb(reg, SLSB_REG(chip, MIXERADDR)); 267 outb(val, SLSB_REG(chip, MIXERDATA)); 268 spin_unlock_irqrestore(&chip->mixer_lock, flags); 269 #ifdef REG_DEBUG 270 snd_printk(KERN_DEBUG "Mixer reg %02x set to %02x\n", reg, val); 271 #endif 272 } 273 274 /* ----------------------------------------------------------------- 275 * Read from a mixer register 276 * -----------------------------------------------------------------*/ 277 static int snd_es1938_mixer_read(es1938_t *chip, unsigned char reg) 278 { 279 int data; 280 unsigned long flags; 281 spin_lock_irqsave(&chip->mixer_lock, flags); 282 outb(reg, SLSB_REG(chip, MIXERADDR)); 283 data = inb(SLSB_REG(chip, MIXERDATA)); 284 spin_unlock_irqrestore(&chip->mixer_lock, flags); 285 #ifdef REG_DEBUG 286 snd_printk(KERN_DEBUG "Mixer reg %02x now is %02x\n", reg, data); 287 #endif 288 return data; 289 } 290 291 /* ----------------------------------------------------------------- 292 * Write to some bits of a mixer register (return old value) 293 * -----------------------------------------------------------------*/ 294 static int snd_es1938_mixer_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val) 295 { 296 unsigned long flags; 297 unsigned char old, new, oval; 298 spin_lock_irqsave(&chip->mixer_lock, flags); 299 outb(reg, SLSB_REG(chip, MIXERADDR)); 300 old = inb(SLSB_REG(chip, MIXERDATA)); 301 oval = old & mask; 302 if (val != oval) { 303 new = (old & ~mask) | (val & mask); 304 outb(new, SLSB_REG(chip, MIXERDATA)); 305 #ifdef REG_DEBUG 306 snd_printk(KERN_DEBUG "Mixer reg %02x was %02x, set to %02x\n", 307 reg, old, new); 308 #endif 309 } 310 spin_unlock_irqrestore(&chip->mixer_lock, flags); 311 return oval; 312 } 313 314 /* ----------------------------------------------------------------- 315 * Write command to Controller Registers 316 * -----------------------------------------------------------------*/ 317 static void snd_es1938_write_cmd(es1938_t *chip, unsigned char cmd) 318 { 319 int i; 320 unsigned char v; 321 for (i = 0; i < WRITE_LOOP_TIMEOUT; i++) { 322 if (!(v = inb(SLSB_REG(chip, READSTATUS)) & 0x80)) { 323 outb(cmd, SLSB_REG(chip, WRITEDATA)); 324 return; 325 } 326 } 327 printk(KERN_ERR "snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v); 328 } 329 330 /* ----------------------------------------------------------------- 331 * Read the Read Data Buffer 332 * -----------------------------------------------------------------*/ 333 static int snd_es1938_get_byte(es1938_t *chip) 334 { 335 int i; 336 unsigned char v; 337 for (i = GET_LOOP_TIMEOUT; i; i--) 338 if ((v = inb(SLSB_REG(chip, STATUS))) & 0x80) 339 return inb(SLSB_REG(chip, READDATA)); 340 snd_printk(KERN_ERR "get_byte timeout: status 0x02%x\n", v); 341 return -ENODEV; 342 } 343 344 /* ----------------------------------------------------------------- 345 * Write value cmd register 346 * -----------------------------------------------------------------*/ 347 static void snd_es1938_write(es1938_t *chip, unsigned char reg, unsigned char val) 348 { 349 unsigned long flags; 350 spin_lock_irqsave(&chip->reg_lock, flags); 351 snd_es1938_write_cmd(chip, reg); 352 snd_es1938_write_cmd(chip, val); 353 spin_unlock_irqrestore(&chip->reg_lock, flags); 354 #ifdef REG_DEBUG 355 snd_printk(KERN_DEBUG "Reg %02x set to %02x\n", reg, val); 356 #endif 357 } 358 359 /* ----------------------------------------------------------------- 360 * Read data from cmd register and return it 361 * -----------------------------------------------------------------*/ 362 static unsigned char snd_es1938_read(es1938_t *chip, unsigned char reg) 363 { 364 unsigned char val; 365 unsigned long flags; 366 spin_lock_irqsave(&chip->reg_lock, flags); 367 snd_es1938_write_cmd(chip, ESS_CMD_READREG); 368 snd_es1938_write_cmd(chip, reg); 369 val = snd_es1938_get_byte(chip); 370 spin_unlock_irqrestore(&chip->reg_lock, flags); 371 #ifdef REG_DEBUG 372 snd_printk(KERN_DEBUG "Reg %02x now is %02x\n", reg, val); 373 #endif 374 return val; 375 } 376 377 /* ----------------------------------------------------------------- 378 * Write data to cmd register and return old value 379 * -----------------------------------------------------------------*/ 380 static int snd_es1938_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val) 381 { 382 unsigned long flags; 383 unsigned char old, new, oval; 384 spin_lock_irqsave(&chip->reg_lock, flags); 385 snd_es1938_write_cmd(chip, ESS_CMD_READREG); 386 snd_es1938_write_cmd(chip, reg); 387 old = snd_es1938_get_byte(chip); 388 oval = old & mask; 389 if (val != oval) { 390 snd_es1938_write_cmd(chip, reg); 391 new = (old & ~mask) | (val & mask); 392 snd_es1938_write_cmd(chip, new); 393 #ifdef REG_DEBUG 394 snd_printk(KERN_DEBUG "Reg %02x was %02x, set to %02x\n", 395 reg, old, new); 396 #endif 397 } 398 spin_unlock_irqrestore(&chip->reg_lock, flags); 399 return oval; 400 } 401 402 /* -------------------------------------------------------------------- 403 * Reset the chip 404 * --------------------------------------------------------------------*/ 405 static void snd_es1938_reset(es1938_t *chip) 406 { 407 int i; 408 409 outb(3, SLSB_REG(chip, RESET)); 410 inb(SLSB_REG(chip, RESET)); 411 outb(0, SLSB_REG(chip, RESET)); 412 for (i = 0; i < RESET_LOOP_TIMEOUT; i++) { 413 if (inb(SLSB_REG(chip, STATUS)) & 0x80) { 414 if (inb(SLSB_REG(chip, READDATA)) == 0xaa) 415 goto __next; 416 } 417 } 418 snd_printk(KERN_ERR "ESS Solo-1 reset failed\n"); 419 420 __next: 421 snd_es1938_write_cmd(chip, ESS_CMD_ENABLEEXT); 422 423 /* Demand transfer DMA: 4 bytes per DMA request */ 424 snd_es1938_write(chip, ESS_CMD_DMATYPE, 2); 425 426 /* Change behaviour of register A1 427 4x oversampling 428 2nd channel DAC asynchronous */ 429 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2MODE, 0x32); 430 /* enable/select DMA channel and IRQ channel */ 431 snd_es1938_bits(chip, ESS_CMD_IRQCONTROL, 0xf0, 0x50); 432 snd_es1938_bits(chip, ESS_CMD_DRQCONTROL, 0xf0, 0x50); 433 snd_es1938_write_cmd(chip, ESS_CMD_ENABLEAUDIO1); 434 /* Set spatializer parameters to recommended values */ 435 snd_es1938_mixer_write(chip, 0x54, 0x8f); 436 snd_es1938_mixer_write(chip, 0x56, 0x95); 437 snd_es1938_mixer_write(chip, 0x58, 0x94); 438 snd_es1938_mixer_write(chip, 0x5a, 0x80); 439 } 440 441 /* -------------------------------------------------------------------- 442 * Reset the FIFOs 443 * --------------------------------------------------------------------*/ 444 static void snd_es1938_reset_fifo(es1938_t *chip) 445 { 446 outb(2, SLSB_REG(chip, RESET)); 447 outb(0, SLSB_REG(chip, RESET)); 448 } 449 450 static ratnum_t clocks[2] = { 451 { 452 .num = 793800, 453 .den_min = 1, 454 .den_max = 128, 455 .den_step = 1, 456 }, 457 { 458 .num = 768000, 459 .den_min = 1, 460 .den_max = 128, 461 .den_step = 1, 462 } 463 }; 464 465 static snd_pcm_hw_constraint_ratnums_t hw_constraints_clocks = { 466 .nrats = 2, 467 .rats = clocks, 468 }; 469 470 471 static void snd_es1938_rate_set(es1938_t *chip, 472 snd_pcm_substream_t *substream, 473 int mode) 474 { 475 unsigned int bits, div0; 476 snd_pcm_runtime_t *runtime = substream->runtime; 477 if (runtime->rate_num == clocks[0].num) 478 bits = 128 - runtime->rate_den; 479 else 480 bits = 256 - runtime->rate_den; 481 482 /* set filter register */ 483 div0 = 256 - 7160000*20/(8*82*runtime->rate); 484 485 if (mode == DAC2) { 486 snd_es1938_mixer_write(chip, 0x70, bits); 487 snd_es1938_mixer_write(chip, 0x72, div0); 488 } else { 489 snd_es1938_write(chip, 0xA1, bits); 490 snd_es1938_write(chip, 0xA2, div0); 491 } 492 } 493 494 /* -------------------------------------------------------------------- 495 * Configure Solo1 builtin DMA Controller 496 * --------------------------------------------------------------------*/ 497 498 static void snd_es1938_playback1_setdma(es1938_t *chip) 499 { 500 outb(0x00, SLIO_REG(chip, AUDIO2MODE)); 501 outl(chip->dma2_start, SLIO_REG(chip, AUDIO2DMAADDR)); 502 outw(0, SLIO_REG(chip, AUDIO2DMACOUNT)); 503 outw(chip->dma2_size, SLIO_REG(chip, AUDIO2DMACOUNT)); 504 } 505 506 static void snd_es1938_playback2_setdma(es1938_t *chip) 507 { 508 /* Enable DMA controller */ 509 outb(0xc4, SLDM_REG(chip, DMACOMMAND)); 510 /* 1. Master reset */ 511 outb(0, SLDM_REG(chip, DMACLEAR)); 512 /* 2. Mask DMA */ 513 outb(1, SLDM_REG(chip, DMAMASK)); 514 outb(0x18, SLDM_REG(chip, DMAMODE)); 515 outl(chip->dma1_start, SLDM_REG(chip, DMAADDR)); 516 outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT)); 517 /* 3. Unmask DMA */ 518 outb(0, SLDM_REG(chip, DMAMASK)); 519 } 520 521 static void snd_es1938_capture_setdma(es1938_t *chip) 522 { 523 /* Enable DMA controller */ 524 outb(0xc4, SLDM_REG(chip, DMACOMMAND)); 525 /* 1. Master reset */ 526 outb(0, SLDM_REG(chip, DMACLEAR)); 527 /* 2. Mask DMA */ 528 outb(1, SLDM_REG(chip, DMAMASK)); 529 outb(0x14, SLDM_REG(chip, DMAMODE)); 530 outl(chip->dma1_start, SLDM_REG(chip, DMAADDR)); 531 outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT)); 532 /* 3. Unmask DMA */ 533 outb(0, SLDM_REG(chip, DMAMASK)); 534 } 535 536 /* ---------------------------------------------------------------------- 537 * 538 * *** PCM part *** 539 */ 540 541 static int snd_es1938_capture_trigger(snd_pcm_substream_t * substream, 542 int cmd) 543 { 544 es1938_t *chip = snd_pcm_substream_chip(substream); 545 int val; 546 switch (cmd) { 547 case SNDRV_PCM_TRIGGER_START: 548 case SNDRV_PCM_TRIGGER_RESUME: 549 val = 0x0f; 550 chip->active |= ADC1; 551 break; 552 case SNDRV_PCM_TRIGGER_STOP: 553 case SNDRV_PCM_TRIGGER_SUSPEND: 554 val = 0x00; 555 chip->active &= ~ADC1; 556 break; 557 default: 558 return -EINVAL; 559 } 560 snd_es1938_write(chip, ESS_CMD_DMACONTROL, val); 561 return 0; 562 } 563 564 static int snd_es1938_playback1_trigger(snd_pcm_substream_t * substream, 565 int cmd) 566 { 567 es1938_t *chip = snd_pcm_substream_chip(substream); 568 switch (cmd) { 569 case SNDRV_PCM_TRIGGER_START: 570 case SNDRV_PCM_TRIGGER_RESUME: 571 /* According to the documentation this should be: 572 0x13 but that value may randomly swap stereo channels */ 573 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x92); 574 udelay(10); 575 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x93); 576 /* This two stage init gives the FIFO -> DAC connection time to 577 * settle before first data from DMA flows in. This should ensure 578 * no swapping of stereo channels. Report a bug if otherwise :-) */ 579 outb(0x0a, SLIO_REG(chip, AUDIO2MODE)); 580 chip->active |= DAC2; 581 break; 582 case SNDRV_PCM_TRIGGER_STOP: 583 case SNDRV_PCM_TRIGGER_SUSPEND: 584 outb(0, SLIO_REG(chip, AUDIO2MODE)); 585 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0); 586 chip->active &= ~DAC2; 587 break; 588 default: 589 return -EINVAL; 590 } 591 return 0; 592 } 593 594 static int snd_es1938_playback2_trigger(snd_pcm_substream_t * substream, 595 int cmd) 596 { 597 es1938_t *chip = snd_pcm_substream_chip(substream); 598 int val; 599 switch (cmd) { 600 case SNDRV_PCM_TRIGGER_START: 601 case SNDRV_PCM_TRIGGER_RESUME: 602 val = 5; 603 chip->active |= DAC1; 604 break; 605 case SNDRV_PCM_TRIGGER_STOP: 606 case SNDRV_PCM_TRIGGER_SUSPEND: 607 val = 0; 608 chip->active &= ~DAC1; 609 break; 610 default: 611 return -EINVAL; 612 } 613 snd_es1938_write(chip, ESS_CMD_DMACONTROL, val); 614 return 0; 615 } 616 617 static int snd_es1938_playback_trigger(snd_pcm_substream_t *substream, 618 int cmd) 619 { 620 switch (substream->number) { 621 case 0: 622 return snd_es1938_playback1_trigger(substream, cmd); 623 case 1: 624 return snd_es1938_playback2_trigger(substream, cmd); 625 } 626 snd_BUG(); 627 return -EINVAL; 628 } 629 630 /* -------------------------------------------------------------------- 631 * First channel for Extended Mode Audio 1 ADC Operation 632 * --------------------------------------------------------------------*/ 633 static int snd_es1938_capture_prepare(snd_pcm_substream_t * substream) 634 { 635 es1938_t *chip = snd_pcm_substream_chip(substream); 636 snd_pcm_runtime_t *runtime = substream->runtime; 637 int u, is8, mono; 638 unsigned int size = snd_pcm_lib_buffer_bytes(substream); 639 unsigned int count = snd_pcm_lib_period_bytes(substream); 640 641 chip->dma1_size = size; 642 chip->dma1_start = runtime->dma_addr; 643 644 mono = (runtime->channels > 1) ? 0 : 1; 645 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1; 646 u = snd_pcm_format_unsigned(runtime->format); 647 648 chip->dma1_shift = 2 - mono - is8; 649 650 snd_es1938_reset_fifo(chip); 651 652 /* program type */ 653 snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1)); 654 655 /* set clock and counters */ 656 snd_es1938_rate_set(chip, substream, ADC1); 657 658 count = 0x10000 - count; 659 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff); 660 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8); 661 662 /* initialize and configure ADC */ 663 snd_es1938_write(chip, ESS_CMD_SETFORMAT2, u ? 0x51 : 0x71); 664 snd_es1938_write(chip, ESS_CMD_SETFORMAT2, 0x90 | 665 (u ? 0x00 : 0x20) | 666 (is8 ? 0x00 : 0x04) | 667 (mono ? 0x40 : 0x08)); 668 669 // snd_es1938_reset_fifo(chip); 670 671 /* 11. configure system interrupt controller and DMA controller */ 672 snd_es1938_capture_setdma(chip); 673 674 return 0; 675 } 676 677 678 /* ------------------------------------------------------------------------------ 679 * Second Audio channel DAC Operation 680 * ------------------------------------------------------------------------------*/ 681 static int snd_es1938_playback1_prepare(snd_pcm_substream_t * substream) 682 { 683 es1938_t *chip = snd_pcm_substream_chip(substream); 684 snd_pcm_runtime_t *runtime = substream->runtime; 685 int u, is8, mono; 686 unsigned int size = snd_pcm_lib_buffer_bytes(substream); 687 unsigned int count = snd_pcm_lib_period_bytes(substream); 688 689 chip->dma2_size = size; 690 chip->dma2_start = runtime->dma_addr; 691 692 mono = (runtime->channels > 1) ? 0 : 1; 693 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1; 694 u = snd_pcm_format_unsigned(runtime->format); 695 696 chip->dma2_shift = 2 - mono - is8; 697 698 snd_es1938_reset_fifo(chip); 699 700 /* set clock and counters */ 701 snd_es1938_rate_set(chip, substream, DAC2); 702 703 count >>= 1; 704 count = 0x10000 - count; 705 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTL, count & 0xff); 706 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTH, count >> 8); 707 708 /* initialize and configure Audio 2 DAC */ 709 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) | (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(snd_pcm_substream_t * substream) 718 { 719 es1938_t *chip = snd_pcm_substream_chip(substream); 720 snd_pcm_runtime_t *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(snd_pcm_substream_t *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(snd_pcm_substream_t * substream) 772 { 773 es1938_t *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(snd_pcm_substream_t * substream) 789 { 790 es1938_t *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(snd_pcm_substream_t * substream) 801 { 802 es1938_t *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(snd_pcm_substream_t *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(snd_pcm_substream_t *substream, 830 int channel, 831 snd_pcm_uframes_t pos, 832 void __user *dst, 833 snd_pcm_uframes_t count) 834 { 835 snd_pcm_runtime_t *runtime = substream->runtime; 836 es1938_t *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(snd_pcm_substream_t *substream, 856 snd_pcm_hw_params_t * 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(snd_pcm_substream_t *substream) 867 { 868 return snd_pcm_lib_free_pages(substream); 869 } 870 871 /* ---------------------------------------------------------------------- 872 * Audio1 Capture (ADC) 873 * ----------------------------------------------------------------------*/ 874 static snd_pcm_hardware_t 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 | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE, 879 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 880 .rate_min = 6000, 881 .rate_max = 48000, 882 .channels_min = 1, 883 .channels_max = 2, 884 .buffer_bytes_max = 0x8000, /* DMA controller screws on higher values */ 885 .period_bytes_min = 64, 886 .period_bytes_max = 0x8000, 887 .periods_min = 1, 888 .periods_max = 1024, 889 .fifo_size = 256, 890 }; 891 892 /* ----------------------------------------------------------------------- 893 * Audio2 Playback (DAC) 894 * -----------------------------------------------------------------------*/ 895 static snd_pcm_hardware_t snd_es1938_playback = 896 { 897 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 898 SNDRV_PCM_INFO_BLOCK_TRANSFER | 899 SNDRV_PCM_INFO_MMAP_VALID), 900 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE, 901 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 902 .rate_min = 6000, 903 .rate_max = 48000, 904 .channels_min = 1, 905 .channels_max = 2, 906 .buffer_bytes_max = 0x8000, /* DMA controller screws on higher values */ 907 .period_bytes_min = 64, 908 .period_bytes_max = 0x8000, 909 .periods_min = 1, 910 .periods_max = 1024, 911 .fifo_size = 256, 912 }; 913 914 static int snd_es1938_capture_open(snd_pcm_substream_t * substream) 915 { 916 es1938_t *chip = snd_pcm_substream_chip(substream); 917 snd_pcm_runtime_t *runtime = substream->runtime; 918 919 if (chip->playback2_substream) 920 return -EAGAIN; 921 chip->capture_substream = substream; 922 runtime->hw = snd_es1938_capture; 923 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 924 &hw_constraints_clocks); 925 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00); 926 return 0; 927 } 928 929 static int snd_es1938_playback_open(snd_pcm_substream_t * substream) 930 { 931 es1938_t *chip = snd_pcm_substream_chip(substream); 932 snd_pcm_runtime_t *runtime = substream->runtime; 933 934 switch (substream->number) { 935 case 0: 936 chip->playback1_substream = substream; 937 break; 938 case 1: 939 if (chip->capture_substream) 940 return -EAGAIN; 941 chip->playback2_substream = substream; 942 break; 943 default: 944 snd_BUG(); 945 return -EINVAL; 946 } 947 runtime->hw = snd_es1938_playback; 948 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 949 &hw_constraints_clocks); 950 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00); 951 return 0; 952 } 953 954 static int snd_es1938_capture_close(snd_pcm_substream_t * substream) 955 { 956 es1938_t *chip = snd_pcm_substream_chip(substream); 957 958 chip->capture_substream = NULL; 959 return 0; 960 } 961 962 static int snd_es1938_playback_close(snd_pcm_substream_t * substream) 963 { 964 es1938_t *chip = snd_pcm_substream_chip(substream); 965 966 switch (substream->number) { 967 case 0: 968 chip->playback1_substream = NULL; 969 break; 970 case 1: 971 chip->playback2_substream = NULL; 972 break; 973 default: 974 snd_BUG(); 975 return -EINVAL; 976 } 977 return 0; 978 } 979 980 static snd_pcm_ops_t snd_es1938_playback_ops = { 981 .open = snd_es1938_playback_open, 982 .close = snd_es1938_playback_close, 983 .ioctl = snd_pcm_lib_ioctl, 984 .hw_params = snd_es1938_pcm_hw_params, 985 .hw_free = snd_es1938_pcm_hw_free, 986 .prepare = snd_es1938_playback_prepare, 987 .trigger = snd_es1938_playback_trigger, 988 .pointer = snd_es1938_playback_pointer, 989 }; 990 991 static snd_pcm_ops_t snd_es1938_capture_ops = { 992 .open = snd_es1938_capture_open, 993 .close = snd_es1938_capture_close, 994 .ioctl = snd_pcm_lib_ioctl, 995 .hw_params = snd_es1938_pcm_hw_params, 996 .hw_free = snd_es1938_pcm_hw_free, 997 .prepare = snd_es1938_capture_prepare, 998 .trigger = snd_es1938_capture_trigger, 999 .pointer = snd_es1938_capture_pointer, 1000 .copy = snd_es1938_capture_copy, 1001 }; 1002 1003 static void snd_es1938_free_pcm(snd_pcm_t *pcm) 1004 { 1005 snd_pcm_lib_preallocate_free_for_all(pcm); 1006 } 1007 1008 static int __devinit snd_es1938_new_pcm(es1938_t *chip, int device) 1009 { 1010 snd_pcm_t *pcm; 1011 int err; 1012 1013 if ((err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm)) < 0) 1014 return err; 1015 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1938_playback_ops); 1016 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1938_capture_ops); 1017 1018 pcm->private_data = chip; 1019 pcm->private_free = snd_es1938_free_pcm; 1020 pcm->info_flags = 0; 1021 strcpy(pcm->name, "ESS Solo-1"); 1022 1023 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 1024 snd_dma_pci_data(chip->pci), 64*1024, 64*1024); 1025 1026 chip->pcm = pcm; 1027 return 0; 1028 } 1029 1030 /* ------------------------------------------------------------------- 1031 * 1032 * *** Mixer part *** 1033 */ 1034 1035 static int snd_es1938_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) 1036 { 1037 static char *texts[8] = { 1038 "Mic", "Mic Master", "CD", "AOUT", 1039 "Mic1", "Mix", "Line", "Master" 1040 }; 1041 1042 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1043 uinfo->count = 1; 1044 uinfo->value.enumerated.items = 8; 1045 if (uinfo->value.enumerated.item > 7) 1046 uinfo->value.enumerated.item = 7; 1047 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]); 1048 return 0; 1049 } 1050 1051 static int snd_es1938_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) 1052 { 1053 es1938_t *chip = snd_kcontrol_chip(kcontrol); 1054 ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07; 1055 return 0; 1056 } 1057 1058 static int snd_es1938_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) 1059 { 1060 es1938_t *chip = snd_kcontrol_chip(kcontrol); 1061 unsigned char val = ucontrol->value.enumerated.item[0]; 1062 1063 if (val > 7) 1064 return -EINVAL; 1065 return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val; 1066 } 1067 1068 static int snd_es1938_info_spatializer_enable(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * 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(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) 1078 { 1079 es1938_t *chip = snd_kcontrol_chip(kcontrol); 1080 unsigned char val = snd_es1938_mixer_read(chip, 0x50); 1081 ucontrol->value.integer.value[0] = !!(val & 8); 1082 return 0; 1083 } 1084 1085 static int snd_es1938_put_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) 1086 { 1087 es1938_t *chip = snd_kcontrol_chip(kcontrol); 1088 unsigned char oval, nval; 1089 int change; 1090 nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04; 1091 oval = snd_es1938_mixer_read(chip, 0x50) & 0x0c; 1092 change = nval != oval; 1093 if (change) { 1094 snd_es1938_mixer_write(chip, 0x50, nval & ~0x04); 1095 snd_es1938_mixer_write(chip, 0x50, nval); 1096 } 1097 return change; 1098 } 1099 1100 static int snd_es1938_info_hw_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) 1101 { 1102 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1103 uinfo->count = 2; 1104 uinfo->value.integer.min = 0; 1105 uinfo->value.integer.max = 63; 1106 return 0; 1107 } 1108 1109 static int snd_es1938_get_hw_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) 1110 { 1111 es1938_t *chip = snd_kcontrol_chip(kcontrol); 1112 ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f; 1113 ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f; 1114 return 0; 1115 } 1116 1117 static int snd_es1938_info_hw_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) 1118 { 1119 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 1120 uinfo->count = 2; 1121 uinfo->value.integer.min = 0; 1122 uinfo->value.integer.max = 1; 1123 return 0; 1124 } 1125 1126 static int snd_es1938_get_hw_switch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) 1127 { 1128 es1938_t *chip = snd_kcontrol_chip(kcontrol); 1129 ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40); 1130 ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40); 1131 return 0; 1132 } 1133 1134 static void snd_es1938_hwv_free(snd_kcontrol_t *kcontrol) 1135 { 1136 es1938_t *chip = snd_kcontrol_chip(kcontrol); 1137 chip->master_volume = NULL; 1138 chip->master_switch = NULL; 1139 chip->hw_volume = NULL; 1140 chip->hw_switch = NULL; 1141 } 1142 1143 static int snd_es1938_reg_bits(es1938_t *chip, unsigned char reg, 1144 unsigned char mask, unsigned char val) 1145 { 1146 if (reg < 0xa0) 1147 return snd_es1938_mixer_bits(chip, reg, mask, val); 1148 else 1149 return snd_es1938_bits(chip, reg, mask, val); 1150 } 1151 1152 static int snd_es1938_reg_read(es1938_t *chip, unsigned char reg) 1153 { 1154 if (reg < 0xa0) 1155 return snd_es1938_mixer_read(chip, reg); 1156 else 1157 return snd_es1938_read(chip, reg); 1158 } 1159 1160 #define ES1938_SINGLE(xname, xindex, reg, shift, mask, invert) \ 1161 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \ 1162 .info = snd_es1938_info_single, \ 1163 .get = snd_es1938_get_single, .put = snd_es1938_put_single, \ 1164 .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) } 1165 1166 static int snd_es1938_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) 1167 { 1168 int mask = (kcontrol->private_value >> 16) & 0xff; 1169 1170 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER; 1171 uinfo->count = 1; 1172 uinfo->value.integer.min = 0; 1173 uinfo->value.integer.max = mask; 1174 return 0; 1175 } 1176 1177 static int snd_es1938_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) 1178 { 1179 es1938_t *chip = snd_kcontrol_chip(kcontrol); 1180 int reg = kcontrol->private_value & 0xff; 1181 int shift = (kcontrol->private_value >> 8) & 0xff; 1182 int mask = (kcontrol->private_value >> 16) & 0xff; 1183 int invert = (kcontrol->private_value >> 24) & 0xff; 1184 int val; 1185 1186 val = snd_es1938_reg_read(chip, reg); 1187 ucontrol->value.integer.value[0] = (val >> shift) & mask; 1188 if (invert) 1189 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0]; 1190 return 0; 1191 } 1192 1193 static int snd_es1938_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) 1194 { 1195 es1938_t *chip = snd_kcontrol_chip(kcontrol); 1196 int reg = kcontrol->private_value & 0xff; 1197 int shift = (kcontrol->private_value >> 8) & 0xff; 1198 int mask = (kcontrol->private_value >> 16) & 0xff; 1199 int invert = (kcontrol->private_value >> 24) & 0xff; 1200 unsigned char val; 1201 1202 val = (ucontrol->value.integer.value[0] & mask); 1203 if (invert) 1204 val = mask - val; 1205 mask <<= shift; 1206 val <<= shift; 1207 return snd_es1938_reg_bits(chip, reg, mask, val) != val; 1208 } 1209 1210 #define ES1938_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \ 1211 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \ 1212 .info = snd_es1938_info_double, \ 1213 .get = snd_es1938_get_double, .put = snd_es1938_put_double, \ 1214 .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) } 1215 1216 static int snd_es1938_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo) 1217 { 1218 int mask = (kcontrol->private_value >> 24) & 0xff; 1219 1220 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER; 1221 uinfo->count = 2; 1222 uinfo->value.integer.min = 0; 1223 uinfo->value.integer.max = mask; 1224 return 0; 1225 } 1226 1227 static int snd_es1938_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) 1228 { 1229 es1938_t *chip = snd_kcontrol_chip(kcontrol); 1230 int left_reg = kcontrol->private_value & 0xff; 1231 int right_reg = (kcontrol->private_value >> 8) & 0xff; 1232 int shift_left = (kcontrol->private_value >> 16) & 0x07; 1233 int shift_right = (kcontrol->private_value >> 19) & 0x07; 1234 int mask = (kcontrol->private_value >> 24) & 0xff; 1235 int invert = (kcontrol->private_value >> 22) & 1; 1236 unsigned char left, right; 1237 1238 left = snd_es1938_reg_read(chip, left_reg); 1239 if (left_reg != right_reg) 1240 right = snd_es1938_reg_read(chip, right_reg); 1241 else 1242 right = left; 1243 ucontrol->value.integer.value[0] = (left >> shift_left) & mask; 1244 ucontrol->value.integer.value[1] = (right >> shift_right) & mask; 1245 if (invert) { 1246 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0]; 1247 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1]; 1248 } 1249 return 0; 1250 } 1251 1252 static int snd_es1938_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol) 1253 { 1254 es1938_t *chip = snd_kcontrol_chip(kcontrol); 1255 int left_reg = kcontrol->private_value & 0xff; 1256 int right_reg = (kcontrol->private_value >> 8) & 0xff; 1257 int shift_left = (kcontrol->private_value >> 16) & 0x07; 1258 int shift_right = (kcontrol->private_value >> 19) & 0x07; 1259 int mask = (kcontrol->private_value >> 24) & 0xff; 1260 int invert = (kcontrol->private_value >> 22) & 1; 1261 int change; 1262 unsigned char val1, val2, mask1, mask2; 1263 1264 val1 = ucontrol->value.integer.value[0] & mask; 1265 val2 = ucontrol->value.integer.value[1] & mask; 1266 if (invert) { 1267 val1 = mask - val1; 1268 val2 = mask - val2; 1269 } 1270 val1 <<= shift_left; 1271 val2 <<= shift_right; 1272 mask1 = mask << shift_left; 1273 mask2 = mask << shift_right; 1274 if (left_reg != right_reg) { 1275 change = 0; 1276 if (snd_es1938_reg_bits(chip, left_reg, mask1, val1) != val1) 1277 change = 1; 1278 if (snd_es1938_reg_bits(chip, right_reg, mask2, val2) != val2) 1279 change = 1; 1280 } else { 1281 change = (snd_es1938_reg_bits(chip, left_reg, mask1 | mask2, 1282 val1 | val2) != (val1 | val2)); 1283 } 1284 return change; 1285 } 1286 1287 static snd_kcontrol_new_t snd_es1938_controls[] = { 1288 ES1938_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0), 1289 ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1), 1290 { 1291 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1292 .name = "Hardware Master Playback Volume", 1293 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1294 .info = snd_es1938_info_hw_volume, 1295 .get = snd_es1938_get_hw_volume, 1296 }, 1297 { 1298 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1299 .name = "Hardware Master Playback Switch", 1300 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1301 .info = snd_es1938_info_hw_switch, 1302 .get = snd_es1938_get_hw_switch, 1303 }, 1304 ES1938_SINGLE("Hardware Volume Split", 0, 0x64, 7, 1, 0), 1305 ES1938_DOUBLE("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0), 1306 ES1938_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0), 1307 ES1938_DOUBLE("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0), 1308 ES1938_DOUBLE("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0), 1309 ES1938_DOUBLE("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0), 1310 ES1938_DOUBLE("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0), 1311 ES1938_DOUBLE("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0), 1312 ES1938_SINGLE("PC Speaker Volume", 0, 0x3c, 0, 7, 0), 1313 ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0), 1314 ES1938_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1), 1315 { 1316 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1317 .name = "Capture Source", 1318 .info = snd_es1938_info_mux, 1319 .get = snd_es1938_get_mux, 1320 .put = snd_es1938_put_mux, 1321 }, 1322 ES1938_DOUBLE("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0), 1323 ES1938_DOUBLE("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0), 1324 ES1938_DOUBLE("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0), 1325 ES1938_DOUBLE("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0), 1326 ES1938_DOUBLE("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0), 1327 ES1938_DOUBLE("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0), 1328 ES1938_DOUBLE("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0), 1329 ES1938_DOUBLE("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0), 1330 ES1938_DOUBLE("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0), 1331 ES1938_DOUBLE("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0), 1332 ES1938_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0), 1333 { 1334 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1335 .name = "3D Control - Switch", 1336 .info = snd_es1938_info_spatializer_enable, 1337 .get = snd_es1938_get_spatializer_enable, 1338 .put = snd_es1938_put_spatializer_enable, 1339 }, 1340 ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0) 1341 }; 1342 1343 1344 /* ---------------------------------------------------------------------------- */ 1345 /* ---------------------------------------------------------------------------- */ 1346 1347 /* 1348 * initialize the chip - used by resume callback, too 1349 */ 1350 static void snd_es1938_chip_init(es1938_t *chip) 1351 { 1352 /* reset chip */ 1353 snd_es1938_reset(chip); 1354 1355 /* configure native mode */ 1356 1357 /* enable bus master */ 1358 pci_set_master(chip->pci); 1359 1360 /* disable legacy audio */ 1361 pci_write_config_word(chip->pci, SL_PCI_LEGACYCONTROL, 0x805f); 1362 1363 /* set DDMA base */ 1364 pci_write_config_word(chip->pci, SL_PCI_DDMACONTROL, chip->ddma_port | 1); 1365 1366 /* set DMA/IRQ policy */ 1367 pci_write_config_dword(chip->pci, SL_PCI_CONFIG, 0); 1368 1369 /* enable Audio 1, Audio 2, MPU401 IRQ and HW volume IRQ*/ 1370 outb(0xf0, SLIO_REG(chip, IRQCONTROL)); 1371 1372 /* reset DMA */ 1373 outb(0, SLDM_REG(chip, DMACLEAR)); 1374 } 1375 1376 #ifdef CONFIG_PM 1377 /* 1378 * PM support 1379 */ 1380 1381 static unsigned char saved_regs[SAVED_REG_SIZE+1] = { 1382 0x14, 0x1a, 0x1c, 0x3a, 0x3c, 0x3e, 0x36, 0x38, 1383 0x50, 0x52, 0x60, 0x61, 0x62, 0x63, 0x64, 0x68, 1384 0x69, 0x6a, 0x6b, 0x6d, 0x6e, 0x6f, 0x7c, 0x7d, 1385 0xa8, 0xb4, 1386 }; 1387 1388 1389 static int es1938_suspend(snd_card_t *card, pm_message_t state) 1390 { 1391 es1938_t *chip = card->pm_private_data; 1392 unsigned char *s, *d; 1393 1394 snd_pcm_suspend_all(chip->pcm); 1395 1396 /* save mixer-related registers */ 1397 for (s = saved_regs, d = chip->saved_regs; *s; s++, d++) 1398 *d = snd_es1938_reg_read(chip, *s); 1399 1400 outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */ 1401 if (chip->irq >= 0) 1402 free_irq(chip->irq, (void *)chip); 1403 pci_disable_device(chip->pci); 1404 return 0; 1405 } 1406 1407 static int es1938_resume(snd_card_t *card) 1408 { 1409 es1938_t *chip = card->pm_private_data; 1410 unsigned char *s, *d; 1411 1412 pci_enable_device(chip->pci); 1413 request_irq(chip->pci->irq, snd_es1938_interrupt, 1414 SA_INTERRUPT|SA_SHIRQ, "ES1938", (void *)chip); 1415 chip->irq = chip->pci->irq; 1416 snd_es1938_chip_init(chip); 1417 1418 /* restore mixer-related registers */ 1419 for (s = saved_regs, d = chip->saved_regs; *s; s++, d++) { 1420 if (*s < 0xa0) 1421 snd_es1938_mixer_write(chip, *s, *d); 1422 else 1423 snd_es1938_write(chip, *s, *d); 1424 } 1425 1426 return 0; 1427 } 1428 #endif /* CONFIG_PM */ 1429 1430 #ifdef SUPPORT_JOYSTICK 1431 static int __devinit snd_es1938_create_gameport(es1938_t *chip) 1432 { 1433 struct gameport *gp; 1434 1435 chip->gameport = gp = gameport_allocate_port(); 1436 if (!gp) { 1437 printk(KERN_ERR "es1938: cannot allocate memory for gameport\n"); 1438 return -ENOMEM; 1439 } 1440 1441 gameport_set_name(gp, "ES1938"); 1442 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci)); 1443 gameport_set_dev_parent(gp, &chip->pci->dev); 1444 gp->io = chip->game_port; 1445 1446 gameport_register_port(gp); 1447 1448 return 0; 1449 } 1450 1451 static void snd_es1938_free_gameport(es1938_t *chip) 1452 { 1453 if (chip->gameport) { 1454 gameport_unregister_port(chip->gameport); 1455 chip->gameport = NULL; 1456 } 1457 } 1458 #else 1459 static inline int snd_es1938_create_gameport(es1938_t *chip) { return -ENOSYS; } 1460 static inline void snd_es1938_free_gameport(es1938_t *chip) { } 1461 #endif /* SUPPORT_JOYSTICK */ 1462 1463 static int snd_es1938_free(es1938_t *chip) 1464 { 1465 /* disable irqs */ 1466 outb(0x00, SLIO_REG(chip, IRQCONTROL)); 1467 if (chip->rmidi) 1468 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); 1469 1470 snd_es1938_free_gameport(chip); 1471 1472 if (chip->irq >= 0) 1473 free_irq(chip->irq, (void *)chip); 1474 pci_release_regions(chip->pci); 1475 pci_disable_device(chip->pci); 1476 kfree(chip); 1477 return 0; 1478 } 1479 1480 static int snd_es1938_dev_free(snd_device_t *device) 1481 { 1482 es1938_t *chip = device->device_data; 1483 return snd_es1938_free(chip); 1484 } 1485 1486 static int __devinit snd_es1938_create(snd_card_t * card, 1487 struct pci_dev * pci, 1488 es1938_t ** rchip) 1489 { 1490 es1938_t *chip; 1491 int err; 1492 static snd_device_ops_t ops = { 1493 .dev_free = snd_es1938_dev_free, 1494 }; 1495 1496 *rchip = NULL; 1497 1498 /* enable PCI device */ 1499 if ((err = pci_enable_device(pci)) < 0) 1500 return err; 1501 /* check, if we can restrict PCI DMA transfers to 24 bits */ 1502 if (pci_set_dma_mask(pci, 0x00ffffff) < 0 || 1503 pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) { 1504 snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n"); 1505 pci_disable_device(pci); 1506 return -ENXIO; 1507 } 1508 1509 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 1510 if (chip == NULL) { 1511 pci_disable_device(pci); 1512 return -ENOMEM; 1513 } 1514 spin_lock_init(&chip->reg_lock); 1515 spin_lock_init(&chip->mixer_lock); 1516 chip->card = card; 1517 chip->pci = pci; 1518 if ((err = pci_request_regions(pci, "ESS Solo-1")) < 0) { 1519 kfree(chip); 1520 pci_disable_device(pci); 1521 return err; 1522 } 1523 chip->io_port = pci_resource_start(pci, 0); 1524 chip->sb_port = pci_resource_start(pci, 1); 1525 chip->vc_port = pci_resource_start(pci, 2); 1526 chip->mpu_port = pci_resource_start(pci, 3); 1527 chip->game_port = pci_resource_start(pci, 4); 1528 if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ, "ES1938", (void *)chip)) { 1529 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq); 1530 snd_es1938_free(chip); 1531 return -EBUSY; 1532 } 1533 chip->irq = pci->irq; 1534 #ifdef ES1938_DDEBUG 1535 snd_printk(KERN_DEBUG "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n", 1536 chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port); 1537 #endif 1538 1539 chip->ddma_port = chip->vc_port + 0x00; /* fix from Thomas Sailer */ 1540 1541 snd_es1938_chip_init(chip); 1542 1543 snd_card_set_pm_callback(card, es1938_suspend, es1938_resume, chip); 1544 1545 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { 1546 snd_es1938_free(chip); 1547 return err; 1548 } 1549 1550 snd_card_set_dev(card, &pci->dev); 1551 1552 *rchip = chip; 1553 return 0; 1554 } 1555 1556 /* -------------------------------------------------------------------- 1557 * Interrupt handler 1558 * -------------------------------------------------------------------- */ 1559 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs) 1560 { 1561 es1938_t *chip = dev_id; 1562 unsigned char status, audiostatus; 1563 int handled = 0; 1564 1565 status = inb(SLIO_REG(chip, IRQCONTROL)); 1566 #if 0 1567 printk("Es1938debug - interrupt status: =0x%x\n", status); 1568 #endif 1569 1570 /* AUDIO 1 */ 1571 if (status & 0x10) { 1572 #if 0 1573 printk("Es1938debug - AUDIO channel 1 interrupt\n"); 1574 printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n", inw(SLDM_REG(chip, DMACOUNT))); 1575 printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n", inl(SLDM_REG(chip, DMAADDR))); 1576 printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n", inl(SLDM_REG(chip, DMASTATUS))); 1577 #endif 1578 /* clear irq */ 1579 handled = 1; 1580 audiostatus = inb(SLSB_REG(chip, STATUS)); 1581 if (chip->active & ADC1) 1582 snd_pcm_period_elapsed(chip->capture_substream); 1583 else if (chip->active & DAC1) 1584 snd_pcm_period_elapsed(chip->playback2_substream); 1585 } 1586 1587 /* AUDIO 2 */ 1588 if (status & 0x20) { 1589 #if 0 1590 printk("Es1938debug - AUDIO channel 2 interrupt\n"); 1591 printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n", inw(SLIO_REG(chip, AUDIO2DMACOUNT))); 1592 printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n", inl(SLIO_REG(chip, AUDIO2DMAADDR))); 1593 1594 #endif 1595 /* clear irq */ 1596 handled = 1; 1597 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0); 1598 if (chip->active & DAC2) 1599 snd_pcm_period_elapsed(chip->playback1_substream); 1600 } 1601 1602 /* Hardware volume */ 1603 if (status & 0x40) { 1604 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80; 1605 handled = 1; 1606 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id); 1607 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id); 1608 if (!split) { 1609 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_switch->id); 1610 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_volume->id); 1611 } 1612 /* ack interrupt */ 1613 snd_es1938_mixer_write(chip, 0x66, 0x00); 1614 } 1615 1616 /* MPU401 */ 1617 if (status & 0x80) { 1618 // the following line is evil! It switches off MIDI interrupt handling after the first interrupt received. 1619 // replacing the last 0 by 0x40 works for ESS-Solo1, but just doing nothing works as well! 1620 // andreas@flying-snail.de 1621 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */ 1622 if (chip->rmidi) { 1623 handled = 1; 1624 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs); 1625 } 1626 } 1627 return IRQ_RETVAL(handled); 1628 } 1629 1630 #define ES1938_DMA_SIZE 64 1631 1632 static int __devinit snd_es1938_mixer(es1938_t *chip) 1633 { 1634 snd_card_t *card; 1635 unsigned int idx; 1636 int err; 1637 1638 card = chip->card; 1639 1640 strcpy(card->mixername, "ESS Solo-1"); 1641 1642 for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) { 1643 snd_kcontrol_t *kctl; 1644 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip); 1645 switch (idx) { 1646 case 0: 1647 chip->master_volume = kctl; 1648 kctl->private_free = snd_es1938_hwv_free; 1649 break; 1650 case 1: 1651 chip->master_switch = kctl; 1652 kctl->private_free = snd_es1938_hwv_free; 1653 break; 1654 case 2: 1655 chip->hw_volume = kctl; 1656 kctl->private_free = snd_es1938_hwv_free; 1657 break; 1658 case 3: 1659 chip->hw_switch = kctl; 1660 kctl->private_free = snd_es1938_hwv_free; 1661 break; 1662 } 1663 if ((err = snd_ctl_add(card, kctl)) < 0) 1664 return err; 1665 } 1666 return 0; 1667 } 1668 1669 1670 static int __devinit snd_es1938_probe(struct pci_dev *pci, 1671 const struct pci_device_id *pci_id) 1672 { 1673 static int dev; 1674 snd_card_t *card; 1675 es1938_t *chip; 1676 opl3_t *opl3; 1677 int idx, err; 1678 1679 if (dev >= SNDRV_CARDS) 1680 return -ENODEV; 1681 if (!enable[dev]) { 1682 dev++; 1683 return -ENOENT; 1684 } 1685 1686 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0); 1687 if (card == NULL) 1688 return -ENOMEM; 1689 for (idx = 0; idx < 5; idx++) { 1690 if (pci_resource_start(pci, idx) == 0 || 1691 !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) { 1692 snd_card_free(card); 1693 return -ENODEV; 1694 } 1695 } 1696 if ((err = snd_es1938_create(card, pci, &chip)) < 0) { 1697 snd_card_free(card); 1698 return err; 1699 } 1700 1701 strcpy(card->driver, "ES1938"); 1702 strcpy(card->shortname, "ESS ES1938 (Solo-1)"); 1703 sprintf(card->longname, "%s rev %i, irq %i", 1704 card->shortname, 1705 chip->revision, 1706 chip->irq); 1707 1708 if ((err = snd_es1938_new_pcm(chip, 0)) < 0) { 1709 snd_card_free(card); 1710 return err; 1711 } 1712 if ((err = snd_es1938_mixer(chip)) < 0) { 1713 snd_card_free(card); 1714 return err; 1715 } 1716 if (snd_opl3_create(card, 1717 SLSB_REG(chip, FMLOWADDR), 1718 SLSB_REG(chip, FMHIGHADDR), 1719 OPL3_HW_OPL3, 1, &opl3) < 0) { 1720 printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n", 1721 SLSB_REG(chip, FMLOWADDR)); 1722 } else { 1723 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) { 1724 snd_card_free(card); 1725 return err; 1726 } 1727 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) { 1728 snd_card_free(card); 1729 return err; 1730 } 1731 } 1732 if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, 1733 chip->mpu_port, 1, chip->irq, 0, &chip->rmidi) < 0) { 1734 printk(KERN_ERR "es1938: unable to initialize MPU-401\n"); 1735 } else { 1736 // this line is vital for MIDI interrupt handling on ess-solo1 1737 // andreas@flying-snail.de 1738 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40); 1739 } 1740 1741 snd_es1938_create_gameport(chip); 1742 1743 if ((err = snd_card_register(card)) < 0) { 1744 snd_card_free(card); 1745 return err; 1746 } 1747 1748 pci_set_drvdata(pci, card); 1749 dev++; 1750 return 0; 1751 } 1752 1753 static void __devexit snd_es1938_remove(struct pci_dev *pci) 1754 { 1755 snd_card_free(pci_get_drvdata(pci)); 1756 pci_set_drvdata(pci, NULL); 1757 } 1758 1759 static struct pci_driver driver = { 1760 .name = "ESS ES1938 (Solo-1)", 1761 .id_table = snd_es1938_ids, 1762 .probe = snd_es1938_probe, 1763 .remove = __devexit_p(snd_es1938_remove), 1764 SND_PCI_PM_CALLBACKS 1765 }; 1766 1767 static int __init alsa_card_es1938_init(void) 1768 { 1769 return pci_register_driver(&driver); 1770 } 1771 1772 static void __exit alsa_card_es1938_exit(void) 1773 { 1774 pci_unregister_driver(&driver); 1775 } 1776 1777 module_init(alsa_card_es1938_init) 1778 module_exit(alsa_card_es1938_exit) 1779