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