sound/pci/es1938.c

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