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