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