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