66ac26c5a2403027bf724dc2e095a83f41768343
[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);
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_READ |
1363                    SNDRV_CTL_ELEM_ACCESS_TLV_READ),
1364         .name = "Hardware Master Playback Switch",
1365         .info = snd_es1938_info_hw_switch,
1366         .get = snd_es1938_get_hw_switch,
1367         .tlv = { .p = db_scale_master },
1368 },
1369 ES1938_SINGLE("Hardware Volume Split", 0, 0x64, 7, 1, 0),
1370 ES1938_DOUBLE_TLV("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0,
1371                   db_scale_line),
1372 ES1938_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0),
1373 ES1938_DOUBLE_TLV("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0,
1374                   db_scale_mic),
1375 ES1938_DOUBLE_TLV("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0,
1376                   db_scale_line),
1377 ES1938_DOUBLE_TLV("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0,
1378                   db_scale_mic),
1379 ES1938_DOUBLE_TLV("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0,
1380                   db_scale_line),
1381 ES1938_DOUBLE_TLV("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0,
1382                   db_scale_capture),
1383 ES1938_SINGLE("PC Speaker Volume", 0, 0x3c, 0, 7, 0),
1384 ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
1385 ES1938_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1),
1386 {
1387         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1388         .name = "Capture Source",
1389         .info = snd_es1938_info_mux,
1390         .get = snd_es1938_get_mux,
1391         .put = snd_es1938_put_mux,
1392 },
1393 ES1938_DOUBLE_TLV("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0,
1394                   db_scale_line),
1395 ES1938_DOUBLE_TLV("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0,
1396                   db_scale_audio2),
1397 ES1938_DOUBLE_TLV("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0,
1398                   db_scale_mic),
1399 ES1938_DOUBLE_TLV("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0,
1400                   db_scale_line),
1401 ES1938_DOUBLE_TLV("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0,
1402                   db_scale_mic),
1403 ES1938_DOUBLE_TLV("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0,
1404                   db_scale_line),
1405 ES1938_DOUBLE_TLV("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0,
1406                   db_scale_line),
1407 ES1938_DOUBLE_TLV("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0,
1408                   db_scale_line),
1409 ES1938_DOUBLE_TLV("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0,
1410                   db_scale_audio2),
1411 ES1938_DOUBLE_TLV("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0,
1412                   db_scale_audio1),
1413 ES1938_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0),
1414 {
1415         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1416         .name = "3D Control - Switch",
1417         .info = snd_es1938_info_spatializer_enable,
1418         .get = snd_es1938_get_spatializer_enable,
1419         .put = snd_es1938_put_spatializer_enable,
1420 },
1421 ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0)
1422 };
1423
1424
1425 /* ---------------------------------------------------------------------------- */
1426 /* ---------------------------------------------------------------------------- */
1427
1428 /*
1429  * initialize the chip - used by resume callback, too
1430  */
1431 static void snd_es1938_chip_init(struct es1938 *chip)
1432 {
1433         /* reset chip */
1434         snd_es1938_reset(chip);
1435
1436         /* configure native mode */
1437
1438         /* enable bus master */
1439         pci_set_master(chip->pci);
1440
1441         /* disable legacy audio */
1442         pci_write_config_word(chip->pci, SL_PCI_LEGACYCONTROL, 0x805f);
1443
1444         /* set DDMA base */
1445         pci_write_config_word(chip->pci, SL_PCI_DDMACONTROL, chip->ddma_port | 1);
1446
1447         /* set DMA/IRQ policy */
1448         pci_write_config_dword(chip->pci, SL_PCI_CONFIG, 0);
1449
1450         /* enable Audio 1, Audio 2, MPU401 IRQ and HW volume IRQ*/
1451         outb(0xf0, SLIO_REG(chip, IRQCONTROL));
1452
1453         /* reset DMA */
1454         outb(0, SLDM_REG(chip, DMACLEAR));
1455 }
1456
1457 #ifdef CONFIG_PM
1458 /*
1459  * PM support
1460  */
1461
1462 static unsigned char saved_regs[SAVED_REG_SIZE+1] = {
1463         0x14, 0x1a, 0x1c, 0x3a, 0x3c, 0x3e, 0x36, 0x38,
1464         0x50, 0x52, 0x60, 0x61, 0x62, 0x63, 0x64, 0x68,
1465         0x69, 0x6a, 0x6b, 0x6d, 0x6e, 0x6f, 0x7c, 0x7d,
1466         0xa8, 0xb4,
1467 };
1468
1469
1470 static int es1938_suspend(struct pci_dev *pci, pm_message_t state)
1471 {
1472         struct snd_card *card = pci_get_drvdata(pci);
1473         struct es1938 *chip = card->private_data;
1474         unsigned char *s, *d;
1475
1476         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1477         snd_pcm_suspend_all(chip->pcm);
1478
1479         /* save mixer-related registers */
1480         for (s = saved_regs, d = chip->saved_regs; *s; s++, d++)
1481                 *d = snd_es1938_reg_read(chip, *s);
1482
1483         outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */
1484         if (chip->irq >= 0) {
1485                 synchronize_irq(chip->irq);
1486                 free_irq(chip->irq, chip);
1487                 chip->irq = -1;
1488         }
1489         pci_disable_device(pci);
1490         pci_save_state(pci);
1491         pci_set_power_state(pci, pci_choose_state(pci, state));
1492         return 0;
1493 }
1494
1495 static int es1938_resume(struct pci_dev *pci)
1496 {
1497         struct snd_card *card = pci_get_drvdata(pci);
1498         struct es1938 *chip = card->private_data;
1499         unsigned char *s, *d;
1500
1501         pci_set_power_state(pci, PCI_D0);
1502         pci_restore_state(pci);
1503         if (pci_enable_device(pci) < 0) {
1504                 printk(KERN_ERR "es1938: pci_enable_device failed, "
1505                        "disabling device\n");
1506                 snd_card_disconnect(card);
1507                 return -EIO;
1508         }
1509
1510         if (request_irq(pci->irq, snd_es1938_interrupt,
1511                         IRQF_SHARED, "ES1938", chip)) {
1512                 printk(KERN_ERR "es1938: unable to grab IRQ %d, "
1513                        "disabling device\n", pci->irq);
1514                 snd_card_disconnect(card);
1515                 return -EIO;
1516         }
1517         chip->irq = pci->irq;
1518         snd_es1938_chip_init(chip);
1519
1520         /* restore mixer-related registers */
1521         for (s = saved_regs, d = chip->saved_regs; *s; s++, d++) {
1522                 if (*s < 0xa0)
1523                         snd_es1938_mixer_write(chip, *s, *d);
1524                 else
1525                         snd_es1938_write(chip, *s, *d);
1526         }
1527
1528         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1529         return 0;
1530 }
1531 #endif /* CONFIG_PM */
1532
1533 #ifdef SUPPORT_JOYSTICK
1534 static int __devinit snd_es1938_create_gameport(struct es1938 *chip)
1535 {
1536         struct gameport *gp;
1537
1538         chip->gameport = gp = gameport_allocate_port();
1539         if (!gp) {
1540                 printk(KERN_ERR "es1938: cannot allocate memory for gameport\n");
1541                 return -ENOMEM;
1542         }
1543
1544         gameport_set_name(gp, "ES1938");
1545         gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
1546         gameport_set_dev_parent(gp, &chip->pci->dev);
1547         gp->io = chip->game_port;
1548
1549         gameport_register_port(gp);
1550
1551         return 0;
1552 }
1553
1554 static void snd_es1938_free_gameport(struct es1938 *chip)
1555 {
1556         if (chip->gameport) {
1557                 gameport_unregister_port(chip->gameport);
1558                 chip->gameport = NULL;
1559         }
1560 }
1561 #else
1562 static inline int snd_es1938_create_gameport(struct es1938 *chip) { return -ENOSYS; }
1563 static inline void snd_es1938_free_gameport(struct es1938 *chip) { }
1564 #endif /* SUPPORT_JOYSTICK */
1565
1566 static int snd_es1938_free(struct es1938 *chip)
1567 {
1568         /* disable irqs */
1569         outb(0x00, SLIO_REG(chip, IRQCONTROL));
1570         if (chip->rmidi)
1571                 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0);
1572
1573         snd_es1938_free_gameport(chip);
1574
1575         if (chip->irq >= 0) {
1576                 synchronize_irq(chip->irq);
1577                 free_irq(chip->irq, chip);
1578         }
1579         pci_release_regions(chip->pci);
1580         pci_disable_device(chip->pci);
1581         kfree(chip);
1582         return 0;
1583 }
1584
1585 static int snd_es1938_dev_free(struct snd_device *device)
1586 {
1587         struct es1938 *chip = device->device_data;
1588         return snd_es1938_free(chip);
1589 }
1590
1591 static int __devinit snd_es1938_create(struct snd_card *card,
1592                                     struct pci_dev * pci,
1593                                     struct es1938 ** rchip)
1594 {
1595         struct es1938 *chip;
1596         int err;
1597         static struct snd_device_ops ops = {
1598                 .dev_free =     snd_es1938_dev_free,
1599         };
1600
1601         *rchip = NULL;
1602
1603         /* enable PCI device */
1604         if ((err = pci_enable_device(pci)) < 0)
1605                 return err;
1606         /* check, if we can restrict PCI DMA transfers to 24 bits */
1607         if (pci_set_dma_mask(pci, DMA_24BIT_MASK) < 0 ||
1608             pci_set_consistent_dma_mask(pci, DMA_24BIT_MASK) < 0) {
1609                 snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
1610                 pci_disable_device(pci);
1611                 return -ENXIO;
1612         }
1613
1614         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1615         if (chip == NULL) {
1616                 pci_disable_device(pci);
1617                 return -ENOMEM;
1618         }
1619         spin_lock_init(&chip->reg_lock);
1620         spin_lock_init(&chip->mixer_lock);
1621         chip->card = card;
1622         chip->pci = pci;
1623         chip->irq = -1;
1624         if ((err = pci_request_regions(pci, "ESS Solo-1")) < 0) {
1625                 kfree(chip);
1626                 pci_disable_device(pci);
1627                 return err;
1628         }
1629         chip->io_port = pci_resource_start(pci, 0);
1630         chip->sb_port = pci_resource_start(pci, 1);
1631         chip->vc_port = pci_resource_start(pci, 2);
1632         chip->mpu_port = pci_resource_start(pci, 3);
1633         chip->game_port = pci_resource_start(pci, 4);
1634         if (request_irq(pci->irq, snd_es1938_interrupt, IRQF_SHARED,
1635                         "ES1938", chip)) {
1636                 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
1637                 snd_es1938_free(chip);
1638                 return -EBUSY;
1639         }
1640         chip->irq = pci->irq;
1641 #ifdef ES1938_DDEBUG
1642         snd_printk(KERN_DEBUG "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
1643                    chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1644 #endif
1645
1646         chip->ddma_port = chip->vc_port + 0x00;         /* fix from Thomas Sailer */
1647
1648         snd_es1938_chip_init(chip);
1649
1650         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1651                 snd_es1938_free(chip);
1652                 return err;
1653         }
1654
1655         snd_card_set_dev(card, &pci->dev);
1656
1657         *rchip = chip;
1658         return 0;
1659 }
1660
1661 /* --------------------------------------------------------------------
1662  * Interrupt handler
1663  * -------------------------------------------------------------------- */
1664 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id)
1665 {
1666         struct es1938 *chip = dev_id;
1667         unsigned char status, audiostatus;
1668         int handled = 0;
1669
1670         status = inb(SLIO_REG(chip, IRQCONTROL));
1671 #if 0
1672         printk("Es1938debug - interrupt status: =0x%x\n", status);
1673 #endif
1674         
1675         /* AUDIO 1 */
1676         if (status & 0x10) {
1677 #if 0
1678                 printk("Es1938debug - AUDIO channel 1 interrupt\n");
1679                 printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
1680                        inw(SLDM_REG(chip, DMACOUNT)));
1681                 printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
1682                        inl(SLDM_REG(chip, DMAADDR)));
1683                 printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
1684                        inl(SLDM_REG(chip, DMASTATUS)));
1685 #endif
1686                 /* clear irq */
1687                 handled = 1;
1688                 audiostatus = inb(SLSB_REG(chip, STATUS));
1689                 if (chip->active & ADC1)
1690                         snd_pcm_period_elapsed(chip->capture_substream);
1691                 else if (chip->active & DAC1)
1692                         snd_pcm_period_elapsed(chip->playback2_substream);
1693         }
1694         
1695         /* AUDIO 2 */
1696         if (status & 0x20) {
1697 #if 0
1698                 printk("Es1938debug - AUDIO channel 2 interrupt\n");
1699                 printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
1700                        inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
1701                 printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
1702                        inl(SLIO_REG(chip, AUDIO2DMAADDR)));
1703
1704 #endif
1705                 /* clear irq */
1706                 handled = 1;
1707                 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
1708                 if (chip->active & DAC2)
1709                         snd_pcm_period_elapsed(chip->playback1_substream);
1710         }
1711
1712         /* Hardware volume */
1713         if (status & 0x40) {
1714                 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
1715                 handled = 1;
1716                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
1717                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
1718                 if (!split) {
1719                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1720                                        &chip->master_switch->id);
1721                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1722                                        &chip->master_volume->id);
1723                 }
1724                 /* ack interrupt */
1725                 snd_es1938_mixer_write(chip, 0x66, 0x00);
1726         }
1727
1728         /* MPU401 */
1729         if (status & 0x80) {
1730                 // the following line is evil! It switches off MIDI interrupt handling after the first interrupt received.
1731                 // replacing the last 0 by 0x40 works for ESS-Solo1, but just doing nothing works as well!
1732                 // andreas@flying-snail.de
1733                 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
1734                 if (chip->rmidi) {
1735                         handled = 1;
1736                         snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data);
1737                 }
1738         }
1739         return IRQ_RETVAL(handled);
1740 }
1741
1742 #define ES1938_DMA_SIZE 64
1743
1744 static int __devinit snd_es1938_mixer(struct es1938 *chip)
1745 {
1746         struct snd_card *card;
1747         unsigned int idx;
1748         int err;
1749
1750         card = chip->card;
1751
1752         strcpy(card->mixername, "ESS Solo-1");
1753
1754         for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
1755                 struct snd_kcontrol *kctl;
1756                 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
1757                 switch (idx) {
1758                         case 0:
1759                                 chip->master_volume = kctl;
1760                                 kctl->private_free = snd_es1938_hwv_free;
1761                                 break;
1762                         case 1:
1763                                 chip->master_switch = kctl;
1764                                 kctl->private_free = snd_es1938_hwv_free;
1765                                 break;
1766                         case 2:
1767                                 chip->hw_volume = kctl;
1768                                 kctl->private_free = snd_es1938_hwv_free;
1769                                 break;
1770                         case 3:
1771                                 chip->hw_switch = kctl;
1772                                 kctl->private_free = snd_es1938_hwv_free;
1773                                 break;
1774                         }
1775                 if ((err = snd_ctl_add(card, kctl)) < 0)
1776                         return err;
1777         }
1778         return 0;
1779 }
1780        
1781
1782 static int __devinit snd_es1938_probe(struct pci_dev *pci,
1783                                       const struct pci_device_id *pci_id)
1784 {
1785         static int dev;
1786         struct snd_card *card;
1787         struct es1938 *chip;
1788         struct snd_opl3 *opl3;
1789         int idx, err;
1790
1791         if (dev >= SNDRV_CARDS)
1792                 return -ENODEV;
1793         if (!enable[dev]) {
1794                 dev++;
1795                 return -ENOENT;
1796         }
1797
1798         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
1799         if (card == NULL)
1800                 return -ENOMEM;
1801         for (idx = 0; idx < 5; idx++) {
1802                 if (pci_resource_start(pci, idx) == 0 ||
1803                     !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) {
1804                         snd_card_free(card);
1805                         return -ENODEV;
1806                 }
1807         }
1808         if ((err = snd_es1938_create(card, pci, &chip)) < 0) {
1809                 snd_card_free(card);
1810                 return err;
1811         }
1812         card->private_data = chip;
1813
1814         strcpy(card->driver, "ES1938");
1815         strcpy(card->shortname, "ESS ES1938 (Solo-1)");
1816         sprintf(card->longname, "%s rev %i, irq %i",
1817                 card->shortname,
1818                 chip->revision,
1819                 chip->irq);
1820
1821         if ((err = snd_es1938_new_pcm(chip, 0)) < 0) {
1822                 snd_card_free(card);
1823                 return err;
1824         }
1825         if ((err = snd_es1938_mixer(chip)) < 0) {
1826                 snd_card_free(card);
1827                 return err;
1828         }
1829         if (snd_opl3_create(card,
1830                             SLSB_REG(chip, FMLOWADDR),
1831                             SLSB_REG(chip, FMHIGHADDR),
1832                             OPL3_HW_OPL3, 1, &opl3) < 0) {
1833                 printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n",
1834                            SLSB_REG(chip, FMLOWADDR));
1835         } else {
1836                 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
1837                         snd_card_free(card);
1838                         return err;
1839                 }
1840                 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
1841                         snd_card_free(card);
1842                         return err;
1843                 }
1844         }
1845         if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
1846                                 chip->mpu_port, MPU401_INFO_INTEGRATED,
1847                                 chip->irq, 0, &chip->rmidi) < 0) {
1848                 printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
1849         } else {
1850                 // this line is vital for MIDI interrupt handling on ess-solo1
1851                 // andreas@flying-snail.de
1852                 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);
1853         }
1854
1855         snd_es1938_create_gameport(chip);
1856
1857         if ((err = snd_card_register(card)) < 0) {
1858                 snd_card_free(card);
1859                 return err;
1860         }
1861
1862         pci_set_drvdata(pci, card);
1863         dev++;
1864         return 0;
1865 }
1866
1867 static void __devexit snd_es1938_remove(struct pci_dev *pci)
1868 {
1869         snd_card_free(pci_get_drvdata(pci));
1870         pci_set_drvdata(pci, NULL);
1871 }
1872
1873 static struct pci_driver driver = {
1874         .name = "ESS ES1938 (Solo-1)",
1875         .id_table = snd_es1938_ids,
1876         .probe = snd_es1938_probe,
1877         .remove = __devexit_p(snd_es1938_remove),
1878 #ifdef CONFIG_PM
1879         .suspend = es1938_suspend,
1880         .resume = es1938_resume,
1881 #endif
1882 };
1883
1884 static int __init alsa_card_es1938_init(void)
1885 {
1886         return pci_register_driver(&driver);
1887 }
1888
1889 static void __exit alsa_card_es1938_exit(void)
1890 {
1891         pci_unregister_driver(&driver);
1892 }
1893
1894 module_init(alsa_card_es1938_init)
1895 module_exit(alsa_card_es1938_exit)