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