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 <sound/core.h>
  58 #include <sound/control.h>
  59 #include <sound/pcm.h>
  60 #include <sound/opl3.h>
  61 #include <sound/mpu401.h>
  62 #include <sound/initval.h>
  63
  64 #include <asm/io.h>
  65
  66 #define chip_t es1938_t
  67
  68 MODULE_AUTHOR("Jaromir Koutek <miri@punknet.cz>");
  69 MODULE_DESCRIPTION("ESS Solo-1");
  70 MODULE_LICENSE("GPL");
  71 MODULE_CLASSES("{sound}");
  72 MODULE_DEVICES("{{ESS,ES1938},"
  73                 "{ESS,ES1946},"
  74                 "{ESS,ES1969},"
  75                 "{TerraTec,128i PCI}}");
  76
  77 #ifndef PCI_VENDOR_ID_ESS
  78 #define PCI_VENDOR_ID_ESS               0x125d
  79 #endif
  80 #ifndef PCI_DEVICE_ID_ESS_ES1938
  81 #define PCI_DEVICE_ID_ESS_ES1938        0x1969
  82 #endif
  83
  84 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
  85 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
  86 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;      /* Enable this card */
  87 static int boot_devs;
  88
  89 module_param_array(index, int, boot_devs, 0444);
  90 MODULE_PARM_DESC(index, "Index value for ESS Solo-1 soundcard.");
  91 MODULE_PARM_SYNTAX(index, SNDRV_INDEX_DESC);
  92 module_param_array(id, charp, boot_devs, 0444);
  93 MODULE_PARM_DESC(id, "ID string for ESS Solo-1 soundcard.");
  94 MODULE_PARM_SYNTAX(id, SNDRV_ID_DESC);
  95 module_param_array(enable, bool, boot_devs, 0444);
  96 MODULE_PARM_DESC(enable, "Enable ESS Solo-1 soundcard.");
  97 MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
  98
  99 #define SLIO_REG(chip, x) ((chip)->io_port + ESSIO_REG_##x)
 100
 101 #define SLDM_REG(chip, x) ((chip)->ddma_port + ESSDM_REG_##x)
 102
 103 #define SLSB_REG(chip, x) ((chip)->sb_port + ESSSB_REG_##x)
 104
 105 #define SL_PCI_LEGACYCONTROL            0x40
 106 #define SL_PCI_CONFIG                   0x50
 107 #define SL_PCI_DDMACONTROL              0x60
 108
 109 #define ESSIO_REG_AUDIO2DMAADDR         0
 110 #define ESSIO_REG_AUDIO2DMACOUNT        4
 111 #define ESSIO_REG_AUDIO2MODE            6
 112 #define ESSIO_REG_IRQCONTROL            7
 113
 114 #define ESSDM_REG_DMAADDR               0x00
 115 #define ESSDM_REG_DMACOUNT              0x04
 116 #define ESSDM_REG_DMACOMMAND            0x08
 117 #define ESSDM_REG_DMASTATUS             0x08
 118 #define ESSDM_REG_DMAMODE               0x0b
 119 #define ESSDM_REG_DMACLEAR              0x0d
 120 #define ESSDM_REG_DMAMASK               0x0f
 121
 122 #define ESSSB_REG_FMLOWADDR             0x00
 123 #define ESSSB_REG_FMHIGHADDR            0x02
 124 #define ESSSB_REG_MIXERADDR             0x04
 125 #define ESSSB_REG_MIXERDATA             0x05
 126
 127 #define ESSSB_IREG_AUDIO1               0x14
 128 #define ESSSB_IREG_MICMIX               0x1a
 129 #define ESSSB_IREG_RECSRC               0x1c
 130 #define ESSSB_IREG_MASTER               0x32
 131 #define ESSSB_IREG_FM                   0x36
 132 #define ESSSB_IREG_AUXACD               0x38
 133 #define ESSSB_IREG_AUXB                 0x3a
 134 #define ESSSB_IREG_PCSPEAKER            0x3c
 135 #define ESSSB_IREG_LINE                 0x3e
 136 #define ESSSB_IREG_SPATCONTROL          0x50
 137 #define ESSSB_IREG_SPATLEVEL            0x52
 138 #define ESSSB_IREG_MASTER_LEFT          0x60
 139 #define ESSSB_IREG_MASTER_RIGHT         0x62
 140 #define ESSSB_IREG_MPU401CONTROL        0x64
 141 #define ESSSB_IREG_MICMIXRECORD         0x68
 142 #define ESSSB_IREG_AUDIO2RECORD         0x69
 143 #define ESSSB_IREG_AUXACDRECORD         0x6a
 144 #define ESSSB_IREG_FMRECORD             0x6b
 145 #define ESSSB_IREG_AUXBRECORD           0x6c
 146 #define ESSSB_IREG_MONO                 0x6d
 147 #define ESSSB_IREG_LINERECORD           0x6e
 148 #define ESSSB_IREG_MONORECORD           0x6f
 149 #define ESSSB_IREG_AUDIO2SAMPLE         0x70
 150 #define ESSSB_IREG_AUDIO2MODE           0x71
 151 #define ESSSB_IREG_AUDIO2FILTER         0x72
 152 #define ESSSB_IREG_AUDIO2TCOUNTL        0x74
 153 #define ESSSB_IREG_AUDIO2TCOUNTH        0x76
 154 #define ESSSB_IREG_AUDIO2CONTROL1       0x78
 155 #define ESSSB_IREG_AUDIO2CONTROL2       0x7a
 156 #define ESSSB_IREG_AUDIO2               0x7c
 157
 158 #define ESSSB_REG_RESET                 0x06
 159
 160 #define ESSSB_REG_READDATA              0x0a
 161 #define ESSSB_REG_WRITEDATA             0x0c
 162 #define ESSSB_REG_READSTATUS            0x0c
 163
 164 #define ESSSB_REG_STATUS                0x0e
 165
 166 #define ESS_CMD_EXTSAMPLERATE           0xa1
 167 #define ESS_CMD_FILTERDIV               0xa2
 168 #define ESS_CMD_DMACNTRELOADL           0xa4
 169 #define ESS_CMD_DMACNTRELOADH           0xa5
 170 #define ESS_CMD_ANALOGCONTROL           0xa8
 171 #define ESS_CMD_IRQCONTROL              0xb1
 172 #define ESS_CMD_DRQCONTROL              0xb2
 173 #define ESS_CMD_RECLEVEL                0xb4
 174 #define ESS_CMD_SETFORMAT               0xb6
 175 #define ESS_CMD_SETFORMAT2              0xb7
 176 #define ESS_CMD_DMACONTROL              0xb8
 177 #define ESS_CMD_DMATYPE                 0xb9
 178 #define ESS_CMD_OFFSETLEFT              0xba
 179 #define ESS_CMD_OFFSETRIGHT             0xbb
 180 #define ESS_CMD_READREG                 0xc0
 181 #define ESS_CMD_ENABLEEXT               0xc6
 182 #define ESS_CMD_PAUSEDMA                0xd0
 183 #define ESS_CMD_ENABLEAUDIO1            0xd1
 184 #define ESS_CMD_STOPAUDIO1              0xd3
 185 #define ESS_CMD_AUDIO1STATUS            0xd8
 186 #define ESS_CMD_CONTDMA                 0xd4
 187 #define ESS_CMD_TESTIRQ                 0xf2
 188
 189 #define ESS_RECSRC_MIC          0
 190 #define ESS_RECSRC_AUXACD       2
 191 #define ESS_RECSRC_AUXB         5
 192 #define ESS_RECSRC_LINE         6
 193 #define ESS_RECSRC_NONE         7
 194
 195 #define DAC1 0x01
 196 #define ADC1 0x02
 197 #define DAC2 0x04
 198
 199 /*
 200
 201  */
 202
 203 typedef struct _snd_es1938 es1938_t;
 204
 205 struct _snd_es1938 {
 206         int irq;
 207
 208         unsigned long io_port;
 209         struct resource *res_io_port;
 210         unsigned long sb_port;
 211         struct resource *res_sb_port;
 212         unsigned long vc_port;
 213         struct resource *res_vc_port;
 214         unsigned long mpu_port;
 215         struct resource *res_mpu_port;
 216         unsigned long game_port;
 217         struct resource *res_game_port;
 218         unsigned long ddma_port;
 219
 220         unsigned char irqmask;
 221         unsigned char revision;
 222
 223         snd_kcontrol_t *hw_volume;
 224         snd_kcontrol_t *hw_switch;
 225         snd_kcontrol_t *master_volume;
 226         snd_kcontrol_t *master_switch;
 227
 228         struct pci_dev *pci;
 229         snd_card_t *card;
 230         snd_pcm_substream_t *capture_substream;
 231         snd_pcm_substream_t *playback1_substream;
 232         snd_pcm_substream_t *playback2_substream;
 233         snd_kmixer_t *mixer;
 234         snd_rawmidi_t *rmidi;
 235
 236         unsigned int dma1_size;
 237         unsigned int dma2_size;
 238         unsigned int dma1_start;
 239         unsigned int dma2_start;
 240         unsigned int dma1_shift;
 241         unsigned int dma2_shift;
 242         unsigned int active;
 243
 244         spinlock_t reg_lock;
 245         spinlock_t mixer_lock;
 246         snd_info_entry_t *proc_entry;
 247
 248 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
 249         struct gameport gameport;
 250 #endif
 251 };
 252
 253 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 254
 255 static struct pci_device_id snd_es1938_ids[] = {
 256         { 0x125d, 0x1969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* Solo-1 */
 257         { 0, }
 258 };
 259
 260 MODULE_DEVICE_TABLE(pci, snd_es1938_ids);
 261
 262 #define RESET_LOOP_TIMEOUT      0x10000
 263 #define WRITE_LOOP_TIMEOUT      0x10000
 264 #define GET_LOOP_TIMEOUT        0x01000
 265
 266 #undef REG_DEBUG
 267 /* -----------------------------------------------------------------
 268  * Write to a mixer register
 269  * -----------------------------------------------------------------*/
 270 static void snd_es1938_mixer_write(es1938_t *chip, unsigned char reg, unsigned char val)
 271 {
 272         unsigned long flags;
 273         spin_lock_irqsave(&chip->mixer_lock, flags);
 274         outb(reg, SLSB_REG(chip, MIXERADDR));
 275         outb(val, SLSB_REG(chip, MIXERDATA));
 276         spin_unlock_irqrestore(&chip->mixer_lock, flags);
 277 #ifdef REG_DEBUG
 278         snd_printk("Mixer reg %02x set to %02x\n", reg, val);
 279 #endif
 280 }
 281
 282 /* -----------------------------------------------------------------
 283  * Read from a mixer register
 284  * -----------------------------------------------------------------*/
 285 static int snd_es1938_mixer_read(es1938_t *chip, unsigned char reg)
 286 {
 287         int data;
 288         unsigned long flags;
 289         spin_lock_irqsave(&chip->mixer_lock, flags);
 290         outb(reg, SLSB_REG(chip, MIXERADDR));
 291         data = inb(SLSB_REG(chip, MIXERDATA));
 292         spin_unlock_irqrestore(&chip->mixer_lock, flags);
 293 #ifdef REG_DEBUG
 294         snd_printk("Mixer reg %02x now is %02x\n", reg, data);
 295 #endif
 296         return data;
 297 }
 298
 299 /* -----------------------------------------------------------------
 300  * Write to some bits of a mixer register (return old value)
 301  * -----------------------------------------------------------------*/
 302 static int snd_es1938_mixer_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val)
 303 {
 304         unsigned long flags;
 305         unsigned char old, new, oval;
 306         spin_lock_irqsave(&chip->mixer_lock, flags);
 307         outb(reg, SLSB_REG(chip, MIXERADDR));
 308         old = inb(SLSB_REG(chip, MIXERDATA));
 309         oval = old & mask;
 310         if (val != oval) {
 311                 new = (old & ~mask) | (val & mask);
 312                 outb(new, SLSB_REG(chip, MIXERDATA));
 313 #ifdef REG_DEBUG
 314                 snd_printk("Mixer reg %02x was %02x, set to %02x\n", reg, old, new);
 315 #endif
 316         }
 317         spin_unlock_irqrestore(&chip->mixer_lock, flags);
 318         return oval;
 319 }
 320
 321 /* -----------------------------------------------------------------
 322  * Write command to Controller Registers
 323  * -----------------------------------------------------------------*/
 324 static void snd_es1938_write_cmd(es1938_t *chip, unsigned char cmd)
 325 {
 326         int i;
 327         unsigned char v;
 328         for (i = 0; i < WRITE_LOOP_TIMEOUT; i++) {
 329                 if (!(v = inb(SLSB_REG(chip, READSTATUS)) & 0x80)) {
 330                         outb(cmd, SLSB_REG(chip, WRITEDATA));
 331                         return;
 332                 }
 333         }
 334         printk("snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v);
 335 }
 336
 337 /* -----------------------------------------------------------------
 338  * Read the Read Data Buffer
 339  * -----------------------------------------------------------------*/
 340 static int snd_es1938_get_byte(es1938_t *chip)
 341 {
 342         int i;
 343         unsigned char v;
 344         for (i = GET_LOOP_TIMEOUT; i; i--)
 345                 if ((v = inb(SLSB_REG(chip, STATUS))) & 0x80)
 346                         return inb(SLSB_REG(chip, READDATA));
 347         snd_printk("get_byte timeout: status 0x02%x\n", v);
 348         return -ENODEV;
 349 }
 350
 351 /* -----------------------------------------------------------------
 352  * Write value cmd register
 353  * -----------------------------------------------------------------*/
 354 static void snd_es1938_write(es1938_t *chip, unsigned char reg, unsigned char val)
 355 {
 356         unsigned long flags;
 357         spin_lock_irqsave(&chip->reg_lock, flags);
 358         snd_es1938_write_cmd(chip, reg);
 359         snd_es1938_write_cmd(chip, val);
 360         spin_unlock_irqrestore(&chip->reg_lock, flags);
 361 #ifdef REG_DEBUG
 362         snd_printk("Reg %02x set to %02x\n", reg, val);
 363 #endif
 364 }
 365
 366 /* -----------------------------------------------------------------
 367  * Read data from cmd register and return it
 368  * -----------------------------------------------------------------*/
 369 static unsigned char snd_es1938_read(es1938_t *chip, unsigned char reg)
 370 {
 371         unsigned char val;
 372         unsigned long flags;
 373         spin_lock_irqsave(&chip->reg_lock, flags);
 374         snd_es1938_write_cmd(chip, ESS_CMD_READREG);
 375         snd_es1938_write_cmd(chip, reg);
 376         val = snd_es1938_get_byte(chip);
 377         spin_unlock_irqrestore(&chip->reg_lock, flags);
 378 #ifdef REG_DEBUG
 379         snd_printk("Reg %02x now is %02x\n", reg, val);
 380 #endif
 381         return val;
 382 }
 383
 384 /* -----------------------------------------------------------------
 385  * Write data to cmd register and return old value
 386  * -----------------------------------------------------------------*/
 387 static int snd_es1938_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val)
 388 {
 389         unsigned long flags;
 390         unsigned char old, new, oval;
 391         spin_lock_irqsave(&chip->reg_lock, flags);
 392         snd_es1938_write_cmd(chip, ESS_CMD_READREG);
 393         snd_es1938_write_cmd(chip, reg);
 394         old = snd_es1938_get_byte(chip);
 395         oval = old & mask;
 396         if (val != oval) {
 397                 snd_es1938_write_cmd(chip, reg);
 398                 new = (old & ~mask) | (val & mask);
 399                 snd_es1938_write_cmd(chip, new);
 400 #ifdef REG_DEBUG
 401                 snd_printk("Reg %02x was %02x, set to %02x\n", reg, old, new);
 402 #endif
 403         }
 404         spin_unlock_irqrestore(&chip->reg_lock, flags);
 405         return oval;
 406 }
 407
 408 /* --------------------------------------------------------------------
 409  * Reset the chip
 410  * --------------------------------------------------------------------*/
 411 static void snd_es1938_reset(es1938_t *chip)
 412 {
 413         int i;
 414
 415         outb(3, SLSB_REG(chip, RESET));
 416         inb(SLSB_REG(chip, RESET));
 417         outb(0, SLSB_REG(chip, RESET));
 418         for (i = 0; i < RESET_LOOP_TIMEOUT; i++) {
 419                 if (inb(SLSB_REG(chip, STATUS)) & 0x80) {
 420                         if (inb(SLSB_REG(chip, READDATA)) == 0xaa)
 421                                 goto __next;
 422                 }
 423         }
 424         snd_printk("ESS Solo-1 reset failed\n");
 425
 426      __next:
 427         snd_es1938_write_cmd(chip, ESS_CMD_ENABLEEXT);
 428
 429         /* Demand transfer DMA: 4 bytes per DMA request */
 430         snd_es1938_write(chip, ESS_CMD_DMATYPE, 2);
 431
 432         /* Change behaviour of register A1
 433            4x oversampling
 434            2nd channel DAC asynchronous */
 435         snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2MODE, 0x32);
 436         /* enable/select DMA channel and IRQ channel */
 437         snd_es1938_bits(chip, ESS_CMD_IRQCONTROL, 0xf0, 0x50);
 438         snd_es1938_bits(chip, ESS_CMD_DRQCONTROL, 0xf0, 0x50);
 439         snd_es1938_write_cmd(chip, ESS_CMD_ENABLEAUDIO1);
 440         /* Set spatializer parameters to recommended values */
 441         snd_es1938_mixer_write(chip, 0x54, 0x8f);
 442         snd_es1938_mixer_write(chip, 0x56, 0x95);
 443         snd_es1938_mixer_write(chip, 0x58, 0x94);
 444         snd_es1938_mixer_write(chip, 0x5a, 0x80);
 445 }
 446
 447 /* --------------------------------------------------------------------
 448  * Reset the FIFOs
 449  * --------------------------------------------------------------------*/
 450 static void snd_es1938_reset_fifo(es1938_t *chip)
 451 {
 452         outb(2, SLSB_REG(chip, RESET));
 453         outb(0, SLSB_REG(chip, RESET));
 454 }
 455
 456 static ratnum_t clocks[2] = {
 457         {
 458                 .num = 793800,
 459                 .den_min = 1,
 460                 .den_max = 128,
 461                 .den_step = 1,
 462         },
 463         {
 464                 .num = 768000,
 465                 .den_min = 1,
 466                 .den_max = 128,
 467                 .den_step = 1,
 468         }
 469 };
 470
 471 static snd_pcm_hw_constraint_ratnums_t hw_constraints_clocks = {
 472         .nrats = 2,
 473         .rats = clocks,
 474 };
 475
 476
 477 static void snd_es1938_rate_set(es1938_t *chip,
 478                                 snd_pcm_substream_t *substream,
 479                                 int mode)
 480 {
 481         unsigned int bits, div0;
 482         snd_pcm_runtime_t *runtime = substream->runtime;
 483         if (runtime->rate_num == clocks[0].num)
 484                 bits = 128 - runtime->rate_den;
 485         else
 486                 bits = 256 - runtime->rate_den;
 487
 488         /* set filter register */
 489         div0 = 256 - 7160000*20/(8*82*runtime->rate);
 490
 491         if (mode == DAC2) {
 492                 snd_es1938_mixer_write(chip, 0x70, bits);
 493                 snd_es1938_mixer_write(chip, 0x72, div0);
 494         } else {
 495                 snd_es1938_write(chip, 0xA1, bits);
 496                 snd_es1938_write(chip, 0xA2, div0);
 497         }
 498 }
 499
 500 /* --------------------------------------------------------------------
 501  * Configure Solo1 builtin DMA Controller
 502  * --------------------------------------------------------------------*/
 503
 504 static void snd_es1938_playback1_setdma(es1938_t *chip)
 505 {
 506         outb(0x00, SLIO_REG(chip, AUDIO2MODE));
 507         outl(chip->dma2_start, SLIO_REG(chip, AUDIO2DMAADDR));
 508         outw(0, SLIO_REG(chip, AUDIO2DMACOUNT));
 509         outw(chip->dma2_size, SLIO_REG(chip, AUDIO2DMACOUNT));
 510 }
 511
 512 static void snd_es1938_playback2_setdma(es1938_t *chip)
 513 {
 514         /* Enable DMA controller */
 515         outb(0xc4, SLDM_REG(chip, DMACOMMAND));
 516         /* 1. Master reset */
 517         outb(0, SLDM_REG(chip, DMACLEAR));
 518         /* 2. Mask DMA */
 519         outb(1, SLDM_REG(chip, DMAMASK));
 520         outb(0x18, SLDM_REG(chip, DMAMODE));
 521         outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
 522         outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
 523         /* 3. Unmask DMA */
 524         outb(0, SLDM_REG(chip, DMAMASK));
 525 }
 526
 527 static void snd_es1938_capture_setdma(es1938_t *chip)
 528 {
 529         /* Enable DMA controller */
 530         outb(0xc4, SLDM_REG(chip, DMACOMMAND));
 531         /* 1. Master reset */
 532         outb(0, SLDM_REG(chip, DMACLEAR));
 533         /* 2. Mask DMA */
 534         outb(1, SLDM_REG(chip, DMAMASK));
 535         outb(0x14, SLDM_REG(chip, DMAMODE));
 536         outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
 537         outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
 538         /* 3. Unmask DMA */
 539         outb(0, SLDM_REG(chip, DMAMASK));
 540 }
 541
 542 /* ----------------------------------------------------------------------
 543  *
 544  *                           *** PCM part ***
 545  */
 546
 547 static int snd_es1938_capture_trigger(snd_pcm_substream_t * substream,
 548                                       int cmd)
 549 {
 550         es1938_t *chip = snd_pcm_substream_chip(substream);
 551         int val;
 552         switch (cmd) {
 553         case SNDRV_PCM_TRIGGER_START:
 554                 val = 0x0f;
 555                 chip->active |= ADC1;
 556                 break;
 557         case SNDRV_PCM_TRIGGER_STOP:
 558                 val = 0x00;
 559                 chip->active &= ~ADC1;
 560                 break;
 561         default:
 562                 return -EINVAL;
 563         }
 564         snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
 565         return 0;
 566 }
 567
 568 static int snd_es1938_playback1_trigger(snd_pcm_substream_t * substream,
 569                                         int cmd)
 570 {
 571         es1938_t *chip = snd_pcm_substream_chip(substream);
 572         switch (cmd) {
 573         case SNDRV_PCM_TRIGGER_START:
 574                 /* According to the documentation this should be:
 575                    0x13 but that value may randomly swap stereo channels */
 576                 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x93);
 577                 outb(0x0a, SLIO_REG(chip, AUDIO2MODE));
 578                 chip->active |= DAC2;
 579                 break;
 580         case SNDRV_PCM_TRIGGER_STOP:
 581                 outb(0, SLIO_REG(chip, AUDIO2MODE));
 582                 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0);
 583                 chip->active &= ~DAC2;
 584                 break;
 585         default:
 586                 return -EINVAL;
 587         }
 588         return 0;
 589 }
 590
 591 static int snd_es1938_playback2_trigger(snd_pcm_substream_t * substream,
 592                                         int cmd)
 593 {
 594         es1938_t *chip = snd_pcm_substream_chip(substream);
 595         int val;
 596         switch (cmd) {
 597         case SNDRV_PCM_TRIGGER_START:
 598                 val = 5;
 599                 chip->active |= DAC1;
 600                 break;
 601         case SNDRV_PCM_TRIGGER_STOP:
 602                 val = 0;
 603                 chip->active &= ~DAC1;
 604                 break;
 605         default:
 606                 return -EINVAL;
 607         }
 608         snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
 609         return 0;
 610 }
 611
 612 static int snd_es1938_playback_trigger(snd_pcm_substream_t *substream,
 613                                        int cmd)
 614 {
 615         switch (substream->number) {
 616         case 0:
 617                 return snd_es1938_playback1_trigger(substream, cmd);
 618         case 1:
 619                 return snd_es1938_playback2_trigger(substream, cmd);
 620         }
 621         snd_BUG();
 622         return -EINVAL;
 623 }
 624
 625 /* --------------------------------------------------------------------
 626  * First channel for Extended Mode Audio 1 ADC Operation
 627  * --------------------------------------------------------------------*/
 628 static int snd_es1938_capture_prepare(snd_pcm_substream_t * substream)
 629 {
 630         es1938_t *chip = snd_pcm_substream_chip(substream);
 631         snd_pcm_runtime_t *runtime = substream->runtime;
 632         int u, is8, mono;
 633         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
 634         unsigned int count = snd_pcm_lib_period_bytes(substream);
 635
 636         chip->dma1_size = size;
 637         chip->dma1_start = runtime->dma_addr;
 638
 639         mono = (runtime->channels > 1) ? 0 : 1;
 640         is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
 641         u = snd_pcm_format_unsigned(runtime->format);
 642
 643         chip->dma1_shift = 2 - mono - is8;
 644
 645         snd_es1938_reset_fifo(chip);
 646
 647         /* program type */
 648         snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
 649
 650         /* set clock and counters */
 651         snd_es1938_rate_set(chip, substream, ADC1);
 652
 653         count = 0x10000 - count;
 654         snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
 655         snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
 656
 657         /* initialize and configure ADC */
 658         snd_es1938_write(chip, ESS_CMD_SETFORMAT2, u ? 0x51 : 0x71);
 659         snd_es1938_write(chip, ESS_CMD_SETFORMAT2, 0x90 |
 660                        (u ? 0x00 : 0x20) |
 661                        (is8 ? 0x00 : 0x04) |
 662                        (mono ? 0x40 : 0x08));
 663
 664         //      snd_es1938_reset_fifo(chip);
 665
 666         /* 11. configure system interrupt controller and DMA controller */
 667         snd_es1938_capture_setdma(chip);
 668
 669         return 0;
 670 }
 671
 672
 673 /* ------------------------------------------------------------------------------
 674  * Second Audio channel DAC Operation
 675  * ------------------------------------------------------------------------------*/
 676 static int snd_es1938_playback1_prepare(snd_pcm_substream_t * substream)
 677 {
 678         es1938_t *chip = snd_pcm_substream_chip(substream);
 679         snd_pcm_runtime_t *runtime = substream->runtime;
 680         int u, is8, mono;
 681         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
 682         unsigned int count = snd_pcm_lib_period_bytes(substream);
 683
 684         chip->dma2_size = size;
 685         chip->dma2_start = runtime->dma_addr;
 686
 687         mono = (runtime->channels > 1) ? 0 : 1;
 688         is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
 689         u = snd_pcm_format_unsigned(runtime->format);
 690
 691         chip->dma2_shift = 2 - mono - is8;
 692
 693         /* set clock and counters */
 694         snd_es1938_rate_set(chip, substream, DAC2);
 695
 696         count >>= 1;
 697         count = 0x10000 - count;
 698         snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTL, count & 0xff);
 699         snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTH, count >> 8);
 700
 701         /* initialize and configure Audio 2 DAC */
 702         snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) | (mono ? 0 : 2) | (is8 ? 0 : 1));
 703
 704         /* program DMA */
 705         snd_es1938_playback1_setdma(chip);
 706
 707         return 0;
 708 }
 709
 710 static int snd_es1938_playback2_prepare(snd_pcm_substream_t * substream)
 711 {
 712         es1938_t *chip = snd_pcm_substream_chip(substream);
 713         snd_pcm_runtime_t *runtime = substream->runtime;
 714         int u, is8, mono;
 715         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
 716         unsigned int count = snd_pcm_lib_period_bytes(substream);
 717
 718         chip->dma1_size = size;
 719         chip->dma1_start = runtime->dma_addr;
 720
 721         mono = (runtime->channels > 1) ? 0 : 1;
 722         is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
 723         u = snd_pcm_format_unsigned(runtime->format);
 724
 725         chip->dma1_shift = 2 - mono - is8;
 726
 727         count = 0x10000 - count;
 728
 729         /* reset */
 730         snd_es1938_reset_fifo(chip);
 731
 732         snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
 733
 734         /* set clock and counters */
 735         snd_es1938_rate_set(chip, substream, DAC1);
 736         snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
 737         snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
 738
 739         /* initialized and configure DAC */
 740         snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x80 : 0x00);
 741         snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x51 : 0x71);
 742         snd_es1938_write(chip, ESS_CMD_SETFORMAT2,
 743                          0x90 | (mono ? 0x40 : 0x08) |
 744                          (is8 ? 0x00 : 0x04) | (u ? 0x00 : 0x20));
 745
 746         /* program DMA */
 747         snd_es1938_playback2_setdma(chip);
 748
 749         return 0;
 750 }
 751
 752 static int snd_es1938_playback_prepare(snd_pcm_substream_t *substream)
 753 {
 754         switch (substream->number) {
 755         case 0:
 756                 return snd_es1938_playback1_prepare(substream);
 757         case 1:
 758                 return snd_es1938_playback2_prepare(substream);
 759         }
 760         snd_BUG();
 761         return -EINVAL;
 762 }
 763
 764 static snd_pcm_uframes_t snd_es1938_capture_pointer(snd_pcm_substream_t * substream)
 765 {
 766         es1938_t *chip = snd_pcm_substream_chip(substream);
 767         size_t ptr;
 768         size_t old, new;
 769 #if 1
 770         /* This stuff is *needed*, don't ask why - AB */
 771         old = inw(SLDM_REG(chip, DMACOUNT));
 772         while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
 773                 old = new;
 774         ptr = chip->dma1_size - 1 - new;
 775 #else
 776         ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start;
 777 #endif
 778         return ptr >> chip->dma1_shift;
 779 }
 780
 781 static snd_pcm_uframes_t snd_es1938_playback1_pointer(snd_pcm_substream_t * substream)
 782 {
 783         es1938_t *chip = snd_pcm_substream_chip(substream);
 784         size_t ptr;
 785 #if 1
 786         ptr = chip->dma2_size - inw(SLIO_REG(chip, AUDIO2DMACOUNT));
 787 #else
 788         ptr = inl(SLIO_REG(chip, AUDIO2DMAADDR)) - chip->dma2_start;
 789 #endif
 790         return ptr >> chip->dma2_shift;
 791 }
 792
 793 static snd_pcm_uframes_t snd_es1938_playback2_pointer(snd_pcm_substream_t * substream)
 794 {
 795         es1938_t *chip = snd_pcm_substream_chip(substream);
 796         size_t ptr;
 797         size_t old, new;
 798 #if 1
 799         /* This stuff is *needed*, don't ask why - AB */
 800         old = inw(SLDM_REG(chip, DMACOUNT));
 801         while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
 802                 old = new;
 803         ptr = chip->dma1_size - 1 - new;
 804 #else
 805         ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start;
 806 #endif
 807         return ptr >> chip->dma1_shift;
 808 }
 809
 810 static snd_pcm_uframes_t snd_es1938_playback_pointer(snd_pcm_substream_t *substream)
 811 {
 812         switch (substream->number) {
 813         case 0:
 814                 return snd_es1938_playback1_pointer(substream);
 815         case 1:
 816                 return snd_es1938_playback2_pointer(substream);
 817         }
 818         snd_BUG();
 819         return -EINVAL;
 820 }
 821
 822 static int snd_es1938_capture_copy(snd_pcm_substream_t *substream,
 823                                    int channel,
 824                                    snd_pcm_uframes_t pos,
 825                                    void __user *dst,
 826                                    snd_pcm_uframes_t count)
 827 {
 828         snd_pcm_runtime_t *runtime = substream->runtime;
 829         es1938_t *chip = snd_pcm_substream_chip(substream);
 830         pos <<= chip->dma1_shift;
 831         count <<= chip->dma1_shift;
 832         snd_assert(pos + count <= chip->dma1_size, return -EINVAL);
 833         if (pos + count < chip->dma1_size) {
 834                 if (copy_to_user(dst, runtime->dma_area + pos + 1, count))
 835                         return -EFAULT;
 836         } else {
 837                 if (copy_to_user(dst, runtime->dma_area + pos + 1, count - 1))
 838                         return -EFAULT;
 839                 if (put_user(runtime->dma_area[0], ((unsigned char __user *)dst) + count - 1))
 840                         return -EFAULT;
 841         }
 842         return 0;
 843 }
 844
 845 /*
 846  * buffer management
 847  */
 848 static int snd_es1938_pcm_hw_params(snd_pcm_substream_t *substream,
 849                                     snd_pcm_hw_params_t * hw_params)
 850
 851 {
 852         int err;
 853
 854         if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
 855                 return err;
 856         return 0;
 857 }
 858
 859 static int snd_es1938_pcm_hw_free(snd_pcm_substream_t *substream)
 860 {
 861         return snd_pcm_lib_free_pages(substream);
 862 }
 863
 864 /* ----------------------------------------------------------------------
 865  * Audio1 Capture (ADC)
 866  * ----------------------------------------------------------------------*/
 867 static snd_pcm_hardware_t snd_es1938_capture =
 868 {
 869         .info =                 (SNDRV_PCM_INFO_INTERLEAVED |
 870                                 SNDRV_PCM_INFO_BLOCK_TRANSFER),
 871         .formats =              SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE,
 872         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
 873         .rate_min =             6000,
 874         .rate_max =             48000,
 875         .channels_min =         1,
 876         .channels_max =         2,
 877         .buffer_bytes_max =     65536,
 878         .period_bytes_min =     64,
 879         .period_bytes_max =     65536,
 880         .periods_min =          1,
 881         .periods_max =          1024,
 882         .fifo_size =            256,
 883 };
 884
 885 /* -----------------------------------------------------------------------
 886  * Audio2 Playback (DAC)
 887  * -----------------------------------------------------------------------*/
 888 static snd_pcm_hardware_t snd_es1938_playback =
 889 {
 890         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
 891                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
 892                                  SNDRV_PCM_INFO_MMAP_VALID),
 893         .formats =              SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE,
 894         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
 895         .rate_min =             6000,
 896         .rate_max =             48000,
 897         .channels_min =         1,
 898         .channels_max =         2,
 899         .buffer_bytes_max =     65536,
 900         .period_bytes_min =     64,
 901         .period_bytes_max =     65536,
 902         .periods_min =          1,
 903         .periods_max =          1024,
 904         .fifo_size =            256,
 905 };
 906
 907 static int snd_es1938_capture_open(snd_pcm_substream_t * substream)
 908 {
 909         es1938_t *chip = snd_pcm_substream_chip(substream);
 910         snd_pcm_runtime_t *runtime = substream->runtime;
 911
 912         if (chip->playback2_substream)
 913                 return -EAGAIN;
 914         chip->capture_substream = substream;
 915         runtime->hw = snd_es1938_capture;
 916         snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 917                                       &hw_constraints_clocks);
 918         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
 919         return 0;
 920 }
 921
 922 static int snd_es1938_playback_open(snd_pcm_substream_t * substream)
 923 {
 924         es1938_t *chip = snd_pcm_substream_chip(substream);
 925         snd_pcm_runtime_t *runtime = substream->runtime;
 926
 927         switch (substream->number) {
 928         case 0:
 929                 chip->playback1_substream = substream;
 930                 break;
 931         case 1:
 932                 if (chip->capture_substream)
 933                         return -EAGAIN;
 934                 chip->playback2_substream = substream;
 935                 break;
 936         default:
 937                 snd_BUG();
 938                 return -EINVAL;
 939         }
 940         runtime->hw = snd_es1938_playback;
 941         snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 942                                       &hw_constraints_clocks);
 943         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
 944         return 0;
 945 }
 946
 947 static int snd_es1938_capture_close(snd_pcm_substream_t * substream)
 948 {
 949         es1938_t *chip = snd_pcm_substream_chip(substream);
 950
 951         chip->capture_substream = NULL;
 952         return 0;
 953 }
 954
 955 static int snd_es1938_playback_close(snd_pcm_substream_t * substream)
 956 {
 957         es1938_t *chip = snd_pcm_substream_chip(substream);
 958
 959         switch (substream->number) {
 960         case 0:
 961                 chip->playback1_substream = NULL;
 962                 break;
 963         case 1:
 964                 chip->playback2_substream = NULL;
 965                 break;
 966         default:
 967                 snd_BUG();
 968                 return -EINVAL;
 969         }
 970         return 0;
 971 }
 972
 973 static snd_pcm_ops_t snd_es1938_playback_ops = {
 974         .open =         snd_es1938_playback_open,
 975         .close =        snd_es1938_playback_close,
 976         .ioctl =        snd_pcm_lib_ioctl,
 977         .hw_params =    snd_es1938_pcm_hw_params,
 978         .hw_free =      snd_es1938_pcm_hw_free,
 979         .prepare =      snd_es1938_playback_prepare,
 980         .trigger =      snd_es1938_playback_trigger,
 981         .pointer =      snd_es1938_playback_pointer,
 982 };
 983
 984 static snd_pcm_ops_t snd_es1938_capture_ops = {
 985         .open =         snd_es1938_capture_open,
 986         .close =        snd_es1938_capture_close,
 987         .ioctl =        snd_pcm_lib_ioctl,
 988         .hw_params =    snd_es1938_pcm_hw_params,
 989         .hw_free =      snd_es1938_pcm_hw_free,
 990         .prepare =      snd_es1938_capture_prepare,
 991         .trigger =      snd_es1938_capture_trigger,
 992         .pointer =      snd_es1938_capture_pointer,
 993         .copy =         snd_es1938_capture_copy,
 994 };
 995
 996 static void snd_es1938_free_pcm(snd_pcm_t *pcm)
 997 {
 998         snd_pcm_lib_preallocate_free_for_all(pcm);
 999 }
