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 <sound/core.h>
  57 #include <sound/control.h>
  58 #include <sound/pcm.h>
  59 #include <sound/opl3.h>
  60 #include <sound/mpu401.h>
  61 #define SNDRV_GET_ID
  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
  88 MODULE_PARM(index, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
  89 MODULE_PARM_DESC(index, "Index value for ESS Solo-1 soundcard.");
  90 MODULE_PARM_SYNTAX(index, SNDRV_INDEX_DESC);
  91 MODULE_PARM(id, "1-" __MODULE_STRING(SNDRV_CARDS) "s");
  92 MODULE_PARM_DESC(id, "ID string for ESS Solo-1 soundcard.");
  93 MODULE_PARM_SYNTAX(id, SNDRV_ID_DESC);
  94 MODULE_PARM(enable, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
  95 MODULE_PARM_DESC(enable, "Enable ESS Solo-1 soundcard.");
  96 MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
  97
  98 #define SLIO_REG(chip, x) ((chip)->io_port + ESSIO_REG_##x)
  99
 100 #define SLDM_REG(chip, x) ((chip)->ddma_port + ESSDM_REG_##x)
 101
 102 #define SLSB_REG(chip, x) ((chip)->sb_port + ESSSB_REG_##x)
 103
 104 #define SL_PCI_LEGACYCONTROL            0x40
 105 #define SL_PCI_CONFIG                   0x50
 106 #define SL_PCI_DDMACONTROL              0x60
 107
 108 #define ESSIO_REG_AUDIO2DMAADDR         0
 109 #define ESSIO_REG_AUDIO2DMACOUNT        4
 110 #define ESSIO_REG_AUDIO2MODE            6
 111 #define ESSIO_REG_IRQCONTROL            7
 112
 113 #define ESSDM_REG_DMAADDR               0x00
 114 #define ESSDM_REG_DMACOUNT              0x04
 115 #define ESSDM_REG_DMACOMMAND            0x08
 116 #define ESSDM_REG_DMASTATUS             0x08
 117 #define ESSDM_REG_DMAMODE               0x0b
 118 #define ESSDM_REG_DMACLEAR              0x0d
 119 #define ESSDM_REG_DMAMASK               0x0f
 120
 121 #define ESSSB_REG_FMLOWADDR             0x00
 122 #define ESSSB_REG_FMHIGHADDR            0x02
 123 #define ESSSB_REG_MIXERADDR             0x04
 124 #define ESSSB_REG_MIXERDATA             0x05
 125
 126 #define ESSSB_IREG_AUDIO1               0x14
 127 #define ESSSB_IREG_MICMIX               0x1a
 128 #define ESSSB_IREG_RECSRC               0x1c
 129 #define ESSSB_IREG_MASTER               0x32
 130 #define ESSSB_IREG_FM                   0x36
 131 #define ESSSB_IREG_AUXACD               0x38
 132 #define ESSSB_IREG_AUXB                 0x3a
 133 #define ESSSB_IREG_PCSPEAKER            0x3c
 134 #define ESSSB_IREG_LINE                 0x3e
 135 #define ESSSB_IREG_SPATCONTROL          0x50
 136 #define ESSSB_IREG_SPATLEVEL            0x52
 137 #define ESSSB_IREG_MASTER_LEFT          0x60
 138 #define ESSSB_IREG_MASTER_RIGHT         0x62
 139 #define ESSSB_IREG_MPU401CONTROL        0x64
 140 #define ESSSB_IREG_MICMIXRECORD         0x68
 141 #define ESSSB_IREG_AUDIO2RECORD         0x69
 142 #define ESSSB_IREG_AUXACDRECORD         0x6a
 143 #define ESSSB_IREG_FMRECORD             0x6b
 144 #define ESSSB_IREG_AUXBRECORD           0x6c
 145 #define ESSSB_IREG_MONO                 0x6d
 146 #define ESSSB_IREG_LINERECORD           0x6e
 147 #define ESSSB_IREG_MONORECORD           0x6f
 148 #define ESSSB_IREG_AUDIO2SAMPLE         0x70
 149 #define ESSSB_IREG_AUDIO2MODE           0x71
 150 #define ESSSB_IREG_AUDIO2FILTER         0x72
 151 #define ESSSB_IREG_AUDIO2TCOUNTL        0x74
 152 #define ESSSB_IREG_AUDIO2TCOUNTH        0x76
 153 #define ESSSB_IREG_AUDIO2CONTROL1       0x78
 154 #define ESSSB_IREG_AUDIO2CONTROL2       0x7a
 155 #define ESSSB_IREG_AUDIO2               0x7c
 156
 157 #define ESSSB_REG_RESET                 0x06
 158
 159 #define ESSSB_REG_READDATA              0x0a
 160 #define ESSSB_REG_WRITEDATA             0x0c
 161 #define ESSSB_REG_READSTATUS            0x0c
 162
 163 #define ESSSB_REG_STATUS                0x0e
 164
 165 #define ESS_CMD_EXTSAMPLERATE           0xa1
 166 #define ESS_CMD_FILTERDIV               0xa2
 167 #define ESS_CMD_DMACNTRELOADL           0xa4
 168 #define ESS_CMD_DMACNTRELOADH           0xa5
 169 #define ESS_CMD_ANALOGCONTROL           0xa8
 170 #define ESS_CMD_IRQCONTROL              0xb1
 171 #define ESS_CMD_DRQCONTROL              0xb2
 172 #define ESS_CMD_RECLEVEL                0xb4
 173 #define ESS_CMD_SETFORMAT               0xb6
 174 #define ESS_CMD_SETFORMAT2              0xb7
 175 #define ESS_CMD_DMACONTROL              0xb8
 176 #define ESS_CMD_DMATYPE                 0xb9
 177 #define ESS_CMD_OFFSETLEFT              0xba
 178 #define ESS_CMD_OFFSETRIGHT             0xbb
 179 #define ESS_CMD_READREG                 0xc0
 180 #define ESS_CMD_ENABLEEXT               0xc6
 181 #define ESS_CMD_PAUSEDMA                0xd0
 182 #define ESS_CMD_ENABLEAUDIO1            0xd1
 183 #define ESS_CMD_STOPAUDIO1              0xd3
 184 #define ESS_CMD_AUDIO1STATUS            0xd8
 185 #define ESS_CMD_CONTDMA                 0xd4
 186 #define ESS_CMD_TESTIRQ                 0xf2
 187
 188 #define ESS_RECSRC_MIC          0
 189 #define ESS_RECSRC_AUXACD       2
 190 #define ESS_RECSRC_AUXB         5
 191 #define ESS_RECSRC_LINE         6
 192 #define ESS_RECSRC_NONE         7
 193
 194 #define DAC1 0x01
 195 #define ADC1 0x02
 196 #define DAC2 0x04
 197
 198 /*
 199
 200  */
 201
 202 typedef struct _snd_es1938 es1938_t;
 203
 204 struct _snd_es1938 {
 205         int irq;
 206
 207         unsigned long io_port;
 208         struct resource *res_io_port;
 209         unsigned long sb_port;
 210         struct resource *res_sb_port;
 211         unsigned long vc_port;
 212         struct resource *res_vc_port;
 213         unsigned long mpu_port;
 214         struct resource *res_mpu_port;
 215         unsigned long game_port;
 216         struct resource *res_game_port;
 217         unsigned long ddma_port;
 218
 219         unsigned char irqmask;
 220         unsigned char revision;
 221
 222         snd_kcontrol_t *hw_volume;
 223         snd_kcontrol_t *hw_switch;
 224         snd_kcontrol_t *master_volume;
 225         snd_kcontrol_t *master_switch;
 226
 227         struct pci_dev *pci;
 228         snd_card_t *card;
 229         snd_pcm_substream_t *capture_substream;
 230         snd_pcm_substream_t *playback1_substream;
 231         snd_pcm_substream_t *playback2_substream;
 232         snd_kmixer_t *mixer;
 233         snd_rawmidi_t *rmidi;
 234
 235         unsigned int dma1_size;
 236         unsigned int dma2_size;
 237         unsigned int dma1_start;
 238         unsigned int dma2_start;
 239         unsigned int dma1_shift;
 240         unsigned int dma2_shift;
 241         unsigned int active;
 242
 243         spinlock_t reg_lock;
 244         spinlock_t mixer_lock;
 245         snd_info_entry_t *proc_entry;
 246
 247 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
 248         struct gameport gameport;
 249 #endif
 250 };
 251
 252 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 253
 254 static struct pci_device_id snd_es1938_ids[] = {
 255         { 0x125d, 0x1969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* Solo-1 */
 256         { 0, }
 257 };
 258
 259 MODULE_DEVICE_TABLE(pci, snd_es1938_ids);
 260
 261 #define RESET_LOOP_TIMEOUT      0x10000
 262 #define WRITE_LOOP_TIMEOUT      0x10000
 263 #define GET_LOOP_TIMEOUT        0x01000
 264
 265 #undef REG_DEBUG
 266 /* -----------------------------------------------------------------
 267  * Write to a mixer register
 268  * -----------------------------------------------------------------*/
 269 static void snd_es1938_mixer_write(es1938_t *chip, unsigned char reg, unsigned char val)
 270 {
 271         unsigned long flags;
 272         spin_lock_irqsave(&chip->mixer_lock, flags);
 273         outb(reg, SLSB_REG(chip, MIXERADDR));
 274         outb(val, SLSB_REG(chip, MIXERDATA));
 275         spin_unlock_irqrestore(&chip->mixer_lock, flags);
 276 #ifdef REG_DEBUG
 277         snd_printk("Mixer reg %02x set to %02x\n", reg, val);
 278 #endif
 279 }
 280
 281 /* -----------------------------------------------------------------
 282  * Read from a mixer register
 283  * -----------------------------------------------------------------*/
 284 static int snd_es1938_mixer_read(es1938_t *chip, unsigned char reg)
 285 {
 286         int data;
 287         unsigned long flags;
 288         spin_lock_irqsave(&chip->mixer_lock, flags);
 289         outb(reg, SLSB_REG(chip, MIXERADDR));
 290         data = inb(SLSB_REG(chip, MIXERDATA));
 291         spin_unlock_irqrestore(&chip->mixer_lock, flags);
 292 #ifdef REG_DEBUG
 293         snd_printk("Mixer reg %02x now is %02x\n", reg, data);
 294 #endif
 295         return data;
 296 }
 297
 298 /* -----------------------------------------------------------------
 299  * Write to some bits of a mixer register (return old value)
 300  * -----------------------------------------------------------------*/
 301 static int snd_es1938_mixer_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val)
 302 {
 303         unsigned long flags;
 304         unsigned char old, new, oval;
 305         spin_lock_irqsave(&chip->mixer_lock, flags);
 306         outb(reg, SLSB_REG(chip, MIXERADDR));
 307         old = inb(SLSB_REG(chip, MIXERDATA));
 308         oval = old & mask;
 309         if (val != oval) {
 310                 new = (old & ~mask) | (val & mask);
 311                 outb(new, SLSB_REG(chip, MIXERDATA));
 312 #ifdef REG_DEBUG
 313                 snd_printk("Mixer reg %02x was %02x, set to %02x\n", reg, old, new);
 314 #endif
 315         }
 316         spin_unlock_irqrestore(&chip->mixer_lock, flags);
 317         return oval;
 318 }
 319
 320 /* -----------------------------------------------------------------
 321  * Write command to Controller Registers
 322  * -----------------------------------------------------------------*/
 323 static void snd_es1938_write_cmd(es1938_t *chip, unsigned char cmd)
 324 {
 325         int i;
 326         unsigned char v;
 327         for (i = 0; i < WRITE_LOOP_TIMEOUT; i++) {
 328                 if (!(v = inb(SLSB_REG(chip, READSTATUS)) & 0x80)) {
 329                         outb(cmd, SLSB_REG(chip, WRITEDATA));
 330                         return;
 331                 }
 332         }
 333         printk("snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v);
 334 }
 335
 336 /* -----------------------------------------------------------------
 337  * Read the Read Data Buffer
 338  * -----------------------------------------------------------------*/
 339 static int snd_es1938_get_byte(es1938_t *chip)
 340 {
 341         int i;
 342         unsigned char v;
 343         for (i = GET_LOOP_TIMEOUT; i; i--)
 344                 if ((v = inb(SLSB_REG(chip, STATUS))) & 0x80)
 345                         return inb(SLSB_REG(chip, READDATA));
 346         snd_printk("get_byte timeout: status 0x02%x\n", v);
 347         return -ENODEV;
 348 }
 349
 350 /* -----------------------------------------------------------------
 351  * Write value cmd register
 352  * -----------------------------------------------------------------*/
 353 static void snd_es1938_write(es1938_t *chip, unsigned char reg, unsigned char val)
 354 {
 355         unsigned long flags;
 356         spin_lock_irqsave(&chip->reg_lock, flags);
 357         snd_es1938_write_cmd(chip, reg);
 358         snd_es1938_write_cmd(chip, val);
 359         spin_unlock_irqrestore(&chip->reg_lock, flags);
 360 #ifdef REG_DEBUG
 361         snd_printk("Reg %02x set to %02x\n", reg, val);
 362 #endif
 363 }
 364
 365 /* -----------------------------------------------------------------
 366  * Read data from cmd register and return it
 367  * -----------------------------------------------------------------*/
 368 static unsigned char snd_es1938_read(es1938_t *chip, unsigned char reg)
 369 {
 370         unsigned char val;
 371         unsigned long flags;
 372         spin_lock_irqsave(&chip->reg_lock, flags);
 373         snd_es1938_write_cmd(chip, ESS_CMD_READREG);
 374         snd_es1938_write_cmd(chip, reg);
 375         val = snd_es1938_get_byte(chip);
 376         spin_unlock_irqrestore(&chip->reg_lock, flags);
 377 #ifdef REG_DEBUG
 378         snd_printk("Reg %02x now is %02x\n", reg, val);
 379 #endif
 380         return val;
 381 }
 382
 383 /* -----------------------------------------------------------------
 384  * Write data to cmd register and return old value
 385  * -----------------------------------------------------------------*/
 386 static int snd_es1938_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val)
 387 {
 388         unsigned long flags;
 389         unsigned char old, new, oval;
 390         spin_lock_irqsave(&chip->reg_lock, flags);
 391         snd_es1938_write_cmd(chip, ESS_CMD_READREG);
 392         snd_es1938_write_cmd(chip, reg);
 393         old = snd_es1938_get_byte(chip);
 394         oval = old & mask;
 395         if (val != oval) {
 396                 snd_es1938_write_cmd(chip, reg);
 397                 new = (old & ~mask) | (val & mask);
 398                 snd_es1938_write_cmd(chip, new);
 399 #ifdef REG_DEBUG
 400                 snd_printk("Reg %02x was %02x, set to %02x\n", reg, old, new);
 401 #endif
 402         }
 403         spin_unlock_irqrestore(&chip->reg_lock, flags);
 404         return oval;
 405 }
 406
 407 /* --------------------------------------------------------------------
 408  * Reset the chip
 409  * --------------------------------------------------------------------*/
 410 static void snd_es1938_reset(es1938_t *chip)
 411 {
 412         int i;
 413
 414         outb(3, SLSB_REG(chip, RESET));
 415         inb(SLSB_REG(chip, RESET));
 416         outb(0, SLSB_REG(chip, RESET));
 417         for (i = 0; i < RESET_LOOP_TIMEOUT; i++) {
 418                 if (inb(SLSB_REG(chip, STATUS)) & 0x80) {
 419                         if (inb(SLSB_REG(chip, READDATA)) == 0xaa)
 420                                 goto __next;
 421                 }
 422         }
 423         snd_printk("ESS Solo-1 reset failed\n");
 424
 425      __next:
 426         snd_es1938_write_cmd(chip, ESS_CMD_ENABLEEXT);
 427
 428         /* Demand transfer DMA: 4 bytes per DMA request */
 429         snd_es1938_write(chip, ESS_CMD_DMATYPE, 2);
 430
 431         /* Change behaviour of register A1
 432            4x oversampling
 433            2nd channel DAC asynchronous */
 434         snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2MODE, 0x32);
 435         /* enable/select DMA channel and IRQ channel */
 436         snd_es1938_bits(chip, ESS_CMD_IRQCONTROL, 0xf0, 0x50);
 437         snd_es1938_bits(chip, ESS_CMD_DRQCONTROL, 0xf0, 0x50);
 438         snd_es1938_write_cmd(chip, ESS_CMD_ENABLEAUDIO1);
 439         /* Set spatializer parameters to recommended values */
 440         snd_es1938_mixer_write(chip, 0x54, 0x8f);
 441         snd_es1938_mixer_write(chip, 0x56, 0x95);
 442         snd_es1938_mixer_write(chip, 0x58, 0x94);
 443         snd_es1938_mixer_write(chip, 0x5a, 0x80);
 444 }
 445
 446 /* --------------------------------------------------------------------
 447  * Reset the FIFOs
 448  * --------------------------------------------------------------------*/
 449 static void snd_es1938_reset_fifo(es1938_t *chip)
 450 {
 451         outb(2, SLSB_REG(chip, RESET));
 452         outb(0, SLSB_REG(chip, RESET));
 453 }
 454
 455 static ratnum_t clocks[2] = {
 456         {
 457                 .num = 793800,
 458                 .den_min = 1,
 459                 .den_max = 128,
 460                 .den_step = 1,
 461         },
 462         {
 463                 .num = 768000,
 464                 .den_min = 1,
 465                 .den_max = 128,
 466                 .den_step = 1,
 467         }
 468 };
 469
 470 static snd_pcm_hw_constraint_ratnums_t hw_constraints_clocks = {
 471         .nrats = 2,
 472         .rats = clocks,
 473 };
 474
 475
 476 static void snd_es1938_rate_set(es1938_t *chip,
 477                                 snd_pcm_substream_t *substream,
 478                                 int mode)
 479 {
 480         unsigned int bits, div0;
 481         snd_pcm_runtime_t *runtime = substream->runtime;
 482         if (runtime->rate_num == clocks[0].num)
 483                 bits = 128 - runtime->rate_den;
 484         else
 485                 bits = 256 - runtime->rate_den;
 486
 487         /* set filter register */
 488         div0 = 256 - 7160000*20/(8*82*runtime->rate);
 489
 490         if (mode == DAC2) {
 491                 snd_es1938_mixer_write(chip, 0x70, bits);
 492                 snd_es1938_mixer_write(chip, 0x72, div0);
 493         } else {
 494                 snd_es1938_write(chip, 0xA1, bits);
 495                 snd_es1938_write(chip, 0xA2, div0);
 496         }
 497 }
 498
 499 /* --------------------------------------------------------------------
 500  * Configure Solo1 builtin DMA Controller
 501  * --------------------------------------------------------------------*/
 502
 503 static void snd_es1938_playback1_setdma(es1938_t *chip)
 504 {
 505         outb(0x00, SLIO_REG(chip, AUDIO2MODE));
 506         outl(chip->dma2_start, SLIO_REG(chip, AUDIO2DMAADDR));
 507         outw(0, SLIO_REG(chip, AUDIO2DMACOUNT));
 508         outw(chip->dma2_size, SLIO_REG(chip, AUDIO2DMACOUNT));
 509 }
 510
 511 static void snd_es1938_playback2_setdma(es1938_t *chip)
 512 {
 513         /* Enable DMA controller */
 514         outb(0xc4, SLDM_REG(chip, DMACOMMAND));
 515         /* 1. Master reset */
 516         outb(0, SLDM_REG(chip, DMACLEAR));
 517         /* 2. Mask DMA */
 518         outb(1, SLDM_REG(chip, DMAMASK));
 519         outb(0x18, SLDM_REG(chip, DMAMODE));
 520         outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
 521         outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
 522         /* 3. Unmask DMA */
 523         outb(0, SLDM_REG(chip, DMAMASK));
 524 }
 525
 526 static void snd_es1938_capture_setdma(es1938_t *chip)
 527 {
 528         /* Enable DMA controller */
 529         outb(0xc4, SLDM_REG(chip, DMACOMMAND));
 530         /* 1. Master reset */
 531         outb(0, SLDM_REG(chip, DMACLEAR));
 532         /* 2. Mask DMA */
 533         outb(1, SLDM_REG(chip, DMAMASK));
 534         outb(0x14, SLDM_REG(chip, DMAMODE));
 535         outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
 536         outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
 537         /* 3. Unmask DMA */
 538         outb(0, SLDM_REG(chip, DMAMASK));
 539 }
 540
 541 /* ----------------------------------------------------------------------
 542  *
 543  *                           *** PCM part ***
 544  */
 545
 546 static int snd_es1938_capture_trigger(snd_pcm_substream_t * substream,
 547                                       int cmd)
 548 {
 549         es1938_t *chip = snd_pcm_substream_chip(substream);
 550         int val;
 551         switch (cmd) {
 552         case SNDRV_PCM_TRIGGER_START:
 553                 val = 0x0f;
 554                 chip->active |= ADC1;
 555                 break;
 556         case SNDRV_PCM_TRIGGER_STOP:
 557                 val = 0x00;
 558                 chip->active &= ~ADC1;
 559                 break;
 560         default:
 561                 return -EINVAL;
 562         }
 563         snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
 564         return 0;
 565 }
 566
 567 static int snd_es1938_playback1_trigger(snd_pcm_substream_t * substream,
 568                                         int cmd)
 569 {
 570         es1938_t *chip = snd_pcm_substream_chip(substream);
 571         switch (cmd) {
 572         case SNDRV_PCM_TRIGGER_START:
 573                 /* According to the documentation this should be:
 574                    0x13 but that value may randomly swap stereo channels */
 575                 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x93);
 576                 outb(0x0a, SLIO_REG(chip, AUDIO2MODE));
 577                 chip->active |= DAC2;
 578                 break;
 579         case SNDRV_PCM_TRIGGER_STOP:
 580                 outb(0, SLIO_REG(chip, AUDIO2MODE));
 581                 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0);
 582                 chip->active &= ~DAC2;
 583                 break;
 584         default:
 585                 return -EINVAL;
 586         }
 587         return 0;
 588 }
 589
 590 static int snd_es1938_playback2_trigger(snd_pcm_substream_t * substream,
 591                                         int cmd)
 592 {
 593         es1938_t *chip = snd_pcm_substream_chip(substream);
 594         int val;
 595         switch (cmd) {
 596         case SNDRV_PCM_TRIGGER_START:
 597                 val = 5;
 598                 chip->active |= DAC1;
 599                 break;
 600         case SNDRV_PCM_TRIGGER_STOP:
 601                 val = 0;
 602                 chip->active &= ~DAC1;
 603                 break;
 604         default:
 605                 return -EINVAL;
 606         }
 607         snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
 608         return 0;
 609 }
 610
 611 static int snd_es1938_playback_trigger(snd_pcm_substream_t *substream,
 612                                        int cmd)
 613 {
 614         switch (substream->number) {
 615         case 0:
 616                 return snd_es1938_playback1_trigger(substream, cmd);
 617         case 1:
 618                 return snd_es1938_playback2_trigger(substream, cmd);
 619         }
 620         snd_BUG();
 621         return -EINVAL;
 622 }
 623
 624 /* --------------------------------------------------------------------
 625  * First channel for Extended Mode Audio 1 ADC Operation
 626  * --------------------------------------------------------------------*/
 627 static int snd_es1938_capture_prepare(snd_pcm_substream_t * substream)
 628 {
 629         es1938_t *chip = snd_pcm_substream_chip(substream);
 630         snd_pcm_runtime_t *runtime = substream->runtime;
 631         int u, is8, mono;
 632         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
 633         unsigned int count = snd_pcm_lib_period_bytes(substream);
 634
 635         chip->dma1_size = size;
 636         chip->dma1_start = runtime->dma_addr;
 637
 638         mono = (runtime->channels > 1) ? 0 : 1;
 639         is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
 640         u = snd_pcm_format_unsigned(runtime->format);
 641
 642         chip->dma1_shift = 2 - mono - is8;
 643
 644         snd_es1938_reset_fifo(chip);
 645
 646         /* program type */
 647         snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
 648
 649         /* set clock and counters */
 650         snd_es1938_rate_set(chip, substream, ADC1);
 651
 652         count = 0x10000 - count;
 653         snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
 654         snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
 655
 656         /* initialize and configure ADC */
 657         snd_es1938_write(chip, ESS_CMD_SETFORMAT2, u ? 0x51 : 0x71);
 658         snd_es1938_write(chip, ESS_CMD_SETFORMAT2, 0x90 |
 659                        (u ? 0x00 : 0x20) |
 660                        (is8 ? 0x00 : 0x04) |
 661                        (mono ? 0x40 : 0x08));
 662
 663         //      snd_es1938_reset_fifo(chip);
 664
 665         /* 11. configure system interrupt controller and DMA controller */
 666         snd_es1938_capture_setdma(chip);
 667
 668         return 0;
 669 }
 670
 671
 672 /* ------------------------------------------------------------------------------
 673  * Second Audio channel DAC Operation
 674  * ------------------------------------------------------------------------------*/
 675 static int snd_es1938_playback1_prepare(snd_pcm_substream_t * substream)
 676 {
 677         es1938_t *chip = snd_pcm_substream_chip(substream);
 678         snd_pcm_runtime_t *runtime = substream->runtime;
 679         int u, is8, mono;
 680         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
 681         unsigned int count = snd_pcm_lib_period_bytes(substream);
 682
 683         chip->dma2_size = size;
 684         chip->dma2_start = runtime->dma_addr;
 685
 686         mono = (runtime->channels > 1) ? 0 : 1;
 687         is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
 688         u = snd_pcm_format_unsigned(runtime->format);
 689
 690         chip->dma2_shift = 2 - mono - is8;
 691
 692         /* set clock and counters */
 693         snd_es1938_rate_set(chip, substream, DAC2);
 694
 695         count >>= 1;
 696         count = 0x10000 - count;
 697         snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTL, count & 0xff);
 698         snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTH, count >> 8);
 699
 700         /* initialize and configure Audio 2 DAC */
 701         snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) | (mono ? 0 : 2) | (is8 ? 0 : 1));
 702
 703         /* program DMA */
 704         snd_es1938_playback1_setdma(chip);
 705
 706         return 0;
 707 }
 708
 709 static int snd_es1938_playback2_prepare(snd_pcm_substream_t * substream)
 710 {
 711         es1938_t *chip = snd_pcm_substream_chip(substream);
 712         snd_pcm_runtime_t *runtime = substream->runtime;
 713         int u, is8, mono;
 714         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
 715         unsigned int count = snd_pcm_lib_period_bytes(substream);
 716
 717         chip->dma1_size = size;
 718         chip->dma1_start = runtime->dma_addr;
 719
 720         mono = (runtime->channels > 1) ? 0 : 1;
 721         is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
 722         u = snd_pcm_format_unsigned(runtime->format);
 723
 724         chip->dma1_shift = 2 - mono - is8;
 725
 726         count = 0x10000 - count;
 727
 728         /* reset */
 729         snd_es1938_reset_fifo(chip);
 730
 731         snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
 732
 733         /* set clock and counters */
 734         snd_es1938_rate_set(chip, substream, DAC1);
 735         snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
 736         snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
 737
 738         /* initialized and configure DAC */
 739         snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x80 : 0x00);
 740         snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x51 : 0x71);
 741         snd_es1938_write(chip, ESS_CMD_SETFORMAT2,
 742                          0x90 | (mono ? 0x40 : 0x08) |
 743                          (is8 ? 0x00 : 0x04) | (u ? 0x00 : 0x20));
 744
 745         /* program DMA */
 746         snd_es1938_playback2_setdma(chip);
 747
 748         return 0;
 749 }
 750
 751 static int snd_es1938_playback_prepare(snd_pcm_substream_t *substream)
 752 {
 753         switch (substream->number) {
 754         case 0:
 755                 return snd_es1938_playback1_prepare(substream);
 756         case 1:
 757                 return snd_es1938_playback2_prepare(substream);
 758         }
 759         snd_BUG();
 760         return -EINVAL;
 761 }
 762
 763 static snd_pcm_uframes_t snd_es1938_capture_pointer(snd_pcm_substream_t * substream)
 764 {
 765         es1938_t *chip = snd_pcm_substream_chip(substream);
 766         size_t ptr;
 767         size_t old, new;
 768 #if 1
 769         /* This stuff is *needed*, don't ask why - AB */
 770         old = inw(SLDM_REG(chip, DMACOUNT));
 771         while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
 772                 old = new;
 773         ptr = chip->dma1_size - 1 - new;
 774 #else
 775         ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start;
 776 #endif
 777         return ptr >> chip->dma1_shift;
 778 }
 779
 780 static snd_pcm_uframes_t snd_es1938_playback1_pointer(snd_pcm_substream_t * substream)
 781 {
 782         es1938_t *chip = snd_pcm_substream_chip(substream);
 783         size_t ptr;
 784 #if 1
 785         ptr = chip->dma2_size - inw(SLIO_REG(chip, AUDIO2DMACOUNT));
 786 #else
 787         ptr = inl(SLIO_REG(chip, AUDIO2DMAADDR)) - chip->dma2_start;
 788 #endif
 789         return ptr >> chip->dma2_shift;
 790 }
 791
 792 static snd_pcm_uframes_t snd_es1938_playback2_pointer(snd_pcm_substream_t * substream)
 793 {
 794         es1938_t *chip = snd_pcm_substream_chip(substream);
 795         size_t ptr;
 796         size_t old, new;
 797 #if 1
 798         /* This stuff is *needed*, don't ask why - AB */
 799         old = inw(SLDM_REG(chip, DMACOUNT));
 800         while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
 801                 old = new;
 802         ptr = chip->dma1_size - 1 - new;
 803 #else
 804         ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start;
 805 #endif
 806         return ptr >> chip->dma1_shift;
 807 }
 808
 809 static snd_pcm_uframes_t snd_es1938_playback_pointer(snd_pcm_substream_t *substream)
 810 {
 811         switch (substream->number) {
 812         case 0:
 813                 return snd_es1938_playback1_pointer(substream);
 814         case 1:
 815                 return snd_es1938_playback2_pointer(substream);
 816         }
 817         snd_BUG();
 818         return -EINVAL;
 819 }
 820
 821 static int snd_es1938_capture_copy(snd_pcm_substream_t *substream,
 822                                    int channel,
 823                                    snd_pcm_uframes_t pos,
 824                                    void *dst,
 825                                    snd_pcm_uframes_t count)
 826 {
 827         snd_pcm_runtime_t *runtime = substream->runtime;
 828         es1938_t *chip = snd_pcm_substream_chip(substream);
 829         pos <<= chip->dma1_shift;
 830         count <<= chip->dma1_shift;
 831         snd_assert(pos + count <= chip->dma1_size, return -EINVAL);
 832         if (pos + count < chip->dma1_size) {
 833                 if (copy_to_user(dst, runtime->dma_area + pos + 1, count))
 834                         return -EFAULT;
 835         } else {
 836                 if (copy_to_user(dst, runtime->dma_area + pos + 1, count - 1))
 837                         return -EFAULT;
 838                 if (put_user(runtime->dma_area[0], ((unsigned char *)dst) + count - 1))
 839                         return -EFAULT;
 840         }
 841         return 0;
 842 }
 843
 844 /*
 845  * buffer management
 846  */
 847 static int snd_es1938_pcm_hw_params(snd_pcm_substream_t *substream,
 848                                     snd_pcm_hw_params_t * hw_params)
 849
 850 {
 851         int err;
 852
 853         if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
 854                 return err;
 855         return 0;
 856 }
 857
 858 static int snd_es1938_pcm_hw_free(snd_pcm_substream_t *substream)
 859 {
 860         return snd_pcm_lib_free_pages(substream);
 861 }
 862
 863 /* ----------------------------------------------------------------------
 864  * Audio1 Capture (ADC)
 865  * ----------------------------------------------------------------------*/
 866 static snd_pcm_hardware_t snd_es1938_capture =
 867 {
 868         .info =                 (SNDRV_PCM_INFO_INTERLEAVED |
 869                                 SNDRV_PCM_INFO_BLOCK_TRANSFER),
 870         .formats =              SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE,
 871         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
 872         .rate_min =             6000,
 873         .rate_max =             48000,
 874         .channels_min =         1,
 875         .channels_max =         2,
 876         .buffer_bytes_max =     65536,
 877         .period_bytes_min =     64,
 878         .period_bytes_max =     65536,
 879         .periods_min =          1,
 880         .periods_max =          1024,
 881         .fifo_size =            256,
 882 };
 883
 884 /* -----------------------------------------------------------------------
 885  * Audio2 Playback (DAC)
 886  * -----------------------------------------------------------------------*/
 887 static snd_pcm_hardware_t snd_es1938_playback =
 888 {
 889         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
 890                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
 891                                  SNDRV_PCM_INFO_MMAP_VALID),
 892         .formats =              SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE,
 893         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
 894         .rate_min =             6000,
 895         .rate_max =             48000,
 896         .channels_min =         1,
 897         .channels_max =         2,
 898         .buffer_bytes_max =     65536,
 899         .period_bytes_min =     64,
 900         .period_bytes_max =     65536,
 901         .periods_min =          1,
 902         .periods_max =          1024,
 903         .fifo_size =            256,
 904 };
 905
 906 static int snd_es1938_capture_open(snd_pcm_substream_t * substream)
 907 {
 908         es1938_t *chip = snd_pcm_substream_chip(substream);
 909         snd_pcm_runtime_t *runtime = substream->runtime;
 910
 911         if (chip->playback2_substream)
 912                 return -EAGAIN;
 913         chip->capture_substream = substream;
 914         runtime->hw = snd_es1938_capture;
 915         snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 916                                       &hw_constraints_clocks);
 917         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
 918         return 0;
 919 }
 920
 921 static int snd_es1938_playback_open(snd_pcm_substream_t * substream)
 922 {
 923         es1938_t *chip = snd_pcm_substream_chip(substream);
 924         snd_pcm_runtime_t *runtime = substream->runtime;
 925
 926         switch (substream->number) {
 927         case 0:
 928                 chip->playback1_substream = substream;
 929                 break;
 930         case 1:
 931                 if (chip->capture_substream)
 932                         return -EAGAIN;
 933                 chip->playback2_substream = substream;
 934                 break;
 935         default:
 936                 snd_BUG();
 937                 return -EINVAL;
 938         }
 939         runtime->hw = snd_es1938_playback;
 940         snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
 941                                       &hw_constraints_clocks);
 942         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
 943         return 0;
 944 }
 945
 946 static int snd_es1938_capture_close(snd_pcm_substream_t * substream)
 947 {
 948         es1938_t *chip = snd_pcm_substream_chip(substream);
 949         snd_pcm_runtime_t *runtime = substream->runtime;
 950
 951         chip->capture_substream = NULL;
 952         snd_free_pci_pages(chip->pci, runtime->dma_bytes, runtime->dma_area, runtime->dma_addr);
 953         return 0;
 954 }
 955
 956 static int snd_es1938_playback_close(snd_pcm_substream_t * substream)
 957 {
 958         es1938_t *chip = snd_pcm_substream_chip(substream);
 959         snd_pcm_runtime_t *runtime = substream->runtime;
 960
 961         switch (substream->number) {
 962         case 0:
 963                 chip->playback1_substream = NULL;
 964                 break;
 965         case 1:
 966                 chip->playback2_substream = NULL;
 967                 break;
 968         default:
 969                 snd_BUG();
 970                 return -EINVAL;
 971         }
 972         snd_free_pci_pages(chip->pci, runtime->dma_bytes, runtime->dma_area, runtime->dma_addr);
 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, snd_pcm_t ** rpcm)
