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