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