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