kernel/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 defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
  76 #define SUPPORT_JOYSTICK 1
  77 #endif
  78
  79 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
  80 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
  81 static 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 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 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,
 843                                    snd_pcm_uframes_t pos,
 844                                    void __user *dst,
 845                                    snd_pcm_uframes_t count)
 846 {
 847         struct snd_pcm_runtime *runtime = substream->runtime;
 848         struct es1938 *chip = snd_pcm_substream_chip(substream);
 849         pos <<= chip->dma1_shift;
 850         count <<= chip->dma1_shift;
 851         if (snd_BUG_ON(pos + count > chip->dma1_size))
 852                 return -EINVAL;
 853         if (pos + count < chip->dma1_size) {
 854                 if (copy_to_user(dst, runtime->dma_area + pos + 1, count))
 855                         return -EFAULT;
 856         } else {
 857                 if (copy_to_user(dst, runtime->dma_area + pos + 1, count - 1))
 858                         return -EFAULT;
 859                 if (put_user(runtime->dma_area[0], ((unsigned char __user *)dst) + count - 1))
 860                         return -EFAULT;
 861         }
 862         return 0;
 863 }
 864
 865 /*
 866  * buffer management
 867  */
 868 static int snd_es1938_pcm_hw_params(struct snd_pcm_substream *substream,
 869                                     struct snd_pcm_hw_params *hw_params)
 870
 871 {
 872         int err;
 873
 874         if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
 875                 return err;
 876         return 0;
 877 }
 878
 879 static int snd_es1938_pcm_hw_free(struct snd_pcm_substream *substream)
 880 {
 881         return snd_pcm_lib_free_pages(substream);
 882 }
 883
 884 /* ----------------------------------------------------------------------
 885  * Audio1 Capture (ADC)
 886  * ----------------------------------------------------------------------*/
 887 static struct snd_pcm_hardware snd_es1938_capture =
 888 {
 889         .info =                 (SNDRV_PCM_INFO_INTERLEAVED |
 890                                 SNDRV_PCM_INFO_BLOCK_TRANSFER),
 891         .formats =              (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
 892                                  SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
 893         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
 894         .rate_min =             6000,
 895         .rate_max =             48000,
 896         .channels_min =         1,
 897         .channels_max =         2,
 898         .buffer_bytes_max =     0x8000,       /* DMA controller screws on higher values */
 899         .period_bytes_min =     64,
 900         .period_bytes_max =     0x8000,
 901         .periods_min =          1,
 902         .periods_max =          1024,
 903         .fifo_size =            256,
 904 };
 905
 906 /* -----------------------------------------------------------------------
 907  * Audio2 Playback (DAC)
 908  * -----------------------------------------------------------------------*/
 909 static struct snd_pcm_hardware snd_es1938_playback =
 910 {
 911         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
 912                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
 913                                  SNDRV_PCM_INFO_MMAP_VALID),
 914         .formats =              (SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
 915                                  SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
 916         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
 917         .rate_min =             6000,
 918         .rate_max =             48000,
 919         .channels_min =         1,
 920         .channels_max =         2,
 921         .buffer_bytes_max =     0x8000,       /* DMA controller screws on higher values */
 922         .period_bytes_min =     64,
 923         .period_bytes_max =     0x8000,
 924         .periods_min =          1,
 925         .periods_max =          1024,
 926         .fifo_size =            256,
 927 };
 928
 929 static int snd_es1938_capture_open(struct snd_pcm_substream *substream)
 930 {
 931         struct es1938 *chip = snd_pcm_substream_chip(substream);
 932         struct snd_pcm_runtime *runtime = substream->runtime;
 933
 934         if (chip->playback2_substream)
 935                 return -EAGAIN;
 936         chip->capture_substream = substream;
 937         runtime->hw = snd_es1938_capture;
 938         snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 939                                       &hw_constraints_clocks);
 940         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
 941         return 0;
 942 }
 943
 944 static int snd_es1938_playback_open(struct snd_pcm_substream *substream)
 945 {
 946         struct es1938 *chip = snd_pcm_substream_chip(substream);
 947         struct snd_pcm_runtime *runtime = substream->runtime;
 948
 949         switch (substream->number) {
 950         case 0:
 951                 chip->playback1_substream = substream;
 952                 break;
 953         case 1:
 954                 if (chip->capture_substream)
 955                         return -EAGAIN;
 956                 chip->playback2_substream = substream;
 957                 break;
 958         default:
 959                 snd_BUG();
 960                 return -EINVAL;
 961         }
 962         runtime->hw = snd_es1938_playback;
 963         snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 964                                       &hw_constraints_clocks);
 965         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
 966         return 0;
 967 }
 968
 969 static int snd_es1938_capture_close(struct snd_pcm_substream *substream)
 970 {
 971         struct es1938 *chip = snd_pcm_substream_chip(substream);
 972
 973         chip->capture_substream = NULL;
 974         return 0;
 975 }
 976
 977 static int snd_es1938_playback_close(struct snd_pcm_substream *substream)
 978 {
 979         struct es1938 *chip = snd_pcm_substream_chip(substream);
 980
 981         switch (substream->number) {
 982         case 0:
 983                 chip->playback1_substream = NULL;
 984                 break;
 985         case 1:
 986                 chip->playback2_substream = NULL;
 987                 break;
 988         default:
 989                 snd_BUG();
 990                 return -EINVAL;
 991         }
 992         return 0;
 993 }
 994
 995 static struct snd_pcm_ops snd_es1938_playback_ops = {
 996         .open =         snd_es1938_playback_open,
 997         .close =        snd_es1938_playback_close,
 998         .ioctl =        snd_pcm_lib_ioctl,
 999         .hw_params =    snd_es1938_pcm_hw_params,
1000         .hw_free =      snd_es1938_pcm_hw_free,
1001         .prepare =      snd_es1938_playback_prepare,
1002         .trigger =      snd_es1938_playback_trigger,
1003         .pointer =      snd_es1938_playback_pointer,
1004 };
1005
1006 static struct snd_pcm_ops snd_es1938_capture_ops = {
1007         .open =         snd_es1938_capture_open,
1008         .close =        snd_es1938_capture_close,
1009         .ioctl =        snd_pcm_lib_ioctl,
1010         .hw_params =    snd_es1938_pcm_hw_params,
1011         .hw_free =      snd_es1938_pcm_hw_free,
1012         .prepare =      snd_es1938_capture_prepare,
1013         .trigger =      snd_es1938_capture_trigger,
1014         .pointer =      snd_es1938_capture_pointer,
1015         .copy =         snd_es1938_capture_copy,
1016 };
1017
1018 static int snd_es1938_new_pcm(struct es1938 *chip, int device)
1019 {
1020         struct snd_pcm *pcm;
1021         int err;
1022
1023         if ((err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm)) < 0)
1024                 return err;
1025         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1938_playback_ops);
1026         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1938_capture_ops);
1027
1028         pcm->private_data = chip;
1029         pcm->info_flags = 0;
1030         strcpy(pcm->name, "ESS Solo-1");
1031
1032         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1033                                               snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
1034
1035         chip->pcm = pcm;
1036         return 0;
1037 }
1038
1039 /* -------------------------------------------------------------------
1040  *
1041  *                       *** Mixer part ***
1042  */
1043
1044 static int snd_es1938_info_mux(struct snd_kcontrol *kcontrol,
1045                                struct snd_ctl_elem_info *uinfo)
1046 {
1047         static const char * const texts[8] = {
1048                 "Mic", "Mic Master", "CD", "AOUT",
1049                 "Mic1", "Mix", "Line", "Master"
1050         };
1051
1052         return snd_ctl_enum_info(uinfo, 1, 8, texts);
1053 }
1054
1055 static int snd_es1938_get_mux(struct snd_kcontrol *kcontrol,
1056                               struct snd_ctl_elem_value *ucontrol)
1057 {
1058         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1059         ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07;
1060         return 0;
1061 }
1062
1063 static int snd_es1938_put_mux(struct snd_kcontrol *kcontrol,
1064                               struct snd_ctl_elem_value *ucontrol)
1065 {
1066         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1067         unsigned char val = ucontrol->value.enumerated.item[0];
1068
1069         if (val > 7)
1070                 return -EINVAL;
1071         return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val;
1072 }
1073
1074 #define snd_es1938_info_spatializer_enable      snd_ctl_boolean_mono_info
1075
1076 static int snd_es1938_get_spatializer_enable(struct snd_kcontrol *kcontrol,
1077                                              struct snd_ctl_elem_value *ucontrol)
1078 {
1079         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1080         unsigned char val = snd_es1938_mixer_read(chip, 0x50);
1081         ucontrol->value.integer.value[0] = !!(val & 8);
1082         return 0;
1083 }
1084
1085 static int snd_es1938_put_spatializer_enable(struct snd_kcontrol *kcontrol,
1086                                              struct snd_ctl_elem_value *ucontrol)
1087 {
1088         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1089         unsigned char oval, nval;
1090         int change;
1091         nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04;
1092         oval = snd_es1938_mixer_read(chip, 0x50) & 0x0c;
1093         change = nval != oval;
1094         if (change) {
1095                 snd_es1938_mixer_write(chip, 0x50, nval & ~0x04);
1096                 snd_es1938_mixer_write(chip, 0x50, nval);
1097         }
1098         return change;
1099 }
1100
1101 static int snd_es1938_info_hw_volume(struct snd_kcontrol *kcontrol,
1102                                      struct snd_ctl_elem_info *uinfo)
1103 {
1104         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1105         uinfo->count = 2;
1106         uinfo->value.integer.min = 0;
1107         uinfo->value.integer.max = 63;
1108         return 0;
1109 }
1110
1111 static int snd_es1938_get_hw_volume(struct snd_kcontrol *kcontrol,
1112                                     struct snd_ctl_elem_value *ucontrol)
1113 {
1114         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1115         ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f;
1116         ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f;
1117         return 0;
1118 }
1119
1120 #define snd_es1938_info_hw_switch               snd_ctl_boolean_stereo_info
1121
1122 static int snd_es1938_get_hw_switch(struct snd_kcontrol *kcontrol,
1123                                     struct snd_ctl_elem_value *ucontrol)
1124 {
1125         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1126         ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40);
1127         ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40);
1128         return 0;
1129 }
1130
1131 static void snd_es1938_hwv_free(struct snd_kcontrol *kcontrol)
1132 {
1133         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1134         chip->master_volume = NULL;
1135         chip->master_switch = NULL;
1136         chip->hw_volume = NULL;
1137         chip->hw_switch = NULL;
1138 }
1139
1140 static int snd_es1938_reg_bits(struct es1938 *chip, unsigned char reg,
1141                                unsigned char mask, unsigned char val)
1142 {
1143         if (reg < 0xa0)
1144                 return snd_es1938_mixer_bits(chip, reg, mask, val);
1145         else
1146                 return snd_es1938_bits(chip, reg, mask, val);
1147 }
1148
1149 static int snd_es1938_reg_read(struct es1938 *chip, unsigned char reg)
1150 {
1151         if (reg < 0xa0)
1152                 return snd_es1938_mixer_read(chip, reg);
1153         else
1154                 return snd_es1938_read(chip, reg);
1155 }
1156
1157 #define ES1938_SINGLE_TLV(xname, xindex, reg, shift, mask, invert, xtlv)    \
1158 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1159   .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,\
1160   .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   .tlv = { .p = xtlv } }
1165 #define ES1938_SINGLE(xname, xindex, reg, shift, mask, invert) \
1166 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1167   .info = snd_es1938_info_single, \
1168   .get = snd_es1938_get_single, .put = snd_es1938_put_single, \
1169   .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
1170
1171 static int snd_es1938_info_single(struct snd_kcontrol *kcontrol,
1172                                   struct snd_ctl_elem_info *uinfo)
1173 {
1174         int mask = (kcontrol->private_value >> 16) & 0xff;
1175
1176         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1177         uinfo->count = 1;
1178         uinfo->value.integer.min = 0;
1179         uinfo->value.integer.max = mask;
1180         return 0;
1181 }
1182
1183 static int snd_es1938_get_single(struct snd_kcontrol *kcontrol,
1184                                  struct snd_ctl_elem_value *ucontrol)
1185 {
1186         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1187         int reg = kcontrol->private_value & 0xff;
1188         int shift = (kcontrol->private_value >> 8) & 0xff;
1189         int mask = (kcontrol->private_value >> 16) & 0xff;
1190         int invert = (kcontrol->private_value >> 24) & 0xff;
1191         int val;
1192
1193         val = snd_es1938_reg_read(chip, reg);
1194         ucontrol->value.integer.value[0] = (val >> shift) & mask;
1195         if (invert)
1196                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1197         return 0;
1198 }
1199
1200 static int snd_es1938_put_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         unsigned char val;
1209
1210         val = (ucontrol->value.integer.value[0] & mask);
1211         if (invert)
1212                 val = mask - val;
1213         mask <<= shift;
1214         val <<= shift;
1215         return snd_es1938_reg_bits(chip, reg, mask, val) != val;
1216 }
1217
1218 #define ES1938_DOUBLE_TLV(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert, xtlv) \
1219 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1220   .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ,\
1221   .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   .tlv = { .p = xtlv } }
1226 #define ES1938_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1227 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1228   .info = snd_es1938_info_double, \
1229   .get = snd_es1938_get_double, .put = snd_es1938_put_double, \
1230   .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1231
1232 static int snd_es1938_info_double(struct snd_kcontrol *kcontrol,
1233                                   struct snd_ctl_elem_info *uinfo)
1234 {
1235         int mask = (kcontrol->private_value >> 24) & 0xff;
1236
1237         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1238         uinfo->count = 2;
1239         uinfo->value.integer.min = 0;
1240         uinfo->value.integer.max = mask;
1241         return 0;
1242 }
1243
1244 static int snd_es1938_get_double(struct snd_kcontrol *kcontrol,
1245                                  struct snd_ctl_elem_value *ucontrol)
1246 {
1247         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1248         int left_reg = kcontrol->private_value & 0xff;
1249         int right_reg = (kcontrol->private_value >> 8) & 0xff;
1250         int shift_left = (kcontrol->private_value >> 16) & 0x07;
1251         int shift_right = (kcontrol->private_value >> 19) & 0x07;
1252         int mask = (kcontrol->private_value >> 24) & 0xff;
1253         int invert = (kcontrol->private_value >> 22) & 1;
1254         unsigned char left, right;
1255
1256         left = snd_es1938_reg_read(chip, left_reg);
1257         if (left_reg != right_reg)
1258                 right = snd_es1938_reg_read(chip, right_reg);
1259         else
1260                 right = left;
1261         ucontrol->value.integer.value[0] = (left >> shift_left) & mask;
1262         ucontrol->value.integer.value[1] = (right >> shift_right) & mask;
1263         if (invert) {
1264                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1265                 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
1266         }
1267         return 0;
1268 }
1269
1270 static int snd_es1938_put_double(struct snd_kcontrol *kcontrol,
1271                                  struct snd_ctl_elem_value *ucontrol)
1272 {
1273         struct es1938 *chip = snd_kcontrol_chip(kcontrol);
1274         int left_reg = kcontrol->private_value & 0xff;
1275         int right_reg = (kcontrol->private_value >> 8) & 0xff;
1276         int shift_left = (kcontrol->private_value >> 16) & 0x07;
1277         int shift_right = (kcontrol->private_value >> 19) & 0x07;
1278         int mask = (kcontrol->private_value >> 24) & 0xff;
1279         int invert = (kcontrol->private_value >> 22) & 1;
1280         int change;
1281         unsigned char val1, val2, mask1, mask2;
1282
1283         val1 = ucontrol->value.integer.value[0] & mask;
1284         val2 = ucontrol->value.integer.value[1] & mask;
1285         if (invert) {
1286                 val1 = mask - val1;
1287                 val2 = mask - val2;
1288         }
1289         val1 <<= shift_left;
1290         val2 <<= shift_right;
1291         mask1 = mask << shift_left;
1292         mask2 = mask << shift_right;
1293         if (left_reg != right_reg) {
1294                 change = 0;
1295                 if (snd_es1938_reg_bits(chip, left_reg, mask1, val1) != val1)
1296                         change = 1;
1297                 if (snd_es1938_reg_bits(chip, right_reg, mask2, val2) != val2)
1298                         change = 1;
1299         } else {
1300                 change = (snd_es1938_reg_bits(chip, left_reg, mask1 | mask2,
1301                                               val1 | val2) != (val1 | val2));
1302         }
1303         return change;
1304 }
1305
1306 static const DECLARE_TLV_DB_RANGE(db_scale_master,
1307         0, 54, TLV_DB_SCALE_ITEM(-3600, 50, 1),
1308         54, 63, TLV_DB_SCALE_ITEM(-900, 100, 0),
1309 );
1310
1311 static const DECLARE_TLV_DB_RANGE(db_scale_audio1,
1312         0, 8, TLV_DB_SCALE_ITEM(-3300, 300, 1),
1313         8, 15, TLV_DB_SCALE_ITEM(-900, 150, 0),
1314 );
1315
1316 static const DECLARE_TLV_DB_RANGE(db_scale_audio2,
1317         0, 8, TLV_DB_SCALE_ITEM(-3450, 300, 1),
1318         8, 15, TLV_DB_SCALE_ITEM(-1050, 150, 0),
1319 );
1320
1321 static const DECLARE_TLV_DB_RANGE(db_scale_mic,
1322         0, 8, TLV_DB_SCALE_ITEM(-2400, 300, 1),
1323         8, 15, TLV_DB_SCALE_ITEM(0, 150, 0),
1324 );
1325
1326 static const DECLARE_TLV_DB_RANGE(db_scale_line,
1327         0, 8, TLV_DB_SCALE_ITEM(-3150, 300, 1),
1328         8, 15, TLV_DB_SCALE_ITEM(-750, 150, 0),
1329 );
1330
1331 static const DECLARE_TLV_DB_SCALE(db_scale_capture, 0, 150, 0);
1332
1333 static struct snd_kcontrol_new snd_es1938_controls[] = {
1334 ES1938_DOUBLE_TLV("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0,
1335                   db_scale_master),
1336 ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1),
1337 {
1338         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1339         .name = "Hardware Master Playback Volume",
1340         .access = SNDRV_CTL_ELEM_ACCESS_READ,
1341         .info = snd_es1938_info_hw_volume,
1342         .get = snd_es1938_get_hw_volume,
1343 },
1344 {
1345         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1346         .access = (SNDRV_CTL_ELEM_ACCESS_READ |
1347                    SNDRV_CTL_ELEM_ACCESS_TLV_READ),
1348         .name = "Hardware Master Playback Switch",
1349         .info = snd_es1938_info_hw_switch,
1350         .get = snd_es1938_get_hw_switch,
1351         .tlv = { .p = db_scale_master },
1352 },
1353 ES1938_SINGLE("Hardware Volume Split", 0, 0x64, 7, 1, 0),
1354 ES1938_DOUBLE_TLV("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0,
1355                   db_scale_line),
1356 ES1938_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0),
1357 ES1938_DOUBLE_TLV("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0,
1358                   db_scale_mic),
1359 ES1938_DOUBLE_TLV("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0,
1360                   db_scale_line),
1361 ES1938_DOUBLE_TLV("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0,
1362                   db_scale_mic),
1363 ES1938_DOUBLE_TLV("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0,
1364                   db_scale_line),
1365 ES1938_DOUBLE_TLV("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0,
1366                   db_scale_capture),
1367 ES1938_SINGLE("Beep Volume", 0, 0x3c, 0, 7, 0),
1368 ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
1369 ES1938_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1),
1370 {
1371         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1372         .name = "Capture Source",
1373         .info = snd_es1938_info_mux,
1374         .get = snd_es1938_get_mux,
1375         .put = snd_es1938_put_mux,
1376 },
1377 ES1938_DOUBLE_TLV("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0,
1378                   db_scale_line),
1379 ES1938_DOUBLE_TLV("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0,
1380                   db_scale_audio2),
1381 ES1938_DOUBLE_TLV("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0,
1382                   db_scale_mic),
1383 ES1938_DOUBLE_TLV("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0,
1384                   db_scale_line),
1385 ES1938_DOUBLE_TLV("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0,
1386                   db_scale_mic),
1387 ES1938_DOUBLE_TLV("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0,
1388                   db_scale_line),
1389 ES1938_DOUBLE_TLV("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0,
1390                   db_scale_line),
1391 ES1938_DOUBLE_TLV("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0,
1392                   db_scale_line),
1393 ES1938_DOUBLE_TLV("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0,
1394                   db_scale_audio2),
1395 ES1938_DOUBLE_TLV("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0,
1396                   db_scale_audio1),
1397 ES1938_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0),
1398 {
1399         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1400         .name = "3D Control - Switch",
1401         .info = snd_es1938_info_spatializer_enable,
1402         .get = snd_es1938_get_spatializer_enable,
1403         .put = snd_es1938_put_spatializer_enable,
1404 },
1405 ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0)
1406 };
1407
1408
1409 /* ---------------------------------------------------------------------------- */
1410 /* ---------------------------------------------------------------------------- */
1411
1412 /*
1413  * initialize the chip - used by resume callback, too
1414  */
1415 static void snd_es1938_chip_init(struct es1938 *chip)
1416 {
1417         /* reset chip */
1418         snd_es1938_reset(chip);
1419
1420         /* configure native mode */
1421
1422         /* enable bus master */
1423         pci_set_master(chip->pci);
1424
1425         /* disable legacy audio */
1426         pci_write_config_word(chip->pci, SL_PCI_LEGACYCONTROL, 0x805f);
1427
1428         /* set DDMA base */
1429         pci_write_config_word(chip->pci, SL_PCI_DDMACONTROL, chip->ddma_port | 1);
1430
1431         /* set DMA/IRQ policy */
1432         pci_write_config_dword(chip->pci, SL_PCI_CONFIG, 0);
1433
1434         /* enable Audio 1, Audio 2, MPU401 IRQ and HW volume IRQ*/
1435         outb(0xf0, SLIO_REG(chip, IRQCONTROL));
1436
1437         /* reset DMA */
1438         outb(0, SLDM_REG(chip, DMACLEAR));
1439 }
1440
1441 #ifdef CONFIG_PM_SLEEP
1442 /*
1443  * PM support
1444  */
1445
1446 static unsigned char saved_regs[SAVED_REG_SIZE+1] = {
1447         0x14, 0x1a, 0x1c, 0x3a, 0x3c, 0x3e, 0x36, 0x38,
1448         0x50, 0x52, 0x60, 0x61, 0x62, 0x63, 0x64, 0x68,
1449         0x69, 0x6a, 0x6b, 0x6d, 0x6e, 0x6f, 0x7c, 0x7d,
1450         0xa8, 0xb4,
1451 };
1452
1453
1454 static int es1938_suspend(struct device *dev)
1455 {
1456         struct snd_card *card = dev_get_drvdata(dev);
1457         struct es1938 *chip = card->private_data;
1458         unsigned char *s, *d;
1459
1460         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1461         snd_pcm_suspend_all(chip->pcm);
1462
1463         /* save mixer-related registers */
1464         for (s = saved_regs, d = chip->saved_regs; *s; s++, d++)
1465                 *d = snd_es1938_reg_read(chip, *s);
1466
1467         outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */
1468         if (chip->irq >= 0) {
1469                 free_irq(chip->irq, chip);
1470                 chip->irq = -1;
1471         }
1472         return 0;
1473 }
1474
1475 static int es1938_resume(struct device *dev)
1476 {
1477         struct pci_dev *pci = to_pci_dev(dev);
1478         struct snd_card *card = dev_get_drvdata(dev);
1479         struct es1938 *chip = card->private_data;
1480         unsigned char *s, *d;
1481
1482         if (request_irq(pci->irq, snd_es1938_interrupt,
1483                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
1484                 dev_err(dev, "unable to grab IRQ %d, disabling device\n",
1485                         pci->irq);
1486                 snd_card_disconnect(card);
1487                 return -EIO;
1488         }
1489         chip->irq = pci->irq;
1490         snd_es1938_chip_init(chip);
1491
1492         /* restore mixer-related registers */
1493         for (s = saved_regs, d = chip->saved_regs; *s; s++, d++) {
1494                 if (*s < 0xa0)
1495                         snd_es1938_mixer_write(chip, *s, *d);
1496                 else
1497                         snd_es1938_write(chip, *s, *d);
1498         }
1499
1500         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1501         return 0;
1502 }
1503
1504 static SIMPLE_DEV_PM_OPS(es1938_pm, es1938_suspend, es1938_resume);
1505 #define ES1938_PM_OPS   &es1938_pm
1506 #else
1507 #define ES1938_PM_OPS   NULL
1508 #endif /* CONFIG_PM_SLEEP */
1509
1510 #ifdef SUPPORT_JOYSTICK
1511 static int snd_es1938_create_gameport(struct es1938 *chip)
1512 {
1513         struct gameport *gp;
1514
1515         chip->gameport = gp = gameport_allocate_port();
1516         if (!gp) {
1517                 dev_err(chip->card->dev,
1518                         "cannot allocate memory for gameport\n");
1519                 return -ENOMEM;
1520         }
1521
1522         gameport_set_name(gp, "ES1938");
1523         gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
1524         gameport_set_dev_parent(gp, &chip->pci->dev);
1525         gp->io = chip->game_port;
1526
1527         gameport_register_port(gp);
1528
1529         return 0;
1530 }
1531
1532 static void snd_es1938_free_gameport(struct es1938 *chip)
1533 {
1534         if (chip->gameport) {
1535                 gameport_unregister_port(chip->gameport);
1536                 chip->gameport = NULL;
1537         }
1538 }
1539 #else
1540 static inline int snd_es1938_create_gameport(struct es1938 *chip) { return -ENOSYS; }
1541 static inline void snd_es1938_free_gameport(struct es1938 *chip) { }
1542 #endif /* SUPPORT_JOYSTICK */
1543
1544 static int snd_es1938_free(struct es1938 *chip)
1545 {
1546         /* disable irqs */
1547         outb(0x00, SLIO_REG(chip, IRQCONTROL));
1548         if (chip->rmidi)
1549                 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0);
1550
1551         snd_es1938_free_gameport(chip);
1552
1553         if (chip->irq >= 0)
1554                 free_irq(chip->irq, chip);
1555         pci_release_regions(chip->pci);
1556         pci_disable_device(chip->pci);
1557         kfree(chip);
1558         return 0;
1559 }
1560
1561 static int snd_es1938_dev_free(struct snd_device *device)
1562 {
1563         struct es1938 *chip = device->device_data;
1564         return snd_es1938_free(chip);
1565 }
1566
1567 static int snd_es1938_create(struct snd_card *card,
1568                              struct pci_dev *pci,
1569                              struct es1938 **rchip)
1570 {
1571         struct es1938 *chip;
1572         int err;
1573         static struct snd_device_ops ops = {
1574                 .dev_free =     snd_es1938_dev_free,
1575         };
1576
1577         *rchip = NULL;
1578
1579         /* enable PCI device */
1580         if ((err = pci_enable_device(pci)) < 0)
1581                 return err;
1582         /* check, if we can restrict PCI DMA transfers to 24 bits */
1583         if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
1584             pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
1585                 dev_err(card->dev,
1586                         "architecture does not support 24bit PCI busmaster DMA\n");
1587                 pci_disable_device(pci);
1588                 return -ENXIO;
1589         }
1590
1591         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1592         if (chip == NULL) {
1593                 pci_disable_device(pci);
1594                 return -ENOMEM;
1595         }
1596         spin_lock_init(&chip->reg_lock);
1597         spin_lock_init(&chip->mixer_lock);
1598         chip->card = card;
1599         chip->pci = pci;
1600         chip->irq = -1;
1601         if ((err = pci_request_regions(pci, "ESS Solo-1")) < 0) {
1602                 kfree(chip);
1603                 pci_disable_device(pci);
1604                 return err;
1605         }
1606         chip->io_port = pci_resource_start(pci, 0);
1607         chip->sb_port = pci_resource_start(pci, 1);
1608         chip->vc_port = pci_resource_start(pci, 2);
1609         chip->mpu_port = pci_resource_start(pci, 3);
1610         chip->game_port = pci_resource_start(pci, 4);
1611         if (request_irq(pci->irq, snd_es1938_interrupt, IRQF_SHARED,
1612                         KBUILD_MODNAME, chip)) {
1613                 dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
1614                 snd_es1938_free(chip);
1615                 return -EBUSY;
1616         }
1617         chip->irq = pci->irq;
1618         dev_dbg(card->dev,
1619                 "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
1620                    chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1621
1622         chip->ddma_port = chip->vc_port + 0x00;         /* fix from Thomas Sailer */
1623
1624         snd_es1938_chip_init(chip);
1625
1626         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1627                 snd_es1938_free(chip);
1628                 return err;
1629         }
1630
1631         *rchip = chip;
1632         return 0;
1633 }
1634
1635 /* --------------------------------------------------------------------
1636  * Interrupt handler
1637  * -------------------------------------------------------------------- */
1638 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id)
1639 {
1640         struct es1938 *chip = dev_id;
1641         unsigned char status, audiostatus;
1642         int handled = 0;
1643
1644         status = inb(SLIO_REG(chip, IRQCONTROL));
1645 #if 0
1646         dev_dbg(chip->card->dev,
1647                 "Es1938debug - interrupt status: =0x%x\n", status);
1648 #endif
1649
1650         /* AUDIO 1 */
1651         if (status & 0x10) {
1652 #if 0
1653                 dev_dbg(chip->card->dev,
1654                        "Es1938debug - AUDIO channel 1 interrupt\n");
1655                 dev_dbg(chip->card->dev,
1656                        "Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
1657                        inw(SLDM_REG(chip, DMACOUNT)));
1658                 dev_dbg(chip->card->dev,
1659                        "Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
1660                        inl(SLDM_REG(chip, DMAADDR)));
1661                 dev_dbg(chip->card->dev,
1662                        "Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
1663                        inl(SLDM_REG(chip, DMASTATUS)));
1664 #endif
1665                 /* clear irq */
1666                 handled = 1;
1667                 audiostatus = inb(SLSB_REG(chip, STATUS));
1668                 if (chip->active & ADC1)
1669                         snd_pcm_period_elapsed(chip->capture_substream);
1670                 else if (chip->active & DAC1)
1671                         snd_pcm_period_elapsed(chip->playback2_substream);
1672         }
1673
1674         /* AUDIO 2 */
1675         if (status & 0x20) {
1676 #if 0
1677                 dev_dbg(chip->card->dev,
1678                        "Es1938debug - AUDIO channel 2 interrupt\n");
1679                 dev_dbg(chip->card->dev,
1680                        "Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
1681                        inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
1682                 dev_dbg(chip->card->dev,
1683                        "Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
1684                        inl(SLIO_REG(chip, AUDIO2DMAADDR)));
1685
1686 #endif
1687                 /* clear irq */
1688                 handled = 1;
1689                 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
1690                 if (chip->active & DAC2)
1691                         snd_pcm_period_elapsed(chip->playback1_substream);
1692         }
1693
1694         /* Hardware volume */
1695         if (status & 0x40) {
1696                 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
1697                 handled = 1;
1698                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
1699                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
1700                 if (!split) {
1701                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1702                                        &chip->master_switch->id);
1703                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1704                                        &chip->master_volume->id);
1705                 }
1706                 /* ack interrupt */
1707                 snd_es1938_mixer_write(chip, 0x66, 0x00);
1708         }
1709
1710         /* MPU401 */
1711         if (status & 0x80) {
1712                 // the following line is evil! It switches off MIDI interrupt handling after the first interrupt received.
1713                 // replacing the last 0 by 0x40 works for ESS-Solo1, but just doing nothing works as well!
1714                 // andreas@flying-snail.de
1715                 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
1716                 if (chip->rmidi) {
1717                         handled = 1;
1718                         snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
1719                 }
1720         }
1721         return IRQ_RETVAL(handled);
1722 }
1723
1724 #define ES1938_DMA_SIZE 64
1725
1726 static int snd_es1938_mixer(struct es1938 *chip)
1727 {
1728         struct snd_card *card;
1729         unsigned int idx;
1730         int err;
1731
1732         card = chip->card;
1733
1734         strcpy(card->mixername, "ESS Solo-1");
1735
1736         for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
1737                 struct snd_kcontrol *kctl;
1738                 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
1739                 switch (idx) {
1740                         case 0:
1741                                 chip->master_volume = kctl;
1742                                 kctl->private_free = snd_es1938_hwv_free;
1743                                 break;
1744                         case 1:
1745                                 chip->master_switch = kctl;
1746                                 kctl->private_free = snd_es1938_hwv_free;
1747                                 break;
1748                         case 2:
1749                                 chip->hw_volume = kctl;
1750                                 kctl->private_free = snd_es1938_hwv_free;
1751                                 break;
1752                         case 3:
1753                                 chip->hw_switch = kctl;
1754                                 kctl->private_free = snd_es1938_hwv_free;
1755                                 break;
1756                         }
1757                 if ((err = snd_ctl_add(card, kctl)) < 0)
1758                         return err;
1759         }
1760         return 0;
1761 }
1762
1763
1764 static int snd_es1938_probe(struct pci_dev *pci,
1765                             const struct pci_device_id *pci_id)
1766 {
1767         static int dev;
1768         struct snd_card *card;
1769         struct es1938 *chip;
1770         struct snd_opl3 *opl3;
1771         int idx, err;
1772
1773         if (dev >= SNDRV_CARDS)
1774                 return -ENODEV;
1775         if (!enable[dev]) {
1776                 dev++;
1777                 return -ENOENT;
1778         }
1779
1780         err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
1781                            0, &card);
1782         if (err < 0)
1783                 return err;
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                 dev_err(card->dev, "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,
1830                                 MPU401_INFO_INTEGRATED | MPU401_INFO_IRQ_HOOK,
1831                                 -1, &chip->rmidi) < 0) {
1832                 dev_err(card->dev, "unable to initialize MPU-401\n");
1833         } else {
1834                 // this line is vital for MIDI interrupt handling on ess-solo1
1835                 // andreas@flying-snail.de
1836                 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);
1837         }
1838
1839         snd_es1938_create_gameport(chip);
1840
1841         if ((err = snd_card_register(card)) < 0) {
1842                 snd_card_free(card);
1843                 return err;
1844         }
1845
1846         pci_set_drvdata(pci, card);
1847         dev++;
1848         return 0;
1849 }
1850
1851 static void snd_es1938_remove(struct pci_dev *pci)
1852 {
1853         snd_card_free(pci_get_drvdata(pci));
1854 }
1855
1856 static struct pci_driver es1938_driver = {
1857         .name = KBUILD_MODNAME,
1858         .id_table = snd_es1938_ids,
1859         .probe = snd_es1938_probe,
1860         .remove = snd_es1938_remove,
1861         .driver = {
1862                 .pm = ES1938_PM_OPS,
1863         },
1864 };
1865
1866 module_pci_driver(es1938_driver);