[ALSA] Optimize for config without PROC_FS (pci drivers)
[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 pci_dev *pci, pm_message_t state)
1402 {
1403         struct snd_card *card = pci_get_drvdata(pci);
1404         struct es1938 *chip = card->private_data;
1405         unsigned char *s, *d;
1406
1407         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1408         snd_pcm_suspend_all(chip->pcm);
1409
1410         /* save mixer-related registers */
1411         for (s = saved_regs, d = chip->saved_regs; *s; s++, d++)
1412                 *d = snd_es1938_reg_read(chip, *s);
1413
1414         outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */
1415         if (chip->irq >= 0)
1416                 free_irq(chip->irq, chip);
1417         pci_disable_device(pci);
1418         pci_save_state(pci);
1419         return 0;
1420 }
1421
1422 static int es1938_resume(struct pci_dev *pci)
1423 {
1424         struct snd_card *card = pci_get_drvdata(pci);
1425         struct es1938 *chip = card->private_data;
1426         unsigned char *s, *d;
1427
1428         pci_restore_state(pci);
1429         pci_enable_device(pci);
1430         request_irq(pci->irq, snd_es1938_interrupt,
1431                     SA_INTERRUPT|SA_SHIRQ, "ES1938", chip);
1432         chip->irq = pci->irq;
1433         snd_es1938_chip_init(chip);
1434
1435         /* restore mixer-related registers */
1436         for (s = saved_regs, d = chip->saved_regs; *s; s++, d++) {
1437                 if (*s < 0xa0)
1438                         snd_es1938_mixer_write(chip, *s, *d);
1439                 else
1440                         snd_es1938_write(chip, *s, *d);
1441         }
1442
1443         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1444         return 0;
1445 }
1446 #endif /* CONFIG_PM */
1447
1448 #ifdef SUPPORT_JOYSTICK
1449 static int __devinit snd_es1938_create_gameport(struct es1938 *chip)
1450 {
1451         struct gameport *gp;
1452
1453         chip->gameport = gp = gameport_allocate_port();
1454         if (!gp) {
1455                 printk(KERN_ERR "es1938: cannot allocate memory for gameport\n");
1456                 return -ENOMEM;
1457         }
1458
1459         gameport_set_name(gp, "ES1938");
1460         gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
1461         gameport_set_dev_parent(gp, &chip->pci->dev);
1462         gp->io = chip->game_port;
1463
1464         gameport_register_port(gp);
1465
1466         return 0;
1467 }
1468
1469 static void snd_es1938_free_gameport(struct es1938 *chip)
1470 {
1471         if (chip->gameport) {
1472                 gameport_unregister_port(chip->gameport);
1473                 chip->gameport = NULL;
1474         }
1475 }
1476 #else
1477 static inline int snd_es1938_create_gameport(struct es1938 *chip) { return -ENOSYS; }
1478 static inline void snd_es1938_free_gameport(struct es1938 *chip) { }
1479 #endif /* SUPPORT_JOYSTICK */
1480
1481 static int snd_es1938_free(struct es1938 *chip)
1482 {
1483         /* disable irqs */
1484         outb(0x00, SLIO_REG(chip, IRQCONTROL));
1485         if (chip->rmidi)
1486                 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0);
1487
1488         snd_es1938_free_gameport(chip);
1489
1490         if (chip->irq >= 0)
1491                 free_irq(chip->irq, chip);
1492         pci_release_regions(chip->pci);
1493         pci_disable_device(chip->pci);
1494         kfree(chip);
1495         return 0;
1496 }
1497
1498 static int snd_es1938_dev_free(struct snd_device *device)
1499 {
1500         struct es1938 *chip = device->device_data;
1501         return snd_es1938_free(chip);
1502 }
1503
1504 static int __devinit snd_es1938_create(struct snd_card *card,
1505                                     struct pci_dev * pci,
1506                                     struct es1938 ** rchip)
1507 {
1508         struct es1938 *chip;
1509         int err;
1510         static struct snd_device_ops ops = {
1511                 .dev_free =     snd_es1938_dev_free,
1512         };
1513
1514         *rchip = NULL;
1515
1516         /* enable PCI device */
1517         if ((err = pci_enable_device(pci)) < 0)
1518                 return err;
1519         /* check, if we can restrict PCI DMA transfers to 24 bits */
1520         if (pci_set_dma_mask(pci, 0x00ffffff) < 0 ||
1521             pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) {
1522                 snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
1523                 pci_disable_device(pci);
1524                 return -ENXIO;
1525         }
1526
1527         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1528         if (chip == NULL) {
1529                 pci_disable_device(pci);
1530                 return -ENOMEM;
1531         }
1532         spin_lock_init(&chip->reg_lock);
1533         spin_lock_init(&chip->mixer_lock);
1534         chip->card = card;
1535         chip->pci = pci;
1536         if ((err = pci_request_regions(pci, "ESS Solo-1")) < 0) {
1537                 kfree(chip);
1538                 pci_disable_device(pci);
1539                 return err;
1540         }
1541         chip->io_port = pci_resource_start(pci, 0);
1542         chip->sb_port = pci_resource_start(pci, 1);
1543         chip->vc_port = pci_resource_start(pci, 2);
1544         chip->mpu_port = pci_resource_start(pci, 3);
1545         chip->game_port = pci_resource_start(pci, 4);
1546         if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ,
1547                         "ES1938", chip)) {
1548                 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
1549                 snd_es1938_free(chip);
1550                 return -EBUSY;
1551         }
1552         chip->irq = pci->irq;
1553 #ifdef ES1938_DDEBUG
1554         snd_printk(KERN_DEBUG "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
1555                    chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1556 #endif
1557
1558         chip->ddma_port = chip->vc_port + 0x00;         /* fix from Thomas Sailer */
1559
1560         snd_es1938_chip_init(chip);
1561
1562         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1563                 snd_es1938_free(chip);
1564                 return err;
1565         }
1566
1567         snd_card_set_dev(card, &pci->dev);
1568
1569         *rchip = chip;
1570         return 0;
1571 }
1572
1573 /* --------------------------------------------------------------------
1574  * Interrupt handler
1575  * -------------------------------------------------------------------- */
1576 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1577 {
1578         struct es1938 *chip = dev_id;
1579         unsigned char status, audiostatus;
1580         int handled = 0;
1581
1582         status = inb(SLIO_REG(chip, IRQCONTROL));
1583 #if 0
1584         printk("Es1938debug - interrupt status: =0x%x\n", status);
1585 #endif
1586         
1587         /* AUDIO 1 */
1588         if (status & 0x10) {
1589 #if 0
1590                 printk("Es1938debug - AUDIO channel 1 interrupt\n");
1591                 printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
1592                        inw(SLDM_REG(chip, DMACOUNT)));
1593                 printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
1594                        inl(SLDM_REG(chip, DMAADDR)));
1595                 printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
1596                        inl(SLDM_REG(chip, DMASTATUS)));
1597 #endif
1598                 /* clear irq */
1599                 handled = 1;
1600                 audiostatus = inb(SLSB_REG(chip, STATUS));
1601                 if (chip->active & ADC1)
1602                         snd_pcm_period_elapsed(chip->capture_substream);
1603                 else if (chip->active & DAC1)
1604                         snd_pcm_period_elapsed(chip->playback2_substream);
1605         }
1606         
1607         /* AUDIO 2 */
1608         if (status & 0x20) {
1609 #if 0
1610                 printk("Es1938debug - AUDIO channel 2 interrupt\n");
1611                 printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
1612                        inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
1613                 printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
1614                        inl(SLIO_REG(chip, AUDIO2DMAADDR)));
1615
1616 #endif
1617                 /* clear irq */
1618                 handled = 1;
1619                 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
1620                 if (chip->active & DAC2)
1621                         snd_pcm_period_elapsed(chip->playback1_substream);
1622         }
1623
1624         /* Hardware volume */
1625         if (status & 0x40) {
1626                 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
1627                 handled = 1;
1628                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
1629                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
1630                 if (!split) {
1631                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1632                                        &chip->master_switch->id);
1633                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1634                                        &chip->master_volume->id);
1635                 }
1636                 /* ack interrupt */
1637                 snd_es1938_mixer_write(chip, 0x66, 0x00);
1638         }
1639
1640         /* MPU401 */
1641         if (status & 0x80) {
1642                 // the following line is evil! It switches off MIDI interrupt handling after the first interrupt received.
1643                 // replacing the last 0 by 0x40 works for ESS-Solo1, but just doing nothing works as well!
1644                 // andreas@flying-snail.de
1645                 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
1646                 if (chip->rmidi) {
1647                         handled = 1;
1648                         snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
1649                 }
1650         }
1651         return IRQ_RETVAL(handled);
1652 }
1653
1654 #define ES1938_DMA_SIZE 64
1655
1656 static int __devinit snd_es1938_mixer(struct es1938 *chip)
1657 {
1658         struct snd_card *card;
1659         unsigned int idx;
1660         int err;
1661
1662         card = chip->card;
1663
1664         strcpy(card->mixername, "ESS Solo-1");
1665
1666         for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
1667                 struct snd_kcontrol *kctl;
1668                 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
1669                 switch (idx) {
1670                         case 0:
1671                                 chip->master_volume = kctl;
1672                                 kctl->private_free = snd_es1938_hwv_free;
1673                                 break;
1674                         case 1:
1675                                 chip->master_switch = kctl;
1676                                 kctl->private_free = snd_es1938_hwv_free;
1677                                 break;
1678                         case 2:
1679                                 chip->hw_volume = kctl;
1680                                 kctl->private_free = snd_es1938_hwv_free;
1681                                 break;
1682                         case 3:
1683                                 chip->hw_switch = kctl;
1684                                 kctl->private_free = snd_es1938_hwv_free;
1685                                 break;
1686                         }
1687                 if ((err = snd_ctl_add(card, kctl)) < 0)
1688                         return err;
1689         }
1690         return 0;
1691 }
1692        
1693
1694 static int __devinit snd_es1938_probe(struct pci_dev *pci,
1695                                       const struct pci_device_id *pci_id)
1696 {
1697         static int dev;
1698         struct snd_card *card;
1699         struct es1938 *chip;
1700         struct snd_opl3 *opl3;
1701         int idx, err;
1702
1703         if (dev >= SNDRV_CARDS)
1704                 return -ENODEV;
1705         if (!enable[dev]) {
1706                 dev++;
1707                 return -ENOENT;
1708         }
1709
1710         card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
1711         if (card == NULL)
1712                 return -ENOMEM;
1713         for (idx = 0; idx < 5; idx++) {
1714                 if (pci_resource_start(pci, idx) == 0 ||
1715                     !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) {
1716                         snd_card_free(card);
1717                         return -ENODEV;
1718                 }
1719         }
1720         if ((err = snd_es1938_create(card, pci, &chip)) < 0) {
1721                 snd_card_free(card);
1722                 return err;
1723         }
1724         card->private_data = chip;
1725
1726         strcpy(card->driver, "ES1938");
1727         strcpy(card->shortname, "ESS ES1938 (Solo-1)");
1728         sprintf(card->longname, "%s rev %i, irq %i",
1729                 card->shortname,
1730                 chip->revision,
1731                 chip->irq);
1732
1733         if ((err = snd_es1938_new_pcm(chip, 0)) < 0) {
1734                 snd_card_free(card);
1735                 return err;
1736         }
1737         if ((err = snd_es1938_mixer(chip)) < 0) {
1738                 snd_card_free(card);
1739                 return err;
1740         }
1741         if (snd_opl3_create(card,
1742                             SLSB_REG(chip, FMLOWADDR),
1743                             SLSB_REG(chip, FMHIGHADDR),
1744                             OPL3_HW_OPL3, 1, &opl3) < 0) {
1745                 printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n",
1746                            SLSB_REG(chip, FMLOWADDR));
1747         } else {
1748                 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
1749                         snd_card_free(card);
1750                         return err;
1751                 }
1752                 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
1753                         snd_card_free(card);
1754                         return err;
1755                 }
1756         }
1757         if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
1758                                 chip->mpu_port, 1, chip->irq, 0, &chip->rmidi) < 0) {
1759                 printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
1760         } else {
1761                 // this line is vital for MIDI interrupt handling on ess-solo1
1762                 // andreas@flying-snail.de
1763                 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);
1764         }
1765
1766         snd_es1938_create_gameport(chip);
1767
1768         if ((err = snd_card_register(card)) < 0) {
1769                 snd_card_free(card);
1770                 return err;
1771         }
1772
1773         pci_set_drvdata(pci, card);
1774         dev++;
1775         return 0;
1776 }
1777
1778 static void __devexit snd_es1938_remove(struct pci_dev *pci)
1779 {
1780         snd_card_free(pci_get_drvdata(pci));
1781         pci_set_drvdata(pci, NULL);
1782 }
1783
1784 static struct pci_driver driver = {
1785         .name = "ESS ES1938 (Solo-1)",
1786         .id_table = snd_es1938_ids,
1787         .probe = snd_es1938_probe,
1788         .remove = __devexit_p(snd_es1938_remove),
1789 #ifdef CONFIG_PM
1790         .suspend = es1938_suspend,
1791         .resume = es1938_resume,
1792 #endif
1793 };
1794
1795 static int __init alsa_card_es1938_init(void)
1796 {
1797         return pci_register_driver(&driver);
1798 }
1799
1800 static void __exit alsa_card_es1938_exit(void)
1801 {
1802         pci_unregister_driver(&driver);
1803 }
1804
1805 module_init(alsa_card_es1938_init)
1806 module_exit(alsa_card_es1938_exit)