adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-28 03:36:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

ALSA: HDA VIA: Add VT2002P support.

Browse source 
Signed-off-by: Lydia Wang <lydiawang@viatech.com.cn>
Signed-off-by: Logan Li <loganli@viatech.com.cn>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
This commit is contained in:
Lydia Wang 2009-10-10 19:08:43 +08:00 committed by Takashi Iwai
parent f3db423df8
commit 25eaba2f8a
1 changed files with 660 additions and 5 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

665
sound/pci/hda/patch_via.c
View file

@ -88,6 +88,7 @@ enum VIA_HDA_CODEC {
VT1702,
VT1718S,
VT1716S,
VT2002P,
CODEC_TYPES,
};
@ -184,6 +185,8 @@ static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec)
codec_type = VT1716S;
else if (dev_id == 0x0441 || dev_id == 0x4441)
codec_type = VT1718S;
else if (dev_id == 0x0438 || dev_id == 0x4438)
codec_type = VT2002P;
else
codec_type = UNKNOWN;
return codec_type;
@ -193,11 +196,14 @@ static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec)
#define VIA_GPIO_EVENT 0x02
#define VIA_JACK_EVENT 0x04
#define VIA_MONO_EVENT 0x08
#define VIA_SPEAKER_EVENT 0x10
#define VIA_BIND_HP_EVENT 0x20
enum {
VIA_CTL_WIDGET_VOL,
VIA_CTL_WIDGET_MUTE,
VIA_CTL_WIDGET_ANALOG_MUTE,
VIA_CTL_WIDGET_BIND_PIN_MUTE,
};
enum {
@ -235,6 +241,7 @@ static void vt1708_stop_hp_work(struct via_spec *spec)
flush_scheduled_work();
}
static int analog_input_switch_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
@ -262,13 +269,108 @@ static int analog_input_switch_put(struct snd_kcontrol *kcontrol,
.put = analog_input_switch_put, \
.private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) }
static void via_hp_bind_automute(struct hda_codec *codec);
static int bind_pin_switch_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
struct via_spec *spec = codec->spec;
int i;
int change = 0;
long *valp = ucontrol->value.integer.value;
int lmute, rmute;
if (strstr(kcontrol->id.name, "Switch") == NULL) {
snd_printd("Invalid control!\n");
return change;
}
change = snd_hda_mixer_amp_switch_put(kcontrol,
ucontrol);
/* Get mute value */
lmute = *valp ? 0 : HDA_AMP_MUTE;
valp++;
rmute = *valp ? 0 : HDA_AMP_MUTE;
/* Set hp pins */
if (!spec->hp_independent_mode) {
for (i = 0; i < spec->autocfg.hp_outs; i++) {
snd_hda_codec_amp_update(
codec, spec->autocfg.hp_pins[i],
0, HDA_OUTPUT, 0, HDA_AMP_MUTE,
lmute);
snd_hda_codec_amp_update(
codec, spec->autocfg.hp_pins[i],
1, HDA_OUTPUT, 0, HDA_AMP_MUTE,
rmute);
}
}
if (!lmute && !rmute) {
/* Line Outs */
for (i = 0; i < spec->autocfg.line_outs; i++)
snd_hda_codec_amp_stereo(
codec, spec->autocfg.line_out_pins[i],
HDA_OUTPUT, 0, HDA_AMP_MUTE, 0);
/* Speakers */
for (i = 0; i < spec->autocfg.speaker_outs; i++)
snd_hda_codec_amp_stereo(
codec, spec->autocfg.speaker_pins[i],
HDA_OUTPUT, 0, HDA_AMP_MUTE, 0);
/* unmute */
via_hp_bind_automute(codec);
} else {
if (lmute) {
/* Mute all left channels */
for (i = 1; i < spec->autocfg.line_outs; i++)
snd_hda_codec_amp_update(
codec,
spec->autocfg.line_out_pins[i],
0, HDA_OUTPUT, 0, HDA_AMP_MUTE,
lmute);
for (i = 0; i < spec->autocfg.speaker_outs; i++)
snd_hda_codec_amp_update(
codec,
spec->autocfg.speaker_pins[i],
0, HDA_OUTPUT, 0, HDA_AMP_MUTE,
lmute);
}
if (rmute) {
/* mute all right channels */
for (i = 1; i < spec->autocfg.line_outs; i++)
snd_hda_codec_amp_update(
codec,
spec->autocfg.line_out_pins[i],
1, HDA_OUTPUT, 0, HDA_AMP_MUTE,
rmute);
for (i = 0; i < spec->autocfg.speaker_outs; i++)
snd_hda_codec_amp_update(
codec,
spec->autocfg.speaker_pins[i],
1, HDA_OUTPUT, 0, HDA_AMP_MUTE,
rmute);
}
}
return change;
}
#define BIND_PIN_MUTE \
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
.name = NULL, \
.index = 0, \
.info = snd_hda_mixer_amp_switch_info, \
.get = snd_hda_mixer_amp_switch_get, \
.put = bind_pin_switch_put, \
.private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) }
static struct snd_kcontrol_new vt1708_control_templates[] = {
HDA_CODEC_VOLUME(NULL, 0, 0, 0),
HDA_CODEC_MUTE(NULL, 0, 0, 0),
ANALOG_INPUT_MUTE,
BIND_PIN_MUTE,
};
static hda_nid_t vt1708_adc_nids[2] = {
/* ADC1-2 */
0x15, 0x27
@ -304,6 +406,11 @@ static hda_nid_t vt1716S_adc_nids[2] = {
0x13, 0x14
};
static hda_nid_t vt2002P_adc_nids[2] = {
/* ADC1-2 */
0x10, 0x11
};
/* add dynamic controls */
static int via_add_control(struct via_spec *spec, int type, const char *name,
unsigned long val)
@ -386,10 +493,13 @@ static void via_auto_init_hp_out(struct hda_codec *codec)
{
struct via_spec *spec = codec->spec;
hda_nid_t pin;
int i;
pin = spec->autocfg.hp_pins[0];
if (pin) /* connect to front */
via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
for (i = 0; i < spec->autocfg.hp_outs; i++) {
pin = spec->autocfg.hp_pins[i];
if (pin) /* connect to front */
via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
}
}
static void via_auto_init_analog_input(struct hda_codec *codec)
@ -693,6 +803,107 @@ static void set_jack_power_state(struct hda_codec *codec)
imux_is_smixer ? AC_PWRST_D0 : parm);
snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
mono_out ? AC_PWRST_D0 : parm);
} else if (spec->codec_type == VT2002P) {
unsigned int present;
/* MUX9 (1eh) = stereo mixer */
imux_is_smixer = snd_hda_codec_read(
codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
/* inputs */
/* PW 5/6/7 (29h/2ah/2bh) */
parm = AC_PWRST_D3;
set_pin_power_state(codec, 0x29, &parm);
set_pin_power_state(codec, 0x2a, &parm);
set_pin_power_state(codec, 0x2b, &parm);
if (imux_is_smixer)
parm = AC_PWRST_D0;
/* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */
snd_hda_codec_write(codec, 0x1e, 0,
AC_VERB_SET_POWER_STATE, parm);
snd_hda_codec_write(codec, 0x1f, 0,
AC_VERB_SET_POWER_STATE, parm);
snd_hda_codec_write(codec, 0x10, 0,
AC_VERB_SET_POWER_STATE, parm);
snd_hda_codec_write(codec, 0x11, 0,
AC_VERB_SET_POWER_STATE, parm);
/* outputs */
/* AOW0 (8h)*/
snd_hda_codec_write(codec, 0x8, 0,
AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
/* PW4 (26h), MW4 (1ch), MUX4(37h) */
parm = AC_PWRST_D3;
set_pin_power_state(codec, 0x26, &parm);
snd_hda_codec_write(codec, 0x1c, 0,
AC_VERB_SET_POWER_STATE, parm);
snd_hda_codec_write(codec, 0x37,
0, AC_VERB_SET_POWER_STATE, parm);
/* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */
parm = AC_PWRST_D3;
set_pin_power_state(codec, 0x25, &parm);
snd_hda_codec_write(codec, 0x19, 0,
AC_VERB_SET_POWER_STATE, parm);
snd_hda_codec_write(codec, 0x35, 0,
AC_VERB_SET_POWER_STATE, parm);
if (spec->hp_independent_mode) {
snd_hda_codec_write(codec, 0x9, 0,
AC_VERB_SET_POWER_STATE, parm);
}
/* Class-D */
/* PW0 (24h), MW0(18h), MUX0(34h) */
present = snd_hda_codec_read(
codec, 0x25, 0, AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
parm = AC_PWRST_D3;
set_pin_power_state(codec, 0x24, &parm);
if (present) {
snd_hda_codec_write(
codec, 0x18, 0,
AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
snd_hda_codec_write(
codec, 0x34, 0,
AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
} else {
snd_hda_codec_write(
codec, 0x18, 0,
AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
snd_hda_codec_write(
codec, 0x34, 0,
AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
}
/* Mono Out */
/* PW15 (31h), MW8(17h), MUX8(3bh) */
present = snd_hda_codec_read(
codec, 0x26, 0, AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
parm = AC_PWRST_D3;
set_pin_power_state(codec, 0x31, &parm);
if (present) {
snd_hda_codec_write(
codec, 0x17, 0,
AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
snd_hda_codec_write(
codec, 0x3b, 0,
AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
} else {
snd_hda_codec_write(
codec, 0x17, 0,
AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
snd_hda_codec_write(
codec, 0x3b, 0,
AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
}
/* MW9 (21h) */
if (imux_is_smixer || !is_aa_path_mute(codec))
snd_hda_codec_write(
codec, 0x21, 0,
AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
else
snd_hda_codec_write(
codec, 0x21, 0,
AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
}
}
@ -760,6 +971,9 @@ static int via_independent_hp_get(struct snd_kcontrol *kcontrol,
case VT1718S:
nid = 0x34;
break;
case VT2002P:
nid = 0x35;
break;
default:
nid = spec->autocfg.hp_pins[0];
break;
@ -832,6 +1046,9 @@ static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
pinsel = pinsel ? 2 : 0; /* indep HP use AOW4 (index 2) */
spec->multiout.num_dacs = 4;
break;
case VT2002P:
nid = 0x35;
break;
default:
nid = spec->autocfg.hp_pins[0];
break;
@ -848,7 +1065,8 @@ static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
if (spec->codec_type == VT1708S
|| spec->codec_type == VT1702
|| spec->codec_type == VT1718S
|| spec->codec_type == VT1716S) {
|| spec->codec_type == VT1716S
|| spec->codec_type == VT2002P) {
activate_ctl(codec, "Headphone Playback Volume",
spec->hp_independent_mode);
activate_ctl(codec, "Headphone Playback Switch",
@ -1088,6 +1306,11 @@ static int is_aa_path_mute(struct hda_codec *codec)
start_idx = 1;
end_idx = 3;
break;
case VT2002P:
nid_mixer = 0x21;
start_idx = 0;
end_idx = 2;
break;
default:
return 0;
}
@ -1146,6 +1369,10 @@ static void analog_low_current_mode(struct hda_codec *codec, int stream_idle)
verb = 0xf73;
parm = enable ? 0x01 : 0x1d; /* 0x01: 4/40x, 0x1d: 1x */
break;
case VT2002P:
verb = 0xf93;
parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */
break;
default:
return; /* other codecs are not supported */
}
@ -1645,6 +1872,66 @@ static void via_gpio_control(struct hda_codec *codec)
}
}
/* mute Internal-Speaker if HP is plugged */
static void via_speaker_automute(struct hda_codec *codec)
{
unsigned int hp_present;
struct via_spec *spec = codec->spec;
if (spec->codec_type != VT2002P)
return;
hp_present = snd_hda_codec_read(codec, spec->autocfg.hp_pins[0], 0,
AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
if (!spec->hp_independent_mode) {
struct snd_ctl_elem_id id;
snd_hda_codec_amp_stereo(
codec, spec->autocfg.speaker_pins[0], HDA_OUTPUT, 0,
HDA_AMP_MUTE, hp_present ? HDA_AMP_MUTE : 0);
/* notify change */
memset(&id, 0, sizeof(id));
id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
strcpy(id.name, "Speaker Playback Switch");
snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE,
&id);
}
}
/* mute line-out and internal speaker if HP is plugged */
static void via_hp_bind_automute(struct hda_codec *codec)
{
unsigned int hp_present, present = 0;
struct via_spec *spec = codec->spec;
int i;
if (!spec->autocfg.hp_pins[0] || !spec->autocfg.line_out_pins[0])
return;
hp_present = snd_hda_codec_read(codec, spec->autocfg.hp_pins[0], 0,
AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
present = snd_hda_codec_read(codec, spec->autocfg.line_out_pins[0], 0,
AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
if (!spec->hp_independent_mode) {
/* Mute Line-Outs */
for (i = 0; i < spec->autocfg.line_outs; i++)
snd_hda_codec_amp_stereo(
codec, spec->autocfg.line_out_pins[i],
HDA_OUTPUT, 0,
HDA_AMP_MUTE, hp_present ? HDA_AMP_MUTE : 0);
if (hp_present)
present = hp_present;
}
/* Speakers */
for (i = 0; i < spec->autocfg.speaker_outs; i++)
snd_hda_codec_amp_stereo(
codec, spec->autocfg.speaker_pins[i], HDA_OUTPUT, 0,
HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
}
/* unsolicited event for jack sensing */
static void via_unsol_event(struct hda_codec *codec,
unsigned int res)
@ -1658,6 +1945,10 @@ static void via_unsol_event(struct hda_codec *codec,
set_jack_power_state(codec);
if (res & VIA_MONO_EVENT)
via_mono_automute(codec);
if (res & VIA_SPEAKER_EVENT)
via_speaker_automute(codec);
if (res & VIA_BIND_HP_EVENT)
via_hp_bind_automute(codec);
}
static int via_init(struct hda_codec *codec)
@ -2067,10 +2358,19 @@ static int vt1708_parse_auto_config(struct hda_codec *codec)
/* init callback for auto-configuration model -- overriding the default init */
static int via_auto_init(struct hda_codec *codec)
{
struct via_spec *spec = codec->spec;
via_init(codec);
via_auto_init_multi_out(codec);
via_auto_init_hp_out(codec);
via_auto_init_analog_input(codec);
if (spec->codec_type == VT2002P) {
via_hp_bind_automute(codec);
} else {
via_hp_automute(codec);
via_speaker_automute(codec);
}
return 0;
}
@ -5001,6 +5301,359 @@ static int patch_vt1716S(struct hda_codec *codec)
return 0;
}
/* for vt2002P */
/* capture mixer elements */
static struct snd_kcontrol_new vt2002P_capture_mixer[] = {
HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT),
HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT),
HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT),
HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT),
HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT),
HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x29, 0x0,
HDA_INPUT),
{
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
/* The multiple "Capture Source" controls confuse alsamixer
* So call somewhat different..
*/
/* .name = "Capture Source", */
.name = "Input Source",
.count = 2,
.info = via_mux_enum_info,
.get = via_mux_enum_get,
.put = via_mux_enum_put,
},
{ } /* end */
};
static struct hda_verb vt2002P_volume_init_verbs[] = {
/*
* Unmute ADC0-1 and set the default input to mic-in
*/
{0x8, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
{0x9, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
* mixer widget
*/
/* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
/* MUX Indices: Mic = 0 */
{0x1e, AC_VERB_SET_CONNECT_SEL, 0},
{0x1f, AC_VERB_SET_CONNECT_SEL, 0},
/* PW9 Output enable */
{0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN},
/* Enable Boost Volume backdoor */
{0x1, 0xfb9, 0x24},
/* MW0/1/4/8: un-mute index 0 (MUXx), un-mute index 1 (MW9) */
{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
{0x17, 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(1)},
{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
/* set MUX0/1/4/8 = 0 (AOW0) */
{0x34, AC_VERB_SET_CONNECT_SEL, 0},
{0x35, AC_VERB_SET_CONNECT_SEL, 0},
{0x37, AC_VERB_SET_CONNECT_SEL, 0},
{0x3b, AC_VERB_SET_CONNECT_SEL, 0},
/* set PW0 index=0 (MW0) */
{0x24, AC_VERB_SET_CONNECT_SEL, 0},
/* Enable AOW0 to MW9 */
{0x1, 0xfb8, 0x88},
{ }
};
static struct hda_verb vt2002P_uniwill_init_verbs[] = {
{0x25, AC_VERB_SET_UNSOLICITED_ENABLE,
AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT},
{0x26, AC_VERB_SET_UNSOLICITED_ENABLE,
AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT},
{0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
{0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
{0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
{ }
};
static struct hda_pcm_stream vt2002P_pcm_analog_playback = {
.substreams = 2,
.channels_min = 2,
.channels_max = 2,
.nid = 0x8, /* NID to query formats and rates */
.ops = {
.open = via_playback_pcm_open,
.prepare = via_playback_multi_pcm_prepare,
.cleanup = via_playback_multi_pcm_cleanup,
.close = via_pcm_open_close,
},
};
static struct hda_pcm_stream vt2002P_pcm_analog_capture = {
.substreams = 2,
.channels_min = 2,
.channels_max = 2,
.nid = 0x10, /* NID to query formats and rates */
.ops = {
.open = via_pcm_open_close,
.prepare = via_capture_pcm_prepare,
.cleanup = via_capture_pcm_cleanup,
.close = via_pcm_open_close,
},
};
static struct hda_pcm_stream vt2002P_pcm_digital_playback = {
.substreams = 1,
.channels_min = 2,
.channels_max = 2,
.rates = SNDRV_PCM_RATE_48000,
/* NID is set in via_build_pcms */
.ops = {
.open = via_dig_playback_pcm_open,
.close = via_dig_playback_pcm_close,
.prepare = via_dig_playback_pcm_prepare,
.cleanup = via_dig_playback_pcm_cleanup
},
};
/* fill in the dac_nids table from the parsed pin configuration */
static int vt2002P_auto_fill_dac_nids(struct via_spec *spec,
const struct auto_pin_cfg *cfg)
{
spec->multiout.num_dacs = 1;
spec->multiout.dac_nids = spec->private_dac_nids;
if (cfg->line_out_pins[0])
spec->multiout.dac_nids[0] = 0x8;
return 0;
}
/* add playback controls from the parsed DAC table */
static int vt2002P_auto_create_multi_out_ctls(struct via_spec *spec,
const struct auto_pin_cfg *cfg)
{
int err;
if (!cfg->line_out_pins[0])
return -1;
/* Line-Out: PortE */
err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
"Master Front Playback Volume",
HDA_COMPOSE_AMP_VAL(0x8, 3, 0, HDA_OUTPUT));
if (err < 0)
return err;
err = via_add_control(spec, VIA_CTL_WIDGET_BIND_PIN_MUTE,
"Master Front Playback Switch",
HDA_COMPOSE_AMP_VAL(0x26, 3, 0, HDA_OUTPUT));
if (err < 0)
return err;
return 0;
}
static int vt2002P_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
{
int err;
if (!pin)
return 0;
spec->multiout.hp_nid = 0x9;
spec->hp_independent_mode_index = 1;
err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
"Headphone Playback Volume",
HDA_COMPOSE_AMP_VAL(
spec->multiout.hp_nid, 3, 0, HDA_OUTPUT));
if (err < 0)
return err;
err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
"Headphone Playback Switch",
HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT));
if (err < 0)
return err;
create_hp_imux(spec);
return 0;
}
/* create playback/capture controls for input pins */
static int vt2002P_auto_create_analog_input_ctls(struct via_spec *spec,
const struct auto_pin_cfg *cfg)
{
static char *labels[] = {
"Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
};
struct hda_input_mux *imux = &spec->private_imux[0];
int i, err, idx = 0;
for (i = 0; i < AUTO_PIN_LAST; i++) {
if (!cfg->input_pins[i])
continue;
switch (cfg->input_pins[i]) {
case 0x2b: /* Mic */
idx = 0;
break;
case 0x2a: /* Line In */
idx = 1;
break;
case 0x29: /* Front Mic */
idx = 2;
break;
}
err = via_new_analog_input(spec, labels[i], idx, 0x21);
if (err < 0)
return err;
imux->items[imux->num_items].label = labels[i];
imux->items[imux->num_items].index = idx;
imux->num_items++;
}
/* build volume/mute control of loopback */
err = via_new_analog_input(spec, "Stereo Mixer", 3, 0x21);
if (err < 0)
return err;
/* for internal loopback recording select */
imux->items[imux->num_items].label = "Stereo Mixer";
imux->items[imux->num_items].index = 3;
imux->num_items++;
/* for digital mic select */
imux->items[imux->num_items].label = "Digital Mic";
imux->items[imux->num_items].index = 4;
imux->num_items++;
return 0;
}
static int vt2002P_parse_auto_config(struct hda_codec *codec)
{
struct via_spec *spec = codec->spec;
int err;
err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
if (err < 0)
return err;
err = vt2002P_auto_fill_dac_nids(spec, &spec->autocfg);
if (err < 0)
return err;
if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
return 0; /* can't find valid BIOS pin config */
err = vt2002P_auto_create_multi_out_ctls(spec, &spec->autocfg);
if (err < 0)
return err;
err = vt2002P_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
if (err < 0)
return err;
err = vt2002P_auto_create_analog_input_ctls(spec, &spec->autocfg);
if (err < 0)
return err;
spec->multiout.max_channels = spec->multiout.num_dacs * 2;
fill_dig_outs(codec);
if (spec->kctls.list)
spec->mixers[spec->num_mixers++] = spec->kctls.list;
spec->input_mux = &spec->private_imux[0];
if (spec->hp_mux)
spec->mixers[spec->num_mixers++] = via_hp_mixer;
return 1;
}
#ifdef CONFIG_SND_HDA_POWER_SAVE
static struct hda_amp_list vt2002P_loopbacks[] = {
{ 0x21, HDA_INPUT, 0 },
{ 0x21, HDA_INPUT, 1 },
{ 0x21, HDA_INPUT, 2 },
{ } /* end */
};
#endif
/* patch for vt2002P */
static int patch_vt2002P(struct hda_codec *codec)
{
struct via_spec *spec;
int err;
/* create a codec specific record */
spec = kzalloc(sizeof(*spec), GFP_KERNEL);
if (spec == NULL)
return -ENOMEM;
codec->spec = spec;
/* automatic parse from the BIOS config */
err = vt2002P_parse_auto_config(codec);
if (err < 0) {
via_free(codec);
return err;
} else if (!err) {
printk(KERN_INFO "hda_codec: Cannot set up configuration "
"from BIOS. Using genenic mode...\n");
}
spec->init_verbs[spec->num_iverbs++] = vt2002P_volume_init_verbs;
spec->init_verbs[spec->num_iverbs++] = vt2002P_uniwill_init_verbs;
spec->stream_name_analog = "VT2002P Analog";
spec->stream_analog_playback = &vt2002P_pcm_analog_playback;
spec->stream_analog_capture = &vt2002P_pcm_analog_capture;
spec->stream_name_digital = "VT2002P Digital";
spec->stream_digital_playback = &vt2002P_pcm_digital_playback;
if (!spec->adc_nids && spec->input_mux) {
spec->adc_nids = vt2002P_adc_nids;
spec->num_adc_nids = ARRAY_SIZE(vt2002P_adc_nids);
get_mux_nids(codec);
override_mic_boost(codec, 0x2b, 0, 3, 40);
override_mic_boost(codec, 0x29, 0, 3, 40);
spec->mixers[spec->num_mixers] = vt2002P_capture_mixer;
spec->num_mixers++;
}
codec->patch_ops = via_patch_ops;
codec->patch_ops.init = via_auto_init;
codec->patch_ops.unsol_event = via_unsol_event,
#ifdef CONFIG_SND_HDA_POWER_SAVE
spec->loopback.amplist = vt2002P_loopbacks;
#endif
return 0;
}
/*
* patch entries
*/
@ -5085,6 +5738,8 @@ static struct hda_codec_preset snd_hda_preset_via[] = {
.patch = patch_vt1716S},
{ .id = 0x1106a721, .name = "VT1716S",
.patch = patch_vt1716S},
{ .id = 0x11060438, .name = "VT2002P", .patch = patch_vt2002P},
{ .id = 0x11064438, .name = "VT2002P", .patch = patch_vt2002P},
{} /* terminator */
};