2 * Driver for ESS Solo-1 (ES1938, ES1946, ES1969) soundcard
3 * Copyright (c) by Jaromir Koutek <miri@punknet.cz>,
4 * Jaroslav Kysela <perex@suse.cz>,
5 * Thomas Sailer <sailer@ife.ee.ethz.ch>,
6 * Abramo Bagnara <abramo@alsa-project.org>,
7 * Markus Gruber <gruber@eikon.tum.de>
9 * Rewritten from sonicvibes.c source.
12 * Rewrite better spinlocks
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.
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.
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
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
43 I've seen that using small period sizes.
50 #include <sound/driver.h>
51 #include <linux/init.h>
52 #include <linux/interrupt.h>
53 #include <linux/pci.h>
54 #include <linux/slab.h>
55 #include <linux/gameport.h>
56 #include <linux/moduleparam.h>
57 #include <linux/delay.h>
58 #include <sound/core.h>
59 #include <sound/control.h>
60 #include <sound/pcm.h>
61 #include <sound/opl3.h>
62 #include <sound/mpu401.h>
63 #include <sound/initval.h>
67 MODULE_AUTHOR("Jaromir Koutek <miri@punknet.cz>");
68 MODULE_DESCRIPTION("ESS Solo-1");
69 MODULE_LICENSE("GPL");
70 MODULE_SUPPORTED_DEVICE("{{ESS,ES1938},"
73 "{TerraTec,128i PCI}}");
75 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
76 #define SUPPORT_JOYSTICK 1
79 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
80 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
81 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
83 module_param_array(index, int, NULL, 0444);
84 MODULE_PARM_DESC(index, "Index value for ESS Solo-1 soundcard.");
85 module_param_array(id, charp, NULL, 0444);
86 MODULE_PARM_DESC(id, "ID string for ESS Solo-1 soundcard.");
87 module_param_array(enable, bool, NULL, 0444);
88 MODULE_PARM_DESC(enable, "Enable ESS Solo-1 soundcard.");
90 #define SLIO_REG(chip, x) ((chip)->io_port + ESSIO_REG_##x)
92 #define SLDM_REG(chip, x) ((chip)->ddma_port + ESSDM_REG_##x)
94 #define SLSB_REG(chip, x) ((chip)->sb_port + ESSSB_REG_##x)
96 #define SL_PCI_LEGACYCONTROL 0x40
97 #define SL_PCI_CONFIG 0x50
98 #define SL_PCI_DDMACONTROL 0x60
100 #define ESSIO_REG_AUDIO2DMAADDR 0
101 #define ESSIO_REG_AUDIO2DMACOUNT 4
102 #define ESSIO_REG_AUDIO2MODE 6
103 #define ESSIO_REG_IRQCONTROL 7
105 #define ESSDM_REG_DMAADDR 0x00
106 #define ESSDM_REG_DMACOUNT 0x04
107 #define ESSDM_REG_DMACOMMAND 0x08
108 #define ESSDM_REG_DMASTATUS 0x08
109 #define ESSDM_REG_DMAMODE 0x0b
110 #define ESSDM_REG_DMACLEAR 0x0d
111 #define ESSDM_REG_DMAMASK 0x0f
113 #define ESSSB_REG_FMLOWADDR 0x00
114 #define ESSSB_REG_FMHIGHADDR 0x02
115 #define ESSSB_REG_MIXERADDR 0x04
116 #define ESSSB_REG_MIXERDATA 0x05
118 #define ESSSB_IREG_AUDIO1 0x14
119 #define ESSSB_IREG_MICMIX 0x1a
120 #define ESSSB_IREG_RECSRC 0x1c
121 #define ESSSB_IREG_MASTER 0x32
122 #define ESSSB_IREG_FM 0x36
123 #define ESSSB_IREG_AUXACD 0x38
124 #define ESSSB_IREG_AUXB 0x3a
125 #define ESSSB_IREG_PCSPEAKER 0x3c
126 #define ESSSB_IREG_LINE 0x3e
127 #define ESSSB_IREG_SPATCONTROL 0x50
128 #define ESSSB_IREG_SPATLEVEL 0x52
129 #define ESSSB_IREG_MASTER_LEFT 0x60
130 #define ESSSB_IREG_MASTER_RIGHT 0x62
131 #define ESSSB_IREG_MPU401CONTROL 0x64
132 #define ESSSB_IREG_MICMIXRECORD 0x68
133 #define ESSSB_IREG_AUDIO2RECORD 0x69
134 #define ESSSB_IREG_AUXACDRECORD 0x6a
135 #define ESSSB_IREG_FMRECORD 0x6b
136 #define ESSSB_IREG_AUXBRECORD 0x6c
137 #define ESSSB_IREG_MONO 0x6d
138 #define ESSSB_IREG_LINERECORD 0x6e
139 #define ESSSB_IREG_MONORECORD 0x6f
140 #define ESSSB_IREG_AUDIO2SAMPLE 0x70
141 #define ESSSB_IREG_AUDIO2MODE 0x71
142 #define ESSSB_IREG_AUDIO2FILTER 0x72
143 #define ESSSB_IREG_AUDIO2TCOUNTL 0x74
144 #define ESSSB_IREG_AUDIO2TCOUNTH 0x76
145 #define ESSSB_IREG_AUDIO2CONTROL1 0x78
146 #define ESSSB_IREG_AUDIO2CONTROL2 0x7a
147 #define ESSSB_IREG_AUDIO2 0x7c
149 #define ESSSB_REG_RESET 0x06
151 #define ESSSB_REG_READDATA 0x0a
152 #define ESSSB_REG_WRITEDATA 0x0c
153 #define ESSSB_REG_READSTATUS 0x0c
155 #define ESSSB_REG_STATUS 0x0e
157 #define ESS_CMD_EXTSAMPLERATE 0xa1
158 #define ESS_CMD_FILTERDIV 0xa2
159 #define ESS_CMD_DMACNTRELOADL 0xa4
160 #define ESS_CMD_DMACNTRELOADH 0xa5
161 #define ESS_CMD_ANALOGCONTROL 0xa8
162 #define ESS_CMD_IRQCONTROL 0xb1
163 #define ESS_CMD_DRQCONTROL 0xb2
164 #define ESS_CMD_RECLEVEL 0xb4
165 #define ESS_CMD_SETFORMAT 0xb6
166 #define ESS_CMD_SETFORMAT2 0xb7
167 #define ESS_CMD_DMACONTROL 0xb8
168 #define ESS_CMD_DMATYPE 0xb9
169 #define ESS_CMD_OFFSETLEFT 0xba
170 #define ESS_CMD_OFFSETRIGHT 0xbb
171 #define ESS_CMD_READREG 0xc0
172 #define ESS_CMD_ENABLEEXT 0xc6
173 #define ESS_CMD_PAUSEDMA 0xd0
174 #define ESS_CMD_ENABLEAUDIO1 0xd1
175 #define ESS_CMD_STOPAUDIO1 0xd3
176 #define ESS_CMD_AUDIO1STATUS 0xd8
177 #define ESS_CMD_CONTDMA 0xd4
178 #define ESS_CMD_TESTIRQ 0xf2
180 #define ESS_RECSRC_MIC 0
181 #define ESS_RECSRC_AUXACD 2
182 #define ESS_RECSRC_AUXB 5
183 #define ESS_RECSRC_LINE 6
184 #define ESS_RECSRC_NONE 7
194 typedef struct _snd_es1938 es1938_t;
196 #define SAVED_REG_SIZE 32 /* max. number of registers to save */
201 unsigned long io_port;
202 unsigned long sb_port;
203 unsigned long vc_port;
204 unsigned long mpu_port;
205 unsigned long game_port;
206 unsigned long ddma_port;
208 unsigned char irqmask;
209 unsigned char revision;
211 snd_kcontrol_t *hw_volume;
212 snd_kcontrol_t *hw_switch;
213 snd_kcontrol_t *master_volume;
214 snd_kcontrol_t *master_switch;
219 snd_pcm_substream_t *capture_substream;
220 snd_pcm_substream_t *playback1_substream;
221 snd_pcm_substream_t *playback2_substream;
223 snd_rawmidi_t *rmidi;
225 unsigned int dma1_size;
226 unsigned int dma2_size;
227 unsigned int dma1_start;
228 unsigned int dma2_start;
229 unsigned int dma1_shift;
230 unsigned int dma2_shift;
234 spinlock_t mixer_lock;
235 snd_info_entry_t *proc_entry;
237 #ifdef SUPPORT_JOYSTICK
238 struct gameport *gameport;
241 unsigned char saved_regs[SAVED_REG_SIZE];
245 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs);
247 static struct pci_device_id snd_es1938_ids[] = {
248 { 0x125d, 0x1969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* Solo-1 */
252 MODULE_DEVICE_TABLE(pci, snd_es1938_ids);
254 #define RESET_LOOP_TIMEOUT 0x10000
255 #define WRITE_LOOP_TIMEOUT 0x10000
256 #define GET_LOOP_TIMEOUT 0x01000
259 /* -----------------------------------------------------------------
260 * Write to a mixer register
261 * -----------------------------------------------------------------*/
262 static void snd_es1938_mixer_write(es1938_t *chip, unsigned char reg, unsigned char val)
265 spin_lock_irqsave(&chip->mixer_lock, flags);
266 outb(reg, SLSB_REG(chip, MIXERADDR));
267 outb(val, SLSB_REG(chip, MIXERDATA));
268 spin_unlock_irqrestore(&chip->mixer_lock, flags);
270 snd_printk("Mixer reg %02x set to %02x\n", reg, val);
274 /* -----------------------------------------------------------------
275 * Read from a mixer register
276 * -----------------------------------------------------------------*/
277 static int snd_es1938_mixer_read(es1938_t *chip, unsigned char reg)
281 spin_lock_irqsave(&chip->mixer_lock, flags);
282 outb(reg, SLSB_REG(chip, MIXERADDR));
283 data = inb(SLSB_REG(chip, MIXERDATA));
284 spin_unlock_irqrestore(&chip->mixer_lock, flags);
286 snd_printk("Mixer reg %02x now is %02x\n", reg, data);
291 /* -----------------------------------------------------------------
292 * Write to some bits of a mixer register (return old value)
293 * -----------------------------------------------------------------*/
294 static int snd_es1938_mixer_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val)
297 unsigned char old, new, oval;
298 spin_lock_irqsave(&chip->mixer_lock, flags);
299 outb(reg, SLSB_REG(chip, MIXERADDR));
300 old = inb(SLSB_REG(chip, MIXERDATA));
303 new = (old & ~mask) | (val & mask);
304 outb(new, SLSB_REG(chip, MIXERDATA));
306 snd_printk("Mixer reg %02x was %02x, set to %02x\n", reg, old, new);
309 spin_unlock_irqrestore(&chip->mixer_lock, flags);
313 /* -----------------------------------------------------------------
314 * Write command to Controller Registers
315 * -----------------------------------------------------------------*/
316 static void snd_es1938_write_cmd(es1938_t *chip, unsigned char cmd)
320 for (i = 0; i < WRITE_LOOP_TIMEOUT; i++) {
321 if (!(v = inb(SLSB_REG(chip, READSTATUS)) & 0x80)) {
322 outb(cmd, SLSB_REG(chip, WRITEDATA));
326 printk("snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v);
329 /* -----------------------------------------------------------------
330 * Read the Read Data Buffer
331 * -----------------------------------------------------------------*/
332 static int snd_es1938_get_byte(es1938_t *chip)
336 for (i = GET_LOOP_TIMEOUT; i; i--)
337 if ((v = inb(SLSB_REG(chip, STATUS))) & 0x80)
338 return inb(SLSB_REG(chip, READDATA));
339 snd_printk("get_byte timeout: status 0x02%x\n", v);
343 /* -----------------------------------------------------------------
344 * Write value cmd register
345 * -----------------------------------------------------------------*/
346 static void snd_es1938_write(es1938_t *chip, unsigned char reg, unsigned char val)
349 spin_lock_irqsave(&chip->reg_lock, flags);
350 snd_es1938_write_cmd(chip, reg);
351 snd_es1938_write_cmd(chip, val);
352 spin_unlock_irqrestore(&chip->reg_lock, flags);
354 snd_printk("Reg %02x set to %02x\n", reg, val);
358 /* -----------------------------------------------------------------
359 * Read data from cmd register and return it
360 * -----------------------------------------------------------------*/
361 static unsigned char snd_es1938_read(es1938_t *chip, unsigned char reg)
365 spin_lock_irqsave(&chip->reg_lock, flags);
366 snd_es1938_write_cmd(chip, ESS_CMD_READREG);
367 snd_es1938_write_cmd(chip, reg);
368 val = snd_es1938_get_byte(chip);
369 spin_unlock_irqrestore(&chip->reg_lock, flags);
371 snd_printk("Reg %02x now is %02x\n", reg, val);
376 /* -----------------------------------------------------------------
377 * Write data to cmd register and return old value
378 * -----------------------------------------------------------------*/
379 static int snd_es1938_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val)
382 unsigned char old, new, oval;
383 spin_lock_irqsave(&chip->reg_lock, flags);
384 snd_es1938_write_cmd(chip, ESS_CMD_READREG);
385 snd_es1938_write_cmd(chip, reg);
386 old = snd_es1938_get_byte(chip);
389 snd_es1938_write_cmd(chip, reg);
390 new = (old & ~mask) | (val & mask);
391 snd_es1938_write_cmd(chip, new);
393 snd_printk("Reg %02x was %02x, set to %02x\n", reg, old, new);
396 spin_unlock_irqrestore(&chip->reg_lock, flags);
400 /* --------------------------------------------------------------------
402 * --------------------------------------------------------------------*/
403 static void snd_es1938_reset(es1938_t *chip)
407 outb(3, SLSB_REG(chip, RESET));
408 inb(SLSB_REG(chip, RESET));
409 outb(0, SLSB_REG(chip, RESET));
410 for (i = 0; i < RESET_LOOP_TIMEOUT; i++) {
411 if (inb(SLSB_REG(chip, STATUS)) & 0x80) {
412 if (inb(SLSB_REG(chip, READDATA)) == 0xaa)
416 snd_printk("ESS Solo-1 reset failed\n");
419 snd_es1938_write_cmd(chip, ESS_CMD_ENABLEEXT);
421 /* Demand transfer DMA: 4 bytes per DMA request */
422 snd_es1938_write(chip, ESS_CMD_DMATYPE, 2);
424 /* Change behaviour of register A1
426 2nd channel DAC asynchronous */
427 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2MODE, 0x32);
428 /* enable/select DMA channel and IRQ channel */
429 snd_es1938_bits(chip, ESS_CMD_IRQCONTROL, 0xf0, 0x50);
430 snd_es1938_bits(chip, ESS_CMD_DRQCONTROL, 0xf0, 0x50);
431 snd_es1938_write_cmd(chip, ESS_CMD_ENABLEAUDIO1);
432 /* Set spatializer parameters to recommended values */
433 snd_es1938_mixer_write(chip, 0x54, 0x8f);
434 snd_es1938_mixer_write(chip, 0x56, 0x95);
435 snd_es1938_mixer_write(chip, 0x58, 0x94);
436 snd_es1938_mixer_write(chip, 0x5a, 0x80);
439 /* --------------------------------------------------------------------
441 * --------------------------------------------------------------------*/
442 static void snd_es1938_reset_fifo(es1938_t *chip)
444 outb(2, SLSB_REG(chip, RESET));
445 outb(0, SLSB_REG(chip, RESET));
448 static ratnum_t clocks[2] = {
463 static snd_pcm_hw_constraint_ratnums_t hw_constraints_clocks = {
469 static void snd_es1938_rate_set(es1938_t *chip,
470 snd_pcm_substream_t *substream,
473 unsigned int bits, div0;
474 snd_pcm_runtime_t *runtime = substream->runtime;
475 if (runtime->rate_num == clocks[0].num)
476 bits = 128 - runtime->rate_den;
478 bits = 256 - runtime->rate_den;
480 /* set filter register */
481 div0 = 256 - 7160000*20/(8*82*runtime->rate);
484 snd_es1938_mixer_write(chip, 0x70, bits);
485 snd_es1938_mixer_write(chip, 0x72, div0);
487 snd_es1938_write(chip, 0xA1, bits);
488 snd_es1938_write(chip, 0xA2, div0);
492 /* --------------------------------------------------------------------
493 * Configure Solo1 builtin DMA Controller
494 * --------------------------------------------------------------------*/
496 static void snd_es1938_playback1_setdma(es1938_t *chip)
498 outb(0x00, SLIO_REG(chip, AUDIO2MODE));
499 outl(chip->dma2_start, SLIO_REG(chip, AUDIO2DMAADDR));
500 outw(0, SLIO_REG(chip, AUDIO2DMACOUNT));
501 outw(chip->dma2_size, SLIO_REG(chip, AUDIO2DMACOUNT));
504 static void snd_es1938_playback2_setdma(es1938_t *chip)
506 /* Enable DMA controller */
507 outb(0xc4, SLDM_REG(chip, DMACOMMAND));
508 /* 1. Master reset */
509 outb(0, SLDM_REG(chip, DMACLEAR));
511 outb(1, SLDM_REG(chip, DMAMASK));
512 outb(0x18, SLDM_REG(chip, DMAMODE));
513 outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
514 outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
516 outb(0, SLDM_REG(chip, DMAMASK));
519 static void snd_es1938_capture_setdma(es1938_t *chip)
521 /* Enable DMA controller */
522 outb(0xc4, SLDM_REG(chip, DMACOMMAND));
523 /* 1. Master reset */
524 outb(0, SLDM_REG(chip, DMACLEAR));
526 outb(1, SLDM_REG(chip, DMAMASK));
527 outb(0x14, SLDM_REG(chip, DMAMODE));
528 outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
529 outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
531 outb(0, SLDM_REG(chip, DMAMASK));
534 /* ----------------------------------------------------------------------
539 static int snd_es1938_capture_trigger(snd_pcm_substream_t * substream,
542 es1938_t *chip = snd_pcm_substream_chip(substream);
545 case SNDRV_PCM_TRIGGER_START:
546 case SNDRV_PCM_TRIGGER_RESUME:
548 chip->active |= ADC1;
550 case SNDRV_PCM_TRIGGER_STOP:
551 case SNDRV_PCM_TRIGGER_SUSPEND:
553 chip->active &= ~ADC1;
558 snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
562 static int snd_es1938_playback1_trigger(snd_pcm_substream_t * substream,
565 es1938_t *chip = snd_pcm_substream_chip(substream);
567 case SNDRV_PCM_TRIGGER_START:
568 case SNDRV_PCM_TRIGGER_RESUME:
569 /* According to the documentation this should be:
570 0x13 but that value may randomly swap stereo channels */
571 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x92);
573 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x93);
574 /* This two stage init gives the FIFO -> DAC connection time to
575 * settle before first data from DMA flows in. This should ensure
576 * no swapping of stereo channels. Report a bug if otherwise :-) */
577 outb(0x0a, SLIO_REG(chip, AUDIO2MODE));
578 chip->active |= DAC2;
580 case SNDRV_PCM_TRIGGER_STOP:
581 case SNDRV_PCM_TRIGGER_SUSPEND:
582 outb(0, SLIO_REG(chip, AUDIO2MODE));
583 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0);
584 chip->active &= ~DAC2;
592 static int snd_es1938_playback2_trigger(snd_pcm_substream_t * substream,
595 es1938_t *chip = snd_pcm_substream_chip(substream);
598 case SNDRV_PCM_TRIGGER_START:
599 case SNDRV_PCM_TRIGGER_RESUME:
601 chip->active |= DAC1;
603 case SNDRV_PCM_TRIGGER_STOP:
604 case SNDRV_PCM_TRIGGER_SUSPEND:
606 chip->active &= ~DAC1;
611 snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
615 static int snd_es1938_playback_trigger(snd_pcm_substream_t *substream,
618 switch (substream->number) {
620 return snd_es1938_playback1_trigger(substream, cmd);
622 return snd_es1938_playback2_trigger(substream, cmd);
628 /* --------------------------------------------------------------------
629 * First channel for Extended Mode Audio 1 ADC Operation
630 * --------------------------------------------------------------------*/
631 static int snd_es1938_capture_prepare(snd_pcm_substream_t * substream)
633 es1938_t *chip = snd_pcm_substream_chip(substream);
634 snd_pcm_runtime_t *runtime = substream->runtime;
636 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
637 unsigned int count = snd_pcm_lib_period_bytes(substream);
639 chip->dma1_size = size;
640 chip->dma1_start = runtime->dma_addr;
642 mono = (runtime->channels > 1) ? 0 : 1;
643 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
644 u = snd_pcm_format_unsigned(runtime->format);
646 chip->dma1_shift = 2 - mono - is8;
648 snd_es1938_reset_fifo(chip);
651 snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
653 /* set clock and counters */
654 snd_es1938_rate_set(chip, substream, ADC1);
656 count = 0x10000 - count;
657 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
658 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
660 /* initialize and configure ADC */
661 snd_es1938_write(chip, ESS_CMD_SETFORMAT2, u ? 0x51 : 0x71);
662 snd_es1938_write(chip, ESS_CMD_SETFORMAT2, 0x90 |
664 (is8 ? 0x00 : 0x04) |
665 (mono ? 0x40 : 0x08));
667 // snd_es1938_reset_fifo(chip);
669 /* 11. configure system interrupt controller and DMA controller */
670 snd_es1938_capture_setdma(chip);
676 /* ------------------------------------------------------------------------------
677 * Second Audio channel DAC Operation
678 * ------------------------------------------------------------------------------*/
679 static int snd_es1938_playback1_prepare(snd_pcm_substream_t * substream)
681 es1938_t *chip = snd_pcm_substream_chip(substream);
682 snd_pcm_runtime_t *runtime = substream->runtime;
684 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
685 unsigned int count = snd_pcm_lib_period_bytes(substream);
687 chip->dma2_size = size;
688 chip->dma2_start = runtime->dma_addr;
690 mono = (runtime->channels > 1) ? 0 : 1;
691 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
692 u = snd_pcm_format_unsigned(runtime->format);
694 chip->dma2_shift = 2 - mono - is8;
696 snd_es1938_reset_fifo(chip);
698 /* set clock and counters */
699 snd_es1938_rate_set(chip, substream, DAC2);
702 count = 0x10000 - count;
703 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTL, count & 0xff);
704 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTH, count >> 8);
706 /* initialize and configure Audio 2 DAC */
707 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) | (mono ? 0 : 2) | (is8 ? 0 : 1));
710 snd_es1938_playback1_setdma(chip);
715 static int snd_es1938_playback2_prepare(snd_pcm_substream_t * substream)
717 es1938_t *chip = snd_pcm_substream_chip(substream);
718 snd_pcm_runtime_t *runtime = substream->runtime;
720 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
721 unsigned int count = snd_pcm_lib_period_bytes(substream);
723 chip->dma1_size = size;
724 chip->dma1_start = runtime->dma_addr;
726 mono = (runtime->channels > 1) ? 0 : 1;
727 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
728 u = snd_pcm_format_unsigned(runtime->format);
730 chip->dma1_shift = 2 - mono - is8;
732 count = 0x10000 - count;
735 snd_es1938_reset_fifo(chip);
737 snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
739 /* set clock and counters */
740 snd_es1938_rate_set(chip, substream, DAC1);
741 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
742 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
744 /* initialized and configure DAC */
745 snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x80 : 0x00);
746 snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x51 : 0x71);
747 snd_es1938_write(chip, ESS_CMD_SETFORMAT2,
748 0x90 | (mono ? 0x40 : 0x08) |
749 (is8 ? 0x00 : 0x04) | (u ? 0x00 : 0x20));
752 snd_es1938_playback2_setdma(chip);
757 static int snd_es1938_playback_prepare(snd_pcm_substream_t *substream)
759 switch (substream->number) {
761 return snd_es1938_playback1_prepare(substream);
763 return snd_es1938_playback2_prepare(substream);
769 static snd_pcm_uframes_t snd_es1938_capture_pointer(snd_pcm_substream_t * substream)
771 es1938_t *chip = snd_pcm_substream_chip(substream);
775 /* This stuff is *needed*, don't ask why - AB */
776 old = inw(SLDM_REG(chip, DMACOUNT));
777 while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
779 ptr = chip->dma1_size - 1 - new;
781 ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start;
783 return ptr >> chip->dma1_shift;
786 static snd_pcm_uframes_t snd_es1938_playback1_pointer(snd_pcm_substream_t * substream)
788 es1938_t *chip = snd_pcm_substream_chip(substream);
791 ptr = chip->dma2_size - inw(SLIO_REG(chip, AUDIO2DMACOUNT));
793 ptr = inl(SLIO_REG(chip, AUDIO2DMAADDR)) - chip->dma2_start;
795 return ptr >> chip->dma2_shift;
798 static snd_pcm_uframes_t snd_es1938_playback2_pointer(snd_pcm_substream_t * substream)
800 es1938_t *chip = snd_pcm_substream_chip(substream);
804 /* This stuff is *needed*, don't ask why - AB */
805 old = inw(SLDM_REG(chip, DMACOUNT));
806 while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
808 ptr = chip->dma1_size - 1 - new;
810 ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start;
812 return ptr >> chip->dma1_shift;
815 static snd_pcm_uframes_t snd_es1938_playback_pointer(snd_pcm_substream_t *substream)
817 switch (substream->number) {
819 return snd_es1938_playback1_pointer(substream);
821 return snd_es1938_playback2_pointer(substream);
827 static int snd_es1938_capture_copy(snd_pcm_substream_t *substream,
829 snd_pcm_uframes_t pos,
831 snd_pcm_uframes_t count)
833 snd_pcm_runtime_t *runtime = substream->runtime;
834 es1938_t *chip = snd_pcm_substream_chip(substream);
835 pos <<= chip->dma1_shift;
836 count <<= chip->dma1_shift;
837 snd_assert(pos + count <= chip->dma1_size, return -EINVAL);
838 if (pos + count < chip->dma1_size) {
839 if (copy_to_user(dst, runtime->dma_area + pos + 1, count))
842 if (copy_to_user(dst, runtime->dma_area + pos + 1, count - 1))
844 if (put_user(runtime->dma_area[0], ((unsigned char __user *)dst) + count - 1))
853 static int snd_es1938_pcm_hw_params(snd_pcm_substream_t *substream,
854 snd_pcm_hw_params_t * hw_params)
859 if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
864 static int snd_es1938_pcm_hw_free(snd_pcm_substream_t *substream)
866 return snd_pcm_lib_free_pages(substream);
869 /* ----------------------------------------------------------------------
870 * Audio1 Capture (ADC)
871 * ----------------------------------------------------------------------*/
872 static snd_pcm_hardware_t snd_es1938_capture =
874 .info = (SNDRV_PCM_INFO_INTERLEAVED |
875 SNDRV_PCM_INFO_BLOCK_TRANSFER),
876 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE,
877 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
882 .buffer_bytes_max = 0x8000, /* DMA controller screws on higher values */
883 .period_bytes_min = 64,
884 .period_bytes_max = 0x8000,
890 /* -----------------------------------------------------------------------
891 * Audio2 Playback (DAC)
892 * -----------------------------------------------------------------------*/
893 static snd_pcm_hardware_t snd_es1938_playback =
895 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
896 SNDRV_PCM_INFO_BLOCK_TRANSFER |
897 SNDRV_PCM_INFO_MMAP_VALID),
898 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE,
899 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
904 .buffer_bytes_max = 0x8000, /* DMA controller screws on higher values */
905 .period_bytes_min = 64,
906 .period_bytes_max = 0x8000,
912 static int snd_es1938_capture_open(snd_pcm_substream_t * substream)
914 es1938_t *chip = snd_pcm_substream_chip(substream);
915 snd_pcm_runtime_t *runtime = substream->runtime;
917 if (chip->playback2_substream)
919 chip->capture_substream = substream;
920 runtime->hw = snd_es1938_capture;
921 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
922 &hw_constraints_clocks);
923 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
927 static int snd_es1938_playback_open(snd_pcm_substream_t * substream)
929 es1938_t *chip = snd_pcm_substream_chip(substream);
930 snd_pcm_runtime_t *runtime = substream->runtime;
932 switch (substream->number) {
934 chip->playback1_substream = substream;
937 if (chip->capture_substream)
939 chip->playback2_substream = substream;
945 runtime->hw = snd_es1938_playback;
946 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
947 &hw_constraints_clocks);
948 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
952 static int snd_es1938_capture_close(snd_pcm_substream_t * substream)
954 es1938_t *chip = snd_pcm_substream_chip(substream);
956 chip->capture_substream = NULL;
960 static int snd_es1938_playback_close(snd_pcm_substream_t * substream)
962 es1938_t *chip = snd_pcm_substream_chip(substream);
964 switch (substream->number) {
966 chip->playback1_substream = NULL;
969 chip->playback2_substream = NULL;
978 static snd_pcm_ops_t snd_es1938_playback_ops = {
979 .open = snd_es1938_playback_open,
980 .close = snd_es1938_playback_close,
981 .ioctl = snd_pcm_lib_ioctl,
982 .hw_params = snd_es1938_pcm_hw_params,
983 .hw_free = snd_es1938_pcm_hw_free,
984 .prepare = snd_es1938_playback_prepare,
985 .trigger = snd_es1938_playback_trigger,
986 .pointer = snd_es1938_playback_pointer,
989 static snd_pcm_ops_t snd_es1938_capture_ops = {
990 .open = snd_es1938_capture_open,
991 .close = snd_es1938_capture_close,
992 .ioctl = snd_pcm_lib_ioctl,
993 .hw_params = snd_es1938_pcm_hw_params,
994 .hw_free = snd_es1938_pcm_hw_free,
995 .prepare = snd_es1938_capture_prepare,
996 .trigger = snd_es1938_capture_trigger,
997 .pointer = snd_es1938_capture_pointer,
998 .copy = snd_es1938_capture_copy,
1001 static void snd_es1938_free_pcm(snd_pcm_t *pcm)
1003 snd_pcm_lib_preallocate_free_for_all(pcm);
1006 static int __devinit snd_es1938_new_pcm(es1938_t *chip, int device)
1011 if ((err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm)) < 0)
1013 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1938_playback_ops);
1014 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1938_capture_ops);
1016 pcm->private_data = chip;
1017 pcm->private_free = snd_es1938_free_pcm;
1018 pcm->info_flags = 0;
1019 strcpy(pcm->name, "ESS Solo-1");
1021 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1022 snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
1028 /* -------------------------------------------------------------------
1030 * *** Mixer part ***
1033 static int snd_es1938_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1035 static char *texts[8] = {
1036 "Mic", "Mic Master", "CD", "AOUT",
1037 "Mic1", "Mix", "Line", "Master"
1040 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1042 uinfo->value.enumerated.items = 8;
1043 if (uinfo->value.enumerated.item > 7)
1044 uinfo->value.enumerated.item = 7;
1045 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1049 static int snd_es1938_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1051 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1052 ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07;
1056 static int snd_es1938_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1058 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1059 unsigned char val = ucontrol->value.enumerated.item[0];
1063 return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val;
1066 static int snd_es1938_info_spatializer_enable(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1068 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1070 uinfo->value.integer.min = 0;
1071 uinfo->value.integer.max = 1;
1075 static int snd_es1938_get_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1077 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1078 unsigned char val = snd_es1938_mixer_read(chip, 0x50);
1079 ucontrol->value.integer.value[0] = !!(val & 8);
1083 static int snd_es1938_put_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1085 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1086 unsigned char oval, nval;
1088 nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04;
1089 oval = snd_es1938_mixer_read(chip, 0x50) & 0x0c;
1090 change = nval != oval;
1092 snd_es1938_mixer_write(chip, 0x50, nval & ~0x04);
1093 snd_es1938_mixer_write(chip, 0x50, nval);
1098 static int snd_es1938_info_hw_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1100 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1102 uinfo->value.integer.min = 0;
1103 uinfo->value.integer.max = 63;
1107 static int snd_es1938_get_hw_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1109 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1110 ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f;
1111 ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f;
1115 static int snd_es1938_info_hw_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1117 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1119 uinfo->value.integer.min = 0;
1120 uinfo->value.integer.max = 1;
1124 static int snd_es1938_get_hw_switch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1126 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1127 ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40);
1128 ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40);
1132 static void snd_es1938_hwv_free(snd_kcontrol_t *kcontrol)
1134 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1135 chip->master_volume = NULL;
1136 chip->master_switch = NULL;
1137 chip->hw_volume = NULL;
1138 chip->hw_switch = NULL;
1141 static int snd_es1938_reg_bits(es1938_t *chip, unsigned char reg,
1142 unsigned char mask, unsigned char val)
1145 return snd_es1938_mixer_bits(chip, reg, mask, val);
1147 return snd_es1938_bits(chip, reg, mask, val);
1150 static int snd_es1938_reg_read(es1938_t *chip, unsigned char reg)
1153 return snd_es1938_mixer_read(chip, reg);
1155 return snd_es1938_read(chip, reg);
1158 #define ES1938_SINGLE(xname, xindex, reg, shift, mask, invert) \
1159 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1160 .info = snd_es1938_info_single, \
1161 .get = snd_es1938_get_single, .put = snd_es1938_put_single, \
1162 .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
1164 static int snd_es1938_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1166 int mask = (kcontrol->private_value >> 16) & 0xff;
1168 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1170 uinfo->value.integer.min = 0;
1171 uinfo->value.integer.max = mask;
1175 static int snd_es1938_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1177 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1178 int reg = kcontrol->private_value & 0xff;
1179 int shift = (kcontrol->private_value >> 8) & 0xff;
1180 int mask = (kcontrol->private_value >> 16) & 0xff;
1181 int invert = (kcontrol->private_value >> 24) & 0xff;
1184 val = snd_es1938_reg_read(chip, reg);
1185 ucontrol->value.integer.value[0] = (val >> shift) & mask;
1187 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1191 static int snd_es1938_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1193 es1938_t *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;
1200 val = (ucontrol->value.integer.value[0] & mask);
1205 return snd_es1938_reg_bits(chip, reg, mask, val) != val;
1208 #define ES1938_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1209 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1210 .info = snd_es1938_info_double, \
1211 .get = snd_es1938_get_double, .put = snd_es1938_put_double, \
1212 .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1214 static int snd_es1938_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1216 int mask = (kcontrol->private_value >> 24) & 0xff;
1218 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1220 uinfo->value.integer.min = 0;
1221 uinfo->value.integer.max = mask;
1225 static int snd_es1938_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1227 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1228 int left_reg = kcontrol->private_value & 0xff;
1229 int right_reg = (kcontrol->private_value >> 8) & 0xff;
1230 int shift_left = (kcontrol->private_value >> 16) & 0x07;
1231 int shift_right = (kcontrol->private_value >> 19) & 0x07;
1232 int mask = (kcontrol->private_value >> 24) & 0xff;
1233 int invert = (kcontrol->private_value >> 22) & 1;
1234 unsigned char left, right;
1236 left = snd_es1938_reg_read(chip, left_reg);
1237 if (left_reg != right_reg)
1238 right = snd_es1938_reg_read(chip, right_reg);
1241 ucontrol->value.integer.value[0] = (left >> shift_left) & mask;
1242 ucontrol->value.integer.value[1] = (right >> shift_right) & mask;
1244 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1245 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
1250 static int snd_es1938_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1252 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1253 int left_reg = kcontrol->private_value & 0xff;
1254 int right_reg = (kcontrol->private_value >> 8) & 0xff;
1255 int shift_left = (kcontrol->private_value >> 16) & 0x07;
1256 int shift_right = (kcontrol->private_value >> 19) & 0x07;
1257 int mask = (kcontrol->private_value >> 24) & 0xff;
1258 int invert = (kcontrol->private_value >> 22) & 1;
1260 unsigned char val1, val2, mask1, mask2;
1262 val1 = ucontrol->value.integer.value[0] & mask;
1263 val2 = ucontrol->value.integer.value[1] & mask;
1268 val1 <<= shift_left;
1269 val2 <<= shift_right;
1270 mask1 = mask << shift_left;
1271 mask2 = mask << shift_right;
1272 if (left_reg != right_reg) {
1274 if (snd_es1938_reg_bits(chip, left_reg, mask1, val1) != val1)
1276 if (snd_es1938_reg_bits(chip, right_reg, mask2, val2) != val2)
1279 change = (snd_es1938_reg_bits(chip, left_reg, mask1 | mask2,
1280 val1 | val2) != (val1 | val2));
1285 static snd_kcontrol_new_t snd_es1938_controls[] = {
1286 ES1938_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0),
1287 ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1),
1289 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1290 .name = "Hardware Master Playback Volume",
1291 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1292 .info = snd_es1938_info_hw_volume,
1293 .get = snd_es1938_get_hw_volume,
1296 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1297 .name = "Hardware Master Playback Switch",
1298 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1299 .info = snd_es1938_info_hw_switch,
1300 .get = snd_es1938_get_hw_switch,
1302 ES1938_SINGLE("Hardware Volume Split", 0, 0x64, 7, 1, 0),
1303 ES1938_DOUBLE("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0),
1304 ES1938_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0),
1305 ES1938_DOUBLE("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0),
1306 ES1938_DOUBLE("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1307 ES1938_DOUBLE("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0),
1308 ES1938_DOUBLE("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0),
1309 ES1938_DOUBLE("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0),
1310 ES1938_SINGLE("PC Speaker Volume", 0, 0x3c, 0, 7, 0),
1311 ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
1312 ES1938_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1),
1314 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1315 .name = "Capture Source",
1316 .info = snd_es1938_info_mux,
1317 .get = snd_es1938_get_mux,
1318 .put = snd_es1938_put_mux,
1320 ES1938_DOUBLE("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1321 ES1938_DOUBLE("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0),
1322 ES1938_DOUBLE("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0),
1323 ES1938_DOUBLE("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0),
1324 ES1938_DOUBLE("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0),
1325 ES1938_DOUBLE("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0),
1326 ES1938_DOUBLE("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0),
1327 ES1938_DOUBLE("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0),
1328 ES1938_DOUBLE("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0),
1329 ES1938_DOUBLE("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0),
1330 ES1938_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0),
1332 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1333 .name = "3D Control - Switch",
1334 .info = snd_es1938_info_spatializer_enable,
1335 .get = snd_es1938_get_spatializer_enable,
1336 .put = snd_es1938_put_spatializer_enable,
1338 ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0)
1342 /* ---------------------------------------------------------------------------- */
1343 /* ---------------------------------------------------------------------------- */
1346 * initialize the chip - used by resume callback, too
1348 static void snd_es1938_chip_init(es1938_t *chip)
1351 snd_es1938_reset(chip);
1353 /* configure native mode */
1355 /* enable bus master */
1356 pci_set_master(chip->pci);
1358 /* disable legacy audio */
1359 pci_write_config_word(chip->pci, SL_PCI_LEGACYCONTROL, 0x805f);
1362 pci_write_config_word(chip->pci, SL_PCI_DDMACONTROL, chip->ddma_port | 1);
1364 /* set DMA/IRQ policy */
1365 pci_write_config_dword(chip->pci, SL_PCI_CONFIG, 0);
1367 /* enable Audio 1, Audio 2, MPU401 IRQ and HW volume IRQ*/
1368 outb(0xf0, SLIO_REG(chip, IRQCONTROL));
1371 outb(0, SLDM_REG(chip, DMACLEAR));
1379 static unsigned char saved_regs[SAVED_REG_SIZE+1] = {
1380 0x14, 0x1a, 0x1c, 0x3a, 0x3c, 0x3e, 0x36, 0x38,
1381 0x50, 0x52, 0x60, 0x61, 0x62, 0x63, 0x64, 0x68,
1382 0x69, 0x6a, 0x6b, 0x6d, 0x6e, 0x6f, 0x7c, 0x7d,
1387 static int es1938_suspend(snd_card_t *card, pm_message_t state)
1389 es1938_t *chip = card->pm_private_data;
1390 unsigned char *s, *d;
1392 snd_pcm_suspend_all(chip->pcm);
1394 /* save mixer-related registers */
1395 for (s = saved_regs, d = chip->saved_regs; *s; s++, d++)
1396 *d = snd_es1938_reg_read(chip, *s);
1398 outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */
1400 free_irq(chip->irq, (void *)chip);
1401 pci_disable_device(chip->pci);
1405 static int es1938_resume(snd_card_t *card)
1407 es1938_t *chip = card->pm_private_data;
1408 unsigned char *s, *d;
1410 pci_enable_device(chip->pci);
1411 request_irq(chip->pci->irq, snd_es1938_interrupt,
1412 SA_INTERRUPT|SA_SHIRQ, "ES1938", (void *)chip);
1413 chip->irq = chip->pci->irq;
1414 snd_es1938_chip_init(chip);
1416 /* restore mixer-related registers */
1417 for (s = saved_regs, d = chip->saved_regs; *s; s++, d++) {
1419 snd_es1938_mixer_write(chip, *s, *d);
1421 snd_es1938_write(chip, *s, *d);
1426 #endif /* CONFIG_PM */
1428 #ifdef SUPPORT_JOYSTICK
1429 static int __devinit snd_es1938_create_gameport(es1938_t *chip)
1431 struct gameport *gp;
1433 chip->gameport = gp = gameport_allocate_port();
1435 printk(KERN_ERR "es1938: cannot allocate memory for gameport\n");
1439 gameport_set_name(gp, "ES1938");
1440 gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
1441 gameport_set_dev_parent(gp, &chip->pci->dev);
1442 gp->io = chip->game_port;
1444 gameport_register_port(gp);
1449 static void snd_es1938_free_gameport(es1938_t *chip)
1451 if (chip->gameport) {
1452 gameport_unregister_port(chip->gameport);
1453 chip->gameport = NULL;
1457 static inline int snd_es1938_create_gameport(es1938_t *chip) { return -ENOSYS; }
1458 static inline void snd_es1938_free_gameport(es1938_t *chip) { }
1459 #endif /* SUPPORT_JOYSTICK */
1461 static int snd_es1938_free(es1938_t *chip)
1464 outb(0x00, SLIO_REG(chip, IRQCONTROL));
1466 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0);
1468 snd_es1938_free_gameport(chip);
1471 free_irq(chip->irq, (void *)chip);
1472 pci_release_regions(chip->pci);
1473 pci_disable_device(chip->pci);
1478 static int snd_es1938_dev_free(snd_device_t *device)
1480 es1938_t *chip = device->device_data;
1481 return snd_es1938_free(chip);
1484 static int __devinit snd_es1938_create(snd_card_t * card,
1485 struct pci_dev * pci,
1490 static snd_device_ops_t ops = {
1491 .dev_free = snd_es1938_dev_free,
1496 /* enable PCI device */
1497 if ((err = pci_enable_device(pci)) < 0)
1499 /* check, if we can restrict PCI DMA transfers to 24 bits */
1500 if (pci_set_dma_mask(pci, 0x00ffffff) < 0 ||
1501 pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) {
1502 snd_printk("architecture does not support 24bit PCI busmaster DMA\n");
1503 pci_disable_device(pci);
1507 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1509 pci_disable_device(pci);
1512 spin_lock_init(&chip->reg_lock);
1513 spin_lock_init(&chip->mixer_lock);
1516 if ((err = pci_request_regions(pci, "ESS Solo-1")) < 0) {
1518 pci_disable_device(pci);
1521 chip->io_port = pci_resource_start(pci, 0);
1522 chip->sb_port = pci_resource_start(pci, 1);
1523 chip->vc_port = pci_resource_start(pci, 2);
1524 chip->mpu_port = pci_resource_start(pci, 3);
1525 chip->game_port = pci_resource_start(pci, 4);
1526 if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ, "ES1938", (void *)chip)) {
1527 snd_printk("unable to grab IRQ %d\n", pci->irq);
1528 snd_es1938_free(chip);
1531 chip->irq = pci->irq;
1532 #ifdef ES1938_DDEBUG
1533 snd_printk("create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
1534 chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1537 chip->ddma_port = chip->vc_port + 0x00; /* fix from Thomas Sailer */
1539 snd_es1938_chip_init(chip);
1541 snd_card_set_pm_callback(card, es1938_suspend, es1938_resume, chip);
1543 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1544 snd_es1938_free(chip);
1548 snd_card_set_dev(card, &pci->dev);
1554 /* --------------------------------------------------------------------
1556 * -------------------------------------------------------------------- */
1557 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1559 es1938_t *chip = dev_id;
1560 unsigned char status, audiostatus;
1563 status = inb(SLIO_REG(chip, IRQCONTROL));
1565 printk("Es1938debug - interrupt status: =0x%x\n", status);
1569 if (status & 0x10) {
1571 printk("Es1938debug - AUDIO channel 1 interrupt\n");
1572 printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n", inw(SLDM_REG(chip, DMACOUNT)));
1573 printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n", inl(SLDM_REG(chip, DMAADDR)));
1574 printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n", inl(SLDM_REG(chip, DMASTATUS)));
1578 audiostatus = inb(SLSB_REG(chip, STATUS));
1579 if (chip->active & ADC1)
1580 snd_pcm_period_elapsed(chip->capture_substream);
1581 else if (chip->active & DAC1)
1582 snd_pcm_period_elapsed(chip->playback2_substream);
1586 if (status & 0x20) {
1588 printk("Es1938debug - AUDIO channel 2 interrupt\n");
1589 printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n", inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
1590 printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n", inl(SLIO_REG(chip, AUDIO2DMAADDR)));
1595 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
1596 if (chip->active & DAC2)
1597 snd_pcm_period_elapsed(chip->playback1_substream);
1600 /* Hardware volume */
1601 if (status & 0x40) {
1602 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
1604 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
1605 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
1607 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_switch->id);
1608 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_volume->id);
1611 snd_es1938_mixer_write(chip, 0x66, 0x00);
1615 if (status & 0x80) {
1616 // the following line is evil! It switches off MIDI interrupt handling after the first interrupt received.
1617 // replacing the last 0 by 0x40 works for ESS-Solo1, but just doing nothing works as well!
1618 // andreas@flying-snail.de
1619 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
1622 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
1625 return IRQ_RETVAL(handled);
1628 #define ES1938_DMA_SIZE 64
1630 static int __devinit snd_es1938_mixer(es1938_t *chip)
1638 strcpy(card->mixername, "ESS Solo-1");
1640 for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
1641 snd_kcontrol_t *kctl;
1642 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
1645 chip->master_volume = kctl;
1646 kctl->private_free = snd_es1938_hwv_free;
1649 chip->master_switch = kctl;
1650 kctl->private_free = snd_es1938_hwv_free;
1653 chip->hw_volume = kctl;
1654 kctl->private_free = snd_es1938_hwv_free;
1657 chip->hw_switch = kctl;
1658 kctl->private_free = snd_es1938_hwv_free;
1661 if ((err = snd_ctl_add(card, kctl)) < 0)
1668 static int __devinit snd_es1938_probe(struct pci_dev *pci,
1669 const struct pci_device_id *pci_id)
1677 if (dev >= SNDRV_CARDS)
1684 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
1687 for (idx = 0; idx < 5; idx++) {
1688 if (pci_resource_start(pci, idx) == 0 ||
1689 !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) {
1690 snd_card_free(card);
1694 if ((err = snd_es1938_create(card, pci, &chip)) < 0) {
1695 snd_card_free(card);
1699 strcpy(card->driver, "ES1938");
1700 strcpy(card->shortname, "ESS ES1938 (Solo-1)");
1701 sprintf(card->longname, "%s rev %i, irq %i",
1706 if ((err = snd_es1938_new_pcm(chip, 0)) < 0) {
1707 snd_card_free(card);
1710 if ((err = snd_es1938_mixer(chip)) < 0) {
1711 snd_card_free(card);
1714 if (snd_opl3_create(card,
1715 SLSB_REG(chip, FMLOWADDR),
1716 SLSB_REG(chip, FMHIGHADDR),
1717 OPL3_HW_OPL3, 1, &opl3) < 0) {
1718 printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n",
1719 SLSB_REG(chip, FMLOWADDR));
1721 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
1722 snd_card_free(card);
1725 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
1726 snd_card_free(card);
1730 if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
1731 chip->mpu_port, 1, chip->irq, 0, &chip->rmidi) < 0) {
1732 printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
1734 // this line is vital for MIDI interrupt handling on ess-solo1
1735 // andreas@flying-snail.de
1736 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);
1739 snd_es1938_create_gameport(chip);
1741 if ((err = snd_card_register(card)) < 0) {
1742 snd_card_free(card);
1746 pci_set_drvdata(pci, card);
1751 static void __devexit snd_es1938_remove(struct pci_dev *pci)
1753 snd_card_free(pci_get_drvdata(pci));
1754 pci_set_drvdata(pci, NULL);
1757 static struct pci_driver driver = {
1758 .name = "ESS ES1938 (Solo-1)",
1759 .owner = THIS_MODULE,
1760 .id_table = snd_es1938_ids,
1761 .probe = snd_es1938_probe,
1762 .remove = __devexit_p(snd_es1938_remove),
1763 SND_PCI_PM_CALLBACKS
1766 static int __init alsa_card_es1938_init(void)
1768 return pci_register_driver(&driver);
1771 static void __exit alsa_card_es1938_exit(void)
1773 pci_unregister_driver(&driver);
1776 module_init(alsa_card_es1938_init)
1777 module_exit(alsa_card_es1938_exit)