git.oblomov.eu Git - linux-2.6/blob - sound/pci/es1938.c

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