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