1000
1001 static int __devinit snd_es1938_new_pcm(es1938_t *chip, int device, snd_pcm_t ** rpcm)
1002 {
1003         snd_pcm_t *pcm;
1004         int err;
1005
1006         if (rpcm)
1007                 *rpcm = NULL;
1008         if ((err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm)) < 0)
1009                 return err;
1010         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1938_playback_ops);
1011         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1938_capture_ops);
1012
1013         pcm->private_data = chip;
1014         pcm->private_free = snd_es1938_free_pcm;
1015         pcm->info_flags = 0;
1016         strcpy(pcm->name, "ESS Solo-1");
1017
1018         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1019                                               snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
1020
1021         if (rpcm)
1022                 *rpcm = 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_magic_cast(es1938_t, _snd_kcontrol_chip(kcontrol), return);
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 static int snd_es1938_free(es1938_t *chip)
1344 {
1345         /*if (chip->rmidi)
1346           snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0);*/
1347 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
1348         if (chip->gameport.io)
1349                 gameport_unregister_port(&chip->gameport);
1350 #endif
1351         if (chip->res_io_port) {
1352                 release_resource(chip->res_io_port);
1353                 kfree_nocheck(chip->res_io_port);
1354         }
1355         if (chip->res_sb_port) {
1356                 release_resource(chip->res_sb_port);
1357                 kfree_nocheck(chip->res_sb_port);
1358         }
1359         if (chip->res_vc_port) {
1360                 release_resource(chip->res_vc_port);
1361                 kfree_nocheck(chip->res_vc_port);
1362         }
1363         if (chip->res_mpu_port) {
1364                 release_resource(chip->res_mpu_port);
1365                 kfree_nocheck(chip->res_mpu_port);
1366         }
1367         if (chip->res_game_port) {
1368                 release_resource(chip->res_game_port);
1369                 kfree_nocheck(chip->res_game_port);
1370         }
1371         if (chip->irq >= 0)
1372                 free_irq(chip->irq, (void *)chip);
1373         snd_magic_kfree(chip);
1374         return 0;
1375 }
1376
1377 static int snd_es1938_dev_free(snd_device_t *device)
1378 {
1379         es1938_t *chip = snd_magic_cast(es1938_t, device->device_data, return -ENXIO);
1380         return snd_es1938_free(chip);
1381 }
1382
1383 static int __devinit snd_es1938_create(snd_card_t * card,
1384                                     struct pci_dev * pci,
1385                                     es1938_t ** rchip)
1386 {
1387         es1938_t *chip;
1388         int err;
1389         static snd_device_ops_t ops = {
1390                 .dev_free =     snd_es1938_dev_free,
1391         };
1392
1393         *rchip = NULL;
1394
1395         /* enable PCI device */
1396         if ((err = pci_enable_device(pci)) < 0)
1397                 return err;
1398         /* check, if we can restrict PCI DMA transfers to 24 bits */
1399         if (pci_set_dma_mask(pci, 0x00ffffff) < 0 ||
1400             pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) {
1401                 snd_printk("architecture does not support 24bit PCI busmaster DMA\n");
1402                 return -ENXIO;
1403         }
1404
1405         chip = snd_magic_kcalloc(es1938_t, 0, GFP_KERNEL);
1406         if (chip == NULL)
1407                 return -ENOMEM;
1408         spin_lock_init(&chip->reg_lock);
1409         spin_lock_init(&chip->mixer_lock);
1410         chip->card = card;
1411         chip->pci = pci;
1412         chip->io_port = pci_resource_start(pci, 0);
1413         if ((chip->res_io_port = request_region(chip->io_port, 8, "ESS Solo-1")) == NULL) {
1414                 snd_printk("unable to grab region 0x%lx-0x%lx\n", chip->io_port, chip->io_port + 8 - 1);
1415                 snd_es1938_free(chip);
1416                 return -EBUSY;
1417         }
1418         chip->sb_port = pci_resource_start(pci, 1);
1419         if ((chip->res_sb_port = request_region(chip->sb_port, 0x10, "ESS Solo-1 SB")) == NULL) {
1420                 snd_printk("unable to grab SB region 0x%lx-0x%lx\n", chip->sb_port, chip->sb_port + 0x10 - 1);
1421                 snd_es1938_free(chip);
1422                 return -EBUSY;
1423         }
1424         chip->vc_port = pci_resource_start(pci, 2);
1425         if ((chip->res_vc_port = request_region(chip->vc_port, 0x10, "ESS Solo-1 VC (DMA)")) == NULL) {
1426                 snd_printk("unable to grab VC (DMA) region 0x%lx-0x%lx\n", chip->vc_port, chip->vc_port + 0x10 - 1);
1427                 snd_es1938_free(chip);
1428                 return -EBUSY;
1429         }
1430         chip->mpu_port = pci_resource_start(pci, 3);
1431         if ((chip->res_mpu_port = request_region(chip->mpu_port, 4, "ESS Solo-1 MIDI")) == NULL) {
1432                 snd_printk("unable to grab MIDI region 0x%lx-0x%lx\n", chip->mpu_port, chip->mpu_port + 4 - 1);
1433                 snd_es1938_free(chip);
1434                 return -EBUSY;
1435         }
1436         chip->game_port = pci_resource_start(pci, 4);
1437         if ((chip->res_game_port = request_region(chip->game_port, 4, "ESS Solo-1 GAME")) == NULL) {
1438                 snd_printk("unable to grab GAME region 0x%lx-0x%lx\n", chip->game_port, chip->game_port + 4 - 1);
1439                 snd_es1938_free(chip);
1440                 return -EBUSY;
1441         }
1442         if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ, "ES1938", (void *)chip)) {
1443                 snd_printk("unable to grab IRQ %d\n", pci->irq);
1444                 snd_es1938_free(chip);
1445                 return -EBUSY;
1446         }
1447         chip->irq = pci->irq;
1448 #ifdef ES1938_DDEBUG
1449         snd_printk("create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
1450                    chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1451 #endif
1452         /* reset chip */
1453         snd_es1938_reset(chip);
1454
1455         /* configure native mode */
1456
1457         /* enable bus master */
1458         pci_set_master(pci);
1459
1460         /* disable legacy audio */
1461         pci_write_config_word(pci, SL_PCI_LEGACYCONTROL, 0x805f);
1462
1463         /* set DDMA base */
1464         chip->ddma_port = chip->vc_port + 0x00;         /* fix from Thomas Sailer */
1465         pci_write_config_word(pci, SL_PCI_DDMACONTROL, chip->ddma_port | 1);
1466
1467         /* set DMA/IRQ policy */
1468         pci_write_config_dword(pci, SL_PCI_CONFIG, 0);
1469
1470         /* enable Audio 1, Audio 2, MPU401 IRQ and HW volume IRQ*/
1471         outb(0xf0, SLIO_REG(chip, IRQCONTROL));
1472
1473         /* reset DMA */
1474         outb(0, SLDM_REG(chip, DMACLEAR));
1475
1476         /* enable bus mastering */
1477         pci_set_master(pci);
1478
1479         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1480                 snd_es1938_free(chip);
1481                 return err;
1482         }
1483
1484         snd_card_set_dev(card, &pci->dev);
1485
1486         *rchip = chip;
1487         return 0;
1488 }
1489
1490 /* --------------------------------------------------------------------
1491  * Interrupt handler
1492  * -------------------------------------------------------------------- */
1493 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1494 {
1495         es1938_t *chip = snd_magic_cast(es1938_t, dev_id, return IRQ_NONE);
1496         unsigned char status, audiostatus;
1497         int handled = 0;
1498
1499         status = inb(SLIO_REG(chip, IRQCONTROL));
1500 #if 0
1501         printk("Es1938debug - interrupt status: =0x%x\n", status);
1502 #endif
1503
1504         /* AUDIO 1 */
1505         if (status & 0x10) {
1506 #if 0
1507                 printk("Es1938debug - AUDIO channel 1 interrupt\n");
1508                 printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n", inw(SLDM_REG(chip, DMACOUNT)));
1509                 printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n", inl(SLDM_REG(chip, DMAADDR)));
1510                 printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n", inl(SLDM_REG(chip, DMASTATUS)));
1511 #endif
1512                 /* clear irq */
1513                 handled = 1;
1514                 audiostatus = inb(SLSB_REG(chip, STATUS));
1515                 if (chip->active & ADC1)
1516                         snd_pcm_period_elapsed(chip->capture_substream);
1517                 else if (chip->active & DAC1)
1518                         snd_pcm_period_elapsed(chip->playback2_substream);
1519         }
1520
1521         /* AUDIO 2 */
1522         if (status & 0x20) {
1523 #if 0
1524                 printk("Es1938debug - AUDIO channel 2 interrupt\n");
1525                 printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n", inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
1526                 printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n", inl(SLIO_REG(chip, AUDIO2DMAADDR)));
1527
1528 #endif
1529                 /* clear irq */
1530                 handled = 1;
1531                 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
1532                 if (chip->active & DAC2)
1533                         snd_pcm_period_elapsed(chip->playback1_substream);
1534         }
1535
1536         /* Hardware volume */
1537         if (status & 0x40) {
1538                 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
1539                 handled = 1;
1540                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
1541                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
1542                 if (!split) {
1543                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_switch->id);
1544                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_volume->id);
1545                 }
1546                 /* ack interrupt */
1547                 snd_es1938_mixer_write(chip, 0x66, 0x00);
1548         }
1549
1550         /* MPU401 */
1551         if (status & 0x80) {
1552                 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
1553                 if (chip->rmidi) {
1554                         handled = 1;
1555                         snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
1556                 }
1557         }
1558         return IRQ_RETVAL(handled);
1559 }
1560
1561 #define ES1938_DMA_SIZE 64
1562
1563 static int __devinit snd_es1938_mixer(snd_pcm_t *pcm)
1564 {
1565         snd_card_t *card;
1566         es1938_t *chip;
1567         unsigned int idx;
1568         int err;
1569
1570         snd_assert(pcm != NULL && pcm->card != NULL, return -EINVAL);
1571
1572         card = pcm->card;
1573         chip = snd_pcm_chip(pcm);
1574
1575         strcpy(card->mixername, pcm->name);
1576
1577         for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
1578                 snd_kcontrol_t *kctl;
1579                 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
1580                 switch (idx) {
1581                         case 0:
1582                                 chip->master_volume = kctl;
1583                                 kctl->private_free = snd_es1938_hwv_free;
1584                                 break;
1585                         case 1:
1586                                 chip->master_switch = kctl;
1587                                 kctl->private_free = snd_es1938_hwv_free;
1588                                 break;
1589                         case 2:
1590                                 chip->hw_volume = kctl;
1591                                 kctl->private_free = snd_es1938_hwv_free;
1592                                 break;
1593                         case 3:
1594                                 chip->hw_switch = kctl;
1595                                 kctl->private_free = snd_es1938_hwv_free;
1596                                 break;
1597                         }
1598                 if ((err = snd_ctl_add(card, kctl)) < 0)
1599                         return err;
1600         }
1601         return 0;
1602 }
1603
1604
1605 static int __devinit snd_es1938_probe(struct pci_dev *pci,
1606                                       const struct pci_device_id *pci_id)
1607 {
1608         static int dev;
1609         snd_card_t *card;
1610         es1938_t *chip;
1611         snd_pcm_t *pcm;
1612         opl3_t *opl3;
1613         int idx, err;
1614
1615         if (dev >= SNDRV_CARDS)
1616                 return -ENODEV;
1617         if (!enable[dev]) {
1618                 dev++;
1619                 return -ENOENT;
1620         }
1621
1622         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
1623         if (card == NULL)
1624                 return -ENOMEM;
1625         for (idx = 0; idx < 5; idx++) {
1626                 if (pci_resource_start(pci, idx) == 0 ||
1627                     !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) {
1628                         snd_card_free(card);
1629                         return -ENODEV;
1630                 }
1631         }
1632         if ((err = snd_es1938_create(card, pci, &chip)) < 0) {
1633                 snd_card_free(card);
1634                 return err;
1635         }
1636
1637         strcpy(card->driver, "ES1938");
1638         strcpy(card->shortname, "ESS ES1938 (Solo-1)");
1639         sprintf(card->longname, "%s rev %i, irq %i",
1640                 card->shortname,
1641                 chip->revision,
1642                 chip->irq);
1643
1644         if ((err = snd_es1938_new_pcm(chip, 0, &pcm)) < 0) {
1645                 snd_card_free(card);
1646                 return err;
1647         }
1648         if ((err = snd_es1938_mixer(pcm)) < 0) {
1649                 snd_card_free(card);
1650                 return err;
1651         }
1652         if (snd_opl3_create(card,
1653                             SLSB_REG(chip, FMLOWADDR),
1654                             SLSB_REG(chip, FMHIGHADDR),
1655                             OPL3_HW_OPL3, 1, &opl3) < 0) {
1656                 printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n",
1657                            SLSB_REG(chip, FMLOWADDR));
1658         } else {
1659                 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
1660                         snd_card_free(card);
1661                         return err;
1662                 }
1663                 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
1664                         snd_card_free(card);
1665                         return err;
1666                 }
1667         }
1668         if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
1669                                 chip->mpu_port, 1, chip->irq, 0, &chip->rmidi) < 0) {
1670                 printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
1671         } /*else
1672             snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);*/
1673
1674 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
1675         chip->gameport.io = chip->game_port;
1676         gameport_register_port(&chip->gameport);
1677 #endif
1678
1679         if ((err = snd_card_register(card)) < 0) {
1680                 snd_card_free(card);
1681                 return err;
1682         }
1683
1684         pci_set_drvdata(pci, card);
1685         dev++;
1686         return 0;
1687 }
1688
1689 static void __devexit snd_es1938_remove(struct pci_dev *pci)
1690 {
1691         snd_card_free(pci_get_drvdata(pci));
1692         pci_set_drvdata(pci, NULL);
1693 }
1694
1695 static struct pci_driver driver = {
1696         .name = "ESS ES1938 (Solo-1)",
1697         .id_table = snd_es1938_ids,
1698         .probe = snd_es1938_probe,
1699         .remove = __devexit_p(snd_es1938_remove),
1700 };
1701
1702 static int __init alsa_card_es1938_init(void)
1703 {
1704         return pci_module_init(&driver);
1705 }
1706
1707 static void __exit alsa_card_es1938_exit(void)
1708 {
1709         pci_unregister_driver(&driver);
1710 }
1711
1712 module_init(alsa_card_es1938_init)
1713 module_exit(alsa_card_es1938_exit)