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