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