sound/pci/es1938.c

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