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