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 <sound/core.h>
57 #include <sound/control.h>
58 #include <sound/pcm.h>
59 #include <sound/opl3.h>
60 #include <sound/mpu401.h>
62 #include <sound/initval.h>
66 #define chip_t es1938_t
68 MODULE_AUTHOR("Jaromir Koutek <miri@punknet.cz>");
69 MODULE_DESCRIPTION("ESS Solo-1");
70 MODULE_LICENSE("GPL");
71 MODULE_CLASSES("{sound}");
72 MODULE_DEVICES("{{ESS,ES1938},"
75 "{TerraTec,128i PCI}}");
77 #ifndef PCI_VENDOR_ID_ESS
78 #define PCI_VENDOR_ID_ESS 0x125d
80 #ifndef PCI_DEVICE_ID_ESS_ES1938
81 #define PCI_DEVICE_ID_ESS_ES1938 0x1969
84 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
85 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
86 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */
88 MODULE_PARM(index, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
89 MODULE_PARM_DESC(index, "Index value for ESS Solo-1 soundcard.");
90 MODULE_PARM_SYNTAX(index, SNDRV_INDEX_DESC);
91 MODULE_PARM(id, "1-" __MODULE_STRING(SNDRV_CARDS) "s");
92 MODULE_PARM_DESC(id, "ID string for ESS Solo-1 soundcard.");
93 MODULE_PARM_SYNTAX(id, SNDRV_ID_DESC);
94 MODULE_PARM(enable, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
95 MODULE_PARM_DESC(enable, "Enable ESS Solo-1 soundcard.");
96 MODULE_PARM_SYNTAX(enable, SNDRV_ENABLE_DESC);
98 #define SLIO_REG(chip, x) ((chip)->io_port + ESSIO_REG_##x)
100 #define SLDM_REG(chip, x) ((chip)->ddma_port + ESSDM_REG_##x)
102 #define SLSB_REG(chip, x) ((chip)->sb_port + ESSSB_REG_##x)
104 #define SL_PCI_LEGACYCONTROL 0x40
105 #define SL_PCI_CONFIG 0x50
106 #define SL_PCI_DDMACONTROL 0x60
108 #define ESSIO_REG_AUDIO2DMAADDR 0
109 #define ESSIO_REG_AUDIO2DMACOUNT 4
110 #define ESSIO_REG_AUDIO2MODE 6
111 #define ESSIO_REG_IRQCONTROL 7
113 #define ESSDM_REG_DMAADDR 0x00
114 #define ESSDM_REG_DMACOUNT 0x04
115 #define ESSDM_REG_DMACOMMAND 0x08
116 #define ESSDM_REG_DMASTATUS 0x08
117 #define ESSDM_REG_DMAMODE 0x0b
118 #define ESSDM_REG_DMACLEAR 0x0d
119 #define ESSDM_REG_DMAMASK 0x0f
121 #define ESSSB_REG_FMLOWADDR 0x00
122 #define ESSSB_REG_FMHIGHADDR 0x02
123 #define ESSSB_REG_MIXERADDR 0x04
124 #define ESSSB_REG_MIXERDATA 0x05
126 #define ESSSB_IREG_AUDIO1 0x14
127 #define ESSSB_IREG_MICMIX 0x1a
128 #define ESSSB_IREG_RECSRC 0x1c
129 #define ESSSB_IREG_MASTER 0x32
130 #define ESSSB_IREG_FM 0x36
131 #define ESSSB_IREG_AUXACD 0x38
132 #define ESSSB_IREG_AUXB 0x3a
133 #define ESSSB_IREG_PCSPEAKER 0x3c
134 #define ESSSB_IREG_LINE 0x3e
135 #define ESSSB_IREG_SPATCONTROL 0x50
136 #define ESSSB_IREG_SPATLEVEL 0x52
137 #define ESSSB_IREG_MASTER_LEFT 0x60
138 #define ESSSB_IREG_MASTER_RIGHT 0x62
139 #define ESSSB_IREG_MPU401CONTROL 0x64
140 #define ESSSB_IREG_MICMIXRECORD 0x68
141 #define ESSSB_IREG_AUDIO2RECORD 0x69
142 #define ESSSB_IREG_AUXACDRECORD 0x6a
143 #define ESSSB_IREG_FMRECORD 0x6b
144 #define ESSSB_IREG_AUXBRECORD 0x6c
145 #define ESSSB_IREG_MONO 0x6d
146 #define ESSSB_IREG_LINERECORD 0x6e
147 #define ESSSB_IREG_MONORECORD 0x6f
148 #define ESSSB_IREG_AUDIO2SAMPLE 0x70
149 #define ESSSB_IREG_AUDIO2MODE 0x71
150 #define ESSSB_IREG_AUDIO2FILTER 0x72
151 #define ESSSB_IREG_AUDIO2TCOUNTL 0x74
152 #define ESSSB_IREG_AUDIO2TCOUNTH 0x76
153 #define ESSSB_IREG_AUDIO2CONTROL1 0x78
154 #define ESSSB_IREG_AUDIO2CONTROL2 0x7a
155 #define ESSSB_IREG_AUDIO2 0x7c
157 #define ESSSB_REG_RESET 0x06
159 #define ESSSB_REG_READDATA 0x0a
160 #define ESSSB_REG_WRITEDATA 0x0c
161 #define ESSSB_REG_READSTATUS 0x0c
163 #define ESSSB_REG_STATUS 0x0e
165 #define ESS_CMD_EXTSAMPLERATE 0xa1
166 #define ESS_CMD_FILTERDIV 0xa2
167 #define ESS_CMD_DMACNTRELOADL 0xa4
168 #define ESS_CMD_DMACNTRELOADH 0xa5
169 #define ESS_CMD_ANALOGCONTROL 0xa8
170 #define ESS_CMD_IRQCONTROL 0xb1
171 #define ESS_CMD_DRQCONTROL 0xb2
172 #define ESS_CMD_RECLEVEL 0xb4
173 #define ESS_CMD_SETFORMAT 0xb6
174 #define ESS_CMD_SETFORMAT2 0xb7
175 #define ESS_CMD_DMACONTROL 0xb8
176 #define ESS_CMD_DMATYPE 0xb9
177 #define ESS_CMD_OFFSETLEFT 0xba
178 #define ESS_CMD_OFFSETRIGHT 0xbb
179 #define ESS_CMD_READREG 0xc0
180 #define ESS_CMD_ENABLEEXT 0xc6
181 #define ESS_CMD_PAUSEDMA 0xd0
182 #define ESS_CMD_ENABLEAUDIO1 0xd1
183 #define ESS_CMD_STOPAUDIO1 0xd3
184 #define ESS_CMD_AUDIO1STATUS 0xd8
185 #define ESS_CMD_CONTDMA 0xd4
186 #define ESS_CMD_TESTIRQ 0xf2
188 #define ESS_RECSRC_MIC 0
189 #define ESS_RECSRC_AUXACD 2
190 #define ESS_RECSRC_AUXB 5
191 #define ESS_RECSRC_LINE 6
192 #define ESS_RECSRC_NONE 7
202 typedef struct _snd_es1938 es1938_t;
207 unsigned long io_port;
208 struct resource *res_io_port;
209 unsigned long sb_port;
210 struct resource *res_sb_port;
211 unsigned long vc_port;
212 struct resource *res_vc_port;
213 unsigned long mpu_port;
214 struct resource *res_mpu_port;
215 unsigned long game_port;
216 struct resource *res_game_port;
217 unsigned long ddma_port;
219 unsigned char irqmask;
220 unsigned char revision;
222 snd_kcontrol_t *hw_volume;
223 snd_kcontrol_t *hw_switch;
224 snd_kcontrol_t *master_volume;
225 snd_kcontrol_t *master_switch;
229 snd_pcm_substream_t *capture_substream;
230 snd_pcm_substream_t *playback1_substream;
231 snd_pcm_substream_t *playback2_substream;
233 snd_rawmidi_t *rmidi;
235 unsigned int dma1_size;
236 unsigned int dma2_size;
237 unsigned int dma1_start;
238 unsigned int dma2_start;
239 unsigned int dma1_shift;
240 unsigned int dma2_shift;
244 spinlock_t mixer_lock;
245 snd_info_entry_t *proc_entry;
247 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
248 struct gameport gameport;
252 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs);
254 static struct pci_device_id snd_es1938_ids[] = {
255 { 0x125d, 0x1969, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* Solo-1 */
259 MODULE_DEVICE_TABLE(pci, snd_es1938_ids);
261 #define RESET_LOOP_TIMEOUT 0x10000
262 #define WRITE_LOOP_TIMEOUT 0x10000
263 #define GET_LOOP_TIMEOUT 0x01000
266 /* -----------------------------------------------------------------
267 * Write to a mixer register
268 * -----------------------------------------------------------------*/
269 static void snd_es1938_mixer_write(es1938_t *chip, unsigned char reg, unsigned char val)
272 spin_lock_irqsave(&chip->mixer_lock, flags);
273 outb(reg, SLSB_REG(chip, MIXERADDR));
274 outb(val, SLSB_REG(chip, MIXERDATA));
275 spin_unlock_irqrestore(&chip->mixer_lock, flags);
277 snd_printk("Mixer reg %02x set to %02x\n", reg, val);
281 /* -----------------------------------------------------------------
282 * Read from a mixer register
283 * -----------------------------------------------------------------*/
284 static int snd_es1938_mixer_read(es1938_t *chip, unsigned char reg)
288 spin_lock_irqsave(&chip->mixer_lock, flags);
289 outb(reg, SLSB_REG(chip, MIXERADDR));
290 data = inb(SLSB_REG(chip, MIXERDATA));
291 spin_unlock_irqrestore(&chip->mixer_lock, flags);
293 snd_printk("Mixer reg %02x now is %02x\n", reg, data);
298 /* -----------------------------------------------------------------
299 * Write to some bits of a mixer register (return old value)
300 * -----------------------------------------------------------------*/
301 static int snd_es1938_mixer_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val)
304 unsigned char old, new, oval;
305 spin_lock_irqsave(&chip->mixer_lock, flags);
306 outb(reg, SLSB_REG(chip, MIXERADDR));
307 old = inb(SLSB_REG(chip, MIXERDATA));
310 new = (old & ~mask) | (val & mask);
311 outb(new, SLSB_REG(chip, MIXERDATA));
313 snd_printk("Mixer reg %02x was %02x, set to %02x\n", reg, old, new);
316 spin_unlock_irqrestore(&chip->mixer_lock, flags);
320 /* -----------------------------------------------------------------
321 * Write command to Controller Registers
322 * -----------------------------------------------------------------*/
323 static void snd_es1938_write_cmd(es1938_t *chip, unsigned char cmd)
327 for (i = 0; i < WRITE_LOOP_TIMEOUT; i++) {
328 if (!(v = inb(SLSB_REG(chip, READSTATUS)) & 0x80)) {
329 outb(cmd, SLSB_REG(chip, WRITEDATA));
333 printk("snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v);
336 /* -----------------------------------------------------------------
337 * Read the Read Data Buffer
338 * -----------------------------------------------------------------*/
339 static int snd_es1938_get_byte(es1938_t *chip)
343 for (i = GET_LOOP_TIMEOUT; i; i--)
344 if ((v = inb(SLSB_REG(chip, STATUS))) & 0x80)
345 return inb(SLSB_REG(chip, READDATA));
346 snd_printk("get_byte timeout: status 0x02%x\n", v);
350 /* -----------------------------------------------------------------
351 * Write value cmd register
352 * -----------------------------------------------------------------*/
353 static void snd_es1938_write(es1938_t *chip, unsigned char reg, unsigned char val)
356 spin_lock_irqsave(&chip->reg_lock, flags);
357 snd_es1938_write_cmd(chip, reg);
358 snd_es1938_write_cmd(chip, val);
359 spin_unlock_irqrestore(&chip->reg_lock, flags);
361 snd_printk("Reg %02x set to %02x\n", reg, val);
365 /* -----------------------------------------------------------------
366 * Read data from cmd register and return it
367 * -----------------------------------------------------------------*/
368 static unsigned char snd_es1938_read(es1938_t *chip, unsigned char reg)
372 spin_lock_irqsave(&chip->reg_lock, flags);
373 snd_es1938_write_cmd(chip, ESS_CMD_READREG);
374 snd_es1938_write_cmd(chip, reg);
375 val = snd_es1938_get_byte(chip);
376 spin_unlock_irqrestore(&chip->reg_lock, flags);
378 snd_printk("Reg %02x now is %02x\n", reg, val);
383 /* -----------------------------------------------------------------
384 * Write data to cmd register and return old value
385 * -----------------------------------------------------------------*/
386 static int snd_es1938_bits(es1938_t *chip, unsigned char reg, unsigned char mask, unsigned char val)
389 unsigned char old, new, oval;
390 spin_lock_irqsave(&chip->reg_lock, flags);
391 snd_es1938_write_cmd(chip, ESS_CMD_READREG);
392 snd_es1938_write_cmd(chip, reg);
393 old = snd_es1938_get_byte(chip);
396 snd_es1938_write_cmd(chip, reg);
397 new = (old & ~mask) | (val & mask);
398 snd_es1938_write_cmd(chip, new);
400 snd_printk("Reg %02x was %02x, set to %02x\n", reg, old, new);
403 spin_unlock_irqrestore(&chip->reg_lock, flags);
407 /* --------------------------------------------------------------------
409 * --------------------------------------------------------------------*/
410 static void snd_es1938_reset(es1938_t *chip)
414 outb(3, SLSB_REG(chip, RESET));
415 inb(SLSB_REG(chip, RESET));
416 outb(0, SLSB_REG(chip, RESET));
417 for (i = 0; i < RESET_LOOP_TIMEOUT; i++) {
418 if (inb(SLSB_REG(chip, STATUS)) & 0x80) {
419 if (inb(SLSB_REG(chip, READDATA)) == 0xaa)
423 snd_printk("ESS Solo-1 reset failed\n");
426 snd_es1938_write_cmd(chip, ESS_CMD_ENABLEEXT);
428 /* Demand transfer DMA: 4 bytes per DMA request */
429 snd_es1938_write(chip, ESS_CMD_DMATYPE, 2);
431 /* Change behaviour of register A1
433 2nd channel DAC asynchronous */
434 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2MODE, 0x32);
435 /* enable/select DMA channel and IRQ channel */
436 snd_es1938_bits(chip, ESS_CMD_IRQCONTROL, 0xf0, 0x50);
437 snd_es1938_bits(chip, ESS_CMD_DRQCONTROL, 0xf0, 0x50);
438 snd_es1938_write_cmd(chip, ESS_CMD_ENABLEAUDIO1);
439 /* Set spatializer parameters to recommended values */
440 snd_es1938_mixer_write(chip, 0x54, 0x8f);
441 snd_es1938_mixer_write(chip, 0x56, 0x95);
442 snd_es1938_mixer_write(chip, 0x58, 0x94);
443 snd_es1938_mixer_write(chip, 0x5a, 0x80);
446 /* --------------------------------------------------------------------
448 * --------------------------------------------------------------------*/
449 static void snd_es1938_reset_fifo(es1938_t *chip)
451 outb(2, SLSB_REG(chip, RESET));
452 outb(0, SLSB_REG(chip, RESET));
455 static ratnum_t clocks[2] = {
470 static snd_pcm_hw_constraint_ratnums_t hw_constraints_clocks = {
476 static void snd_es1938_rate_set(es1938_t *chip,
477 snd_pcm_substream_t *substream,
480 unsigned int bits, div0;
481 snd_pcm_runtime_t *runtime = substream->runtime;
482 if (runtime->rate_num == clocks[0].num)
483 bits = 128 - runtime->rate_den;
485 bits = 256 - runtime->rate_den;
487 /* set filter register */
488 div0 = 256 - 7160000*20/(8*82*runtime->rate);
491 snd_es1938_mixer_write(chip, 0x70, bits);
492 snd_es1938_mixer_write(chip, 0x72, div0);
494 snd_es1938_write(chip, 0xA1, bits);
495 snd_es1938_write(chip, 0xA2, div0);
499 /* --------------------------------------------------------------------
500 * Configure Solo1 builtin DMA Controller
501 * --------------------------------------------------------------------*/
503 static void snd_es1938_playback1_setdma(es1938_t *chip)
505 outb(0x00, SLIO_REG(chip, AUDIO2MODE));
506 outl(chip->dma2_start, SLIO_REG(chip, AUDIO2DMAADDR));
507 outw(0, SLIO_REG(chip, AUDIO2DMACOUNT));
508 outw(chip->dma2_size, SLIO_REG(chip, AUDIO2DMACOUNT));
511 static void snd_es1938_playback2_setdma(es1938_t *chip)
513 /* Enable DMA controller */
514 outb(0xc4, SLDM_REG(chip, DMACOMMAND));
515 /* 1. Master reset */
516 outb(0, SLDM_REG(chip, DMACLEAR));
518 outb(1, SLDM_REG(chip, DMAMASK));
519 outb(0x18, SLDM_REG(chip, DMAMODE));
520 outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
521 outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
523 outb(0, SLDM_REG(chip, DMAMASK));
526 static void snd_es1938_capture_setdma(es1938_t *chip)
528 /* Enable DMA controller */
529 outb(0xc4, SLDM_REG(chip, DMACOMMAND));
530 /* 1. Master reset */
531 outb(0, SLDM_REG(chip, DMACLEAR));
533 outb(1, SLDM_REG(chip, DMAMASK));
534 outb(0x14, SLDM_REG(chip, DMAMODE));
535 outl(chip->dma1_start, SLDM_REG(chip, DMAADDR));
536 outw(chip->dma1_size - 1, SLDM_REG(chip, DMACOUNT));
538 outb(0, SLDM_REG(chip, DMAMASK));
541 /* ----------------------------------------------------------------------
546 static int snd_es1938_capture_trigger(snd_pcm_substream_t * substream,
549 es1938_t *chip = snd_pcm_substream_chip(substream);
552 case SNDRV_PCM_TRIGGER_START:
554 chip->active |= ADC1;
556 case SNDRV_PCM_TRIGGER_STOP:
558 chip->active &= ~ADC1;
563 snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
567 static int snd_es1938_playback1_trigger(snd_pcm_substream_t * substream,
570 es1938_t *chip = snd_pcm_substream_chip(substream);
572 case SNDRV_PCM_TRIGGER_START:
573 /* According to the documentation this should be:
574 0x13 but that value may randomly swap stereo channels */
575 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0x93);
576 outb(0x0a, SLIO_REG(chip, AUDIO2MODE));
577 chip->active |= DAC2;
579 case SNDRV_PCM_TRIGGER_STOP:
580 outb(0, SLIO_REG(chip, AUDIO2MODE));
581 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL1, 0);
582 chip->active &= ~DAC2;
590 static int snd_es1938_playback2_trigger(snd_pcm_substream_t * substream,
593 es1938_t *chip = snd_pcm_substream_chip(substream);
596 case SNDRV_PCM_TRIGGER_START:
598 chip->active |= DAC1;
600 case SNDRV_PCM_TRIGGER_STOP:
602 chip->active &= ~DAC1;
607 snd_es1938_write(chip, ESS_CMD_DMACONTROL, val);
611 static int snd_es1938_playback_trigger(snd_pcm_substream_t *substream,
614 switch (substream->number) {
616 return snd_es1938_playback1_trigger(substream, cmd);
618 return snd_es1938_playback2_trigger(substream, cmd);
624 /* --------------------------------------------------------------------
625 * First channel for Extended Mode Audio 1 ADC Operation
626 * --------------------------------------------------------------------*/
627 static int snd_es1938_capture_prepare(snd_pcm_substream_t * substream)
629 es1938_t *chip = snd_pcm_substream_chip(substream);
630 snd_pcm_runtime_t *runtime = substream->runtime;
632 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
633 unsigned int count = snd_pcm_lib_period_bytes(substream);
635 chip->dma1_size = size;
636 chip->dma1_start = runtime->dma_addr;
638 mono = (runtime->channels > 1) ? 0 : 1;
639 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
640 u = snd_pcm_format_unsigned(runtime->format);
642 chip->dma1_shift = 2 - mono - is8;
644 snd_es1938_reset_fifo(chip);
647 snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
649 /* set clock and counters */
650 snd_es1938_rate_set(chip, substream, ADC1);
652 count = 0x10000 - count;
653 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
654 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
656 /* initialize and configure ADC */
657 snd_es1938_write(chip, ESS_CMD_SETFORMAT2, u ? 0x51 : 0x71);
658 snd_es1938_write(chip, ESS_CMD_SETFORMAT2, 0x90 |
660 (is8 ? 0x00 : 0x04) |
661 (mono ? 0x40 : 0x08));
663 // snd_es1938_reset_fifo(chip);
665 /* 11. configure system interrupt controller and DMA controller */
666 snd_es1938_capture_setdma(chip);
672 /* ------------------------------------------------------------------------------
673 * Second Audio channel DAC Operation
674 * ------------------------------------------------------------------------------*/
675 static int snd_es1938_playback1_prepare(snd_pcm_substream_t * substream)
677 es1938_t *chip = snd_pcm_substream_chip(substream);
678 snd_pcm_runtime_t *runtime = substream->runtime;
680 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
681 unsigned int count = snd_pcm_lib_period_bytes(substream);
683 chip->dma2_size = size;
684 chip->dma2_start = runtime->dma_addr;
686 mono = (runtime->channels > 1) ? 0 : 1;
687 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
688 u = snd_pcm_format_unsigned(runtime->format);
690 chip->dma2_shift = 2 - mono - is8;
692 /* set clock and counters */
693 snd_es1938_rate_set(chip, substream, DAC2);
696 count = 0x10000 - count;
697 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTL, count & 0xff);
698 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2TCOUNTH, count >> 8);
700 /* initialize and configure Audio 2 DAC */
701 snd_es1938_mixer_write(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x40 | (u ? 0 : 4) | (mono ? 0 : 2) | (is8 ? 0 : 1));
704 snd_es1938_playback1_setdma(chip);
709 static int snd_es1938_playback2_prepare(snd_pcm_substream_t * substream)
711 es1938_t *chip = snd_pcm_substream_chip(substream);
712 snd_pcm_runtime_t *runtime = substream->runtime;
714 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
715 unsigned int count = snd_pcm_lib_period_bytes(substream);
717 chip->dma1_size = size;
718 chip->dma1_start = runtime->dma_addr;
720 mono = (runtime->channels > 1) ? 0 : 1;
721 is8 = snd_pcm_format_width(runtime->format) == 16 ? 0 : 1;
722 u = snd_pcm_format_unsigned(runtime->format);
724 chip->dma1_shift = 2 - mono - is8;
726 count = 0x10000 - count;
729 snd_es1938_reset_fifo(chip);
731 snd_es1938_bits(chip, ESS_CMD_ANALOGCONTROL, 0x03, (mono ? 2 : 1));
733 /* set clock and counters */
734 snd_es1938_rate_set(chip, substream, DAC1);
735 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADL, count & 0xff);
736 snd_es1938_write(chip, ESS_CMD_DMACNTRELOADH, count >> 8);
738 /* initialized and configure DAC */
739 snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x80 : 0x00);
740 snd_es1938_write(chip, ESS_CMD_SETFORMAT, u ? 0x51 : 0x71);
741 snd_es1938_write(chip, ESS_CMD_SETFORMAT2,
742 0x90 | (mono ? 0x40 : 0x08) |
743 (is8 ? 0x00 : 0x04) | (u ? 0x00 : 0x20));
746 snd_es1938_playback2_setdma(chip);
751 static int snd_es1938_playback_prepare(snd_pcm_substream_t *substream)
753 switch (substream->number) {
755 return snd_es1938_playback1_prepare(substream);
757 return snd_es1938_playback2_prepare(substream);
763 static snd_pcm_uframes_t snd_es1938_capture_pointer(snd_pcm_substream_t * substream)
765 es1938_t *chip = snd_pcm_substream_chip(substream);
769 /* This stuff is *needed*, don't ask why - AB */
770 old = inw(SLDM_REG(chip, DMACOUNT));
771 while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
773 ptr = chip->dma1_size - 1 - new;
775 ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start;
777 return ptr >> chip->dma1_shift;
780 static snd_pcm_uframes_t snd_es1938_playback1_pointer(snd_pcm_substream_t * substream)
782 es1938_t *chip = snd_pcm_substream_chip(substream);
785 ptr = chip->dma2_size - inw(SLIO_REG(chip, AUDIO2DMACOUNT));
787 ptr = inl(SLIO_REG(chip, AUDIO2DMAADDR)) - chip->dma2_start;
789 return ptr >> chip->dma2_shift;
792 static snd_pcm_uframes_t snd_es1938_playback2_pointer(snd_pcm_substream_t * substream)
794 es1938_t *chip = snd_pcm_substream_chip(substream);
798 /* This stuff is *needed*, don't ask why - AB */
799 old = inw(SLDM_REG(chip, DMACOUNT));
800 while ((new = inw(SLDM_REG(chip, DMACOUNT))) != old)
802 ptr = chip->dma1_size - 1 - new;
804 ptr = inl(SLDM_REG(chip, DMAADDR)) - chip->dma1_start;
806 return ptr >> chip->dma1_shift;
809 static snd_pcm_uframes_t snd_es1938_playback_pointer(snd_pcm_substream_t *substream)
811 switch (substream->number) {
813 return snd_es1938_playback1_pointer(substream);
815 return snd_es1938_playback2_pointer(substream);
821 static int snd_es1938_capture_copy(snd_pcm_substream_t *substream,
823 snd_pcm_uframes_t pos,
825 snd_pcm_uframes_t count)
827 snd_pcm_runtime_t *runtime = substream->runtime;
828 es1938_t *chip = snd_pcm_substream_chip(substream);
829 pos <<= chip->dma1_shift;
830 count <<= chip->dma1_shift;
831 snd_assert(pos + count <= chip->dma1_size, return -EINVAL);
832 if (pos + count < chip->dma1_size) {
833 if (copy_to_user(dst, runtime->dma_area + pos + 1, count))
836 if (copy_to_user(dst, runtime->dma_area + pos + 1, count - 1))
838 if (put_user(runtime->dma_area[0], ((unsigned char *)dst) + count - 1))
847 static int snd_es1938_pcm_hw_params(snd_pcm_substream_t *substream,
848 snd_pcm_hw_params_t * hw_params)
853 if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
858 static int snd_es1938_pcm_hw_free(snd_pcm_substream_t *substream)
860 return snd_pcm_lib_free_pages(substream);
863 /* ----------------------------------------------------------------------
864 * Audio1 Capture (ADC)
865 * ----------------------------------------------------------------------*/
866 static snd_pcm_hardware_t snd_es1938_capture =
868 .info = (SNDRV_PCM_INFO_INTERLEAVED |
869 SNDRV_PCM_INFO_BLOCK_TRANSFER),
870 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE,
871 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
876 .buffer_bytes_max = 65536,
877 .period_bytes_min = 64,
878 .period_bytes_max = 65536,
884 /* -----------------------------------------------------------------------
885 * Audio2 Playback (DAC)
886 * -----------------------------------------------------------------------*/
887 static snd_pcm_hardware_t snd_es1938_playback =
889 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
890 SNDRV_PCM_INFO_BLOCK_TRANSFER |
891 SNDRV_PCM_INFO_MMAP_VALID),
892 .formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE,
893 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
898 .buffer_bytes_max = 65536,
899 .period_bytes_min = 64,
900 .period_bytes_max = 65536,
906 static int snd_es1938_capture_open(snd_pcm_substream_t * substream)
908 es1938_t *chip = snd_pcm_substream_chip(substream);
909 snd_pcm_runtime_t *runtime = substream->runtime;
911 if (chip->playback2_substream)
913 chip->capture_substream = substream;
914 runtime->hw = snd_es1938_capture;
915 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
916 &hw_constraints_clocks);
917 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
921 static int snd_es1938_playback_open(snd_pcm_substream_t * substream)
923 es1938_t *chip = snd_pcm_substream_chip(substream);
924 snd_pcm_runtime_t *runtime = substream->runtime;
926 switch (substream->number) {
928 chip->playback1_substream = substream;
931 if (chip->capture_substream)
933 chip->playback2_substream = substream;
939 runtime->hw = snd_es1938_playback;
940 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
941 &hw_constraints_clocks);
942 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 0, 0xff00);
946 static int snd_es1938_capture_close(snd_pcm_substream_t * substream)
948 es1938_t *chip = snd_pcm_substream_chip(substream);
950 chip->capture_substream = NULL;
954 static int snd_es1938_playback_close(snd_pcm_substream_t * substream)
956 es1938_t *chip = snd_pcm_substream_chip(substream);
958 switch (substream->number) {
960 chip->playback1_substream = NULL;
963 chip->playback2_substream = NULL;
972 static snd_pcm_ops_t snd_es1938_playback_ops = {
973 .open = snd_es1938_playback_open,
974 .close = snd_es1938_playback_close,
975 .ioctl = snd_pcm_lib_ioctl,
976 .hw_params = snd_es1938_pcm_hw_params,
977 .hw_free = snd_es1938_pcm_hw_free,
978 .prepare = snd_es1938_playback_prepare,
979 .trigger = snd_es1938_playback_trigger,
980 .pointer = snd_es1938_playback_pointer,
983 static snd_pcm_ops_t snd_es1938_capture_ops = {
984 .open = snd_es1938_capture_open,
985 .close = snd_es1938_capture_close,
986 .ioctl = snd_pcm_lib_ioctl,
987 .hw_params = snd_es1938_pcm_hw_params,
988 .hw_free = snd_es1938_pcm_hw_free,
989 .prepare = snd_es1938_capture_prepare,
990 .trigger = snd_es1938_capture_trigger,
991 .pointer = snd_es1938_capture_pointer,
992 .copy = snd_es1938_capture_copy,
995 static void snd_es1938_free_pcm(snd_pcm_t *pcm)
997 snd_pcm_lib_preallocate_free_for_all(pcm);
1000 static int __devinit snd_es1938_new_pcm(es1938_t *chip, int device, snd_pcm_t ** rpcm)
1007 if ((err = snd_pcm_new(chip->card, "es-1938-1946", device, 2, 1, &pcm)) < 0)
1009 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_es1938_playback_ops);
1010 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_es1938_capture_ops);
1012 pcm->private_data = chip;
1013 pcm->private_free = snd_es1938_free_pcm;
1014 pcm->info_flags = 0;
1015 strcpy(pcm->name, "ESS Solo-1");
1017 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1018 snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
1025 /* -------------------------------------------------------------------
1027 * *** Mixer part ***
1030 static int snd_es1938_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1032 static char *texts[8] = {
1033 "Mic", "Mic Master", "CD", "AOUT",
1034 "Mic1", "Mix", "Line", "Master"
1037 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1039 uinfo->value.enumerated.items = 8;
1040 if (uinfo->value.enumerated.item > 7)
1041 uinfo->value.enumerated.item = 7;
1042 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1046 static int snd_es1938_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1048 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1049 ucontrol->value.enumerated.item[0] = snd_es1938_mixer_read(chip, 0x1c) & 0x07;
1053 static int snd_es1938_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1055 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1056 unsigned char val = ucontrol->value.enumerated.item[0];
1060 return snd_es1938_mixer_bits(chip, 0x1c, 0x07, val) != val;
1063 static int snd_es1938_info_spatializer_enable(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1065 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1067 uinfo->value.integer.min = 0;
1068 uinfo->value.integer.max = 1;
1072 static int snd_es1938_get_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1074 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1075 unsigned char val = snd_es1938_mixer_read(chip, 0x50);
1076 ucontrol->value.integer.value[0] = !!(val & 8);
1080 static int snd_es1938_put_spatializer_enable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1082 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1083 unsigned char oval, nval;
1085 nval = ucontrol->value.integer.value[0] ? 0x0c : 0x04;
1086 oval = snd_es1938_mixer_read(chip, 0x50) & 0x0c;
1087 change = nval != oval;
1089 snd_es1938_mixer_write(chip, 0x50, nval & ~0x04);
1090 snd_es1938_mixer_write(chip, 0x50, nval);
1095 static int snd_es1938_info_hw_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1097 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1099 uinfo->value.integer.min = 0;
1100 uinfo->value.integer.max = 63;
1104 static int snd_es1938_get_hw_volume(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1106 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1107 ucontrol->value.integer.value[0] = snd_es1938_mixer_read(chip, 0x61) & 0x3f;
1108 ucontrol->value.integer.value[1] = snd_es1938_mixer_read(chip, 0x63) & 0x3f;
1112 static int snd_es1938_info_hw_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1114 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1116 uinfo->value.integer.min = 0;
1117 uinfo->value.integer.max = 1;
1121 static int snd_es1938_get_hw_switch(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1123 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1124 ucontrol->value.integer.value[0] = !(snd_es1938_mixer_read(chip, 0x61) & 0x40);
1125 ucontrol->value.integer.value[1] = !(snd_es1938_mixer_read(chip, 0x63) & 0x40);
1129 static void snd_es1938_hwv_free(snd_kcontrol_t *kcontrol)
1131 es1938_t *chip = snd_magic_cast(es1938_t, _snd_kcontrol_chip(kcontrol), return);
1132 chip->master_volume = NULL;
1133 chip->master_switch = NULL;
1134 chip->hw_volume = NULL;
1135 chip->hw_switch = NULL;
1138 static int snd_es1938_reg_bits(es1938_t *chip, unsigned char reg,
1139 unsigned char mask, unsigned char val)
1142 return snd_es1938_mixer_bits(chip, reg, mask, val);
1144 return snd_es1938_bits(chip, reg, mask, val);
1147 static int snd_es1938_reg_read(es1938_t *chip, unsigned char reg)
1150 return snd_es1938_mixer_read(chip, reg);
1152 return snd_es1938_read(chip, reg);
1155 #define ES1938_SINGLE(xname, xindex, reg, shift, mask, invert) \
1156 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1157 .info = snd_es1938_info_single, \
1158 .get = snd_es1938_get_single, .put = snd_es1938_put_single, \
1159 .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
1161 static int snd_es1938_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1163 int mask = (kcontrol->private_value >> 16) & 0xff;
1165 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1167 uinfo->value.integer.min = 0;
1168 uinfo->value.integer.max = mask;
1172 static int snd_es1938_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1174 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1175 int reg = kcontrol->private_value & 0xff;
1176 int shift = (kcontrol->private_value >> 8) & 0xff;
1177 int mask = (kcontrol->private_value >> 16) & 0xff;
1178 int invert = (kcontrol->private_value >> 24) & 0xff;
1181 val = snd_es1938_reg_read(chip, reg);
1182 ucontrol->value.integer.value[0] = (val >> shift) & mask;
1184 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1188 static int snd_es1938_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1190 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1191 int reg = kcontrol->private_value & 0xff;
1192 int shift = (kcontrol->private_value >> 8) & 0xff;
1193 int mask = (kcontrol->private_value >> 16) & 0xff;
1194 int invert = (kcontrol->private_value >> 24) & 0xff;
1197 val = (ucontrol->value.integer.value[0] & mask);
1202 return snd_es1938_reg_bits(chip, reg, mask, val) != val;
1205 #define ES1938_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1206 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1207 .info = snd_es1938_info_double, \
1208 .get = snd_es1938_get_double, .put = snd_es1938_put_double, \
1209 .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1211 static int snd_es1938_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
1213 int mask = (kcontrol->private_value >> 24) & 0xff;
1215 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1217 uinfo->value.integer.min = 0;
1218 uinfo->value.integer.max = mask;
1222 static int snd_es1938_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1224 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1225 int left_reg = kcontrol->private_value & 0xff;
1226 int right_reg = (kcontrol->private_value >> 8) & 0xff;
1227 int shift_left = (kcontrol->private_value >> 16) & 0x07;
1228 int shift_right = (kcontrol->private_value >> 19) & 0x07;
1229 int mask = (kcontrol->private_value >> 24) & 0xff;
1230 int invert = (kcontrol->private_value >> 22) & 1;
1231 unsigned char left, right;
1233 left = snd_es1938_reg_read(chip, left_reg);
1234 if (left_reg != right_reg)
1235 right = snd_es1938_reg_read(chip, right_reg);
1238 ucontrol->value.integer.value[0] = (left >> shift_left) & mask;
1239 ucontrol->value.integer.value[1] = (right >> shift_right) & mask;
1241 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1242 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
1247 static int snd_es1938_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
1249 es1938_t *chip = snd_kcontrol_chip(kcontrol);
1250 int left_reg = kcontrol->private_value & 0xff;
1251 int right_reg = (kcontrol->private_value >> 8) & 0xff;
1252 int shift_left = (kcontrol->private_value >> 16) & 0x07;
1253 int shift_right = (kcontrol->private_value >> 19) & 0x07;
1254 int mask = (kcontrol->private_value >> 24) & 0xff;
1255 int invert = (kcontrol->private_value >> 22) & 1;
1257 unsigned char val1, val2, mask1, mask2;
1259 val1 = ucontrol->value.integer.value[0] & mask;
1260 val2 = ucontrol->value.integer.value[1] & mask;
1265 val1 <<= shift_left;
1266 val2 <<= shift_right;
1267 mask1 = mask << shift_left;
1268 mask2 = mask << shift_right;
1269 if (left_reg != right_reg) {
1271 if (snd_es1938_reg_bits(chip, left_reg, mask1, val1) != val1)
1273 if (snd_es1938_reg_bits(chip, right_reg, mask2, val2) != val2)
1276 change = (snd_es1938_reg_bits(chip, left_reg, mask1 | mask2,
1277 val1 | val2) != (val1 | val2));
1282 static snd_kcontrol_new_t snd_es1938_controls[] = {
1283 ES1938_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0),
1284 ES1938_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1),
1286 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1287 .name = "Hardware Master Playback Volume",
1288 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1289 .info = snd_es1938_info_hw_volume,
1290 .get = snd_es1938_get_hw_volume,
1293 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1294 .name = "Hardware Master Playback Switch",
1295 .access = SNDRV_CTL_ELEM_ACCESS_READ,
1296 .info = snd_es1938_info_hw_switch,
1297 .get = snd_es1938_get_hw_switch,
1299 ES1938_SINGLE("Hardware Volume Split", 0, 0x64, 7, 1, 0),
1300 ES1938_DOUBLE("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0),
1301 ES1938_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0),
1302 ES1938_DOUBLE("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0),
1303 ES1938_DOUBLE("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1304 ES1938_DOUBLE("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0),
1305 ES1938_DOUBLE("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0),
1306 ES1938_DOUBLE("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0),
1307 ES1938_SINGLE("PC Speaker Volume", 0, 0x3c, 0, 7, 0),
1308 ES1938_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
1309 ES1938_SINGLE("Capture Switch", 0, 0x1c, 4, 1, 1),
1311 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1312 .name = "Capture Source",
1313 .info = snd_es1938_info_mux,
1314 .get = snd_es1938_get_mux,
1315 .put = snd_es1938_put_mux,
1317 ES1938_DOUBLE("Mono Input Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1318 ES1938_DOUBLE("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0),
1319 ES1938_DOUBLE("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0),
1320 ES1938_DOUBLE("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0),
1321 ES1938_DOUBLE("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0),
1322 ES1938_DOUBLE("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0),
1323 ES1938_DOUBLE("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0),
1324 ES1938_DOUBLE("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0),
1325 ES1938_DOUBLE("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0),
1326 ES1938_DOUBLE("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0),
1327 ES1938_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0),
1329 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1330 .name = "3D Control - Switch",
1331 .info = snd_es1938_info_spatializer_enable,
1332 .get = snd_es1938_get_spatializer_enable,
1333 .put = snd_es1938_put_spatializer_enable,
1335 ES1938_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0)
1339 /* ---------------------------------------------------------------------------- */
1340 /* ---------------------------------------------------------------------------- */
1342 static int snd_es1938_free(es1938_t *chip)
1345 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0);*/
1346 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
1347 if (chip->gameport.io)
1348 gameport_unregister_port(&chip->gameport);
1350 if (chip->res_io_port) {
1351 release_resource(chip->res_io_port);
1352 kfree_nocheck(chip->res_io_port);
1354 if (chip->res_sb_port) {
1355 release_resource(chip->res_sb_port);
1356 kfree_nocheck(chip->res_sb_port);
1358 if (chip->res_vc_port) {
1359 release_resource(chip->res_vc_port);
1360 kfree_nocheck(chip->res_vc_port);
1362 if (chip->res_mpu_port) {
1363 release_resource(chip->res_mpu_port);
1364 kfree_nocheck(chip->res_mpu_port);
1366 if (chip->res_game_port) {
1367 release_resource(chip->res_game_port);
1368 kfree_nocheck(chip->res_game_port);
1371 free_irq(chip->irq, (void *)chip);
1372 snd_magic_kfree(chip);
1376 static int snd_es1938_dev_free(snd_device_t *device)
1378 es1938_t *chip = snd_magic_cast(es1938_t, device->device_data, return -ENXIO);
1379 return snd_es1938_free(chip);
1382 static int __devinit snd_es1938_create(snd_card_t * card,
1383 struct pci_dev * pci,
1388 static snd_device_ops_t ops = {
1389 .dev_free = snd_es1938_dev_free,
1394 /* enable PCI device */
1395 if ((err = pci_enable_device(pci)) < 0)
1397 /* check, if we can restrict PCI DMA transfers to 24 bits */
1398 if (pci_set_dma_mask(pci, 0x00ffffff) < 0 ||
1399 pci_set_consistent_dma_mask(pci, 0x00ffffff) < 0) {
1400 snd_printk("architecture does not support 24bit PCI busmaster DMA\n");
1404 chip = snd_magic_kcalloc(es1938_t, 0, GFP_KERNEL);
1407 spin_lock_init(&chip->reg_lock);
1408 spin_lock_init(&chip->mixer_lock);
1411 chip->io_port = pci_resource_start(pci, 0);
1412 if ((chip->res_io_port = request_region(chip->io_port, 8, "ESS Solo-1")) == NULL) {
1413 snd_printk("unable to grab region 0x%lx-0x%lx\n", chip->io_port, chip->io_port + 8 - 1);
1414 snd_es1938_free(chip);
1417 chip->sb_port = pci_resource_start(pci, 1);
1418 if ((chip->res_sb_port = request_region(chip->sb_port, 0x10, "ESS Solo-1 SB")) == NULL) {
1419 snd_printk("unable to grab SB region 0x%lx-0x%lx\n", chip->sb_port, chip->sb_port + 0x10 - 1);
1420 snd_es1938_free(chip);
1423 chip->vc_port = pci_resource_start(pci, 2);
1424 if ((chip->res_vc_port = request_region(chip->vc_port, 0x10, "ESS Solo-1 VC (DMA)")) == NULL) {
1425 snd_printk("unable to grab VC (DMA) region 0x%lx-0x%lx\n", chip->vc_port, chip->vc_port + 0x10 - 1);
1426 snd_es1938_free(chip);
1429 chip->mpu_port = pci_resource_start(pci, 3);
1430 if ((chip->res_mpu_port = request_region(chip->mpu_port, 4, "ESS Solo-1 MIDI")) == NULL) {
1431 snd_printk("unable to grab MIDI region 0x%lx-0x%lx\n", chip->mpu_port, chip->mpu_port + 4 - 1);
1432 snd_es1938_free(chip);
1435 chip->game_port = pci_resource_start(pci, 4);
1436 if ((chip->res_game_port = request_region(chip->game_port, 4, "ESS Solo-1 GAME")) == NULL) {
1437 snd_printk("unable to grab GAME region 0x%lx-0x%lx\n", chip->game_port, chip->game_port + 4 - 1);
1438 snd_es1938_free(chip);
1441 if (request_irq(pci->irq, snd_es1938_interrupt, SA_INTERRUPT|SA_SHIRQ, "ES1938", (void *)chip)) {
1442 snd_printk("unable to grab IRQ %d\n", pci->irq);
1443 snd_es1938_free(chip);
1446 chip->irq = pci->irq;
1447 #ifdef ES1938_DDEBUG
1448 snd_printk("create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
1449 chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
1452 snd_es1938_reset(chip);
1454 /* configure native mode */
1456 /* enable bus master */
1457 pci_set_master(pci);
1459 /* disable legacy audio */
1460 pci_write_config_word(pci, SL_PCI_LEGACYCONTROL, 0x805f);
1463 chip->ddma_port = chip->vc_port + 0x00; /* fix from Thomas Sailer */
1464 pci_write_config_word(pci, SL_PCI_DDMACONTROL, chip->ddma_port | 1);
1466 /* set DMA/IRQ policy */
1467 pci_write_config_dword(pci, SL_PCI_CONFIG, 0);
1469 /* enable Audio 1, Audio 2, MPU401 IRQ and HW volume IRQ*/
1470 outb(0xf0, SLIO_REG(chip, IRQCONTROL));
1473 outb(0, SLDM_REG(chip, DMACLEAR));
1475 /* enable bus mastering */
1476 pci_set_master(pci);
1478 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1479 snd_es1938_free(chip);
1483 snd_card_set_dev(card, &pci->dev);
1489 /* --------------------------------------------------------------------
1491 * -------------------------------------------------------------------- */
1492 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1494 es1938_t *chip = snd_magic_cast(es1938_t, dev_id, return IRQ_NONE);
1495 unsigned char status, audiostatus;
1498 status = inb(SLIO_REG(chip, IRQCONTROL));
1500 printk("Es1938debug - interrupt status: =0x%x\n", status);
1504 if (status & 0x10) {
1506 printk("Es1938debug - AUDIO channel 1 interrupt\n");
1507 printk("Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n", inw(SLDM_REG(chip, DMACOUNT)));
1508 printk("Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n", inl(SLDM_REG(chip, DMAADDR)));
1509 printk("Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n", inl(SLDM_REG(chip, DMASTATUS)));
1513 audiostatus = inb(SLSB_REG(chip, STATUS));
1514 if (chip->active & ADC1)
1515 snd_pcm_period_elapsed(chip->capture_substream);
1516 else if (chip->active & DAC1)
1517 snd_pcm_period_elapsed(chip->playback2_substream);
1521 if (status & 0x20) {
1523 printk("Es1938debug - AUDIO channel 2 interrupt\n");
1524 printk("Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n", inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
1525 printk("Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n", inl(SLIO_REG(chip, AUDIO2DMAADDR)));
1530 snd_es1938_mixer_bits(chip, ESSSB_IREG_AUDIO2CONTROL2, 0x80, 0);
1531 if (chip->active & DAC2)
1532 snd_pcm_period_elapsed(chip->playback1_substream);
1535 /* Hardware volume */
1536 if (status & 0x40) {
1537 int split = snd_es1938_mixer_read(chip, 0x64) & 0x80;
1539 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_switch->id);
1540 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->hw_volume->id);
1542 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_switch->id);
1543 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->master_volume->id);
1546 snd_es1938_mixer_write(chip, 0x66, 0x00);
1550 if (status & 0x80) {
1551 // snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0); /* ack? */
1554 snd_mpu401_uart_interrupt(irq, chip->rmidi->private_data, regs);
1557 return IRQ_RETVAL(handled);
1560 #define ES1938_DMA_SIZE 64
1562 static int __devinit snd_es1938_mixer(snd_pcm_t *pcm)
1569 snd_assert(pcm != NULL && pcm->card != NULL, return -EINVAL);
1572 chip = snd_pcm_chip(pcm);
1574 strcpy(card->mixername, pcm->name);
1576 for (idx = 0; idx < ARRAY_SIZE(snd_es1938_controls); idx++) {
1577 snd_kcontrol_t *kctl;
1578 kctl = snd_ctl_new1(&snd_es1938_controls[idx], chip);
1581 chip->master_volume = kctl;
1582 kctl->private_free = snd_es1938_hwv_free;
1585 chip->master_switch = kctl;
1586 kctl->private_free = snd_es1938_hwv_free;
1589 chip->hw_volume = kctl;
1590 kctl->private_free = snd_es1938_hwv_free;
1593 chip->hw_switch = kctl;
1594 kctl->private_free = snd_es1938_hwv_free;
1597 if ((err = snd_ctl_add(card, kctl)) < 0)
1604 static int __devinit snd_es1938_probe(struct pci_dev *pci,
1605 const struct pci_device_id *pci_id)
1614 if (dev >= SNDRV_CARDS)
1621 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
1624 for (idx = 0; idx < 5; idx++) {
1625 if (pci_resource_start(pci, idx) == 0 ||
1626 !(pci_resource_flags(pci, idx) & IORESOURCE_IO)) {
1627 snd_card_free(card);
1631 if ((err = snd_es1938_create(card, pci, &chip)) < 0) {
1632 snd_card_free(card);
1636 strcpy(card->driver, "ES1938");
1637 strcpy(card->shortname, "ESS ES1938 (Solo-1)");
1638 sprintf(card->longname, "%s rev %i, irq %i",
1643 if ((err = snd_es1938_new_pcm(chip, 0, &pcm)) < 0) {
1644 snd_card_free(card);
1647 if ((err = snd_es1938_mixer(pcm)) < 0) {
1648 snd_card_free(card);
1651 if (snd_opl3_create(card,
1652 SLSB_REG(chip, FMLOWADDR),
1653 SLSB_REG(chip, FMHIGHADDR),
1654 OPL3_HW_OPL3, 1, &opl3) < 0) {
1655 printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n",
1656 SLSB_REG(chip, FMLOWADDR));
1658 if ((err = snd_opl3_timer_new(opl3, 0, 1)) < 0) {
1659 snd_card_free(card);
1662 if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
1663 snd_card_free(card);
1667 if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
1668 chip->mpu_port, 1, chip->irq, 0, &chip->rmidi) < 0) {
1669 printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
1671 snd_es1938_mixer_bits(chip, ESSSB_IREG_MPU401CONTROL, 0x40, 0x40);*/
1673 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
1674 chip->gameport.io = chip->game_port;
1675 gameport_register_port(&chip->gameport);
1678 if ((err = snd_card_register(card)) < 0) {
1679 snd_card_free(card);
1683 pci_set_drvdata(pci, card);
1688 static void __devexit snd_es1938_remove(struct pci_dev *pci)
1690 snd_card_free(pci_get_drvdata(pci));
1691 pci_set_drvdata(pci, NULL);
1694 static struct pci_driver driver = {
1695 .name = "ESS ES1938 (Solo-1)",
1696 .id_table = snd_es1938_ids,
1697 .probe = snd_es1938_probe,
1698 .remove = __devexit_p(snd_es1938_remove),
1701 static int __init alsa_card_es1938_init(void)
1705 if ((err = pci_module_init(&driver)) < 0) {
1707 printk(KERN_ERR "ESS Solo-1 soundcard not found or device busy\n");
1714 static void __exit alsa_card_es1938_exit(void)
1716 pci_unregister_driver(&driver);
1719 module_init(alsa_card_es1938_init)
1720 module_exit(alsa_card_es1938_exit)
1724 /* format is: snd-es1938=enable,index,id */
1726 static int __init alsa_card_es1938_setup(char *str)
1728 static unsigned __initdata nr_dev = 0;
1730 if (nr_dev >= SNDRV_CARDS)
1732 (void)(get_option(&str,&enable[nr_dev]) == 2 &&
1733 get_option(&str,&index[nr_dev]) == 2 &&
1734 get_id(&str,&id[nr_dev]) == 2);
1739 __setup("snd-es1938=", alsa_card_es1938_setup);
1741 #endif /* ifndef MODULE */