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