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