1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Driver for generic ESS AudioDrive ES18xx soundcards
4 * Copyright (c) by Christian Fischbach <fishbach@pool.informatik.rwth-aachen.de>
5 * Copyright (c) by Abramo Bagnara <abramo@alsa-project.org>
10 * - There are pops (we can't delay in trigger function, cause midlevel
11 * often need to trigger down and then up very quickly).
13 * - Support for 16 bit DMA seems to be broken. I've no hardware to tune it.
18 * - The chip has one half duplex pcm (with very limited full duplex support).
20 * - Duplex stereophonic sound is impossible.
21 * - Record and playback must share the same frequency rate.
23 * - The driver use dma2 for playback and dma1 for capture.
29 * - there are a first full duplex pcm and a second playback only pcm
30 * (incompatible with first pcm capture)
32 * - there is support for the capture volume and ESS Spatializer 3D effect.
34 * - contrarily to some pages in DS_1869.PDF the rates can be set
37 * - Zoom Video is implemented by sharing the FM DAC, thus the user can
38 * have either FM playback or Video playback but not both simultaneously.
39 * The Video Playback Switch mixer control toggles this choice.
43 * - There is a major trouble I noted:
45 * using both channel for playback stereo 16 bit samples at 44100 Hz
46 * the second pcm (Audio1) DMA slows down irregularly and sound is garbled.
48 * The same happens using Audio1 for captureing.
50 * The Windows driver does not suffer of this (although it use Audio1
51 * only for captureing). I'm unable to discover why.
57 * - When Zoom Video is enabled (reg 0x71 bit 6 toggled on) the PCM playback
58 * seems to be effected (speaker_test plays a lower frequency). Can't find
59 * anything in the datasheet to account for this, so a Video Playback Switch
60 * control has been included to allow ZV to be enabled only when necessary.
61 * Then again on at least one test system the 0x71 bit 6 enable bit is not
62 * needed for ZV, so maybe the datasheet is entirely wrong here.
65 #include <linux/init.h>
66 #include <linux/err.h>
67 #include <linux/isa.h>
68 #include <linux/pnp.h>
69 #include <linux/isapnp.h>
70 #include <linux/module.h>
71 #include <linux/delay.h>
75 #include <sound/core.h>
76 #include <sound/control.h>
77 #include <sound/pcm.h>
78 #include <sound/pcm_params.h>
79 #include <sound/mpu401.h>
80 #include <sound/opl3.h>
81 #define SNDRV_LEGACY_FIND_FREE_IRQ
82 #define SNDRV_LEGACY_FIND_FREE_DMA
83 #include <sound/initval.h>
85 #define PFX "es18xx: "
88 unsigned long port
; /* port of ESS chip */
89 unsigned long ctrl_port
; /* Control port of ESS chip */
90 int irq
; /* IRQ number of ESS chip */
93 unsigned short version
; /* version of ESS chip */
94 int caps
; /* Chip capabilities */
95 unsigned short audio2_vol
; /* volume level of audio2 */
97 unsigned short active
; /* active channel mask */
98 unsigned int dma1_shift
;
99 unsigned int dma2_shift
;
102 struct snd_pcm_substream
*playback_a_substream
;
103 struct snd_pcm_substream
*capture_a_substream
;
104 struct snd_pcm_substream
*playback_b_substream
;
106 struct snd_rawmidi
*rmidi
;
108 struct snd_kcontrol
*hw_volume
;
109 struct snd_kcontrol
*hw_switch
;
110 struct snd_kcontrol
*master_volume
;
111 struct snd_kcontrol
*master_switch
;
114 spinlock_t mixer_lock
;
116 unsigned char pm_reg
;
120 struct pnp_dev
*devc
;
124 #define AUDIO1_IRQ 0x01
125 #define AUDIO2_IRQ 0x02
129 #define ES18XX_PCM2 0x0001 /* Has two useable PCM */
130 #define ES18XX_SPATIALIZER 0x0002 /* Has 3D Spatializer */
131 #define ES18XX_RECMIX 0x0004 /* Has record mixer */
132 #define ES18XX_DUPLEX_MONO 0x0008 /* Has mono duplex only */
133 #define ES18XX_DUPLEX_SAME 0x0010 /* Playback and record must share the same rate */
134 #define ES18XX_NEW_RATE 0x0020 /* More precise rate setting */
135 #define ES18XX_AUXB 0x0040 /* AuxB mixer control */
136 #define ES18XX_HWV 0x0080 /* Has separate hardware volume mixer controls*/
137 #define ES18XX_MONO 0x0100 /* Mono_in mixer control */
138 #define ES18XX_I2S 0x0200 /* I2S mixer control */
139 #define ES18XX_MUTEREC 0x0400 /* Record source can be muted */
140 #define ES18XX_CONTROL 0x0800 /* Has control ports */
141 #define ES18XX_GPO_2BIT 0x1000 /* GPO0,1 controlled by PM port */
143 /* Power Management */
144 #define ES18XX_PM 0x07
145 #define ES18XX_PM_GPO0 0x01
146 #define ES18XX_PM_GPO1 0x02
147 #define ES18XX_PM_PDR 0x04
148 #define ES18XX_PM_ANA 0x08
149 #define ES18XX_PM_FM 0x020
150 #define ES18XX_PM_SUS 0x080
157 #define MILLISECOND 10000
159 static int snd_es18xx_dsp_command(struct snd_es18xx
*chip
, unsigned char val
)
163 for(i
= MILLISECOND
; i
; i
--)
164 if ((inb(chip
->port
+ 0x0C) & 0x80) == 0) {
165 outb(val
, chip
->port
+ 0x0C);
168 snd_printk(KERN_ERR
"dsp_command: timeout (0x%x)\n", val
);
172 static int snd_es18xx_dsp_get_byte(struct snd_es18xx
*chip
)
176 for(i
= MILLISECOND
/10; i
; i
--)
177 if (inb(chip
->port
+ 0x0C) & 0x40)
178 return inb(chip
->port
+ 0x0A);
179 snd_printk(KERN_ERR
"dsp_get_byte failed: 0x%lx = 0x%x!!!\n",
180 chip
->port
+ 0x0A, inb(chip
->port
+ 0x0A));
186 static int snd_es18xx_write(struct snd_es18xx
*chip
,
187 unsigned char reg
, unsigned char data
)
192 spin_lock_irqsave(&chip
->reg_lock
, flags
);
193 ret
= snd_es18xx_dsp_command(chip
, reg
);
196 ret
= snd_es18xx_dsp_command(chip
, data
);
198 spin_unlock_irqrestore(&chip
->reg_lock
, flags
);
200 snd_printk(KERN_DEBUG
"Reg %02x set to %02x\n", reg
, data
);
205 static int snd_es18xx_read(struct snd_es18xx
*chip
, unsigned char reg
)
209 spin_lock_irqsave(&chip
->reg_lock
, flags
);
210 ret
= snd_es18xx_dsp_command(chip
, 0xC0);
213 ret
= snd_es18xx_dsp_command(chip
, reg
);
216 data
= snd_es18xx_dsp_get_byte(chip
);
219 snd_printk(KERN_DEBUG
"Reg %02x now is %02x (%d)\n", reg
, data
, ret
);
222 spin_unlock_irqrestore(&chip
->reg_lock
, flags
);
226 /* Return old value */
227 static int snd_es18xx_bits(struct snd_es18xx
*chip
, unsigned char reg
,
228 unsigned char mask
, unsigned char val
)
231 unsigned char old
, new, oval
;
233 spin_lock_irqsave(&chip
->reg_lock
, flags
);
234 ret
= snd_es18xx_dsp_command(chip
, 0xC0);
237 ret
= snd_es18xx_dsp_command(chip
, reg
);
240 ret
= snd_es18xx_dsp_get_byte(chip
);
247 ret
= snd_es18xx_dsp_command(chip
, reg
);
250 new = (old
& ~mask
) | (val
& mask
);
251 ret
= snd_es18xx_dsp_command(chip
, new);
255 snd_printk(KERN_DEBUG
"Reg %02x was %02x, set to %02x (%d)\n",
261 spin_unlock_irqrestore(&chip
->reg_lock
, flags
);
265 static inline void snd_es18xx_mixer_write(struct snd_es18xx
*chip
,
266 unsigned char reg
, unsigned char data
)
269 spin_lock_irqsave(&chip
->mixer_lock
, flags
);
270 outb(reg
, chip
->port
+ 0x04);
271 outb(data
, chip
->port
+ 0x05);
272 spin_unlock_irqrestore(&chip
->mixer_lock
, flags
);
274 snd_printk(KERN_DEBUG
"Mixer reg %02x set to %02x\n", reg
, data
);
278 static inline int snd_es18xx_mixer_read(struct snd_es18xx
*chip
, unsigned char reg
)
282 spin_lock_irqsave(&chip
->mixer_lock
, flags
);
283 outb(reg
, chip
->port
+ 0x04);
284 data
= inb(chip
->port
+ 0x05);
285 spin_unlock_irqrestore(&chip
->mixer_lock
, flags
);
287 snd_printk(KERN_DEBUG
"Mixer reg %02x now is %02x\n", reg
, data
);
292 /* Return old value */
293 static inline int snd_es18xx_mixer_bits(struct snd_es18xx
*chip
, unsigned char reg
,
294 unsigned char mask
, unsigned char val
)
296 unsigned char old
, new, oval
;
298 spin_lock_irqsave(&chip
->mixer_lock
, flags
);
299 outb(reg
, chip
->port
+ 0x04);
300 old
= inb(chip
->port
+ 0x05);
303 new = (old
& ~mask
) | (val
& mask
);
304 outb(new, chip
->port
+ 0x05);
306 snd_printk(KERN_DEBUG
"Mixer reg %02x was %02x, set to %02x\n",
310 spin_unlock_irqrestore(&chip
->mixer_lock
, flags
);
314 static inline int snd_es18xx_mixer_writable(struct snd_es18xx
*chip
, unsigned char reg
,
317 int old
, expected
, new;
319 spin_lock_irqsave(&chip
->mixer_lock
, flags
);
320 outb(reg
, chip
->port
+ 0x04);
321 old
= inb(chip
->port
+ 0x05);
322 expected
= old
^ mask
;
323 outb(expected
, chip
->port
+ 0x05);
324 new = inb(chip
->port
+ 0x05);
325 spin_unlock_irqrestore(&chip
->mixer_lock
, flags
);
327 snd_printk(KERN_DEBUG
"Mixer reg %02x was %02x, set to %02x, now is %02x\n",
328 reg
, old
, expected
, new);
330 return expected
== new;
334 static int snd_es18xx_reset(struct snd_es18xx
*chip
)
337 outb(0x03, chip
->port
+ 0x06);
338 inb(chip
->port
+ 0x06);
339 outb(0x00, chip
->port
+ 0x06);
340 for(i
= 0; i
< MILLISECOND
&& !(inb(chip
->port
+ 0x0E) & 0x80); i
++);
341 if (inb(chip
->port
+ 0x0A) != 0xAA)
346 static int snd_es18xx_reset_fifo(struct snd_es18xx
*chip
)
348 outb(0x02, chip
->port
+ 0x06);
349 inb(chip
->port
+ 0x06);
350 outb(0x00, chip
->port
+ 0x06);
354 static const struct snd_ratnum new_clocks
[2] = {
369 static const struct snd_pcm_hw_constraint_ratnums new_hw_constraints_clocks
= {
374 static const struct snd_ratnum old_clocks
[2] = {
389 static const struct snd_pcm_hw_constraint_ratnums old_hw_constraints_clocks
= {
395 static void snd_es18xx_rate_set(struct snd_es18xx
*chip
,
396 struct snd_pcm_substream
*substream
,
399 unsigned int bits
, div0
;
400 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
401 if (chip
->caps
& ES18XX_NEW_RATE
) {
402 if (runtime
->rate_num
== new_clocks
[0].num
)
403 bits
= 128 - runtime
->rate_den
;
405 bits
= 256 - runtime
->rate_den
;
407 if (runtime
->rate_num
== old_clocks
[0].num
)
408 bits
= 256 - runtime
->rate_den
;
410 bits
= 128 - runtime
->rate_den
;
413 /* set filter register */
414 div0
= 256 - 7160000*20/(8*82*runtime
->rate
);
416 if ((chip
->caps
& ES18XX_PCM2
) && mode
== DAC2
) {
417 snd_es18xx_mixer_write(chip
, 0x70, bits
);
419 * Comment from kernel oss driver:
420 * FKS: fascinating: 0x72 doesn't seem to work.
422 snd_es18xx_write(chip
, 0xA2, div0
);
423 snd_es18xx_mixer_write(chip
, 0x72, div0
);
425 snd_es18xx_write(chip
, 0xA1, bits
);
426 snd_es18xx_write(chip
, 0xA2, div0
);
430 static int snd_es18xx_playback_hw_params(struct snd_pcm_substream
*substream
,
431 struct snd_pcm_hw_params
*hw_params
)
433 struct snd_es18xx
*chip
= snd_pcm_substream_chip(substream
);
437 if (params_channels(hw_params
) == 2)
439 if (snd_pcm_format_width(params_format(hw_params
)) == 16)
442 if (substream
->number
== 0 && (chip
->caps
& ES18XX_PCM2
)) {
443 if ((chip
->caps
& ES18XX_DUPLEX_MONO
) &&
444 (chip
->capture_a_substream
) &&
445 params_channels(hw_params
) != 1) {
446 _snd_pcm_hw_param_setempty(hw_params
, SNDRV_PCM_HW_PARAM_CHANNELS
);
449 chip
->dma2_shift
= shift
;
451 chip
->dma1_shift
= shift
;
456 static int snd_es18xx_playback1_prepare(struct snd_es18xx
*chip
,
457 struct snd_pcm_substream
*substream
)
459 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
460 unsigned int size
= snd_pcm_lib_buffer_bytes(substream
);
461 unsigned int count
= snd_pcm_lib_period_bytes(substream
);
463 snd_es18xx_rate_set(chip
, substream
, DAC2
);
465 /* Transfer Count Reload */
466 count
= 0x10000 - count
;
467 snd_es18xx_mixer_write(chip
, 0x74, count
& 0xff);
468 snd_es18xx_mixer_write(chip
, 0x76, count
>> 8);
471 snd_es18xx_mixer_bits(chip
, 0x7A, 0x07,
472 ((runtime
->channels
== 1) ? 0x00 : 0x02) |
473 (snd_pcm_format_width(runtime
->format
) == 16 ? 0x01 : 0x00) |
474 (snd_pcm_format_unsigned(runtime
->format
) ? 0x00 : 0x04));
476 /* Set DMA controller */
477 snd_dma_program(chip
->dma2
, runtime
->dma_addr
, size
, DMA_MODE_WRITE
| DMA_AUTOINIT
);
482 static int snd_es18xx_playback1_trigger(struct snd_es18xx
*chip
,
483 struct snd_pcm_substream
*substream
,
487 case SNDRV_PCM_TRIGGER_START
:
488 case SNDRV_PCM_TRIGGER_RESUME
:
489 if (chip
->active
& DAC2
)
491 chip
->active
|= DAC2
;
494 snd_es18xx_mixer_write(chip
, 0x78, 0xb3);
496 snd_es18xx_mixer_write(chip
, 0x78, 0x93);
500 if (chip
->caps
& ES18XX_PCM2
)
501 /* Restore Audio 2 volume */
502 snd_es18xx_mixer_write(chip
, 0x7C, chip
->audio2_vol
);
504 /* Enable PCM output */
505 snd_es18xx_dsp_command(chip
, 0xD1);
508 case SNDRV_PCM_TRIGGER_STOP
:
509 case SNDRV_PCM_TRIGGER_SUSPEND
:
510 if (!(chip
->active
& DAC2
))
512 chip
->active
&= ~DAC2
;
514 snd_es18xx_mixer_write(chip
, 0x78, 0x00);
517 if (chip
->caps
& ES18XX_PCM2
)
518 /* Set Audio 2 volume to 0 */
519 snd_es18xx_mixer_write(chip
, 0x7C, 0);
521 /* Disable PCM output */
522 snd_es18xx_dsp_command(chip
, 0xD3);
532 static int snd_es18xx_capture_hw_params(struct snd_pcm_substream
*substream
,
533 struct snd_pcm_hw_params
*hw_params
)
535 struct snd_es18xx
*chip
= snd_pcm_substream_chip(substream
);
539 if ((chip
->caps
& ES18XX_DUPLEX_MONO
) &&
540 chip
->playback_a_substream
&&
541 params_channels(hw_params
) != 1) {
542 _snd_pcm_hw_param_setempty(hw_params
, SNDRV_PCM_HW_PARAM_CHANNELS
);
545 if (params_channels(hw_params
) == 2)
547 if (snd_pcm_format_width(params_format(hw_params
)) == 16)
549 chip
->dma1_shift
= shift
;
553 static int snd_es18xx_capture_prepare(struct snd_pcm_substream
*substream
)
555 struct snd_es18xx
*chip
= snd_pcm_substream_chip(substream
);
556 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
557 unsigned int size
= snd_pcm_lib_buffer_bytes(substream
);
558 unsigned int count
= snd_pcm_lib_period_bytes(substream
);
560 snd_es18xx_reset_fifo(chip
);
562 /* Set stereo/mono */
563 snd_es18xx_bits(chip
, 0xA8, 0x03, runtime
->channels
== 1 ? 0x02 : 0x01);
565 snd_es18xx_rate_set(chip
, substream
, ADC1
);
567 /* Transfer Count Reload */
568 count
= 0x10000 - count
;
569 snd_es18xx_write(chip
, 0xA4, count
& 0xff);
570 snd_es18xx_write(chip
, 0xA5, count
>> 8);
577 snd_es18xx_write(chip
, 0xB7,
578 snd_pcm_format_unsigned(runtime
->format
) ? 0x51 : 0x71);
579 snd_es18xx_write(chip
, 0xB7, 0x90 |
580 ((runtime
->channels
== 1) ? 0x40 : 0x08) |
581 (snd_pcm_format_width(runtime
->format
) == 16 ? 0x04 : 0x00) |
582 (snd_pcm_format_unsigned(runtime
->format
) ? 0x00 : 0x20));
584 /* Set DMA controller */
585 snd_dma_program(chip
->dma1
, runtime
->dma_addr
, size
, DMA_MODE_READ
| DMA_AUTOINIT
);
590 static int snd_es18xx_capture_trigger(struct snd_pcm_substream
*substream
,
593 struct snd_es18xx
*chip
= snd_pcm_substream_chip(substream
);
596 case SNDRV_PCM_TRIGGER_START
:
597 case SNDRV_PCM_TRIGGER_RESUME
:
598 if (chip
->active
& ADC1
)
600 chip
->active
|= ADC1
;
602 snd_es18xx_write(chip
, 0xB8, 0x0f);
604 case SNDRV_PCM_TRIGGER_STOP
:
605 case SNDRV_PCM_TRIGGER_SUSPEND
:
606 if (!(chip
->active
& ADC1
))
608 chip
->active
&= ~ADC1
;
610 snd_es18xx_write(chip
, 0xB8, 0x00);
619 static int snd_es18xx_playback2_prepare(struct snd_es18xx
*chip
,
620 struct snd_pcm_substream
*substream
)
622 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
623 unsigned int size
= snd_pcm_lib_buffer_bytes(substream
);
624 unsigned int count
= snd_pcm_lib_period_bytes(substream
);
626 snd_es18xx_reset_fifo(chip
);
628 /* Set stereo/mono */
629 snd_es18xx_bits(chip
, 0xA8, 0x03, runtime
->channels
== 1 ? 0x02 : 0x01);
631 snd_es18xx_rate_set(chip
, substream
, DAC1
);
633 /* Transfer Count Reload */
634 count
= 0x10000 - count
;
635 snd_es18xx_write(chip
, 0xA4, count
& 0xff);
636 snd_es18xx_write(chip
, 0xA5, count
>> 8);
639 snd_es18xx_write(chip
, 0xB6,
640 snd_pcm_format_unsigned(runtime
->format
) ? 0x80 : 0x00);
641 snd_es18xx_write(chip
, 0xB7,
642 snd_pcm_format_unsigned(runtime
->format
) ? 0x51 : 0x71);
643 snd_es18xx_write(chip
, 0xB7, 0x90 |
644 (runtime
->channels
== 1 ? 0x40 : 0x08) |
645 (snd_pcm_format_width(runtime
->format
) == 16 ? 0x04 : 0x00) |
646 (snd_pcm_format_unsigned(runtime
->format
) ? 0x00 : 0x20));
648 /* Set DMA controller */
649 snd_dma_program(chip
->dma1
, runtime
->dma_addr
, size
, DMA_MODE_WRITE
| DMA_AUTOINIT
);
654 static int snd_es18xx_playback2_trigger(struct snd_es18xx
*chip
,
655 struct snd_pcm_substream
*substream
,
659 case SNDRV_PCM_TRIGGER_START
:
660 case SNDRV_PCM_TRIGGER_RESUME
:
661 if (chip
->active
& DAC1
)
663 chip
->active
|= DAC1
;
665 snd_es18xx_write(chip
, 0xB8, 0x05);
670 snd_es18xx_dsp_command(chip
, 0xD1);
673 case SNDRV_PCM_TRIGGER_STOP
:
674 case SNDRV_PCM_TRIGGER_SUSPEND
:
675 if (!(chip
->active
& DAC1
))
677 chip
->active
&= ~DAC1
;
679 snd_es18xx_write(chip
, 0xB8, 0x00);
683 /* Disable Audio 1 */
684 snd_es18xx_dsp_command(chip
, 0xD3);
694 static int snd_es18xx_playback_prepare(struct snd_pcm_substream
*substream
)
696 struct snd_es18xx
*chip
= snd_pcm_substream_chip(substream
);
697 if (substream
->number
== 0 && (chip
->caps
& ES18XX_PCM2
))
698 return snd_es18xx_playback1_prepare(chip
, substream
);
700 return snd_es18xx_playback2_prepare(chip
, substream
);
703 static int snd_es18xx_playback_trigger(struct snd_pcm_substream
*substream
,
706 struct snd_es18xx
*chip
= snd_pcm_substream_chip(substream
);
707 if (substream
->number
== 0 && (chip
->caps
& ES18XX_PCM2
))
708 return snd_es18xx_playback1_trigger(chip
, substream
, cmd
);
710 return snd_es18xx_playback2_trigger(chip
, substream
, cmd
);
713 static irqreturn_t
snd_es18xx_interrupt(int irq
, void *dev_id
)
715 struct snd_card
*card
= dev_id
;
716 struct snd_es18xx
*chip
= card
->private_data
;
717 unsigned char status
;
719 if (chip
->caps
& ES18XX_CONTROL
) {
720 /* Read Interrupt status */
721 status
= inb(chip
->ctrl_port
+ 6);
723 /* Read Interrupt status */
724 status
= snd_es18xx_mixer_read(chip
, 0x7f) >> 4;
729 if (inb(chip
->port
+ 0x0C) & 0x01)
730 status
|= AUDIO1_IRQ
;
731 if (snd_es18xx_mixer_read(chip
, 0x7A) & 0x80)
732 status
|= AUDIO2_IRQ
;
733 if ((chip
->caps
& ES18XX_HWV
) &&
734 snd_es18xx_mixer_read(chip
, 0x64) & 0x10)
739 /* Audio 1 & Audio 2 */
740 if (status
& AUDIO2_IRQ
) {
741 if (chip
->active
& DAC2
)
742 snd_pcm_period_elapsed(chip
->playback_a_substream
);
744 snd_es18xx_mixer_bits(chip
, 0x7A, 0x80, 0x00);
746 if (status
& AUDIO1_IRQ
) {
747 /* ok.. capture is active */
748 if (chip
->active
& ADC1
)
749 snd_pcm_period_elapsed(chip
->capture_a_substream
);
750 /* ok.. playback2 is active */
751 else if (chip
->active
& DAC1
)
752 snd_pcm_period_elapsed(chip
->playback_b_substream
);
754 inb(chip
->port
+ 0x0E);
758 if ((status
& MPU_IRQ
) && chip
->rmidi
)
759 snd_mpu401_uart_interrupt(irq
, chip
->rmidi
->private_data
);
761 /* Hardware volume */
762 if (status
& HWV_IRQ
) {
764 if (chip
->caps
& ES18XX_HWV
) {
765 split
= snd_es18xx_mixer_read(chip
, 0x64) & 0x80;
766 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_VALUE
,
767 &chip
->hw_switch
->id
);
768 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_VALUE
,
769 &chip
->hw_volume
->id
);
772 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_VALUE
,
773 &chip
->master_switch
->id
);
774 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_VALUE
,
775 &chip
->master_volume
->id
);
778 snd_es18xx_mixer_write(chip
, 0x66, 0x00);
783 static snd_pcm_uframes_t
snd_es18xx_playback_pointer(struct snd_pcm_substream
*substream
)
785 struct snd_es18xx
*chip
= snd_pcm_substream_chip(substream
);
786 unsigned int size
= snd_pcm_lib_buffer_bytes(substream
);
789 if (substream
->number
== 0 && (chip
->caps
& ES18XX_PCM2
)) {
790 if (!(chip
->active
& DAC2
))
792 pos
= snd_dma_pointer(chip
->dma2
, size
);
793 return pos
>> chip
->dma2_shift
;
795 if (!(chip
->active
& DAC1
))
797 pos
= snd_dma_pointer(chip
->dma1
, size
);
798 return pos
>> chip
->dma1_shift
;
802 static snd_pcm_uframes_t
snd_es18xx_capture_pointer(struct snd_pcm_substream
*substream
)
804 struct snd_es18xx
*chip
= snd_pcm_substream_chip(substream
);
805 unsigned int size
= snd_pcm_lib_buffer_bytes(substream
);
808 if (!(chip
->active
& ADC1
))
810 pos
= snd_dma_pointer(chip
->dma1
, size
);
811 return pos
>> chip
->dma1_shift
;
814 static const struct snd_pcm_hardware snd_es18xx_playback
=
816 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
817 SNDRV_PCM_INFO_RESUME
|
818 SNDRV_PCM_INFO_MMAP_VALID
),
819 .formats
= (SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S8
|
820 SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_U16_LE
),
821 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_48000
,
826 .buffer_bytes_max
= 65536,
827 .period_bytes_min
= 64,
828 .period_bytes_max
= 65536,
834 static const struct snd_pcm_hardware snd_es18xx_capture
=
836 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
837 SNDRV_PCM_INFO_RESUME
|
838 SNDRV_PCM_INFO_MMAP_VALID
),
839 .formats
= (SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S8
|
840 SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_U16_LE
),
841 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_48000
,
846 .buffer_bytes_max
= 65536,
847 .period_bytes_min
= 64,
848 .period_bytes_max
= 65536,
854 static int snd_es18xx_playback_open(struct snd_pcm_substream
*substream
)
856 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
857 struct snd_es18xx
*chip
= snd_pcm_substream_chip(substream
);
859 if (substream
->number
== 0 && (chip
->caps
& ES18XX_PCM2
)) {
860 if ((chip
->caps
& ES18XX_DUPLEX_MONO
) &&
861 chip
->capture_a_substream
&&
862 chip
->capture_a_substream
->runtime
->channels
!= 1)
864 chip
->playback_a_substream
= substream
;
865 } else if (substream
->number
<= 1) {
866 if (chip
->capture_a_substream
)
868 chip
->playback_b_substream
= substream
;
873 substream
->runtime
->hw
= snd_es18xx_playback
;
874 snd_pcm_hw_constraint_ratnums(runtime
, 0, SNDRV_PCM_HW_PARAM_RATE
,
875 (chip
->caps
& ES18XX_NEW_RATE
) ? &new_hw_constraints_clocks
: &old_hw_constraints_clocks
);
879 static int snd_es18xx_capture_open(struct snd_pcm_substream
*substream
)
881 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
882 struct snd_es18xx
*chip
= snd_pcm_substream_chip(substream
);
884 if (chip
->playback_b_substream
)
886 if ((chip
->caps
& ES18XX_DUPLEX_MONO
) &&
887 chip
->playback_a_substream
&&
888 chip
->playback_a_substream
->runtime
->channels
!= 1)
890 chip
->capture_a_substream
= substream
;
891 substream
->runtime
->hw
= snd_es18xx_capture
;
892 snd_pcm_hw_constraint_ratnums(runtime
, 0, SNDRV_PCM_HW_PARAM_RATE
,
893 (chip
->caps
& ES18XX_NEW_RATE
) ? &new_hw_constraints_clocks
: &old_hw_constraints_clocks
);
897 static int snd_es18xx_playback_close(struct snd_pcm_substream
*substream
)
899 struct snd_es18xx
*chip
= snd_pcm_substream_chip(substream
);
901 if (substream
->number
== 0 && (chip
->caps
& ES18XX_PCM2
))
902 chip
->playback_a_substream
= NULL
;
904 chip
->playback_b_substream
= NULL
;
909 static int snd_es18xx_capture_close(struct snd_pcm_substream
*substream
)
911 struct snd_es18xx
*chip
= snd_pcm_substream_chip(substream
);
913 chip
->capture_a_substream
= NULL
;
921 /* Record source mux routines:
922 * Depending on the chipset this mux switches between 4, 5, or 8 possible inputs.
923 * bit table for the 4/5 source mux:
930 * if it's "mixer" and it's a 5 source mux chipset then reg 7A bit 3 determines
931 * either the play mixer or the capture mixer.
933 * "map4Source" translates from source number to reg bit pattern
934 * "invMap4Source" translates from reg bit pattern to source number
937 static int snd_es18xx_info_mux(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
939 static const char * const texts5Source
[5] = {
940 "Mic", "CD", "Line", "Master", "Mix"
942 static const char * const texts8Source
[8] = {
943 "Mic", "Mic Master", "CD", "AOUT",
944 "Mic1", "Mix", "Line", "Master"
946 struct snd_es18xx
*chip
= snd_kcontrol_chip(kcontrol
);
948 switch (chip
->version
) {
951 return snd_ctl_enum_info(uinfo
, 1, 4, texts5Source
);
954 return snd_ctl_enum_info(uinfo
, 1, 5, texts5Source
);
955 case 0x1869: /* DS somewhat contradictory for 1869: could be 5 or 8 */
957 return snd_ctl_enum_info(uinfo
, 1, 8, texts8Source
);
963 static int snd_es18xx_get_mux(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
965 static const unsigned char invMap4Source
[8] = {0, 0, 1, 1, 0, 0, 2, 3};
966 struct snd_es18xx
*chip
= snd_kcontrol_chip(kcontrol
);
967 int muxSource
= snd_es18xx_mixer_read(chip
, 0x1c) & 0x07;
968 if (!(chip
->version
== 0x1869 || chip
->version
== 0x1879)) {
969 muxSource
= invMap4Source
[muxSource
];
971 (chip
->version
== 0x1887 || chip
->version
== 0x1888) &&
972 (snd_es18xx_mixer_read(chip
, 0x7a) & 0x08)
976 ucontrol
->value
.enumerated
.item
[0] = muxSource
;
980 static int snd_es18xx_put_mux(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
982 static const unsigned char map4Source
[4] = {0, 2, 6, 7};
983 struct snd_es18xx
*chip
= snd_kcontrol_chip(kcontrol
);
984 unsigned char val
= ucontrol
->value
.enumerated
.item
[0];
985 unsigned char retVal
= 0;
987 switch (chip
->version
) {
994 retVal
= snd_es18xx_mixer_bits(chip
, 0x7a, 0x08, 0x08) != 0x08;
997 retVal
= snd_es18xx_mixer_bits(chip
, 0x7a, 0x08, 0x00) != 0x00;
1004 val
= map4Source
[val
];
1006 /* 8 source chips */
1015 return (snd_es18xx_mixer_bits(chip
, 0x1c, 0x07, val
) != val
) || retVal
;
1018 #define snd_es18xx_info_spatializer_enable snd_ctl_boolean_mono_info
1020 static int snd_es18xx_get_spatializer_enable(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1022 struct snd_es18xx
*chip
= snd_kcontrol_chip(kcontrol
);
1023 unsigned char val
= snd_es18xx_mixer_read(chip
, 0x50);
1024 ucontrol
->value
.integer
.value
[0] = !!(val
& 8);
1028 static int snd_es18xx_put_spatializer_enable(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1030 struct snd_es18xx
*chip
= snd_kcontrol_chip(kcontrol
);
1031 unsigned char oval
, nval
;
1033 nval
= ucontrol
->value
.integer
.value
[0] ? 0x0c : 0x04;
1034 oval
= snd_es18xx_mixer_read(chip
, 0x50) & 0x0c;
1035 change
= nval
!= oval
;
1037 snd_es18xx_mixer_write(chip
, 0x50, nval
& ~0x04);
1038 snd_es18xx_mixer_write(chip
, 0x50, nval
);
1043 static int snd_es18xx_info_hw_volume(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
1045 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
1047 uinfo
->value
.integer
.min
= 0;
1048 uinfo
->value
.integer
.max
= 63;
1052 static int snd_es18xx_get_hw_volume(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1054 struct snd_es18xx
*chip
= snd_kcontrol_chip(kcontrol
);
1055 ucontrol
->value
.integer
.value
[0] = snd_es18xx_mixer_read(chip
, 0x61) & 0x3f;
1056 ucontrol
->value
.integer
.value
[1] = snd_es18xx_mixer_read(chip
, 0x63) & 0x3f;
1060 #define snd_es18xx_info_hw_switch snd_ctl_boolean_stereo_info
1062 static int snd_es18xx_get_hw_switch(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1064 struct snd_es18xx
*chip
= snd_kcontrol_chip(kcontrol
);
1065 ucontrol
->value
.integer
.value
[0] = !(snd_es18xx_mixer_read(chip
, 0x61) & 0x40);
1066 ucontrol
->value
.integer
.value
[1] = !(snd_es18xx_mixer_read(chip
, 0x63) & 0x40);
1070 static void snd_es18xx_hwv_free(struct snd_kcontrol
*kcontrol
)
1072 struct snd_es18xx
*chip
= snd_kcontrol_chip(kcontrol
);
1073 chip
->master_volume
= NULL
;
1074 chip
->master_switch
= NULL
;
1075 chip
->hw_volume
= NULL
;
1076 chip
->hw_switch
= NULL
;
1079 static int snd_es18xx_reg_bits(struct snd_es18xx
*chip
, unsigned char reg
,
1080 unsigned char mask
, unsigned char val
)
1083 return snd_es18xx_mixer_bits(chip
, reg
, mask
, val
);
1085 return snd_es18xx_bits(chip
, reg
, mask
, val
);
1088 static int snd_es18xx_reg_read(struct snd_es18xx
*chip
, unsigned char reg
)
1091 return snd_es18xx_mixer_read(chip
, reg
);
1093 return snd_es18xx_read(chip
, reg
);
1096 #define ES18XX_SINGLE(xname, xindex, reg, shift, mask, flags) \
1097 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1098 .info = snd_es18xx_info_single, \
1099 .get = snd_es18xx_get_single, .put = snd_es18xx_put_single, \
1100 .private_value = reg | (shift << 8) | (mask << 16) | (flags << 24) }
1102 #define ES18XX_FL_INVERT (1 << 0)
1103 #define ES18XX_FL_PMPORT (1 << 1)
1105 static int snd_es18xx_info_single(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
1107 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
1109 uinfo
->type
= mask
== 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN
: SNDRV_CTL_ELEM_TYPE_INTEGER
;
1111 uinfo
->value
.integer
.min
= 0;
1112 uinfo
->value
.integer
.max
= mask
;
1116 static int snd_es18xx_get_single(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1118 struct snd_es18xx
*chip
= snd_kcontrol_chip(kcontrol
);
1119 int reg
= kcontrol
->private_value
& 0xff;
1120 int shift
= (kcontrol
->private_value
>> 8) & 0xff;
1121 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
1122 int invert
= (kcontrol
->private_value
>> 24) & ES18XX_FL_INVERT
;
1123 int pm_port
= (kcontrol
->private_value
>> 24) & ES18XX_FL_PMPORT
;
1127 val
= inb(chip
->port
+ ES18XX_PM
);
1129 val
= snd_es18xx_reg_read(chip
, reg
);
1130 ucontrol
->value
.integer
.value
[0] = (val
>> shift
) & mask
;
1132 ucontrol
->value
.integer
.value
[0] = mask
- ucontrol
->value
.integer
.value
[0];
1136 static int snd_es18xx_put_single(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1138 struct snd_es18xx
*chip
= snd_kcontrol_chip(kcontrol
);
1139 int reg
= kcontrol
->private_value
& 0xff;
1140 int shift
= (kcontrol
->private_value
>> 8) & 0xff;
1141 int mask
= (kcontrol
->private_value
>> 16) & 0xff;
1142 int invert
= (kcontrol
->private_value
>> 24) & ES18XX_FL_INVERT
;
1143 int pm_port
= (kcontrol
->private_value
>> 24) & ES18XX_FL_PMPORT
;
1146 val
= (ucontrol
->value
.integer
.value
[0] & mask
);
1152 unsigned char cur
= inb(chip
->port
+ ES18XX_PM
);
1154 if ((cur
& mask
) == val
)
1156 outb((cur
& ~mask
) | val
, chip
->port
+ ES18XX_PM
);
1160 return snd_es18xx_reg_bits(chip
, reg
, mask
, val
) != val
;
1163 #define ES18XX_DOUBLE(xname, xindex, left_reg, right_reg, shift_left, shift_right, mask, invert) \
1164 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
1165 .info = snd_es18xx_info_double, \
1166 .get = snd_es18xx_get_double, .put = snd_es18xx_put_double, \
1167 .private_value = left_reg | (right_reg << 8) | (shift_left << 16) | (shift_right << 19) | (mask << 24) | (invert << 22) }
1169 static int snd_es18xx_info_double(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
1171 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
1173 uinfo
->type
= mask
== 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN
: SNDRV_CTL_ELEM_TYPE_INTEGER
;
1175 uinfo
->value
.integer
.min
= 0;
1176 uinfo
->value
.integer
.max
= mask
;
1180 static int snd_es18xx_get_double(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1182 struct snd_es18xx
*chip
= snd_kcontrol_chip(kcontrol
);
1183 int left_reg
= kcontrol
->private_value
& 0xff;
1184 int right_reg
= (kcontrol
->private_value
>> 8) & 0xff;
1185 int shift_left
= (kcontrol
->private_value
>> 16) & 0x07;
1186 int shift_right
= (kcontrol
->private_value
>> 19) & 0x07;
1187 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
1188 int invert
= (kcontrol
->private_value
>> 22) & 1;
1189 unsigned char left
, right
;
1191 left
= snd_es18xx_reg_read(chip
, left_reg
);
1192 if (left_reg
!= right_reg
)
1193 right
= snd_es18xx_reg_read(chip
, right_reg
);
1196 ucontrol
->value
.integer
.value
[0] = (left
>> shift_left
) & mask
;
1197 ucontrol
->value
.integer
.value
[1] = (right
>> shift_right
) & mask
;
1199 ucontrol
->value
.integer
.value
[0] = mask
- ucontrol
->value
.integer
.value
[0];
1200 ucontrol
->value
.integer
.value
[1] = mask
- ucontrol
->value
.integer
.value
[1];
1205 static int snd_es18xx_put_double(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
1207 struct snd_es18xx
*chip
= snd_kcontrol_chip(kcontrol
);
1208 int left_reg
= kcontrol
->private_value
& 0xff;
1209 int right_reg
= (kcontrol
->private_value
>> 8) & 0xff;
1210 int shift_left
= (kcontrol
->private_value
>> 16) & 0x07;
1211 int shift_right
= (kcontrol
->private_value
>> 19) & 0x07;
1212 int mask
= (kcontrol
->private_value
>> 24) & 0xff;
1213 int invert
= (kcontrol
->private_value
>> 22) & 1;
1215 unsigned char val1
, val2
, mask1
, mask2
;
1217 val1
= ucontrol
->value
.integer
.value
[0] & mask
;
1218 val2
= ucontrol
->value
.integer
.value
[1] & mask
;
1223 val1
<<= shift_left
;
1224 val2
<<= shift_right
;
1225 mask1
= mask
<< shift_left
;
1226 mask2
= mask
<< shift_right
;
1227 if (left_reg
!= right_reg
) {
1229 if (snd_es18xx_reg_bits(chip
, left_reg
, mask1
, val1
) != val1
)
1231 if (snd_es18xx_reg_bits(chip
, right_reg
, mask2
, val2
) != val2
)
1234 change
= (snd_es18xx_reg_bits(chip
, left_reg
, mask1
| mask2
,
1235 val1
| val2
) != (val1
| val2
));
1241 * These arrays contain setup data for mixer controls.
1243 * The controls that are universal to all chipsets are fully initialized
1246 static const struct snd_kcontrol_new snd_es18xx_base_controls
[] = {
1247 ES18XX_DOUBLE("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0),
1248 ES18XX_DOUBLE("Master Playback Switch", 0, 0x60, 0x62, 6, 6, 1, 1),
1249 ES18XX_DOUBLE("Line Playback Volume", 0, 0x3e, 0x3e, 4, 0, 15, 0),
1250 ES18XX_DOUBLE("CD Playback Volume", 0, 0x38, 0x38, 4, 0, 15, 0),
1251 ES18XX_DOUBLE("FM Playback Volume", 0, 0x36, 0x36, 4, 0, 15, 0),
1252 ES18XX_DOUBLE("Mic Playback Volume", 0, 0x1a, 0x1a, 4, 0, 15, 0),
1253 ES18XX_DOUBLE("Aux Playback Volume", 0, 0x3a, 0x3a, 4, 0, 15, 0),
1254 ES18XX_SINGLE("Record Monitor", 0, 0xa8, 3, 1, 0),
1255 ES18XX_DOUBLE("Capture Volume", 0, 0xb4, 0xb4, 4, 0, 15, 0),
1257 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1258 .name
= "Capture Source",
1259 .info
= snd_es18xx_info_mux
,
1260 .get
= snd_es18xx_get_mux
,
1261 .put
= snd_es18xx_put_mux
,
1265 static const struct snd_kcontrol_new snd_es18xx_recmix_controls
[] = {
1266 ES18XX_DOUBLE("PCM Capture Volume", 0, 0x69, 0x69, 4, 0, 15, 0),
1267 ES18XX_DOUBLE("Mic Capture Volume", 0, 0x68, 0x68, 4, 0, 15, 0),
1268 ES18XX_DOUBLE("Line Capture Volume", 0, 0x6e, 0x6e, 4, 0, 15, 0),
1269 ES18XX_DOUBLE("FM Capture Volume", 0, 0x6b, 0x6b, 4, 0, 15, 0),
1270 ES18XX_DOUBLE("CD Capture Volume", 0, 0x6a, 0x6a, 4, 0, 15, 0),
1271 ES18XX_DOUBLE("Aux Capture Volume", 0, 0x6c, 0x6c, 4, 0, 15, 0)
1275 * The chipset specific mixer controls
1277 static const struct snd_kcontrol_new snd_es18xx_opt_speaker
=
1278 ES18XX_SINGLE("Beep Playback Volume", 0, 0x3c, 0, 7, 0);
1280 static const struct snd_kcontrol_new snd_es18xx_opt_1869
[] = {
1281 ES18XX_SINGLE("Capture Switch", 0, 0x1c, 4, 1, ES18XX_FL_INVERT
),
1282 ES18XX_SINGLE("Video Playback Switch", 0, 0x7f, 0, 1, 0),
1283 ES18XX_DOUBLE("Mono Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1284 ES18XX_DOUBLE("Mono Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0)
1287 static const struct snd_kcontrol_new snd_es18xx_opt_1878
=
1288 ES18XX_DOUBLE("Video Playback Volume", 0, 0x68, 0x68, 4, 0, 15, 0);
1290 static const struct snd_kcontrol_new snd_es18xx_opt_1879
[] = {
1291 ES18XX_SINGLE("Video Playback Switch", 0, 0x71, 6, 1, 0),
1292 ES18XX_DOUBLE("Video Playback Volume", 0, 0x6d, 0x6d, 4, 0, 15, 0),
1293 ES18XX_DOUBLE("Video Capture Volume", 0, 0x6f, 0x6f, 4, 0, 15, 0)
1296 static const struct snd_kcontrol_new snd_es18xx_pcm1_controls
[] = {
1297 ES18XX_DOUBLE("PCM Playback Volume", 0, 0x14, 0x14, 4, 0, 15, 0),
1300 static const struct snd_kcontrol_new snd_es18xx_pcm2_controls
[] = {
1301 ES18XX_DOUBLE("PCM Playback Volume", 0, 0x7c, 0x7c, 4, 0, 15, 0),
1302 ES18XX_DOUBLE("PCM Playback Volume", 1, 0x14, 0x14, 4, 0, 15, 0)
1305 static const struct snd_kcontrol_new snd_es18xx_spatializer_controls
[] = {
1306 ES18XX_SINGLE("3D Control - Level", 0, 0x52, 0, 63, 0),
1308 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1309 .name
= "3D Control - Switch",
1310 .info
= snd_es18xx_info_spatializer_enable
,
1311 .get
= snd_es18xx_get_spatializer_enable
,
1312 .put
= snd_es18xx_put_spatializer_enable
,
1316 static const struct snd_kcontrol_new snd_es18xx_micpre1_control
=
1317 ES18XX_SINGLE("Mic Boost (+26dB)", 0, 0xa9, 2, 1, 0);
1319 static const struct snd_kcontrol_new snd_es18xx_micpre2_control
=
1320 ES18XX_SINGLE("Mic Boost (+26dB)", 0, 0x7d, 3, 1, 0);
1322 static const struct snd_kcontrol_new snd_es18xx_hw_volume_controls
[] = {
1324 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1325 .name
= "Hardware Master Playback Volume",
1326 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
1327 .info
= snd_es18xx_info_hw_volume
,
1328 .get
= snd_es18xx_get_hw_volume
,
1331 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
1332 .name
= "Hardware Master Playback Switch",
1333 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
1334 .info
= snd_es18xx_info_hw_switch
,
1335 .get
= snd_es18xx_get_hw_switch
,
1337 ES18XX_SINGLE("Hardware Master Volume Split", 0, 0x64, 7, 1, 0),
1340 static const struct snd_kcontrol_new snd_es18xx_opt_gpo_2bit
[] = {
1341 ES18XX_SINGLE("GPO0 Switch", 0, ES18XX_PM
, 0, 1, ES18XX_FL_PMPORT
),
1342 ES18XX_SINGLE("GPO1 Switch", 0, ES18XX_PM
, 1, 1, ES18XX_FL_PMPORT
),
1345 static int snd_es18xx_config_read(struct snd_es18xx
*chip
, unsigned char reg
)
1349 outb(reg
, chip
->ctrl_port
);
1350 data
= inb(chip
->ctrl_port
+ 1);
1354 static void snd_es18xx_config_write(struct snd_es18xx
*chip
,
1355 unsigned char reg
, unsigned char data
)
1357 /* No need for spinlocks, this function is used only in
1358 otherwise protected init code */
1359 outb(reg
, chip
->ctrl_port
);
1360 outb(data
, chip
->ctrl_port
+ 1);
1362 snd_printk(KERN_DEBUG
"Config reg %02x set to %02x\n", reg
, data
);
1366 static int snd_es18xx_initialize(struct snd_es18xx
*chip
,
1367 unsigned long mpu_port
,
1368 unsigned long fm_port
)
1372 /* enable extended mode */
1373 snd_es18xx_dsp_command(chip
, 0xC6);
1374 /* Reset mixer registers */
1375 snd_es18xx_mixer_write(chip
, 0x00, 0x00);
1377 /* Audio 1 DMA demand mode (4 bytes/request) */
1378 snd_es18xx_write(chip
, 0xB9, 2);
1379 if (chip
->caps
& ES18XX_CONTROL
) {
1380 /* Hardware volume IRQ */
1381 snd_es18xx_config_write(chip
, 0x27, chip
->irq
);
1382 if (fm_port
> 0 && fm_port
!= SNDRV_AUTO_PORT
) {
1384 snd_es18xx_config_write(chip
, 0x62, fm_port
>> 8);
1385 snd_es18xx_config_write(chip
, 0x63, fm_port
& 0xff);
1387 if (mpu_port
> 0 && mpu_port
!= SNDRV_AUTO_PORT
) {
1389 snd_es18xx_config_write(chip
, 0x64, mpu_port
>> 8);
1390 snd_es18xx_config_write(chip
, 0x65, mpu_port
& 0xff);
1392 snd_es18xx_config_write(chip
, 0x28, chip
->irq
);
1395 snd_es18xx_config_write(chip
, 0x70, chip
->irq
);
1397 snd_es18xx_config_write(chip
, 0x72, chip
->irq
);
1399 snd_es18xx_config_write(chip
, 0x74, chip
->dma1
);
1401 snd_es18xx_config_write(chip
, 0x75, chip
->dma2
);
1403 /* Enable Audio 1 IRQ */
1404 snd_es18xx_write(chip
, 0xB1, 0x50);
1405 /* Enable Audio 2 IRQ */
1406 snd_es18xx_mixer_write(chip
, 0x7A, 0x40);
1407 /* Enable Audio 1 DMA */
1408 snd_es18xx_write(chip
, 0xB2, 0x50);
1409 /* Enable MPU and hardware volume interrupt */
1410 snd_es18xx_mixer_write(chip
, 0x64, 0x42);
1411 /* Enable ESS wavetable input */
1412 snd_es18xx_mixer_bits(chip
, 0x48, 0x10, 0x10);
1415 int irqmask
, dma1mask
, dma2mask
;
1416 switch (chip
->irq
) {
1431 snd_printk(KERN_ERR
"invalid irq %d\n", chip
->irq
);
1434 switch (chip
->dma1
) {
1445 snd_printk(KERN_ERR
"invalid dma1 %d\n", chip
->dma1
);
1448 switch (chip
->dma2
) {
1462 snd_printk(KERN_ERR
"invalid dma2 %d\n", chip
->dma2
);
1466 /* Enable and set Audio 1 IRQ */
1467 snd_es18xx_write(chip
, 0xB1, 0x50 | (irqmask
<< 2));
1468 /* Enable and set Audio 1 DMA */
1469 snd_es18xx_write(chip
, 0xB2, 0x50 | (dma1mask
<< 2));
1470 /* Set Audio 2 DMA */
1471 snd_es18xx_mixer_bits(chip
, 0x7d, 0x07, 0x04 | dma2mask
);
1472 /* Enable Audio 2 IRQ and DMA
1473 Set capture mixer input */
1474 snd_es18xx_mixer_write(chip
, 0x7A, 0x68);
1475 /* Enable and set hardware volume interrupt */
1476 snd_es18xx_mixer_write(chip
, 0x64, 0x06);
1477 if (mpu_port
> 0 && mpu_port
!= SNDRV_AUTO_PORT
) {
1478 /* MPU401 share irq with audio
1481 snd_es18xx_mixer_write(chip
, 0x40,
1482 0x43 | (mpu_port
& 0xf0) >> 1);
1484 snd_es18xx_mixer_write(chip
, 0x7f, ((irqmask
+ 1) << 1) | 0x01);
1486 if (chip
->caps
& ES18XX_NEW_RATE
) {
1487 /* Change behaviour of register A1
1489 2nd channel DAC asynchronous */
1490 snd_es18xx_mixer_write(chip
, 0x71, 0x32);
1492 if (!(chip
->caps
& ES18XX_PCM2
)) {
1493 /* Enable DMA FIFO */
1494 snd_es18xx_write(chip
, 0xB7, 0x80);
1496 if (chip
->caps
& ES18XX_SPATIALIZER
) {
1497 /* Set spatializer parameters to recommended values */
1498 snd_es18xx_mixer_write(chip
, 0x54, 0x8f);
1499 snd_es18xx_mixer_write(chip
, 0x56, 0x95);
1500 snd_es18xx_mixer_write(chip
, 0x58, 0x94);
1501 snd_es18xx_mixer_write(chip
, 0x5a, 0x80);
1503 /* Flip the "enable I2S" bits for those chipsets that need it */
1504 switch (chip
->version
) {
1506 //Leaving I2S enabled on the 1879 screws up the PCM playback (rate effected somehow)
1507 //so a Switch control has been added to toggle this 0x71 bit on/off:
1508 //snd_es18xx_mixer_bits(chip, 0x71, 0x40, 0x40);
1509 /* Note: we fall through on purpose here. */
1511 snd_es18xx_config_write(chip
, 0x29, snd_es18xx_config_read(chip
, 0x29) | 0x40);
1514 /* Mute input source */
1515 if (chip
->caps
& ES18XX_MUTEREC
)
1517 if (chip
->caps
& ES18XX_RECMIX
)
1518 snd_es18xx_mixer_write(chip
, 0x1c, 0x05 | mask
);
1520 snd_es18xx_mixer_write(chip
, 0x1c, 0x00 | mask
);
1521 snd_es18xx_write(chip
, 0xb4, 0x00);
1524 /* Enable PCM output */
1525 snd_es18xx_dsp_command(chip
, 0xD1);
1531 static int snd_es18xx_identify(struct snd_card
*card
, struct snd_es18xx
*chip
)
1536 if (snd_es18xx_reset(chip
) < 0) {
1537 snd_printk(KERN_ERR
"reset at 0x%lx failed!!!\n", chip
->port
);
1541 snd_es18xx_dsp_command(chip
, 0xe7);
1542 hi
= snd_es18xx_dsp_get_byte(chip
);
1546 lo
= snd_es18xx_dsp_get_byte(chip
);
1547 if ((lo
& 0xf0) != 0x80) {
1551 chip
->version
= 0x488;
1557 if ((lo
& 0x0f) < 8) {
1558 chip
->version
= 0x688;
1562 outb(0x40, chip
->port
+ 0x04);
1564 hi
= inb(chip
->port
+ 0x05);
1566 lo
= inb(chip
->port
+ 0x05);
1568 chip
->version
= hi
<< 8 | lo
;
1569 chip
->ctrl_port
= inb(chip
->port
+ 0x05) << 8;
1571 chip
->ctrl_port
+= inb(chip
->port
+ 0x05);
1573 if (!devm_request_region(card
->dev
, chip
->ctrl_port
, 8,
1575 snd_printk(KERN_ERR PFX
"unable go grab port 0x%lx\n", chip
->ctrl_port
);
1582 /* If has Hardware volume */
1583 if (snd_es18xx_mixer_writable(chip
, 0x64, 0x04)) {
1585 if (snd_es18xx_mixer_writable(chip
, 0x70, 0x7f)) {
1586 /* If has volume count */
1587 if (snd_es18xx_mixer_writable(chip
, 0x64, 0x20)) {
1588 chip
->version
= 0x1887;
1590 chip
->version
= 0x1888;
1593 chip
->version
= 0x1788;
1597 chip
->version
= 0x1688;
1601 static int snd_es18xx_probe(struct snd_card
*card
,
1602 struct snd_es18xx
*chip
,
1603 unsigned long mpu_port
,
1604 unsigned long fm_port
)
1606 if (snd_es18xx_identify(card
, chip
) < 0) {
1607 snd_printk(KERN_ERR PFX
"[0x%lx] ESS chip not found\n", chip
->port
);
1611 switch (chip
->version
) {
1613 chip
->caps
= ES18XX_DUPLEX_MONO
| ES18XX_DUPLEX_SAME
| ES18XX_CONTROL
| ES18XX_GPO_2BIT
;
1616 chip
->caps
= ES18XX_PCM2
| ES18XX_SPATIALIZER
| ES18XX_RECMIX
| ES18XX_NEW_RATE
| ES18XX_AUXB
| ES18XX_MONO
| ES18XX_MUTEREC
| ES18XX_CONTROL
| ES18XX_HWV
| ES18XX_GPO_2BIT
;
1619 chip
->caps
= ES18XX_DUPLEX_MONO
| ES18XX_DUPLEX_SAME
| ES18XX_I2S
| ES18XX_CONTROL
;
1622 chip
->caps
= ES18XX_PCM2
| ES18XX_SPATIALIZER
| ES18XX_RECMIX
| ES18XX_NEW_RATE
| ES18XX_AUXB
| ES18XX_I2S
| ES18XX_CONTROL
| ES18XX_HWV
;
1626 chip
->caps
= ES18XX_PCM2
| ES18XX_RECMIX
| ES18XX_AUXB
| ES18XX_DUPLEX_SAME
| ES18XX_GPO_2BIT
;
1629 snd_printk(KERN_ERR
"[0x%lx] unsupported chip ES%x\n",
1630 chip
->port
, chip
->version
);
1634 snd_printd("[0x%lx] ESS%x chip found\n", chip
->port
, chip
->version
);
1636 if (chip
->dma1
== chip
->dma2
)
1637 chip
->caps
&= ~(ES18XX_PCM2
| ES18XX_DUPLEX_SAME
);
1639 return snd_es18xx_initialize(chip
, mpu_port
, fm_port
);
1642 static const struct snd_pcm_ops snd_es18xx_playback_ops
= {
1643 .open
= snd_es18xx_playback_open
,
1644 .close
= snd_es18xx_playback_close
,
1645 .hw_params
= snd_es18xx_playback_hw_params
,
1646 .prepare
= snd_es18xx_playback_prepare
,
1647 .trigger
= snd_es18xx_playback_trigger
,
1648 .pointer
= snd_es18xx_playback_pointer
,
1651 static const struct snd_pcm_ops snd_es18xx_capture_ops
= {
1652 .open
= snd_es18xx_capture_open
,
1653 .close
= snd_es18xx_capture_close
,
1654 .hw_params
= snd_es18xx_capture_hw_params
,
1655 .prepare
= snd_es18xx_capture_prepare
,
1656 .trigger
= snd_es18xx_capture_trigger
,
1657 .pointer
= snd_es18xx_capture_pointer
,
1660 static int snd_es18xx_pcm(struct snd_card
*card
, int device
)
1662 struct snd_es18xx
*chip
= card
->private_data
;
1663 struct snd_pcm
*pcm
;
1667 sprintf(str
, "ES%x", chip
->version
);
1668 if (chip
->caps
& ES18XX_PCM2
)
1669 err
= snd_pcm_new(card
, str
, device
, 2, 1, &pcm
);
1671 err
= snd_pcm_new(card
, str
, device
, 1, 1, &pcm
);
1675 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_es18xx_playback_ops
);
1676 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_es18xx_capture_ops
);
1679 pcm
->private_data
= chip
;
1680 pcm
->info_flags
= 0;
1681 if (chip
->caps
& ES18XX_DUPLEX_SAME
)
1682 pcm
->info_flags
|= SNDRV_PCM_INFO_JOINT_DUPLEX
;
1683 if (! (chip
->caps
& ES18XX_PCM2
))
1684 pcm
->info_flags
|= SNDRV_PCM_INFO_HALF_DUPLEX
;
1685 sprintf(pcm
->name
, "ESS AudioDrive ES%x", chip
->version
);
1688 snd_pcm_set_managed_buffer_all(pcm
, SNDRV_DMA_TYPE_DEV
, card
->dev
,
1690 chip
->dma1
> 3 || chip
->dma2
> 3 ? 128*1024 : 64*1024);
1694 /* Power Management support functions */
1696 static int snd_es18xx_suspend(struct snd_card
*card
, pm_message_t state
)
1698 struct snd_es18xx
*chip
= card
->private_data
;
1700 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
1703 chip
->pm_reg
= (unsigned char)snd_es18xx_read(chip
, ES18XX_PM
);
1704 chip
->pm_reg
|= (ES18XX_PM_FM
| ES18XX_PM_SUS
);
1705 snd_es18xx_write(chip
, ES18XX_PM
, chip
->pm_reg
);
1706 snd_es18xx_write(chip
, ES18XX_PM
, chip
->pm_reg
^= ES18XX_PM_SUS
);
1711 static int snd_es18xx_resume(struct snd_card
*card
)
1713 struct snd_es18xx
*chip
= card
->private_data
;
1715 /* restore PM register, we won't wake till (not 0x07) i/o activity though */
1716 snd_es18xx_write(chip
, ES18XX_PM
, chip
->pm_reg
^= ES18XX_PM_FM
);
1718 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
1721 #endif /* CONFIG_PM */
1723 static int snd_es18xx_new_device(struct snd_card
*card
,
1725 unsigned long mpu_port
,
1726 unsigned long fm_port
,
1727 int irq
, int dma1
, int dma2
)
1729 struct snd_es18xx
*chip
= card
->private_data
;
1731 spin_lock_init(&chip
->reg_lock
);
1732 spin_lock_init(&chip
->mixer_lock
);
1737 chip
->audio2_vol
= 0x00;
1740 if (!devm_request_region(card
->dev
, port
, 16, "ES18xx")) {
1741 snd_printk(KERN_ERR PFX
"unable to grap ports 0x%lx-0x%lx\n", port
, port
+ 16 - 1);
1745 if (devm_request_irq(card
->dev
, irq
, snd_es18xx_interrupt
, 0, "ES18xx",
1747 snd_printk(KERN_ERR PFX
"unable to grap IRQ %d\n", irq
);
1751 card
->sync_irq
= chip
->irq
;
1753 if (snd_devm_request_dma(card
->dev
, dma1
, "ES18xx DMA 1")) {
1754 snd_printk(KERN_ERR PFX
"unable to grap DMA1 %d\n", dma1
);
1760 snd_devm_request_dma(card
->dev
, dma2
, "ES18xx DMA 2")) {
1761 snd_printk(KERN_ERR PFX
"unable to grap DMA2 %d\n", dma2
);
1766 if (snd_es18xx_probe(card
, chip
, mpu_port
, fm_port
) < 0)
1771 static int snd_es18xx_mixer(struct snd_card
*card
)
1773 struct snd_es18xx
*chip
= card
->private_data
;
1777 strcpy(card
->mixername
, chip
->pcm
->name
);
1779 for (idx
= 0; idx
< ARRAY_SIZE(snd_es18xx_base_controls
); idx
++) {
1780 struct snd_kcontrol
*kctl
;
1781 kctl
= snd_ctl_new1(&snd_es18xx_base_controls
[idx
], chip
);
1782 if (chip
->caps
& ES18XX_HWV
) {
1785 chip
->master_volume
= kctl
;
1786 kctl
->private_free
= snd_es18xx_hwv_free
;
1789 chip
->master_switch
= kctl
;
1790 kctl
->private_free
= snd_es18xx_hwv_free
;
1794 err
= snd_ctl_add(card
, kctl
);
1798 if (chip
->caps
& ES18XX_PCM2
) {
1799 for (idx
= 0; idx
< ARRAY_SIZE(snd_es18xx_pcm2_controls
); idx
++) {
1800 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_es18xx_pcm2_controls
[idx
], chip
));
1805 for (idx
= 0; idx
< ARRAY_SIZE(snd_es18xx_pcm1_controls
); idx
++) {
1806 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_es18xx_pcm1_controls
[idx
], chip
));
1812 if (chip
->caps
& ES18XX_RECMIX
) {
1813 for (idx
= 0; idx
< ARRAY_SIZE(snd_es18xx_recmix_controls
); idx
++) {
1814 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_es18xx_recmix_controls
[idx
], chip
));
1819 switch (chip
->version
) {
1821 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_es18xx_micpre1_control
, chip
));
1827 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_es18xx_micpre2_control
, chip
));
1832 if (chip
->caps
& ES18XX_SPATIALIZER
) {
1833 for (idx
= 0; idx
< ARRAY_SIZE(snd_es18xx_spatializer_controls
); idx
++) {
1834 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_es18xx_spatializer_controls
[idx
], chip
));
1839 if (chip
->caps
& ES18XX_HWV
) {
1840 for (idx
= 0; idx
< ARRAY_SIZE(snd_es18xx_hw_volume_controls
); idx
++) {
1841 struct snd_kcontrol
*kctl
;
1842 kctl
= snd_ctl_new1(&snd_es18xx_hw_volume_controls
[idx
], chip
);
1844 chip
->hw_volume
= kctl
;
1846 chip
->hw_switch
= kctl
;
1847 kctl
->private_free
= snd_es18xx_hwv_free
;
1848 err
= snd_ctl_add(card
, kctl
);
1854 /* finish initializing other chipset specific controls
1856 if (chip
->version
!= 0x1868) {
1857 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_es18xx_opt_speaker
,
1862 if (chip
->version
== 0x1869) {
1863 for (idx
= 0; idx
< ARRAY_SIZE(snd_es18xx_opt_1869
); idx
++) {
1864 err
= snd_ctl_add(card
,
1865 snd_ctl_new1(&snd_es18xx_opt_1869
[idx
],
1870 } else if (chip
->version
== 0x1878) {
1871 err
= snd_ctl_add(card
, snd_ctl_new1(&snd_es18xx_opt_1878
,
1875 } else if (chip
->version
== 0x1879) {
1876 for (idx
= 0; idx
< ARRAY_SIZE(snd_es18xx_opt_1879
); idx
++) {
1877 err
= snd_ctl_add(card
,
1878 snd_ctl_new1(&snd_es18xx_opt_1879
[idx
],
1884 if (chip
->caps
& ES18XX_GPO_2BIT
) {
1885 for (idx
= 0; idx
< ARRAY_SIZE(snd_es18xx_opt_gpo_2bit
); idx
++) {
1886 err
= snd_ctl_add(card
,
1887 snd_ctl_new1(&snd_es18xx_opt_gpo_2bit
[idx
],
1899 MODULE_AUTHOR("Christian Fischbach <fishbach@pool.informatik.rwth-aachen.de>, Abramo Bagnara <abramo@alsa-project.org>");
1900 MODULE_DESCRIPTION("ESS ES18xx AudioDrive");
1901 MODULE_LICENSE("GPL");
1903 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
1904 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
1905 static bool enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_ISAPNP
; /* Enable this card */
1907 static bool isapnp
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_ISAPNP
;
1909 static long port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
; /* 0x220,0x240,0x260,0x280 */
1911 static long mpu_port
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
- 1)] = -1};
1913 static long mpu_port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
;
1915 static long fm_port
[SNDRV_CARDS
] = SNDRV_DEFAULT_PORT
;
1916 static int irq
[SNDRV_CARDS
] = SNDRV_DEFAULT_IRQ
; /* 5,7,9,10 */
1917 static int dma1
[SNDRV_CARDS
] = SNDRV_DEFAULT_DMA
; /* 0,1,3 */
1918 static int dma2
[SNDRV_CARDS
] = SNDRV_DEFAULT_DMA
; /* 0,1,3 */
1920 module_param_array(index
, int, NULL
, 0444);
1921 MODULE_PARM_DESC(index
, "Index value for ES18xx soundcard.");
1922 module_param_array(id
, charp
, NULL
, 0444);
1923 MODULE_PARM_DESC(id
, "ID string for ES18xx soundcard.");
1924 module_param_array(enable
, bool, NULL
, 0444);
1925 MODULE_PARM_DESC(enable
, "Enable ES18xx soundcard.");
1927 module_param_array(isapnp
, bool, NULL
, 0444);
1928 MODULE_PARM_DESC(isapnp
, "PnP detection for specified soundcard.");
1930 module_param_hw_array(port
, long, ioport
, NULL
, 0444);
1931 MODULE_PARM_DESC(port
, "Port # for ES18xx driver.");
1932 module_param_hw_array(mpu_port
, long, ioport
, NULL
, 0444);
1933 MODULE_PARM_DESC(mpu_port
, "MPU-401 port # for ES18xx driver.");
1934 module_param_hw_array(fm_port
, long, ioport
, NULL
, 0444);
1935 MODULE_PARM_DESC(fm_port
, "FM port # for ES18xx driver.");
1936 module_param_hw_array(irq
, int, irq
, NULL
, 0444);
1937 MODULE_PARM_DESC(irq
, "IRQ # for ES18xx driver.");
1938 module_param_hw_array(dma1
, int, dma
, NULL
, 0444);
1939 MODULE_PARM_DESC(dma1
, "DMA 1 # for ES18xx driver.");
1940 module_param_hw_array(dma2
, int, dma
, NULL
, 0444);
1941 MODULE_PARM_DESC(dma2
, "DMA 2 # for ES18xx driver.");
1944 static int isa_registered
;
1945 static int pnp_registered
;
1946 static int pnpc_registered
;
1948 static const struct pnp_device_id snd_audiodrive_pnpbiosids
[] = {
1949 { .id
= "ESS1869" },
1950 { .id
= "ESS1879" },
1951 { .id
= "" } /* end */
1954 MODULE_DEVICE_TABLE(pnp
, snd_audiodrive_pnpbiosids
);
1956 /* PnP main device initialization */
1957 static int snd_audiodrive_pnp_init_main(int dev
, struct pnp_dev
*pdev
)
1959 if (pnp_activate_dev(pdev
) < 0) {
1960 snd_printk(KERN_ERR PFX
"PnP configure failure (out of resources?)\n");
1963 /* ok. hack using Vendor-Defined Card-Level registers */
1964 /* skip csn and logdev initialization - already done in isapnp_configure */
1965 if (pnp_device_is_isapnp(pdev
)) {
1966 isapnp_cfg_begin(isapnp_card_number(pdev
), isapnp_csn_number(pdev
));
1967 isapnp_write_byte(0x27, pnp_irq(pdev
, 0)); /* Hardware Volume IRQ Number */
1968 if (mpu_port
[dev
] != SNDRV_AUTO_PORT
)
1969 isapnp_write_byte(0x28, pnp_irq(pdev
, 0)); /* MPU-401 IRQ Number */
1970 isapnp_write_byte(0x72, pnp_irq(pdev
, 0)); /* second IRQ */
1973 port
[dev
] = pnp_port_start(pdev
, 0);
1974 fm_port
[dev
] = pnp_port_start(pdev
, 1);
1975 mpu_port
[dev
] = pnp_port_start(pdev
, 2);
1976 dma1
[dev
] = pnp_dma(pdev
, 0);
1977 dma2
[dev
] = pnp_dma(pdev
, 1);
1978 irq
[dev
] = pnp_irq(pdev
, 0);
1979 snd_printdd("PnP ES18xx: port=0x%lx, fm port=0x%lx, mpu port=0x%lx\n", port
[dev
], fm_port
[dev
], mpu_port
[dev
]);
1980 snd_printdd("PnP ES18xx: dma1=%i, dma2=%i, irq=%i\n", dma1
[dev
], dma2
[dev
], irq
[dev
]);
1984 static int snd_audiodrive_pnp(int dev
, struct snd_es18xx
*chip
,
1985 struct pnp_dev
*pdev
)
1988 if (snd_audiodrive_pnp_init_main(dev
, chip
->dev
) < 0)
1993 static const struct pnp_card_device_id snd_audiodrive_pnpids
[] = {
1994 /* ESS 1868 (integrated on Compaq dual P-Pro motherboard and Genius 18PnP 3D) */
1995 { .id
= "ESS1868", .devs
= { { "ESS1868" }, { "ESS0000" } } },
1996 /* ESS 1868 (integrated on Maxisound Cards) */
1997 { .id
= "ESS1868", .devs
= { { "ESS8601" }, { "ESS8600" } } },
1998 /* ESS 1868 (integrated on Maxisound Cards) */
1999 { .id
= "ESS1868", .devs
= { { "ESS8611" }, { "ESS8610" } } },
2000 /* ESS ES1869 Plug and Play AudioDrive */
2001 { .id
= "ESS0003", .devs
= { { "ESS1869" }, { "ESS0006" } } },
2003 { .id
= "ESS1869", .devs
= { { "ESS1869" }, { "ESS0006" } } },
2005 { .id
= "ESS1878", .devs
= { { "ESS1878" }, { "ESS0004" } } },
2007 { .id
= "ESS1879", .devs
= { { "ESS1879" }, { "ESS0009" } } },
2009 { .id
= "" } /* end */
2012 MODULE_DEVICE_TABLE(pnp_card
, snd_audiodrive_pnpids
);
2014 static int snd_audiodrive_pnpc(int dev
, struct snd_es18xx
*chip
,
2015 struct pnp_card_link
*card
,
2016 const struct pnp_card_device_id
*id
)
2018 chip
->dev
= pnp_request_card_device(card
, id
->devs
[0].id
, NULL
);
2019 if (chip
->dev
== NULL
)
2022 chip
->devc
= pnp_request_card_device(card
, id
->devs
[1].id
, NULL
);
2023 if (chip
->devc
== NULL
)
2026 /* Control port initialization */
2027 if (pnp_activate_dev(chip
->devc
) < 0) {
2028 snd_printk(KERN_ERR PFX
"PnP control configure failure (out of resources?)\n");
2031 snd_printdd("pnp: port=0x%llx\n",
2032 (unsigned long long)pnp_port_start(chip
->devc
, 0));
2033 if (snd_audiodrive_pnp_init_main(dev
, chip
->dev
) < 0)
2038 #endif /* CONFIG_PNP */
2041 #define is_isapnp_selected(dev) isapnp[dev]
2043 #define is_isapnp_selected(dev) 0
2046 static int snd_es18xx_card_new(struct device
*pdev
, int dev
,
2047 struct snd_card
**cardp
)
2049 return snd_devm_card_new(pdev
, index
[dev
], id
[dev
], THIS_MODULE
,
2050 sizeof(struct snd_es18xx
), cardp
);
2053 static int snd_audiodrive_probe(struct snd_card
*card
, int dev
)
2055 struct snd_es18xx
*chip
= card
->private_data
;
2056 struct snd_opl3
*opl3
;
2059 err
= snd_es18xx_new_device(card
,
2060 port
[dev
], mpu_port
[dev
], fm_port
[dev
],
2061 irq
[dev
], dma1
[dev
], dma2
[dev
]);
2065 sprintf(card
->driver
, "ES%x", chip
->version
);
2067 sprintf(card
->shortname
, "ESS AudioDrive ES%x", chip
->version
);
2068 if (dma1
[dev
] != dma2
[dev
])
2069 sprintf(card
->longname
, "%s at 0x%lx, irq %d, dma1 %d, dma2 %d",
2072 irq
[dev
], dma1
[dev
], dma2
[dev
]);
2074 sprintf(card
->longname
, "%s at 0x%lx, irq %d, dma %d",
2077 irq
[dev
], dma1
[dev
]);
2079 err
= snd_es18xx_pcm(card
, 0);
2083 err
= snd_es18xx_mixer(card
);
2087 if (fm_port
[dev
] > 0 && fm_port
[dev
] != SNDRV_AUTO_PORT
) {
2088 if (snd_opl3_create(card
, fm_port
[dev
], fm_port
[dev
] + 2,
2089 OPL3_HW_OPL3
, 0, &opl3
) < 0) {
2090 snd_printk(KERN_WARNING PFX
2091 "opl3 not detected at 0x%lx\n",
2094 err
= snd_opl3_hwdep_new(opl3
, 0, 1, NULL
);
2100 if (mpu_port
[dev
] > 0 && mpu_port
[dev
] != SNDRV_AUTO_PORT
) {
2101 err
= snd_mpu401_uart_new(card
, 0, MPU401_HW_ES18XX
,
2102 mpu_port
[dev
], MPU401_INFO_IRQ_HOOK
,
2108 return snd_card_register(card
);
2111 static int snd_es18xx_isa_match(struct device
*pdev
, unsigned int dev
)
2113 return enable
[dev
] && !is_isapnp_selected(dev
);
2116 static int snd_es18xx_isa_probe1(int dev
, struct device
*devptr
)
2118 struct snd_card
*card
;
2121 err
= snd_es18xx_card_new(devptr
, dev
, &card
);
2124 err
= snd_audiodrive_probe(card
, dev
);
2127 dev_set_drvdata(devptr
, card
);
2131 static int snd_es18xx_isa_probe(struct device
*pdev
, unsigned int dev
)
2134 static const int possible_irqs
[] = {5, 9, 10, 7, 11, 12, -1};
2135 static const int possible_dmas
[] = {1, 0, 3, 5, -1};
2137 if (irq
[dev
] == SNDRV_AUTO_IRQ
) {
2138 irq
[dev
] = snd_legacy_find_free_irq(possible_irqs
);
2140 snd_printk(KERN_ERR PFX
"unable to find a free IRQ\n");
2144 if (dma1
[dev
] == SNDRV_AUTO_DMA
) {
2145 dma1
[dev
] = snd_legacy_find_free_dma(possible_dmas
);
2146 if (dma1
[dev
] < 0) {
2147 snd_printk(KERN_ERR PFX
"unable to find a free DMA1\n");
2151 if (dma2
[dev
] == SNDRV_AUTO_DMA
) {
2152 dma2
[dev
] = snd_legacy_find_free_dma(possible_dmas
);
2153 if (dma2
[dev
] < 0) {
2154 snd_printk(KERN_ERR PFX
"unable to find a free DMA2\n");
2159 if (port
[dev
] != SNDRV_AUTO_PORT
) {
2160 return snd_es18xx_isa_probe1(dev
, pdev
);
2162 static const unsigned long possible_ports
[] = {0x220, 0x240, 0x260, 0x280};
2164 for (i
= 0; i
< ARRAY_SIZE(possible_ports
); i
++) {
2165 port
[dev
] = possible_ports
[i
];
2166 err
= snd_es18xx_isa_probe1(dev
, pdev
);
2175 static int snd_es18xx_isa_suspend(struct device
*dev
, unsigned int n
,
2178 return snd_es18xx_suspend(dev_get_drvdata(dev
), state
);
2181 static int snd_es18xx_isa_resume(struct device
*dev
, unsigned int n
)
2183 return snd_es18xx_resume(dev_get_drvdata(dev
));
2187 #define DEV_NAME "es18xx"
2189 static struct isa_driver snd_es18xx_isa_driver
= {
2190 .match
= snd_es18xx_isa_match
,
2191 .probe
= snd_es18xx_isa_probe
,
2193 .suspend
= snd_es18xx_isa_suspend
,
2194 .resume
= snd_es18xx_isa_resume
,
2203 static int snd_audiodrive_pnp_detect(struct pnp_dev
*pdev
,
2204 const struct pnp_device_id
*id
)
2208 struct snd_card
*card
;
2210 if (pnp_device_is_isapnp(pdev
))
2211 return -ENOENT
; /* we have another procedure - card */
2212 for (; dev
< SNDRV_CARDS
; dev
++) {
2213 if (enable
[dev
] && isapnp
[dev
])
2216 if (dev
>= SNDRV_CARDS
)
2219 err
= snd_es18xx_card_new(&pdev
->dev
, dev
, &card
);
2222 err
= snd_audiodrive_pnp(dev
, card
->private_data
, pdev
);
2225 err
= snd_audiodrive_probe(card
, dev
);
2228 pnp_set_drvdata(pdev
, card
);
2234 static int snd_audiodrive_pnp_suspend(struct pnp_dev
*pdev
, pm_message_t state
)
2236 return snd_es18xx_suspend(pnp_get_drvdata(pdev
), state
);
2238 static int snd_audiodrive_pnp_resume(struct pnp_dev
*pdev
)
2240 return snd_es18xx_resume(pnp_get_drvdata(pdev
));
2244 static struct pnp_driver es18xx_pnp_driver
= {
2245 .name
= "es18xx-pnpbios",
2246 .id_table
= snd_audiodrive_pnpbiosids
,
2247 .probe
= snd_audiodrive_pnp_detect
,
2249 .suspend
= snd_audiodrive_pnp_suspend
,
2250 .resume
= snd_audiodrive_pnp_resume
,
2254 static int snd_audiodrive_pnpc_detect(struct pnp_card_link
*pcard
,
2255 const struct pnp_card_device_id
*pid
)
2258 struct snd_card
*card
;
2261 for ( ; dev
< SNDRV_CARDS
; dev
++) {
2262 if (enable
[dev
] && isapnp
[dev
])
2265 if (dev
>= SNDRV_CARDS
)
2268 res
= snd_es18xx_card_new(&pcard
->card
->dev
, dev
, &card
);
2272 res
= snd_audiodrive_pnpc(dev
, card
->private_data
, pcard
, pid
);
2275 res
= snd_audiodrive_probe(card
, dev
);
2279 pnp_set_card_drvdata(pcard
, card
);
2285 static int snd_audiodrive_pnpc_suspend(struct pnp_card_link
*pcard
, pm_message_t state
)
2287 return snd_es18xx_suspend(pnp_get_card_drvdata(pcard
), state
);
2290 static int snd_audiodrive_pnpc_resume(struct pnp_card_link
*pcard
)
2292 return snd_es18xx_resume(pnp_get_card_drvdata(pcard
));
2297 static struct pnp_card_driver es18xx_pnpc_driver
= {
2298 .flags
= PNP_DRIVER_RES_DISABLE
,
2300 .id_table
= snd_audiodrive_pnpids
,
2301 .probe
= snd_audiodrive_pnpc_detect
,
2303 .suspend
= snd_audiodrive_pnpc_suspend
,
2304 .resume
= snd_audiodrive_pnpc_resume
,
2307 #endif /* CONFIG_PNP */
2309 static int __init
alsa_card_es18xx_init(void)
2313 err
= isa_register_driver(&snd_es18xx_isa_driver
, SNDRV_CARDS
);
2318 err
= pnp_register_driver(&es18xx_pnp_driver
);
2322 err
= pnp_register_card_driver(&es18xx_pnpc_driver
);
2324 pnpc_registered
= 1;
2326 if (isa_registered
|| pnp_registered
)
2332 static void __exit
alsa_card_es18xx_exit(void)
2335 if (pnpc_registered
)
2336 pnp_unregister_card_driver(&es18xx_pnpc_driver
);
2338 pnp_unregister_driver(&es18xx_pnp_driver
);
2341 isa_unregister_driver(&snd_es18xx_isa_driver
);
2344 module_init(alsa_card_es18xx_init
)
2345 module_exit(alsa_card_es18xx_exit
)