mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-05 10:29:37 +00:00
Merge branch 'topic/hda' into for-linus
This commit is contained in:
commit
76531d4166
30 changed files with 19575 additions and 22099 deletions
100
Documentation/sound/alsa/HD-Audio-Controls.txt
Normal file
100
Documentation/sound/alsa/HD-Audio-Controls.txt
Normal file
|
@ -0,0 +1,100 @@
|
|||
This file explains the codec-specific mixer controls.
|
||||
|
||||
Realtek codecs
|
||||
--------------
|
||||
|
||||
* Channel Mode
|
||||
This is an enum control to change the surround-channel setup,
|
||||
appears only when the surround channels are available.
|
||||
It gives the number of channels to be used, "2ch", "4ch", "6ch",
|
||||
and "8ch". According to the configuration, this also controls the
|
||||
jack-retasking of multi-I/O jacks.
|
||||
|
||||
* Auto-Mute Mode
|
||||
This is an enum control to change the auto-mute behavior of the
|
||||
headphone and line-out jacks. If built-in speakers and headphone
|
||||
and/or line-out jacks are available on a machine, this controls
|
||||
appears.
|
||||
When there are only either headphones or line-out jacks, it gives
|
||||
"Disabled" and "Enabled" state. When enabled, the speaker is muted
|
||||
automatically when a jack is plugged.
|
||||
|
||||
When both headphone and line-out jacks are present, it gives
|
||||
"Disabled", "Speaker Only" and "Line-Out+Speaker". When
|
||||
speaker-only is chosen, plugging into a headphone or a line-out jack
|
||||
mutes the speakers, but not line-outs. When line-out+speaker is
|
||||
selected, plugging to a headphone jack mutes both speakers and
|
||||
line-outs.
|
||||
|
||||
|
||||
IDT/Sigmatel codecs
|
||||
-------------------
|
||||
|
||||
* Analog Loopback
|
||||
This control enables/disables the analog-loopback circuit. This
|
||||
appears only when "loopback" is set to true in a codec hint
|
||||
(see HD-Audio.txt). Note that on some codecs the analog-loopback
|
||||
and the normal PCM playback are exclusive, i.e. when this is on, you
|
||||
won't hear any PCM stream.
|
||||
|
||||
* Swap Center/LFE
|
||||
Swaps the center and LFE channel order. Normally, the left
|
||||
corresponds to the center and the right to the LFE. When this is
|
||||
ON, the left to the LFE and the right to the center.
|
||||
|
||||
* Headphone as Line Out
|
||||
When this control is ON, treat the headphone jacks as line-out
|
||||
jacks. That is, the headphone won't auto-mute the other line-outs,
|
||||
and no HP-amp is set to the pins.
|
||||
|
||||
* Mic Jack Mode, Line Jack Mode, etc
|
||||
These enum controls the direction and the bias of the input jack
|
||||
pins. Depending on the jack type, it can set as "Mic In" and "Line
|
||||
In", for determining the input bias, or it can be set to "Line Out"
|
||||
when the pin is a multi-I/O jack for surround channels.
|
||||
|
||||
|
||||
VIA codecs
|
||||
----------
|
||||
|
||||
* Smart 5.1
|
||||
An enum control to re-task the multi-I/O jacks for surround outputs.
|
||||
When it's ON, the corresponding input jacks (usually a line-in and a
|
||||
mic-in) are switched as the surround and the CLFE output jacks.
|
||||
|
||||
* Independent HP
|
||||
When this enum control is enabled, the headphone output is routed
|
||||
from an individual stream (the third PCM such as hw:0,2) instead of
|
||||
the primary stream. In the case the headphone DAC is shared with a
|
||||
side or a CLFE-channel DAC, the DAC is switched to the headphone
|
||||
automatically.
|
||||
|
||||
* Loopback Mixing
|
||||
An enum control to determine whether the analog-loopback route is
|
||||
enabled or not. When it's enabled, the analog-loopback is mixed to
|
||||
the front-channel. Also, the same route is used for the headphone
|
||||
and speaker outputs. As a side-effect, when this mode is set, the
|
||||
individual volume controls will be no longer available for
|
||||
headphones and speakers because there is only one DAC connected to a
|
||||
mixer widget.
|
||||
|
||||
* Dynamic Power-Control
|
||||
This control determines whether the dynamic power-control per jack
|
||||
detection is enabled or not. When enabled, the widgets power state
|
||||
(D0/D3) are changed dynamically depending on the jack plugging
|
||||
state for saving power consumptions. However, if your system
|
||||
doesn't provide a proper jack-detection, this won't work; in such a
|
||||
case, turn this control OFF.
|
||||
|
||||
* Jack Detect
|
||||
This control is provided only for VT1708 codec which gives no proper
|
||||
unsolicited event per jack plug. When this is on, the driver polls
|
||||
the jack detection so that the headphone auto-mute can work, while
|
||||
turning this off would reduce the power consumption.
|
||||
|
||||
|
||||
Conexant codecs
|
||||
---------------
|
||||
|
||||
* Auto-Mute Mode
|
||||
See Reatek codecs.
|
|
@ -14,6 +14,19 @@ menuconfig SND_HDA_INTEL
|
|||
|
||||
if SND_HDA_INTEL
|
||||
|
||||
config SND_HDA_PREALLOC_SIZE
|
||||
int "Pre-allocated buffer size for HD-audio driver"
|
||||
range 0 32768
|
||||
default 64
|
||||
help
|
||||
Specifies the default pre-allocated buffer-size in kB for the
|
||||
HD-audio driver. A larger buffer (e.g. 2048) is preferred
|
||||
for systems using PulseAudio. The default 64 is chosen just
|
||||
for compatibility reasons.
|
||||
|
||||
Note that the pre-allocation size can be changed dynamically
|
||||
via a proc file (/proc/asound/card*/pcm*/sub*/prealloc), too.
|
||||
|
||||
config SND_HDA_HWDEP
|
||||
bool "Build hwdep interface for HD-audio driver"
|
||||
select SND_HWDEP
|
||||
|
@ -83,6 +96,19 @@ config SND_HDA_CODEC_REALTEK
|
|||
snd-hda-codec-realtek.
|
||||
This module is automatically loaded at probing.
|
||||
|
||||
config SND_HDA_ENABLE_REALTEK_QUIRKS
|
||||
bool "Build static quirks for Realtek codecs"
|
||||
depends on SND_HDA_CODEC_REALTEK
|
||||
default y
|
||||
help
|
||||
Say Y here to build the static quirks codes for Realtek codecs.
|
||||
If you need the "model" preset that the default BIOS auto-parser
|
||||
can't handle, turn this option on.
|
||||
|
||||
If your device works with model=auto option, basically you don't
|
||||
need the quirk code. By turning this off, you can reduce the
|
||||
module size quite a lot.
|
||||
|
||||
config SND_HDA_CODEC_ANALOG
|
||||
bool "Build Analog Device HD-audio codec support"
|
||||
default y
|
||||
|
@ -171,6 +197,19 @@ config SND_HDA_CODEC_CA0110
|
|||
snd-hda-codec-ca0110.
|
||||
This module is automatically loaded at probing.
|
||||
|
||||
config SND_HDA_CODEC_CA0132
|
||||
bool "Build Creative CA0132 codec support"
|
||||
depends on SND_HDA_INTEL
|
||||
default y
|
||||
help
|
||||
Say Y here to include Creative CA0132 codec support in
|
||||
snd-hda-intel driver.
|
||||
|
||||
When the HD-audio driver is built as a module, the codec
|
||||
support code is also built as another module,
|
||||
snd-hda-codec-ca0132.
|
||||
This module is automatically loaded at probing.
|
||||
|
||||
config SND_HDA_CODEC_CMEDIA
|
||||
bool "Build C-Media HD-audio codec support"
|
||||
default y
|
||||
|
|
|
@ -13,6 +13,7 @@ snd-hda-codec-idt-objs := patch_sigmatel.o
|
|||
snd-hda-codec-si3054-objs := patch_si3054.o
|
||||
snd-hda-codec-cirrus-objs := patch_cirrus.o
|
||||
snd-hda-codec-ca0110-objs := patch_ca0110.o
|
||||
snd-hda-codec-ca0132-objs := patch_ca0132.o
|
||||
snd-hda-codec-conexant-objs := patch_conexant.o
|
||||
snd-hda-codec-via-objs := patch_via.o
|
||||
snd-hda-codec-hdmi-objs := patch_hdmi.o hda_eld.o
|
||||
|
@ -42,6 +43,9 @@ endif
|
|||
ifdef CONFIG_SND_HDA_CODEC_CA0110
|
||||
obj-$(CONFIG_SND_HDA_INTEL) += snd-hda-codec-ca0110.o
|
||||
endif
|
||||
ifdef CONFIG_SND_HDA_CODEC_CA0132
|
||||
obj-$(CONFIG_SND_HDA_INTEL) += snd-hda-codec-ca0132.o
|
||||
endif
|
||||
ifdef CONFIG_SND_HDA_CODEC_CONEXANT
|
||||
obj-$(CONFIG_SND_HDA_INTEL) += snd-hda-codec-conexant.o
|
||||
endif
|
||||
|
|
1272
sound/pci/hda/alc260_quirks.c
Normal file
1272
sound/pci/hda/alc260_quirks.c
Normal file
File diff suppressed because it is too large
Load diff
1353
sound/pci/hda/alc262_quirks.c
Normal file
1353
sound/pci/hda/alc262_quirks.c
Normal file
File diff suppressed because it is too large
Load diff
636
sound/pci/hda/alc268_quirks.c
Normal file
636
sound/pci/hda/alc268_quirks.c
Normal file
|
@ -0,0 +1,636 @@
|
|||
/*
|
||||
* ALC267/ALC268 quirk models
|
||||
* included by patch_realtek.c
|
||||
*/
|
||||
|
||||
/* ALC268 models */
|
||||
enum {
|
||||
ALC268_AUTO,
|
||||
ALC267_QUANTA_IL1,
|
||||
ALC268_3ST,
|
||||
ALC268_TOSHIBA,
|
||||
ALC268_ACER,
|
||||
ALC268_ACER_DMIC,
|
||||
ALC268_ACER_ASPIRE_ONE,
|
||||
ALC268_DELL,
|
||||
ALC268_ZEPTO,
|
||||
#ifdef CONFIG_SND_DEBUG
|
||||
ALC268_TEST,
|
||||
#endif
|
||||
ALC268_MODEL_LAST /* last tag */
|
||||
};
|
||||
|
||||
/*
|
||||
* ALC268 channel source setting (2 channel)
|
||||
*/
|
||||
#define ALC268_DIGOUT_NID ALC880_DIGOUT_NID
|
||||
#define alc268_modes alc260_modes
|
||||
|
||||
static const hda_nid_t alc268_dac_nids[2] = {
|
||||
/* front, hp */
|
||||
0x02, 0x03
|
||||
};
|
||||
|
||||
static const hda_nid_t alc268_adc_nids[2] = {
|
||||
/* ADC0-1 */
|
||||
0x08, 0x07
|
||||
};
|
||||
|
||||
static const hda_nid_t alc268_adc_nids_alt[1] = {
|
||||
/* ADC0 */
|
||||
0x08
|
||||
};
|
||||
|
||||
static const hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
|
||||
|
||||
static const struct snd_kcontrol_new alc268_base_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc268_toshiba_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
|
||||
ALC262_HIPPO_MASTER_SWITCH,
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_verb alc268_eapd_verbs[] = {
|
||||
{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
|
||||
{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
|
||||
{ }
|
||||
};
|
||||
|
||||
/* Toshiba specific */
|
||||
static const struct hda_verb alc268_toshiba_verbs[] = {
|
||||
{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT | AC_USRSP_EN},
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
/* Acer specific */
|
||||
/* bind volumes of both NID 0x02 and 0x03 */
|
||||
static const struct hda_bind_ctls alc268_acer_bind_master_vol = {
|
||||
.ops = &snd_hda_bind_vol,
|
||||
.values = {
|
||||
HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
|
||||
HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
|
||||
0
|
||||
},
|
||||
};
|
||||
|
||||
static void alc268_acer_setup(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
|
||||
spec->autocfg.hp_pins[0] = 0x14;
|
||||
spec->autocfg.speaker_pins[0] = 0x15;
|
||||
spec->automute = 1;
|
||||
spec->automute_mode = ALC_AUTOMUTE_AMP;
|
||||
}
|
||||
|
||||
#define alc268_acer_master_sw_get alc262_hp_master_sw_get
|
||||
#define alc268_acer_master_sw_put alc262_hp_master_sw_put
|
||||
|
||||
static const struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
|
||||
{
|
||||
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||||
.name = "Master Playback Switch",
|
||||
.subdevice = HDA_SUBDEV_NID_FLAG | 0x15,
|
||||
.info = snd_ctl_boolean_mono_info,
|
||||
.get = alc268_acer_master_sw_get,
|
||||
.put = alc268_acer_master_sw_put,
|
||||
},
|
||||
HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc268_acer_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
|
||||
{
|
||||
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||||
.name = "Master Playback Switch",
|
||||
.subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
|
||||
.info = snd_ctl_boolean_mono_info,
|
||||
.get = alc268_acer_master_sw_get,
|
||||
.put = alc268_acer_master_sw_put,
|
||||
},
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
|
||||
{
|
||||
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||||
.name = "Master Playback Switch",
|
||||
.subdevice = HDA_SUBDEV_NID_FLAG | 0x14,
|
||||
.info = snd_ctl_boolean_mono_info,
|
||||
.get = alc268_acer_master_sw_get,
|
||||
.put = alc268_acer_master_sw_put,
|
||||
},
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_verb alc268_acer_aspire_one_verbs[] = {
|
||||
{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
||||
{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT | AC_USRSP_EN},
|
||||
{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_MIC_EVENT},
|
||||
{0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
|
||||
{0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_verb alc268_acer_verbs[] = {
|
||||
{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
|
||||
{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
||||
{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
|
||||
{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
|
||||
{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT | AC_USRSP_EN},
|
||||
{ }
|
||||
};
|
||||
|
||||
/* unsolicited event for HP jack sensing */
|
||||
#define alc268_toshiba_setup alc262_hippo_setup
|
||||
|
||||
static void alc268_acer_lc_setup(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
spec->autocfg.hp_pins[0] = 0x15;
|
||||
spec->autocfg.speaker_pins[0] = 0x14;
|
||||
spec->automute = 1;
|
||||
spec->automute_mode = ALC_AUTOMUTE_AMP;
|
||||
spec->ext_mic_pin = 0x18;
|
||||
spec->int_mic_pin = 0x12;
|
||||
spec->auto_mic = 1;
|
||||
}
|
||||
|
||||
static const struct snd_kcontrol_new alc268_dell_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_verb alc268_dell_verbs[] = {
|
||||
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
||||
{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
||||
{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT | AC_USRSP_EN},
|
||||
{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_MIC_EVENT | AC_USRSP_EN},
|
||||
{ }
|
||||
};
|
||||
|
||||
/* mute/unmute internal speaker according to the hp jack and mute state */
|
||||
static void alc268_dell_setup(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
|
||||
spec->autocfg.hp_pins[0] = 0x15;
|
||||
spec->autocfg.speaker_pins[0] = 0x14;
|
||||
spec->ext_mic_pin = 0x18;
|
||||
spec->int_mic_pin = 0x19;
|
||||
spec->auto_mic = 1;
|
||||
spec->automute = 1;
|
||||
spec->automute_mode = ALC_AUTOMUTE_PIN;
|
||||
}
|
||||
|
||||
static const struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_verb alc267_quanta_il1_verbs[] = {
|
||||
{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT | AC_USRSP_EN},
|
||||
{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_MIC_EVENT | AC_USRSP_EN},
|
||||
{ }
|
||||
};
|
||||
|
||||
static void alc267_quanta_il1_setup(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
spec->autocfg.hp_pins[0] = 0x15;
|
||||
spec->autocfg.speaker_pins[0] = 0x14;
|
||||
spec->ext_mic_pin = 0x18;
|
||||
spec->int_mic_pin = 0x19;
|
||||
spec->auto_mic = 1;
|
||||
spec->automute = 1;
|
||||
spec->automute_mode = ALC_AUTOMUTE_PIN;
|
||||
}
|
||||
|
||||
/*
|
||||
* generic initialization of ADC, input mixers and output mixers
|
||||
*/
|
||||
static const struct hda_verb alc268_base_init_verbs[] = {
|
||||
/* Unmute DAC0-1 and set vol = 0 */
|
||||
{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
|
||||
/*
|
||||
* Set up output mixers (0x0c - 0x0e)
|
||||
*/
|
||||
/* set vol=0 to output mixers */
|
||||
{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
|
||||
{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
|
||||
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
|
||||
{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
|
||||
{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
|
||||
{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
|
||||
{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
|
||||
{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
|
||||
{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
|
||||
{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
|
||||
|
||||
{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
|
||||
/* set PCBEEP vol = 0, mute connections */
|
||||
{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
||||
{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
||||
|
||||
/* Unmute Selector 23h,24h and set the default input to mic-in */
|
||||
|
||||
{0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
|
||||
{ }
|
||||
};
|
||||
|
||||
/* only for model=test */
|
||||
#ifdef CONFIG_SND_DEBUG
|
||||
/*
|
||||
* generic initialization of ADC, input mixers and output mixers
|
||||
*/
|
||||
static const struct hda_verb alc268_volume_init_verbs[] = {
|
||||
/* set output DAC */
|
||||
{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
|
||||
{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
|
||||
{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
|
||||
{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
|
||||
{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
|
||||
{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
|
||||
|
||||
{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
{ }
|
||||
};
|
||||
#endif /* CONFIG_SND_DEBUG */
|
||||
|
||||
static const struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
|
||||
_DEFINE_CAPSRC(1),
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc268_capture_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
|
||||
_DEFINE_CAPSRC(2),
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct hda_input_mux alc268_capture_source = {
|
||||
.num_items = 4,
|
||||
.items = {
|
||||
{ "Mic", 0x0 },
|
||||
{ "Front Mic", 0x1 },
|
||||
{ "Line", 0x2 },
|
||||
{ "CD", 0x3 },
|
||||
},
|
||||
};
|
||||
|
||||
static const struct hda_input_mux alc268_acer_capture_source = {
|
||||
.num_items = 3,
|
||||
.items = {
|
||||
{ "Mic", 0x0 },
|
||||
{ "Internal Mic", 0x1 },
|
||||
{ "Line", 0x2 },
|
||||
},
|
||||
};
|
||||
|
||||
static const struct hda_input_mux alc268_acer_dmic_capture_source = {
|
||||
.num_items = 3,
|
||||
.items = {
|
||||
{ "Mic", 0x0 },
|
||||
{ "Internal Mic", 0x6 },
|
||||
{ "Line", 0x2 },
|
||||
},
|
||||
};
|
||||
|
||||
#ifdef CONFIG_SND_DEBUG
|
||||
static const struct snd_kcontrol_new alc268_test_mixer[] = {
|
||||
/* Volume widgets */
|
||||
HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
|
||||
HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
|
||||
HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
|
||||
HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
|
||||
HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
|
||||
HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
|
||||
/* The below appears problematic on some hardwares */
|
||||
/*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
|
||||
HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
|
||||
|
||||
/* Modes for retasking pin widgets */
|
||||
ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
|
||||
ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
|
||||
ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
|
||||
ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
|
||||
|
||||
/* Controls for GPIO pins, assuming they are configured as outputs */
|
||||
ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
|
||||
ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
|
||||
ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
|
||||
ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
|
||||
|
||||
/* Switches to allow the digital SPDIF output pin to be enabled.
|
||||
* The ALC268 does not have an SPDIF input.
|
||||
*/
|
||||
ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
|
||||
|
||||
/* A switch allowing EAPD to be enabled. Some laptops seem to use
|
||||
* this output to turn on an external amplifier.
|
||||
*/
|
||||
ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
|
||||
ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
|
||||
|
||||
{ } /* end */
|
||||
};
|
||||
#endif
|
||||
|
||||
/*
|
||||
* configuration and preset
|
||||
*/
|
||||
static const char * const alc268_models[ALC268_MODEL_LAST] = {
|
||||
[ALC267_QUANTA_IL1] = "quanta-il1",
|
||||
[ALC268_3ST] = "3stack",
|
||||
[ALC268_TOSHIBA] = "toshiba",
|
||||
[ALC268_ACER] = "acer",
|
||||
[ALC268_ACER_DMIC] = "acer-dmic",
|
||||
[ALC268_ACER_ASPIRE_ONE] = "acer-aspire",
|
||||
[ALC268_DELL] = "dell",
|
||||
[ALC268_ZEPTO] = "zepto",
|
||||
#ifdef CONFIG_SND_DEBUG
|
||||
[ALC268_TEST] = "test",
|
||||
#endif
|
||||
[ALC268_AUTO] = "auto",
|
||||
};
|
||||
|
||||
static const struct snd_pci_quirk alc268_cfg_tbl[] = {
|
||||
SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
|
||||
SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
|
||||
SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
|
||||
SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
|
||||
SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
|
||||
SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
|
||||
ALC268_ACER_ASPIRE_ONE),
|
||||
SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
|
||||
SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron 910", ALC268_AUTO),
|
||||
SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
|
||||
"Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
|
||||
/* almost compatible with toshiba but with optional digital outs;
|
||||
* auto-probing seems working fine
|
||||
*/
|
||||
SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
|
||||
ALC268_AUTO),
|
||||
SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
|
||||
SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
|
||||
SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
|
||||
SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
|
||||
{}
|
||||
};
|
||||
|
||||
/* Toshiba laptops have no unique PCI SSID but only codec SSID */
|
||||
static const struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
|
||||
SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
|
||||
SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
|
||||
SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
|
||||
ALC268_TOSHIBA),
|
||||
{}
|
||||
};
|
||||
|
||||
static const struct alc_config_preset alc268_presets[] = {
|
||||
[ALC267_QUANTA_IL1] = {
|
||||
.mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
|
||||
alc268_capture_nosrc_mixer },
|
||||
.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
|
||||
alc267_quanta_il1_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc268_dac_nids),
|
||||
.dac_nids = alc268_dac_nids,
|
||||
.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
|
||||
.adc_nids = alc268_adc_nids_alt,
|
||||
.hp_nid = 0x03,
|
||||
.num_channel_mode = ARRAY_SIZE(alc268_modes),
|
||||
.channel_mode = alc268_modes,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc267_quanta_il1_setup,
|
||||
.init_hook = alc_inithook,
|
||||
},
|
||||
[ALC268_3ST] = {
|
||||
.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
|
||||
alc268_beep_mixer },
|
||||
.init_verbs = { alc268_base_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc268_dac_nids),
|
||||
.dac_nids = alc268_dac_nids,
|
||||
.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
|
||||
.adc_nids = alc268_adc_nids_alt,
|
||||
.capsrc_nids = alc268_capsrc_nids,
|
||||
.hp_nid = 0x03,
|
||||
.dig_out_nid = ALC268_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc268_modes),
|
||||
.channel_mode = alc268_modes,
|
||||
.input_mux = &alc268_capture_source,
|
||||
},
|
||||
[ALC268_TOSHIBA] = {
|
||||
.mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
|
||||
alc268_beep_mixer },
|
||||
.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
|
||||
alc268_toshiba_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc268_dac_nids),
|
||||
.dac_nids = alc268_dac_nids,
|
||||
.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
|
||||
.adc_nids = alc268_adc_nids_alt,
|
||||
.capsrc_nids = alc268_capsrc_nids,
|
||||
.hp_nid = 0x03,
|
||||
.num_channel_mode = ARRAY_SIZE(alc268_modes),
|
||||
.channel_mode = alc268_modes,
|
||||
.input_mux = &alc268_capture_source,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc268_toshiba_setup,
|
||||
.init_hook = alc_inithook,
|
||||
},
|
||||
[ALC268_ACER] = {
|
||||
.mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
|
||||
alc268_beep_mixer },
|
||||
.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
|
||||
alc268_acer_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc268_dac_nids),
|
||||
.dac_nids = alc268_dac_nids,
|
||||
.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
|
||||
.adc_nids = alc268_adc_nids_alt,
|
||||
.capsrc_nids = alc268_capsrc_nids,
|
||||
.hp_nid = 0x02,
|
||||
.num_channel_mode = ARRAY_SIZE(alc268_modes),
|
||||
.channel_mode = alc268_modes,
|
||||
.input_mux = &alc268_acer_capture_source,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc268_acer_setup,
|
||||
.init_hook = alc_inithook,
|
||||
},
|
||||
[ALC268_ACER_DMIC] = {
|
||||
.mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
|
||||
alc268_beep_mixer },
|
||||
.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
|
||||
alc268_acer_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc268_dac_nids),
|
||||
.dac_nids = alc268_dac_nids,
|
||||
.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
|
||||
.adc_nids = alc268_adc_nids_alt,
|
||||
.capsrc_nids = alc268_capsrc_nids,
|
||||
.hp_nid = 0x02,
|
||||
.num_channel_mode = ARRAY_SIZE(alc268_modes),
|
||||
.channel_mode = alc268_modes,
|
||||
.input_mux = &alc268_acer_dmic_capture_source,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc268_acer_setup,
|
||||
.init_hook = alc_inithook,
|
||||
},
|
||||
[ALC268_ACER_ASPIRE_ONE] = {
|
||||
.mixers = { alc268_acer_aspire_one_mixer,
|
||||
alc268_beep_mixer,
|
||||
alc268_capture_nosrc_mixer },
|
||||
.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
|
||||
alc268_acer_aspire_one_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc268_dac_nids),
|
||||
.dac_nids = alc268_dac_nids,
|
||||
.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
|
||||
.adc_nids = alc268_adc_nids_alt,
|
||||
.capsrc_nids = alc268_capsrc_nids,
|
||||
.hp_nid = 0x03,
|
||||
.num_channel_mode = ARRAY_SIZE(alc268_modes),
|
||||
.channel_mode = alc268_modes,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc268_acer_lc_setup,
|
||||
.init_hook = alc_inithook,
|
||||
},
|
||||
[ALC268_DELL] = {
|
||||
.mixers = { alc268_dell_mixer, alc268_beep_mixer,
|
||||
alc268_capture_nosrc_mixer },
|
||||
.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
|
||||
alc268_dell_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc268_dac_nids),
|
||||
.dac_nids = alc268_dac_nids,
|
||||
.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
|
||||
.adc_nids = alc268_adc_nids_alt,
|
||||
.capsrc_nids = alc268_capsrc_nids,
|
||||
.hp_nid = 0x02,
|
||||
.num_channel_mode = ARRAY_SIZE(alc268_modes),
|
||||
.channel_mode = alc268_modes,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc268_dell_setup,
|
||||
.init_hook = alc_inithook,
|
||||
},
|
||||
[ALC268_ZEPTO] = {
|
||||
.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
|
||||
alc268_beep_mixer },
|
||||
.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
|
||||
alc268_toshiba_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc268_dac_nids),
|
||||
.dac_nids = alc268_dac_nids,
|
||||
.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
|
||||
.adc_nids = alc268_adc_nids_alt,
|
||||
.capsrc_nids = alc268_capsrc_nids,
|
||||
.hp_nid = 0x03,
|
||||
.dig_out_nid = ALC268_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc268_modes),
|
||||
.channel_mode = alc268_modes,
|
||||
.input_mux = &alc268_capture_source,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc268_toshiba_setup,
|
||||
.init_hook = alc_inithook,
|
||||
},
|
||||
#ifdef CONFIG_SND_DEBUG
|
||||
[ALC268_TEST] = {
|
||||
.mixers = { alc268_test_mixer, alc268_capture_mixer },
|
||||
.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
|
||||
alc268_volume_init_verbs,
|
||||
alc268_beep_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc268_dac_nids),
|
||||
.dac_nids = alc268_dac_nids,
|
||||
.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
|
||||
.adc_nids = alc268_adc_nids_alt,
|
||||
.capsrc_nids = alc268_capsrc_nids,
|
||||
.hp_nid = 0x03,
|
||||
.dig_out_nid = ALC268_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc268_modes),
|
||||
.channel_mode = alc268_modes,
|
||||
.input_mux = &alc268_capture_source,
|
||||
},
|
||||
#endif
|
||||
};
|
||||
|
681
sound/pci/hda/alc269_quirks.c
Normal file
681
sound/pci/hda/alc269_quirks.c
Normal file
|
@ -0,0 +1,681 @@
|
|||
/*
|
||||
* ALC269/ALC270/ALC275/ALC276 quirk models
|
||||
* included by patch_realtek.c
|
||||
*/
|
||||
|
||||
/* ALC269 models */
|
||||
enum {
|
||||
ALC269_AUTO,
|
||||
ALC269_BASIC,
|
||||
ALC269_QUANTA_FL1,
|
||||
ALC269_AMIC,
|
||||
ALC269_DMIC,
|
||||
ALC269VB_AMIC,
|
||||
ALC269VB_DMIC,
|
||||
ALC269_FUJITSU,
|
||||
ALC269_LIFEBOOK,
|
||||
ALC271_ACER,
|
||||
ALC269_MODEL_LAST /* last tag */
|
||||
};
|
||||
|
||||
/*
|
||||
* ALC269 channel source setting (2 channel)
|
||||
*/
|
||||
#define ALC269_DIGOUT_NID ALC880_DIGOUT_NID
|
||||
|
||||
#define alc269_dac_nids alc260_dac_nids
|
||||
|
||||
static const hda_nid_t alc269_adc_nids[1] = {
|
||||
/* ADC1 */
|
||||
0x08,
|
||||
};
|
||||
|
||||
static const hda_nid_t alc269_capsrc_nids[1] = {
|
||||
0x23,
|
||||
};
|
||||
|
||||
static const hda_nid_t alc269vb_adc_nids[1] = {
|
||||
/* ADC1 */
|
||||
0x09,
|
||||
};
|
||||
|
||||
static const hda_nid_t alc269vb_capsrc_nids[1] = {
|
||||
0x22,
|
||||
};
|
||||
|
||||
#define alc269_modes alc260_modes
|
||||
#define alc269_capture_source alc880_lg_lw_capture_source
|
||||
|
||||
static const struct snd_kcontrol_new alc269_base_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
|
||||
{
|
||||
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||||
.name = "Master Playback Switch",
|
||||
.subdevice = HDA_SUBDEV_AMP_FLAG,
|
||||
.info = snd_hda_mixer_amp_switch_info,
|
||||
.get = snd_hda_mixer_amp_switch_get,
|
||||
.put = alc268_acer_master_sw_put,
|
||||
.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
|
||||
},
|
||||
HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc269_lifebook_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
|
||||
{
|
||||
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||||
.name = "Master Playback Switch",
|
||||
.subdevice = HDA_SUBDEV_AMP_FLAG,
|
||||
.info = snd_hda_mixer_amp_switch_info,
|
||||
.get = snd_hda_mixer_amp_switch_get,
|
||||
.put = alc268_acer_master_sw_put,
|
||||
.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
|
||||
},
|
||||
HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x1b, 0, HDA_INPUT),
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc269_laptop_mixer[] = {
|
||||
HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
|
||||
HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc269_asus_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
/* capture mixer elements */
|
||||
static const struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
/* FSC amilo */
|
||||
#define alc269_fujitsu_mixer alc269_laptop_mixer
|
||||
|
||||
static const struct hda_verb alc269_quanta_fl1_verbs[] = {
|
||||
{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
|
||||
{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
||||
{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT | AC_USRSP_EN},
|
||||
{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_MIC_EVENT},
|
||||
{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_verb alc269_lifebook_verbs[] = {
|
||||
{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
|
||||
{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
|
||||
{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
||||
{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT | AC_USRSP_EN},
|
||||
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
||||
{0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT | AC_USRSP_EN},
|
||||
{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_MIC_EVENT},
|
||||
{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{ }
|
||||
};
|
||||
|
||||
/* toggle speaker-output according to the hp-jack state */
|
||||
static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
|
||||
{
|
||||
alc_hp_automute(codec);
|
||||
|
||||
snd_hda_codec_write(codec, 0x20, 0,
|
||||
AC_VERB_SET_COEF_INDEX, 0x0c);
|
||||
snd_hda_codec_write(codec, 0x20, 0,
|
||||
AC_VERB_SET_PROC_COEF, 0x680);
|
||||
|
||||
snd_hda_codec_write(codec, 0x20, 0,
|
||||
AC_VERB_SET_COEF_INDEX, 0x0c);
|
||||
snd_hda_codec_write(codec, 0x20, 0,
|
||||
AC_VERB_SET_PROC_COEF, 0x480);
|
||||
}
|
||||
|
||||
#define alc269_lifebook_speaker_automute \
|
||||
alc269_quanta_fl1_speaker_automute
|
||||
|
||||
static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
|
||||
{
|
||||
unsigned int present_laptop;
|
||||
unsigned int present_dock;
|
||||
|
||||
present_laptop = snd_hda_jack_detect(codec, 0x18);
|
||||
present_dock = snd_hda_jack_detect(codec, 0x1b);
|
||||
|
||||
/* Laptop mic port overrides dock mic port, design decision */
|
||||
if (present_dock)
|
||||
snd_hda_codec_write(codec, 0x23, 0,
|
||||
AC_VERB_SET_CONNECT_SEL, 0x3);
|
||||
if (present_laptop)
|
||||
snd_hda_codec_write(codec, 0x23, 0,
|
||||
AC_VERB_SET_CONNECT_SEL, 0x0);
|
||||
if (!present_dock && !present_laptop)
|
||||
snd_hda_codec_write(codec, 0x23, 0,
|
||||
AC_VERB_SET_CONNECT_SEL, 0x1);
|
||||
}
|
||||
|
||||
static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
|
||||
unsigned int res)
|
||||
{
|
||||
switch (res >> 26) {
|
||||
case ALC_HP_EVENT:
|
||||
alc269_quanta_fl1_speaker_automute(codec);
|
||||
break;
|
||||
case ALC_MIC_EVENT:
|
||||
alc_mic_automute(codec);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void alc269_lifebook_unsol_event(struct hda_codec *codec,
|
||||
unsigned int res)
|
||||
{
|
||||
if ((res >> 26) == ALC_HP_EVENT)
|
||||
alc269_lifebook_speaker_automute(codec);
|
||||
if ((res >> 26) == ALC_MIC_EVENT)
|
||||
alc269_lifebook_mic_autoswitch(codec);
|
||||
}
|
||||
|
||||
static void alc269_quanta_fl1_setup(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
spec->autocfg.hp_pins[0] = 0x15;
|
||||
spec->autocfg.speaker_pins[0] = 0x14;
|
||||
spec->automute_mixer_nid[0] = 0x0c;
|
||||
spec->automute = 1;
|
||||
spec->automute_mode = ALC_AUTOMUTE_MIXER;
|
||||
spec->ext_mic_pin = 0x18;
|
||||
spec->int_mic_pin = 0x19;
|
||||
spec->auto_mic = 1;
|
||||
}
|
||||
|
||||
static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
|
||||
{
|
||||
alc269_quanta_fl1_speaker_automute(codec);
|
||||
alc_mic_automute(codec);
|
||||
}
|
||||
|
||||
static void alc269_lifebook_setup(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
spec->autocfg.hp_pins[0] = 0x15;
|
||||
spec->autocfg.hp_pins[1] = 0x1a;
|
||||
spec->autocfg.speaker_pins[0] = 0x14;
|
||||
spec->automute_mixer_nid[0] = 0x0c;
|
||||
spec->automute = 1;
|
||||
spec->automute_mode = ALC_AUTOMUTE_MIXER;
|
||||
}
|
||||
|
||||
static void alc269_lifebook_init_hook(struct hda_codec *codec)
|
||||
{
|
||||
alc269_lifebook_speaker_automute(codec);
|
||||
alc269_lifebook_mic_autoswitch(codec);
|
||||
}
|
||||
|
||||
static const struct hda_verb alc269_laptop_dmic_init_verbs[] = {
|
||||
{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
|
||||
{0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
|
||||
{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
|
||||
{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
|
||||
{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_MIC_EVENT},
|
||||
{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
|
||||
{}
|
||||
};
|
||||
|
||||
static const struct hda_verb alc269_laptop_amic_init_verbs[] = {
|
||||
{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
|
||||
{0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
|
||||
{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
|
||||
{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
|
||||
{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_MIC_EVENT},
|
||||
{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
|
||||
{}
|
||||
};
|
||||
|
||||
static const struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
|
||||
{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
|
||||
{0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
|
||||
{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
|
||||
{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
|
||||
{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_MIC_EVENT},
|
||||
{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
|
||||
{}
|
||||
};
|
||||
|
||||
static const struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
|
||||
{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
|
||||
{0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
|
||||
{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
|
||||
{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
|
||||
{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_MIC_EVENT},
|
||||
{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
|
||||
{}
|
||||
};
|
||||
|
||||
static const struct hda_verb alc271_acer_dmic_verbs[] = {
|
||||
{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
|
||||
{0x20, AC_VERB_SET_PROC_COEF, 0x4000},
|
||||
{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
||||
{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
|
||||
{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_MIC_EVENT},
|
||||
{0x22, AC_VERB_SET_CONNECT_SEL, 6},
|
||||
{ }
|
||||
};
|
||||
|
||||
static void alc269_laptop_amic_setup(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
spec->autocfg.hp_pins[0] = 0x15;
|
||||
spec->autocfg.speaker_pins[0] = 0x14;
|
||||
spec->automute_mixer_nid[0] = 0x0c;
|
||||
spec->automute = 1;
|
||||
spec->automute_mode = ALC_AUTOMUTE_MIXER;
|
||||
spec->ext_mic_pin = 0x18;
|
||||
spec->int_mic_pin = 0x19;
|
||||
spec->auto_mic = 1;
|
||||
}
|
||||
|
||||
static void alc269_laptop_dmic_setup(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
spec->autocfg.hp_pins[0] = 0x15;
|
||||
spec->autocfg.speaker_pins[0] = 0x14;
|
||||
spec->automute_mixer_nid[0] = 0x0c;
|
||||
spec->automute = 1;
|
||||
spec->automute_mode = ALC_AUTOMUTE_MIXER;
|
||||
spec->ext_mic_pin = 0x18;
|
||||
spec->int_mic_pin = 0x12;
|
||||
spec->auto_mic = 1;
|
||||
}
|
||||
|
||||
static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
spec->autocfg.hp_pins[0] = 0x21;
|
||||
spec->autocfg.speaker_pins[0] = 0x14;
|
||||
spec->automute_mixer_nid[0] = 0x0c;
|
||||
spec->automute = 1;
|
||||
spec->automute_mode = ALC_AUTOMUTE_MIXER;
|
||||
spec->ext_mic_pin = 0x18;
|
||||
spec->int_mic_pin = 0x19;
|
||||
spec->auto_mic = 1;
|
||||
}
|
||||
|
||||
static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
spec->autocfg.hp_pins[0] = 0x21;
|
||||
spec->autocfg.speaker_pins[0] = 0x14;
|
||||
spec->automute_mixer_nid[0] = 0x0c;
|
||||
spec->automute = 1;
|
||||
spec->automute_mode = ALC_AUTOMUTE_MIXER;
|
||||
spec->ext_mic_pin = 0x18;
|
||||
spec->int_mic_pin = 0x12;
|
||||
spec->auto_mic = 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* generic initialization of ADC, input mixers and output mixers
|
||||
*/
|
||||
static const struct hda_verb alc269_init_verbs[] = {
|
||||
/*
|
||||
* Unmute ADC0 and set the default input to mic-in
|
||||
*/
|
||||
{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
|
||||
/*
|
||||
* Set up output mixers (0x02 - 0x03)
|
||||
*/
|
||||
/* set vol=0 to output mixers */
|
||||
{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
|
||||
/* set up input amps for analog loopback */
|
||||
/* Amp Indices: DAC = 0, mixer = 1 */
|
||||
{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
|
||||
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
||||
{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
|
||||
{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
|
||||
{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
|
||||
{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
|
||||
/* FIXME: use Mux-type input source selection */
|
||||
/* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
|
||||
/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
|
||||
{0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
|
||||
/* set EAPD */
|
||||
{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_verb alc269vb_init_verbs[] = {
|
||||
/*
|
||||
* Unmute ADC0 and set the default input to mic-in
|
||||
*/
|
||||
{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
|
||||
/*
|
||||
* Set up output mixers (0x02 - 0x03)
|
||||
*/
|
||||
/* set vol=0 to output mixers */
|
||||
{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
|
||||
/* set up input amps for analog loopback */
|
||||
/* Amp Indices: DAC = 0, mixer = 1 */
|
||||
{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
|
||||
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
||||
{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
|
||||
{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
|
||||
{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
|
||||
{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
|
||||
/* FIXME: use Mux-type input source selection */
|
||||
/* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
|
||||
/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
|
||||
{0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
|
||||
/* set EAPD */
|
||||
{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
|
||||
{ }
|
||||
};
|
||||
|
||||
/*
|
||||
* configuration and preset
|
||||
*/
|
||||
static const char * const alc269_models[ALC269_MODEL_LAST] = {
|
||||
[ALC269_BASIC] = "basic",
|
||||
[ALC269_QUANTA_FL1] = "quanta",
|
||||
[ALC269_AMIC] = "laptop-amic",
|
||||
[ALC269_DMIC] = "laptop-dmic",
|
||||
[ALC269_FUJITSU] = "fujitsu",
|
||||
[ALC269_LIFEBOOK] = "lifebook",
|
||||
[ALC269_AUTO] = "auto",
|
||||
};
|
||||
|
||||
static const struct snd_pci_quirk alc269_cfg_tbl[] = {
|
||||
SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
|
||||
SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
|
||||
SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
|
||||
ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269VB_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
|
||||
ALC269_DMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
|
||||
ALC269_DMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
|
||||
SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
|
||||
SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
|
||||
SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
|
||||
SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
|
||||
SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
|
||||
SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
|
||||
SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
|
||||
SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
|
||||
{}
|
||||
};
|
||||
|
||||
static const struct alc_config_preset alc269_presets[] = {
|
||||
[ALC269_BASIC] = {
|
||||
.mixers = { alc269_base_mixer },
|
||||
.init_verbs = { alc269_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc269_dac_nids),
|
||||
.dac_nids = alc269_dac_nids,
|
||||
.hp_nid = 0x03,
|
||||
.num_channel_mode = ARRAY_SIZE(alc269_modes),
|
||||
.channel_mode = alc269_modes,
|
||||
.input_mux = &alc269_capture_source,
|
||||
},
|
||||
[ALC269_QUANTA_FL1] = {
|
||||
.mixers = { alc269_quanta_fl1_mixer },
|
||||
.init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc269_dac_nids),
|
||||
.dac_nids = alc269_dac_nids,
|
||||
.hp_nid = 0x03,
|
||||
.num_channel_mode = ARRAY_SIZE(alc269_modes),
|
||||
.channel_mode = alc269_modes,
|
||||
.input_mux = &alc269_capture_source,
|
||||
.unsol_event = alc269_quanta_fl1_unsol_event,
|
||||
.setup = alc269_quanta_fl1_setup,
|
||||
.init_hook = alc269_quanta_fl1_init_hook,
|
||||
},
|
||||
[ALC269_AMIC] = {
|
||||
.mixers = { alc269_laptop_mixer },
|
||||
.cap_mixer = alc269_laptop_analog_capture_mixer,
|
||||
.init_verbs = { alc269_init_verbs,
|
||||
alc269_laptop_amic_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc269_dac_nids),
|
||||
.dac_nids = alc269_dac_nids,
|
||||
.hp_nid = 0x03,
|
||||
.num_channel_mode = ARRAY_SIZE(alc269_modes),
|
||||
.channel_mode = alc269_modes,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc269_laptop_amic_setup,
|
||||
.init_hook = alc_inithook,
|
||||
},
|
||||
[ALC269_DMIC] = {
|
||||
.mixers = { alc269_laptop_mixer },
|
||||
.cap_mixer = alc269_laptop_digital_capture_mixer,
|
||||
.init_verbs = { alc269_init_verbs,
|
||||
alc269_laptop_dmic_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc269_dac_nids),
|
||||
.dac_nids = alc269_dac_nids,
|
||||
.hp_nid = 0x03,
|
||||
.num_channel_mode = ARRAY_SIZE(alc269_modes),
|
||||
.channel_mode = alc269_modes,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc269_laptop_dmic_setup,
|
||||
.init_hook = alc_inithook,
|
||||
},
|
||||
[ALC269VB_AMIC] = {
|
||||
.mixers = { alc269vb_laptop_mixer },
|
||||
.cap_mixer = alc269vb_laptop_analog_capture_mixer,
|
||||
.init_verbs = { alc269vb_init_verbs,
|
||||
alc269vb_laptop_amic_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc269_dac_nids),
|
||||
.dac_nids = alc269_dac_nids,
|
||||
.hp_nid = 0x03,
|
||||
.num_channel_mode = ARRAY_SIZE(alc269_modes),
|
||||
.channel_mode = alc269_modes,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc269vb_laptop_amic_setup,
|
||||
.init_hook = alc_inithook,
|
||||
},
|
||||
[ALC269VB_DMIC] = {
|
||||
.mixers = { alc269vb_laptop_mixer },
|
||||
.cap_mixer = alc269vb_laptop_digital_capture_mixer,
|
||||
.init_verbs = { alc269vb_init_verbs,
|
||||
alc269vb_laptop_dmic_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc269_dac_nids),
|
||||
.dac_nids = alc269_dac_nids,
|
||||
.hp_nid = 0x03,
|
||||
.num_channel_mode = ARRAY_SIZE(alc269_modes),
|
||||
.channel_mode = alc269_modes,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc269vb_laptop_dmic_setup,
|
||||
.init_hook = alc_inithook,
|
||||
},
|
||||
[ALC269_FUJITSU] = {
|
||||
.mixers = { alc269_fujitsu_mixer },
|
||||
.cap_mixer = alc269_laptop_digital_capture_mixer,
|
||||
.init_verbs = { alc269_init_verbs,
|
||||
alc269_laptop_dmic_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc269_dac_nids),
|
||||
.dac_nids = alc269_dac_nids,
|
||||
.hp_nid = 0x03,
|
||||
.num_channel_mode = ARRAY_SIZE(alc269_modes),
|
||||
.channel_mode = alc269_modes,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc269_laptop_dmic_setup,
|
||||
.init_hook = alc_inithook,
|
||||
},
|
||||
[ALC269_LIFEBOOK] = {
|
||||
.mixers = { alc269_lifebook_mixer },
|
||||
.init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc269_dac_nids),
|
||||
.dac_nids = alc269_dac_nids,
|
||||
.hp_nid = 0x03,
|
||||
.num_channel_mode = ARRAY_SIZE(alc269_modes),
|
||||
.channel_mode = alc269_modes,
|
||||
.input_mux = &alc269_capture_source,
|
||||
.unsol_event = alc269_lifebook_unsol_event,
|
||||
.setup = alc269_lifebook_setup,
|
||||
.init_hook = alc269_lifebook_init_hook,
|
||||
},
|
||||
[ALC271_ACER] = {
|
||||
.mixers = { alc269_asus_mixer },
|
||||
.cap_mixer = alc269vb_laptop_digital_capture_mixer,
|
||||
.init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc269_dac_nids),
|
||||
.dac_nids = alc269_dac_nids,
|
||||
.adc_nids = alc262_dmic_adc_nids,
|
||||
.num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
|
||||
.capsrc_nids = alc262_dmic_capsrc_nids,
|
||||
.num_channel_mode = ARRAY_SIZE(alc269_modes),
|
||||
.channel_mode = alc269_modes,
|
||||
.input_mux = &alc269_capture_source,
|
||||
.dig_out_nid = ALC880_DIGOUT_NID,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc269vb_laptop_dmic_setup,
|
||||
.init_hook = alc_inithook,
|
||||
},
|
||||
};
|
||||
|
1408
sound/pci/hda/alc662_quirks.c
Normal file
1408
sound/pci/hda/alc662_quirks.c
Normal file
File diff suppressed because it is too large
Load diff
222
sound/pci/hda/alc680_quirks.c
Normal file
222
sound/pci/hda/alc680_quirks.c
Normal file
|
@ -0,0 +1,222 @@
|
|||
/*
|
||||
* ALC680 quirk models
|
||||
* included by patch_realtek.c
|
||||
*/
|
||||
|
||||
/* ALC680 models */
|
||||
enum {
|
||||
ALC680_AUTO,
|
||||
ALC680_BASE,
|
||||
ALC680_MODEL_LAST,
|
||||
};
|
||||
|
||||
#define ALC680_DIGIN_NID ALC880_DIGIN_NID
|
||||
#define ALC680_DIGOUT_NID ALC880_DIGOUT_NID
|
||||
#define alc680_modes alc260_modes
|
||||
|
||||
static const hda_nid_t alc680_dac_nids[3] = {
|
||||
/* Lout1, Lout2, hp */
|
||||
0x02, 0x03, 0x04
|
||||
};
|
||||
|
||||
static const hda_nid_t alc680_adc_nids[3] = {
|
||||
/* ADC0-2 */
|
||||
/* DMIC, MIC, Line-in*/
|
||||
0x07, 0x08, 0x09
|
||||
};
|
||||
|
||||
/*
|
||||
* Analog capture ADC cgange
|
||||
*/
|
||||
static hda_nid_t alc680_get_cur_adc(struct hda_codec *codec)
|
||||
{
|
||||
static hda_nid_t pins[] = {0x18, 0x19};
|
||||
static hda_nid_t adcs[] = {0x08, 0x09};
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(pins); i++) {
|
||||
if (!is_jack_detectable(codec, pins[i]))
|
||||
continue;
|
||||
if (snd_hda_jack_detect(codec, pins[i]))
|
||||
return adcs[i];
|
||||
}
|
||||
return 0x07;
|
||||
}
|
||||
|
||||
static void alc680_rec_autoswitch(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
hda_nid_t nid = alc680_get_cur_adc(codec);
|
||||
if (spec->cur_adc && nid != spec->cur_adc) {
|
||||
__snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
|
||||
spec->cur_adc = nid;
|
||||
snd_hda_codec_setup_stream(codec, nid,
|
||||
spec->cur_adc_stream_tag, 0,
|
||||
spec->cur_adc_format);
|
||||
}
|
||||
}
|
||||
|
||||
static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
|
||||
struct hda_codec *codec,
|
||||
unsigned int stream_tag,
|
||||
unsigned int format,
|
||||
struct snd_pcm_substream *substream)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
hda_nid_t nid = alc680_get_cur_adc(codec);
|
||||
|
||||
spec->cur_adc = nid;
|
||||
spec->cur_adc_stream_tag = stream_tag;
|
||||
spec->cur_adc_format = format;
|
||||
snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
|
||||
struct hda_codec *codec,
|
||||
struct snd_pcm_substream *substream)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
|
||||
spec->cur_adc = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
|
||||
.substreams = 1, /* can be overridden */
|
||||
.channels_min = 2,
|
||||
.channels_max = 2,
|
||||
/* NID is set in alc_build_pcms */
|
||||
.ops = {
|
||||
.prepare = alc680_capture_pcm_prepare,
|
||||
.cleanup = alc680_capture_pcm_cleanup
|
||||
},
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc680_base_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x12, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Line In Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_bind_ctls alc680_bind_cap_vol = {
|
||||
.ops = &snd_hda_bind_vol,
|
||||
.values = {
|
||||
HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
|
||||
HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
|
||||
HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
|
||||
0
|
||||
},
|
||||
};
|
||||
|
||||
static const struct hda_bind_ctls alc680_bind_cap_switch = {
|
||||
.ops = &snd_hda_bind_sw,
|
||||
.values = {
|
||||
HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
|
||||
HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
|
||||
HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
|
||||
0
|
||||
},
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc680_master_capture_mixer[] = {
|
||||
HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
|
||||
HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
/*
|
||||
* generic initialization of ADC, input mixers and output mixers
|
||||
*/
|
||||
static const struct hda_verb alc680_init_verbs[] = {
|
||||
{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
|
||||
{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
||||
{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
|
||||
{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
|
||||
{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
|
||||
{0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_HP_EVENT | AC_USRSP_EN},
|
||||
{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_MIC_EVENT | AC_USRSP_EN},
|
||||
{0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC_MIC_EVENT | AC_USRSP_EN},
|
||||
|
||||
{ }
|
||||
};
|
||||
|
||||
/* toggle speaker-output according to the hp-jack state */
|
||||
static void alc680_base_setup(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
|
||||
spec->autocfg.hp_pins[0] = 0x16;
|
||||
spec->autocfg.speaker_pins[0] = 0x14;
|
||||
spec->autocfg.speaker_pins[1] = 0x15;
|
||||
spec->autocfg.num_inputs = 2;
|
||||
spec->autocfg.inputs[0].pin = 0x18;
|
||||
spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
|
||||
spec->autocfg.inputs[1].pin = 0x19;
|
||||
spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
|
||||
spec->automute = 1;
|
||||
spec->automute_mode = ALC_AUTOMUTE_AMP;
|
||||
}
|
||||
|
||||
static void alc680_unsol_event(struct hda_codec *codec,
|
||||
unsigned int res)
|
||||
{
|
||||
if ((res >> 26) == ALC_HP_EVENT)
|
||||
alc_hp_automute(codec);
|
||||
if ((res >> 26) == ALC_MIC_EVENT)
|
||||
alc680_rec_autoswitch(codec);
|
||||
}
|
||||
|
||||
static void alc680_inithook(struct hda_codec *codec)
|
||||
{
|
||||
alc_hp_automute(codec);
|
||||
alc680_rec_autoswitch(codec);
|
||||
}
|
||||
|
||||
/*
|
||||
* configuration and preset
|
||||
*/
|
||||
static const char * const alc680_models[ALC680_MODEL_LAST] = {
|
||||
[ALC680_BASE] = "base",
|
||||
[ALC680_AUTO] = "auto",
|
||||
};
|
||||
|
||||
static const struct snd_pci_quirk alc680_cfg_tbl[] = {
|
||||
SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
|
||||
{}
|
||||
};
|
||||
|
||||
static const struct alc_config_preset alc680_presets[] = {
|
||||
[ALC680_BASE] = {
|
||||
.mixers = { alc680_base_mixer },
|
||||
.cap_mixer = alc680_master_capture_mixer,
|
||||
.init_verbs = { alc680_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc680_dac_nids),
|
||||
.dac_nids = alc680_dac_nids,
|
||||
.dig_out_nid = ALC680_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc680_modes),
|
||||
.channel_mode = alc680_modes,
|
||||
.unsol_event = alc680_unsol_event,
|
||||
.setup = alc680_base_setup,
|
||||
.init_hook = alc680_inithook,
|
||||
|
||||
},
|
||||
};
|
725
sound/pci/hda/alc861_quirks.c
Normal file
725
sound/pci/hda/alc861_quirks.c
Normal file
|
@ -0,0 +1,725 @@
|
|||
/*
|
||||
* ALC660/ALC861 quirk models
|
||||
* included by patch_realtek.c
|
||||
*/
|
||||
|
||||
/* ALC861 models */
|
||||
enum {
|
||||
ALC861_AUTO,
|
||||
ALC861_3ST,
|
||||
ALC660_3ST,
|
||||
ALC861_3ST_DIG,
|
||||
ALC861_6ST_DIG,
|
||||
ALC861_UNIWILL_M31,
|
||||
ALC861_TOSHIBA,
|
||||
ALC861_ASUS,
|
||||
ALC861_ASUS_LAPTOP,
|
||||
ALC861_MODEL_LAST,
|
||||
};
|
||||
|
||||
/*
|
||||
* ALC861 channel source setting (2/6 channel selection for 3-stack)
|
||||
*/
|
||||
|
||||
/*
|
||||
* set the path ways for 2 channel output
|
||||
* need to set the codec line out and mic 1 pin widgets to inputs
|
||||
*/
|
||||
static const struct hda_verb alc861_threestack_ch2_init[] = {
|
||||
/* set pin widget 1Ah (line in) for input */
|
||||
{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
|
||||
/* set pin widget 18h (mic1/2) for input, for mic also enable
|
||||
* the vref
|
||||
*/
|
||||
{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
|
||||
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
|
||||
#if 0
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
|
||||
#endif
|
||||
{ } /* end */
|
||||
};
|
||||
/*
|
||||
* 6ch mode
|
||||
* need to set the codec line out and mic 1 pin widgets to outputs
|
||||
*/
|
||||
static const struct hda_verb alc861_threestack_ch6_init[] = {
|
||||
/* set pin widget 1Ah (line in) for output (Back Surround)*/
|
||||
{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
/* set pin widget 18h (mic1) for output (CLFE)*/
|
||||
{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
|
||||
{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
|
||||
#if 0
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
|
||||
#endif
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct hda_channel_mode alc861_threestack_modes[2] = {
|
||||
{ 2, alc861_threestack_ch2_init },
|
||||
{ 6, alc861_threestack_ch6_init },
|
||||
};
|
||||
/* Set mic1 as input and unmute the mixer */
|
||||
static const struct hda_verb alc861_uniwill_m31_ch2_init[] = {
|
||||
{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
|
||||
{ } /* end */
|
||||
};
|
||||
/* Set mic1 as output and mute mixer */
|
||||
static const struct hda_verb alc861_uniwill_m31_ch4_init[] = {
|
||||
{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
|
||||
{ 2, alc861_uniwill_m31_ch2_init },
|
||||
{ 4, alc861_uniwill_m31_ch4_init },
|
||||
};
|
||||
|
||||
/* Set mic1 and line-in as input and unmute the mixer */
|
||||
static const struct hda_verb alc861_asus_ch2_init[] = {
|
||||
/* set pin widget 1Ah (line in) for input */
|
||||
{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
|
||||
/* set pin widget 18h (mic1/2) for input, for mic also enable
|
||||
* the vref
|
||||
*/
|
||||
{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
|
||||
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
|
||||
#if 0
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
|
||||
#endif
|
||||
{ } /* end */
|
||||
};
|
||||
/* Set mic1 nad line-in as output and mute mixer */
|
||||
static const struct hda_verb alc861_asus_ch6_init[] = {
|
||||
/* set pin widget 1Ah (line in) for output (Back Surround)*/
|
||||
{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
/* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
|
||||
/* set pin widget 18h (mic1) for output (CLFE)*/
|
||||
{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
/* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
|
||||
{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
|
||||
#if 0
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
|
||||
#endif
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct hda_channel_mode alc861_asus_modes[2] = {
|
||||
{ 2, alc861_asus_ch2_init },
|
||||
{ 6, alc861_asus_ch6_init },
|
||||
};
|
||||
|
||||
/* patch-ALC861 */
|
||||
|
||||
static const struct snd_kcontrol_new alc861_base_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
|
||||
|
||||
/*Input mixer control */
|
||||
/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
|
||||
HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
|
||||
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc861_3ST_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
|
||||
/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
|
||||
|
||||
/* Input mixer control */
|
||||
/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
|
||||
HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
|
||||
|
||||
{
|
||||
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||||
.name = "Channel Mode",
|
||||
.info = alc_ch_mode_info,
|
||||
.get = alc_ch_mode_get,
|
||||
.put = alc_ch_mode_put,
|
||||
.private_value = ARRAY_SIZE(alc861_threestack_modes),
|
||||
},
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc861_toshiba_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
|
||||
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
|
||||
/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
|
||||
|
||||
/* Input mixer control */
|
||||
/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
|
||||
HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
|
||||
|
||||
{
|
||||
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||||
.name = "Channel Mode",
|
||||
.info = alc_ch_mode_info,
|
||||
.get = alc_ch_mode_get,
|
||||
.put = alc_ch_mode_put,
|
||||
.private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
|
||||
},
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc861_asus_mixer[] = {
|
||||
/* output mixer control */
|
||||
HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
|
||||
|
||||
/* Input mixer control */
|
||||
HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
|
||||
|
||||
{
|
||||
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||||
.name = "Channel Mode",
|
||||
.info = alc_ch_mode_info,
|
||||
.get = alc_ch_mode_get,
|
||||
.put = alc_ch_mode_put,
|
||||
.private_value = ARRAY_SIZE(alc861_asus_modes),
|
||||
},
|
||||
{ }
|
||||
};
|
||||
|
||||
/* additional mixer */
|
||||
static const struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
|
||||
HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
|
||||
{ }
|
||||
};
|
||||
|
||||
/*
|
||||
* generic initialization of ADC, input mixers and output mixers
|
||||
*/
|
||||
static const struct hda_verb alc861_base_init_verbs[] = {
|
||||
/*
|
||||
* Unmute ADC0 and set the default input to mic-in
|
||||
*/
|
||||
/* port-A for surround (rear panel) */
|
||||
{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
/* port-B for mic-in (rear panel) with vref */
|
||||
{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
|
||||
/* port-C for line-in (rear panel) */
|
||||
{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
|
||||
/* port-D for Front */
|
||||
{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
/* port-E for HP out (front panel) */
|
||||
{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
|
||||
/* route front PCM to HP */
|
||||
{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
/* port-F for mic-in (front panel) with vref */
|
||||
{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
|
||||
/* port-G for CLFE (rear panel) */
|
||||
{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
{ 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
/* port-H for side (rear panel) */
|
||||
{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
/* CD-in */
|
||||
{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
|
||||
/* route front mic to ADC1*/
|
||||
{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
|
||||
/* Unmute DAC0~3 & spdif out*/
|
||||
{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
|
||||
/* Unmute Mixer 14 (mic) 1c (Line in)*/
|
||||
{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
|
||||
/* Unmute Stereo Mixer 15 */
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
|
||||
|
||||
{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
/* hp used DAC 3 (Front) */
|
||||
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
|
||||
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
|
||||
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_verb alc861_threestack_init_verbs[] = {
|
||||
/*
|
||||
* Unmute ADC0 and set the default input to mic-in
|
||||
*/
|
||||
/* port-A for surround (rear panel) */
|
||||
{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
|
||||
/* port-B for mic-in (rear panel) with vref */
|
||||
{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
|
||||
/* port-C for line-in (rear panel) */
|
||||
{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
|
||||
/* port-D for Front */
|
||||
{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
/* port-E for HP out (front panel) */
|
||||
{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
|
||||
/* route front PCM to HP */
|
||||
{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
/* port-F for mic-in (front panel) with vref */
|
||||
{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
|
||||
/* port-G for CLFE (rear panel) */
|
||||
{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
|
||||
/* port-H for side (rear panel) */
|
||||
{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
|
||||
/* CD-in */
|
||||
{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
|
||||
/* route front mic to ADC1*/
|
||||
{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
/* Unmute DAC0~3 & spdif out*/
|
||||
{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
|
||||
/* Unmute Mixer 14 (mic) 1c (Line in)*/
|
||||
{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
|
||||
/* Unmute Stereo Mixer 15 */
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
|
||||
|
||||
{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
/* hp used DAC 3 (Front) */
|
||||
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
|
||||
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_verb alc861_uniwill_m31_init_verbs[] = {
|
||||
/*
|
||||
* Unmute ADC0 and set the default input to mic-in
|
||||
*/
|
||||
/* port-A for surround (rear panel) */
|
||||
{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
|
||||
/* port-B for mic-in (rear panel) with vref */
|
||||
{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
|
||||
/* port-C for line-in (rear panel) */
|
||||
{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
|
||||
/* port-D for Front */
|
||||
{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
/* port-E for HP out (front panel) */
|
||||
/* this has to be set to VREF80 */
|
||||
{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
|
||||
/* route front PCM to HP */
|
||||
{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
/* port-F for mic-in (front panel) with vref */
|
||||
{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
|
||||
/* port-G for CLFE (rear panel) */
|
||||
{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
|
||||
/* port-H for side (rear panel) */
|
||||
{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
|
||||
/* CD-in */
|
||||
{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
|
||||
/* route front mic to ADC1*/
|
||||
{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
/* Unmute DAC0~3 & spdif out*/
|
||||
{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
|
||||
/* Unmute Mixer 14 (mic) 1c (Line in)*/
|
||||
{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
|
||||
/* Unmute Stereo Mixer 15 */
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
|
||||
|
||||
{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
/* hp used DAC 3 (Front) */
|
||||
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
|
||||
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_verb alc861_asus_init_verbs[] = {
|
||||
/*
|
||||
* Unmute ADC0 and set the default input to mic-in
|
||||
*/
|
||||
/* port-A for surround (rear panel)
|
||||
* according to codec#0 this is the HP jack
|
||||
*/
|
||||
{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
|
||||
/* route front PCM to HP */
|
||||
{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
|
||||
/* port-B for mic-in (rear panel) with vref */
|
||||
{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
|
||||
/* port-C for line-in (rear panel) */
|
||||
{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
|
||||
/* port-D for Front */
|
||||
{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
/* port-E for HP out (front panel) */
|
||||
/* this has to be set to VREF80 */
|
||||
{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
|
||||
/* route front PCM to HP */
|
||||
{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
|
||||
/* port-F for mic-in (front panel) with vref */
|
||||
{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
|
||||
/* port-G for CLFE (rear panel) */
|
||||
{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
/* port-H for side (rear panel) */
|
||||
{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
|
||||
/* CD-in */
|
||||
{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
|
||||
/* route front mic to ADC1*/
|
||||
{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
/* Unmute DAC0~3 & spdif out*/
|
||||
{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
/* Unmute Mixer 14 (mic) 1c (Line in)*/
|
||||
{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
|
||||
/* Unmute Stereo Mixer 15 */
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
|
||||
|
||||
{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
/* hp used DAC 3 (Front) */
|
||||
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
|
||||
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
|
||||
{ }
|
||||
};
|
||||
|
||||
/* additional init verbs for ASUS laptops */
|
||||
static const struct hda_verb alc861_asus_laptop_init_verbs[] = {
|
||||
{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
|
||||
{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_verb alc861_toshiba_init_verbs[] = {
|
||||
{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
|
||||
|
||||
{ }
|
||||
};
|
||||
|
||||
/* toggle speaker-output according to the hp-jack state */
|
||||
static void alc861_toshiba_automute(struct hda_codec *codec)
|
||||
{
|
||||
unsigned int present = snd_hda_jack_detect(codec, 0x0f);
|
||||
|
||||
snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
|
||||
HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
|
||||
snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
|
||||
HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
|
||||
}
|
||||
|
||||
static void alc861_toshiba_unsol_event(struct hda_codec *codec,
|
||||
unsigned int res)
|
||||
{
|
||||
if ((res >> 26) == ALC_HP_EVENT)
|
||||
alc861_toshiba_automute(codec);
|
||||
}
|
||||
|
||||
#define ALC861_DIGOUT_NID 0x07
|
||||
|
||||
static const struct hda_channel_mode alc861_8ch_modes[1] = {
|
||||
{ 8, NULL }
|
||||
};
|
||||
|
||||
static const hda_nid_t alc861_dac_nids[4] = {
|
||||
/* front, surround, clfe, side */
|
||||
0x03, 0x06, 0x05, 0x04
|
||||
};
|
||||
|
||||
static const hda_nid_t alc660_dac_nids[3] = {
|
||||
/* front, clfe, surround */
|
||||
0x03, 0x05, 0x06
|
||||
};
|
||||
|
||||
static const hda_nid_t alc861_adc_nids[1] = {
|
||||
/* ADC0-2 */
|
||||
0x08,
|
||||
};
|
||||
|
||||
static const struct hda_input_mux alc861_capture_source = {
|
||||
.num_items = 5,
|
||||
.items = {
|
||||
{ "Mic", 0x0 },
|
||||
{ "Front Mic", 0x3 },
|
||||
{ "Line", 0x1 },
|
||||
{ "CD", 0x4 },
|
||||
{ "Mixer", 0x5 },
|
||||
},
|
||||
};
|
||||
|
||||
/*
|
||||
* configuration and preset
|
||||
*/
|
||||
static const char * const alc861_models[ALC861_MODEL_LAST] = {
|
||||
[ALC861_3ST] = "3stack",
|
||||
[ALC660_3ST] = "3stack-660",
|
||||
[ALC861_3ST_DIG] = "3stack-dig",
|
||||
[ALC861_6ST_DIG] = "6stack-dig",
|
||||
[ALC861_UNIWILL_M31] = "uniwill-m31",
|
||||
[ALC861_TOSHIBA] = "toshiba",
|
||||
[ALC861_ASUS] = "asus",
|
||||
[ALC861_ASUS_LAPTOP] = "asus-laptop",
|
||||
[ALC861_AUTO] = "auto",
|
||||
};
|
||||
|
||||
static const struct snd_pci_quirk alc861_cfg_tbl[] = {
|
||||
SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
|
||||
SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
|
||||
SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
|
||||
SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
|
||||
SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
|
||||
SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
|
||||
SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
|
||||
/* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
|
||||
* Any other models that need this preset?
|
||||
*/
|
||||
/* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
|
||||
SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
|
||||
SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
|
||||
SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
|
||||
SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
|
||||
SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
|
||||
/* FIXME: the below seems conflict */
|
||||
/* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
|
||||
SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
|
||||
SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
|
||||
{}
|
||||
};
|
||||
|
||||
static const struct alc_config_preset alc861_presets[] = {
|
||||
[ALC861_3ST] = {
|
||||
.mixers = { alc861_3ST_mixer },
|
||||
.init_verbs = { alc861_threestack_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc861_dac_nids),
|
||||
.dac_nids = alc861_dac_nids,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
|
||||
.channel_mode = alc861_threestack_modes,
|
||||
.need_dac_fix = 1,
|
||||
.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
|
||||
.adc_nids = alc861_adc_nids,
|
||||
.input_mux = &alc861_capture_source,
|
||||
},
|
||||
[ALC861_3ST_DIG] = {
|
||||
.mixers = { alc861_base_mixer },
|
||||
.init_verbs = { alc861_threestack_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc861_dac_nids),
|
||||
.dac_nids = alc861_dac_nids,
|
||||
.dig_out_nid = ALC861_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
|
||||
.channel_mode = alc861_threestack_modes,
|
||||
.need_dac_fix = 1,
|
||||
.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
|
||||
.adc_nids = alc861_adc_nids,
|
||||
.input_mux = &alc861_capture_source,
|
||||
},
|
||||
[ALC861_6ST_DIG] = {
|
||||
.mixers = { alc861_base_mixer },
|
||||
.init_verbs = { alc861_base_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc861_dac_nids),
|
||||
.dac_nids = alc861_dac_nids,
|
||||
.dig_out_nid = ALC861_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
|
||||
.channel_mode = alc861_8ch_modes,
|
||||
.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
|
||||
.adc_nids = alc861_adc_nids,
|
||||
.input_mux = &alc861_capture_source,
|
||||
},
|
||||
[ALC660_3ST] = {
|
||||
.mixers = { alc861_3ST_mixer },
|
||||
.init_verbs = { alc861_threestack_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc660_dac_nids),
|
||||
.dac_nids = alc660_dac_nids,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
|
||||
.channel_mode = alc861_threestack_modes,
|
||||
.need_dac_fix = 1,
|
||||
.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
|
||||
.adc_nids = alc861_adc_nids,
|
||||
.input_mux = &alc861_capture_source,
|
||||
},
|
||||
[ALC861_UNIWILL_M31] = {
|
||||
.mixers = { alc861_uniwill_m31_mixer },
|
||||
.init_verbs = { alc861_uniwill_m31_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc861_dac_nids),
|
||||
.dac_nids = alc861_dac_nids,
|
||||
.dig_out_nid = ALC861_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
|
||||
.channel_mode = alc861_uniwill_m31_modes,
|
||||
.need_dac_fix = 1,
|
||||
.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
|
||||
.adc_nids = alc861_adc_nids,
|
||||
.input_mux = &alc861_capture_source,
|
||||
},
|
||||
[ALC861_TOSHIBA] = {
|
||||
.mixers = { alc861_toshiba_mixer },
|
||||
.init_verbs = { alc861_base_init_verbs,
|
||||
alc861_toshiba_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc861_dac_nids),
|
||||
.dac_nids = alc861_dac_nids,
|
||||
.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
|
||||
.channel_mode = alc883_3ST_2ch_modes,
|
||||
.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
|
||||
.adc_nids = alc861_adc_nids,
|
||||
.input_mux = &alc861_capture_source,
|
||||
.unsol_event = alc861_toshiba_unsol_event,
|
||||
.init_hook = alc861_toshiba_automute,
|
||||
},
|
||||
[ALC861_ASUS] = {
|
||||
.mixers = { alc861_asus_mixer },
|
||||
.init_verbs = { alc861_asus_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc861_dac_nids),
|
||||
.dac_nids = alc861_dac_nids,
|
||||
.dig_out_nid = ALC861_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
|
||||
.channel_mode = alc861_asus_modes,
|
||||
.need_dac_fix = 1,
|
||||
.hp_nid = 0x06,
|
||||
.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
|
||||
.adc_nids = alc861_adc_nids,
|
||||
.input_mux = &alc861_capture_source,
|
||||
},
|
||||
[ALC861_ASUS_LAPTOP] = {
|
||||
.mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
|
||||
.init_verbs = { alc861_asus_init_verbs,
|
||||
alc861_asus_laptop_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc861_dac_nids),
|
||||
.dac_nids = alc861_dac_nids,
|
||||
.dig_out_nid = ALC861_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
|
||||
.channel_mode = alc883_3ST_2ch_modes,
|
||||
.need_dac_fix = 1,
|
||||
.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
|
||||
.adc_nids = alc861_adc_nids,
|
||||
.input_mux = &alc861_capture_source,
|
||||
},
|
||||
};
|
||||
|
605
sound/pci/hda/alc861vd_quirks.c
Normal file
605
sound/pci/hda/alc861vd_quirks.c
Normal file
|
@ -0,0 +1,605 @@
|
|||
/*
|
||||
* ALC660-VD/ALC861-VD quirk models
|
||||
* included by patch_realtek.c
|
||||
*/
|
||||
|
||||
/* ALC861-VD models */
|
||||
enum {
|
||||
ALC861VD_AUTO,
|
||||
ALC660VD_3ST,
|
||||
ALC660VD_3ST_DIG,
|
||||
ALC660VD_ASUS_V1S,
|
||||
ALC861VD_3ST,
|
||||
ALC861VD_3ST_DIG,
|
||||
ALC861VD_6ST_DIG,
|
||||
ALC861VD_LENOVO,
|
||||
ALC861VD_DALLAS,
|
||||
ALC861VD_HP,
|
||||
ALC861VD_MODEL_LAST,
|
||||
};
|
||||
|
||||
#define ALC861VD_DIGOUT_NID 0x06
|
||||
|
||||
static const hda_nid_t alc861vd_dac_nids[4] = {
|
||||
/* front, surr, clfe, side surr */
|
||||
0x02, 0x03, 0x04, 0x05
|
||||
};
|
||||
|
||||
/* dac_nids for ALC660vd are in a different order - according to
|
||||
* Realtek's driver.
|
||||
* This should probably result in a different mixer for 6stack models
|
||||
* of ALC660vd codecs, but for now there is only 3stack mixer
|
||||
* - and it is the same as in 861vd.
|
||||
* adc_nids in ALC660vd are (is) the same as in 861vd
|
||||
*/
|
||||
static const hda_nid_t alc660vd_dac_nids[3] = {
|
||||
/* front, rear, clfe, rear_surr */
|
||||
0x02, 0x04, 0x03
|
||||
};
|
||||
|
||||
static const hda_nid_t alc861vd_adc_nids[1] = {
|
||||
/* ADC0 */
|
||||
0x09,
|
||||
};
|
||||
|
||||
static const hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
|
||||
|
||||
/* input MUX */
|
||||
/* FIXME: should be a matrix-type input source selection */
|
||||
static const struct hda_input_mux alc861vd_capture_source = {
|
||||
.num_items = 4,
|
||||
.items = {
|
||||
{ "Mic", 0x0 },
|
||||
{ "Front Mic", 0x1 },
|
||||
{ "Line", 0x2 },
|
||||
{ "CD", 0x4 },
|
||||
},
|
||||
};
|
||||
|
||||
static const struct hda_input_mux alc861vd_dallas_capture_source = {
|
||||
.num_items = 2,
|
||||
.items = {
|
||||
{ "Mic", 0x0 },
|
||||
{ "Internal Mic", 0x1 },
|
||||
},
|
||||
};
|
||||
|
||||
static const struct hda_input_mux alc861vd_hp_capture_source = {
|
||||
.num_items = 2,
|
||||
.items = {
|
||||
{ "Front Mic", 0x0 },
|
||||
{ "ATAPI Mic", 0x1 },
|
||||
},
|
||||
};
|
||||
|
||||
/*
|
||||
* 2ch mode
|
||||
*/
|
||||
static const struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
|
||||
{ 2, NULL }
|
||||
};
|
||||
|
||||
/*
|
||||
* 6ch mode
|
||||
*/
|
||||
static const struct hda_verb alc861vd_6stack_ch6_init[] = {
|
||||
{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
|
||||
{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
|
||||
{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
|
||||
{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
/*
|
||||
* 8ch mode
|
||||
*/
|
||||
static const struct hda_verb alc861vd_6stack_ch8_init[] = {
|
||||
{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
|
||||
{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
|
||||
{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
|
||||
{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct hda_channel_mode alc861vd_6stack_modes[2] = {
|
||||
{ 6, alc861vd_6stack_ch6_init },
|
||||
{ 8, alc861vd_6stack_ch8_init },
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
|
||||
{
|
||||
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||||
.name = "Channel Mode",
|
||||
.info = alc_ch_mode_info,
|
||||
.get = alc_ch_mode_get,
|
||||
.put = alc_ch_mode_put,
|
||||
},
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
|
||||
* Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
|
||||
*/
|
||||
static const struct snd_kcontrol_new alc861vd_6st_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
|
||||
|
||||
HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
|
||||
|
||||
HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
|
||||
HDA_OUTPUT),
|
||||
HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
|
||||
HDA_OUTPUT),
|
||||
HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
|
||||
HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
|
||||
|
||||
HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
|
||||
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
|
||||
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
|
||||
|
||||
HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
|
||||
|
||||
HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
|
||||
|
||||
HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
|
||||
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc861vd_3st_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
|
||||
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
|
||||
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
|
||||
|
||||
HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
|
||||
|
||||
HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
|
||||
|
||||
HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
|
||||
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
static const struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
|
||||
/*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
|
||||
HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
|
||||
|
||||
HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
|
||||
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
|
||||
|
||||
HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
|
||||
|
||||
HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
|
||||
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
/* Pin assignment: Speaker=0x14, HP = 0x15,
|
||||
* Mic=0x18, Internal Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
|
||||
*/
|
||||
static const struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
/* Pin assignment: Speaker=0x14, Line-out = 0x15,
|
||||
* Front Mic=0x18, ATAPI Mic = 0x19,
|
||||
*/
|
||||
static const struct snd_kcontrol_new alc861vd_hp_mixer[] = {
|
||||
HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
|
||||
HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
|
||||
HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
|
||||
HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
|
||||
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
/*
|
||||
* generic initialization of ADC, input mixers and output mixers
|
||||
*/
|
||||
static const struct hda_verb alc861vd_volume_init_verbs[] = {
|
||||
/*
|
||||
* Unmute ADC0 and set the default input to mic-in
|
||||
*/
|
||||
{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
|
||||
/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
|
||||
* the analog-loopback mixer widget
|
||||
*/
|
||||
/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
|
||||
{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
||||
{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
||||
{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
|
||||
{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
|
||||
{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
|
||||
|
||||
/* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
|
||||
{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
|
||||
{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
|
||||
|
||||
/*
|
||||
* Set up output mixers (0x02 - 0x05)
|
||||
*/
|
||||
/* set vol=0 to output mixers */
|
||||
{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
|
||||
/* set up input amps for analog loopback */
|
||||
/* Amp Indices: DAC = 0, mixer = 1 */
|
||||
{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
||||
{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
||||
{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
||||
{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
||||
{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
||||
{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
||||
{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
||||
{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
||||
|
||||
{ }
|
||||
};
|
||||
|
||||
/*
|
||||
* 3-stack pin configuration:
|
||||
* front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
|
||||
*/
|
||||
static const struct hda_verb alc861vd_3stack_init_verbs[] = {
|
||||
/*
|
||||
* Set pin mode and muting
|
||||
*/
|
||||
/* set front pin widgets 0x14 for output */
|
||||
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
|
||||
/* Mic (rear) pin: input vref at 80% */
|
||||
{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
/* Front Mic pin: input vref at 80% */
|
||||
{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
|
||||
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
/* Line In pin: input */
|
||||
{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
/* Line-2 In: Headphone output (output 0 - 0x0c) */
|
||||
{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
||||
{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
/* CD pin widget for input */
|
||||
{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
|
||||
{ }
|
||||
};
|
||||
|
||||
/*
|
||||
* 6-stack pin configuration:
|
||||
*/
|
||||
static const struct hda_verb alc861vd_6stack_init_verbs[] = {
|
||||
/*
|
||||
* Set pin mode and muting
|
||||
*/
|
||||
/* set front pin widgets 0x14 for output */
|
||||
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
|
||||
/* Rear Pin: output 1 (0x0d) */
|
||||
{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
|
||||
/* CLFE Pin: output 2 (0x0e) */
|
||||
{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
|
||||
/* Side Pin: output 3 (0x0f) */
|
||||
{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
|
||||
|
||||
/* Mic (rear) pin: input vref at 80% */
|
||||
{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
/* Front Mic pin: input vref at 80% */
|
||||
{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
|
||||
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
/* Line In pin: input */
|
||||
{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
/* Line-2 In: Headphone output (output 0 - 0x0c) */
|
||||
{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
|
||||
{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
/* CD pin widget for input */
|
||||
{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_verb alc861vd_eapd_verbs[] = {
|
||||
{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
|
||||
{ }
|
||||
};
|
||||
|
||||
static const struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
|
||||
{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
|
||||
{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
|
||||
{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_MIC_EVENT},
|
||||
{}
|
||||
};
|
||||
|
||||
static void alc861vd_lenovo_setup(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
spec->autocfg.hp_pins[0] = 0x1b;
|
||||
spec->autocfg.speaker_pins[0] = 0x14;
|
||||
spec->automute = 1;
|
||||
spec->automute_mode = ALC_AUTOMUTE_AMP;
|
||||
}
|
||||
|
||||
static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
|
||||
{
|
||||
alc_hp_automute(codec);
|
||||
alc88x_simple_mic_automute(codec);
|
||||
}
|
||||
|
||||
static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
|
||||
unsigned int res)
|
||||
{
|
||||
switch (res >> 26) {
|
||||
case ALC_MIC_EVENT:
|
||||
alc88x_simple_mic_automute(codec);
|
||||
break;
|
||||
default:
|
||||
alc_sku_unsol_event(codec, res);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static const struct hda_verb alc861vd_dallas_verbs[] = {
|
||||
{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
|
||||
|
||||
{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
|
||||
{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
||||
{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
||||
{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
||||
{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
||||
{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
||||
{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
|
||||
|
||||
{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
|
||||
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
|
||||
|
||||
{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
|
||||
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
|
||||
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
|
||||
{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
|
||||
|
||||
{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
|
||||
{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
|
||||
{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
|
||||
{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
|
||||
|
||||
{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
|
||||
{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
|
||||
{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
|
||||
|
||||
{ } /* end */
|
||||
};
|
||||
|
||||
/* toggle speaker-output according to the hp-jack state */
|
||||
static void alc861vd_dallas_setup(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
|
||||
spec->autocfg.hp_pins[0] = 0x15;
|
||||
spec->autocfg.speaker_pins[0] = 0x14;
|
||||
spec->automute = 1;
|
||||
spec->automute_mode = ALC_AUTOMUTE_AMP;
|
||||
}
|
||||
|
||||
/*
|
||||
* configuration and preset
|
||||
*/
|
||||
static const char * const alc861vd_models[ALC861VD_MODEL_LAST] = {
|
||||
[ALC660VD_3ST] = "3stack-660",
|
||||
[ALC660VD_3ST_DIG] = "3stack-660-digout",
|
||||
[ALC660VD_ASUS_V1S] = "asus-v1s",
|
||||
[ALC861VD_3ST] = "3stack",
|
||||
[ALC861VD_3ST_DIG] = "3stack-digout",
|
||||
[ALC861VD_6ST_DIG] = "6stack-digout",
|
||||
[ALC861VD_LENOVO] = "lenovo",
|
||||
[ALC861VD_DALLAS] = "dallas",
|
||||
[ALC861VD_HP] = "hp",
|
||||
[ALC861VD_AUTO] = "auto",
|
||||
};
|
||||
|
||||
static const struct snd_pci_quirk alc861vd_cfg_tbl[] = {
|
||||
SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
|
||||
SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
|
||||
SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
|
||||
/*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
|
||||
SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
|
||||
SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
|
||||
SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
|
||||
SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
|
||||
/*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
|
||||
SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
|
||||
SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
|
||||
SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
|
||||
SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
|
||||
SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
|
||||
SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
|
||||
{}
|
||||
};
|
||||
|
||||
static const struct alc_config_preset alc861vd_presets[] = {
|
||||
[ALC660VD_3ST] = {
|
||||
.mixers = { alc861vd_3st_mixer },
|
||||
.init_verbs = { alc861vd_volume_init_verbs,
|
||||
alc861vd_3stack_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
|
||||
.dac_nids = alc660vd_dac_nids,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
|
||||
.channel_mode = alc861vd_3stack_2ch_modes,
|
||||
.input_mux = &alc861vd_capture_source,
|
||||
},
|
||||
[ALC660VD_3ST_DIG] = {
|
||||
.mixers = { alc861vd_3st_mixer },
|
||||
.init_verbs = { alc861vd_volume_init_verbs,
|
||||
alc861vd_3stack_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
|
||||
.dac_nids = alc660vd_dac_nids,
|
||||
.dig_out_nid = ALC861VD_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
|
||||
.channel_mode = alc861vd_3stack_2ch_modes,
|
||||
.input_mux = &alc861vd_capture_source,
|
||||
},
|
||||
[ALC861VD_3ST] = {
|
||||
.mixers = { alc861vd_3st_mixer },
|
||||
.init_verbs = { alc861vd_volume_init_verbs,
|
||||
alc861vd_3stack_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
|
||||
.dac_nids = alc861vd_dac_nids,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
|
||||
.channel_mode = alc861vd_3stack_2ch_modes,
|
||||
.input_mux = &alc861vd_capture_source,
|
||||
},
|
||||
[ALC861VD_3ST_DIG] = {
|
||||
.mixers = { alc861vd_3st_mixer },
|
||||
.init_verbs = { alc861vd_volume_init_verbs,
|
||||
alc861vd_3stack_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
|
||||
.dac_nids = alc861vd_dac_nids,
|
||||
.dig_out_nid = ALC861VD_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
|
||||
.channel_mode = alc861vd_3stack_2ch_modes,
|
||||
.input_mux = &alc861vd_capture_source,
|
||||
},
|
||||
[ALC861VD_6ST_DIG] = {
|
||||
.mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
|
||||
.init_verbs = { alc861vd_volume_init_verbs,
|
||||
alc861vd_6stack_init_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
|
||||
.dac_nids = alc861vd_dac_nids,
|
||||
.dig_out_nid = ALC861VD_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
|
||||
.channel_mode = alc861vd_6stack_modes,
|
||||
.input_mux = &alc861vd_capture_source,
|
||||
},
|
||||
[ALC861VD_LENOVO] = {
|
||||
.mixers = { alc861vd_lenovo_mixer },
|
||||
.init_verbs = { alc861vd_volume_init_verbs,
|
||||
alc861vd_3stack_init_verbs,
|
||||
alc861vd_eapd_verbs,
|
||||
alc861vd_lenovo_unsol_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
|
||||
.dac_nids = alc660vd_dac_nids,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
|
||||
.channel_mode = alc861vd_3stack_2ch_modes,
|
||||
.input_mux = &alc861vd_capture_source,
|
||||
.unsol_event = alc861vd_lenovo_unsol_event,
|
||||
.setup = alc861vd_lenovo_setup,
|
||||
.init_hook = alc861vd_lenovo_init_hook,
|
||||
},
|
||||
[ALC861VD_DALLAS] = {
|
||||
.mixers = { alc861vd_dallas_mixer },
|
||||
.init_verbs = { alc861vd_dallas_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
|
||||
.dac_nids = alc861vd_dac_nids,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
|
||||
.channel_mode = alc861vd_3stack_2ch_modes,
|
||||
.input_mux = &alc861vd_dallas_capture_source,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc861vd_dallas_setup,
|
||||
.init_hook = alc_hp_automute,
|
||||
},
|
||||
[ALC861VD_HP] = {
|
||||
.mixers = { alc861vd_hp_mixer },
|
||||
.init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
|
||||
.dac_nids = alc861vd_dac_nids,
|
||||
.dig_out_nid = ALC861VD_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
|
||||
.channel_mode = alc861vd_3stack_2ch_modes,
|
||||
.input_mux = &alc861vd_hp_capture_source,
|
||||
.unsol_event = alc_sku_unsol_event,
|
||||
.setup = alc861vd_dallas_setup,
|
||||
.init_hook = alc_hp_automute,
|
||||
},
|
||||
[ALC660VD_ASUS_V1S] = {
|
||||
.mixers = { alc861vd_lenovo_mixer },
|
||||
.init_verbs = { alc861vd_volume_init_verbs,
|
||||
alc861vd_3stack_init_verbs,
|
||||
alc861vd_eapd_verbs,
|
||||
alc861vd_lenovo_unsol_verbs },
|
||||
.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
|
||||
.dac_nids = alc660vd_dac_nids,
|
||||
.dig_out_nid = ALC861VD_DIGOUT_NID,
|
||||
.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
|
||||
.channel_mode = alc861vd_3stack_2ch_modes,
|
||||
.input_mux = &alc861vd_capture_source,
|
||||
.unsol_event = alc861vd_lenovo_unsol_event,
|
||||
.setup = alc861vd_lenovo_setup,
|
||||
.init_hook = alc861vd_lenovo_init_hook,
|
||||
},
|
||||
};
|
||||
|
1898
sound/pci/hda/alc880_quirks.c
Normal file
1898
sound/pci/hda/alc880_quirks.c
Normal file
File diff suppressed because it is too large
Load diff
3755
sound/pci/hda/alc882_quirks.c
Normal file
3755
sound/pci/hda/alc882_quirks.c
Normal file
File diff suppressed because it is too large
Load diff
467
sound/pci/hda/alc_quirks.c
Normal file
467
sound/pci/hda/alc_quirks.c
Normal file
|
@ -0,0 +1,467 @@
|
|||
/*
|
||||
* Common codes for Realtek codec quirks
|
||||
* included by patch_realtek.c
|
||||
*/
|
||||
|
||||
/*
|
||||
* configuration template - to be copied to the spec instance
|
||||
*/
|
||||
struct alc_config_preset {
|
||||
const struct snd_kcontrol_new *mixers[5]; /* should be identical size
|
||||
* with spec
|
||||
*/
|
||||
const struct snd_kcontrol_new *cap_mixer; /* capture mixer */
|
||||
const struct hda_verb *init_verbs[5];
|
||||
unsigned int num_dacs;
|
||||
const hda_nid_t *dac_nids;
|
||||
hda_nid_t dig_out_nid; /* optional */
|
||||
hda_nid_t hp_nid; /* optional */
|
||||
const hda_nid_t *slave_dig_outs;
|
||||
unsigned int num_adc_nids;
|
||||
const hda_nid_t *adc_nids;
|
||||
const hda_nid_t *capsrc_nids;
|
||||
hda_nid_t dig_in_nid;
|
||||
unsigned int num_channel_mode;
|
||||
const struct hda_channel_mode *channel_mode;
|
||||
int need_dac_fix;
|
||||
int const_channel_count;
|
||||
unsigned int num_mux_defs;
|
||||
const struct hda_input_mux *input_mux;
|
||||
void (*unsol_event)(struct hda_codec *, unsigned int);
|
||||
void (*setup)(struct hda_codec *);
|
||||
void (*init_hook)(struct hda_codec *);
|
||||
#ifdef CONFIG_SND_HDA_POWER_SAVE
|
||||
const struct hda_amp_list *loopbacks;
|
||||
void (*power_hook)(struct hda_codec *codec);
|
||||
#endif
|
||||
};
|
||||
|
||||
/*
|
||||
* channel mode setting
|
||||
*/
|
||||
static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_info *uinfo)
|
||||
{
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
struct alc_spec *spec = codec->spec;
|
||||
return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
|
||||
spec->num_channel_mode);
|
||||
}
|
||||
|
||||
static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
struct alc_spec *spec = codec->spec;
|
||||
return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
|
||||
spec->num_channel_mode,
|
||||
spec->ext_channel_count);
|
||||
}
|
||||
|
||||
static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
struct alc_spec *spec = codec->spec;
|
||||
int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
|
||||
spec->num_channel_mode,
|
||||
&spec->ext_channel_count);
|
||||
if (err >= 0 && !spec->const_channel_count) {
|
||||
spec->multiout.max_channels = spec->ext_channel_count;
|
||||
if (spec->need_dac_fix)
|
||||
spec->multiout.num_dacs = spec->multiout.max_channels / 2;
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
/*
|
||||
* Control the mode of pin widget settings via the mixer. "pc" is used
|
||||
* instead of "%" to avoid consequences of accidentally treating the % as
|
||||
* being part of a format specifier. Maximum allowed length of a value is
|
||||
* 63 characters plus NULL terminator.
|
||||
*
|
||||
* Note: some retasking pin complexes seem to ignore requests for input
|
||||
* states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
|
||||
* are requested. Therefore order this list so that this behaviour will not
|
||||
* cause problems when mixer clients move through the enum sequentially.
|
||||
* NIDs 0x0f and 0x10 have been observed to have this behaviour as of
|
||||
* March 2006.
|
||||
*/
|
||||
static const char * const alc_pin_mode_names[] = {
|
||||
"Mic 50pc bias", "Mic 80pc bias",
|
||||
"Line in", "Line out", "Headphone out",
|
||||
};
|
||||
static const unsigned char alc_pin_mode_values[] = {
|
||||
PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
|
||||
};
|
||||
/* The control can present all 5 options, or it can limit the options based
|
||||
* in the pin being assumed to be exclusively an input or an output pin. In
|
||||
* addition, "input" pins may or may not process the mic bias option
|
||||
* depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
|
||||
* accept requests for bias as of chip versions up to March 2006) and/or
|
||||
* wiring in the computer.
|
||||
*/
|
||||
#define ALC_PIN_DIR_IN 0x00
|
||||
#define ALC_PIN_DIR_OUT 0x01
|
||||
#define ALC_PIN_DIR_INOUT 0x02
|
||||
#define ALC_PIN_DIR_IN_NOMICBIAS 0x03
|
||||
#define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
|
||||
|
||||
/* Info about the pin modes supported by the different pin direction modes.
|
||||
* For each direction the minimum and maximum values are given.
|
||||
*/
|
||||
static const signed char alc_pin_mode_dir_info[5][2] = {
|
||||
{ 0, 2 }, /* ALC_PIN_DIR_IN */
|
||||
{ 3, 4 }, /* ALC_PIN_DIR_OUT */
|
||||
{ 0, 4 }, /* ALC_PIN_DIR_INOUT */
|
||||
{ 2, 2 }, /* ALC_PIN_DIR_IN_NOMICBIAS */
|
||||
{ 2, 4 }, /* ALC_PIN_DIR_INOUT_NOMICBIAS */
|
||||
};
|
||||
#define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
|
||||
#define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
|
||||
#define alc_pin_mode_n_items(_dir) \
|
||||
(alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
|
||||
|
||||
static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_info *uinfo)
|
||||
{
|
||||
unsigned int item_num = uinfo->value.enumerated.item;
|
||||
unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
|
||||
|
||||
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
|
||||
uinfo->count = 1;
|
||||
uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
|
||||
|
||||
if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
|
||||
item_num = alc_pin_mode_min(dir);
|
||||
strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
unsigned int i;
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
||||
unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
|
||||
long *valp = ucontrol->value.integer.value;
|
||||
unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
|
||||
AC_VERB_GET_PIN_WIDGET_CONTROL,
|
||||
0x00);
|
||||
|
||||
/* Find enumerated value for current pinctl setting */
|
||||
i = alc_pin_mode_min(dir);
|
||||
while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
|
||||
i++;
|
||||
*valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
signed int change;
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
||||
unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
|
||||
long val = *ucontrol->value.integer.value;
|
||||
unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
|
||||
AC_VERB_GET_PIN_WIDGET_CONTROL,
|
||||
0x00);
|
||||
|
||||
if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
|
||||
val = alc_pin_mode_min(dir);
|
||||
|
||||
change = pinctl != alc_pin_mode_values[val];
|
||||
if (change) {
|
||||
/* Set pin mode to that requested */
|
||||
snd_hda_codec_write_cache(codec, nid, 0,
|
||||
AC_VERB_SET_PIN_WIDGET_CONTROL,
|
||||
alc_pin_mode_values[val]);
|
||||
|
||||
/* Also enable the retasking pin's input/output as required
|
||||
* for the requested pin mode. Enum values of 2 or less are
|
||||
* input modes.
|
||||
*
|
||||
* Dynamically switching the input/output buffers probably
|
||||
* reduces noise slightly (particularly on input) so we'll
|
||||
* do it. However, having both input and output buffers
|
||||
* enabled simultaneously doesn't seem to be problematic if
|
||||
* this turns out to be necessary in the future.
|
||||
*/
|
||||
if (val <= 2) {
|
||||
snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
|
||||
HDA_AMP_MUTE, HDA_AMP_MUTE);
|
||||
snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
|
||||
HDA_AMP_MUTE, 0);
|
||||
} else {
|
||||
snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
|
||||
HDA_AMP_MUTE, HDA_AMP_MUTE);
|
||||
snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
|
||||
HDA_AMP_MUTE, 0);
|
||||
}
|
||||
}
|
||||
return change;
|
||||
}
|
||||
|
||||
#define ALC_PIN_MODE(xname, nid, dir) \
|
||||
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
|
||||
.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
|
||||
.info = alc_pin_mode_info, \
|
||||
.get = alc_pin_mode_get, \
|
||||
.put = alc_pin_mode_put, \
|
||||
.private_value = nid | (dir<<16) }
|
||||
|
||||
/* A switch control for ALC260 GPIO pins. Multiple GPIOs can be ganged
|
||||
* together using a mask with more than one bit set. This control is
|
||||
* currently used only by the ALC260 test model. At this stage they are not
|
||||
* needed for any "production" models.
|
||||
*/
|
||||
#ifdef CONFIG_SND_DEBUG
|
||||
#define alc_gpio_data_info snd_ctl_boolean_mono_info
|
||||
|
||||
static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
||||
unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
|
||||
long *valp = ucontrol->value.integer.value;
|
||||
unsigned int val = snd_hda_codec_read(codec, nid, 0,
|
||||
AC_VERB_GET_GPIO_DATA, 0x00);
|
||||
|
||||
*valp = (val & mask) != 0;
|
||||
return 0;
|
||||
}
|
||||
static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
signed int change;
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
||||
unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
|
||||
long val = *ucontrol->value.integer.value;
|
||||
unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
|
||||
AC_VERB_GET_GPIO_DATA,
|
||||
0x00);
|
||||
|
||||
/* Set/unset the masked GPIO bit(s) as needed */
|
||||
change = (val == 0 ? 0 : mask) != (gpio_data & mask);
|
||||
if (val == 0)
|
||||
gpio_data &= ~mask;
|
||||
else
|
||||
gpio_data |= mask;
|
||||
snd_hda_codec_write_cache(codec, nid, 0,
|
||||
AC_VERB_SET_GPIO_DATA, gpio_data);
|
||||
|
||||
return change;
|
||||
}
|
||||
#define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
|
||||
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
|
||||
.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
|
||||
.info = alc_gpio_data_info, \
|
||||
.get = alc_gpio_data_get, \
|
||||
.put = alc_gpio_data_put, \
|
||||
.private_value = nid | (mask<<16) }
|
||||
#endif /* CONFIG_SND_DEBUG */
|
||||
|
||||
/* A switch control to allow the enabling of the digital IO pins on the
|
||||
* ALC260. This is incredibly simplistic; the intention of this control is
|
||||
* to provide something in the test model allowing digital outputs to be
|
||||
* identified if present. If models are found which can utilise these
|
||||
* outputs a more complete mixer control can be devised for those models if
|
||||
* necessary.
|
||||
*/
|
||||
#ifdef CONFIG_SND_DEBUG
|
||||
#define alc_spdif_ctrl_info snd_ctl_boolean_mono_info
|
||||
|
||||
static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
||||
unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
|
||||
long *valp = ucontrol->value.integer.value;
|
||||
unsigned int val = snd_hda_codec_read(codec, nid, 0,
|
||||
AC_VERB_GET_DIGI_CONVERT_1, 0x00);
|
||||
|
||||
*valp = (val & mask) != 0;
|
||||
return 0;
|
||||
}
|
||||
static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
signed int change;
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
||||
unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
|
||||
long val = *ucontrol->value.integer.value;
|
||||
unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
|
||||
AC_VERB_GET_DIGI_CONVERT_1,
|
||||
0x00);
|
||||
|
||||
/* Set/unset the masked control bit(s) as needed */
|
||||
change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
|
||||
if (val==0)
|
||||
ctrl_data &= ~mask;
|
||||
else
|
||||
ctrl_data |= mask;
|
||||
snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
|
||||
ctrl_data);
|
||||
|
||||
return change;
|
||||
}
|
||||
#define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
|
||||
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
|
||||
.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
|
||||
.info = alc_spdif_ctrl_info, \
|
||||
.get = alc_spdif_ctrl_get, \
|
||||
.put = alc_spdif_ctrl_put, \
|
||||
.private_value = nid | (mask<<16) }
|
||||
#endif /* CONFIG_SND_DEBUG */
|
||||
|
||||
/* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
|
||||
* Again, this is only used in the ALC26x test models to help identify when
|
||||
* the EAPD line must be asserted for features to work.
|
||||
*/
|
||||
#ifdef CONFIG_SND_DEBUG
|
||||
#define alc_eapd_ctrl_info snd_ctl_boolean_mono_info
|
||||
|
||||
static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
||||
unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
|
||||
long *valp = ucontrol->value.integer.value;
|
||||
unsigned int val = snd_hda_codec_read(codec, nid, 0,
|
||||
AC_VERB_GET_EAPD_BTLENABLE, 0x00);
|
||||
|
||||
*valp = (val & mask) != 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
int change;
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
hda_nid_t nid = kcontrol->private_value & 0xffff;
|
||||
unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
|
||||
long val = *ucontrol->value.integer.value;
|
||||
unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
|
||||
AC_VERB_GET_EAPD_BTLENABLE,
|
||||
0x00);
|
||||
|
||||
/* Set/unset the masked control bit(s) as needed */
|
||||
change = (!val ? 0 : mask) != (ctrl_data & mask);
|
||||
if (!val)
|
||||
ctrl_data &= ~mask;
|
||||
else
|
||||
ctrl_data |= mask;
|
||||
snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
|
||||
ctrl_data);
|
||||
|
||||
return change;
|
||||
}
|
||||
|
||||
#define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
|
||||
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
|
||||
.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
|
||||
.info = alc_eapd_ctrl_info, \
|
||||
.get = alc_eapd_ctrl_get, \
|
||||
.put = alc_eapd_ctrl_put, \
|
||||
.private_value = nid | (mask<<16) }
|
||||
#endif /* CONFIG_SND_DEBUG */
|
||||
|
||||
static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
struct auto_pin_cfg *cfg = &spec->autocfg;
|
||||
|
||||
if (!cfg->line_outs) {
|
||||
while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
|
||||
cfg->line_out_pins[cfg->line_outs])
|
||||
cfg->line_outs++;
|
||||
}
|
||||
if (!cfg->speaker_outs) {
|
||||
while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
|
||||
cfg->speaker_pins[cfg->speaker_outs])
|
||||
cfg->speaker_outs++;
|
||||
}
|
||||
if (!cfg->hp_outs) {
|
||||
while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
|
||||
cfg->hp_pins[cfg->hp_outs])
|
||||
cfg->hp_outs++;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* set up from the preset table
|
||||
*/
|
||||
static void setup_preset(struct hda_codec *codec,
|
||||
const struct alc_config_preset *preset)
|
||||
{
|
||||
struct alc_spec *spec = codec->spec;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
|
||||
add_mixer(spec, preset->mixers[i]);
|
||||
spec->cap_mixer = preset->cap_mixer;
|
||||
for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
|
||||
i++)
|
||||
add_verb(spec, preset->init_verbs[i]);
|
||||
|
||||
spec->channel_mode = preset->channel_mode;
|
||||
spec->num_channel_mode = preset->num_channel_mode;
|
||||
spec->need_dac_fix = preset->need_dac_fix;
|
||||
spec->const_channel_count = preset->const_channel_count;
|
||||
|
||||
if (preset->const_channel_count)
|
||||
spec->multiout.max_channels = preset->const_channel_count;
|
||||
else
|
||||
spec->multiout.max_channels = spec->channel_mode[0].channels;
|
||||
spec->ext_channel_count = spec->channel_mode[0].channels;
|
||||
|
||||
spec->multiout.num_dacs = preset->num_dacs;
|
||||
spec->multiout.dac_nids = preset->dac_nids;
|
||||
spec->multiout.dig_out_nid = preset->dig_out_nid;
|
||||
spec->multiout.slave_dig_outs = preset->slave_dig_outs;
|
||||
spec->multiout.hp_nid = preset->hp_nid;
|
||||
|
||||
spec->num_mux_defs = preset->num_mux_defs;
|
||||
if (!spec->num_mux_defs)
|
||||
spec->num_mux_defs = 1;
|
||||
spec->input_mux = preset->input_mux;
|
||||
|
||||
spec->num_adc_nids = preset->num_adc_nids;
|
||||
spec->adc_nids = preset->adc_nids;
|
||||
spec->capsrc_nids = preset->capsrc_nids;
|
||||
spec->dig_in_nid = preset->dig_in_nid;
|
||||
|
||||
spec->unsol_event = preset->unsol_event;
|
||||
spec->init_hook = preset->init_hook;
|
||||
#ifdef CONFIG_SND_HDA_POWER_SAVE
|
||||
spec->power_hook = preset->power_hook;
|
||||
spec->loopback.amplist = preset->loopbacks;
|
||||
#endif
|
||||
|
||||
if (preset->setup)
|
||||
preset->setup(codec);
|
||||
|
||||
alc_fixup_autocfg_pin_nums(codec);
|
||||
}
|
||||
|
||||
|
||||
/* auto-toggle front mic */
|
||||
static void alc88x_simple_mic_automute(struct hda_codec *codec)
|
||||
{
|
||||
unsigned int present;
|
||||
unsigned char bits;
|
||||
|
||||
present = snd_hda_jack_detect(codec, 0x18);
|
||||
bits = present ? HDA_AMP_MUTE : 0;
|
||||
snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
|
||||
}
|
||||
|
|
@ -243,7 +243,8 @@ unsigned int snd_hda_codec_read(struct hda_codec *codec, hda_nid_t nid,
|
|||
{
|
||||
unsigned cmd = make_codec_cmd(codec, nid, direct, verb, parm);
|
||||
unsigned int res;
|
||||
codec_exec_verb(codec, cmd, &res);
|
||||
if (codec_exec_verb(codec, cmd, &res))
|
||||
return -1;
|
||||
return res;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_codec_read);
|
||||
|
@ -307,14 +308,65 @@ int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
|
|||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_sub_nodes);
|
||||
|
||||
static int _hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
|
||||
hda_nid_t *conn_list, int max_conns);
|
||||
static bool add_conn_list(struct snd_array *array, hda_nid_t nid);
|
||||
static int copy_conn_list(hda_nid_t nid, hda_nid_t *dst, int max_dst,
|
||||
hda_nid_t *src, int len);
|
||||
/* look up the cached results */
|
||||
static hda_nid_t *lookup_conn_list(struct snd_array *array, hda_nid_t nid)
|
||||
{
|
||||
int i, len;
|
||||
for (i = 0; i < array->used; ) {
|
||||
hda_nid_t *p = snd_array_elem(array, i);
|
||||
if (nid == *p)
|
||||
return p;
|
||||
len = p[1];
|
||||
i += len + 2;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* snd_hda_get_connections - get connection list
|
||||
* snd_hda_get_conn_list - get connection list
|
||||
* @codec: the HDA codec
|
||||
* @nid: NID to parse
|
||||
* @listp: the pointer to store NID list
|
||||
*
|
||||
* Parses the connection list of the given widget and stores the list
|
||||
* of NIDs.
|
||||
*
|
||||
* Returns the number of connections, or a negative error code.
|
||||
*/
|
||||
int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
|
||||
const hda_nid_t **listp)
|
||||
{
|
||||
struct snd_array *array = &codec->conn_lists;
|
||||
int len, err;
|
||||
hda_nid_t list[HDA_MAX_CONNECTIONS];
|
||||
hda_nid_t *p;
|
||||
bool added = false;
|
||||
|
||||
again:
|
||||
/* if the connection-list is already cached, read it */
|
||||
p = lookup_conn_list(array, nid);
|
||||
if (p) {
|
||||
if (listp)
|
||||
*listp = p + 2;
|
||||
return p[1];
|
||||
}
|
||||
if (snd_BUG_ON(added))
|
||||
return -EINVAL;
|
||||
|
||||
/* read the connection and add to the cache */
|
||||
len = snd_hda_get_raw_connections(codec, nid, list, HDA_MAX_CONNECTIONS);
|
||||
if (len < 0)
|
||||
return len;
|
||||
err = snd_hda_override_conn_list(codec, nid, len, list);
|
||||
if (err < 0)
|
||||
return err;
|
||||
added = true;
|
||||
goto again;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_conn_list);
|
||||
|
||||
/**
|
||||
* snd_hda_get_connections - copy connection list
|
||||
* @codec: the HDA codec
|
||||
* @nid: NID to parse
|
||||
* @conn_list: connection list array
|
||||
|
@ -328,42 +380,35 @@ static int copy_conn_list(hda_nid_t nid, hda_nid_t *dst, int max_dst,
|
|||
int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
|
||||
hda_nid_t *conn_list, int max_conns)
|
||||
{
|
||||
struct snd_array *array = &codec->conn_lists;
|
||||
int i, len, old_used;
|
||||
hda_nid_t list[HDA_MAX_CONNECTIONS];
|
||||
const hda_nid_t *list;
|
||||
int len = snd_hda_get_conn_list(codec, nid, &list);
|
||||
|
||||
/* look up the cached results */
|
||||
for (i = 0; i < array->used; ) {
|
||||
hda_nid_t *p = snd_array_elem(array, i);
|
||||
len = p[1];
|
||||
if (nid == *p)
|
||||
return copy_conn_list(nid, conn_list, max_conns,
|
||||
p + 2, len);
|
||||
i += len + 2;
|
||||
}
|
||||
|
||||
len = _hda_get_connections(codec, nid, list, HDA_MAX_CONNECTIONS);
|
||||
if (len < 0)
|
||||
if (len <= 0)
|
||||
return len;
|
||||
|
||||
/* add to the cache */
|
||||
old_used = array->used;
|
||||
if (!add_conn_list(array, nid) || !add_conn_list(array, len))
|
||||
goto error_add;
|
||||
for (i = 0; i < len; i++)
|
||||
if (!add_conn_list(array, list[i]))
|
||||
goto error_add;
|
||||
|
||||
return copy_conn_list(nid, conn_list, max_conns, list, len);
|
||||
|
||||
error_add:
|
||||
array->used = old_used;
|
||||
return -ENOMEM;
|
||||
if (len > max_conns) {
|
||||
snd_printk(KERN_ERR "hda_codec: "
|
||||
"Too many connections %d for NID 0x%x\n",
|
||||
len, nid);
|
||||
return -EINVAL;
|
||||
}
|
||||
memcpy(conn_list, list, len * sizeof(hda_nid_t));
|
||||
return len;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_connections);
|
||||
|
||||
static int _hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
|
||||
hda_nid_t *conn_list, int max_conns)
|
||||
/**
|
||||
* snd_hda_get_raw_connections - copy connection list without cache
|
||||
* @codec: the HDA codec
|
||||
* @nid: NID to parse
|
||||
* @conn_list: connection list array
|
||||
* @max_conns: max. number of connections to store
|
||||
*
|
||||
* Like snd_hda_get_connections(), copy the connection list but without
|
||||
* checking through the connection-list cache.
|
||||
* Currently called only from hda_proc.c, so not exported.
|
||||
*/
|
||||
int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
|
||||
hda_nid_t *conn_list, int max_conns)
|
||||
{
|
||||
unsigned int parm;
|
||||
int i, conn_len, conns;
|
||||
|
@ -376,11 +421,8 @@ static int _hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
|
|||
|
||||
wcaps = get_wcaps(codec, nid);
|
||||
if (!(wcaps & AC_WCAP_CONN_LIST) &&
|
||||
get_wcaps_type(wcaps) != AC_WID_VOL_KNB) {
|
||||
snd_printk(KERN_WARNING "hda_codec: "
|
||||
"connection list not available for 0x%x\n", nid);
|
||||
return -EINVAL;
|
||||
}
|
||||
get_wcaps_type(wcaps) != AC_WID_VOL_KNB)
|
||||
return 0;
|
||||
|
||||
parm = snd_hda_param_read(codec, nid, AC_PAR_CONNLIST_LEN);
|
||||
if (parm & AC_CLIST_LONG) {
|
||||
|
@ -470,18 +512,77 @@ static bool add_conn_list(struct snd_array *array, hda_nid_t nid)
|
|||
return true;
|
||||
}
|
||||
|
||||
static int copy_conn_list(hda_nid_t nid, hda_nid_t *dst, int max_dst,
|
||||
hda_nid_t *src, int len)
|
||||
/**
|
||||
* snd_hda_override_conn_list - add/modify the connection-list to cache
|
||||
* @codec: the HDA codec
|
||||
* @nid: NID to parse
|
||||
* @len: number of connection list entries
|
||||
* @list: the list of connection entries
|
||||
*
|
||||
* Add or modify the given connection-list to the cache. If the corresponding
|
||||
* cache already exists, invalidate it and append a new one.
|
||||
*
|
||||
* Returns zero or a negative error code.
|
||||
*/
|
||||
int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int len,
|
||||
const hda_nid_t *list)
|
||||
{
|
||||
if (len > max_dst) {
|
||||
snd_printk(KERN_ERR "hda_codec: "
|
||||
"Too many connections %d for NID 0x%x\n",
|
||||
len, nid);
|
||||
return -EINVAL;
|
||||
}
|
||||
memcpy(dst, src, len * sizeof(hda_nid_t));
|
||||
return len;
|
||||
struct snd_array *array = &codec->conn_lists;
|
||||
hda_nid_t *p;
|
||||
int i, old_used;
|
||||
|
||||
p = lookup_conn_list(array, nid);
|
||||
if (p)
|
||||
*p = -1; /* invalidate the old entry */
|
||||
|
||||
old_used = array->used;
|
||||
if (!add_conn_list(array, nid) || !add_conn_list(array, len))
|
||||
goto error_add;
|
||||
for (i = 0; i < len; i++)
|
||||
if (!add_conn_list(array, list[i]))
|
||||
goto error_add;
|
||||
return 0;
|
||||
|
||||
error_add:
|
||||
array->used = old_used;
|
||||
return -ENOMEM;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_override_conn_list);
|
||||
|
||||
/**
|
||||
* snd_hda_get_conn_index - get the connection index of the given NID
|
||||
* @codec: the HDA codec
|
||||
* @mux: NID containing the list
|
||||
* @nid: NID to select
|
||||
* @recursive: 1 when searching NID recursively, otherwise 0
|
||||
*
|
||||
* Parses the connection list of the widget @mux and checks whether the
|
||||
* widget @nid is present. If it is, return the connection index.
|
||||
* Otherwise it returns -1.
|
||||
*/
|
||||
int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
|
||||
hda_nid_t nid, int recursive)
|
||||
{
|
||||
hda_nid_t conn[HDA_MAX_NUM_INPUTS];
|
||||
int i, nums;
|
||||
|
||||
nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
|
||||
for (i = 0; i < nums; i++)
|
||||
if (conn[i] == nid)
|
||||
return i;
|
||||
if (!recursive)
|
||||
return -1;
|
||||
if (recursive > 5) {
|
||||
snd_printd("hda_codec: too deep connection for 0x%x\n", nid);
|
||||
return -1;
|
||||
}
|
||||
recursive++;
|
||||
for (i = 0; i < nums; i++)
|
||||
if (snd_hda_get_conn_index(codec, conn[i], nid, recursive) >= 0)
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_get_conn_index);
|
||||
|
||||
/**
|
||||
* snd_hda_queue_unsol_event - add an unsolicited event to queue
|
||||
|
@ -1083,6 +1184,7 @@ static void snd_hda_codec_free(struct hda_codec *codec)
|
|||
snd_array_free(&codec->mixers);
|
||||
snd_array_free(&codec->nids);
|
||||
snd_array_free(&codec->conn_lists);
|
||||
snd_array_free(&codec->spdif_out);
|
||||
codec->bus->caddr_tbl[codec->addr] = NULL;
|
||||
if (codec->patch_ops.free)
|
||||
codec->patch_ops.free(codec);
|
||||
|
@ -1144,6 +1246,7 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus,
|
|||
snd_array_init(&codec->driver_pins, sizeof(struct hda_pincfg), 16);
|
||||
snd_array_init(&codec->cvt_setups, sizeof(struct hda_cvt_setup), 8);
|
||||
snd_array_init(&codec->conn_lists, sizeof(hda_nid_t), 64);
|
||||
snd_array_init(&codec->spdif_out, sizeof(struct hda_spdif_out), 16);
|
||||
if (codec->bus->modelname) {
|
||||
codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
|
||||
if (!codec->modelname) {
|
||||
|
@ -2555,11 +2658,13 @@ static int snd_hda_spdif_default_get(struct snd_kcontrol *kcontrol,
|
|||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
int idx = kcontrol->private_value;
|
||||
struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
|
||||
|
||||
ucontrol->value.iec958.status[0] = codec->spdif_status & 0xff;
|
||||
ucontrol->value.iec958.status[1] = (codec->spdif_status >> 8) & 0xff;
|
||||
ucontrol->value.iec958.status[2] = (codec->spdif_status >> 16) & 0xff;
|
||||
ucontrol->value.iec958.status[3] = (codec->spdif_status >> 24) & 0xff;
|
||||
ucontrol->value.iec958.status[0] = spdif->status & 0xff;
|
||||
ucontrol->value.iec958.status[1] = (spdif->status >> 8) & 0xff;
|
||||
ucontrol->value.iec958.status[2] = (spdif->status >> 16) & 0xff;
|
||||
ucontrol->value.iec958.status[3] = (spdif->status >> 24) & 0xff;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -2644,23 +2749,23 @@ static int snd_hda_spdif_default_put(struct snd_kcontrol *kcontrol,
|
|||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
hda_nid_t nid = kcontrol->private_value;
|
||||
int idx = kcontrol->private_value;
|
||||
struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
|
||||
hda_nid_t nid = spdif->nid;
|
||||
unsigned short val;
|
||||
int change;
|
||||
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
codec->spdif_status = ucontrol->value.iec958.status[0] |
|
||||
spdif->status = ucontrol->value.iec958.status[0] |
|
||||
((unsigned int)ucontrol->value.iec958.status[1] << 8) |
|
||||
((unsigned int)ucontrol->value.iec958.status[2] << 16) |
|
||||
((unsigned int)ucontrol->value.iec958.status[3] << 24);
|
||||
val = convert_from_spdif_status(codec->spdif_status);
|
||||
val |= codec->spdif_ctls & 1;
|
||||
change = codec->spdif_ctls != val;
|
||||
codec->spdif_ctls = val;
|
||||
|
||||
if (change)
|
||||
val = convert_from_spdif_status(spdif->status);
|
||||
val |= spdif->ctls & 1;
|
||||
change = spdif->ctls != val;
|
||||
spdif->ctls = val;
|
||||
if (change && nid != (u16)-1)
|
||||
set_dig_out_convert(codec, nid, val & 0xff, (val >> 8) & 0xff);
|
||||
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return change;
|
||||
}
|
||||
|
@ -2671,33 +2776,42 @@ static int snd_hda_spdif_out_switch_get(struct snd_kcontrol *kcontrol,
|
|||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
int idx = kcontrol->private_value;
|
||||
struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
|
||||
|
||||
ucontrol->value.integer.value[0] = codec->spdif_ctls & AC_DIG1_ENABLE;
|
||||
ucontrol->value.integer.value[0] = spdif->ctls & AC_DIG1_ENABLE;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void set_spdif_ctls(struct hda_codec *codec, hda_nid_t nid,
|
||||
int dig1, int dig2)
|
||||
{
|
||||
set_dig_out_convert(codec, nid, dig1, dig2);
|
||||
/* unmute amp switch (if any) */
|
||||
if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
|
||||
(dig1 & AC_DIG1_ENABLE))
|
||||
snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
|
||||
HDA_AMP_MUTE, 0);
|
||||
}
|
||||
|
||||
static int snd_hda_spdif_out_switch_put(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_value *ucontrol)
|
||||
{
|
||||
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
|
||||
hda_nid_t nid = kcontrol->private_value;
|
||||
int idx = kcontrol->private_value;
|
||||
struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
|
||||
hda_nid_t nid = spdif->nid;
|
||||
unsigned short val;
|
||||
int change;
|
||||
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
val = codec->spdif_ctls & ~AC_DIG1_ENABLE;
|
||||
val = spdif->ctls & ~AC_DIG1_ENABLE;
|
||||
if (ucontrol->value.integer.value[0])
|
||||
val |= AC_DIG1_ENABLE;
|
||||
change = codec->spdif_ctls != val;
|
||||
if (change) {
|
||||
codec->spdif_ctls = val;
|
||||
set_dig_out_convert(codec, nid, val & 0xff, -1);
|
||||
/* unmute amp switch (if any) */
|
||||
if ((get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) &&
|
||||
(val & AC_DIG1_ENABLE))
|
||||
snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
|
||||
HDA_AMP_MUTE, 0);
|
||||
}
|
||||
change = spdif->ctls != val;
|
||||
spdif->ctls = val;
|
||||
if (change && nid != (u16)-1)
|
||||
set_spdif_ctls(codec, nid, val & 0xff, -1);
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
return change;
|
||||
}
|
||||
|
@ -2744,36 +2858,79 @@ static struct snd_kcontrol_new dig_mixes[] = {
|
|||
*
|
||||
* Returns 0 if successful, or a negative error code.
|
||||
*/
|
||||
int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid)
|
||||
int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
|
||||
hda_nid_t associated_nid,
|
||||
hda_nid_t cvt_nid)
|
||||
{
|
||||
int err;
|
||||
struct snd_kcontrol *kctl;
|
||||
struct snd_kcontrol_new *dig_mix;
|
||||
int idx;
|
||||
struct hda_spdif_out *spdif;
|
||||
|
||||
idx = find_empty_mixer_ctl_idx(codec, "IEC958 Playback Switch");
|
||||
if (idx < 0) {
|
||||
printk(KERN_ERR "hda_codec: too many IEC958 outputs\n");
|
||||
return -EBUSY;
|
||||
}
|
||||
spdif = snd_array_new(&codec->spdif_out);
|
||||
for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
|
||||
kctl = snd_ctl_new1(dig_mix, codec);
|
||||
if (!kctl)
|
||||
return -ENOMEM;
|
||||
kctl->id.index = idx;
|
||||
kctl->private_value = nid;
|
||||
err = snd_hda_ctl_add(codec, nid, kctl);
|
||||
kctl->private_value = codec->spdif_out.used - 1;
|
||||
err = snd_hda_ctl_add(codec, associated_nid, kctl);
|
||||
if (err < 0)
|
||||
return err;
|
||||
}
|
||||
codec->spdif_ctls =
|
||||
snd_hda_codec_read(codec, nid, 0,
|
||||
AC_VERB_GET_DIGI_CONVERT_1, 0);
|
||||
codec->spdif_status = convert_to_spdif_status(codec->spdif_ctls);
|
||||
spdif->nid = cvt_nid;
|
||||
spdif->ctls = snd_hda_codec_read(codec, cvt_nid, 0,
|
||||
AC_VERB_GET_DIGI_CONVERT_1, 0);
|
||||
spdif->status = convert_to_spdif_status(spdif->ctls);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_create_spdif_out_ctls);
|
||||
|
||||
struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
|
||||
hda_nid_t nid)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < codec->spdif_out.used; i++) {
|
||||
struct hda_spdif_out *spdif =
|
||||
snd_array_elem(&codec->spdif_out, i);
|
||||
if (spdif->nid == nid)
|
||||
return spdif;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_spdif_out_of_nid);
|
||||
|
||||
void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx)
|
||||
{
|
||||
struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
|
||||
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
spdif->nid = (u16)-1;
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_unassign);
|
||||
|
||||
void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid)
|
||||
{
|
||||
struct hda_spdif_out *spdif = snd_array_elem(&codec->spdif_out, idx);
|
||||
unsigned short val;
|
||||
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
if (spdif->nid != nid) {
|
||||
spdif->nid = nid;
|
||||
val = spdif->ctls;
|
||||
set_spdif_ctls(codec, nid, val & 0xff, (val >> 8) & 0xff);
|
||||
}
|
||||
mutex_unlock(&codec->spdif_mutex);
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_spdif_ctls_assign);
|
||||
|
||||
/*
|
||||
* SPDIF sharing with analog output
|
||||
*/
|
||||
|
@ -3356,7 +3513,7 @@ static unsigned int query_stream_param(struct hda_codec *codec, hda_nid_t nid)
|
|||
*
|
||||
* Returns 0 if successful, otherwise a negative error code.
|
||||
*/
|
||||
static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
|
||||
int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
|
||||
u32 *ratesp, u64 *formatsp, unsigned int *bpsp)
|
||||
{
|
||||
unsigned int i, val, wcaps;
|
||||
|
@ -3448,6 +3605,7 @@ static int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
|
|||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_HDA(snd_hda_query_supported_pcm);
|
||||
|
||||
/**
|
||||
* snd_hda_is_supported_format - Check the validity of the format
|
||||
|
@ -4177,10 +4335,12 @@ EXPORT_SYMBOL_HDA(snd_hda_input_mux_put);
|
|||
static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
|
||||
unsigned int stream_tag, unsigned int format)
|
||||
{
|
||||
struct hda_spdif_out *spdif = snd_hda_spdif_out_of_nid(codec, nid);
|
||||
|
||||
/* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
|
||||
if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
|
||||
if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
|
||||
set_dig_out_convert(codec, nid,
|
||||
codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff,
|
||||
spdif->ctls & ~AC_DIG1_ENABLE & 0xff,
|
||||
-1);
|
||||
snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
|
||||
if (codec->slave_dig_outs) {
|
||||
|
@ -4190,9 +4350,9 @@ static void setup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid,
|
|||
format);
|
||||
}
|
||||
/* turn on again (if needed) */
|
||||
if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE))
|
||||
if (codec->spdif_status_reset && (spdif->ctls & AC_DIG1_ENABLE))
|
||||
set_dig_out_convert(codec, nid,
|
||||
codec->spdif_ctls & 0xff, -1);
|
||||
spdif->ctls & 0xff, -1);
|
||||
}
|
||||
|
||||
static void cleanup_dig_out_stream(struct hda_codec *codec, hda_nid_t nid)
|
||||
|
@ -4348,6 +4508,8 @@ int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
|
|||
{
|
||||
const hda_nid_t *nids = mout->dac_nids;
|
||||
int chs = substream->runtime->channels;
|
||||
struct hda_spdif_out *spdif =
|
||||
snd_hda_spdif_out_of_nid(codec, mout->dig_out_nid);
|
||||
int i;
|
||||
|
||||
mutex_lock(&codec->spdif_mutex);
|
||||
|
@ -4356,7 +4518,7 @@ int snd_hda_multi_out_analog_prepare(struct hda_codec *codec,
|
|||
if (chs == 2 &&
|
||||
snd_hda_is_supported_format(codec, mout->dig_out_nid,
|
||||
format) &&
|
||||
!(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
|
||||
!(spdif->status & IEC958_AES0_NONAUDIO)) {
|
||||
mout->dig_out_used = HDA_DIG_ANALOG_DUP;
|
||||
setup_dig_out_stream(codec, mout->dig_out_nid,
|
||||
stream_tag, format);
|
||||
|
@ -4528,7 +4690,7 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec,
|
|||
unsigned int wid_caps = get_wcaps(codec, nid);
|
||||
unsigned int wid_type = get_wcaps_type(wid_caps);
|
||||
unsigned int def_conf;
|
||||
short assoc, loc;
|
||||
short assoc, loc, conn, dev;
|
||||
|
||||
/* read all default configuration for pin complex */
|
||||
if (wid_type != AC_WID_PIN)
|
||||
|
@ -4538,10 +4700,19 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec,
|
|||
continue;
|
||||
|
||||
def_conf = snd_hda_codec_get_pincfg(codec, nid);
|
||||
if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
|
||||
conn = get_defcfg_connect(def_conf);
|
||||
if (conn == AC_JACK_PORT_NONE)
|
||||
continue;
|
||||
loc = get_defcfg_location(def_conf);
|
||||
switch (get_defcfg_device(def_conf)) {
|
||||
dev = get_defcfg_device(def_conf);
|
||||
|
||||
/* workaround for buggy BIOS setups */
|
||||
if (dev == AC_JACK_LINE_OUT) {
|
||||
if (conn == AC_JACK_PORT_FIXED)
|
||||
dev = AC_JACK_SPEAKER;
|
||||
}
|
||||
|
||||
switch (dev) {
|
||||
case AC_JACK_LINE_OUT:
|
||||
seq = get_defcfg_sequence(def_conf);
|
||||
assoc = get_defcfg_association(def_conf);
|
||||
|
|
|
@ -829,8 +829,7 @@ struct hda_codec {
|
|||
|
||||
struct mutex spdif_mutex;
|
||||
struct mutex control_mutex;
|
||||
unsigned int spdif_status; /* IEC958 status bits */
|
||||
unsigned short spdif_ctls; /* SPDIF control bits */
|
||||
struct snd_array spdif_out;
|
||||
unsigned int spdif_in_enable; /* SPDIF input enable? */
|
||||
const hda_nid_t *slave_dig_outs; /* optional digital out slave widgets */
|
||||
struct snd_array init_pins; /* initial (BIOS) pin configurations */
|
||||
|
@ -904,6 +903,16 @@ int snd_hda_get_sub_nodes(struct hda_codec *codec, hda_nid_t nid,
|
|||
hda_nid_t *start_id);
|
||||
int snd_hda_get_connections(struct hda_codec *codec, hda_nid_t nid,
|
||||
hda_nid_t *conn_list, int max_conns);
|
||||
int snd_hda_get_raw_connections(struct hda_codec *codec, hda_nid_t nid,
|
||||
hda_nid_t *conn_list, int max_conns);
|
||||
int snd_hda_get_conn_list(struct hda_codec *codec, hda_nid_t nid,
|
||||
const hda_nid_t **listp);
|
||||
int snd_hda_override_conn_list(struct hda_codec *codec, hda_nid_t nid, int nums,
|
||||
const hda_nid_t *list);
|
||||
int snd_hda_get_conn_index(struct hda_codec *codec, hda_nid_t mux,
|
||||
hda_nid_t nid, int recursive);
|
||||
int snd_hda_query_supported_pcm(struct hda_codec *codec, hda_nid_t nid,
|
||||
u32 *ratesp, u64 *formatsp, unsigned int *bpsp);
|
||||
|
||||
struct hda_verb {
|
||||
hda_nid_t nid;
|
||||
|
@ -947,6 +956,17 @@ int snd_hda_add_pincfg(struct hda_codec *codec, struct snd_array *list,
|
|||
hda_nid_t nid, unsigned int cfg); /* for hwdep */
|
||||
void snd_hda_shutup_pins(struct hda_codec *codec);
|
||||
|
||||
/* SPDIF controls */
|
||||
struct hda_spdif_out {
|
||||
hda_nid_t nid; /* Converter nid values relate to */
|
||||
unsigned int status; /* IEC958 status bits */
|
||||
unsigned short ctls; /* SPDIF control bits */
|
||||
};
|
||||
struct hda_spdif_out *snd_hda_spdif_out_of_nid(struct hda_codec *codec,
|
||||
hda_nid_t nid);
|
||||
void snd_hda_spdif_ctls_unassign(struct hda_codec *codec, int idx);
|
||||
void snd_hda_spdif_ctls_assign(struct hda_codec *codec, int idx, hda_nid_t nid);
|
||||
|
||||
/*
|
||||
* Mixer
|
||||
*/
|
||||
|
@ -997,17 +1017,15 @@ int snd_hda_suspend(struct hda_bus *bus);
|
|||
int snd_hda_resume(struct hda_bus *bus);
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_SND_HDA_POWER_SAVE
|
||||
static inline
|
||||
int hda_call_check_power_status(struct hda_codec *codec, hda_nid_t nid)
|
||||
{
|
||||
#ifdef CONFIG_SND_HDA_POWER_SAVE
|
||||
if (codec->patch_ops.check_power_status)
|
||||
return codec->patch_ops.check_power_status(codec, nid);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
#else
|
||||
#define hda_call_check_power_status(codec, nid) 0
|
||||
#endif
|
||||
|
||||
/*
|
||||
* get widget information
|
||||
|
|
|
@ -580,43 +580,45 @@ void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld)
|
|||
#endif /* CONFIG_PROC_FS */
|
||||
|
||||
/* update PCM info based on ELD */
|
||||
void hdmi_eld_update_pcm_info(struct hdmi_eld *eld, struct hda_pcm_stream *pcm,
|
||||
struct hda_pcm_stream *codec_pars)
|
||||
void snd_hdmi_eld_update_pcm_info(struct hdmi_eld *eld,
|
||||
struct hda_pcm_stream *hinfo)
|
||||
{
|
||||
u32 rates;
|
||||
u64 formats;
|
||||
unsigned int maxbps;
|
||||
unsigned int channels_max;
|
||||
int i;
|
||||
|
||||
/* assume basic audio support (the basic audio flag is not in ELD;
|
||||
* however, all audio capable sinks are required to support basic
|
||||
* audio) */
|
||||
pcm->rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000;
|
||||
pcm->formats = SNDRV_PCM_FMTBIT_S16_LE;
|
||||
pcm->maxbps = 16;
|
||||
pcm->channels_max = 2;
|
||||
rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
|
||||
SNDRV_PCM_RATE_48000;
|
||||
formats = SNDRV_PCM_FMTBIT_S16_LE;
|
||||
maxbps = 16;
|
||||
channels_max = 2;
|
||||
for (i = 0; i < eld->sad_count; i++) {
|
||||
struct cea_sad *a = &eld->sad[i];
|
||||
pcm->rates |= a->rates;
|
||||
if (a->channels > pcm->channels_max)
|
||||
pcm->channels_max = a->channels;
|
||||
rates |= a->rates;
|
||||
if (a->channels > channels_max)
|
||||
channels_max = a->channels;
|
||||
if (a->format == AUDIO_CODING_TYPE_LPCM) {
|
||||
if (a->sample_bits & AC_SUPPCM_BITS_20) {
|
||||
pcm->formats |= SNDRV_PCM_FMTBIT_S32_LE;
|
||||
if (pcm->maxbps < 20)
|
||||
pcm->maxbps = 20;
|
||||
formats |= SNDRV_PCM_FMTBIT_S32_LE;
|
||||
if (maxbps < 20)
|
||||
maxbps = 20;
|
||||
}
|
||||
if (a->sample_bits & AC_SUPPCM_BITS_24) {
|
||||
pcm->formats |= SNDRV_PCM_FMTBIT_S32_LE;
|
||||
if (pcm->maxbps < 24)
|
||||
pcm->maxbps = 24;
|
||||
formats |= SNDRV_PCM_FMTBIT_S32_LE;
|
||||
if (maxbps < 24)
|
||||
maxbps = 24;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!codec_pars)
|
||||
return;
|
||||
|
||||
/* restrict the parameters by the values the codec provides */
|
||||
pcm->rates &= codec_pars->rates;
|
||||
pcm->formats &= codec_pars->formats;
|
||||
pcm->channels_max = min(pcm->channels_max, codec_pars->channels_max);
|
||||
pcm->maxbps = min(pcm->maxbps, codec_pars->maxbps);
|
||||
hinfo->rates &= rates;
|
||||
hinfo->formats &= formats;
|
||||
hinfo->maxbps = min(hinfo->maxbps, maxbps);
|
||||
hinfo->channels_max = min(hinfo->channels_max, channels_max);
|
||||
}
|
||||
|
|
|
@ -177,7 +177,8 @@ MODULE_DESCRIPTION("Intel HDA driver");
|
|||
#define ICH6_REG_INTCTL 0x20
|
||||
#define ICH6_REG_INTSTS 0x24
|
||||
#define ICH6_REG_WALLCLK 0x30 /* 24Mhz source */
|
||||
#define ICH6_REG_SYNC 0x34
|
||||
#define ICH6_REG_OLD_SSYNC 0x34 /* SSYNC for old ICH */
|
||||
#define ICH6_REG_SSYNC 0x38
|
||||
#define ICH6_REG_CORBLBASE 0x40
|
||||
#define ICH6_REG_CORBUBASE 0x44
|
||||
#define ICH6_REG_CORBWP 0x48
|
||||
|
@ -479,6 +480,7 @@ enum {
|
|||
#define AZX_DCAPS_POSFIX_VIA (1 << 17) /* Use VIACOMBO as default */
|
||||
#define AZX_DCAPS_NO_64BIT (1 << 18) /* No 64bit address */
|
||||
#define AZX_DCAPS_SYNC_WRITE (1 << 19) /* sync each cmd write */
|
||||
#define AZX_DCAPS_OLD_SSYNC (1 << 20) /* Old SSYNC reg for ICH */
|
||||
|
||||
/* quirks for ATI SB / AMD Hudson */
|
||||
#define AZX_DCAPS_PRESET_ATI_SB \
|
||||
|
@ -1706,13 +1708,16 @@ static int azx_pcm_prepare(struct snd_pcm_substream *substream)
|
|||
struct snd_pcm_runtime *runtime = substream->runtime;
|
||||
unsigned int bufsize, period_bytes, format_val, stream_tag;
|
||||
int err;
|
||||
struct hda_spdif_out *spdif =
|
||||
snd_hda_spdif_out_of_nid(apcm->codec, hinfo->nid);
|
||||
unsigned short ctls = spdif ? spdif->ctls : 0;
|
||||
|
||||
azx_stream_reset(chip, azx_dev);
|
||||
format_val = snd_hda_calc_stream_format(runtime->rate,
|
||||
runtime->channels,
|
||||
runtime->format,
|
||||
hinfo->maxbps,
|
||||
apcm->codec->spdif_ctls);
|
||||
ctls);
|
||||
if (!format_val) {
|
||||
snd_printk(KERN_ERR SFX
|
||||
"invalid format_val, rate=%d, ch=%d, format=%d\n",
|
||||
|
@ -1792,7 +1797,11 @@ static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
|
|||
spin_lock(&chip->reg_lock);
|
||||
if (nsync > 1) {
|
||||
/* first, set SYNC bits of corresponding streams */
|
||||
azx_writel(chip, SYNC, azx_readl(chip, SYNC) | sbits);
|
||||
if (chip->driver_caps & AZX_DCAPS_OLD_SSYNC)
|
||||
azx_writel(chip, OLD_SSYNC,
|
||||
azx_readl(chip, OLD_SSYNC) | sbits);
|
||||
else
|
||||
azx_writel(chip, SSYNC, azx_readl(chip, SSYNC) | sbits);
|
||||
}
|
||||
snd_pcm_group_for_each_entry(s, substream) {
|
||||
if (s->pcm->card != substream->pcm->card)
|
||||
|
@ -1848,7 +1857,11 @@ static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
|
|||
if (nsync > 1) {
|
||||
spin_lock(&chip->reg_lock);
|
||||
/* reset SYNC bits */
|
||||
azx_writel(chip, SYNC, azx_readl(chip, SYNC) & ~sbits);
|
||||
if (chip->driver_caps & AZX_DCAPS_OLD_SSYNC)
|
||||
azx_writel(chip, OLD_SSYNC,
|
||||
azx_readl(chip, OLD_SSYNC) & ~sbits);
|
||||
else
|
||||
azx_writel(chip, SSYNC, azx_readl(chip, SSYNC) & ~sbits);
|
||||
spin_unlock(&chip->reg_lock);
|
||||
}
|
||||
return 0;
|
||||
|
@ -1863,7 +1876,7 @@ static unsigned int azx_via_get_position(struct azx *chip,
|
|||
unsigned int fifo_size;
|
||||
|
||||
link_pos = azx_sd_readl(azx_dev, SD_LPIB);
|
||||
if (azx_dev->index >= 4) {
|
||||
if (azx_dev->substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
|
||||
/* Playback, no problem using link position */
|
||||
return link_pos;
|
||||
}
|
||||
|
@ -1927,6 +1940,17 @@ static unsigned int azx_get_position(struct azx *chip,
|
|||
default:
|
||||
/* use the position buffer */
|
||||
pos = le32_to_cpu(*azx_dev->posbuf);
|
||||
if (chip->position_fix[stream] == POS_FIX_AUTO) {
|
||||
if (!pos || pos == (u32)-1) {
|
||||
printk(KERN_WARNING
|
||||
"hda-intel: Invalid position buffer, "
|
||||
"using LPIB read method instead.\n");
|
||||
chip->position_fix[stream] = POS_FIX_LPIB;
|
||||
pos = azx_sd_readl(azx_dev, SD_LPIB);
|
||||
} else
|
||||
chip->position_fix[stream] = POS_FIX_POSBUF;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
if (pos >= azx_dev->bufsize)
|
||||
|
@ -1964,16 +1988,6 @@ static int azx_position_ok(struct azx *chip, struct azx_dev *azx_dev)
|
|||
|
||||
stream = azx_dev->substream->stream;
|
||||
pos = azx_get_position(chip, azx_dev);
|
||||
if (chip->position_fix[stream] == POS_FIX_AUTO) {
|
||||
if (!pos) {
|
||||
printk(KERN_WARNING
|
||||
"hda-intel: Invalid position buffer, "
|
||||
"using LPIB read method instead.\n");
|
||||
chip->position_fix[stream] = POS_FIX_LPIB;
|
||||
pos = azx_get_position(chip, azx_dev);
|
||||
} else
|
||||
chip->position_fix[stream] = POS_FIX_POSBUF;
|
||||
}
|
||||
|
||||
if (WARN_ONCE(!azx_dev->period_bytes,
|
||||
"hda-intel: zero azx_dev->period_bytes"))
|
||||
|
@ -2061,6 +2075,8 @@ static void azx_pcm_free(struct snd_pcm *pcm)
|
|||
}
|
||||
}
|
||||
|
||||
#define MAX_PREALLOC_SIZE (32 * 1024 * 1024)
|
||||
|
||||
static int
|
||||
azx_attach_pcm_stream(struct hda_bus *bus, struct hda_codec *codec,
|
||||
struct hda_pcm *cpcm)
|
||||
|
@ -2069,6 +2085,7 @@ azx_attach_pcm_stream(struct hda_bus *bus, struct hda_codec *codec,
|
|||
struct snd_pcm *pcm;
|
||||
struct azx_pcm *apcm;
|
||||
int pcm_dev = cpcm->device;
|
||||
unsigned int size;
|
||||
int s, err;
|
||||
|
||||
if (pcm_dev >= HDA_MAX_PCMS) {
|
||||
|
@ -2104,9 +2121,12 @@ azx_attach_pcm_stream(struct hda_bus *bus, struct hda_codec *codec,
|
|||
snd_pcm_set_ops(pcm, s, &azx_pcm_ops);
|
||||
}
|
||||
/* buffer pre-allocation */
|
||||
size = CONFIG_SND_HDA_PREALLOC_SIZE * 1024;
|
||||
if (size > MAX_PREALLOC_SIZE)
|
||||
size = MAX_PREALLOC_SIZE;
|
||||
snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
|
||||
snd_dma_pci_data(chip->pci),
|
||||
1024 * 64, 32 * 1024 * 1024);
|
||||
size, MAX_PREALLOC_SIZE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -2347,28 +2367,20 @@ static int azx_dev_free(struct snd_device *device)
|
|||
* white/black-listing for position_fix
|
||||
*/
|
||||
static struct snd_pci_quirk position_fix_list[] __devinitdata = {
|
||||
SND_PCI_QUIRK(0x1025, 0x009f, "Acer Aspire 5110", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1025, 0x026f, "Acer Aspire 5538", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1028, 0x01cc, "Dell D820", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1028, 0x01de, "Dell Precision 390", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1028, 0x01f6, "Dell Latitude 131L", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1028, 0x0470, "Dell Inspiron 1120", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x103c, 0x306d, "HP dv3", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1043, 0x813d, "ASUS P5AD2", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS M2V", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1043, 0x8410, "ASUS", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x104d, 0x9069, "Sony VPCS11V9E", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1106, 0x3288, "ASUS M2V-MX SE", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba A100-259", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1297, 0x3166, "Shuttle", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1458, 0xa022, "ga-ma770-ud3", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1462, 0x1002, "MSI Wind U115", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1565, 0x820f, "Biostar Microtech", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1565, 0x8218, "Biostar Microtech", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x1849, 0x0888, "775Dual-VSTA", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x8086, 0x2503, "DG965OT AAD63733-203", POS_FIX_LPIB),
|
||||
SND_PCI_QUIRK(0x8086, 0xd601, "eMachines T5212", POS_FIX_LPIB),
|
||||
{}
|
||||
};
|
||||
|
||||
|
@ -2815,6 +2827,22 @@ static DEFINE_PCI_DEVICE_TABLE(azx_ids) = {
|
|||
/* SCH */
|
||||
{ PCI_DEVICE(0x8086, 0x811b),
|
||||
.driver_data = AZX_DRIVER_SCH | AZX_DCAPS_SCH_SNOOP },
|
||||
{ PCI_DEVICE(0x8086, 0x2668),
|
||||
.driver_data = AZX_DRIVER_ICH | AZX_DCAPS_OLD_SSYNC }, /* ICH6 */
|
||||
{ PCI_DEVICE(0x8086, 0x27d8),
|
||||
.driver_data = AZX_DRIVER_ICH | AZX_DCAPS_OLD_SSYNC }, /* ICH7 */
|
||||
{ PCI_DEVICE(0x8086, 0x269a),
|
||||
.driver_data = AZX_DRIVER_ICH | AZX_DCAPS_OLD_SSYNC }, /* ESB2 */
|
||||
{ PCI_DEVICE(0x8086, 0x284b),
|
||||
.driver_data = AZX_DRIVER_ICH | AZX_DCAPS_OLD_SSYNC }, /* ICH8 */
|
||||
{ PCI_DEVICE(0x8086, 0x293e),
|
||||
.driver_data = AZX_DRIVER_ICH | AZX_DCAPS_OLD_SSYNC }, /* ICH9 */
|
||||
{ PCI_DEVICE(0x8086, 0x293f),
|
||||
.driver_data = AZX_DRIVER_ICH | AZX_DCAPS_OLD_SSYNC }, /* ICH9 */
|
||||
{ PCI_DEVICE(0x8086, 0x3a3e),
|
||||
.driver_data = AZX_DRIVER_ICH | AZX_DCAPS_OLD_SSYNC }, /* ICH10 */
|
||||
{ PCI_DEVICE(0x8086, 0x3a6e),
|
||||
.driver_data = AZX_DRIVER_ICH | AZX_DCAPS_OLD_SSYNC }, /* ICH10 */
|
||||
/* Generic Intel */
|
||||
{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_ANY_ID),
|
||||
.class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8,
|
||||
|
|
|
@ -212,7 +212,9 @@ int snd_hda_mixer_bind_tlv(struct snd_kcontrol *kcontrol, int op_flag,
|
|||
/*
|
||||
* SPDIF I/O
|
||||
*/
|
||||
int snd_hda_create_spdif_out_ctls(struct hda_codec *codec, hda_nid_t nid);
|
||||
int snd_hda_create_spdif_out_ctls(struct hda_codec *codec,
|
||||
hda_nid_t associated_nid,
|
||||
hda_nid_t cvt_nid);
|
||||
int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid);
|
||||
|
||||
/*
|
||||
|
@ -563,7 +565,6 @@ int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key)
|
|||
* power-management
|
||||
*/
|
||||
|
||||
#ifdef CONFIG_SND_HDA_POWER_SAVE
|
||||
void snd_hda_schedule_power_save(struct hda_codec *codec);
|
||||
|
||||
struct hda_amp_list {
|
||||
|
@ -580,7 +581,6 @@ struct hda_loopback_check {
|
|||
int snd_hda_check_amp_list_power(struct hda_codec *codec,
|
||||
struct hda_loopback_check *check,
|
||||
hda_nid_t nid);
|
||||
#endif /* CONFIG_SND_HDA_POWER_SAVE */
|
||||
|
||||
/*
|
||||
* AMP control callbacks
|
||||
|
@ -639,8 +639,8 @@ struct hdmi_eld {
|
|||
int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid);
|
||||
int snd_hdmi_get_eld(struct hdmi_eld *, struct hda_codec *, hda_nid_t);
|
||||
void snd_hdmi_show_eld(struct hdmi_eld *eld);
|
||||
void hdmi_eld_update_pcm_info(struct hdmi_eld *eld, struct hda_pcm_stream *pcm,
|
||||
struct hda_pcm_stream *codec_pars);
|
||||
void snd_hdmi_eld_update_pcm_info(struct hdmi_eld *eld,
|
||||
struct hda_pcm_stream *hinfo);
|
||||
|
||||
#ifdef CONFIG_PROC_FS
|
||||
int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld,
|
||||
|
|
|
@ -636,7 +636,7 @@ static void print_codec_info(struct snd_info_entry *entry,
|
|||
wid_caps |= AC_WCAP_CONN_LIST;
|
||||
|
||||
if (wid_caps & AC_WCAP_CONN_LIST)
|
||||
conn_len = snd_hda_get_connections(codec, nid, conn,
|
||||
conn_len = snd_hda_get_raw_connections(codec, nid, conn,
|
||||
HDA_MAX_CONNECTIONS);
|
||||
|
||||
if (wid_caps & AC_WCAP_IN_AMP) {
|
||||
|
|
|
@ -213,7 +213,9 @@ static int ad198x_build_controls(struct hda_codec *codec)
|
|||
return err;
|
||||
}
|
||||
if (spec->multiout.dig_out_nid) {
|
||||
err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
|
||||
err = snd_hda_create_spdif_out_ctls(codec,
|
||||
spec->multiout.dig_out_nid,
|
||||
spec->multiout.dig_out_nid);
|
||||
if (err < 0)
|
||||
return err;
|
||||
err = snd_hda_create_spdif_share_sw(codec,
|
||||
|
@ -1920,7 +1922,8 @@ static int patch_ad1981(struct hda_codec *codec)
|
|||
spec->mixers[0] = ad1981_hp_mixers;
|
||||
spec->num_init_verbs = 2;
|
||||
spec->init_verbs[1] = ad1981_hp_init_verbs;
|
||||
spec->multiout.dig_out_nid = 0;
|
||||
if (!is_jack_available(codec, 0x0a))
|
||||
spec->multiout.dig_out_nid = 0;
|
||||
spec->input_mux = &ad1981_hp_capture_source;
|
||||
|
||||
codec->patch_ops.init = ad1981_hp_init;
|
||||
|
|
|
@ -240,7 +240,8 @@ static int ca0110_build_controls(struct hda_codec *codec)
|
|||
}
|
||||
|
||||
if (spec->dig_out) {
|
||||
err = snd_hda_create_spdif_out_ctls(codec, spec->dig_out);
|
||||
err = snd_hda_create_spdif_out_ctls(codec, spec->dig_out,
|
||||
spec->dig_out);
|
||||
if (err < 0)
|
||||
return err;
|
||||
err = snd_hda_create_spdif_share_sw(codec, &spec->multiout);
|
||||
|
|
1097
sound/pci/hda/patch_ca0132.c
Normal file
1097
sound/pci/hda/patch_ca0132.c
Normal file
File diff suppressed because it is too large
Load diff
|
@ -346,21 +346,15 @@ static hda_nid_t get_adc(struct hda_codec *codec, hda_nid_t pin,
|
|||
|
||||
nid = codec->start_nid;
|
||||
for (i = 0; i < codec->num_nodes; i++, nid++) {
|
||||
hda_nid_t pins[2];
|
||||
unsigned int type;
|
||||
int j, nums;
|
||||
int idx;
|
||||
type = get_wcaps_type(get_wcaps(codec, nid));
|
||||
if (type != AC_WID_AUD_IN)
|
||||
continue;
|
||||
nums = snd_hda_get_connections(codec, nid, pins,
|
||||
ARRAY_SIZE(pins));
|
||||
if (nums <= 0)
|
||||
continue;
|
||||
for (j = 0; j < nums; j++) {
|
||||
if (pins[j] == pin) {
|
||||
*idxp = j;
|
||||
return nid;
|
||||
}
|
||||
idx = snd_hda_get_conn_index(codec, nid, pin, 0);
|
||||
if (idx >= 0) {
|
||||
*idxp = idx;
|
||||
return nid;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
|
@ -821,7 +815,8 @@ static int build_digital_output(struct hda_codec *codec)
|
|||
if (!spec->multiout.dig_out_nid)
|
||||
return 0;
|
||||
|
||||
err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
|
||||
err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid,
|
||||
spec->multiout.dig_out_nid);
|
||||
if (err < 0)
|
||||
return err;
|
||||
err = snd_hda_create_spdif_share_sw(codec, &spec->multiout);
|
||||
|
|
|
@ -327,7 +327,9 @@ static int cmi9880_build_controls(struct hda_codec *codec)
|
|||
return err;
|
||||
}
|
||||
if (spec->multiout.dig_out_nid) {
|
||||
err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
|
||||
err = snd_hda_create_spdif_out_ctls(codec,
|
||||
spec->multiout.dig_out_nid,
|
||||
spec->multiout.dig_out_nid);
|
||||
if (err < 0)
|
||||
return err;
|
||||
err = snd_hda_create_spdif_share_sw(codec,
|
||||
|
@ -396,12 +398,11 @@ static int cmi9880_fill_multi_init(struct hda_codec *codec, const struct auto_pi
|
|||
{
|
||||
struct cmi_spec *spec = codec->spec;
|
||||
hda_nid_t nid;
|
||||
int i, j, k, len;
|
||||
int i, j, k;
|
||||
|
||||
/* clear the table, only one c-media dac assumed here */
|
||||
memset(spec->multi_init, 0, sizeof(spec->multi_init));
|
||||
for (j = 0, i = 0; i < cfg->line_outs; i++) {
|
||||
hda_nid_t conn[4];
|
||||
nid = cfg->line_out_pins[i];
|
||||
/* set as output */
|
||||
spec->multi_init[j].nid = nid;
|
||||
|
@ -414,12 +415,10 @@ static int cmi9880_fill_multi_init(struct hda_codec *codec, const struct auto_pi
|
|||
spec->multi_init[j].verb = AC_VERB_SET_CONNECT_SEL;
|
||||
spec->multi_init[j].param = 0;
|
||||
/* find the index in connect list */
|
||||
len = snd_hda_get_connections(codec, nid, conn, 4);
|
||||
for (k = 0; k < len; k++)
|
||||
if (conn[k] == spec->dac_nids[i]) {
|
||||
spec->multi_init[j].param = k;
|
||||
break;
|
||||
}
|
||||
k = snd_hda_get_conn_index(codec, nid,
|
||||
spec->dac_nids[i], 0);
|
||||
if (k >= 0)
|
||||
spec->multi_init[j].param = k;
|
||||
j++;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -155,6 +155,10 @@ struct conexant_spec {
|
|||
unsigned int mic_boost; /* offset into cxt5066_analog_mic_boost */
|
||||
|
||||
unsigned int beep_amp;
|
||||
|
||||
/* extra EAPD pins */
|
||||
unsigned int num_eapds;
|
||||
hda_nid_t eapds[4];
|
||||
};
|
||||
|
||||
static int conexant_playback_pcm_open(struct hda_pcm_stream *hinfo,
|
||||
|
@ -510,6 +514,7 @@ static int conexant_build_controls(struct hda_codec *codec)
|
|||
}
|
||||
if (spec->multiout.dig_out_nid) {
|
||||
err = snd_hda_create_spdif_out_ctls(codec,
|
||||
spec->multiout.dig_out_nid,
|
||||
spec->multiout.dig_out_nid);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
@ -1123,10 +1128,8 @@ static int patch_cxt5045(struct hda_codec *codec)
|
|||
board_config = snd_hda_check_board_config(codec, CXT5045_MODELS,
|
||||
cxt5045_models,
|
||||
cxt5045_cfg_tbl);
|
||||
#if 0 /* use the old method just for safety */
|
||||
if (board_config < 0)
|
||||
board_config = CXT5045_AUTO;
|
||||
#endif
|
||||
board_config = CXT5045_AUTO; /* model=auto as default */
|
||||
if (board_config == CXT5045_AUTO)
|
||||
return patch_conexant_auto(codec);
|
||||
|
||||
|
@ -1564,10 +1567,8 @@ static int patch_cxt5047(struct hda_codec *codec)
|
|||
board_config = snd_hda_check_board_config(codec, CXT5047_MODELS,
|
||||
cxt5047_models,
|
||||
cxt5047_cfg_tbl);
|
||||
#if 0 /* not enabled as default, as BIOS often broken for this codec */
|
||||
if (board_config < 0)
|
||||
board_config = CXT5047_AUTO;
|
||||
#endif
|
||||
board_config = CXT5047_AUTO; /* model=auto as default */
|
||||
if (board_config == CXT5047_AUTO)
|
||||
return patch_conexant_auto(codec);
|
||||
|
||||
|
@ -1993,10 +1994,8 @@ static int patch_cxt5051(struct hda_codec *codec)
|
|||
board_config = snd_hda_check_board_config(codec, CXT5051_MODELS,
|
||||
cxt5051_models,
|
||||
cxt5051_cfg_tbl);
|
||||
#if 0 /* use the old method just for safety */
|
||||
if (board_config < 0)
|
||||
board_config = CXT5051_AUTO;
|
||||
#endif
|
||||
board_config = CXT5051_AUTO; /* model=auto as default */
|
||||
if (board_config == CXT5051_AUTO)
|
||||
return patch_conexant_auto(codec);
|
||||
|
||||
|
@ -3114,10 +3113,8 @@ static int patch_cxt5066(struct hda_codec *codec)
|
|||
|
||||
board_config = snd_hda_check_board_config(codec, CXT5066_MODELS,
|
||||
cxt5066_models, cxt5066_cfg_tbl);
|
||||
#if 0 /* use the old method just for safety */
|
||||
if (board_config < 0)
|
||||
board_config = CXT5066_AUTO;
|
||||
#endif
|
||||
board_config = CXT5066_AUTO; /* model=auto as default */
|
||||
if (board_config == CXT5066_AUTO)
|
||||
return patch_conexant_auto(codec);
|
||||
|
||||
|
@ -3308,19 +3305,8 @@ static const struct hda_pcm_stream cx_auto_pcm_analog_capture = {
|
|||
|
||||
static const hda_nid_t cx_auto_adc_nids[] = { 0x14 };
|
||||
|
||||
/* get the connection index of @nid in the widget @mux */
|
||||
static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
|
||||
hda_nid_t nid)
|
||||
{
|
||||
hda_nid_t conn[HDA_MAX_NUM_INPUTS];
|
||||
int i, nums;
|
||||
|
||||
nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
|
||||
for (i = 0; i < nums; i++)
|
||||
if (conn[i] == nid)
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
#define get_connection_index(codec, mux, nid)\
|
||||
snd_hda_get_conn_index(codec, mux, nid, 0)
|
||||
|
||||
/* get an unassigned DAC from the given list.
|
||||
* Return the nid if found and reduce the DAC list, or return zero if
|
||||
|
@ -3919,6 +3905,38 @@ static void cx_auto_parse_beep(struct hda_codec *codec)
|
|||
#define cx_auto_parse_beep(codec)
|
||||
#endif
|
||||
|
||||
static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < nums; i++)
|
||||
if (list[i] == nid)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* parse extra-EAPD that aren't assigned to any pins */
|
||||
static void cx_auto_parse_eapd(struct hda_codec *codec)
|
||||
{
|
||||
struct conexant_spec *spec = codec->spec;
|
||||
struct auto_pin_cfg *cfg = &spec->autocfg;
|
||||
hda_nid_t nid, end_nid;
|
||||
|
||||
end_nid = codec->start_nid + codec->num_nodes;
|
||||
for (nid = codec->start_nid; nid < end_nid; nid++) {
|
||||
if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
|
||||
continue;
|
||||
if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD))
|
||||
continue;
|
||||
if (found_in_nid_list(nid, cfg->line_out_pins, cfg->line_outs) ||
|
||||
found_in_nid_list(nid, cfg->hp_pins, cfg->hp_outs) ||
|
||||
found_in_nid_list(nid, cfg->speaker_pins, cfg->speaker_outs))
|
||||
continue;
|
||||
spec->eapds[spec->num_eapds++] = nid;
|
||||
if (spec->num_eapds >= ARRAY_SIZE(spec->eapds))
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static int cx_auto_parse_auto_config(struct hda_codec *codec)
|
||||
{
|
||||
struct conexant_spec *spec = codec->spec;
|
||||
|
@ -3932,6 +3950,7 @@ static int cx_auto_parse_auto_config(struct hda_codec *codec)
|
|||
cx_auto_parse_input(codec);
|
||||
cx_auto_parse_digital(codec);
|
||||
cx_auto_parse_beep(codec);
|
||||
cx_auto_parse_eapd(codec);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -4019,6 +4038,8 @@ static void cx_auto_init_output(struct hda_codec *codec)
|
|||
}
|
||||
}
|
||||
cx_auto_update_speakers(codec);
|
||||
/* turn on/off extra EAPDs, too */
|
||||
cx_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, true);
|
||||
}
|
||||
|
||||
static void cx_auto_init_input(struct hda_codec *codec)
|
||||
|
|
File diff suppressed because it is too large
Load diff
File diff suppressed because it is too large
Load diff
|
@ -1112,7 +1112,9 @@ static int stac92xx_build_controls(struct hda_codec *codec)
|
|||
}
|
||||
|
||||
if (spec->multiout.dig_out_nid) {
|
||||
err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
|
||||
err = snd_hda_create_spdif_out_ctls(codec,
|
||||
spec->multiout.dig_out_nid,
|
||||
spec->multiout.dig_out_nid);
|
||||
if (err < 0)
|
||||
return err;
|
||||
err = snd_hda_create_spdif_share_sw(codec,
|
||||
|
@ -3406,30 +3408,9 @@ static hda_nid_t get_connected_node(struct hda_codec *codec, hda_nid_t mux,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
|
||||
hda_nid_t nid)
|
||||
{
|
||||
hda_nid_t conn[HDA_MAX_NUM_INPUTS];
|
||||
int i, nums;
|
||||
|
||||
if (!(get_wcaps(codec, mux) & AC_WCAP_CONN_LIST))
|
||||
return -1;
|
||||
|
||||
nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
|
||||
for (i = 0; i < nums; i++)
|
||||
if (conn[i] == nid)
|
||||
return i;
|
||||
|
||||
for (i = 0; i < nums; i++) {
|
||||
unsigned int wid_caps = get_wcaps(codec, conn[i]);
|
||||
unsigned int wid_type = get_wcaps_type(wid_caps);
|
||||
|
||||
if (wid_type != AC_WID_PIN && wid_type != AC_WID_AUD_MIX)
|
||||
if (get_connection_index(codec, conn[i], nid) >= 0)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
/* look for NID recursively */
|
||||
#define get_connection_index(codec, mux, nid) \
|
||||
snd_hda_get_conn_index(codec, mux, nid, 1)
|
||||
|
||||
/* create a volume assigned to the given pin (only if supported) */
|
||||
/* return 1 if the volume control is created */
|
||||
|
|
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue