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 #ifndef PCI_VENDOR_ID_ESS
76 #define PCI_VENDOR_ID_ESS 0x125d
78 #ifndef PCI_DEVICE_ID_ESS_ES1938
79 #define PCI_DEVICE_ID_ESS_ES1938 0x1969
82 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
83 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
84 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
87 module_param_array(index, int, boot_devs, 0444);
88 MODULE_PARM_DESC(index, "Index value for ESS Solo-1 soundcard.");
89 module_param_array(id, charp, boot_devs, 0444);
90 MODULE_PARM_DESC(id, "ID string for ESS Solo-1 soundcard.");
91 module_param_array(enable, bool, boot_devs, 0444);
92 MODULE_PARM_DESC(enable, "Enable ESS Solo-1 soundcard.");
94 #define SLIO_REG(chip, x) ((chip)->io_port + ESSIO_REG_##x)
96 #define SLDM_REG(chip, x) ((chip)->ddma_port + ESSDM_REG_##x)
98 #define SLSB_REG(chip, x) ((chip)->sb_port + ESSSB_REG_##x)
100 #define SL_PCI_LEGACYCONTROL 0x40
101 #define SL_PCI_CONFIG 0x50
102 #define SL_PCI_DDMACONTROL 0x60
104 #define ESSIO_REG_AUDIO2DMAADDR 0
105 #define ESSIO_REG_AUDIO2DMACOUNT 4
106 #define ESSIO_REG_AUDIO2MODE 6
107 #define ESSIO_REG_IRQCONTROL 7
109 #define ESSDM_REG_DMAADDR 0x00
110 #define ESSDM_REG_DMACOUNT 0x04
111 #define ESSDM_REG_DMACOMMAND 0x08
112 #define ESSDM_REG_DMASTATUS 0x08
113 #define ESSDM_REG_DMAMODE 0x0b
114 #define ESSDM_REG_DMACLEAR 0x0d
115 #define ESSDM_REG_DMAMASK 0x0f
117 #define ESSSB_REG_FMLOWADDR 0x00
118 #define ESSSB_REG_FMHIGHADDR 0x02
119 #define ESSSB_REG_MIXERADDR 0x04
120 #define ESSSB_REG_MIXERDATA 0x05
122 #define ESSSB_IREG_AUDIO1 0x14
123 #define ESSSB_IREG_MICMIX 0x1a
124 #define ESSSB_IREG_RECSRC 0x1c
125 #define ESSSB_IREG_MASTER 0x32
126 #define ESSSB_IREG_FM 0x36
127 #define ESSSB_IREG_AUXACD 0x38
128 #define ESSSB_IREG_AUXB 0x3a
129 #define ESSSB_IREG_PCSPEAKER 0x3c
130 #define ESSSB_IREG_LINE 0x3e
131 #define ESSSB_IREG_SPATCONTROL 0x50
132 #define ESSSB_IREG_SPATLEVEL 0x52
133 #define ESSSB_IREG_MASTER_LEFT 0x60
134 #define ESSSB_IREG_MASTER_RIGHT 0x62
135 #define ESSSB_IREG_MPU401CONTROL 0x64
136 #define ESSSB_IREG_MICMIXRECORD 0x68
137 #define ESSSB_IREG_AUDIO2RECORD 0x69
138 #define ESSSB_IREG_AUXACDRECORD 0x6a
139 #define ESSSB_IREG_FMRECORD 0x6b
140 #define ESSSB_IREG_AUXBRECORD 0x6c
141 #define ESSSB_IREG_MONO 0x6d
142 #define ESSSB_IREG_LINERECORD 0x6e
143 #define ESSSB_IREG_MONORECORD 0x6f
144 #define ESSSB_IREG_AUDIO2SAMPLE 0x70
145 #define ESSSB_IREG_AUDIO2MODE 0x71
146 #define ESSSB_IREG_AUDIO2FILTER 0x72
147 #define ESSSB_IREG_AUDIO2TCOUNTL 0x74
148 #define ESSSB_IREG_AUDIO2TCOUNTH 0x76
149 #define ESSSB_IREG_AUDIO2CONTROL1 0x78
150 #define ESSSB_IREG_AUDIO2CONTROL2 0x7a
151 #define ESSSB_IREG_AUDIO2 0x7c
153 #define ESSSB_REG_RESET 0x06
155 #define ESSSB_REG_READDATA 0x0a
156 #define ESSSB_REG_WRITEDATA 0x0c
157 #define ESSSB_REG_READSTATUS 0x0c
159 #define ESSSB_REG_STATUS 0x0e
161 #define ESS_CMD_EXTSAMPLERATE 0xa1
162 #define ESS_CMD_FILTERDIV 0xa2
163 #define ESS_CMD_DMACNTRELOADL 0xa4
164 #define ESS_CMD_DMACNTRELOADH 0xa5
165 #define ESS_CMD_ANALOGCONTROL 0xa8
166 #define ESS_CMD_IRQCONTROL 0xb1
167 #define ESS_CMD_DRQCONTROL 0xb2
168 #define ESS_CMD_RECLEVEL 0xb4
169 #define ESS_CMD_SETFORMAT 0xb6
170 #define ESS_CMD_SETFORMAT2 0xb7
171 #define ESS_CMD_DMACONTROL 0xb8
172 #define ESS_CMD_DMATYPE 0xb9
173 #define ESS_CMD_OFFSETLEFT 0xba
174 #define ESS_CMD_OFFSETRIGHT 0xbb
175 #define ESS_CMD_READREG 0xc0
176 #define ESS_CMD_ENABLEEXT 0xc6
177 #define ESS_CMD_PAUSEDMA 0xd0
178 #define ESS_CMD_ENABLEAUDIO1 0xd1
179 #define ESS_CMD_STOPAUDIO1 0xd3
180 #define ESS_CMD_AUDIO1STATUS 0xd8
181 #define ESS_CMD_CONTDMA 0xd4
182 #define ESS_CMD_TESTIRQ 0xf2
184 #define ESS_RECSRC_MIC 0
185 #define ESS_RECSRC_AUXACD 2
186 #define ESS_RECSRC_AUXB 5
187 #define ESS_RECSRC_LINE 6
188 #define ESS_RECSRC_NONE 7
198 typedef struct _snd_es1938 es1938_t;
200 #define SAVED_REG_SIZE 32 /* max. number of registers to save */
205 unsigned long io_port;
206 unsigned long sb_port;
207 unsigned long vc_port;
208 unsigned long mpu_port;
209 unsigned long game_port;
210 unsigned long ddma_port;
212 unsigned char irqmask;
213 unsigned char revision;
215 snd_kcontrol_t *hw_volume;
216 snd_kcontrol_t *hw_switch;
217 snd_kcontrol_t *master_volume;
218 snd_kcontrol_t *master_switch;
223 snd_pcm_substream_t *capture_substream;
224 snd_pcm_substream_t *playback1_substream;
225 snd_pcm_substream_t *playback2_substream;
227 snd_rawmidi_t *rmidi;
229 unsigned int dma1_size;
230 unsigned int dma2_size;
231 unsigned int dma1_start;
232 unsigned int dma2_start;
233 unsigned int dma1_shift;
234 unsigned int dma2_shift;
238 spinlock_t mixer_lock;
239 snd_info_entry_t *proc_entry;
241 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
242 struct gameport gameport;
245 unsigned char saved_regs[SAVED_REG_SIZE];
249 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs);
251 static struct pci_device_id snd_es1938_ids[] = {
252 { 0x125d, 0x1969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* Solo-1 */
256 MODULE_DEVICE_TABLE(pci, snd_es1938_ids);
258 #define RESET_LOOP_TIMEOUT 0x10000
259 #define WRITE_LOOP_TIMEOUT 0x10000
260 #define GET_LOOP_TIMEOUT 0x01000
263 /* -----------------------------------------------------------------
264 * Write to a mixer register
265 * -----------------------------------------------------------------*/
266 static void snd_es1938_mixer_write(es1938_t *chip, unsigned char reg, unsigned char val)
269 spin_lock_irqsave(&chip->mixer_lock, flags);
270 outb(reg, SLSB_REG(chip, MIXERADDR));
271 outb(val, SLSB_REG(chip, MIXERDATA));
272 spin_unlock_irqrestore(&chip->mixer_lock, flags);
274 snd_printk("Mixer reg %02x set to %02x\n", reg, val);
278 /* -----------------------------------------------------------------
279 * Read from a mixer register
280 * -----------------------------------------------------------------*/
281 static int snd_es1938_mixer_read(es1938_t *chip, unsigned char reg)
285 spin_lock_irqsave(&chip->mixer_lock, flags);
286 outb(reg, SLSB_REG(chip, MIXERADDR));
287 data = inb(SLSB_REG(chip, MIXERDATA));
288 spin_unlock_irqrestore(&chip->mixer_lock, flags);
290 snd_printk("Mixer reg %02x now is %02x\n", reg, data);
295 /* -----------------------------------------------------------------
296 * Write to some bits of a mixer register (return old value)
297 * -----------------------------------------------------------------*/
298 static int snd_es1938_mixer_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val)
301 unsigned char old, new, oval;
302 spin_lock_irqsave(&chip->mixer_lock, flags);
303 outb(reg, SLSB_REG(chip, MIXERADDR));
304 old = inb(SLSB_REG(chip, MIXERDATA));
307 new = (old & ~mask) | (val & mask);
308 outb(new, SLSB_REG(chip, MIXERDATA));
310 snd_printk("Mixer reg %02x was %02x, set to %02x\n", reg, old, new);
313 spin_unlock_irqrestore(&chip->mixer_lock, flags);
317 /* -----------------------------------------------------------------
318 * Write command to Controller Registers
319 * -----------------------------------------------------------------*/
320 static void snd_es1938_write_cmd(es1938_t *chip, unsigned char cmd)
324 for (i = 0; i < WRITE_LOOP_TIMEOUT; i++) {
325 if (!(v = inb(SLSB_REG(chip, READSTATUS)) & 0x80)) {
326 outb(cmd, SLSB_REG(chip, WRITEDATA));
330 printk("snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v);
333 /* -----------------------------------------------------------------
334 * Read the Read Data Buffer
335 * -----------------------------------------------------------------*/
336 static int snd_es1938_get_byte(es1938_t *chip)
340 for (i = GET_LOOP_TIMEOUT; i; i--)
341 if ((v = inb(SLSB_REG(chip, STATUS))) & 0x80)
342 return inb(SLSB_REG(chip, READDATA));
343 snd_printk("get_byte timeout: status 0x02%x\n", v);
347 /* -----------------------------------------------------------------
348 * Write value cmd register
349 * -----------------------------------------------------------------*/
350 static void snd_es1938_write(es1938_t *chip, unsigned char reg, unsigned char val)
353 spin_lock_irqsave(&chip->reg_lock, flags);
354 snd_es1938_write_cmd(chip, reg);
355 snd_es1938_write_cmd(chip, val);
356 spin_unlock_irqrestore(&chip->reg_lock, flags);
358 snd_printk("Reg %02x set to %02x\n", reg, val);
362 /* -----------------------------------------------------------------
363 * Read data from cmd register and return it
364 * -----------------------------------------------------------------*/
365 static unsigned char snd_es1938_read(es1938_t *chip, unsigned char reg)
369 spin_lock_irqsave(&chip->reg_lock, flags);
370 snd_es1938_write_cmd(chip, ESS_CMD_READREG);
371 snd_es1938_write_cmd(chip, reg);
372 val = snd_es1938_get_byte(chip);
373 spin_unlock_irqrestore(&chip->reg_lock, flags);
375 snd_printk("Reg %02x now is %02x\n", reg, val);
380 /* -----------------------------------------------------------------
381 * Write data to cmd register and return old value
382 * -----------------------------------------------------------------*/
383 static int snd_es1938_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val)
386 unsigned char old, new, oval;
387 spin_lock_irqsave(&chip->reg_lock, flags);
388 snd_es1938_write_cmd(chip, ESS_CMD_READREG);
389 snd_es1938_write_cmd(chip, reg);
390 old = snd_es1938_get_byte(chip);
393 snd_es1938_write_cmd(chip, reg);
394 new = (old & ~mask) | (val & mask);
395 snd_es1938_write_cmd(chip, new);
397 snd_printk("Reg %02x was %02x, set to %02x\n", reg, old, new);
400 spin_unlock_irqrestore(&chip->reg_lock, flags);
404 /* --------------------------------------------------------------------
406 * --------------------------------------------------------------------*/
407 static void snd_es1938_reset(es1938_t *chip)
411 outb(3, SLSB_REG(chip, RESET));
412 inb(SLSB_REG(chip, RESET));
413 outb(0, SLSB_REG(chip, RESET));
414 for (i = 0; i < RESET_LOOP_TIMEOUT; i++) {
415 if (inb(SLSB_REG(chip, STATUS)) & 0x80) {
416 if (inb(SLSB_REG(chip, READDATA)) == 0xaa)
420 snd_printk("ESS Solo-1 reset failed\n");
423 snd_es1938_write_cmd(chip, ESS_CMD_ENABLEEXT);
425 /* Demand transfer DMA: 4 bytes per DMA request */
426 snd_es1938_write(chip, ESS_CMD_DMATYPE, 2);
428 /* Change behaviour of register A1
430 2nd channel DAC asynchronous */
431 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2MODE, 0x32);
432 /* enable/select DMA channel and IRQ channel */
433 snd_es1938_bits(chip, ESS_CMD_IRQCONTROL, 0xf0, 0x50);
434 snd_es1938_bits(chip, ESS_CMD_DRQCONTROL, 0xf0, 0x50);
435 snd_es1938_write_cmd(chip, ESS_CMD_ENABLEAUDIO1);
436 /* Set spatializer parameters to recommended values */
437 snd_es1938_mixer_write(chip, 0x54, 0x8f);
438 snd_es1938_mixer_write(chip, 0x56, 0x95);
439 snd_es1938_mixer_write(chip, 0x58, 0x94);
440 snd_es1938_mixer_write(chip, 0x5a, 0x80);
443 /* --------------------------------------------------------------------
445 * --------------------------------------------------------------------*/
446 static void snd_es1938_reset_fifo(es1938_t *chip)
448 outb(2, SLSB_REG(chip, RESET));
449 outb(0, SLSB_REG(chip, RESET));
452 static ratnum_t clocks[2] = {
467 static snd_pcm_hw_constraint_ratnums_t hw_constraints_clocks = {
473 static void snd_es1938_rate_set(es1938_t *chip,
474 snd_pcm_substream_t *substream,
477 unsigned int bits, div0;
478 snd_pcm_runtime_t *runtime = substream->runtime;
479 if (runtime->rate_num == clocks[0].num)
480 bits = 128 - runtime->rate_den;
482 bits = 256 - runtime->rate_den;
484 /* set filter register */
485 div0 = 256 - 7160000*20/(8*82*runtime->rate);
488 snd_es1938_mixer_write(chip, 0x70, bits);
489 snd_es1938_mixer_write(chip, 0x72, div0);
491 snd_es1938_write(chip, 0xA1, bits);
492 snd_es1938_write(chip, 0xA2, div0);
496 /* --------------------------------------------------------------------
497 * Configure Solo1 builtin DMA Controller
498 * --------------------------------------------------------------------*/
500 static void snd_es1938_playback1_setdma(es1938_t *chip)
502 outb(0x00, SLIO_REG(chip, AUDIO2MODE));
503 outl(chip->dma2_start, SLIO_REG(chip, AUDIO2DMAADDR));
504 outw(0, SLIO_REG(chip, AUDIO2DMACOUNT));
505 outw(chip->dma2_size, SLIO_REG(chip, AUDIO2DMACOUNT));
508 static void snd_es1938_playback2_setdma(es1938_t *chip)
510 /* Enable DMA controller */
511 outb(0xc4, SLDM_REG(chip, DMACOMMAND));
512 /* 1. Master reset */
513 outb(0, SLDM_REG(chip, DMACLEAR));
515 outb(1, SLDM_REG(chip, DMAMASK));
516 outb(0x18, SLDM_REG(chip, DMAMODE));
517 outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
518 outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
520 outb(0, SLDM_REG(chip, DMAMASK));
523 static void snd_es1938_capture_setdma(es1938_t *chip)
525 /* Enable DMA controller */
526 outb(0xc4, SLDM_REG(chip, DMACOMMAND));
527 /* 1. Master reset */
528 outb(0, SLDM_REG(chip, DMACLEAR));
530 outb(1, SLDM_REG(chip, DMAMASK));
531 outb(0x14, SLDM_REG(chip, DMAMODE));
532 outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
533 outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
535 outb(0, SLDM_REG(chip, DMAMASK));
538 /* ----------------------------------------------------------------------
543 static int snd_es1938_capture_trigger(snd_pcm_substream_t * substream,
546 es1938_t *chip = snd_pcm_substream_chip(substream);
549 case SNDRV_PCM_TRIGGER_START:
551 chip->active |= ADC1;
553 case SNDRV_PCM_TRIGGER_STOP:
555 chip->active &= ~ADC1;
560 snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
564 static int snd_es1938_playback1_trigger(snd_pcm_substream_t * substream,
567 es1938_t *chip = snd_pcm_substream_chip(substream);
569 case SNDRV_PCM_TRIGGER_START:
570 /* According to the documentation this should be:
571 0x13 but that value may randomly swap stereo channels */
572 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x92);
574 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x93);
575 /* This two stage init gives the FIFO -> DAC connection time to
576 * settle before first data from DMA flows in. This should ensure
577 * no swapping of stereo channels. Report a bug if otherwise :-) */
578 outb(0x0a, SLIO_REG(chip, AUDIO2MODE));
579 chip->active |= DAC2;
581 case SNDRV_PCM_TRIGGER_STOP:
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:
600 chip->active |= DAC1;
602 case SNDRV_PCM_TRIGGER_STOP:
604 chip->active &= ~DAC1;
609 snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
613 static int snd_es1938_playback_trigger(snd_pcm_substream_t *substream,
616 switch (substream->number) {
618 return snd_es1938_playback1_trigger(substream, cmd);
620 return snd_es1938_playback2_trigger(substream, cmd);
626 /* --------------------------------------------------------------------
627 * First channel for Extended Mode Audio 1 ADC Operation
628 * --------------------------------------------------------------------*/
629 static int snd_es1938_capture_prepare(snd_pcm_substream_t * substream)
631 es1938_t *chip = snd_pcm_substream_chip(substream);
632 snd_pcm_runtime_t *runtime = substream->runtime;
634 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
635 unsigned int count = snd_pcm_lib_period_bytes(substream);
637 chip->dma1_size = size;
638 chip->dma1_start = runtime->dma_addr;
640 mono = (runtime->channels > 1) ? 0 : 1;
641 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
642 u = snd_pcm_format_unsigned(runtime->format);
644 chip->dma1_shift = 2 - mono - is8;
646 snd_es1938_reset_fifo(chip);
649 snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
651 /* set clock and counters */
652 snd_es1938_rate_set(chip, substream, ADC1);
654 count = 0x10000 - count;
655 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
656 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
658 /* initialize and configure ADC */
659 snd_es1938_write(chip, ESS_CMD_SETFORMAT2, u ? 0x51 : 0x71);
660 snd_es1938_write(chip, ESS_CMD_SETFORMAT2, 0x90 |
662 (is8 ? 0x00 : 0x04) |
663 (mono ? 0x40 : 0x08));
665 // snd_es1938_reset_fifo(chip);
667 /* 11. configure system interrupt controller and DMA controller */
668 snd_es1938_capture_setdma(chip);
674 /* ------------------------------------------------------------------------------
675 * Second Audio channel DAC Operation
676 * ------------------------------------------------------------------------------*/
677 static int snd_es1938_playback1_prepare(snd_pcm_substream_t * substream)
679 es1938_t *chip = snd_pcm_substream_chip(substream);
680 snd_pcm_runtime_t *runtime = substream->runtime;
682 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
683 unsigned int count = snd_pcm_lib_period_bytes(substream);
685 chip->dma2_size = size;
686 chip->dma2_start = runtime->dma_addr;
688 mono = (runtime->channels > 1) ? 0 : 1;
689 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
690 u = snd_pcm_format_unsigned(runtime->format);
692 chip->dma2_shift = 2 - mono - is8;
694 snd_es1938_reset_fifo(chip);
696 /* set clock and counters */
697 snd_es1938_rate_set(chip, substream, DAC2);
700 count = 0x10000 - count;
701 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTL, count & 0xff);
702 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTH, count >> 8);
704 /* initialize and configure Audio 2 DAC */
705 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) | (mono ? 0 : 2) | (is8 ? 0 : 1));
708 snd_es1938_playback1_setdma(chip);
713 static int snd_es1938_playback2_prepare(snd_pcm_substream_t * substream)
715 es1938_t *chip = snd_pcm_substream_chip(substream);
716 snd_pcm_runtime_t *runtime = substream->runtime;
718 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
719 unsigned int count = snd_pcm_lib_period_bytes(substream);
721 chip->dma1_size = size;
722 chip->dma1_start = runtime->dma_addr;
724 mono = (runtime->channels > 1) ? 0 : 1;
725 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
726 u = snd_pcm_format_unsigned(runtime->format);
728 chip->dma1_shift = 2 - mono - is8;
730 count = 0x10000 - count;
733 snd_es1938_reset_fifo(chip);
735 snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
737 /* set clock and counters */
738 snd_es1938_rate_set(chip, substream, DAC1);
739 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
740 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
742 /* initialized and configure DAC */
743 snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x80 : 0x00);
744 snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x51 : 0x71);
745 snd_es1938_write(chip, ESS_CMD_SETFORMAT2,
746 0x90 | (mono ? 0x40 : 0x08) |
747 (is8 ? 0x00 : 0x04) | (u ? 0x00 : 0x20));
750 snd_es1938_playback2_setdma(chip);
755 static int snd_es1938_playback_prepare(snd_pcm_substream_t *substream)
757 switch (substream->number) {
759 return snd_es1938_playback1_prepare(substream);
761 return snd_es1938_playback2_prepare(substream);
767 static snd_pcm_uframes_t snd_es1938_capture_pointer(snd_pcm_substream_t * substream)
769 es1938_t *chip = snd_pcm_substream_chip(substream);
773 /* This stuff is *needed*, don't ask why - AB */
774 old = inw(SLDM_REG(chip, DMACOUNT));
775 while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
777 ptr = chip->dma1_size - 1 - new;
779 ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start;
781 return ptr >> chip->dma1_shift;
784 static snd_pcm_uframes_t snd_es1938_playback1_pointer(snd_pcm_substream_t * substream)
786 es1938_t *chip = snd_pcm_substream_chip(substream);
789 ptr = chip->dma2_size - inw(SLIO_REG(chip, AUDIO2DMACOUNT));
791 ptr = inl(SLIO_REG(chip, AUDIO2DMAADDR)) - chip->dma2_start;
793 return ptr >> chip->dma2_shift;
796 static snd_pcm_uframes_t snd_es1938_playback2_pointer(snd_pcm_substream_t * substream)
798 es1938_t *chip = snd_pcm_substream_chip(substream);
802 /* This stuff is *needed*, don't ask why - AB */
803 old = inw(SLDM_REG(chip, DMACOUNT));
804 while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
806 ptr = chip->dma1_size - 1 - new;
808 ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start;
810 return ptr >> chip->dma1_shift;
813 static snd_pcm_uframes_t snd_es1938_playback_pointer(snd_pcm_substream_t *substream)
815 switch (substream->number) {
817 return snd_es1938_playback1_pointer(substream);
819 return snd_es1938_playback2_pointer(substream);
825 static int snd_es1938_capture_copy(snd_pcm_substream_t *substream,
827 snd_pcm_uframes_t pos,
829 snd_pcm_uframes_t count)
831 snd_pcm_runtime_t *runtime = substream->runtime;
832 es1938_t *chip = snd_pcm_substream_chip(substream);
833 pos <<= chip->dma1_shift;
834 count <<= chip->dma1_shift;
835 snd_assert(pos + count <= chip->dma1_size, return -EINVAL);
836 if (pos + count < chip->dma1_size) {
837 if (copy_to_user(dst, runtime->dma_area + pos + 1, count))
840 if (copy_to_user(dst, runtime->dma_area + pos + 1, count - 1))
842 if (put_user(runtime->dma_area[0], ((unsigned char __user *)dst) + count - 1))
851 static int snd_es1938_pcm_hw_params(snd_pcm_substream_t *substream,
852 snd_pcm_hw_params_t * hw_params)
857 if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
862 static int snd_es1938_pcm_hw_free(snd_pcm_substream_t *substream)
864 return snd_pcm_lib_free_pages(substream);
867 /* ----------------------------------------------------------------------
868 * Audio1 Capture (ADC)
869 * ----------------------------------------------------------------------*/
870 static snd_pcm_hardware_t snd_es1938_capture =
872 .info = (SNDRV_PCM_INFO_INTERLEAVED |
873 SNDRV_PCM_INFO_BLOCK_TRANSFER),
874 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE,
875 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
880 .buffer_bytes_max = 0x8000, /* DMA controller screws on higher values */
881 .period_bytes_min = 64,
882 .period_bytes_max = 0x8000,
888 /* -----------------------------------------------------------------------
889 * Audio2 Playback (DAC)
890 * -----------------------------------------------------------------------*/
891 static snd_pcm_hardware_t snd_es1938_playback =
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 | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE,
897 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
902 .buffer_bytes_max = 0x8000, /* DMA controller screws on higher values */
903 .period_bytes_min = 64,
904 .period_bytes_max = 0x8000,
910 static int snd_es1938_capture_open(snd_pcm_substream_t * substream)
912 es1938_t *chip = snd_pcm_substream_chip(substream);
913 snd_pcm_runtime_t *runtime = substream->runtime;
915 if (chip->playback2_substream)
917 chip->capture_substream = substream;
918 runtime->hw = snd_es1938_capture;
919 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
920 &hw_constraints_clocks);
921 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
925 static int snd_es1938_playback_open(snd_pcm_substream_t * substream)
927 es1938_t *chip = snd_pcm_substream_chip(substream);
928 snd_pcm_runtime_t *runtime = substream->runtime;
930 switch (substream->number) {
932 chip->playback1_substream = substream;
935 if (chip->capture_substream)
937 chip->playback2_substream = substream;
943 runtime->hw = snd_es1938_playback;
944 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
945 &hw_constraints_clocks);
946 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
950 static int snd_es1938_capture_close(snd_pcm_substream_t * substream)
952 es1938_t *chip = snd_pcm_substream_chip(substream);
954 chip->capture_substream = NULL;
958 static int snd_es1938_playback_close(snd_pcm_substream_t * substream)
960 es1938_t *chip = snd_pcm_substream_chip(substream);
962 switch (substream->number) {
964 chip->playback1_substream = NULL;
967 chip->playback2_substream = NULL;
976 static snd_pcm_ops_t snd_es1938_playback_ops = {
977 .open = snd_es1938_playback_open,
978 .close = snd_es1938_playback_close,
979 .ioctl = snd_pcm_lib_ioctl,
980 .hw_params = snd_es1938_pcm_hw_params,
981 .hw_free = snd_es1938_pcm_hw_free,
982 .prepare = snd_es1938_playback_prepare,
983 .trigger = snd_es1938_playback_trigger,
984 .pointer = snd_es1938_playback_pointer,
987 static snd_pcm_ops_t snd_es1938_capture_ops = {
988 .open = snd_es1938_capture_open,
989 .close = snd_es1938_capture_close,
990 .ioctl = snd_pcm_lib_ioctl,
991 .hw_params = snd_es1938_pcm_hw_params,
992 .hw_free = snd_es1938_pcm_hw_free,
993 .prepare = snd_es1938_capture_prepare,
994 .trigger = snd_es1938_capture_trigger,
995 .pointer = snd_es1938_capture_pointer,
996 .copy = snd_es1938_capture_copy,
999 static void snd_es1938_free_pcm(snd_pcm_t *pcm)
1001 snd_pcm_lib_preallocate_free_for_all(pcm);
1004 static int __devinit snd_es1938_new_pcm(es1938_t *chip, int device)
1009 if ((err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm)) < 0)
1011 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1938_playback_ops);
1012 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1938_capture_ops);
1014 pcm->private_data = chip;
1015 pcm->private_free = snd_es1938_free_pcm;
1016 pcm->info_flags = 0;
1017 strcpy(pcm->name, "ESS Solo-1");
1019 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1020 snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
1026 /* -------------------------------------------------------------------
1028 * *** Mixer part ***
1031 static int snd_es1938_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1033 static char *texts[8] = {
1034 "Mic", "Mic Master", "CD", "AOUT",
1035 "Mic1", "Mix", "Line", "Master"
1038 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1040 uinfo->value.enumerated.items = 8;
1041 if (uinfo->value.enumerated.item > 7)
1042 uinfo->value.enumerated.item = 7;
1043 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1047 static int snd_es1938_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1049 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1050 ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07;
1054 static int snd_es1938_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1056 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1057 unsigned char val = ucontrol->value.enumerated.item[0];
1061 return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val;
1064 static int snd_es1938_info_spatializer_enable(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1066 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1068 uinfo->value.integer.min = 0;
1069 uinfo->value.integer.max = 1;
1073 static int snd_es1938_get_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1075 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1076 unsigned char val = snd_es1938_mixer_read(chip, 0x50);
1077 ucontrol->value.integer.value[0] = !!(val & 8);
1081 static int snd_es1938_put_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1083 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1084 unsigned char oval, nval;
1086 nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04;
1087 oval = snd_es1938_mixer_read(chip, 0x50) & 0x0c;
1088 change = nval != oval;
1090 snd_es1938_mixer_write(chip, 0x50, nval & ~0x04);
1091 snd_es1938_mixer_write(chip, 0x50, nval);
1096 static int snd_es1938_info_hw_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1098 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1100 uinfo->value.integer.min = 0;
1101 uinfo->value.integer.max = 63;
1105 static int snd_es1938_get_hw_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1107 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1108 ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f;
1109 ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f;
1113 static int snd_es1938_info_hw_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1115 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1117 uinfo->value.integer.min = 0;
1118 uinfo->value.integer.max = 1;
1122 static int snd_es1938_get_hw_switch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1124 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1125 ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40);
1126 ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40);
1130 static void snd_es1938_hwv_free(snd_kcontrol_t *kcontrol)
1132 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1133 chip->master_volume = NULL;
1134 chip->master_switch = NULL;
1135 chip->hw_volume = NULL;
1136 chip->hw_switch = NULL;
1139 static int snd_es1938_reg_bits(es1938_t *chip, unsigned char reg,
1140 unsigned char mask, unsigned char val)
1143 return snd_es1938_mixer_bits(chip, reg, mask, val);
1145 return snd_es1938_bits(chip, reg, mask, val);
1148 static int snd_es1938_reg_read(es1938_t *chip, unsigned char reg)
1151 return snd_es1938_mixer_read(chip, reg);
1153 return snd_es1938_read(chip, reg);
1156 #define ES1938_SINGLE(xname, xindex, reg, shift, mask, invert) \
1157 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1158 .info = snd_es1938_info_single, \
1159 .get = snd_es1938_get_single, .put = snd_es1938_put_single, \
1160 .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
1162 static int snd_es1938_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1164 int mask = (kcontrol->private_value >> 16) & 0xff;
1166 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1168 uinfo->value.integer.min = 0;
1169 uinfo->value.integer.max = mask;
1173 static int snd_es1938_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1175 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1176 int reg = kcontrol->private_value & 0xff;
1177 int shift = (kcontrol->private_value >> 8) & 0xff;
1178 int mask = (kcontrol->private_value >> 16) & 0xff;
1179 int invert = (kcontrol->private_value >> 24) & 0xff;
1182 val = snd_es1938_reg_read(chip, reg);
1183 ucontrol->value.integer.value[0] = (val >> shift) & mask;
1185 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1189 static int snd_es1938_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1191 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1192 int reg = kcontrol->private_value & 0xff;
1193 int shift = (kcontrol->private_value >> 8) & 0xff;
1194 int mask = (kcontrol->private_value >> 16) & 0xff;
1195 int invert = (kcontrol->private_value >> 24) & 0xff;
1198 val = (ucontrol->value.integer.value[0] & mask);
1203 return snd_es1938_reg_bits(chip, reg, mask, val) != val;
1206 #define ES1938_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1207 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1208 .info = snd_es1938_info_double, \
1209 .get = snd_es1938_get_double, .put = snd_es1938_put_double, \
1210 .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1212 static int snd_es1938_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1214 int mask = (kcontrol->private_value >> 24) & 0xff;
1216 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1218 uinfo->value.integer.min = 0;
1219 uinfo->value.integer.max = mask;
1223 static int snd_es1938_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1225 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1226 int left_reg = kcontrol->private_value & 0xff;
1227 int right_reg = (kcontrol->private_value >> 8) & 0xff;
1228 int shift_left = (kcontrol->private_value >> 16) & 0x07;
1229 int shift_right = (kcontrol->private_value >> 19) & 0x07;
1230 int mask = (kcontrol->private_value >> 24) & 0xff;
1231 int invert = (kcontrol->private_value >> 22) & 1;
1232 unsigned char left, right;
1234 left = snd_es1938_reg_read(chip, left_reg);
1235 if (left_reg != right_reg)
1236 right = snd_es1938_reg_read(chip, right_reg);
1239 ucontrol->value.integer.value[0] = (left >> shift_left) & mask;
1240 ucontrol->value.integer.value[1] = (right >> shift_right) & mask;
1242 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1243 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
1248 static int snd_es1938_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1250 es1938_t *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;
1258 unsigned char val1, val2, mask1, mask2;
1260 val1 = ucontrol->value.integer.value[0] & mask;
1261 val2 = ucontrol->value.integer.value[1] & mask;
1266 val1 <<= shift_left;
1267 val2 <<= shift_right;
1268 mask1 = mask << shift_left;
1269 mask2 = mask << shift_right;
1270 if (left_reg != right_reg) {
1272 if (snd_es1938_reg_bits(chip, left_reg, mask1, val1) != val1)
1274 if (snd_es1938_reg_bits(chip, right_reg, mask2, val2) != val2)
1277 change = (snd_es1938_reg_bits(chip, left_reg, mask1 | mask2,
1278 val1 | val2) != (val1 | val2));
1283 static snd_kcontrol_new_t snd_es1938_controls[] = {
1284 ES1938_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0),
1285 ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1),
1287 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1288 .name = "Hardware Master Playback Volume",
1289 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1290 .info = snd_es1938_info_hw_volume,
1291 .get = snd_es1938_get_hw_volume,
1294 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1295 .name = "Hardware Master Playback Switch",
1296 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1297 .info = snd_es1938_info_hw_switch,
1298 .get = snd_es1938_get_hw_switch,
1300 ES1938_SINGLE("Hardware Volume Split", 0, 0x64, 7, 1, 0),
1301 ES1938_DOUBLE("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0),
1302 ES1938_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0),
1303 ES1938_DOUBLE("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0),
1304 ES1938_DOUBLE("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1305 ES1938_DOUBLE("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0),
1306 ES1938_DOUBLE("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0),
1307 ES1938_DOUBLE("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0),
1308 ES1938_SINGLE("PC Speaker Volume", 0, 0x3c, 0, 7, 0),
1309 ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
1310 ES1938_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1),
1312 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1313 .name = "Capture Source",
1314 .info = snd_es1938_info_mux,
1315 .get = snd_es1938_get_mux,
1316 .put = snd_es1938_put_mux,
1318 ES1938_DOUBLE("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1319 ES1938_DOUBLE("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0),
1320 ES1938_DOUBLE("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0),
1321 ES1938_DOUBLE("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0),
1322 ES1938_DOUBLE("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0),
1323 ES1938_DOUBLE("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0),
1324 ES1938_DOUBLE("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0),
1325 ES1938_DOUBLE("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0),
1326 ES1938_DOUBLE("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0),
1327 ES1938_DOUBLE("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0),
1328 ES1938_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0),
1330 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1331 .name = "3D Control - Switch",
1332 .info = snd_es1938_info_spatializer_enable,
1333 .get = snd_es1938_get_spatializer_enable,
1334 .put = snd_es1938_put_spatializer_enable,
1336 ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0)
1340 /* ---------------------------------------------------------------------------- */
1341 /* ---------------------------------------------------------------------------- */
1344 * initialize the chip - used by resume callback, too
1346 static void snd_es1938_chip_init(es1938_t *chip)
1349 snd_es1938_reset(chip);
1351 /* configure native mode */
1353 /* enable bus master */
1354 pci_set_master(chip->pci);
1356 /* disable legacy audio */
1357 pci_write_config_word(chip->pci, SL_PCI_LEGACYCONTROL, 0x805f);
1360 pci_write_config_word(chip->pci, SL_PCI_DDMACONTROL, chip->ddma_port | 1);
1362 /* set DMA/IRQ policy */
1363 pci_write_config_dword(chip->pci, SL_PCI_CONFIG, 0);
1365 /* enable Audio 1, Audio 2, MPU401 IRQ and HW volume IRQ*/
1366 outb(0xf0, SLIO_REG(chip, IRQCONTROL));
1369 outb(0, SLDM_REG(chip, DMACLEAR));
1377 static unsigned char saved_regs[SAVED_REG_SIZE+1] = {
1378 0x14, 0x1a, 0x1c, 0x3a, 0x3c, 0x3e, 0x36, 0x38,
1379 0x50, 0x52, 0x60, 0x61, 0x62, 0x63, 0x64, 0x68,
1380 0x69, 0x6a, 0x6b, 0x6d, 0x6e, 0x6f, 0x7c, 0x7d,
1385 static int es1938_suspend(snd_card_t *card, unsigned int state)
1387 es1938_t *chip = card->pm_private_data;
1388 unsigned char *s, *d;
1390 snd_pcm_suspend_all(chip->pcm);
1392 /* save mixer-related registers */
1393 for (s = saved_regs, d = chip->saved_regs; *s; s++, d++)
1394 *d = snd_es1938_reg_read(chip, *s);
1396 outb(0x00, SLIO_REG(chip, IRQCONTROL)); /* disable irqs */
1398 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1402 static int es1938_resume(snd_card_t *card, unsigned int state)
1404 es1938_t *chip = card->pm_private_data;
1405 unsigned char *s, *d;
1407 pci_enable_device(chip->pci);
1408 snd_es1938_chip_init(chip);
1410 /* restore mixer-related registers */
1411 for (s = saved_regs, d = chip->saved_regs; *s; s++, d++) {
1413 snd_es1938_mixer_write(chip, *s, *d);
1415 snd_es1938_write(chip, *s, *d);
1418 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1421 #endif /* CONFIG_PM */
1423 static int snd_es1938_free(es1938_t *chip)
1426 outb(0x00, SLIO_REG(chip, IRQCONTROL));
1428 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0);*/
1429 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
1430 if (chip->gameport.io)
1431 gameport_unregister_port(&chip->gameport);
1434 free_irq(chip->irq, (void *)chip);
1435 pci_release_regions(chip->pci);
1440 static int snd_es1938_dev_free(snd_device_t *device)
1442 es1938_t *chip = device->device_data;
1443 return snd_es1938_free(chip);
1446 static int __devinit snd_es1938_create(snd_card_t * card,
1447 struct pci_dev * pci,
1452 static snd_device_ops_t ops = {
1453 .dev_free = snd_es1938_dev_free,
1458 /* enable PCI device */
1459 if ((err = pci_enable_device(pci)) < 0)
1461 /* check, if we can restrict PCI DMA transfers to 24 bits */
1462 if (pci_set_dma_mask(pci, 0x00ffffff) < 0 ||
1463 pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) {
1464 snd_printk("architecture does not support 24bit PCI busmaster DMA\n");
1468 chip = kcalloc(1, sizeof(*chip), GFP_KERNEL);
1471 spin_lock_init(&chip->reg_lock);
1472 spin_lock_init(&chip->mixer_lock);
1475 if ((err = pci_request_regions(pci, "ESS Solo-1")) < 0) {
1479 chip->io_port = pci_resource_start(pci, 0);
1480 chip->sb_port = pci_resource_start(pci, 1);
1481 chip->vc_port = pci_resource_start(pci, 2);
1482 chip->mpu_port = pci_resource_start(pci, 3);
1483 chip->game_port = pci_resource_start(pci, 4);
1484 if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ, "ES1938", (void *)chip)) {
1485 snd_printk("unable to grab IRQ %d\n", pci->irq);
1486 snd_es1938_free(chip);
1489 chip->irq = pci->irq;
1490 #ifdef ES1938_DDEBUG
1491 snd_printk("create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
1492 chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1495 chip->ddma_port = chip->vc_port + 0x00; /* fix from Thomas Sailer */
1497 snd_es1938_chip_init(chip);
1499 snd_card_set_pm_callback(card, es1938_suspend, es1938_resume, chip);
1501 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1502 snd_es1938_free(chip);
1506 snd_card_set_dev(card, &pci->dev);
1512 /* --------------------------------------------------------------------
1514 * -------------------------------------------------------------------- */
1515 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1517 es1938_t *chip = dev_id;
1518 unsigned char status, audiostatus;
1521 status = inb(SLIO_REG(chip, IRQCONTROL));
1523 printk("Es1938debug - interrupt status: =0x%x\n", status);
1527 if (status & 0x10) {
1529 printk("Es1938debug - AUDIO channel 1 interrupt\n");
1530 printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n", inw(SLDM_REG(chip, DMACOUNT)));
1531 printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n", inl(SLDM_REG(chip, DMAADDR)));
1532 printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n", inl(SLDM_REG(chip, DMASTATUS)));
1536 audiostatus = inb(SLSB_REG(chip, STATUS));
1537 if (chip->active & ADC1)
1538 snd_pcm_period_elapsed(chip->capture_substream);
1539 else if (chip->active & DAC1)
1540 snd_pcm_period_elapsed(chip->playback2_substream);
1544 if (status & 0x20) {
1546 printk("Es1938debug - AUDIO channel 2 interrupt\n");
1547 printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n", inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
1548 printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n", inl(SLIO_REG(chip, AUDIO2DMAADDR)));
1553 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
1554 if (chip->active & DAC2)
1555 snd_pcm_period_elapsed(chip->playback1_substream);
1558 /* Hardware volume */
1559 if (status & 0x40) {
1560 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
1562 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
1563 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
1565 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_switch->id);
1566 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_volume->id);
1569 snd_es1938_mixer_write(chip, 0x66, 0x00);
1573 if (status & 0x80) {
1574 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
1577 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
1580 return IRQ_RETVAL(handled);
1583 #define ES1938_DMA_SIZE 64
1585 static int __devinit snd_es1938_mixer(es1938_t *chip)
1593 strcpy(card->mixername, "ESS Solo-1");
1595 for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
1596 snd_kcontrol_t *kctl;
1597 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
1600 chip->master_volume = kctl;
1601 kctl->private_free = snd_es1938_hwv_free;
1604 chip->master_switch = kctl;
1605 kctl->private_free = snd_es1938_hwv_free;
1608 chip->hw_volume = kctl;
1609 kctl->private_free = snd_es1938_hwv_free;
1612 chip->hw_switch = kctl;
1613 kctl->private_free = snd_es1938_hwv_free;
1616 if ((err = snd_ctl_add(card, kctl)) < 0)
1623 static int __devinit snd_es1938_probe(struct pci_dev *pci,
1624 const struct pci_device_id *pci_id)
1632 if (dev >= SNDRV_CARDS)
1639 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
1642 for (idx = 0; idx < 5; idx++) {
1643 if (pci_resource_start(pci, idx) == 0 ||
1644 !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) {
1645 snd_card_free(card);
1649 if ((err = snd_es1938_create(card, pci, &chip)) < 0) {
1650 snd_card_free(card);
1654 strcpy(card->driver, "ES1938");
1655 strcpy(card->shortname, "ESS ES1938 (Solo-1)");
1656 sprintf(card->longname, "%s rev %i, irq %i",
1661 if ((err = snd_es1938_new_pcm(chip, 0)) < 0) {
1662 snd_card_free(card);
1665 if ((err = snd_es1938_mixer(chip)) < 0) {
1666 snd_card_free(card);
1669 if (snd_opl3_create(card,
1670 SLSB_REG(chip, FMLOWADDR),
1671 SLSB_REG(chip, FMHIGHADDR),
1672 OPL3_HW_OPL3, 1, &opl3) < 0) {
1673 printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n",
1674 SLSB_REG(chip, FMLOWADDR));
1676 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
1677 snd_card_free(card);
1680 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
1681 snd_card_free(card);
1685 if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
1686 chip->mpu_port, 1, chip->irq, 0, &chip->rmidi) < 0) {
1687 printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
1689 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);*/
1691 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
1692 chip->gameport.io = chip->game_port;
1693 gameport_register_port(&chip->gameport);
1696 if ((err = snd_card_register(card)) < 0) {
1697 snd_card_free(card);
1701 pci_set_drvdata(pci, card);
1706 static void __devexit snd_es1938_remove(struct pci_dev *pci)
1708 snd_card_free(pci_get_drvdata(pci));
1709 pci_set_drvdata(pci, NULL);
1712 static struct pci_driver driver = {
1713 .name = "ESS ES1938 (Solo-1)",
1714 .id_table = snd_es1938_ids,
1715 .probe = snd_es1938_probe,
1716 .remove = __devexit_p(snd_es1938_remove),
1717 SND_PCI_PM_CALLBACKS
1720 static int __init alsa_card_es1938_init(void)
1722 return pci_module_init(&driver);
1725 static void __exit alsa_card_es1938_exit(void)
1727 pci_unregister_driver(&driver);
1730 module_init(alsa_card_es1938_init)
1731 module_exit(alsa_card_es1938_exit)