sound/pci/es1938.c

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