UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

ALSA: hda - Parse ADCs and CAPSRCs dynamically for Realtek auto-parser 

Now with the new code for looking for ADCs and MUXs, we can replace
the whole ADC assignment with the parsed results.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
This commit is contained in:
Takashi Iwai 2011-07-06 16:38:42 +02:00
parent 0a7f532090
commit d6cc9fabd5
1 changed files with 131 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

323
sound/pci/hda/patch_realtek.c
View File

@ -405,6 +405,7 @@ struct alc_spec {
unsigned int no_analog :1; /* digital I/O only */ unsigned int no_analog :1; /* digital I/O only */
unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */ unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
unsigned int single_input_src:1; unsigned int single_input_src:1;
unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */
/* auto-mute control */ /* auto-mute control */
int automute_mode; int automute_mode;
@ -2677,11 +2678,15 @@ static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
{ {
struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
struct alc_spec *spec = codec->spec; struct alc_spec *spec = codec->spec;
unsigned long val;
int err; int err;
mutex_lock(&codec->control_mutex); mutex_lock(&codec->control_mutex);
kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, if (spec->vol_in_capsrc)
HDA_INPUT); val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
else
val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
kcontrol->private_value = val;
err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo); err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
mutex_unlock(&codec->control_mutex); mutex_unlock(&codec->control_mutex);
return err; return err;
@ -2692,11 +2697,15 @@ static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
{ {
struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
struct alc_spec *spec = codec->spec; struct alc_spec *spec = codec->spec;
unsigned long val;
int err; int err;
mutex_lock(&codec->control_mutex); mutex_lock(&codec->control_mutex);
kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, if (spec->vol_in_capsrc)
HDA_INPUT); val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
else
val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
kcontrol->private_value = val;
err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv); err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
mutex_unlock(&codec->control_mutex); mutex_unlock(&codec->control_mutex);
return err; return err;
@ -2725,9 +2734,14 @@ static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
} }
} else { } else {
i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
kcontrol->private_value = if (spec->vol_in_capsrc)
HDA_COMPOSE_AMP_VAL(spec->adc_nids[i], kcontrol->private_value =
3, 0, HDA_INPUT); HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i],
3, 0, HDA_OUTPUT);
else
kcontrol->private_value =
val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
3, 0, HDA_INPUT);
err = func(kcontrol, ucontrol); err = func(kcontrol, ucontrol);
} }
error: error:
@ -5381,10 +5395,14 @@ static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
return (pincap & AC_PINCAP_IN) != 0; return (pincap & AC_PINCAP_IN) != 0;
} }
static int alc_auto_fill_adc_caps(struct hda_codec *codec, hda_nid_t *adc_nids, static int alc_auto_fill_adc_caps(struct hda_codec *codec)
hda_nid_t *cap_nids, int max_nums)
{ {
struct alc_spec *spec = codec->spec;
hda_nid_t nid; hda_nid_t nid;
hda_nid_t *adc_nids = spec->private_adc_nids;
hda_nid_t *cap_nids = spec->private_capsrc_nids;
int max_nums = ARRAY_SIZE(spec->private_adc_nids);
bool indep_capsrc = false;
int i, nums = 0; int i, nums = 0;
nid = codec->start_nid; nid = codec->start_nid;
@ -5406,11 +5424,13 @@ static int alc_auto_fill_adc_caps(struct hda_codec *codec, hda_nid_t *adc_nids,
break; break;
if (type == AC_WID_AUD_SEL) { if (type == AC_WID_AUD_SEL) {
cap_nids[nums] = src; cap_nids[nums] = src;
indep_capsrc = true;
break; break;
} }
n = snd_hda_get_conn_list(codec, src, &list); n = snd_hda_get_conn_list(codec, src, &list);
if (n > 1) { if (n > 1) {
cap_nids[nums] = src; cap_nids[nums] = src;
indep_capsrc = true;
break; break;
} else if (n != 1) } else if (n != 1)
break; break;
@ -5419,6 +5439,10 @@ static int alc_auto_fill_adc_caps(struct hda_codec *codec, hda_nid_t *adc_nids,
if (++nums >= max_nums) if (++nums >= max_nums)
break; break;
} }
spec->adc_nids = spec->private_adc_nids;
if (indep_capsrc)
spec->capsrc_nids = spec->private_capsrc_nids;
spec->num_adc_nids = nums;
return nums; return nums;
} }
@ -5430,11 +5454,10 @@ static int alc_auto_create_input_ctls(struct hda_codec *codec)
hda_nid_t mixer = spec->mixer_nid; hda_nid_t mixer = spec->mixer_nid;
struct hda_input_mux *imux = &spec->private_imux[0]; struct hda_input_mux *imux = &spec->private_imux[0];
int num_adcs; int num_adcs;
hda_nid_t caps[5], adcs[5];
int i, c, err, idx, type_idx = 0; int i, c, err, idx, type_idx = 0;
const char *prev_label = NULL; const char *prev_label = NULL;
num_adcs = alc_auto_fill_adc_caps(codec, adcs, caps, ARRAY_SIZE(adcs)); num_adcs = alc_auto_fill_adc_caps(codec);
if (num_adcs < 0) if (num_adcs < 0)
return 0; return 0;
@ -5465,7 +5488,9 @@ static int alc_auto_create_input_ctls(struct hda_codec *codec)
} }
for (c = 0; c < num_adcs; c++) { for (c = 0; c < num_adcs; c++) {
idx = get_connection_index(codec, caps[c], pin); hda_nid_t cap = spec->capsrc_nids ?
spec->capsrc_nids[c] : spec->adc_nids[c];
idx = get_connection_index(codec, cap, pin);
if (idx >= 0) { if (idx >= 0) {
snd_hda_add_imux_item(imux, label, idx, NULL); snd_hda_add_imux_item(imux, label, idx, NULL);
break; break;
@ -5552,6 +5577,7 @@ static void alc880_auto_init_input_src(struct hda_codec *codec)
static int alc_auto_add_multi_channel_mode(struct hda_codec *codec, static int alc_auto_add_multi_channel_mode(struct hda_codec *codec,
int (*fill_dac)(struct hda_codec *)); int (*fill_dac)(struct hda_codec *));
static void alc_remove_invalid_adc_nids(struct hda_codec *codec);
/* parse the BIOS configuration and set up the alc_spec */ /* parse the BIOS configuration and set up the alc_spec */
/* return 1 if successful, 0 if the proper config is not found, /* return 1 if successful, 0 if the proper config is not found,
@ -5599,6 +5625,9 @@ static int alc880_parse_auto_config(struct hda_codec *codec)
spec->num_mux_defs = 1; spec->num_mux_defs = 1;
spec->input_mux = &spec->private_imux[0]; spec->input_mux = &spec->private_imux[0];
if (!spec->dual_adc_switch)
alc_remove_invalid_adc_nids(codec);
alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0); alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
return 1; return 1;
@ -5742,9 +5771,21 @@ static void set_capture_mixer(struct hda_codec *codec)
alc_capture_mixer2, alc_capture_mixer2,
alc_capture_mixer3 }, alc_capture_mixer3 },
}; };
if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
/* check whether either of ADC or MUX has a volume control */
if (!(query_amp_caps(codec, spec->adc_nids[0], HDA_INPUT) &
AC_AMPCAP_NUM_STEPS)) {
if (!spec->capsrc_nids)
return; /* no volume */
if (!(query_amp_caps(codec, spec->capsrc_nids[0], HDA_OUTPUT) &
AC_AMPCAP_NUM_STEPS))
return; /* no volume in capsrc, too */
spec->vol_in_capsrc = 1;
}
if (spec->num_adc_nids > 0) {
int mux = 0; int mux = 0;
int num_adcs = spec->num_adc_nids; int num_adcs = 0;
if (spec->dual_adc_switch) if (spec->dual_adc_switch)
num_adcs = 1; num_adcs = 1;
else if (spec->auto_mic) else if (spec->auto_mic)
@ -5755,70 +5796,52 @@ static void set_capture_mixer(struct hda_codec *codec)
else if (spec->input_mux->num_items == 1) else if (spec->input_mux->num_items == 1)
fixup_single_adc(codec); fixup_single_adc(codec);
} }
if (!num_adcs) {
if (spec->num_adc_nids > 3)
spec->num_adc_nids = 3;
else if (!spec->num_adc_nids)
return;
num_adcs = spec->num_adc_nids;
}
spec->cap_mixer = caps[mux][num_adcs - 1]; spec->cap_mixer = caps[mux][num_adcs - 1];
} }
} }
/* fill adc_nids (and capsrc_nids) containing all active input pins */ /* filter out invalid adc_nids (and capsrc_nids) that don't give all
static void fillup_priv_adc_nids(struct hda_codec *codec, const hda_nid_t *nids, * active input pins
int num_nids) */
static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
{ {
struct alc_spec *spec = codec->spec; struct alc_spec *spec = codec->spec;
struct auto_pin_cfg *cfg = &spec->autocfg; struct auto_pin_cfg *cfg = &spec->autocfg;
int n; hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)];
hda_nid_t fallback_adc = 0, fallback_cap = 0; hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)];
int i, n, nums;
for (n = 0; n < num_nids; n++) { nums = 0;
hda_nid_t adc, cap; for (n = 0; n < spec->num_adc_nids; n++) {
hda_nid_t conn[HDA_MAX_NUM_INPUTS]; hda_nid_t cap = spec->private_capsrc_nids[n];
int nconns, i, j;
adc = nids[n];
if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
continue;
cap = adc;
nconns = snd_hda_get_connections(codec, cap, conn,
ARRAY_SIZE(conn));
if (nconns == 1) {
cap = conn[0];
nconns = snd_hda_get_connections(codec, cap, conn,
ARRAY_SIZE(conn));
}
if (nconns <= 0)
continue;
if (!fallback_adc) {
fallback_adc = adc;
fallback_cap = cap;
}
for (i = 0; i < cfg->num_inputs; i++) { for (i = 0; i < cfg->num_inputs; i++) {
hda_nid_t nid = cfg->inputs[i].pin; hda_nid_t pin = cfg->inputs[i].pin;
for (j = 0; j < nconns; j++) { if (get_connection_index(codec, cap, pin) < 0)
if (conn[j] == nid)
break;
}
if (j >= nconns)
break; break;
} }
if (i >= cfg->num_inputs) { if (i >= cfg->num_inputs) {
int num_adcs = spec->num_adc_nids; adc_nids[nums] = spec->private_adc_nids[n];
spec->private_adc_nids[num_adcs] = adc; capsrc_nids[nums++] = cap;
spec->private_capsrc_nids[num_adcs] = cap;
spec->num_adc_nids++;
spec->adc_nids = spec->private_adc_nids;
if (adc != cap)
spec->capsrc_nids = spec->private_capsrc_nids;
} }
} }
if (!spec->num_adc_nids) { if (!nums) {
printk(KERN_WARNING "hda_codec: %s: no valid ADC found;" printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
" using fallback 0x%x\n", " using fallback 0x%x\n",
codec->chip_name, fallback_adc); codec->chip_name, spec->private_adc_nids[0]);
spec->private_adc_nids[0] = fallback_adc; spec->num_adc_nids = 1;
spec->adc_nids = spec->private_adc_nids; } else if (nums != spec->num_adc_nids) {
if (fallback_adc != fallback_cap) { memcpy(spec->private_adc_nids, adc_nids,
spec->private_capsrc_nids[0] = fallback_cap; nums * sizeof(hda_nid_t));
spec->capsrc_nids = spec->private_adc_nids; memcpy(spec->private_capsrc_nids, capsrc_nids,
} nums * sizeof(hda_nid_t));
spec->num_adc_nids = nums;
} }
} }
@ -5907,17 +5930,8 @@ static int patch_alc880(struct hda_codec *codec)
spec->stream_digital_capture = &alc880_pcm_digital_capture; spec->stream_digital_capture = &alc880_pcm_digital_capture;
if (!spec->adc_nids && spec->input_mux) { if (!spec->adc_nids && spec->input_mux) {
/* check whether NID 0x07 is valid */ alc_auto_fill_adc_caps(codec);
unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]); alc_remove_invalid_adc_nids(codec);
/* get type */
wcap = get_wcaps_type(wcap);
if (wcap != AC_WID_AUD_IN) {
spec->adc_nids = alc880_adc_nids_alt;
spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
} else {
spec->adc_nids = alc880_adc_nids;
spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
}
} }
set_capture_mixer(codec); set_capture_mixer(codec);
set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
@ -7173,6 +7187,9 @@ static int alc260_parse_auto_config(struct hda_codec *codec)
spec->num_mux_defs = 1; spec->num_mux_defs = 1;
spec->input_mux = &spec->private_imux[0]; spec->input_mux = &spec->private_imux[0];
if (!spec->dual_adc_switch)
alc_remove_invalid_adc_nids(codec);
alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0); alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
return 1; return 1;
@ -7463,17 +7480,8 @@ static int patch_alc260(struct hda_codec *codec)
spec->stream_digital_capture = &alc260_pcm_digital_capture; spec->stream_digital_capture = &alc260_pcm_digital_capture;
if (!spec->adc_nids && spec->input_mux) { if (!spec->adc_nids && spec->input_mux) {
/* check whether NID 0x04 is valid */ alc_auto_fill_adc_caps(codec);
unsigned int wcap = get_wcaps(codec, 0x04); alc_remove_invalid_adc_nids(codec);
wcap = get_wcaps_type(wcap);
/* get type */
if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
spec->adc_nids = alc260_adc_nids_alt;
spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
} else {
spec->adc_nids = alc260_adc_nids;
spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
}
} }
set_capture_mixer(codec); set_capture_mixer(codec);
set_beep_amp(spec, 0x07, 0x05, HDA_INPUT); set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
@ -10947,6 +10955,9 @@ static int alc882_parse_auto_config(struct hda_codec *codec)
spec->num_mux_defs = 1; spec->num_mux_defs = 1;
spec->input_mux = &spec->private_imux[0]; spec->input_mux = &spec->private_imux[0];
if (!spec->dual_adc_switch)
alc_remove_invalid_adc_nids(codec);
alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0); alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
err = alc_auto_add_mic_boost(codec); err = alc_auto_add_mic_boost(codec);
@ -11048,34 +11059,8 @@ static int patch_alc882(struct hda_codec *codec)
spec->stream_digital_capture = &alc882_pcm_digital_capture; spec->stream_digital_capture = &alc882_pcm_digital_capture;
if (!spec->adc_nids && spec->input_mux) { if (!spec->adc_nids && spec->input_mux) {
int i, j; alc_auto_fill_adc_caps(codec);
spec->num_adc_nids = 0; alc_remove_invalid_adc_nids(codec);
for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
const struct hda_input_mux *imux = spec->input_mux;
hda_nid_t cap;
hda_nid_t nid = alc882_adc_nids[i];
unsigned int wcap = get_wcaps(codec, nid);
/* get type */
wcap = get_wcaps_type(wcap);
if (wcap != AC_WID_AUD_IN)
continue;
spec->private_adc_nids[spec->num_adc_nids] = nid;
err = snd_hda_get_connections(codec, nid, &cap, 1);
if (err < 0)
continue;
err = snd_hda_get_conn_list(codec, cap, NULL);
if (err < 0)
continue;
for (j = 0; j < imux->num_items; j++)
if (imux->items[j].index >= err)
break;
if (j < imux->num_items)
continue;
spec->private_capsrc_nids[spec->num_adc_nids] = cap;
spec->num_adc_nids++;
}
spec->adc_nids = spec->private_adc_nids;
spec->capsrc_nids = spec->private_capsrc_nids;
} }
set_capture_mixer(codec); set_capture_mixer(codec);
@ -12308,6 +12293,9 @@ static int alc262_parse_auto_config(struct hda_codec *codec)
spec->num_mux_defs = 1; spec->num_mux_defs = 1;
spec->input_mux = &spec->private_imux[0]; spec->input_mux = &spec->private_imux[0];
if (!spec->dual_adc_switch)
alc_remove_invalid_adc_nids(codec);
err = alc_auto_add_mic_boost(codec); err = alc_auto_add_mic_boost(codec);
if (err < 0) if (err < 0)
return err; return err;
@ -12727,36 +12715,8 @@ static int patch_alc262(struct hda_codec *codec)
spec->stream_digital_capture = &alc262_pcm_digital_capture; spec->stream_digital_capture = &alc262_pcm_digital_capture;
if (!spec->adc_nids && spec->input_mux) { if (!spec->adc_nids && spec->input_mux) {
int i; alc_auto_fill_adc_caps(codec);
/* check whether the digital-mic has to be supported */ alc_remove_invalid_adc_nids(codec);
for (i = 0; i < spec->input_mux->num_items; i++) {
if (spec->input_mux->items[i].index >= 9)
break;
}
if (i < spec->input_mux->num_items) {
/* use only ADC0 */
spec->adc_nids = alc262_dmic_adc_nids;
spec->num_adc_nids = 1;
spec->capsrc_nids = alc262_dmic_capsrc_nids;
} else {
/* all analog inputs */
/* check whether NID 0x07 is valid */
unsigned int wcap = get_wcaps(codec, 0x07);
/* get type */
wcap = get_wcaps_type(wcap);
if (wcap != AC_WID_AUD_IN) {
spec->adc_nids = alc262_adc_nids_alt;
spec->num_adc_nids =
ARRAY_SIZE(alc262_adc_nids_alt);
spec->capsrc_nids = alc262_capsrc_nids_alt;
} else {
spec->adc_nids = alc262_adc_nids;
spec->num_adc_nids =
ARRAY_SIZE(alc262_adc_nids);
spec->capsrc_nids = alc262_capsrc_nids;
}
}
} }
if (!spec->cap_mixer && !spec->no_analog) if (!spec->cap_mixer && !spec->no_analog)
set_capture_mixer(codec); set_capture_mixer(codec);
@ -13462,6 +13422,9 @@ static int alc268_parse_auto_config(struct hda_codec *codec)
spec->num_mux_defs = 2; spec->num_mux_defs = 2;
spec->input_mux = &spec->private_imux[0]; spec->input_mux = &spec->private_imux[0];
if (!spec->dual_adc_switch)
alc_remove_invalid_adc_nids(codec);
err = alc_auto_add_mic_boost(codec); err = alc_auto_add_mic_boost(codec);
if (err < 0) if (err < 0)
return err; return err;
@ -13773,29 +13736,13 @@ static int patch_alc268(struct hda_codec *codec)
} }
if (!spec->no_analog && !spec->adc_nids && spec->input_mux) { if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
/* check whether NID 0x07 is valid */ alc_auto_fill_adc_caps(codec);
unsigned int wcap = get_wcaps(codec, 0x07); alc_remove_invalid_adc_nids(codec);
spec->capsrc_nids = alc268_capsrc_nids;
/* get type */
wcap = get_wcaps_type(wcap);
if (spec->auto_mic ||
wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
spec->adc_nids = alc268_adc_nids_alt;
spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
if (spec->auto_mic)
fixup_automic_adc(codec);
if (spec->auto_mic || spec->input_mux->num_items == 1)
add_mixer(spec, alc268_capture_nosrc_mixer);
else
add_mixer(spec, alc268_capture_alt_mixer);
} else {
spec->adc_nids = alc268_adc_nids;
spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
add_mixer(spec, alc268_capture_mixer);
}
} }
if (!spec->cap_mixer && !spec->no_analog)
set_capture_mixer(codec);
spec->vmaster_nid = 0x02; spec->vmaster_nid = 0x02;
codec->patch_ops = alc_patch_ops; codec->patch_ops = alc_patch_ops;
@ -13833,10 +13780,6 @@ static const hda_nid_t alc269vb_capsrc_nids[1] = {
0x22, 0x22,
}; };
static const hda_nid_t alc269_adc_candidates[] = {
0x08, 0x09, 0x07, 0x11,
};
#define alc269_modes alc260_modes #define alc269_modes alc260_modes
#define alc269_capture_source alc880_lg_lw_capture_source #define alc269_capture_source alc880_lg_lw_capture_source
@ -14422,9 +14365,9 @@ static int alc269_parse_auto_config(struct hda_codec *codec)
spec->num_mux_defs = 1; spec->num_mux_defs = 1;
spec->input_mux = &spec->private_imux[0]; spec->input_mux = &spec->private_imux[0];
if (!alc275_setup_dual_adc(codec)) alc275_setup_dual_adc(codec);
fillup_priv_adc_nids(codec, alc269_adc_candidates, if (!spec->dual_adc_switch)
sizeof(alc269_adc_candidates)); alc_remove_invalid_adc_nids(codec);
err = alc_auto_add_mic_boost(codec); err = alc_auto_add_mic_boost(codec);
if (err < 0) if (err < 0)
@ -14961,15 +14904,8 @@ static int patch_alc269(struct hda_codec *codec)
spec->stream_digital_capture = &alc269_pcm_digital_capture; spec->stream_digital_capture = &alc269_pcm_digital_capture;
if (!spec->adc_nids) { /* wasn't filled automatically? use default */ if (!spec->adc_nids) { /* wasn't filled automatically? use default */
if (spec->codec_variant == ALC269_TYPE_ALC269VA) { alc_auto_fill_adc_caps(codec);
spec->adc_nids = alc269_adc_nids; alc_remove_invalid_adc_nids(codec);
spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
spec->capsrc_nids = alc269_capsrc_nids;
} else {
spec->adc_nids = alc269vb_adc_nids;
spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
spec->capsrc_nids = alc269vb_capsrc_nids;
}
} }
if (!spec->cap_mixer) if (!spec->cap_mixer)
@ -15776,12 +15712,13 @@ static int alc861_parse_auto_config(struct hda_codec *codec)
spec->num_mux_defs = 1; spec->num_mux_defs = 1;
spec->input_mux = &spec->private_imux[0]; spec->input_mux = &spec->private_imux[0];
spec->adc_nids = alc861_adc_nids; if (!spec->dual_adc_switch)
spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids); alc_remove_invalid_adc_nids(codec);
set_capture_mixer(codec);
alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0); alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
set_capture_mixer(codec);
return 1; return 1;
} }
@ -16837,6 +16774,9 @@ static int alc861vd_parse_auto_config(struct hda_codec *codec)
spec->num_mux_defs = 1; spec->num_mux_defs = 1;
spec->input_mux = &spec->private_imux[0]; spec->input_mux = &spec->private_imux[0];
if (!spec->dual_adc_switch)
alc_remove_invalid_adc_nids(codec);
err = alc_auto_add_mic_boost(codec); err = alc_auto_add_mic_boost(codec);
if (err < 0) if (err < 0)
return err; return err;
@ -16944,11 +16884,9 @@ static int patch_alc861vd(struct hda_codec *codec)
spec->stream_digital_capture = &alc861vd_pcm_digital_capture; spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
if (!spec->adc_nids) { if (!spec->adc_nids) {
spec->adc_nids = alc861vd_adc_nids; alc_auto_fill_adc_caps(codec);
spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids); alc_remove_invalid_adc_nids(codec);
} }
if (!spec->capsrc_nids)
spec->capsrc_nids = alc861vd_capsrc_nids;
set_capture_mixer(codec); set_capture_mixer(codec);
set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
@ -18965,6 +18903,9 @@ static int alc662_parse_auto_config(struct hda_codec *codec)
spec->num_mux_defs = 1; spec->num_mux_defs = 1;
spec->input_mux = &spec->private_imux[0]; spec->input_mux = &spec->private_imux[0];
if (!spec->dual_adc_switch)
alc_remove_invalid_adc_nids(codec);
err = alc_auto_add_mic_boost(codec); err = alc_auto_add_mic_boost(codec);
if (err < 0) if (err < 0)
return err; return err;
@ -19134,11 +19075,9 @@ static int patch_alc662(struct hda_codec *codec)
spec->stream_digital_capture = &alc662_pcm_digital_capture; spec->stream_digital_capture = &alc662_pcm_digital_capture;
if (!spec->adc_nids) { if (!spec->adc_nids) {
spec->adc_nids = alc662_adc_nids; alc_auto_fill_adc_caps(codec);
spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids); alc_remove_invalid_adc_nids(codec);
} }
if (!spec->capsrc_nids)
spec->capsrc_nids = alc662_capsrc_nids;
if (!spec->cap_mixer) if (!spec->cap_mixer)
set_capture_mixer(codec); set_capture_mixer(codec);
@ -19631,8 +19570,8 @@ static int patch_alc680(struct hda_codec *codec)
spec->stream_digital_capture = &alc680_pcm_digital_capture; spec->stream_digital_capture = &alc680_pcm_digital_capture;
if (!spec->adc_nids) { if (!spec->adc_nids) {
spec->adc_nids = alc680_adc_nids; alc_auto_fill_adc_caps(codec);
spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids); alc_remove_invalid_adc_nids(codec);
} }
if (!spec->cap_mixer) if (!spec->cap_mixer)