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 #define SAVED_REG_SIZE  32 /* max. number of registers to save */
 195
 196 struct es1938 {
 197         int irq;
 198
 199         unsigned long io_port;
 200         unsigned long sb_port;
 201         unsigned long vc_port;
 202         unsigned long mpu_port;
 203         unsigned long game_port;
 204         unsigned long ddma_port;
 205
 206         unsigned char irqmask;
 207         unsigned char revision;
 208
 209         struct snd_kcontrol *hw_volume;
 210         struct snd_kcontrol *hw_switch;
 211         struct snd_kcontrol *master_volume;
 212         struct snd_kcontrol *master_switch;
 213
 214         struct pci_dev *pci;
 215         struct snd_card *card;
 216         struct snd_pcm *pcm;
 217         struct snd_pcm_substream *capture_substream;
 218         struct snd_pcm_substream *playback1_substream;
 219         struct snd_pcm_substream *playback2_substream;
 220         struct snd_rawmidi *rmidi;
 221
 222         unsigned int dma1_size;
 223         unsigned int dma2_size;
 224         unsigned int dma1_start;
 225         unsigned int dma2_start;
 226         unsigned int dma1_shift;
 227         unsigned int dma2_shift;
 228         unsigned int active;
 229
 230         spinlock_t reg_lock;
 231         spinlock_t mixer_lock;
 232         struct snd_info_entry *proc_entry;
 233
 234 #ifdef SUPPORT_JOYSTICK
 235         struct gameport *gameport;
 236 #endif
 237 #ifdef CONFIG_PM
 238         unsigned char saved_regs[SAVED_REG_SIZE];
 239 #endif
 240 };
 241
 242 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 243
 244 static struct pci_device_id snd_es1938_ids[] = {
 245         { 0x125d, 0x1969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* Solo-1 */
 246         { 0, }
 247 };
 248
 249 MODULE_DEVICE_TABLE(pci, snd_es1938_ids);
 250
 251 #define RESET_LOOP_TIMEOUT      0x10000
 252 #define WRITE_LOOP_TIMEOUT      0x10000
 253 #define GET_LOOP_TIMEOUT        0x01000
 254
 255 #undef REG_DEBUG
 256 /* -----------------------------------------------------------------
 257  * Write to a mixer register
 258  * -----------------------------------------------------------------*/
 259 static void snd_es1938_mixer_write(struct es1938 *chip, unsigned char reg, unsigned char val)
 260 {
 261         unsigned long flags;
 262         spin_lock_irqsave(&chip->mixer_lock, flags);
 263         outb(reg, SLSB_REG(chip, MIXERADDR));
 264         outb(val, SLSB_REG(chip, MIXERDATA));
 265         spin_unlock_irqrestore(&chip->mixer_lock, flags);
 266 #ifdef REG_DEBUG
 267         snd_printk(KERN_DEBUG "Mixer reg %02x set to %02x\n", reg, val);
 268 #endif
 269 }
 270
 271 /* -----------------------------------------------------------------
 272  * Read from a mixer register
 273  * -----------------------------------------------------------------*/
 274 static int snd_es1938_mixer_read(struct es1938 *chip, unsigned char reg)
 275 {
 276         int data;
 277         unsigned long flags;
 278         spin_lock_irqsave(&chip->mixer_lock, flags);
 279         outb(reg, SLSB_REG(chip, MIXERADDR));
 280         data = inb(SLSB_REG(chip, MIXERDATA));
 281         spin_unlock_irqrestore(&chip->mixer_lock, flags);
 282 #ifdef REG_DEBUG
 283         snd_printk(KERN_DEBUG "Mixer reg %02x now is %02x\n", reg, data);
 284 #endif
 285         return data;
 286 }
 287
 288 /* -----------------------------------------------------------------
 289  * Write to some bits of a mixer register (return old value)
 290  * -----------------------------------------------------------------*/
 291 static int snd_es1938_mixer_bits(struct es1938 *chip, unsigned char reg,
 292                                  unsigned char mask, unsigned char val)
 293 {
 294         unsigned long flags;
 295         unsigned char old, new, oval;
 296         spin_lock_irqsave(&chip->mixer_lock, flags);
 297         outb(reg, SLSB_REG(chip, MIXERADDR));
 298         old = inb(SLSB_REG(chip, MIXERDATA));
 299         oval = old & mask;
 300         if (val != oval) {
 301                 new = (old & ~mask) | (val & mask);
 302                 outb(new, SLSB_REG(chip, MIXERDATA));
 303 #ifdef REG_DEBUG
 304                 snd_printk(KERN_DEBUG "Mixer reg %02x was %02x, set to %02x\n",
 305                            reg, old, new);
 306 #endif
 307         }
 308         spin_unlock_irqrestore(&chip->mixer_lock, flags);
 309         return oval;
 310 }
 311
 312 /* -----------------------------------------------------------------
 313  * Write command to Controller Registers
 314  * -----------------------------------------------------------------*/
 315 static void snd_es1938_write_cmd(struct es1938 *chip, unsigned char cmd)
 316 {
 317         int i;
 318         unsigned char v;
 319         for (i = 0; i < WRITE_LOOP_TIMEOUT; i++) {
 320                 if (!(v = inb(SLSB_REG(chip, READSTATUS)) & 0x80)) {
 321                         outb(cmd, SLSB_REG(chip, WRITEDATA));
 322                         return;
 323                 }
 324         }
 325         printk(KERN_ERR "snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v);
 326 }
 327
 328 /* -----------------------------------------------------------------
 329  * Read the Read Data Buffer
 330  * -----------------------------------------------------------------*/
 331 static int snd_es1938_get_byte(struct es1938 *chip)
 332 {
 333         int i;
 334         unsigned char v;
 335         for (i = GET_LOOP_TIMEOUT; i; i--)
 336                 if ((v = inb(SLSB_REG(chip, STATUS))) & 0x80)
 337                         return inb(SLSB_REG(chip, READDATA));
 338         snd_printk(KERN_ERR "get_byte timeout: status 0x02%x\n", v);
 339         return -ENODEV;
 340 }
 341
 342 /* -----------------------------------------------------------------
 343  * Write value cmd register
 344  * -----------------------------------------------------------------*/
 345 static void snd_es1938_write(struct es1938 *chip, unsigned char reg, unsigned char val)
 346 {
 347         unsigned long flags;
 348         spin_lock_irqsave(&chip->reg_lock, flags);
 349         snd_es1938_write_cmd(chip, reg);
 350         snd_es1938_write_cmd(chip, val);
 351         spin_unlock_irqrestore(&chip->reg_lock, flags);
 352 #ifdef REG_DEBUG
 353         snd_printk(KERN_DEBUG "Reg %02x set to %02x\n", reg, val);
 354 #endif
 355 }
 356
 357 /* -----------------------------------------------------------------
 358  * Read data from cmd register and return it
 359  * -----------------------------------------------------------------*/
 360 static unsigned char snd_es1938_read(struct es1938 *chip, unsigned char reg)
 361 {
 362         unsigned char val;
 363         unsigned long flags;
 364         spin_lock_irqsave(&chip->reg_lock, flags);
 365         snd_es1938_write_cmd(chip, ESS_CMD_READREG);
 366         snd_es1938_write_cmd(chip, reg);
 367         val = snd_es1938_get_byte(chip);
 368         spin_unlock_irqrestore(&chip->reg_lock, flags);
 369 #ifdef REG_DEBUG
 370         snd_printk(KERN_DEBUG "Reg %02x now is %02x\n", reg, val);
 371 #endif
 372         return val;
 373 }
 374
 375 /* -----------------------------------------------------------------
 376  * Write data to cmd register and return old value
 377  * -----------------------------------------------------------------*/
 378 static int snd_es1938_bits(struct es1938 *chip, unsigned char reg, unsigned char mask,
 379                            unsigned char val)
 380 {
 381         unsigned long flags;
 382         unsigned char old, new, oval;
 383         spin_lock_irqsave(&chip->reg_lock, flags);
 384         snd_es1938_write_cmd(chip, ESS_CMD_READREG);
 385         snd_es1938_write_cmd(chip, reg);
 386         old = snd_es1938_get_byte(chip);
 387         oval = old & mask;
 388         if (val != oval) {
 389                 snd_es1938_write_cmd(chip, reg);
 390                 new = (old & ~mask) | (val & mask);
 391                 snd_es1938_write_cmd(chip, new);
 392 #ifdef REG_DEBUG
 393                 snd_printk(KERN_DEBUG "Reg %02x was %02x, set to %02x\n",
 394                            reg, old, new);
 395 #endif
 396         }
 397         spin_unlock_irqrestore(&chip->reg_lock, flags);
 398         return oval;
 399 }
 400
 401 /* --------------------------------------------------------------------
 402  * Reset the chip
 403  * --------------------------------------------------------------------*/
 404 static void snd_es1938_reset(struct es1938 *chip)
 405 {
 406         int i;
 407
 408         outb(3, SLSB_REG(chip, RESET));
 409         inb(SLSB_REG(chip, RESET));
 410         outb(0, SLSB_REG(chip, RESET));
 411         for (i = 0; i < RESET_LOOP_TIMEOUT; i++) {
 412                 if (inb(SLSB_REG(chip, STATUS)) & 0x80) {
 413                         if (inb(SLSB_REG(chip, READDATA)) == 0xaa)
 414                                 goto __next;
 415                 }
 416         }
 417         snd_printk(KERN_ERR "ESS Solo-1 reset failed\n");
 418
 419      __next:
 420         snd_es1938_write_cmd(chip, ESS_CMD_ENABLEEXT);
 421
 422         /* Demand transfer DMA: 4 bytes per DMA request */
 423         snd_es1938_write(chip, ESS_CMD_DMATYPE, 2);
 424
 425         /* Change behaviour of register A1
 426            4x oversampling
 427            2nd channel DAC asynchronous */
 428         snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2MODE, 0x32);
 429         /* enable/select DMA channel and IRQ channel */
 430         snd_es1938_bits(chip, ESS_CMD_IRQCONTROL, 0xf0, 0x50);
 431         snd_es1938_bits(chip, ESS_CMD_DRQCONTROL, 0xf0, 0x50);
 432         snd_es1938_write_cmd(chip, ESS_CMD_ENABLEAUDIO1);
 433         /* Set spatializer parameters to recommended values */
 434         snd_es1938_mixer_write(chip, 0x54, 0x8f);
 435         snd_es1938_mixer_write(chip, 0x56, 0x95);
 436         snd_es1938_mixer_write(chip, 0x58, 0x94);
 437         snd_es1938_mixer_write(chip, 0x5a, 0x80);
 438 }
 439
 440 /* --------------------------------------------------------------------
 441  * Reset the FIFOs
 442  * --------------------------------------------------------------------*/
 443 static void snd_es1938_reset_fifo(struct es1938 *chip)
 444 {
 445         outb(2, SLSB_REG(chip, RESET));
 446         outb(0, SLSB_REG(chip, RESET));
 447 }
 448
 449 static struct snd_ratnum clocks[2] = {
 450         {
 451                 .num = 793800,
 452                 .den_min = 1,
 453                 .den_max = 128,
 454                 .den_step = 1,
 455         },
 456         {
 457                 .num = 768000,
 458                 .den_min = 1,
 459                 .den_max = 128,
 460                 .den_step = 1,
 461         }
 462 };
 463
 464 static struct snd_pcm_hw_constraint_ratnums hw_constraints_clocks = {
 465         .nrats = 2,
 466         .rats = clocks,
 467 };
 468
 469
 470 static void snd_es1938_rate_set(struct es1938 *chip,
 471                                 struct snd_pcm_substream *substream,
 472                                 int mode)
 473 {
 474         unsigned int bits, div0;
 475         struct snd_pcm_runtime *runtime = substream->runtime;
 476         if (runtime->rate_num == clocks[0].num)
 477                 bits = 128 - runtime->rate_den;
 478         else
 479                 bits = 256 - runtime->rate_den;
 480
 481         /* set filter register */
 482         div0 = 256 - 7160000*20/(8*82*runtime->rate);
 483
 484         if (mode == DAC2) {
 485                 snd_es1938_mixer_write(chip, 0x70, bits);
 486                 snd_es1938_mixer_write(chip, 0x72, div0);
 487         } else {
 488                 snd_es1938_write(chip, 0xA1, bits);
 489                 snd_es1938_write(chip, 0xA2, div0);
 490         }
 491 }
 492
 493 /* --------------------------------------------------------------------
 494  * Configure Solo1 builtin DMA Controller
 495  * --------------------------------------------------------------------*/
 496
 497 static void snd_es1938_playback1_setdma(struct es1938 *chip)
 498 {
 499         outb(0x00, SLIO_REG(chip, AUDIO2MODE));
 500         outl(chip->dma2_start, SLIO_REG(chip, AUDIO2DMAADDR));
 501         outw(0, SLIO_REG(chip, AUDIO2DMACOUNT));
 502         outw(chip->dma2_size, SLIO_REG(chip, AUDIO2DMACOUNT));
 503 }
 504
 505 static void snd_es1938_playback2_setdma(struct es1938 *chip)
 506 {
 507         /* Enable DMA controller */
 508         outb(0xc4, SLDM_REG(chip, DMACOMMAND));
 509         /* 1. Master reset */
 510         outb(0, SLDM_REG(chip, DMACLEAR));
 511         /* 2. Mask DMA */
 512         outb(1, SLDM_REG(chip, DMAMASK));
 513         outb(0x18, SLDM_REG(chip, DMAMODE));
 514         outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
 515         outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
 516         /* 3. Unmask DMA */
 517         outb(0, SLDM_REG(chip, DMAMASK));
 518 }
 519
 520 static void snd_es1938_capture_setdma(struct es1938 *chip)
 521 {
 522         /* Enable DMA controller */
 523         outb(0xc4, SLDM_REG(chip, DMACOMMAND));
 524         /* 1. Master reset */
 525         outb(0, SLDM_REG(chip, DMACLEAR));
 526         /* 2. Mask DMA */
 527         outb(1, SLDM_REG(chip, DMAMASK));
 528         outb(0x14, SLDM_REG(chip, DMAMODE));
 529         outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
 530         outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
 531         /* 3. Unmask DMA */
 532         outb(0, SLDM_REG(chip, DMAMASK));
 533 }
 534
 535 /* ----------------------------------------------------------------------
 536  *
 537  *                           *** PCM part ***
 538  */
 539
 540 static int snd_es1938_capture_trigger(struct snd_pcm_substream *substream,
 541                                       int cmd)
 542 {
 543         struct es1938 *chip = snd_pcm_substream_chip(substream);
 544         int val;
 545         switch (cmd) {
 546         case SNDRV_PCM_TRIGGER_START:
 547         case SNDRV_PCM_TRIGGER_RESUME:
 548                 val = 0x0f;
 549                 chip->active |= ADC1;
 550                 break;
 551         case SNDRV_PCM_TRIGGER_STOP:
 552         case SNDRV_PCM_TRIGGER_SUSPEND:
 553                 val = 0x00;
 554                 chip->active &= ~ADC1;
 555                 break;
 556         default:
 557                 return -EINVAL;
 558         }
 559         snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
 560         return 0;
 561 }
 562
 563 static int snd_es1938_playback1_trigger(struct snd_pcm_substream *substream,
 564                                         int cmd)
 565 {
 566         struct es1938 *chip = snd_pcm_substream_chip(substream);
 567         switch (cmd) {
 568         case SNDRV_PCM_TRIGGER_START:
 569         case SNDRV_PCM_TRIGGER_RESUME:
 570                 /* According to the documentation this should be:
 571                    0x13 but that value may randomly swap stereo channels */
 572                 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x92);
 573                 udelay(10);
 574                 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x93);
 575                 /* This two stage init gives the FIFO -> DAC connection time to
 576                  * settle before first data from DMA flows in.  This should ensure
 577                  * no swapping of stereo channels.  Report a bug if otherwise :-) */
 578                 outb(0x0a, SLIO_REG(chip, AUDIO2MODE));
 579                 chip->active |= DAC2;
 580                 break;
 581         case SNDRV_PCM_TRIGGER_STOP:
 582         case SNDRV_PCM_TRIGGER_SUSPEND:
 583                 outb(0, SLIO_REG(chip, AUDIO2MODE));
 584                 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0);
 585                 chip->active &= ~DAC2;
 586                 break;
 587         default:
 588                 return -EINVAL;
 589         }
 590         return 0;
 591 }
 592
 593 static int snd_es1938_playback2_trigger(struct snd_pcm_substream *substream,
 594                                         int cmd)
 595 {
 596         struct es1938 *chip = snd_pcm_substream_chip(substream);
 597         int val;
 598         switch (cmd) {
 599         case SNDRV_PCM_TRIGGER_START:
 600         case SNDRV_PCM_TRIGGER_RESUME:
 601                 val = 5;
 602                 chip->active |= DAC1;
 603                 break;
 604         case SNDRV_PCM_TRIGGER_STOP:
 605         case SNDRV_PCM_TRIGGER_SUSPEND:
 606                 val = 0;
 607                 chip->active &= ~DAC1;
 608                 break;
 609         default:
 610                 return -EINVAL;
 611         }
 612         snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
 613         return 0;
 614 }
 615
 616 static int snd_es1938_playback_trigger(struct snd_pcm_substream *substream,
 617                                        int cmd)
 618 {
 619         switch (substream->number) {
 620         case 0:
 621                 return snd_es1938_playback1_trigger(substream, cmd);
 622         case 1:
 623                 return snd_es1938_playback2_trigger(substream, cmd);
 624         }
 625         snd_BUG();
 626         return -EINVAL;
 627 }
 628
 629 /* --------------------------------------------------------------------
 630  * First channel for Extended Mode Audio 1 ADC Operation
 631  * --------------------------------------------------------------------*/
 632 static int snd_es1938_capture_prepare(struct snd_pcm_substream *substream)
 633 {
 634         struct es1938 *chip = snd_pcm_substream_chip(substream);
 635         struct snd_pcm_runtime *runtime = substream->runtime;
 636         int u, is8, mono;
 637         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
 638         unsigned int count = snd_pcm_lib_period_bytes(substream);
 639
 640         chip->dma1_size = size;
 641         chip->dma1_start = runtime->dma_addr;
 642
 643         mono = (runtime->channels > 1) ? 0 : 1;
 644         is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
 645         u = snd_pcm_format_unsigned(runtime->format);
 646
 647         chip->dma1_shift = 2 - mono - is8;
 648
 649         snd_es1938_reset_fifo(chip);
 650
 651         /* program type */
 652         snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
 653
 654         /* set clock and counters */
 655         snd_es1938_rate_set(chip, substream, ADC1);
 656
 657         count = 0x10000 - count;
 658         snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
 659         snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
 660
 661         /* initialize and configure ADC */
 662         snd_es1938_write(chip, ESS_CMD_SETFORMAT2, u ? 0x51 : 0x71);
 663         snd_es1938_write(chip, ESS_CMD_SETFORMAT2, 0x90 |
 664                        (u ? 0x00 : 0x20) |
 665                        (is8 ? 0x00 : 0x04) |
 666                        (mono ? 0x40 : 0x08));
 667
 668         //      snd_es1938_reset_fifo(chip);
 669
 670         /* 11. configure system interrupt controller and DMA controller */
 671         snd_es1938_capture_setdma(chip);
 672
 673         return 0;
 674 }
 675
 676
 677 /* ------------------------------------------------------------------------------
 678  * Second Audio channel DAC Operation
 679  * ------------------------------------------------------------------------------*/
 680 static int snd_es1938_playback1_prepare(struct snd_pcm_substream *substream)
 681 {
 682         struct es1938 *chip = snd_pcm_substream_chip(substream);
 683         struct snd_pcm_runtime *runtime = substream->runtime;
 684         int u, is8, mono;
 685         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
 686         unsigned int count = snd_pcm_lib_period_bytes(substream);
 687
 688         chip->dma2_size = size;
 689         chip->dma2_start = runtime->dma_addr;
 690
 691         mono = (runtime->channels > 1) ? 0 : 1;
 692         is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
 693         u = snd_pcm_format_unsigned(runtime->format);
 694
 695         chip->dma2_shift = 2 - mono - is8;
 696
 697         snd_es1938_reset_fifo(chip);
 698
 699         /* set clock and counters */
 700         snd_es1938_rate_set(chip, substream, DAC2);
 701
 702         count >>= 1;
 703         count = 0x10000 - count;
 704         snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTL, count & 0xff);
 705         snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTH, count >> 8);
 706
 707         /* initialize and configure Audio 2 DAC */
 708         snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) |
 709                                (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(struct snd_pcm_substream *substream)
 718 {
 719         struct es1938 *chip = snd_pcm_substream_chip(substream);
 720         struct snd_pcm_runtime *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(struct snd_pcm_substream *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(struct snd_pcm_substream *substream)
 772 {
 773         struct es1938 *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(struct snd_pcm_substream *substream)
 789 {
 790         struct es1938 *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(struct snd_pcm_substream *substream)
 801 {
 802         struct es1938 *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(struct snd_pcm_substream *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(struct snd_pcm_substream *substream,
 830                                    int channel,
 831                                    snd_pcm_uframes_t pos,
 832                                    void __user *dst,
 833                                    snd_pcm_uframes_t count)
 834 {
 835         struct snd_pcm_runtime *runtime = substream->runtime;
 836         struct es1938 *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(struct snd_pcm_substream *substream,
 856                                     struct snd_pcm_hw_params *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(struct snd_pcm_substream *substream)
 867 {
 868         return snd_pcm_lib_free_pages(substream);
 869 }
 870
 871 /* ----------------------------------------------------------------------
 872  * Audio1 Capture (ADC)
 873  * ----------------------------------------------------------------------*/
 874 static struct snd_pcm_hardware 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 |
 879                                  SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
 880         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
 881         .rate_min =             6000,
 882         .rate_max =             48000,
 883         .channels_min =         1,
 884         .channels_max =         2,
 885         .buffer_bytes_max =     0x8000,       /* DMA controller screws on higher values */
 886         .period_bytes_min =     64,
 887         .period_bytes_max =     0x8000,
 888         .periods_min =          1,
 889         .periods_max =          1024,
 890         .fifo_size =            256,
 891 };
 892
 893 /* -----------------------------------------------------------------------
 894  * Audio2 Playback (DAC)
 895  * -----------------------------------------------------------------------*/
 896 static struct snd_pcm_hardware snd_es1938_playback =
 897 {
 898         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
 899                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
 900                                  SNDRV_PCM_INFO_MMAP_VALID),
 901         .formats =              (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
 902                                  SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
 903         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
 904         .rate_min =             6000,
 905         .rate_max =             48000,
 906         .channels_min =         1,
 907         .channels_max =         2,
 908         .buffer_bytes_max =     0x8000,       /* DMA controller screws on higher values */
 909         .period_bytes_min =     64,
 910         .period_bytes_max =     0x8000,
 911         .periods_min =          1,
 912         .periods_max =          1024,
 913         .fifo_size =            256,
 914 };
 915
 916 static int snd_es1938_capture_open(struct snd_pcm_substream *substream)
 917 {
 918         struct es1938 *chip = snd_pcm_substream_chip(substream);
 919         struct snd_pcm_runtime *runtime = substream->runtime;
 920
 921         if (chip->playback2_substream)
 922                 return -EAGAIN;
 923         chip->capture_substream = substream;
 924         runtime->hw = snd_es1938_capture;
 925         snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 926                                       &hw_constraints_clocks);
 927         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
 928         return 0;
 929 }
 930
 931 static int snd_es1938_playback_open(struct snd_pcm_substream *substream)
 932 {
 933         struct es1938 *chip = snd_pcm_substream_chip(substream);
 934         struct snd_pcm_runtime *runtime = substream->runtime;
 935
 936         switch (substream->number) {
 937         case 0:
 938                 chip->playback1_substream = substream;
 939                 break;
 940         case 1:
 941                 if (chip->capture_substream)
 942                         return -EAGAIN;
 943                 chip->playback2_substream = substream;
 944                 break;
 945         default:
 946                 snd_BUG();
 947                 return -EINVAL;
 948         }
 949         runtime->hw = snd_es1938_playback;
 950         snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 951                                       &hw_constraints_clocks);
 952         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
 953         return 0;
 954 }
 955
 956 static int snd_es1938_capture_close(struct snd_pcm_substream *substream)
 957 {
 958         struct es1938 *chip = snd_pcm_substream_chip(substream);
 959
 960         chip->capture_substream = NULL;
 961         return 0;
 962 }
 963
 964 static int snd_es1938_playback_close(struct snd_pcm_substream *substream)
 965 {
 966         struct es1938 *chip = snd_pcm_substream_chip(substream);
 967
 968         switch (substream->number) {
 969         case 0:
 970                 chip->playback1_substream = NULL;
 971                 break;
 972         case 1:
 973                 chip->playback2_substream = NULL;
 974                 break;
 975         default:
 976                 snd_BUG();
 977                 return -EINVAL;
 978         }
 979         return 0;
 980 }
 981
 982 static struct snd_pcm_ops snd_es1938_playback_ops = {
 983         .open =         snd_es1938_playback_open,
 984         .close =        snd_es1938_playback_close,
 985         .ioctl =        snd_pcm_lib_ioctl,
 986         .hw_params =    snd_es1938_pcm_hw_params,
 987         .hw_free =      snd_es1938_pcm_hw_free,
 988         .prepare =      snd_es1938_playback_prepare,
 989         .trigger =      snd_es1938_playback_trigger,
 990         .pointer =      snd_es1938_playback_pointer,
 991 };
 992
 993 static struct snd_pcm_ops snd_es1938_capture_ops = {
 994         .open =         snd_es1938_capture_open,
 995         .close =        snd_es1938_capture_close,
 996         .ioctl =        snd_pcm_lib_ioctl,
 997         .hw_params =    snd_es1938_pcm_hw_params,
 998         .hw_free =      snd_es1938_pcm_hw_free,
 999         .prepare =      snd_es1938_capture_prepare,
1000         .trigger =      snd_es1938_capture_trigger,
1001         .pointer =      snd_es1938_capture_pointer,
1002         .copy =         snd_es1938_capture_copy,
1003 };
1004
1005 static int __devinit snd_es1938_new_pcm(struct es1938 *chip, int device)
1006 {
1007         struct snd_pcm *pcm;
1008         int err;
1009
1010         if ((err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm)) < 0)
1011                 return err;
1012         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1938_playback_ops);
1013         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1938_capture_ops);
1014
1015         pcm->private_data = chip;
1016         pcm->info_flags = 0;
1017         strcpy(pcm->name, "ESS Solo-1");
1018
1019         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1020                                               snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
1021
1022         chip->pcm = pcm;
1023         return 0;
1024 }
1025
1026 /* -------------------------------------------------------------------
1027  *
1028  *                       *** Mixer part ***
1029  */
1030
1031 static int snd_es1938_info_mux(struct snd_kcontrol *kcontrol,
1032                                struct snd_ctl_elem_info *uinfo)
1033 {
1034         static char *texts[8] = {
1035                 "Mic", "Mic Master", "CD", "AOUT",
1036                 "Mic1", "Mix", "Line", "Master"
1037         };
1038
1039         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1040         uinfo->count = 1;
1041         uinfo->value.enumerated.items = 8;
1042         if (uinfo->value.enumerated.item > 7)
1043                 uinfo->value.enumerated.item = 7;
1044         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1045         return 0;
1046 }
1047
1048 static int snd_es1938_get_mux(struct snd_kcontrol *kcontrol,
1049                               struct snd_ctl_elem_value *ucontrol)
1050 {
1051         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1052         ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07;
1053         return 0;
1054 }
1055
1056 static int snd_es1938_put_mux(struct snd_kcontrol *kcontrol,
1057                               struct snd_ctl_elem_value *ucontrol)
1058 {
1059         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1060         unsigned char val = ucontrol->value.enumerated.item[0];
1061
1062         if (val > 7)
1063                 return -EINVAL;
1064         return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val;
1065 }
1066
1067 static int snd_es1938_info_spatializer_enable(struct snd_kcontrol *kcontrol,
1068                                               struct snd_ctl_elem_info *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(struct snd_kcontrol *kcontrol,
1078                                              struct snd_ctl_elem_value *ucontrol)
1079 {
1080         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1081         unsigned char val = snd_es1938_mixer_read(chip, 0x50);
1082         ucontrol->value.integer.value[0] = !!(val & 8);
1083         return 0;
1084 }
1085
1086 static int snd_es1938_put_spatializer_enable(struct snd_kcontrol *kcontrol,
1087                                              struct snd_ctl_elem_value *ucontrol)
1088 {
1089         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1090         unsigned char oval, nval;
1091         int change;
1092         nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04;
1093         oval = snd_es1938_mixer_read(chip, 0x50) & 0x0c;
1094         change = nval != oval;
1095         if (change) {
1096                 snd_es1938_mixer_write(chip, 0x50, nval & ~0x04);
1097                 snd_es1938_mixer_write(chip, 0x50, nval);
1098         }
1099         return change;
1100 }
1101
1102 static int snd_es1938_info_hw_volume(struct snd_kcontrol *kcontrol,
1103                                      struct snd_ctl_elem_info *uinfo)
1104 {
1105         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1106         uinfo->count = 2;
1107         uinfo->value.integer.min = 0;
1108         uinfo->value.integer.max = 63;
1109         return 0;
1110 }
1111
1112 static int snd_es1938_get_hw_volume(struct snd_kcontrol *kcontrol,
1113                                     struct snd_ctl_elem_value *ucontrol)
1114 {
1115         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1116         ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f;
1117         ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f;
1118         return 0;
1119 }
1120
1121 static int snd_es1938_info_hw_switch(struct snd_kcontrol *kcontrol,
1122                                      struct snd_ctl_elem_info *uinfo)
1123 {
1124         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1125         uinfo->count = 2;
1126         uinfo->value.integer.min = 0;
1127         uinfo->value.integer.max = 1;
1128         return 0;
1129 }
1130
1131 static int snd_es1938_get_hw_switch(struct snd_kcontrol *kcontrol,
1132                                     struct snd_ctl_elem_value *ucontrol)
1133 {
1134         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1135         ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40);
1136         ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40);
1137         return 0;
1138 }
1139
1140 static void snd_es1938_hwv_free(struct snd_kcontrol *kcontrol)
1141 {
1142         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1143         chip->master_volume = NULL;
1144         chip->master_switch = NULL;
1145         chip->hw_volume = NULL;
1146         chip->hw_switch = NULL;
1147 }
1148
1149 static int snd_es1938_reg_bits(struct es1938 *chip, unsigned char reg,
1150                                unsigned char mask, unsigned char val)
1151 {
1152         if (reg < 0xa0)
1153                 return snd_es1938_mixer_bits(chip, reg, mask, val);
1154         else
1155                 return snd_es1938_bits(chip, reg, mask, val);
1156 }
1157
1158 static int snd_es1938_reg_read(struct es1938 *chip, unsigned char reg)
1159 {
1160         if (reg < 0xa0)
1161                 return snd_es1938_mixer_read(chip, reg);
1162         else
1163                 return snd_es1938_read(chip, reg);
1164 }
1165
1166 #define ES1938_SINGLE(xname, xindex, reg, shift, mask, invert) \
1167 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1168   .info = snd_es1938_info_single, \
1169   .get = snd_es1938_get_single, .put = snd_es1938_put_single, \
1170   .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
1171
1172 static int snd_es1938_info_single(struct snd_kcontrol *kcontrol,
1173                                   struct snd_ctl_elem_info *uinfo)
1174 {
1175         int mask = (kcontrol->private_value >> 16) & 0xff;
1176
1177         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1178         uinfo->count = 1;
1179         uinfo->value.integer.min = 0;
1180         uinfo->value.integer.max = mask;
1181         return 0;
1182 }
1183
1184 static int snd_es1938_get_single(struct snd_kcontrol *kcontrol,
1185                                  struct snd_ctl_elem_value *ucontrol)
1186 {
1187         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1188         int reg = kcontrol->private_value & 0xff;
1189         int shift = (kcontrol->private_value >> 8) & 0xff;
1190         int mask = (kcontrol->private_value >> 16) & 0xff;
1191         int invert = (kcontrol->private_value >> 24) & 0xff;
1192         int val;
1193
1194         val = snd_es1938_reg_read(chip, reg);
1195         ucontrol->value.integer.value[0] = (val >> shift) & mask;
1196         if (invert)
1197                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1198         return 0;
1199 }
1200
1201 static int snd_es1938_put_single(struct snd_kcontrol *kcontrol,
1202                                  struct snd_ctl_elem_value *ucontrol)
1203 {
1204         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1205         int reg = kcontrol->private_value & 0xff;
1206         int shift = (kcontrol->private_value >> 8) & 0xff;
1207         int mask = (kcontrol->private_value >> 16) & 0xff;
1208         int invert = (kcontrol->private_value >> 24) & 0xff;
1209         unsigned char val;
1210
1211         val = (ucontrol->value.integer.value[0] & mask);
1212         if (invert)
1213                 val = mask - val;
1214         mask <<= shift;
1215         val <<= shift;
1216         return snd_es1938_reg_bits(chip, reg, mask, val) != val;
1217 }
1218
1219 #define ES1938_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1220 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .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
1225 static int snd_es1938_info_double(struct snd_kcontrol *kcontrol,
1226                                   struct snd_ctl_elem_info *uinfo)
1227 {
1228         int mask = (kcontrol->private_value >> 24) & 0xff;
1229
1230         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1231         uinfo->count = 2;
1232         uinfo->value.integer.min = 0;
1233         uinfo->value.integer.max = mask;
1234         return 0;
1235 }
1236
1237 static int snd_es1938_get_double(struct snd_kcontrol *kcontrol,
1238                                  struct snd_ctl_elem_value *ucontrol)
1239 {
1240         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1241         int left_reg = kcontrol->private_value & 0xff;
1242         int right_reg = (kcontrol->private_value >> 8) & 0xff;
1243         int shift_left = (kcontrol->private_value >> 16) & 0x07;
1244         int shift_right = (kcontrol->private_value >> 19) & 0x07;
1245         int mask = (kcontrol->private_value >> 24) & 0xff;
1246         int invert = (kcontrol->private_value >> 22) & 1;
1247         unsigned char left, right;
1248
1249         left = snd_es1938_reg_read(chip, left_reg);
1250         if (left_reg != right_reg)
1251                 right = snd_es1938_reg_read(chip, right_reg);
1252         else
1253                 right = left;
1254         ucontrol->value.integer.value[0] = (left >> shift_left) & mask;
1255         ucontrol->value.integer.value[1] = (right >> shift_right) & mask;
1256         if (invert) {
1257                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1258                 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
1259         }
1260         return 0;
1261 }
1262
1263 static int snd_es1938_put_double(struct snd_kcontrol *kcontrol,
1264                                  struct snd_ctl_elem_value *ucontrol)
1265 {
1266         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1267         int left_reg = kcontrol->private_value & 0xff;
1268         int right_reg = (kcontrol->private_value >> 8) & 0xff;
1269         int shift_left = (kcontrol->private_value >> 16) & 0x07;
1270         int shift_right = (kcontrol->private_value >> 19) & 0x07;
1271         int mask = (kcontrol->private_value >> 24) & 0xff;
1272         int invert = (kcontrol->private_value >> 22) & 1;
1273         int change;
1274         unsigned char val1, val2, mask1, mask2;
1275
1276         val1 = ucontrol->value.integer.value[0] & mask;
1277         val2 = ucontrol->value.integer.value[1] & mask;
1278         if (invert) {
1279                 val1 = mask - val1;
1280                 val2 = mask - val2;
1281         }
1282         val1 <<= shift_left;
1283         val2 <<= shift_right;
1284         mask1 = mask << shift_left;
1285         mask2 = mask << shift_right;
1286         if (left_reg != right_reg) {
1287                 change = 0;
1288                 if (snd_es1938_reg_bits(chip, left_reg, mask1, val1) != val1)
1289                         change = 1;
1290                 if (snd_es1938_reg_bits(chip, right_reg, mask2, val2) != val2)
1291                         change = 1;
1292         } else {
1293                 change = (snd_es1938_reg_bits(chip, left_reg, mask1 | mask2,
1294                                               val1 | val2) != (val1 | val2));
1295         }
1296         return change;
1297 }
1298
1299 static struct snd_kcontrol_new snd_es1938_controls[] = {
1300 ES1938_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0),
1301 ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1),
1302 {
1303         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1304         .name = "Hardware Master Playback Volume",
1305         .access = SNDRV_CTL_ELEM_ACCESS_READ,
1306         .info = snd_es1938_info_hw_volume,
1307         .get = snd_es1938_get_hw_volume,
1308 },
1309 {
1310         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1311         .name = "Hardware Master Playback Switch",
1312         .access = SNDRV_CTL_ELEM_ACCESS_READ,
1313         .info = snd_es1938_info_hw_switch,
1314         .get = snd_es1938_get_hw_switch,
1315 },
1316 ES1938_SINGLE("Hardware Volume Split", 0, 0x64, 7, 1, 0),
1317 ES1938_DOUBLE("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0),
1318 ES1938_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0),
1319 ES1938_DOUBLE("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0),
1320 ES1938_DOUBLE("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1321 ES1938_DOUBLE("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0),
1322 ES1938_DOUBLE("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0),
1323 ES1938_DOUBLE("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0),
1324 ES1938_SINGLE("PC Speaker Volume", 0, 0x3c, 0, 7, 0),
1325 ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
1326 ES1938_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1),
1327 {
1328         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1329         .name = "Capture Source",
1330         .info = snd_es1938_info_mux,
1331         .get = snd_es1938_get_mux,
1332         .put = snd_es1938_put_mux,
1333 },
1334 ES1938_DOUBLE("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1335 ES1938_DOUBLE("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0),
1336 ES1938_DOUBLE("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0),
1337 ES1938_DOUBLE("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0),
1338 ES1938_DOUBLE("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0),
1339 ES1938_DOUBLE("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0),
1340 ES1938_DOUBLE("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0),
1341 ES1938_DOUBLE("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0),
1342 ES1938_DOUBLE("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0),
1343 ES1938_DOUBLE("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0),
1344 ES1938_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0),
1345 {
1346         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1347         .name = "3D Control - Switch",
1348         .info = snd_es1938_info_spatializer_enable,
1349         .get = snd_es1938_get_spatializer_enable,
1350         .put = snd_es1938_put_spatializer_enable,
1351 },
1352 ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0)
1353 };
1354
1355
1356 /* ---------------------------------------------------------------------------- */
1357 /* ---------------------------------------------------------------------------- */
1358
1359 /*
1360  * initialize the chip - used by resume callback, too
1361  */
1362 static void snd_es1938_chip_init(struct es1938 *chip)
1363 {
1364         /* reset chip */
1365         snd_es1938_reset(chip);
1366
1367         /* configure native mode */
1368
1369         /* enable bus master */
1370         pci_set_master(chip->pci);
1371
1372         /* disable legacy audio */
1373         pci_write_config_word(chip->pci, SL_PCI_LEGACYCONTROL, 0x805f);
1374
1375         /* set DDMA base */
1376         pci_write_config_word(chip->pci, SL_PCI_DDMACONTROL, chip->ddma_port | 1);
1377
1378         /* set DMA/IRQ policy */
1379         pci_write_config_dword(chip->pci, SL_PCI_CONFIG, 0);
1380
1381         /* enable Audio 1, Audio 2, MPU401 IRQ and HW volume IRQ*/
1382         outb(0xf0, SLIO_REG(chip, IRQCONTROL));
1383
1384         /* reset DMA */
1385         outb(0, SLDM_REG(chip, DMACLEAR));
1386 }
1387
1388 #ifdef CONFIG_PM
1389 /*
1390  * PM support
1391  */
1392
1393 static unsigned char saved_regs[SAVED_REG_SIZE+1] = {
1394         0x14, 0x1a, 0x1c, 0x3a, 0x3c, 0x3e, 0x36, 0x38,
1395         0x50, 0x52, 0x60, 0x61, 0x62, 0x63, 0x64, 0x68,
1396         0x69, 0x6a, 0x6b, 0x6d, 0x6e, 0x6f, 0x7c, 0x7d,
1397         0xa8, 0xb4,
1398 };
1399
1400
1401 static int es1938_suspend(struct pci_dev *pci, pm_message_t state)
1402 {
1403         struct snd_card *card = pci_get_drvdata(pci);
1404         struct es1938 *chip = card->private_data;
1405         unsigned char *s, *d;
1406
1407         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1408         snd_pcm_suspend_all(chip->pcm);
1409
1410         /* save mixer-related registers */
1411         for (s = saved_regs, d = chip->saved_regs; *s; s++, d++)
1412                 *d = snd_es1938_reg_read(chip, *s);
1413
1414         outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */
1415         if (chip->irq >= 0)
1416                 free_irq(chip->irq, chip);
1417         pci_disable_device(pci);
1418         pci_save_state(pci);
1419         return 0;
1420 }
1421
1422 static int es1938_resume(struct pci_dev *pci)
1423 {
1424         struct snd_card *card = pci_get_drvdata(pci);
1425         struct es1938 *chip = card->private_data;
1426         unsigned char *s, *d;
1427
1428         pci_restore_state(pci);
1429         pci_enable_device(pci);
1430         request_irq(pci->irq, snd_es1938_interrupt,
1431                     SA_INTERRUPT|SA_SHIRQ, "ES1938", chip);
1432         chip->irq = pci->irq;
1433         snd_es1938_chip_init(chip);
1434
1435         /* restore mixer-related registers */
1436         for (s = saved_regs, d = chip->saved_regs; *s; s++, d++) {
1437                 if (*s < 0xa0)
1438                         snd_es1938_mixer_write(chip, *s, *d);
1439                 else
1440                         snd_es1938_write(chip, *s, *d);
1441         }
1442
1443         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1444         return 0;
1445 }
1446 #endif /* CONFIG_PM */
1447
1448 #ifdef SUPPORT_JOYSTICK
1449 static int __devinit snd_es1938_create_gameport(struct es1938 *chip)
1450 {
1451         struct gameport *gp;
1452
1453         chip->gameport = gp = gameport_allocate_port();
1454         if (!gp) {
1455                 printk(KERN_ERR "es1938: cannot allocate memory for gameport\n");
1456                 return -ENOMEM;
1457         }
1458
1459         gameport_set_name(gp, "ES1938");
1460         gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
1461         gameport_set_dev_parent(gp, &chip->pci->dev);
1462         gp->io = chip->game_port;
1463
1464         gameport_register_port(gp);
1465
1466         return 0;
1467 }
1468
1469 static void snd_es1938_free_gameport(struct es1938 *chip)
1470 {
1471         if (chip->gameport) {
1472                 gameport_unregister_port(chip->gameport);
1473                 chip->gameport = NULL;
1474         }
1475 }
1476 #else
1477 static inline int snd_es1938_create_gameport(struct es1938 *chip) { return -ENOSYS; }
1478 static inline void snd_es1938_free_gameport(struct es1938 *chip) { }
1479 #endif /* SUPPORT_JOYSTICK */
1480
1481 static int snd_es1938_free(struct es1938 *chip)
1482 {
1483         /* disable irqs */
1484         outb(0x00, SLIO_REG(chip, IRQCONTROL));
1485         if (chip->rmidi)
1486                 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0);
1487
1488         snd_es1938_free_gameport(chip);
1489
1490         if (chip->irq >= 0)
1491                 free_irq(chip->irq, chip);
1492         pci_release_regions(chip->pci);
1493         pci_disable_device(chip->pci);
1494         kfree(chip);
1495         return 0;
1496 }
1497
1498 static int snd_es1938_dev_free(struct snd_device *device)
1499 {
1500         struct es1938 *chip = device->device_data;
1501         return snd_es1938_free(chip);
1502 }
1503
1504 static int __devinit snd_es1938_create(struct snd_card *card,
1505                                     struct pci_dev * pci,
1506                                     struct es1938 ** rchip)
1507 {
1508         struct es1938 *chip;
1509         int err;
1510         static struct snd_device_ops ops = {
1511                 .dev_free =     snd_es1938_dev_free,
1512         };
1513
1514         *rchip = NULL;
1515
1516         /* enable PCI device */
1517         if ((err = pci_enable_device(pci)) < 0)
1518                 return err;
1519         /* check, if we can restrict PCI DMA transfers to 24 bits */
1520         if (pci_set_dma_mask(pci, 0x00ffffff) < 0 ||
1521             pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) {
1522                 snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
1523                 pci_disable_device(pci);
1524                 return -ENXIO;
1525         }
1526
1527         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1528         if (chip == NULL) {
1529                 pci_disable_device(pci);
1530                 return -ENOMEM;
1531         }
1532         spin_lock_init(&chip->reg_lock);
1533         spin_lock_init(&chip->mixer_lock);
1534         chip->card = card;
1535         chip->pci = pci;
1536         if ((err = pci_request_regions(pci, "ESS Solo-1")) < 0) {
1537                 kfree(chip);
1538                 pci_disable_device(pci);
1539                 return err;
1540         }
1541         chip->io_port = pci_resource_start(pci, 0);
1542         chip->sb_port = pci_resource_start(pci, 1);
1543         chip->vc_port = pci_resource_start(pci, 2);
1544         chip->mpu_port = pci_resource_start(pci, 3);
1545         chip->game_port = pci_resource_start(pci, 4);
1546         if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ,
1547                         "ES1938", chip)) {
1548                 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
1549                 snd_es1938_free(chip);
1550                 return -EBUSY;
1551         }
1552         chip->irq = pci->irq;
1553 #ifdef ES1938_DDEBUG
1554         snd_printk(KERN_DEBUG "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
1555                    chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1556 #endif
1557
1558         chip->ddma_port = chip->vc_port + 0x00;         /* fix from Thomas Sailer */
1559
1560         snd_es1938_chip_init(chip);
1561
1562         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1563                 snd_es1938_free(chip);
1564                 return err;
1565         }
1566
1567         snd_card_set_dev(card, &pci->dev);
1568
1569         *rchip = chip;
1570         return 0;
1571 }
1572
1573 /* --------------------------------------------------------------------
1574  * Interrupt handler
1575  * -------------------------------------------------------------------- */
1576 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1577 {
1578         struct es1938 *chip = dev_id;
1579         unsigned char status, audiostatus;
1580         int handled = 0;
1581
1582         status = inb(SLIO_REG(chip, IRQCONTROL));
1583 #if 0
1584         printk("Es1938debug - interrupt status: =0x%x\n", status);
1585 #endif
1586
1587         /* AUDIO 1 */
1588         if (status & 0x10) {
1589 #if 0
1590                 printk("Es1938debug - AUDIO channel 1 interrupt\n");
1591                 printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
1592                        inw(SLDM_REG(chip, DMACOUNT)));
1593                 printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
1594                        inl(SLDM_REG(chip, DMAADDR)));
1595                 printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
1596                        inl(SLDM_REG(chip, DMASTATUS)));
1597 #endif
1598                 /* clear irq */
1599                 handled = 1;
1600                 audiostatus = inb(SLSB_REG(chip, STATUS));
1601                 if (chip->active & ADC1)
1602                         snd_pcm_period_elapsed(chip->capture_substream);
1603                 else if (chip->active & DAC1)
1604                         snd_pcm_period_elapsed(chip->playback2_substream);
1605         }
1606
1607         /* AUDIO 2 */
1608         if (status & 0x20) {
1609 #if 0
1610                 printk("Es1938debug - AUDIO channel 2 interrupt\n");
1611                 printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
1612                        inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
1613                 printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
1614                        inl(SLIO_REG(chip, AUDIO2DMAADDR)));
1615
1616 #endif
1617                 /* clear irq */
1618                 handled = 1;
1619                 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
1620                 if (chip->active & DAC2)
1621                         snd_pcm_period_elapsed(chip->playback1_substream);
1622         }
1623
1624         /* Hardware volume */
1625         if (status & 0x40) {
1626                 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
1627                 handled = 1;
1628                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
1629                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
1630                 if (!split) {
1631                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1632                                        &chip->master_switch->id);
1633                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1634                                        &chip->master_volume->id);
1635                 }
1636                 /* ack interrupt */
1637                 snd_es1938_mixer_write(chip, 0x66, 0x00);
1638         }
1639
1640         /* MPU401 */
1641         if (status & 0x80) {
1642                 // the following line is evil! It switches off MIDI interrupt handling after the first interrupt received.
1643                 // replacing the last 0 by 0x40 works for ESS-Solo1, but just doing nothing works as well!
1644                 // andreas@flying-snail.de
1645                 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
1646                 if (chip->rmidi) {
1647                         handled = 1;
1648                         snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
1649                 }
1650         }
1651         return IRQ_RETVAL(handled);
1652 }
1653
1654 #define ES1938_DMA_SIZE 64
1655
1656 static int __devinit snd_es1938_mixer(struct es1938 *chip)
1657 {
1658         struct snd_card *card;
1659         unsigned int idx;
1660         int err;
1661
1662         card = chip->card;
1663
1664         strcpy(card->mixername, "ESS Solo-1");
1665
1666         for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
1667                 struct snd_kcontrol *kctl;
1668                 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
1669                 switch (idx) {
1670                         case 0:
1671                                 chip->master_volume = kctl;
1672                                 kctl->private_free = snd_es1938_hwv_free;
1673                                 break;
1674                         case 1:
1675                                 chip->master_switch = kctl;
1676                                 kctl->private_free = snd_es1938_hwv_free;
1677                                 break;
1678                         case 2:
1679                                 chip->hw_volume = kctl;
1680                                 kctl->private_free = snd_es1938_hwv_free;
1681                                 break;
1682                         case 3:
1683                                 chip->hw_switch = kctl;
1684                                 kctl->private_free = snd_es1938_hwv_free;
1685                                 break;
1686                         }
1687                 if ((err = snd_ctl_add(card, kctl)) < 0)
1688                         return err;
1689         }
1690         return 0;
1691 }
1692
1693
1694 static int __devinit snd_es1938_probe(struct pci_dev *pci,
1695                                       const struct pci_device_id *pci_id)
1696 {
1697         static int dev;
1698         struct snd_card *card;
1699         struct es1938 *chip;
1700         struct snd_opl3 *opl3;
1701         int idx, err;
1702
1703         if (dev >= SNDRV_CARDS)
1704                 return -ENODEV;
1705         if (!enable[dev]) {
1706                 dev++;
1707                 return -ENOENT;
1708         }
1709
1710         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
1711         if (card == NULL)
1712                 return -ENOMEM;
1713         for (idx = 0; idx < 5; idx++) {
1714                 if (pci_resource_start(pci, idx) == 0 ||
1715                     !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) {
1716                         snd_card_free(card);
1717                         return -ENODEV;
1718                 }
1719         }
1720         if ((err = snd_es1938_create(card, pci, &chip)) < 0) {
1721                 snd_card_free(card);
1722                 return err;
1723         }
1724         card->private_data = chip;
1725
1726         strcpy(card->driver, "ES1938");
1727         strcpy(card->shortname, "ESS ES1938 (Solo-1)");
1728         sprintf(card->longname, "%s rev %i, irq %i",
1729                 card->shortname,
1730                 chip->revision,
1731                 chip->irq);
1732
1733         if ((err = snd_es1938_new_pcm(chip, 0)) < 0) {
1734                 snd_card_free(card);
1735                 return err;
1736         }
1737         if ((err = snd_es1938_mixer(chip)) < 0) {
1738                 snd_card_free(card);
1739                 return err;
1740         }
1741         if (snd_opl3_create(card,
1742                             SLSB_REG(chip, FMLOWADDR),
1743                             SLSB_REG(chip, FMHIGHADDR),
1744                             OPL3_HW_OPL3, 1, &opl3) < 0) {
1745                 printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n",
1746                            SLSB_REG(chip, FMLOWADDR));
1747         } else {
1748                 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
1749                         snd_card_free(card);
1750                         return err;
1751                 }
1752                 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
1753                         snd_card_free(card);
1754                         return err;
1755                 }
1756         }
1757         if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
1758                                 chip->mpu_port, 1, chip->irq, 0, &chip->rmidi) < 0) {
1759                 printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
1760         } else {
1761                 // this line is vital for MIDI interrupt handling on ess-solo1
1762                 // andreas@flying-snail.de
1763                 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);
1764         }
1765
1766         snd_es1938_create_gameport(chip);
1767
1768         if ((err = snd_card_register(card)) < 0) {
1769                 snd_card_free(card);
1770                 return err;
1771         }
1772
1773         pci_set_drvdata(pci, card);
1774         dev++;
1775         return 0;
1776 }
1777
1778 static void __devexit snd_es1938_remove(struct pci_dev *pci)
1779 {
1780         snd_card_free(pci_get_drvdata(pci));
1781         pci_set_drvdata(pci, NULL);
1782 }
1783
1784 static struct pci_driver driver = {
1785         .name = "ESS ES1938 (Solo-1)",
1786         .id_table = snd_es1938_ids,
1787         .probe = snd_es1938_probe,
1788         .remove = __devexit_p(snd_es1938_remove),
1789 #ifdef CONFIG_PM
1790         .suspend = es1938_suspend,
1791         .resume = es1938_resume,
1792 #endif
1793 };
1794
1795 static int __init alsa_card_es1938_init(void)
1796 {
1797         return pci_register_driver(&driver);
1798 }
1799
1800 static void __exit alsa_card_es1938_exit(void)
1801 {
1802         pci_unregister_driver(&driver);
1803 }
1804
1805 module_init(alsa_card_es1938_init)
1806 module_exit(alsa_card_es1938_exit)