1005 {
1006         snd_pcm_t *pcm;
1007         int err;
1008
1009         if (rpcm)
1010                 *rpcm = NULL;
1011         if ((err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm)) < 0)
1012                 return err;
1013         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1938_playback_ops);
1014         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1938_capture_ops);
1015
1016         pcm->private_data = chip;
1017         pcm->private_free = snd_es1938_free_pcm;
1018         pcm->info_flags = 0;
1019         strcpy(pcm->name, "ESS Solo-1");
1020
1021         snd_pcm_lib_preallocate_pci_pages_for_all(chip->pci, pcm, 64*1024, 64*1024);
1022
1023         if (rpcm)
1024                 *rpcm = pcm;
1025         return 0;
1026 }
1027
1028 /* -------------------------------------------------------------------
1029  *
1030  *                       *** Mixer part ***
1031  */
1032
1033 static int snd_es1938_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1034 {
1035         static char *texts[8] = {
1036                 "Mic", "Mic Master", "CD", "AOUT",
1037                 "Mic1", "Mix", "Line", "Master"
1038         };
1039
1040         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1041         uinfo->count = 1;
1042         uinfo->value.enumerated.items = 8;
1043         if (uinfo->value.enumerated.item > 7)
1044                 uinfo->value.enumerated.item = 7;
1045         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1046         return 0;
1047 }
1048
1049 static int snd_es1938_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1050 {
1051         es1938_t *chip = snd_kcontrol_chip(kcontrol);
1052         ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07;
1053         return 0;
1054 }
1055
1056 static int snd_es1938_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1057 {
1058         es1938_t *chip = snd_kcontrol_chip(kcontrol);
1059         unsigned char val = ucontrol->value.enumerated.item[0];
1060
1061         if (val > 7)
1062                 return -EINVAL;
1063         return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val;
1064 }
1065
1066 static int snd_es1938_info_spatializer_enable(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1067 {
1068         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1069         uinfo->count = 1;
1070         uinfo->value.integer.min = 0;
1071         uinfo->value.integer.max = 1;
1072         return 0;
1073 }
1074
1075 static int snd_es1938_get_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1076 {
1077         es1938_t *chip = snd_kcontrol_chip(kcontrol);
1078         unsigned char val = snd_es1938_mixer_read(chip, 0x50);
1079         ucontrol->value.integer.value[0] = !!(val & 8);
1080         return 0;
1081 }
1082
1083 static int snd_es1938_put_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1084 {
1085         es1938_t *chip = snd_kcontrol_chip(kcontrol);
1086         unsigned char oval, nval;
1087         int change;
1088         nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04;
1089         oval = snd_es1938_mixer_read(chip, 0x50) & 0x0c;
1090         change = nval != oval;
1091         if (change) {
1092                 snd_es1938_mixer_write(chip, 0x50, nval & ~0x04);
1093                 snd_es1938_mixer_write(chip, 0x50, nval);
1094         }
1095         return change;
1096 }
1097
1098 static int snd_es1938_info_hw_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1099 {
1100         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1101         uinfo->count = 2;
1102         uinfo->value.integer.min = 0;
1103         uinfo->value.integer.max = 63;
1104         return 0;
1105 }
1106
1107 static int snd_es1938_get_hw_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1108 {
1109         es1938_t *chip = snd_kcontrol_chip(kcontrol);
1110         ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f;
1111         ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f;
1112         return 0;
1113 }
1114
1115 static int snd_es1938_info_hw_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1116 {
1117         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1118         uinfo->count = 2;
1119         uinfo->value.integer.min = 0;
1120         uinfo->value.integer.max = 1;
1121         return 0;
1122 }
1123
1124 static int snd_es1938_get_hw_switch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1125 {
1126         es1938_t *chip = snd_kcontrol_chip(kcontrol);
1127         ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40);
1128         ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40);
1129         return 0;
1130 }
1131
1132 static void snd_es1938_hwv_free(snd_kcontrol_t *kcontrol)
1133 {
1134         es1938_t *chip = snd_magic_cast(es1938_t, _snd_kcontrol_chip(kcontrol), return);
1135         chip->master_volume = NULL;
1136         chip->master_switch = NULL;
1137         chip->hw_volume = NULL;
1138         chip->hw_switch = NULL;
1139 }
1140
1141 static int snd_es1938_reg_bits(es1938_t *chip, unsigned char reg,
1142                                unsigned char mask, unsigned char val)
1143 {
1144         if (reg < 0xa0)
1145                 return snd_es1938_mixer_bits(chip, reg, mask, val);
1146         else
1147                 return snd_es1938_bits(chip, reg, mask, val);
1148 }
1149
1150 static int snd_es1938_reg_read(es1938_t *chip, unsigned char reg)
1151 {
1152         if (reg < 0xa0)
1153                 return snd_es1938_mixer_read(chip, reg);
1154         else
1155                 return snd_es1938_read(chip, reg);
1156 }
1157
1158 #define ES1938_SINGLE(xname, xindex, reg, shift, mask, invert) \
1159 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1160   .info = snd_es1938_info_single, \
1161   .get = snd_es1938_get_single, .put = snd_es1938_put_single, \
1162   .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
1163
1164 static int snd_es1938_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1165 {
1166         int mask = (kcontrol->private_value >> 16) & 0xff;
1167
1168         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1169         uinfo->count = 1;
1170         uinfo->value.integer.min = 0;
1171         uinfo->value.integer.max = mask;
1172         return 0;
1173 }
1174
1175 static int snd_es1938_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1176 {
1177         es1938_t *chip = snd_kcontrol_chip(kcontrol);
1178         int reg = kcontrol->private_value & 0xff;
1179         int shift = (kcontrol->private_value >> 8) & 0xff;
1180         int mask = (kcontrol->private_value >> 16) & 0xff;
1181         int invert = (kcontrol->private_value >> 24) & 0xff;
1182         int val;
1183
1184         val = snd_es1938_reg_read(chip, reg);
1185         ucontrol->value.integer.value[0] = (val >> shift) & mask;
1186         if (invert)
1187                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1188         return 0;
1189 }
1190
1191 static int snd_es1938_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1192 {
1193         es1938_t *chip = snd_kcontrol_chip(kcontrol);
1194         int reg = kcontrol->private_value & 0xff;
1195         int shift = (kcontrol->private_value >> 8) & 0xff;
1196         int mask = (kcontrol->private_value >> 16) & 0xff;
1197         int invert = (kcontrol->private_value >> 24) & 0xff;
1198         unsigned char val;
1199
1200         val = (ucontrol->value.integer.value[0] & mask);
1201         if (invert)
1202                 val = mask - val;
1203         mask <<= shift;
1204         val <<= shift;
1205         return snd_es1938_reg_bits(chip, reg, mask, val) != val;
1206 }
1207
1208 #define ES1938_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1209 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1210   .info = snd_es1938_info_double, \
1211   .get = snd_es1938_get_double, .put = snd_es1938_put_double, \
1212   .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1213
1214 static int snd_es1938_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1215 {
1216         int mask = (kcontrol->private_value >> 24) & 0xff;
1217
1218         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1219         uinfo->count = 2;
1220         uinfo->value.integer.min = 0;
1221         uinfo->value.integer.max = mask;
1222         return 0;
1223 }
1224
1225 static int snd_es1938_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1226 {
1227         es1938_t *chip = snd_kcontrol_chip(kcontrol);
1228         int left_reg = kcontrol->private_value & 0xff;
1229         int right_reg = (kcontrol->private_value >> 8) & 0xff;
1230         int shift_left = (kcontrol->private_value >> 16) & 0x07;
1231         int shift_right = (kcontrol->private_value >> 19) & 0x07;
1232         int mask = (kcontrol->private_value >> 24) & 0xff;
1233         int invert = (kcontrol->private_value >> 22) & 1;
1234         unsigned char left, right;
1235
1236         left = snd_es1938_reg_read(chip, left_reg);
1237         if (left_reg != right_reg)
1238                 right = snd_es1938_reg_read(chip, right_reg);
1239         else
1240                 right = left;
1241         ucontrol->value.integer.value[0] = (left >> shift_left) & mask;
1242         ucontrol->value.integer.value[1] = (right >> shift_right) & mask;
1243         if (invert) {
1244                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1245                 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
1246         }
1247         return 0;
1248 }
1249
1250 static int snd_es1938_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1251 {
1252         es1938_t *chip = snd_kcontrol_chip(kcontrol);
1253         int left_reg = kcontrol->private_value & 0xff;
1254         int right_reg = (kcontrol->private_value >> 8) & 0xff;
1255         int shift_left = (kcontrol->private_value >> 16) & 0x07;
1256         int shift_right = (kcontrol->private_value >> 19) & 0x07;
1257         int mask = (kcontrol->private_value >> 24) & 0xff;
1258         int invert = (kcontrol->private_value >> 22) & 1;
1259         int change;
1260         unsigned char val1, val2, mask1, mask2;
1261
1262         val1 = ucontrol->value.integer.value[0] & mask;
1263         val2 = ucontrol->value.integer.value[1] & mask;
1264         if (invert) {
1265                 val1 = mask - val1;
1266                 val2 = mask - val2;
1267         }
1268         val1 <<= shift_left;
1269         val2 <<= shift_right;
1270         mask1 = mask << shift_left;
1271         mask2 = mask << shift_right;
1272         if (left_reg != right_reg) {
1273                 change = 0;
1274                 if (snd_es1938_reg_bits(chip, left_reg, mask1, val1) != val1)
1275                         change = 1;
1276                 if (snd_es1938_reg_bits(chip, right_reg, mask2, val2) != val2)
1277                         change = 1;
1278         } else {
1279                 change = (snd_es1938_reg_bits(chip, left_reg, mask1 | mask2,
1280                                               val1 | val2) != (val1 | val2));
1281         }
1282         return change;
1283 }
1284
1285 static snd_kcontrol_new_t snd_es1938_controls[] = {
1286 ES1938_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0),
1287 ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1),
1288 {
1289         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1290         .name = "Hardware Master Playback Volume",
1291         .access = SNDRV_CTL_ELEM_ACCESS_READ,
1292         .info = snd_es1938_info_hw_volume,
1293         .get = snd_es1938_get_hw_volume,
1294 },
1295 {
1296         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1297         .name = "Hardware Master Playback Switch",
1298         .access = SNDRV_CTL_ELEM_ACCESS_READ,
1299         .info = snd_es1938_info_hw_switch,
1300         .get = snd_es1938_get_hw_switch,
1301 },
1302 ES1938_SINGLE("Hardware Volume Split", 0, 0x64, 7, 1, 0),
1303 ES1938_DOUBLE("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0),
1304 ES1938_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0),
1305 ES1938_DOUBLE("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0),
1306 ES1938_DOUBLE("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1307 ES1938_DOUBLE("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0),
1308 ES1938_DOUBLE("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0),
1309 ES1938_DOUBLE("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0),
1310 ES1938_SINGLE("PC Speaker Volume", 0, 0x3c, 0, 7, 0),
1311 ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
1312 ES1938_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1),
1313 {
1314         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1315         .name = "Capture Source",
1316         .info = snd_es1938_info_mux,
1317         .get = snd_es1938_get_mux,
1318         .put = snd_es1938_put_mux,
1319 },
1320 ES1938_DOUBLE("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1321 ES1938_DOUBLE("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0),
1322 ES1938_DOUBLE("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0),
1323 ES1938_DOUBLE("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0),
1324 ES1938_DOUBLE("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0),
1325 ES1938_DOUBLE("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0),
1326 ES1938_DOUBLE("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0),
1327 ES1938_DOUBLE("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0),
1328 ES1938_DOUBLE("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0),
1329 ES1938_DOUBLE("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0),
1330 ES1938_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0),
1331 {
1332         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1333         .name = "3D Control - Switch",
1334         .info = snd_es1938_info_spatializer_enable,
1335         .get = snd_es1938_get_spatializer_enable,
1336         .put = snd_es1938_put_spatializer_enable,
1337 },
1338 ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0)
1339 };
1340
1341
1342 /* ---------------------------------------------------------------------------- */
1343 /* ---------------------------------------------------------------------------- */
1344
1345 static int snd_es1938_free(es1938_t *chip)
1346 {
1347         /*if (chip->rmidi)
1348           snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0);*/
1349 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
1350         if (chip->gameport.io)
1351                 gameport_unregister_port(&chip->gameport);
1352 #endif
1353         if (chip->res_io_port) {
1354                 release_resource(chip->res_io_port);
1355                 kfree_nocheck(chip->res_io_port);
1356         }
1357         if (chip->res_sb_port) {
1358                 release_resource(chip->res_sb_port);
1359                 kfree_nocheck(chip->res_sb_port);
1360         }
1361         if (chip->res_vc_port) {
1362                 release_resource(chip->res_vc_port);
1363                 kfree_nocheck(chip->res_vc_port);
1364         }
1365         if (chip->res_mpu_port) {
1366                 release_resource(chip->res_mpu_port);
1367                 kfree_nocheck(chip->res_mpu_port);
1368         }
1369         if (chip->res_game_port) {
1370                 release_resource(chip->res_game_port);
1371                 kfree_nocheck(chip->res_game_port);
1372         }
1373         if (chip->irq >= 0)
1374                 free_irq(chip->irq, (void *)chip);
1375         snd_magic_kfree(chip);
1376         return 0;
1377 }
1378
1379 static int snd_es1938_dev_free(snd_device_t *device)
1380 {
1381         es1938_t *chip = snd_magic_cast(es1938_t, device->device_data, return -ENXIO);
1382         return snd_es1938_free(chip);
1383 }
1384
1385 static int __devinit snd_es1938_create(snd_card_t * card,
1386                                     struct pci_dev * pci,
1387                                     es1938_t ** rchip)
1388 {
1389         es1938_t *chip;
1390         int err;
1391         static snd_device_ops_t ops = {
1392                 .dev_free =     snd_es1938_dev_free,
1393         };
1394
1395         *rchip = NULL;
1396
1397         /* enable PCI device */
1398         if ((err = pci_enable_device(pci)) < 0)
1399                 return err;
1400         /* check, if we can restrict PCI DMA transfers to 24 bits */
1401         if (!pci_dma_supported(pci, 0x00ffffff)) {
1402                 snd_printk("architecture does not support 24bit PCI busmaster DMA\n");
1403                 return -ENXIO;
1404         }
1405         pci_set_dma_mask(pci, 0x00ffffff);
1406
1407         chip = snd_magic_kcalloc(es1938_t, 0, GFP_KERNEL);
1408         if (chip == NULL)
1409                 return -ENOMEM;
1410         spin_lock_init(&chip->reg_lock);
1411         spin_lock_init(&chip->mixer_lock);
1412         chip->card = card;
1413         chip->pci = pci;
1414         chip->io_port = pci_resource_start(pci, 0);
1415         if ((chip->res_io_port = request_region(chip->io_port, 8, "ESS Solo-1")) == NULL) {
1416                 snd_es1938_free(chip);
1417                 snd_printk("unable to grab region 0x%lx-0x%lx\n", chip->io_port, chip->io_port + 8 - 1);
1418                 return -EBUSY;
1419         }
1420         chip->sb_port = pci_resource_start(pci, 1);
1421         if ((chip->res_sb_port = request_region(chip->sb_port, 0x10, "ESS Solo-1 SB")) == NULL) {
1422                 snd_es1938_free(chip);
1423                 snd_printk("unable to grab SB region 0x%lx-0x%lx\n", chip->sb_port, chip->sb_port + 0x10 - 1);
1424                 return -EBUSY;
1425         }
1426         chip->vc_port = pci_resource_start(pci, 2);
1427         if ((chip->res_vc_port = request_region(chip->vc_port, 0x10, "ESS Solo-1 VC (DMA)")) == NULL) {
1428                 snd_es1938_free(chip);
1429                 snd_printk("unable to grab VC (DMA) region 0x%lx-0x%lx\n", chip->vc_port, chip->vc_port + 0x10 - 1);
1430                 return -EBUSY;
1431         }
1432         chip->mpu_port = pci_resource_start(pci, 3);
1433         if ((chip->res_mpu_port = request_region(chip->mpu_port, 4, "ESS Solo-1 MIDI")) == NULL) {
1434                 snd_es1938_free(chip);
1435                 snd_printk("unable to grab MIDI region 0x%lx-0x%lx\n", chip->mpu_port, chip->mpu_port + 4 - 1);
1436                 return -EBUSY;
1437         }
1438         chip->game_port = pci_resource_start(pci, 4);
1439         if ((chip->res_game_port = request_region(chip->game_port, 4, "ESS Solo-1 GAME")) == NULL) {
1440                 snd_es1938_free(chip);
1441                 snd_printk("unable to grab GAME region 0x%lx-0x%lx\n", chip->game_port, chip->game_port + 4 - 1);
1442                 return -EBUSY;
1443         }
1444         if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ, "ES1938", (void *)chip)) {
1445                 snd_es1938_free(chip);
1446                 snd_printk("unable to grab IRQ %d\n", pci->irq);
1447                 return -EBUSY;
1448         }
1449         chip->irq = pci->irq;
1450 #ifdef ES1938_DDEBUG
1451         snd_printk("create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
1452                    chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1453 #endif
1454         /* reset chip */
1455         snd_es1938_reset(chip);
1456
1457         /* configure native mode */
1458
1459         /* enable bus master */
1460         pci_set_master(pci);
1461
1462         /* disable legacy audio */
1463         pci_write_config_word(pci, SL_PCI_LEGACYCONTROL, 0x805f);
1464
1465         /* set DDMA base */
1466         chip->ddma_port = chip->vc_port + 0x00;         /* fix from Thomas Sailer */
1467         pci_write_config_word(pci, SL_PCI_DDMACONTROL, chip->ddma_port | 1);
1468
1469         /* set DMA/IRQ policy */
1470         pci_write_config_dword(pci, SL_PCI_CONFIG, 0);
1471
1472         /* enable Audio 1, Audio 2, MPU401 IRQ and HW volume IRQ*/
1473         outb(0xf0, SLIO_REG(chip, IRQCONTROL));
1474
1475         /* reset DMA */
1476         outb(0, SLDM_REG(chip, DMACLEAR));
1477
1478         /* enable bus mastering */
1479         pci_set_master(pci);
1480
1481         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1482                 snd_es1938_free(chip);
1483                 return err;
1484         }
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         if ((err = snd_es1938_new_pcm(chip, 0, &pcm)) < 0) {
1637                 snd_card_free(card);
1638                 return err;
1639         }
1640         if ((err = snd_es1938_mixer(pcm)) < 0) {
1641                 snd_card_free(card);
1642                 return err;
1643         }
1644         if (snd_opl3_create(card,
1645                             SLSB_REG(chip, FMLOWADDR),
1646                             SLSB_REG(chip, FMHIGHADDR),
1647                             OPL3_HW_OPL3, 1, &opl3) < 0) {
1648                 printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n",
1649                            SLSB_REG(chip, FMLOWADDR));
1650         } else {
1651                 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
1652                         snd_card_free(card);
1653                         return err;
1654                 }
1655                 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
1656                         snd_card_free(card);
1657                         return err;
1658                 }
1659         }
1660         if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
1661                                 chip->mpu_port, 1, chip->irq, 0, &chip->rmidi) < 0) {
1662                 printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
1663         } /*else
1664             snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);*/
1665
1666 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
1667         chip->gameport.io = chip->game_port;
1668         gameport_register_port(&chip->gameport);
1669 #endif
1670
1671         strcpy(card->driver, "ES1938");
1672         strcpy(card->shortname, "ESS ES1938 (Solo-1)");
1673         sprintf(card->longname, "%s rev %i, irq %i",
1674                 card->shortname,
1675                 chip->revision,
1676                 chip->irq);
1677
1678         if ((err = snd_card_register(card)) < 0) {
1679                 snd_card_free(card);
1680                 return err;
1681         }
1682
1683         pci_set_drvdata(pci, card);
1684         dev++;
1685         return 0;
1686 }
1687
1688 static void __devexit snd_es1938_remove(struct pci_dev *pci)
1689 {
1690         snd_card_free(pci_get_drvdata(pci));
1691         pci_set_drvdata(pci, NULL);
1692 }
1693
1694 static struct pci_driver driver = {
1695         .name = "ESS ES1938 (Solo-1)",
1696         .id_table = snd_es1938_ids,
1697         .probe = snd_es1938_probe,
1698         .remove = __devexit_p(snd_es1938_remove),
1699 };
1700
1701 static int __init alsa_card_es1938_init(void)
1702 {
1703         int err;
1704
1705         if ((err = pci_module_init(&driver)) < 0) {
1706 #ifdef MODULE
1707                 printk(KERN_ERR "ESS Solo-1 soundcard not found or device busy\n");
1708 #endif
1709                 return err;
1710         }
1711         return 0;
1712 }
1713
1714 static void __exit alsa_card_es1938_exit(void)
1715 {
1716         pci_unregister_driver(&driver);
1717 }
1718
1719 module_init(alsa_card_es1938_init)
1720 module_exit(alsa_card_es1938_exit)
1721
1722 #ifndef MODULE
1723
1724 /* format is: snd-es1938=enable,index,id */
1725
1726 static int __init alsa_card_es1938_setup(char *str)
1727 {
1728         static unsigned __initdata nr_dev = 0;
1729
1730         if (nr_dev >= SNDRV_CARDS)
1731                 return 0;
1732         (void)(get_option(&str,&enable[nr_dev]) == 2 &&
1733                get_option(&str,&index[nr_dev]) == 2 &&
1734                get_id(&str,&id[nr_dev]) == 2);
1735         nr_dev++;
1736         return 1;
1737 }
1738
1739 __setup("snd-es1938=", alsa_card_es1938_setup);
1740
1741 #endif /* ifndef MODULE */