2 * Universal Interface for Intel High Definition Audio Codec
4 * HD audio interface patch for Realtek ALC codecs
6 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
7 * PeiSen Hou <pshou@realtek.com.tw>
8 * Takashi Iwai <tiwai@suse.de>
9 * Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
11 * This driver is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This driver is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/pci.h>
30 #include <linux/module.h>
31 #include <sound/core.h>
32 #include <sound/jack.h>
33 #include "hda_codec.h"
34 #include "hda_local.h"
38 /* unsol event tags */
39 #define ALC_FRONT_EVENT 0x01
40 #define ALC_DCVOL_EVENT 0x02
41 #define ALC_HP_EVENT 0x04
42 #define ALC_MIC_EVENT 0x08
45 #define GPIO_MASK 0x03
47 /* extra amp-initialization sequence types */
56 struct alc_customize_define {
58 unsigned char port_connectivity;
59 unsigned char check_sum;
60 unsigned char customization;
61 unsigned char external_amp;
62 unsigned int enable_pcbeep:1;
63 unsigned int platform_type:1;
65 unsigned int override:1;
66 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */
72 hda_nid_t pin; /* multi-io widget pin NID */
73 hda_nid_t dac; /* DAC to be connected */
74 unsigned int ctl_in; /* cached input-pin control value */
78 ALC_AUTOMUTE_PIN, /* change the pin control */
79 ALC_AUTOMUTE_AMP, /* mute/unmute the pin AMP */
80 ALC_AUTOMUTE_MIXER, /* mute/unmute mixer widget AMP */
83 #define MAX_VOL_NIDS 0x40
86 /* codec parameterization */
87 const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
88 unsigned int num_mixers;
89 const struct snd_kcontrol_new *cap_mixer; /* capture mixer */
90 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
92 const struct hda_verb *init_verbs[10]; /* initialization verbs
96 unsigned int num_init_verbs;
98 char stream_name_analog[32]; /* analog PCM stream */
99 const struct hda_pcm_stream *stream_analog_playback;
100 const struct hda_pcm_stream *stream_analog_capture;
101 const struct hda_pcm_stream *stream_analog_alt_playback;
102 const struct hda_pcm_stream *stream_analog_alt_capture;
104 char stream_name_digital[32]; /* digital PCM stream */
105 const struct hda_pcm_stream *stream_digital_playback;
106 const struct hda_pcm_stream *stream_digital_capture;
109 struct hda_multi_out multiout; /* playback set-up
110 * max_channels, dacs must be set
111 * dig_out_nid and hp_nid are optional
113 hda_nid_t alt_dac_nid;
114 hda_nid_t slave_dig_outs[3]; /* optional - for auto-parsing */
118 unsigned int num_adc_nids;
119 const hda_nid_t *adc_nids;
120 const hda_nid_t *capsrc_nids;
121 hda_nid_t dig_in_nid; /* digital-in NID; optional */
122 hda_nid_t mixer_nid; /* analog-mixer NID */
123 DECLARE_BITMAP(vol_ctls, MAX_VOL_NIDS << 1);
124 DECLARE_BITMAP(sw_ctls, MAX_VOL_NIDS << 1);
126 /* capture setup for dynamic dual-adc switch */
128 unsigned int cur_adc_stream_tag;
129 unsigned int cur_adc_format;
132 unsigned int num_mux_defs;
133 const struct hda_input_mux *input_mux;
134 unsigned int cur_mux[3];
135 hda_nid_t ext_mic_pin;
136 hda_nid_t dock_mic_pin;
137 hda_nid_t int_mic_pin;
140 const struct hda_channel_mode *channel_mode;
141 int num_channel_mode;
143 int const_channel_count;
144 int ext_channel_count;
146 /* PCM information */
147 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
149 /* dynamic controls, init_verbs and input_mux */
150 struct auto_pin_cfg autocfg;
151 struct alc_customize_define cdefine;
152 struct snd_array kctls;
153 struct hda_input_mux private_imux[3];
154 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
155 hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
156 hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
157 hda_nid_t imux_pins[HDA_MAX_NUM_INPUTS];
158 unsigned int dyn_adc_idx[HDA_MAX_NUM_INPUTS];
159 int int_mic_idx, ext_mic_idx, dock_mic_idx; /* for auto-mic */
162 void (*init_hook)(struct hda_codec *codec);
163 void (*unsol_event)(struct hda_codec *codec, unsigned int res);
164 #ifdef CONFIG_SND_HDA_POWER_SAVE
165 void (*power_hook)(struct hda_codec *codec);
167 void (*shutup)(struct hda_codec *codec);
168 void (*automute_hook)(struct hda_codec *codec);
170 /* for pin sensing */
171 unsigned int hp_jack_present:1;
172 unsigned int line_jack_present:1;
173 unsigned int master_mute:1;
174 unsigned int auto_mic:1;
175 unsigned int auto_mic_valid_imux:1; /* valid imux for auto-mic */
176 unsigned int automute_speaker:1; /* automute speaker outputs */
177 unsigned int automute_lo:1; /* automute LO outputs */
178 unsigned int detect_hp:1; /* Headphone detection enabled */
179 unsigned int detect_lo:1; /* Line-out detection enabled */
180 unsigned int automute_speaker_possible:1; /* there are speakers and either LO or HP */
181 unsigned int automute_lo_possible:1; /* there are line outs and HP */
182 unsigned int keep_vref_in_automute:1; /* Don't clear VREF in automute */
185 unsigned int no_analog :1; /* digital I/O only */
186 unsigned int dyn_adc_switch:1; /* switch ADCs (for ALC275) */
187 unsigned int single_input_src:1;
188 unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */
189 unsigned int parse_flags; /* passed to snd_hda_parse_pin_defcfg() */
190 unsigned int shared_mic_hp:1; /* HP/Mic-in sharing */
192 /* auto-mute control */
194 hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];
197 int codec_variant; /* flag for other variants */
199 /* for virtual master */
200 hda_nid_t vmaster_nid;
201 #ifdef CONFIG_SND_HDA_POWER_SAVE
202 struct hda_loopback_check loopback;
207 unsigned int pll_coef_idx, pll_coef_bit;
212 const struct alc_fixup *fixup_list;
213 const char *fixup_name;
217 struct alc_multi_io multi_io[4];
220 struct snd_array bind_ctls;
223 #define ALC_MODEL_AUTO 0 /* common for all chips */
225 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
226 int dir, unsigned int bits)
230 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
231 if (query_amp_caps(codec, nid, dir) & bits)
236 #define nid_has_mute(codec, nid, dir) \
237 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
238 #define nid_has_volume(codec, nid, dir) \
239 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
244 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
245 struct snd_ctl_elem_info *uinfo)
247 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
248 struct alc_spec *spec = codec->spec;
249 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
250 if (mux_idx >= spec->num_mux_defs)
252 if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
254 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
257 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
258 struct snd_ctl_elem_value *ucontrol)
260 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
261 struct alc_spec *spec = codec->spec;
262 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
264 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
268 static bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
270 struct alc_spec *spec = codec->spec;
271 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
273 if (spec->cur_adc && spec->cur_adc != new_adc) {
274 /* stream is running, let's swap the current ADC */
275 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
276 spec->cur_adc = new_adc;
277 snd_hda_codec_setup_stream(codec, new_adc,
278 spec->cur_adc_stream_tag, 0,
279 spec->cur_adc_format);
285 static inline hda_nid_t get_capsrc(struct alc_spec *spec, int idx)
287 return spec->capsrc_nids ?
288 spec->capsrc_nids[idx] : spec->adc_nids[idx];
291 static void call_update_outputs(struct hda_codec *codec);
293 /* select the given imux item; either unmute exclusively or select the route */
294 static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
295 unsigned int idx, bool force)
297 struct alc_spec *spec = codec->spec;
298 const struct hda_input_mux *imux;
299 unsigned int mux_idx;
300 int i, type, num_conns;
303 mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
304 imux = &spec->input_mux[mux_idx];
305 if (!imux->num_items && mux_idx > 0)
306 imux = &spec->input_mux[0];
307 if (!imux->num_items)
310 if (idx >= imux->num_items)
311 idx = imux->num_items - 1;
312 if (spec->cur_mux[adc_idx] == idx && !force)
314 spec->cur_mux[adc_idx] = idx;
316 /* for shared I/O, change the pin-control accordingly */
317 if (spec->shared_mic_hp) {
318 /* NOTE: this assumes that there are only two inputs, the
319 * first is the real internal mic and the second is HP jack.
321 snd_hda_codec_write(codec, spec->autocfg.inputs[1].pin, 0,
322 AC_VERB_SET_PIN_WIDGET_CONTROL,
323 spec->cur_mux[adc_idx] ?
324 PIN_VREF80 : PIN_HP);
325 spec->automute_speaker = !spec->cur_mux[adc_idx];
326 call_update_outputs(codec);
329 if (spec->dyn_adc_switch) {
330 alc_dyn_adc_pcm_resetup(codec, idx);
331 adc_idx = spec->dyn_adc_idx[idx];
334 nid = get_capsrc(spec, adc_idx);
337 num_conns = snd_hda_get_conn_list(codec, nid, NULL);
341 type = get_wcaps_type(get_wcaps(codec, nid));
342 if (type == AC_WID_AUD_MIX) {
343 /* Matrix-mixer style (e.g. ALC882) */
344 int active = imux->items[idx].index;
345 for (i = 0; i < num_conns; i++) {
346 unsigned int v = (i == active) ? 0 : HDA_AMP_MUTE;
347 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, i,
351 /* MUX style (e.g. ALC880) */
352 snd_hda_codec_write_cache(codec, nid, 0,
353 AC_VERB_SET_CONNECT_SEL,
354 imux->items[idx].index);
359 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
360 struct snd_ctl_elem_value *ucontrol)
362 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
363 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
364 return alc_mux_select(codec, adc_idx,
365 ucontrol->value.enumerated.item[0], false);
369 * set up the input pin config (depending on the given auto-pin type)
371 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
374 unsigned int val = PIN_IN;
376 if (auto_pin_type == AUTO_PIN_MIC) {
379 oldval = snd_hda_codec_read(codec, nid, 0,
380 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
381 pincap = snd_hda_query_pin_caps(codec, nid);
382 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
383 /* if the default pin setup is vref50, we give it priority */
384 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
386 else if (pincap & AC_PINCAP_VREF_50)
388 else if (pincap & AC_PINCAP_VREF_100)
390 else if (pincap & AC_PINCAP_VREF_GRD)
393 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
397 * Append the given mixer and verb elements for the later use
398 * The mixer array is referred in build_controls(), and init_verbs are
401 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
403 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
405 spec->mixers[spec->num_mixers++] = mix;
408 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
410 if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
412 spec->init_verbs[spec->num_init_verbs++] = verb;
416 * GPIO setup tables, used in initialization
418 /* Enable GPIO mask and set output */
419 static const struct hda_verb alc_gpio1_init_verbs[] = {
420 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
421 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
422 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
426 static const struct hda_verb alc_gpio2_init_verbs[] = {
427 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
428 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
429 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
433 static const struct hda_verb alc_gpio3_init_verbs[] = {
434 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
435 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
436 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
441 * Fix hardware PLL issue
442 * On some codecs, the analog PLL gating control must be off while
443 * the default value is 1.
445 static void alc_fix_pll(struct hda_codec *codec)
447 struct alc_spec *spec = codec->spec;
452 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
454 val = snd_hda_codec_read(codec, spec->pll_nid, 0,
455 AC_VERB_GET_PROC_COEF, 0);
456 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
458 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
459 val & ~(1 << spec->pll_coef_bit));
462 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
463 unsigned int coef_idx, unsigned int coef_bit)
465 struct alc_spec *spec = codec->spec;
467 spec->pll_coef_idx = coef_idx;
468 spec->pll_coef_bit = coef_bit;
473 * Jack detections for HP auto-mute and mic-switch
476 /* check each pin in the given array; returns true if any of them is plugged */
477 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
481 for (i = 0; i < num_pins; i++) {
482 hda_nid_t nid = pins[i];
485 present |= snd_hda_jack_detect(codec, nid);
490 /* standard HP/line-out auto-mute helper */
491 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
492 bool mute, bool hp_out)
494 struct alc_spec *spec = codec->spec;
495 unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;
496 unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
499 for (i = 0; i < num_pins; i++) {
500 hda_nid_t nid = pins[i];
504 switch (spec->automute_mode) {
505 case ALC_AUTOMUTE_PIN:
506 /* don't reset VREF value in case it's controlling
507 * the amp (see alc861_fixup_asus_amp_vref_0f())
509 if (spec->keep_vref_in_automute) {
510 val = snd_hda_codec_read(codec, nid, 0,
511 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
516 snd_hda_codec_write(codec, nid, 0,
517 AC_VERB_SET_PIN_WIDGET_CONTROL,
520 case ALC_AUTOMUTE_AMP:
521 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
522 HDA_AMP_MUTE, mute_bits);
524 case ALC_AUTOMUTE_MIXER:
525 nid = spec->automute_mixer_nid[i];
528 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
529 HDA_AMP_MUTE, mute_bits);
530 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,
531 HDA_AMP_MUTE, mute_bits);
537 /* Toggle outputs muting */
538 static void update_outputs(struct hda_codec *codec)
540 struct alc_spec *spec = codec->spec;
543 /* Control HP pins/amps depending on master_mute state;
544 * in general, HP pins/amps control should be enabled in all cases,
545 * but currently set only for master_mute, just to be safe
547 if (!spec->shared_mic_hp) /* don't change HP-pin when shared with mic */
548 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
549 spec->autocfg.hp_pins, spec->master_mute, true);
551 if (!spec->automute_speaker)
554 on = spec->hp_jack_present | spec->line_jack_present;
555 on |= spec->master_mute;
556 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
557 spec->autocfg.speaker_pins, on, false);
559 /* toggle line-out mutes if needed, too */
560 /* if LO is a copy of either HP or Speaker, don't need to handle it */
561 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
562 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
564 if (!spec->automute_lo)
567 on = spec->hp_jack_present;
568 on |= spec->master_mute;
569 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
570 spec->autocfg.line_out_pins, on, false);
573 static void call_update_outputs(struct hda_codec *codec)
575 struct alc_spec *spec = codec->spec;
576 if (spec->automute_hook)
577 spec->automute_hook(codec);
579 update_outputs(codec);
582 /* standard HP-automute helper */
583 static void alc_hp_automute(struct hda_codec *codec)
585 struct alc_spec *spec = codec->spec;
587 spec->hp_jack_present =
588 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
589 spec->autocfg.hp_pins);
590 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
592 call_update_outputs(codec);
595 /* standard line-out-automute helper */
596 static void alc_line_automute(struct hda_codec *codec)
598 struct alc_spec *spec = codec->spec;
600 /* check LO jack only when it's different from HP */
601 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
604 spec->line_jack_present =
605 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
606 spec->autocfg.line_out_pins);
607 if (!spec->automute_speaker || !spec->detect_lo)
609 call_update_outputs(codec);
612 #define get_connection_index(codec, mux, nid) \
613 snd_hda_get_conn_index(codec, mux, nid, 0)
615 /* standard mic auto-switch helper */
616 static void alc_mic_automute(struct hda_codec *codec)
618 struct alc_spec *spec = codec->spec;
619 hda_nid_t *pins = spec->imux_pins;
621 if (!spec->auto_mic || !spec->auto_mic_valid_imux)
623 if (snd_BUG_ON(!spec->adc_nids))
625 if (snd_BUG_ON(spec->int_mic_idx < 0 || spec->ext_mic_idx < 0))
628 if (snd_hda_jack_detect(codec, pins[spec->ext_mic_idx]))
629 alc_mux_select(codec, 0, spec->ext_mic_idx, false);
630 else if (spec->dock_mic_idx >= 0 &&
631 snd_hda_jack_detect(codec, pins[spec->dock_mic_idx]))
632 alc_mux_select(codec, 0, spec->dock_mic_idx, false);
634 alc_mux_select(codec, 0, spec->int_mic_idx, false);
637 /* handle the specified unsol action (ALC_XXX_EVENT) */
638 static void alc_exec_unsol_event(struct hda_codec *codec, int action)
642 alc_hp_automute(codec);
644 case ALC_FRONT_EVENT:
645 alc_line_automute(codec);
648 alc_mic_automute(codec);
651 snd_hda_jack_report_sync(codec);
654 /* unsolicited event for HP jack sensing */
655 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
657 if (codec->vendor_id == 0x10ec0880)
661 res = snd_hda_jack_get_action(codec, res);
662 alc_exec_unsol_event(codec, res);
665 /* call init functions of standard auto-mute helpers */
666 static void alc_inithook(struct hda_codec *codec)
668 alc_hp_automute(codec);
669 alc_line_automute(codec);
670 alc_mic_automute(codec);
673 /* additional initialization for ALC888 variants */
674 static void alc888_coef_init(struct hda_codec *codec)
678 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
679 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
680 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
681 if ((tmp & 0xf0) == 0x20)
683 snd_hda_codec_read(codec, 0x20, 0,
684 AC_VERB_SET_PROC_COEF, 0x830);
687 snd_hda_codec_read(codec, 0x20, 0,
688 AC_VERB_SET_PROC_COEF, 0x3030);
691 /* additional initialization for ALC889 variants */
692 static void alc889_coef_init(struct hda_codec *codec)
696 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
697 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
698 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
699 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
702 /* turn on/off EAPD control (only if available) */
703 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
705 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
707 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
708 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
712 /* turn on/off EAPD controls of the codec */
713 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
715 /* We currently only handle front, HP */
716 static hda_nid_t pins[] = {
717 0x0f, 0x10, 0x14, 0x15, 0
720 for (p = pins; *p; p++)
721 set_eapd(codec, *p, on);
724 /* generic shutup callback;
725 * just turning off EPAD and a little pause for avoiding pop-noise
727 static void alc_eapd_shutup(struct hda_codec *codec)
729 alc_auto_setup_eapd(codec, false);
733 /* generic EAPD initialization */
734 static void alc_auto_init_amp(struct hda_codec *codec, int type)
738 alc_auto_setup_eapd(codec, true);
741 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
744 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
747 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
749 case ALC_INIT_DEFAULT:
750 switch (codec->vendor_id) {
752 snd_hda_codec_write(codec, 0x1a, 0,
753 AC_VERB_SET_COEF_INDEX, 7);
754 tmp = snd_hda_codec_read(codec, 0x1a, 0,
755 AC_VERB_GET_PROC_COEF, 0);
756 snd_hda_codec_write(codec, 0x1a, 0,
757 AC_VERB_SET_COEF_INDEX, 7);
758 snd_hda_codec_write(codec, 0x1a, 0,
759 AC_VERB_SET_PROC_COEF,
768 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
769 alc889_coef_init(codec);
772 alc888_coef_init(codec);
774 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
777 snd_hda_codec_write(codec, 0x20, 0,
778 AC_VERB_SET_COEF_INDEX, 7);
779 tmp = snd_hda_codec_read(codec, 0x20, 0,
780 AC_VERB_GET_PROC_COEF, 0);
781 snd_hda_codec_write(codec, 0x20, 0,
782 AC_VERB_SET_COEF_INDEX, 7);
783 snd_hda_codec_write(codec, 0x20, 0,
784 AC_VERB_SET_PROC_COEF,
794 * Auto-Mute mode mixer enum support
796 static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
797 struct snd_ctl_elem_info *uinfo)
799 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
800 struct alc_spec *spec = codec->spec;
801 static const char * const texts2[] = {
802 "Disabled", "Enabled"
804 static const char * const texts3[] = {
805 "Disabled", "Speaker Only", "Line Out+Speaker"
807 const char * const *texts;
809 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
811 if (spec->automute_speaker_possible && spec->automute_lo_possible) {
812 uinfo->value.enumerated.items = 3;
815 uinfo->value.enumerated.items = 2;
818 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
819 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
820 strcpy(uinfo->value.enumerated.name,
821 texts[uinfo->value.enumerated.item]);
825 static int alc_automute_mode_get(struct snd_kcontrol *kcontrol,
826 struct snd_ctl_elem_value *ucontrol)
828 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
829 struct alc_spec *spec = codec->spec;
830 unsigned int val = 0;
831 if (spec->automute_speaker)
833 if (spec->automute_lo)
836 ucontrol->value.enumerated.item[0] = val;
840 static int alc_automute_mode_put(struct snd_kcontrol *kcontrol,
841 struct snd_ctl_elem_value *ucontrol)
843 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
844 struct alc_spec *spec = codec->spec;
846 switch (ucontrol->value.enumerated.item[0]) {
848 if (!spec->automute_speaker && !spec->automute_lo)
850 spec->automute_speaker = 0;
851 spec->automute_lo = 0;
854 if (spec->automute_speaker_possible) {
855 if (!spec->automute_lo && spec->automute_speaker)
857 spec->automute_speaker = 1;
858 spec->automute_lo = 0;
859 } else if (spec->automute_lo_possible) {
860 if (spec->automute_lo)
862 spec->automute_lo = 1;
867 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
869 if (spec->automute_speaker && spec->automute_lo)
871 spec->automute_speaker = 1;
872 spec->automute_lo = 1;
877 call_update_outputs(codec);
881 static const struct snd_kcontrol_new alc_automute_mode_enum = {
882 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
883 .name = "Auto-Mute Mode",
884 .info = alc_automute_mode_info,
885 .get = alc_automute_mode_get,
886 .put = alc_automute_mode_put,
889 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
891 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
892 return snd_array_new(&spec->kctls);
895 static int alc_add_automute_mode_enum(struct hda_codec *codec)
897 struct alc_spec *spec = codec->spec;
898 struct snd_kcontrol_new *knew;
900 knew = alc_kcontrol_new(spec);
903 *knew = alc_automute_mode_enum;
904 knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
911 * Check the availability of HP/line-out auto-mute;
912 * Set up appropriately if really supported
914 static void alc_init_automute(struct hda_codec *codec)
916 struct alc_spec *spec = codec->spec;
917 struct auto_pin_cfg *cfg = &spec->autocfg;
923 if (cfg->line_out_pins[0])
925 if (cfg->speaker_pins[0])
927 if (present < 2) /* need two different output types */
930 if (!cfg->speaker_pins[0] &&
931 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
932 memcpy(cfg->speaker_pins, cfg->line_out_pins,
933 sizeof(cfg->speaker_pins));
934 cfg->speaker_outs = cfg->line_outs;
937 if (!cfg->hp_pins[0] &&
938 cfg->line_out_type == AUTO_PIN_HP_OUT) {
939 memcpy(cfg->hp_pins, cfg->line_out_pins,
940 sizeof(cfg->hp_pins));
941 cfg->hp_outs = cfg->line_outs;
944 spec->automute_mode = ALC_AUTOMUTE_PIN;
946 for (i = 0; i < cfg->hp_outs; i++) {
947 hda_nid_t nid = cfg->hp_pins[i];
948 if (!is_jack_detectable(codec, nid))
950 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
952 snd_hda_jack_detect_enable(codec, nid, ALC_HP_EVENT);
956 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
957 if (cfg->speaker_outs)
958 for (i = 0; i < cfg->line_outs; i++) {
959 hda_nid_t nid = cfg->line_out_pins[i];
960 if (!is_jack_detectable(codec, nid))
962 snd_printdd("realtek: Enable Line-Out "
963 "auto-muting on NID 0x%x\n", nid);
964 snd_hda_jack_detect_enable(codec, nid,
968 spec->automute_lo_possible = spec->detect_hp;
971 spec->automute_speaker_possible = cfg->speaker_outs &&
972 (spec->detect_hp || spec->detect_lo);
974 spec->automute_lo = spec->automute_lo_possible;
975 spec->automute_speaker = spec->automute_speaker_possible;
977 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
978 /* create a control for automute mode */
979 alc_add_automute_mode_enum(codec);
980 spec->unsol_event = alc_sku_unsol_event;
984 /* return the position of NID in the list, or -1 if not found */
985 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
988 for (i = 0; i < nums; i++)
994 /* check whether dynamic ADC-switching is available */
995 static bool alc_check_dyn_adc_switch(struct hda_codec *codec)
997 struct alc_spec *spec = codec->spec;
998 struct hda_input_mux *imux = &spec->private_imux[0];
1002 if (imux != spec->input_mux) /* no dynamic imux? */
1005 for (n = 0; n < spec->num_adc_nids; n++) {
1006 cap = spec->private_capsrc_nids[n];
1007 for (i = 0; i < imux->num_items; i++) {
1008 pin = spec->imux_pins[i];
1011 if (get_connection_index(codec, cap, pin) < 0)
1014 if (i >= imux->num_items)
1015 return true; /* no ADC-switch is needed */
1018 for (i = 0; i < imux->num_items; i++) {
1019 pin = spec->imux_pins[i];
1020 for (n = 0; n < spec->num_adc_nids; n++) {
1021 cap = spec->private_capsrc_nids[n];
1022 idx = get_connection_index(codec, cap, pin);
1024 imux->items[i].index = idx;
1025 spec->dyn_adc_idx[i] = n;
1031 snd_printdd("realtek: enabling ADC switching\n");
1032 spec->dyn_adc_switch = 1;
1036 /* rebuild imux for matching with the given auto-mic pins (if not yet) */
1037 static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec)
1039 struct alc_spec *spec = codec->spec;
1040 struct hda_input_mux *imux;
1041 static char * const texts[3] = {
1042 "Mic", "Internal Mic", "Dock Mic"
1046 if (!spec->auto_mic)
1048 imux = &spec->private_imux[0];
1049 if (spec->input_mux == imux)
1051 spec->imux_pins[0] = spec->ext_mic_pin;
1052 spec->imux_pins[1] = spec->int_mic_pin;
1053 spec->imux_pins[2] = spec->dock_mic_pin;
1054 for (i = 0; i < 3; i++) {
1055 strcpy(imux->items[i].label, texts[i]);
1056 if (spec->imux_pins[i]) {
1057 hda_nid_t pin = spec->imux_pins[i];
1059 for (c = 0; c < spec->num_adc_nids; c++) {
1060 hda_nid_t cap = get_capsrc(spec, c);
1061 int idx = get_connection_index(codec, cap, pin);
1063 imux->items[i].index = idx;
1067 imux->num_items = i + 1;
1070 spec->num_mux_defs = 1;
1071 spec->input_mux = imux;
1075 /* check whether all auto-mic pins are valid; setup indices if OK */
1076 static bool alc_auto_mic_check_imux(struct hda_codec *codec)
1078 struct alc_spec *spec = codec->spec;
1079 const struct hda_input_mux *imux;
1081 if (!spec->auto_mic)
1083 if (spec->auto_mic_valid_imux)
1084 return true; /* already checked */
1086 /* fill up imux indices */
1087 if (!alc_check_dyn_adc_switch(codec)) {
1092 imux = spec->input_mux;
1093 spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin,
1094 spec->imux_pins, imux->num_items);
1095 spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin,
1096 spec->imux_pins, imux->num_items);
1097 spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin,
1098 spec->imux_pins, imux->num_items);
1099 if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) {
1101 return false; /* no corresponding imux */
1104 snd_hda_jack_detect_enable(codec, spec->ext_mic_pin, ALC_MIC_EVENT);
1105 if (spec->dock_mic_pin)
1106 snd_hda_jack_detect_enable(codec, spec->dock_mic_pin,
1109 spec->auto_mic_valid_imux = 1;
1115 * Check the availability of auto-mic switch;
1116 * Set up if really supported
1118 static void alc_init_auto_mic(struct hda_codec *codec)
1120 struct alc_spec *spec = codec->spec;
1121 struct auto_pin_cfg *cfg = &spec->autocfg;
1122 hda_nid_t fixed, ext, dock;
1125 if (spec->shared_mic_hp)
1126 return; /* no auto-mic for the shared I/O */
1128 spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1;
1130 fixed = ext = dock = 0;
1131 for (i = 0; i < cfg->num_inputs; i++) {
1132 hda_nid_t nid = cfg->inputs[i].pin;
1133 unsigned int defcfg;
1134 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1135 switch (snd_hda_get_input_pin_attr(defcfg)) {
1136 case INPUT_PIN_ATTR_INT:
1138 return; /* already occupied */
1139 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1140 return; /* invalid type */
1143 case INPUT_PIN_ATTR_UNUSED:
1144 return; /* invalid entry */
1145 case INPUT_PIN_ATTR_DOCK:
1147 return; /* already occupied */
1148 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
1149 return; /* invalid type */
1154 return; /* already occupied */
1155 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1156 return; /* invalid type */
1167 if (!is_jack_detectable(codec, ext))
1168 return; /* no unsol support */
1169 if (dock && !is_jack_detectable(codec, dock))
1170 return; /* no unsol support */
1172 /* check imux indices */
1173 spec->ext_mic_pin = ext;
1174 spec->int_mic_pin = fixed;
1175 spec->dock_mic_pin = dock;
1178 if (!alc_auto_mic_check_imux(codec))
1181 snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1183 spec->unsol_event = alc_sku_unsol_event;
1186 /* check the availabilities of auto-mute and auto-mic switches */
1187 static void alc_auto_check_switches(struct hda_codec *codec)
1189 alc_init_automute(codec);
1190 alc_init_auto_mic(codec);
1194 * Realtek SSID verification
1197 /* Could be any non-zero and even value. When used as fixup, tells
1198 * the driver to ignore any present sku defines.
1200 #define ALC_FIXUP_SKU_IGNORE (2)
1202 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1204 unsigned int ass, tmp, i;
1206 struct alc_spec *spec = codec->spec;
1208 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1210 if (spec->cdefine.fixup) {
1211 ass = spec->cdefine.sku_cfg;
1212 if (ass == ALC_FIXUP_SKU_IGNORE)
1217 ass = codec->subsystem_id & 0xffff;
1218 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1222 if (codec->vendor_id == 0x10ec0260)
1224 ass = snd_hda_codec_get_pincfg(codec, nid);
1227 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1228 codec->chip_name, ass);
1234 for (i = 1; i < 16; i++) {
1238 if (((ass >> 16) & 0xf) != tmp)
1241 spec->cdefine.port_connectivity = ass >> 30;
1242 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1243 spec->cdefine.check_sum = (ass >> 16) & 0xf;
1244 spec->cdefine.customization = ass >> 8;
1246 spec->cdefine.sku_cfg = ass;
1247 spec->cdefine.external_amp = (ass & 0x38) >> 3;
1248 spec->cdefine.platform_type = (ass & 0x4) >> 2;
1249 spec->cdefine.swap = (ass & 0x2) >> 1;
1250 spec->cdefine.override = ass & 0x1;
1252 snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1253 nid, spec->cdefine.sku_cfg);
1254 snd_printd("SKU: port_connectivity=0x%x\n",
1255 spec->cdefine.port_connectivity);
1256 snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1257 snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1258 snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1259 snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1260 snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1261 snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1262 snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1267 /* return true if the given NID is found in the list */
1268 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1270 return find_idx_in_nid_list(nid, list, nums) >= 0;
1273 /* check subsystem ID and set up device-specific initialization;
1274 * return 1 if initialized, 0 if invalid SSID
1276 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1277 * 31 ~ 16 : Manufacture ID
1279 * 7 ~ 0 : Assembly ID
1280 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1282 static int alc_subsystem_id(struct hda_codec *codec,
1283 hda_nid_t porta, hda_nid_t porte,
1284 hda_nid_t portd, hda_nid_t porti)
1286 unsigned int ass, tmp, i;
1288 struct alc_spec *spec = codec->spec;
1290 if (spec->cdefine.fixup) {
1291 ass = spec->cdefine.sku_cfg;
1292 if (ass == ALC_FIXUP_SKU_IGNORE)
1297 ass = codec->subsystem_id & 0xffff;
1298 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1301 /* invalid SSID, check the special NID pin defcfg instead */
1303 * 31~30 : port connectivity
1306 * 19~16 : Check sum (15:1)
1311 if (codec->vendor_id == 0x10ec0260)
1313 ass = snd_hda_codec_get_pincfg(codec, nid);
1314 snd_printd("realtek: No valid SSID, "
1315 "checking pincfg 0x%08x for NID 0x%x\n",
1319 if ((ass >> 30) != 1) /* no physical connection */
1324 for (i = 1; i < 16; i++) {
1328 if (((ass >> 16) & 0xf) != tmp)
1331 snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1332 ass & 0xffff, codec->vendor_id);
1336 * 2 : 0 --> Desktop, 1 --> Laptop
1337 * 3~5 : External Amplifier control
1340 tmp = (ass & 0x38) >> 3; /* external Amp control */
1343 spec->init_amp = ALC_INIT_GPIO1;
1346 spec->init_amp = ALC_INIT_GPIO2;
1349 spec->init_amp = ALC_INIT_GPIO3;
1353 spec->init_amp = ALC_INIT_DEFAULT;
1357 /* is laptop or Desktop and enable the function "Mute internal speaker
1358 * when the external headphone out jack is plugged"
1360 if (!(ass & 0x8000))
1363 * 10~8 : Jack location
1364 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1366 * 15 : 1 --> enable the function "Mute internal speaker
1367 * when the external headphone out jack is plugged"
1369 if (!spec->autocfg.hp_pins[0] &&
1370 !(spec->autocfg.line_out_pins[0] &&
1371 spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
1373 tmp = (ass >> 11) & 0x3; /* HP to chassis */
1384 if (found_in_nid_list(nid, spec->autocfg.line_out_pins,
1385 spec->autocfg.line_outs))
1387 spec->autocfg.hp_pins[0] = nid;
1392 /* Check the validity of ALC subsystem-id
1393 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
1394 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
1396 if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {
1397 struct alc_spec *spec = codec->spec;
1398 snd_printd("realtek: "
1399 "Enable default setup for auto mode as fallback\n");
1400 spec->init_amp = ALC_INIT_DEFAULT;
1405 * Fix-up pin default configurations and add default verbs
1413 struct alc_model_fixup {
1424 const struct alc_pincfg *pins;
1425 const struct hda_verb *verbs;
1426 void (*func)(struct hda_codec *codec,
1427 const struct alc_fixup *fix,
1441 ALC_FIXUP_ACT_PRE_PROBE,
1442 ALC_FIXUP_ACT_PROBE,
1446 static void alc_apply_fixup(struct hda_codec *codec, int action)
1448 struct alc_spec *spec = codec->spec;
1449 int id = spec->fixup_id;
1450 #ifdef CONFIG_SND_DEBUG_VERBOSE
1451 const char *modelname = spec->fixup_name;
1455 if (!spec->fixup_list)
1459 const struct alc_fixup *fix = spec->fixup_list + id;
1460 const struct alc_pincfg *cfg;
1462 switch (fix->type) {
1464 if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1466 snd_printdd(KERN_INFO "hda_codec: %s: "
1467 "Apply sku override for %s\n",
1468 codec->chip_name, modelname);
1469 spec->cdefine.sku_cfg = fix->v.sku;
1470 spec->cdefine.fixup = 1;
1472 case ALC_FIXUP_PINS:
1474 if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1476 snd_printdd(KERN_INFO "hda_codec: %s: "
1477 "Apply pincfg for %s\n",
1478 codec->chip_name, modelname);
1479 for (; cfg->nid; cfg++)
1480 snd_hda_codec_set_pincfg(codec, cfg->nid,
1483 case ALC_FIXUP_VERBS:
1484 if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1486 snd_printdd(KERN_INFO "hda_codec: %s: "
1487 "Apply fix-verbs for %s\n",
1488 codec->chip_name, modelname);
1489 add_verb(codec->spec, fix->v.verbs);
1491 case ALC_FIXUP_FUNC:
1494 snd_printdd(KERN_INFO "hda_codec: %s: "
1495 "Apply fix-func for %s\n",
1496 codec->chip_name, modelname);
1497 fix->v.func(codec, fix, action);
1500 snd_printk(KERN_ERR "hda_codec: %s: "
1501 "Invalid fixup type %d\n",
1502 codec->chip_name, fix->type);
1513 static void alc_pick_fixup(struct hda_codec *codec,
1514 const struct alc_model_fixup *models,
1515 const struct snd_pci_quirk *quirk,
1516 const struct alc_fixup *fixlist)
1518 struct alc_spec *spec = codec->spec;
1519 const struct snd_pci_quirk *q;
1521 const char *name = NULL;
1523 if (codec->modelname && models) {
1524 while (models->name) {
1525 if (!strcmp(codec->modelname, models->name)) {
1527 name = models->name;
1534 q = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1537 #ifdef CONFIG_SND_DEBUG_VERBOSE
1543 for (q = quirk; q->subvendor; q++) {
1544 unsigned int vendorid =
1545 q->subdevice | (q->subvendor << 16);
1546 if (vendorid == codec->subsystem_id) {
1548 #ifdef CONFIG_SND_DEBUG_VERBOSE
1556 spec->fixup_id = id;
1558 spec->fixup_list = fixlist;
1559 spec->fixup_name = name;
1564 * COEF access helper functions
1566 static int alc_read_coef_idx(struct hda_codec *codec,
1567 unsigned int coef_idx)
1570 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1572 val = snd_hda_codec_read(codec, 0x20, 0,
1573 AC_VERB_GET_PROC_COEF, 0);
1577 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1578 unsigned int coef_val)
1580 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1582 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1586 /* a special bypass for COEF 0; read the cached value at the second time */
1587 static unsigned int alc_get_coef0(struct hda_codec *codec)
1589 struct alc_spec *spec = codec->spec;
1591 spec->coef0 = alc_read_coef_idx(codec, 0);
1596 * Digital I/O handling
1599 /* set right pin controls for digital I/O */
1600 static void alc_auto_init_digital(struct hda_codec *codec)
1602 struct alc_spec *spec = codec->spec;
1606 for (i = 0; i < spec->autocfg.dig_outs; i++) {
1607 pin = spec->autocfg.dig_out_pins[i];
1610 snd_hda_codec_write(codec, pin, 0,
1611 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
1613 dac = spec->multiout.dig_out_nid;
1615 dac = spec->slave_dig_outs[i - 1];
1616 if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
1618 snd_hda_codec_write(codec, dac, 0,
1619 AC_VERB_SET_AMP_GAIN_MUTE,
1622 pin = spec->autocfg.dig_in_pin;
1624 snd_hda_codec_write(codec, pin, 0,
1625 AC_VERB_SET_PIN_WIDGET_CONTROL,
1629 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1630 static void alc_auto_parse_digital(struct hda_codec *codec)
1632 struct alc_spec *spec = codec->spec;
1636 /* support multiple SPDIFs; the secondary is set up as a slave */
1638 for (i = 0; i < spec->autocfg.dig_outs; i++) {
1640 err = snd_hda_get_connections(codec,
1641 spec->autocfg.dig_out_pins[i],
1642 conn, ARRAY_SIZE(conn));
1645 dig_nid = conn[0]; /* assume the first element is audio-out */
1647 spec->multiout.dig_out_nid = dig_nid;
1648 spec->dig_out_type = spec->autocfg.dig_out_type[0];
1650 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1651 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1653 spec->slave_dig_outs[nums - 1] = dig_nid;
1658 if (spec->autocfg.dig_in_pin) {
1659 dig_nid = codec->start_nid;
1660 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1661 unsigned int wcaps = get_wcaps(codec, dig_nid);
1662 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1664 if (!(wcaps & AC_WCAP_DIGITAL))
1666 if (!(wcaps & AC_WCAP_CONN_LIST))
1668 err = get_connection_index(codec, dig_nid,
1669 spec->autocfg.dig_in_pin);
1671 spec->dig_in_nid = dig_nid;
1679 * capture mixer elements
1681 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1682 struct snd_ctl_elem_info *uinfo)
1684 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1685 struct alc_spec *spec = codec->spec;
1689 mutex_lock(&codec->control_mutex);
1690 if (spec->vol_in_capsrc)
1691 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1693 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1694 kcontrol->private_value = val;
1695 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1696 mutex_unlock(&codec->control_mutex);
1700 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1701 unsigned int size, unsigned int __user *tlv)
1703 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1704 struct alc_spec *spec = codec->spec;
1708 mutex_lock(&codec->control_mutex);
1709 if (spec->vol_in_capsrc)
1710 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1712 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1713 kcontrol->private_value = val;
1714 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1715 mutex_unlock(&codec->control_mutex);
1719 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1720 struct snd_ctl_elem_value *ucontrol);
1722 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1723 struct snd_ctl_elem_value *ucontrol,
1724 getput_call_t func, bool check_adc_switch)
1726 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1727 struct alc_spec *spec = codec->spec;
1730 mutex_lock(&codec->control_mutex);
1731 if (check_adc_switch && spec->dyn_adc_switch) {
1732 for (i = 0; i < spec->num_adc_nids; i++) {
1733 kcontrol->private_value =
1734 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1736 err = func(kcontrol, ucontrol);
1741 i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1742 if (spec->vol_in_capsrc)
1743 kcontrol->private_value =
1744 HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i],
1747 kcontrol->private_value =
1748 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1750 err = func(kcontrol, ucontrol);
1753 mutex_unlock(&codec->control_mutex);
1757 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1758 struct snd_ctl_elem_value *ucontrol)
1760 return alc_cap_getput_caller(kcontrol, ucontrol,
1761 snd_hda_mixer_amp_volume_get, false);
1764 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1765 struct snd_ctl_elem_value *ucontrol)
1767 return alc_cap_getput_caller(kcontrol, ucontrol,
1768 snd_hda_mixer_amp_volume_put, true);
1771 /* capture mixer elements */
1772 #define alc_cap_sw_info snd_ctl_boolean_stereo_info
1774 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1775 struct snd_ctl_elem_value *ucontrol)
1777 return alc_cap_getput_caller(kcontrol, ucontrol,
1778 snd_hda_mixer_amp_switch_get, false);
1781 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1782 struct snd_ctl_elem_value *ucontrol)
1784 return alc_cap_getput_caller(kcontrol, ucontrol,
1785 snd_hda_mixer_amp_switch_put, true);
1788 #define _DEFINE_CAPMIX(num) \
1790 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1791 .name = "Capture Switch", \
1792 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1794 .info = alc_cap_sw_info, \
1795 .get = alc_cap_sw_get, \
1796 .put = alc_cap_sw_put, \
1799 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1800 .name = "Capture Volume", \
1801 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1802 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1803 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1805 .info = alc_cap_vol_info, \
1806 .get = alc_cap_vol_get, \
1807 .put = alc_cap_vol_put, \
1808 .tlv = { .c = alc_cap_vol_tlv }, \
1811 #define _DEFINE_CAPSRC(num) \
1813 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1814 /* .name = "Capture Source", */ \
1815 .name = "Input Source", \
1817 .info = alc_mux_enum_info, \
1818 .get = alc_mux_enum_get, \
1819 .put = alc_mux_enum_put, \
1822 #define DEFINE_CAPMIX(num) \
1823 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1824 _DEFINE_CAPMIX(num), \
1825 _DEFINE_CAPSRC(num), \
1829 #define DEFINE_CAPMIX_NOSRC(num) \
1830 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1831 _DEFINE_CAPMIX(num), \
1835 /* up to three ADCs */
1839 DEFINE_CAPMIX_NOSRC(1);
1840 DEFINE_CAPMIX_NOSRC(2);
1841 DEFINE_CAPMIX_NOSRC(3);
1844 * virtual master controls
1848 * slave controls for virtual master
1850 static const char * const alc_slave_vols[] = {
1851 "Front Playback Volume",
1852 "Surround Playback Volume",
1853 "Center Playback Volume",
1854 "LFE Playback Volume",
1855 "Side Playback Volume",
1856 "Headphone Playback Volume",
1857 "Speaker Playback Volume",
1858 "Mono Playback Volume",
1859 "Line Out Playback Volume",
1860 "CLFE Playback Volume",
1861 "Bass Speaker Playback Volume",
1862 "PCM Playback Volume",
1866 static const char * const alc_slave_sws[] = {
1867 "Front Playback Switch",
1868 "Surround Playback Switch",
1869 "Center Playback Switch",
1870 "LFE Playback Switch",
1871 "Side Playback Switch",
1872 "Headphone Playback Switch",
1873 "Speaker Playback Switch",
1874 "Mono Playback Switch",
1875 "IEC958 Playback Switch",
1876 "Line Out Playback Switch",
1877 "CLFE Playback Switch",
1878 "Bass Speaker Playback Switch",
1879 "PCM Playback Switch",
1884 * build control elements
1887 #define NID_MAPPING (-1)
1889 #define SUBDEV_SPEAKER_ (0 << 6)
1890 #define SUBDEV_HP_ (1 << 6)
1891 #define SUBDEV_LINE_ (2 << 6)
1892 #define SUBDEV_SPEAKER(x) (SUBDEV_SPEAKER_ | ((x) & 0x3f))
1893 #define SUBDEV_HP(x) (SUBDEV_HP_ | ((x) & 0x3f))
1894 #define SUBDEV_LINE(x) (SUBDEV_LINE_ | ((x) & 0x3f))
1896 static void alc_free_kctls(struct hda_codec *codec);
1898 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1899 /* additional beep mixers; the actual parameters are overwritten at build */
1900 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1901 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1902 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1907 static int __alc_build_controls(struct hda_codec *codec)
1909 struct alc_spec *spec = codec->spec;
1910 struct snd_kcontrol *kctl = NULL;
1911 const struct snd_kcontrol_new *knew;
1916 for (i = 0; i < spec->num_mixers; i++) {
1917 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1921 if (spec->cap_mixer) {
1922 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
1926 if (spec->multiout.dig_out_nid) {
1927 err = snd_hda_create_spdif_out_ctls(codec,
1928 spec->multiout.dig_out_nid,
1929 spec->multiout.dig_out_nid);
1932 if (!spec->no_analog) {
1933 err = snd_hda_create_spdif_share_sw(codec,
1937 spec->multiout.share_spdif = 1;
1940 if (spec->dig_in_nid) {
1941 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1946 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1947 /* create beep controls if needed */
1948 if (spec->beep_amp) {
1949 const struct snd_kcontrol_new *knew;
1950 for (knew = alc_beep_mixer; knew->name; knew++) {
1951 struct snd_kcontrol *kctl;
1952 kctl = snd_ctl_new1(knew, codec);
1955 kctl->private_value = spec->beep_amp;
1956 err = snd_hda_ctl_add(codec, 0, kctl);
1963 /* if we have no master control, let's create it */
1964 if (!spec->no_analog &&
1965 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1966 unsigned int vmaster_tlv[4];
1967 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1968 HDA_OUTPUT, vmaster_tlv);
1969 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1970 vmaster_tlv, alc_slave_vols);
1974 if (!spec->no_analog &&
1975 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1976 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1977 NULL, alc_slave_sws);
1982 /* assign Capture Source enums to NID */
1983 if (spec->capsrc_nids || spec->adc_nids) {
1984 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
1986 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1987 for (i = 0; kctl && i < kctl->count; i++) {
1988 err = snd_hda_add_nid(codec, kctl, i,
1989 get_capsrc(spec, i));
1994 if (spec->cap_mixer && spec->adc_nids) {
1995 const char *kname = kctl ? kctl->id.name : NULL;
1996 for (knew = spec->cap_mixer; knew->name; knew++) {
1997 if (kname && strcmp(knew->name, kname) == 0)
1999 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2000 for (i = 0; kctl && i < kctl->count; i++) {
2001 err = snd_hda_add_nid(codec, kctl, i,
2009 /* other nid->control mapping */
2010 for (i = 0; i < spec->num_mixers; i++) {
2011 for (knew = spec->mixers[i]; knew->name; knew++) {
2012 if (knew->iface != NID_MAPPING)
2014 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2017 u = knew->subdevice;
2018 for (j = 0; j < 4; j++, u >>= 8) {
2023 case SUBDEV_SPEAKER_:
2024 nid = spec->autocfg.speaker_pins[nid];
2027 nid = spec->autocfg.line_out_pins[nid];
2030 nid = spec->autocfg.hp_pins[nid];
2035 err = snd_hda_add_nid(codec, kctl, 0, nid);
2039 u = knew->private_value;
2040 for (j = 0; j < 4; j++, u >>= 8) {
2044 err = snd_hda_add_nid(codec, kctl, 0, nid);
2051 alc_free_kctls(codec); /* no longer needed */
2056 static int alc_build_controls(struct hda_codec *codec)
2058 struct alc_spec *spec = codec->spec;
2059 int err = __alc_build_controls(codec);
2062 return snd_hda_jack_add_kctls(codec, &spec->autocfg);
2070 static void alc_init_special_input_src(struct hda_codec *codec);
2072 static int alc_init(struct hda_codec *codec)
2074 struct alc_spec *spec = codec->spec;
2078 alc_auto_init_amp(codec, spec->init_amp);
2080 for (i = 0; i < spec->num_init_verbs; i++)
2081 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2082 alc_init_special_input_src(codec);
2084 if (spec->init_hook)
2085 spec->init_hook(codec);
2087 alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
2089 snd_hda_jack_report_sync(codec);
2091 hda_call_check_power_status(codec, 0x01);
2095 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2097 struct alc_spec *spec = codec->spec;
2099 if (spec->unsol_event)
2100 spec->unsol_event(codec, res);
2103 #ifdef CONFIG_SND_HDA_POWER_SAVE
2104 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2106 struct alc_spec *spec = codec->spec;
2107 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2112 * Analog playback callbacks
2114 static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo,
2115 struct hda_codec *codec,
2116 struct snd_pcm_substream *substream)
2118 struct alc_spec *spec = codec->spec;
2119 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2123 static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2124 struct hda_codec *codec,
2125 unsigned int stream_tag,
2126 unsigned int format,
2127 struct snd_pcm_substream *substream)
2129 struct alc_spec *spec = codec->spec;
2130 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2131 stream_tag, format, substream);
2134 static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2135 struct hda_codec *codec,
2136 struct snd_pcm_substream *substream)
2138 struct alc_spec *spec = codec->spec;
2139 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2145 static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2146 struct hda_codec *codec,
2147 struct snd_pcm_substream *substream)
2149 struct alc_spec *spec = codec->spec;
2150 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2153 static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2154 struct hda_codec *codec,
2155 unsigned int stream_tag,
2156 unsigned int format,
2157 struct snd_pcm_substream *substream)
2159 struct alc_spec *spec = codec->spec;
2160 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2161 stream_tag, format, substream);
2164 static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2165 struct hda_codec *codec,
2166 struct snd_pcm_substream *substream)
2168 struct alc_spec *spec = codec->spec;
2169 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2172 static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2173 struct hda_codec *codec,
2174 struct snd_pcm_substream *substream)
2176 struct alc_spec *spec = codec->spec;
2177 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2183 static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2184 struct hda_codec *codec,
2185 unsigned int stream_tag,
2186 unsigned int format,
2187 struct snd_pcm_substream *substream)
2189 struct alc_spec *spec = codec->spec;
2191 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2192 stream_tag, 0, format);
2196 static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2197 struct hda_codec *codec,
2198 struct snd_pcm_substream *substream)
2200 struct alc_spec *spec = codec->spec;
2202 snd_hda_codec_cleanup_stream(codec,
2203 spec->adc_nids[substream->number + 1]);
2207 /* analog capture with dynamic dual-adc changes */
2208 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2209 struct hda_codec *codec,
2210 unsigned int stream_tag,
2211 unsigned int format,
2212 struct snd_pcm_substream *substream)
2214 struct alc_spec *spec = codec->spec;
2215 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
2216 spec->cur_adc_stream_tag = stream_tag;
2217 spec->cur_adc_format = format;
2218 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
2222 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2223 struct hda_codec *codec,
2224 struct snd_pcm_substream *substream)
2226 struct alc_spec *spec = codec->spec;
2227 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
2232 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
2236 .nid = 0, /* fill later */
2238 .prepare = dyn_adc_capture_pcm_prepare,
2239 .cleanup = dyn_adc_capture_pcm_cleanup
2245 static const struct hda_pcm_stream alc_pcm_analog_playback = {
2249 /* NID is set in alc_build_pcms */
2251 .open = alc_playback_pcm_open,
2252 .prepare = alc_playback_pcm_prepare,
2253 .cleanup = alc_playback_pcm_cleanup
2257 static const struct hda_pcm_stream alc_pcm_analog_capture = {
2261 /* NID is set in alc_build_pcms */
2264 static const struct hda_pcm_stream alc_pcm_analog_alt_playback = {
2268 /* NID is set in alc_build_pcms */
2271 static const struct hda_pcm_stream alc_pcm_analog_alt_capture = {
2272 .substreams = 2, /* can be overridden */
2275 /* NID is set in alc_build_pcms */
2277 .prepare = alc_alt_capture_pcm_prepare,
2278 .cleanup = alc_alt_capture_pcm_cleanup
2282 static const struct hda_pcm_stream alc_pcm_digital_playback = {
2286 /* NID is set in alc_build_pcms */
2288 .open = alc_dig_playback_pcm_open,
2289 .close = alc_dig_playback_pcm_close,
2290 .prepare = alc_dig_playback_pcm_prepare,
2291 .cleanup = alc_dig_playback_pcm_cleanup
2295 static const struct hda_pcm_stream alc_pcm_digital_capture = {
2299 /* NID is set in alc_build_pcms */
2302 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2303 static const struct hda_pcm_stream alc_pcm_null_stream = {
2309 static int alc_build_pcms(struct hda_codec *codec)
2311 struct alc_spec *spec = codec->spec;
2312 struct hda_pcm *info = spec->pcm_rec;
2313 const struct hda_pcm_stream *p;
2314 bool have_multi_adcs;
2317 codec->num_pcms = 1;
2318 codec->pcm_info = info;
2320 if (spec->no_analog)
2323 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
2324 "%s Analog", codec->chip_name);
2325 info->name = spec->stream_name_analog;
2327 if (spec->multiout.num_dacs > 0) {
2328 p = spec->stream_analog_playback;
2330 p = &alc_pcm_analog_playback;
2331 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2332 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2334 if (spec->adc_nids) {
2335 p = spec->stream_analog_capture;
2337 if (spec->dyn_adc_switch)
2338 p = &dyn_adc_pcm_analog_capture;
2340 p = &alc_pcm_analog_capture;
2342 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2343 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2346 if (spec->channel_mode) {
2347 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2348 for (i = 0; i < spec->num_channel_mode; i++) {
2349 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2350 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2356 /* SPDIF for stream index #1 */
2357 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2358 snprintf(spec->stream_name_digital,
2359 sizeof(spec->stream_name_digital),
2360 "%s Digital", codec->chip_name);
2361 codec->num_pcms = 2;
2362 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
2363 info = spec->pcm_rec + 1;
2364 info->name = spec->stream_name_digital;
2365 if (spec->dig_out_type)
2366 info->pcm_type = spec->dig_out_type;
2368 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2369 if (spec->multiout.dig_out_nid) {
2370 p = spec->stream_digital_playback;
2372 p = &alc_pcm_digital_playback;
2373 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2374 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2376 if (spec->dig_in_nid) {
2377 p = spec->stream_digital_capture;
2379 p = &alc_pcm_digital_capture;
2380 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2381 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2383 /* FIXME: do we need this for all Realtek codec models? */
2384 codec->spdif_status_reset = 1;
2387 if (spec->no_analog)
2390 /* If the use of more than one ADC is requested for the current
2391 * model, configure a second analog capture-only PCM.
2393 have_multi_adcs = (spec->num_adc_nids > 1) &&
2394 !spec->dyn_adc_switch && !spec->auto_mic &&
2395 (!spec->input_mux || spec->input_mux->num_items > 1);
2396 /* Additional Analaog capture for index #2 */
2397 if (spec->alt_dac_nid || have_multi_adcs) {
2398 codec->num_pcms = 3;
2399 info = spec->pcm_rec + 2;
2400 info->name = spec->stream_name_analog;
2401 if (spec->alt_dac_nid) {
2402 p = spec->stream_analog_alt_playback;
2404 p = &alc_pcm_analog_alt_playback;
2405 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2406 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2409 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2410 alc_pcm_null_stream;
2411 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2413 if (have_multi_adcs) {
2414 p = spec->stream_analog_alt_capture;
2416 p = &alc_pcm_analog_alt_capture;
2417 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2418 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2420 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2421 spec->num_adc_nids - 1;
2423 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2424 alc_pcm_null_stream;
2425 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2432 static inline void alc_shutup(struct hda_codec *codec)
2434 struct alc_spec *spec = codec->spec;
2436 if (spec && spec->shutup)
2437 spec->shutup(codec);
2438 snd_hda_shutup_pins(codec);
2441 static void alc_free_kctls(struct hda_codec *codec)
2443 struct alc_spec *spec = codec->spec;
2445 if (spec->kctls.list) {
2446 struct snd_kcontrol_new *kctl = spec->kctls.list;
2448 for (i = 0; i < spec->kctls.used; i++)
2449 kfree(kctl[i].name);
2451 snd_array_free(&spec->kctls);
2454 static void alc_free_bind_ctls(struct hda_codec *codec)
2456 struct alc_spec *spec = codec->spec;
2457 if (spec->bind_ctls.list) {
2458 struct hda_bind_ctls **ctl = spec->bind_ctls.list;
2460 for (i = 0; i < spec->bind_ctls.used; i++)
2463 snd_array_free(&spec->bind_ctls);
2466 static void alc_free(struct hda_codec *codec)
2468 struct alc_spec *spec = codec->spec;
2474 alc_free_kctls(codec);
2475 alc_free_bind_ctls(codec);
2477 snd_hda_detach_beep_device(codec);
2480 #ifdef CONFIG_SND_HDA_POWER_SAVE
2481 static void alc_power_eapd(struct hda_codec *codec)
2483 alc_auto_setup_eapd(codec, false);
2486 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
2488 struct alc_spec *spec = codec->spec;
2490 if (spec && spec->power_hook)
2491 spec->power_hook(codec);
2497 static int alc_resume(struct hda_codec *codec)
2499 msleep(150); /* to avoid pop noise */
2500 codec->patch_ops.init(codec);
2501 snd_hda_codec_resume_amp(codec);
2502 snd_hda_codec_resume_cache(codec);
2503 hda_call_check_power_status(codec, 0x01);
2510 static const struct hda_codec_ops alc_patch_ops = {
2511 .build_controls = alc_build_controls,
2512 .build_pcms = alc_build_pcms,
2515 .unsol_event = alc_unsol_event,
2517 .resume = alc_resume,
2519 #ifdef CONFIG_SND_HDA_POWER_SAVE
2520 .suspend = alc_suspend,
2521 .check_power_status = alc_check_power_status,
2523 .reboot_notify = alc_shutup,
2526 /* replace the codec chip_name with the given string */
2527 static int alc_codec_rename(struct hda_codec *codec, const char *name)
2529 kfree(codec->chip_name);
2530 codec->chip_name = kstrdup(name, GFP_KERNEL);
2531 if (!codec->chip_name) {
2539 * Rename codecs appropriately from COEF value
2541 struct alc_codec_rename_table {
2542 unsigned int vendor_id;
2543 unsigned short coef_mask;
2544 unsigned short coef_bits;
2548 static struct alc_codec_rename_table rename_tbl[] = {
2549 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
2550 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
2551 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
2552 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
2553 { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
2554 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
2555 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
2556 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
2557 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
2558 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
2559 { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
2560 { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
2561 { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
2562 { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
2563 { } /* terminator */
2566 static int alc_codec_rename_from_preset(struct hda_codec *codec)
2568 const struct alc_codec_rename_table *p;
2570 for (p = rename_tbl; p->vendor_id; p++) {
2571 if (p->vendor_id != codec->vendor_id)
2573 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
2574 return alc_codec_rename(codec, p->name);
2580 * Automatic parse of I/O pins from the BIOS configuration
2585 ALC_CTL_WIDGET_MUTE,
2590 static const struct snd_kcontrol_new alc_control_templates[] = {
2591 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2592 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2593 HDA_BIND_MUTE(NULL, 0, 0, 0),
2594 HDA_BIND_VOL(NULL, 0),
2595 HDA_BIND_SW(NULL, 0),
2598 /* add dynamic controls */
2599 static int add_control(struct alc_spec *spec, int type, const char *name,
2600 int cidx, unsigned long val)
2602 struct snd_kcontrol_new *knew;
2604 knew = alc_kcontrol_new(spec);
2607 *knew = alc_control_templates[type];
2608 knew->name = kstrdup(name, GFP_KERNEL);
2612 if (get_amp_nid_(val))
2613 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2614 knew->private_value = val;
2618 static int add_control_with_pfx(struct alc_spec *spec, int type,
2619 const char *pfx, const char *dir,
2620 const char *sfx, int cidx, unsigned long val)
2623 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
2624 return add_control(spec, type, name, cidx, val);
2627 #define add_pb_vol_ctrl(spec, type, pfx, val) \
2628 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
2629 #define add_pb_sw_ctrl(spec, type, pfx, val) \
2630 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
2631 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
2632 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
2633 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
2634 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
2636 static const char * const channel_name[4] = {
2637 "Front", "Surround", "CLFE", "Side"
2640 static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch,
2641 bool can_be_master, int *index)
2643 struct auto_pin_cfg *cfg = &spec->autocfg;
2646 if (cfg->line_outs == 1 && !spec->multi_ios &&
2647 !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
2650 switch (cfg->line_out_type) {
2651 case AUTO_PIN_SPEAKER_OUT:
2652 if (cfg->line_outs == 1)
2654 if (cfg->line_outs == 2)
2655 return ch ? "Bass Speaker" : "Speaker";
2657 case AUTO_PIN_HP_OUT:
2658 /* for multi-io case, only the primary out */
2659 if (ch && spec->multi_ios)
2664 if (cfg->line_outs == 1 && !spec->multi_ios)
2668 if (snd_BUG_ON(ch >= ARRAY_SIZE(channel_name)))
2671 return channel_name[ch];
2674 /* create input playback/capture controls for the given pin */
2675 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
2676 const char *ctlname, int ctlidx,
2677 int idx, hda_nid_t mix_nid)
2681 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
2682 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2685 err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
2686 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2692 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2694 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2695 return (pincap & AC_PINCAP_IN) != 0;
2698 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
2699 static int alc_auto_fill_adc_caps(struct hda_codec *codec)
2701 struct alc_spec *spec = codec->spec;
2703 hda_nid_t *adc_nids = spec->private_adc_nids;
2704 hda_nid_t *cap_nids = spec->private_capsrc_nids;
2705 int max_nums = ARRAY_SIZE(spec->private_adc_nids);
2708 if (spec->shared_mic_hp)
2709 max_nums = 1; /* no multi streams with the shared HP/mic */
2711 nid = codec->start_nid;
2712 for (i = 0; i < codec->num_nodes; i++, nid++) {
2714 const hda_nid_t *list;
2715 unsigned int caps = get_wcaps(codec, nid);
2716 int type = get_wcaps_type(caps);
2718 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2720 adc_nids[nums] = nid;
2721 cap_nids[nums] = nid;
2725 type = get_wcaps_type(get_wcaps(codec, src));
2726 if (type == AC_WID_PIN)
2728 if (type == AC_WID_AUD_SEL) {
2729 cap_nids[nums] = src;
2732 n = snd_hda_get_conn_list(codec, src, &list);
2734 cap_nids[nums] = src;
2740 if (++nums >= max_nums)
2743 spec->adc_nids = spec->private_adc_nids;
2744 spec->capsrc_nids = spec->private_capsrc_nids;
2745 spec->num_adc_nids = nums;
2749 /* create playback/capture controls for input pins */
2750 static int alc_auto_create_input_ctls(struct hda_codec *codec)
2752 struct alc_spec *spec = codec->spec;
2753 const struct auto_pin_cfg *cfg = &spec->autocfg;
2754 hda_nid_t mixer = spec->mixer_nid;
2755 struct hda_input_mux *imux = &spec->private_imux[0];
2757 int i, c, err, idx, type_idx = 0;
2758 const char *prev_label = NULL;
2760 num_adcs = alc_auto_fill_adc_caps(codec);
2764 for (i = 0; i < cfg->num_inputs; i++) {
2768 pin = cfg->inputs[i].pin;
2769 if (!alc_is_input_pin(codec, pin))
2772 label = hda_get_autocfg_input_label(codec, cfg, i);
2773 if (spec->shared_mic_hp && !strcmp(label, "Misc"))
2774 label = "Headphone Mic";
2775 if (prev_label && !strcmp(label, prev_label))
2782 idx = get_connection_index(codec, mixer, pin);
2784 err = new_analog_input(spec, pin,
2792 for (c = 0; c < num_adcs; c++) {
2793 hda_nid_t cap = get_capsrc(spec, c);
2794 idx = get_connection_index(codec, cap, pin);
2796 spec->imux_pins[imux->num_items] = pin;
2797 snd_hda_add_imux_item(imux, label, idx, NULL);
2803 spec->num_mux_defs = 1;
2804 spec->input_mux = imux;
2809 /* create a shared input with the headphone out */
2810 static int alc_auto_create_shared_input(struct hda_codec *codec)
2812 struct alc_spec *spec = codec->spec;
2813 struct auto_pin_cfg *cfg = &spec->autocfg;
2814 unsigned int defcfg;
2817 /* only one internal input pin? */
2818 if (cfg->num_inputs != 1)
2820 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2821 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2824 if (cfg->hp_outs == 1 && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
2825 nid = cfg->hp_pins[0]; /* OK, we have a single HP-out */
2826 else if (cfg->line_outs == 1 && cfg->line_out_type == AUTO_PIN_HP_OUT)
2827 nid = cfg->line_out_pins[0]; /* OK, we have a single line-out */
2829 return 0; /* both not available */
2831 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2832 return 0; /* no input */
2834 cfg->inputs[1].pin = nid;
2835 cfg->inputs[1].type = AUTO_PIN_MIC;
2836 cfg->num_inputs = 2;
2837 spec->shared_mic_hp = 1;
2838 snd_printdd("realtek: Enable shared I/O jack on NID 0x%x\n", nid);
2842 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
2843 unsigned int pin_type)
2845 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2848 if (nid_has_mute(codec, nid, HDA_OUTPUT))
2849 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2853 static int get_pin_type(int line_out_type)
2855 if (line_out_type == AUTO_PIN_HP_OUT)
2861 static void alc_auto_init_analog_input(struct hda_codec *codec)
2863 struct alc_spec *spec = codec->spec;
2864 struct auto_pin_cfg *cfg = &spec->autocfg;
2867 for (i = 0; i < cfg->num_inputs; i++) {
2868 hda_nid_t nid = cfg->inputs[i].pin;
2869 if (alc_is_input_pin(codec, nid)) {
2870 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
2871 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
2872 snd_hda_codec_write(codec, nid, 0,
2873 AC_VERB_SET_AMP_GAIN_MUTE,
2878 /* mute all loopback inputs */
2879 if (spec->mixer_nid) {
2880 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL);
2881 for (i = 0; i < nums; i++)
2882 snd_hda_codec_write(codec, spec->mixer_nid, 0,
2883 AC_VERB_SET_AMP_GAIN_MUTE,
2888 /* convert from MIX nid to DAC */
2889 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
2894 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT)
2896 num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
2897 for (i = 0; i < num; i++) {
2898 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
2904 /* go down to the selector widget before the mixer */
2905 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
2908 int num = snd_hda_get_connections(codec, pin, srcs,
2911 get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
2916 /* get MIX nid connected to the given pin targeted to DAC */
2917 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
2923 pin = alc_go_down_to_selector(codec, pin);
2924 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2925 for (i = 0; i < num; i++) {
2926 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
2932 /* select the connection from pin to DAC if needed */
2933 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
2939 pin = alc_go_down_to_selector(codec, pin);
2940 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2943 for (i = 0; i < num; i++) {
2944 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
2945 snd_hda_codec_update_cache(codec, pin, 0,
2946 AC_VERB_SET_CONNECT_SEL, i);
2953 /* look for an empty DAC slot */
2954 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
2956 struct alc_spec *spec = codec->spec;
2960 pin = alc_go_down_to_selector(codec, pin);
2961 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2962 for (i = 0; i < num; i++) {
2963 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2966 if (found_in_nid_list(nid, spec->multiout.dac_nids,
2967 ARRAY_SIZE(spec->private_dac_nids)))
2969 if (found_in_nid_list(nid, spec->multiout.hp_out_nid,
2970 ARRAY_SIZE(spec->multiout.hp_out_nid)))
2972 if (found_in_nid_list(nid, spec->multiout.extra_out_nid,
2973 ARRAY_SIZE(spec->multiout.extra_out_nid)))
2980 /* check whether the DAC is reachable from the pin */
2981 static bool alc_auto_is_dac_reachable(struct hda_codec *codec,
2982 hda_nid_t pin, hda_nid_t dac)
2987 pin = alc_go_down_to_selector(codec, pin);
2988 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2989 for (i = 0; i < num; i++) {
2990 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2997 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
2999 hda_nid_t sel = alc_go_down_to_selector(codec, pin);
3000 if (snd_hda_get_conn_list(codec, sel, NULL) == 1)
3001 return alc_auto_look_for_dac(codec, pin);
3005 /* return 0 if no possible DAC is found, 1 if one or more found */
3006 static int alc_auto_fill_extra_dacs(struct hda_codec *codec, int num_outs,
3007 const hda_nid_t *pins, hda_nid_t *dacs)
3011 if (num_outs && !dacs[0]) {
3012 dacs[0] = alc_auto_look_for_dac(codec, pins[0]);
3017 for (i = 1; i < num_outs; i++)
3018 dacs[i] = get_dac_if_single(codec, pins[i]);
3019 for (i = 1; i < num_outs; i++) {
3021 dacs[i] = alc_auto_look_for_dac(codec, pins[i]);
3026 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
3027 unsigned int location, int offset);
3028 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
3029 hda_nid_t pin, hda_nid_t dac);
3031 /* fill in the dac_nids table from the parsed pin configuration */
3032 static int alc_auto_fill_dac_nids(struct hda_codec *codec)
3034 struct alc_spec *spec = codec->spec;
3035 struct auto_pin_cfg *cfg = &spec->autocfg;
3036 unsigned int location, defcfg;
3038 bool redone = false;
3042 /* set num_dacs once to full for alc_auto_look_for_dac() */
3043 spec->multiout.num_dacs = cfg->line_outs;
3044 spec->multiout.hp_out_nid[0] = 0;
3045 spec->multiout.extra_out_nid[0] = 0;
3046 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
3047 spec->multiout.dac_nids = spec->private_dac_nids;
3048 spec->multi_ios = 0;
3050 /* fill hard-wired DACs first */
3052 for (i = 0; i < cfg->line_outs; i++)
3053 spec->private_dac_nids[i] =
3054 get_dac_if_single(codec, cfg->line_out_pins[i]);
3056 spec->multiout.hp_out_nid[0] =
3057 get_dac_if_single(codec, cfg->hp_pins[0]);
3058 if (cfg->speaker_outs)
3059 spec->multiout.extra_out_nid[0] =
3060 get_dac_if_single(codec, cfg->speaker_pins[0]);
3063 for (i = 0; i < cfg->line_outs; i++) {
3064 hda_nid_t pin = cfg->line_out_pins[i];
3065 if (spec->private_dac_nids[i])
3067 spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin);
3068 if (!spec->private_dac_nids[i] && !redone) {
3069 /* if we can't find primary DACs, re-probe without
3070 * checking the hard-wired DACs
3077 /* re-count num_dacs and squash invalid entries */
3078 spec->multiout.num_dacs = 0;
3079 for (i = 0; i < cfg->line_outs; i++) {
3080 if (spec->private_dac_nids[i])
3081 spec->multiout.num_dacs++;
3083 memmove(spec->private_dac_nids + i,
3084 spec->private_dac_nids + i + 1,
3085 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
3086 spec->private_dac_nids[cfg->line_outs - 1] = 0;
3090 if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3091 /* try to fill multi-io first */
3092 defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
3093 location = get_defcfg_location(defcfg);
3095 num_pins = alc_auto_fill_multi_ios(codec, location, 0);
3097 spec->multi_ios = num_pins;
3098 spec->ext_channel_count = 2;
3099 spec->multiout.num_dacs = num_pins + 1;
3103 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
3104 alc_auto_fill_extra_dacs(codec, cfg->hp_outs, cfg->hp_pins,
3105 spec->multiout.hp_out_nid);
3106 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3107 int err = alc_auto_fill_extra_dacs(codec, cfg->speaker_outs,
3109 spec->multiout.extra_out_nid);
3110 /* if no speaker volume is assigned, try again as the primary
3113 if (!err && cfg->speaker_outs > 0 &&
3114 cfg->line_out_type == AUTO_PIN_HP_OUT) {
3115 cfg->hp_outs = cfg->line_outs;
3116 memcpy(cfg->hp_pins, cfg->line_out_pins,
3117 sizeof(cfg->hp_pins));
3118 cfg->line_outs = cfg->speaker_outs;
3119 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3120 sizeof(cfg->speaker_pins));
3121 cfg->speaker_outs = 0;
3122 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3123 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3129 if (!spec->multi_ios &&
3130 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3132 /* try multi-ios with HP + inputs */
3133 defcfg = snd_hda_codec_get_pincfg(codec, cfg->hp_pins[0]);
3134 location = get_defcfg_location(defcfg);
3136 num_pins = alc_auto_fill_multi_ios(codec, location, 1);
3138 spec->multi_ios = num_pins;
3139 spec->ext_channel_count = 2;
3140 spec->multiout.num_dacs = num_pins + 1;
3144 if (cfg->line_out_pins[0])
3146 alc_look_for_out_vol_nid(codec, cfg->line_out_pins[0],
3147 spec->multiout.dac_nids[0]);
3151 static inline unsigned int get_ctl_pos(unsigned int data)
3153 hda_nid_t nid = get_amp_nid_(data);
3155 if (snd_BUG_ON(nid >= MAX_VOL_NIDS))
3157 dir = get_amp_direction_(data);
3158 return (nid << 1) | dir;
3161 #define is_ctl_used(bits, data) \
3162 test_bit(get_ctl_pos(data), bits)
3163 #define mark_ctl_usage(bits, data) \
3164 set_bit(get_ctl_pos(data), bits)
3166 static int alc_auto_add_vol_ctl(struct hda_codec *codec,
3167 const char *pfx, int cidx,
3168 hda_nid_t nid, unsigned int chs)
3170 struct alc_spec *spec = codec->spec;
3174 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3175 if (is_ctl_used(spec->vol_ctls, val) && chs != 2) /* exclude LFE */
3177 mark_ctl_usage(spec->vol_ctls, val);
3178 return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx,
3182 static int alc_auto_add_stereo_vol(struct hda_codec *codec,
3183 const char *pfx, int cidx,
3187 if (get_wcaps(codec, nid) & AC_WCAP_STEREO)
3189 return alc_auto_add_vol_ctl(codec, pfx, cidx, nid, chs);
3192 /* create a mute-switch for the given mixer widget;
3193 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
3195 static int alc_auto_add_sw_ctl(struct hda_codec *codec,
3196 const char *pfx, int cidx,
3197 hda_nid_t nid, unsigned int chs)
3199 struct alc_spec *spec = codec->spec;
3205 wid_type = get_wcaps_type(get_wcaps(codec, nid));
3206 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) {
3207 type = ALC_CTL_WIDGET_MUTE;
3208 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3209 } else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) {
3210 type = ALC_CTL_WIDGET_MUTE;
3211 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT);
3213 type = ALC_CTL_BIND_MUTE;
3214 val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT);
3216 if (is_ctl_used(spec->sw_ctls, val) && chs != 2) /* exclude LFE */
3218 mark_ctl_usage(spec->sw_ctls, val);
3219 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
3222 static int alc_auto_add_stereo_sw(struct hda_codec *codec, const char *pfx,
3223 int cidx, hda_nid_t nid)
3226 if (get_wcaps(codec, nid) & AC_WCAP_STEREO)
3228 return alc_auto_add_sw_ctl(codec, pfx, cidx, nid, chs);
3231 static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec,
3232 hda_nid_t pin, hda_nid_t dac)
3234 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3235 if (nid_has_mute(codec, pin, HDA_OUTPUT))
3237 else if (mix && nid_has_mute(codec, mix, HDA_INPUT))
3239 else if (nid_has_mute(codec, dac, HDA_OUTPUT))
3244 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
3245 hda_nid_t pin, hda_nid_t dac)
3247 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3248 if (nid_has_volume(codec, dac, HDA_OUTPUT))
3250 else if (nid_has_volume(codec, mix, HDA_OUTPUT))
3252 else if (nid_has_volume(codec, pin, HDA_OUTPUT))
3257 /* add playback controls from the parsed DAC table */
3258 static int alc_auto_create_multi_out_ctls(struct hda_codec *codec,
3259 const struct auto_pin_cfg *cfg)
3261 struct alc_spec *spec = codec->spec;
3262 int i, err, noutputs;
3264 noutputs = cfg->line_outs;
3265 if (spec->multi_ios > 0 && cfg->line_outs < 3)
3266 noutputs += spec->multi_ios;
3268 for (i = 0; i < noutputs; i++) {
3274 dac = spec->multiout.dac_nids[i];
3277 if (i >= cfg->line_outs)
3278 pin = spec->multi_io[i - 1].pin;
3280 pin = cfg->line_out_pins[i];
3282 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3283 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3284 name = alc_get_line_out_pfx(spec, i, true, &index);
3285 if (!name || !strcmp(name, "CLFE")) {
3287 err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1);
3290 err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2);
3293 err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1);
3296 err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2);
3300 err = alc_auto_add_stereo_vol(codec, name, index, vol);
3303 err = alc_auto_add_stereo_sw(codec, name, index, sw);
3311 static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
3312 hda_nid_t dac, const char *pfx,
3315 struct alc_spec *spec = codec->spec;
3321 /* the corresponding DAC is already occupied */
3322 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
3323 return 0; /* no way */
3324 /* create a switch only */
3325 val = HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT);
3326 if (is_ctl_used(spec->sw_ctls, val))
3327 return 0; /* already created */
3328 mark_ctl_usage(spec->sw_ctls, val);
3329 return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, cidx, val);
3332 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3333 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3334 err = alc_auto_add_stereo_vol(codec, pfx, cidx, vol);
3337 err = alc_auto_add_stereo_sw(codec, pfx, cidx, sw);
3343 static struct hda_bind_ctls *new_bind_ctl(struct hda_codec *codec,
3345 struct hda_ctl_ops *ops)
3347 struct alc_spec *spec = codec->spec;
3348 struct hda_bind_ctls **ctlp, *ctl;
3349 snd_array_init(&spec->bind_ctls, sizeof(ctl), 8);
3350 ctlp = snd_array_new(&spec->bind_ctls);
3353 ctl = kzalloc(sizeof(*ctl) + sizeof(long) * (nums + 1), GFP_KERNEL);
3360 /* add playback controls for speaker and HP outputs */
3361 static int alc_auto_create_extra_outs(struct hda_codec *codec, int num_pins,
3362 const hda_nid_t *pins,
3363 const hda_nid_t *dacs,
3366 struct alc_spec *spec = codec->spec;
3367 struct hda_bind_ctls *ctl;
3371 if (!num_pins || !pins[0])
3374 if (num_pins == 1) {
3375 hda_nid_t dac = *dacs;
3377 dac = spec->multiout.dac_nids[0];
3378 return alc_auto_create_extra_out(codec, *pins, dac, pfx, 0);
3381 if (dacs[num_pins - 1]) {
3382 /* OK, we have a multi-output system with individual volumes */
3383 for (i = 0; i < num_pins; i++) {
3384 if (num_pins >= 3) {
3385 snprintf(name, sizeof(name), "%s %s",
3386 pfx, channel_name[i]);
3387 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3390 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3399 /* Let's create a bind-controls */
3400 ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_sw);
3404 for (i = 0; i < num_pins; i++) {
3405 if (get_wcaps(codec, pins[i]) & AC_WCAP_OUT_AMP)
3407 HDA_COMPOSE_AMP_VAL(pins[i], 3, 0, HDA_OUTPUT);
3410 snprintf(name, sizeof(name), "%s Playback Switch", pfx);
3411 err = add_control(spec, ALC_CTL_BIND_SW, name, 0, (long)ctl);
3416 ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_vol);
3420 for (i = 0; i < num_pins; i++) {
3422 if (!pins[i] || !dacs[i])
3424 vol = alc_look_for_out_vol_nid(codec, pins[i], dacs[i]);
3427 HDA_COMPOSE_AMP_VAL(vol, 3, 0, HDA_OUTPUT);
3430 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
3431 err = add_control(spec, ALC_CTL_BIND_VOL, name, 0, (long)ctl);
3438 static int alc_auto_create_hp_out(struct hda_codec *codec)
3440 struct alc_spec *spec = codec->spec;
3441 return alc_auto_create_extra_outs(codec, spec->autocfg.hp_outs,
3442 spec->autocfg.hp_pins,
3443 spec->multiout.hp_out_nid,
3447 static int alc_auto_create_speaker_out(struct hda_codec *codec)
3449 struct alc_spec *spec = codec->spec;
3450 return alc_auto_create_extra_outs(codec, spec->autocfg.speaker_outs,
3451 spec->autocfg.speaker_pins,
3452 spec->multiout.extra_out_nid,
3456 static void alc_auto_set_output_and_unmute(struct hda_codec *codec,
3457 hda_nid_t pin, int pin_type,
3461 hda_nid_t nid, mix = 0;
3462 hda_nid_t srcs[HDA_MAX_CONNECTIONS];
3464 alc_set_pin_output(codec, pin, pin_type);
3465 nid = alc_go_down_to_selector(codec, pin);
3466 num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
3467 for (i = 0; i < num; i++) {
3468 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
3476 /* need the manual connection? */
3478 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
3479 /* unmute mixer widget inputs */
3480 if (nid_has_mute(codec, mix, HDA_INPUT)) {
3481 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3483 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3486 /* initialize volume */
3487 nid = alc_look_for_out_vol_nid(codec, pin, dac);
3489 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3492 /* unmute DAC if it's not assigned to a mixer */
3493 nid = alc_look_for_out_mute_nid(codec, pin, dac);
3494 if (nid == mix && nid_has_mute(codec, dac, HDA_OUTPUT))
3495 snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3499 static void alc_auto_init_multi_out(struct hda_codec *codec)
3501 struct alc_spec *spec = codec->spec;
3502 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3505 for (i = 0; i <= HDA_SIDE; i++) {
3506 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3508 alc_auto_set_output_and_unmute(codec, nid, pin_type,
3509 spec->multiout.dac_nids[i]);
3513 static void alc_auto_init_extra_out(struct hda_codec *codec)
3515 struct alc_spec *spec = codec->spec;
3519 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3520 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
3522 pin = spec->autocfg.hp_pins[i];
3525 dac = spec->multiout.hp_out_nid[i];
3527 if (i > 0 && spec->multiout.hp_out_nid[0])
3528 dac = spec->multiout.hp_out_nid[0];
3530 dac = spec->multiout.dac_nids[0];
3532 alc_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
3534 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3535 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3537 pin = spec->autocfg.speaker_pins[i];
3540 dac = spec->multiout.extra_out_nid[i];
3542 if (i > 0 && spec->multiout.extra_out_nid[0])
3543 dac = spec->multiout.extra_out_nid[0];
3545 dac = spec->multiout.dac_nids[0];
3547 alc_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
3554 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
3555 unsigned int location,
3558 struct alc_spec *spec = codec->spec;
3559 struct auto_pin_cfg *cfg = &spec->autocfg;
3560 hda_nid_t prime_dac = spec->private_dac_nids[0];
3561 int type, i, dacs, num_pins = 0;
3563 dacs = spec->multiout.num_dacs;
3564 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
3565 for (i = 0; i < cfg->num_inputs; i++) {
3566 hda_nid_t nid = cfg->inputs[i].pin;
3568 unsigned int defcfg, caps;
3569 if (cfg->inputs[i].type != type)
3571 defcfg = snd_hda_codec_get_pincfg(codec, nid);
3572 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
3574 if (location && get_defcfg_location(defcfg) != location)
3576 caps = snd_hda_query_pin_caps(codec, nid);
3577 if (!(caps & AC_PINCAP_OUT))
3579 if (offset && offset + num_pins < dacs) {
3580 dac = spec->private_dac_nids[offset + num_pins];
3581 if (!alc_auto_is_dac_reachable(codec, nid, dac))
3585 dac = alc_auto_look_for_dac(codec, nid);
3588 spec->multi_io[num_pins].pin = nid;
3589 spec->multi_io[num_pins].dac = dac;
3591 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
3594 spec->multiout.num_dacs = dacs;
3596 /* clear up again */
3597 memset(spec->private_dac_nids + dacs, 0,
3598 sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - dacs));
3599 spec->private_dac_nids[0] = prime_dac;
3605 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
3606 struct snd_ctl_elem_info *uinfo)
3608 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3609 struct alc_spec *spec = codec->spec;
3611 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3613 uinfo->value.enumerated.items = spec->multi_ios + 1;
3614 if (uinfo->value.enumerated.item > spec->multi_ios)
3615 uinfo->value.enumerated.item = spec->multi_ios;
3616 sprintf(uinfo->value.enumerated.name, "%dch",
3617 (uinfo->value.enumerated.item + 1) * 2);
3621 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
3622 struct snd_ctl_elem_value *ucontrol)
3624 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3625 struct alc_spec *spec = codec->spec;
3626 ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
3630 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
3632 struct alc_spec *spec = codec->spec;
3633 hda_nid_t nid = spec->multi_io[idx].pin;
3635 if (!spec->multi_io[idx].ctl_in)
3636 spec->multi_io[idx].ctl_in =
3637 snd_hda_codec_read(codec, nid, 0,
3638 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3640 snd_hda_codec_update_cache(codec, nid, 0,
3641 AC_VERB_SET_PIN_WIDGET_CONTROL,
3643 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3644 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3646 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
3648 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3649 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3650 HDA_AMP_MUTE, HDA_AMP_MUTE);
3651 snd_hda_codec_update_cache(codec, nid, 0,
3652 AC_VERB_SET_PIN_WIDGET_CONTROL,
3653 spec->multi_io[idx].ctl_in);
3658 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
3659 struct snd_ctl_elem_value *ucontrol)
3661 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3662 struct alc_spec *spec = codec->spec;
3665 ch = ucontrol->value.enumerated.item[0];
3666 if (ch < 0 || ch > spec->multi_ios)
3668 if (ch == (spec->ext_channel_count - 1) / 2)
3670 spec->ext_channel_count = (ch + 1) * 2;
3671 for (i = 0; i < spec->multi_ios; i++)
3672 alc_set_multi_io(codec, i, i < ch);
3673 spec->multiout.max_channels = spec->ext_channel_count;
3674 if (spec->need_dac_fix && !spec->const_channel_count)
3675 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
3679 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
3680 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3681 .name = "Channel Mode",
3682 .info = alc_auto_ch_mode_info,
3683 .get = alc_auto_ch_mode_get,
3684 .put = alc_auto_ch_mode_put,
3687 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec)
3689 struct alc_spec *spec = codec->spec;
3691 if (spec->multi_ios > 0) {
3692 struct snd_kcontrol_new *knew;
3694 knew = alc_kcontrol_new(spec);
3697 *knew = alc_auto_channel_mode_enum;
3698 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
3705 /* filter out invalid adc_nids (and capsrc_nids) that don't give all
3708 static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
3710 struct alc_spec *spec = codec->spec;
3711 const struct hda_input_mux *imux;
3712 hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3713 hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3716 imux = spec->input_mux;
3719 if (spec->dyn_adc_switch)
3723 for (n = 0; n < spec->num_adc_nids; n++) {
3724 hda_nid_t cap = spec->private_capsrc_nids[n];
3725 int num_conns = snd_hda_get_conn_list(codec, cap, NULL);
3726 for (i = 0; i < imux->num_items; i++) {
3727 hda_nid_t pin = spec->imux_pins[i];
3729 if (get_connection_index(codec, cap, pin) < 0)
3731 } else if (num_conns <= imux->items[i].index)
3734 if (i >= imux->num_items) {
3735 adc_nids[nums] = spec->private_adc_nids[n];
3736 capsrc_nids[nums++] = cap;
3740 /* check whether ADC-switch is possible */
3741 if (!alc_check_dyn_adc_switch(codec)) {
3742 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
3743 " using fallback 0x%x\n",
3744 codec->chip_name, spec->private_adc_nids[0]);
3745 spec->num_adc_nids = 1;
3749 } else if (nums != spec->num_adc_nids) {
3750 memcpy(spec->private_adc_nids, adc_nids,
3751 nums * sizeof(hda_nid_t));
3752 memcpy(spec->private_capsrc_nids, capsrc_nids,
3753 nums * sizeof(hda_nid_t));
3754 spec->num_adc_nids = nums;
3758 alc_auto_mic_check_imux(codec); /* check auto-mic setups */
3759 else if (spec->input_mux->num_items == 1)
3760 spec->num_adc_nids = 1; /* reduce to a single ADC */
3764 * initialize ADC paths
3766 static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx)
3768 struct alc_spec *spec = codec->spec;
3771 nid = spec->adc_nids[adc_idx];
3773 if (nid_has_mute(codec, nid, HDA_INPUT)) {
3774 snd_hda_codec_write(codec, nid, 0,
3775 AC_VERB_SET_AMP_GAIN_MUTE,
3779 if (!spec->capsrc_nids)
3781 nid = spec->capsrc_nids[adc_idx];
3782 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3783 snd_hda_codec_write(codec, nid, 0,
3784 AC_VERB_SET_AMP_GAIN_MUTE,
3788 static void alc_auto_init_input_src(struct hda_codec *codec)
3790 struct alc_spec *spec = codec->spec;
3793 for (c = 0; c < spec->num_adc_nids; c++)
3794 alc_auto_init_adc(codec, c);
3795 if (spec->dyn_adc_switch)
3798 nums = spec->num_adc_nids;
3799 for (c = 0; c < nums; c++)
3800 alc_mux_select(codec, c, spec->cur_mux[c], true);
3803 /* add mic boosts if needed */
3804 static int alc_auto_add_mic_boost(struct hda_codec *codec)
3806 struct alc_spec *spec = codec->spec;
3807 struct auto_pin_cfg *cfg = &spec->autocfg;
3811 const char *prev_label = NULL;
3813 for (i = 0; i < cfg->num_inputs; i++) {
3814 if (cfg->inputs[i].type > AUTO_PIN_MIC)
3816 nid = cfg->inputs[i].pin;
3817 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
3819 char boost_label[32];
3821 label = hda_get_autocfg_input_label(codec, cfg, i);
3822 if (spec->shared_mic_hp && !strcmp(label, "Misc"))
3823 label = "Headphone Mic";
3824 if (prev_label && !strcmp(label, prev_label))
3830 snprintf(boost_label, sizeof(boost_label),
3831 "%s Boost Volume", label);
3832 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3833 boost_label, type_idx,
3834 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
3842 /* select or unmute the given capsrc route */
3843 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
3846 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
3847 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
3849 } else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) {
3850 snd_hda_codec_write_cache(codec, cap, 0,
3851 AC_VERB_SET_CONNECT_SEL, idx);
3855 /* set the default connection to that pin */
3856 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
3858 struct alc_spec *spec = codec->spec;
3863 for (i = 0; i < spec->num_adc_nids; i++) {
3864 hda_nid_t cap = get_capsrc(spec, i);
3867 idx = get_connection_index(codec, cap, pin);
3870 select_or_unmute_capsrc(codec, cap, idx);
3871 return i; /* return the found index */
3873 return -1; /* not found */
3876 /* initialize some special cases for input sources */
3877 static void alc_init_special_input_src(struct hda_codec *codec)
3879 struct alc_spec *spec = codec->spec;
3882 for (i = 0; i < spec->autocfg.num_inputs; i++)
3883 init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin);
3886 /* assign appropriate capture mixers */
3887 static void set_capture_mixer(struct hda_codec *codec)
3889 struct alc_spec *spec = codec->spec;
3890 static const struct snd_kcontrol_new *caps[2][3] = {
3891 { alc_capture_mixer_nosrc1,
3892 alc_capture_mixer_nosrc2,
3893 alc_capture_mixer_nosrc3 },
3894 { alc_capture_mixer1,
3896 alc_capture_mixer3 },
3899 /* check whether either of ADC or MUX has a volume control */
3900 if (!nid_has_volume(codec, spec->adc_nids[0], HDA_INPUT)) {
3901 if (!spec->capsrc_nids)
3902 return; /* no volume */
3903 if (!nid_has_volume(codec, spec->capsrc_nids[0], HDA_OUTPUT))
3904 return; /* no volume in capsrc, too */
3905 spec->vol_in_capsrc = 1;
3908 if (spec->num_adc_nids > 0) {
3912 if (spec->input_mux && spec->input_mux->num_items > 1)
3914 if (spec->auto_mic) {
3917 } else if (spec->dyn_adc_switch)
3920 if (spec->num_adc_nids > 3)
3921 spec->num_adc_nids = 3;
3922 else if (!spec->num_adc_nids)
3924 num_adcs = spec->num_adc_nids;
3926 spec->cap_mixer = caps[mux][num_adcs - 1];
3931 * standard auto-parser initializations
3933 static void alc_auto_init_std(struct hda_codec *codec)
3935 struct alc_spec *spec = codec->spec;
3936 alc_auto_init_multi_out(codec);
3937 alc_auto_init_extra_out(codec);
3938 alc_auto_init_analog_input(codec);
3939 alc_auto_init_input_src(codec);
3940 alc_auto_init_digital(codec);
3941 if (spec->unsol_event)
3942 alc_inithook(codec);
3946 * Digital-beep handlers
3948 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3949 #define set_beep_amp(spec, nid, idx, dir) \
3950 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
3952 static const struct snd_pci_quirk beep_white_list[] = {
3953 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
3954 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
3955 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
3956 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
3957 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
3961 static inline int has_cdefine_beep(struct hda_codec *codec)
3963 struct alc_spec *spec = codec->spec;
3964 const struct snd_pci_quirk *q;
3965 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
3968 return spec->cdefine.enable_pcbeep;
3971 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
3972 #define has_cdefine_beep(codec) 0
3975 /* parse the BIOS configuration and set up the alc_spec */
3976 /* return 1 if successful, 0 if the proper config is not found,
3977 * or a negative error code
3979 static int alc_parse_auto_config(struct hda_codec *codec,
3980 const hda_nid_t *ignore_nids,
3981 const hda_nid_t *ssid_nids)
3983 struct alc_spec *spec = codec->spec;
3984 struct auto_pin_cfg *cfg = &spec->autocfg;
3987 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
3991 if (!cfg->line_outs) {
3992 if (cfg->dig_outs || cfg->dig_in_pin) {
3993 spec->multiout.max_channels = 2;
3994 spec->no_analog = 1;
3997 return 0; /* can't find valid BIOS pin config */
4000 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
4001 cfg->line_outs <= cfg->hp_outs) {
4002 /* use HP as primary out */
4003 cfg->speaker_outs = cfg->line_outs;
4004 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4005 sizeof(cfg->speaker_pins));
4006 cfg->line_outs = cfg->hp_outs;
4007 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
4009 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4010 cfg->line_out_type = AUTO_PIN_HP_OUT;
4013 err = alc_auto_fill_dac_nids(codec);
4016 err = alc_auto_add_multi_channel_mode(codec);
4019 err = alc_auto_create_multi_out_ctls(codec, cfg);
4022 err = alc_auto_create_hp_out(codec);
4025 err = alc_auto_create_speaker_out(codec);
4028 err = alc_auto_create_shared_input(codec);
4031 err = alc_auto_create_input_ctls(codec);
4035 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4038 alc_auto_parse_digital(codec);
4040 if (!spec->no_analog)
4041 alc_remove_invalid_adc_nids(codec);
4044 alc_ssid_check(codec, ssid_nids);
4046 if (!spec->no_analog) {
4047 alc_auto_check_switches(codec);
4048 err = alc_auto_add_mic_boost(codec);
4053 if (spec->kctls.list)
4054 add_mixer(spec, spec->kctls.list);
4059 static int alc880_parse_auto_config(struct hda_codec *codec)
4061 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4062 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4063 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
4066 #ifdef CONFIG_SND_HDA_POWER_SAVE
4067 static const struct hda_amp_list alc880_loopbacks[] = {
4068 { 0x0b, HDA_INPUT, 0 },
4069 { 0x0b, HDA_INPUT, 1 },
4070 { 0x0b, HDA_INPUT, 2 },
4071 { 0x0b, HDA_INPUT, 3 },
4072 { 0x0b, HDA_INPUT, 4 },
4082 ALC880_FIXUP_MEDION_RIM,
4085 static const struct alc_fixup alc880_fixups[] = {
4086 [ALC880_FIXUP_GPIO2] = {
4087 .type = ALC_FIXUP_VERBS,
4088 .v.verbs = alc_gpio2_init_verbs,
4090 [ALC880_FIXUP_MEDION_RIM] = {
4091 .type = ALC_FIXUP_VERBS,
4092 .v.verbs = (const struct hda_verb[]) {
4093 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4094 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
4098 .chain_id = ALC880_FIXUP_GPIO2,
4102 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
4103 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
4111 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4112 #define alc_board_config \
4113 snd_hda_check_board_config
4114 #define alc_board_codec_sid_config \
4115 snd_hda_check_board_codec_sid_config
4116 #include "alc_quirks.c"
4118 #define alc_board_config(codec, nums, models, tbl) -1
4119 #define alc_board_codec_sid_config(codec, nums, models, tbl) -1
4120 #define setup_preset(codec, x) /* NOP */
4124 * OK, here we have finally the patch for ALC880
4126 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4127 #include "alc880_quirks.c"
4130 static int patch_alc880(struct hda_codec *codec)
4132 struct alc_spec *spec;
4136 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4142 spec->mixer_nid = 0x0b;
4143 spec->need_dac_fix = 1;
4145 board_config = alc_board_config(codec, ALC880_MODEL_LAST,
4146 alc880_models, alc880_cfg_tbl);
4147 if (board_config < 0) {
4148 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4150 board_config = ALC_MODEL_AUTO;
4153 if (board_config == ALC_MODEL_AUTO) {
4154 alc_pick_fixup(codec, NULL, alc880_fixup_tbl, alc880_fixups);
4155 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4158 if (board_config == ALC_MODEL_AUTO) {
4159 /* automatic parse from the BIOS config */
4160 err = alc880_parse_auto_config(codec);
4163 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4166 "hda_codec: Cannot set up configuration "
4167 "from BIOS. Using 3-stack mode...\n");
4168 board_config = ALC880_3ST;
4173 if (board_config != ALC_MODEL_AUTO) {
4174 spec->vmaster_nid = 0x0c;
4175 setup_preset(codec, &alc880_presets[board_config]);
4178 if (!spec->no_analog && !spec->adc_nids) {
4179 alc_auto_fill_adc_caps(codec);
4180 alc_rebuild_imux_for_auto_mic(codec);
4181 alc_remove_invalid_adc_nids(codec);
4184 if (!spec->no_analog && !spec->cap_mixer)
4185 set_capture_mixer(codec);
4187 if (!spec->no_analog) {
4188 err = snd_hda_attach_beep_device(codec, 0x1);
4191 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4194 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4196 codec->patch_ops = alc_patch_ops;
4197 if (board_config == ALC_MODEL_AUTO)
4198 spec->init_hook = alc_auto_init_std;
4200 codec->patch_ops.build_controls = __alc_build_controls;
4201 #ifdef CONFIG_SND_HDA_POWER_SAVE
4202 if (!spec->loopback.amplist)
4203 spec->loopback.amplist = alc880_loopbacks;
4217 static int alc260_parse_auto_config(struct hda_codec *codec)
4219 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
4220 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
4221 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
4224 #ifdef CONFIG_SND_HDA_POWER_SAVE
4225 static const struct hda_amp_list alc260_loopbacks[] = {
4226 { 0x07, HDA_INPUT, 0 },
4227 { 0x07, HDA_INPUT, 1 },
4228 { 0x07, HDA_INPUT, 2 },
4229 { 0x07, HDA_INPUT, 3 },
4230 { 0x07, HDA_INPUT, 4 },
4242 static const struct alc_fixup alc260_fixups[] = {
4243 [PINFIX_HP_DC5750] = {
4244 .type = ALC_FIXUP_PINS,
4245 .v.pins = (const struct alc_pincfg[]) {
4246 { 0x11, 0x90130110 }, /* speaker */
4252 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
4253 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
4259 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4260 #include "alc260_quirks.c"
4263 static int patch_alc260(struct hda_codec *codec)
4265 struct alc_spec *spec;
4266 int err, board_config;
4268 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4274 spec->mixer_nid = 0x07;
4276 board_config = alc_board_config(codec, ALC260_MODEL_LAST,
4277 alc260_models, alc260_cfg_tbl);
4278 if (board_config < 0) {
4279 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4281 board_config = ALC_MODEL_AUTO;
4284 if (board_config == ALC_MODEL_AUTO) {
4285 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
4286 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4289 if (board_config == ALC_MODEL_AUTO) {
4290 /* automatic parse from the BIOS config */
4291 err = alc260_parse_auto_config(codec);
4294 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4297 "hda_codec: Cannot set up configuration "
4298 "from BIOS. Using base mode...\n");
4299 board_config = ALC260_BASIC;
4304 if (board_config != ALC_MODEL_AUTO) {
4305 setup_preset(codec, &alc260_presets[board_config]);
4306 spec->vmaster_nid = 0x08;
4309 if (!spec->no_analog && !spec->adc_nids) {
4310 alc_auto_fill_adc_caps(codec);
4311 alc_rebuild_imux_for_auto_mic(codec);
4312 alc_remove_invalid_adc_nids(codec);
4315 if (!spec->no_analog && !spec->cap_mixer)
4316 set_capture_mixer(codec);
4318 if (!spec->no_analog) {
4319 err = snd_hda_attach_beep_device(codec, 0x1);
4322 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
4325 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4327 codec->patch_ops = alc_patch_ops;
4328 if (board_config == ALC_MODEL_AUTO)
4329 spec->init_hook = alc_auto_init_std;
4331 codec->patch_ops.build_controls = __alc_build_controls;
4332 spec->shutup = alc_eapd_shutup;
4333 #ifdef CONFIG_SND_HDA_POWER_SAVE
4334 if (!spec->loopback.amplist)
4335 spec->loopback.amplist = alc260_loopbacks;
4347 * ALC882/883/885/888/889 support
4349 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
4350 * configuration. Each pin widget can choose any input DACs and a mixer.
4351 * Each ADC is connected from a mixer of all inputs. This makes possible
4352 * 6-channel independent captures.
4354 * In addition, an independent DAC for the multi-playback (not used in this
4357 #ifdef CONFIG_SND_HDA_POWER_SAVE
4358 #define alc882_loopbacks alc880_loopbacks
4365 ALC882_FIXUP_ABIT_AW9D_MAX,
4366 ALC882_FIXUP_LENOVO_Y530,
4367 ALC882_FIXUP_PB_M5210,
4368 ALC882_FIXUP_ACER_ASPIRE_7736,
4369 ALC882_FIXUP_ASUS_W90V,
4370 ALC889_FIXUP_VAIO_TT,
4371 ALC888_FIXUP_EEE1601,
4374 ALC883_FIXUP_ACER_EAPD,
4377 ALC882_FIXUP_ASUS_W2JC,
4378 ALC882_FIXUP_ACER_ASPIRE_4930G,
4379 ALC882_FIXUP_ACER_ASPIRE_8930G,
4380 ALC882_FIXUP_ASPIRE_8930G_VERBS,
4381 ALC885_FIXUP_MACPRO_GPIO,
4382 ALC889_FIXUP_DAC_ROUTE,
4385 static void alc889_fixup_coef(struct hda_codec *codec,
4386 const struct alc_fixup *fix, int action)
4388 if (action != ALC_FIXUP_ACT_INIT)
4390 alc889_coef_init(codec);
4393 /* toggle speaker-output according to the hp-jack state */
4394 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
4396 unsigned int gpiostate, gpiomask, gpiodir;
4398 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4399 AC_VERB_GET_GPIO_DATA, 0);
4402 gpiostate |= (1 << pin);
4404 gpiostate &= ~(1 << pin);
4406 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4407 AC_VERB_GET_GPIO_MASK, 0);
4408 gpiomask |= (1 << pin);
4410 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4411 AC_VERB_GET_GPIO_DIRECTION, 0);
4412 gpiodir |= (1 << pin);
4415 snd_hda_codec_write(codec, codec->afg, 0,
4416 AC_VERB_SET_GPIO_MASK, gpiomask);
4417 snd_hda_codec_write(codec, codec->afg, 0,
4418 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
4422 snd_hda_codec_write(codec, codec->afg, 0,
4423 AC_VERB_SET_GPIO_DATA, gpiostate);
4426 /* set up GPIO at initialization */
4427 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
4428 const struct alc_fixup *fix, int action)
4430 if (action != ALC_FIXUP_ACT_INIT)
4432 alc882_gpio_mute(codec, 0, 0);
4433 alc882_gpio_mute(codec, 1, 0);
4436 /* Fix the connection of some pins for ALC889:
4437 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
4438 * work correctly (bko#42740)
4440 static void alc889_fixup_dac_route(struct hda_codec *codec,
4441 const struct alc_fixup *fix, int action)
4443 if (action == ALC_FIXUP_ACT_PRE_PROBE) {
4444 /* fake the connections during parsing the tree */
4445 hda_nid_t conn1[2] = { 0x0c, 0x0d };
4446 hda_nid_t conn2[2] = { 0x0e, 0x0f };
4447 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
4448 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
4449 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
4450 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
4451 } else if (action == ALC_FIXUP_ACT_PROBE) {
4452 /* restore the connections */
4453 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
4454 snd_hda_override_conn_list(codec, 0x14, 5, conn);
4455 snd_hda_override_conn_list(codec, 0x15, 5, conn);
4456 snd_hda_override_conn_list(codec, 0x18, 5, conn);
4457 snd_hda_override_conn_list(codec, 0x1a, 5, conn);
4461 static const struct alc_fixup alc882_fixups[] = {
4462 [ALC882_FIXUP_ABIT_AW9D_MAX] = {
4463 .type = ALC_FIXUP_PINS,
4464 .v.pins = (const struct alc_pincfg[]) {
4465 { 0x15, 0x01080104 }, /* side */
4466 { 0x16, 0x01011012 }, /* rear */
4467 { 0x17, 0x01016011 }, /* clfe */
4471 [ALC882_FIXUP_LENOVO_Y530] = {
4472 .type = ALC_FIXUP_PINS,
4473 .v.pins = (const struct alc_pincfg[]) {
4474 { 0x15, 0x99130112 }, /* rear int speakers */
4475 { 0x16, 0x99130111 }, /* subwoofer */
4479 [ALC882_FIXUP_PB_M5210] = {
4480 .type = ALC_FIXUP_VERBS,
4481 .v.verbs = (const struct hda_verb[]) {
4482 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
4486 [ALC882_FIXUP_ACER_ASPIRE_7736] = {
4487 .type = ALC_FIXUP_SKU,
4488 .v.sku = ALC_FIXUP_SKU_IGNORE,
4490 [ALC882_FIXUP_ASUS_W90V] = {
4491 .type = ALC_FIXUP_PINS,
4492 .v.pins = (const struct alc_pincfg[]) {
4493 { 0x16, 0x99130110 }, /* fix sequence for CLFE */
4497 [ALC889_FIXUP_VAIO_TT] = {
4498 .type = ALC_FIXUP_PINS,
4499 .v.pins = (const struct alc_pincfg[]) {
4500 { 0x17, 0x90170111 }, /* hidden surround speaker */
4504 [ALC888_FIXUP_EEE1601] = {
4505 .type = ALC_FIXUP_VERBS,
4506 .v.verbs = (const struct hda_verb[]) {
4507 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
4508 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },
4512 [ALC882_FIXUP_EAPD] = {
4513 .type = ALC_FIXUP_VERBS,
4514 .v.verbs = (const struct hda_verb[]) {
4515 /* change to EAPD mode */
4516 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4517 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
4521 [ALC883_FIXUP_EAPD] = {
4522 .type = ALC_FIXUP_VERBS,
4523 .v.verbs = (const struct hda_verb[]) {
4524 /* change to EAPD mode */
4525 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4526 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
4530 [ALC883_FIXUP_ACER_EAPD] = {
4531 .type = ALC_FIXUP_VERBS,
4532 .v.verbs = (const struct hda_verb[]) {
4533 /* eanable EAPD on Acer laptops */
4534 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4535 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4539 [ALC882_FIXUP_GPIO3] = {
4540 .type = ALC_FIXUP_VERBS,
4541 .v.verbs = alc_gpio3_init_verbs,
4543 [ALC882_FIXUP_ASUS_W2JC] = {
4544 .type = ALC_FIXUP_VERBS,
4545 .v.verbs = alc_gpio1_init_verbs,
4547 .chain_id = ALC882_FIXUP_EAPD,
4549 [ALC889_FIXUP_COEF] = {
4550 .type = ALC_FIXUP_FUNC,
4551 .v.func = alc889_fixup_coef,
4553 [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
4554 .type = ALC_FIXUP_PINS,
4555 .v.pins = (const struct alc_pincfg[]) {
4556 { 0x16, 0x99130111 }, /* CLFE speaker */
4557 { 0x17, 0x99130112 }, /* surround speaker */
4561 [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
4562 .type = ALC_FIXUP_PINS,
4563 .v.pins = (const struct alc_pincfg[]) {
4564 { 0x16, 0x99130111 }, /* CLFE speaker */
4565 { 0x1b, 0x99130112 }, /* surround speaker */
4569 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
4571 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
4572 /* additional init verbs for Acer Aspire 8930G */
4573 .type = ALC_FIXUP_VERBS,
4574 .v.verbs = (const struct hda_verb[]) {
4575 /* Enable all DACs */
4576 /* DAC DISABLE/MUTE 1? */
4577 /* setting bits 1-5 disables DAC nids 0x02-0x06
4578 * apparently. Init=0x38 */
4579 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
4580 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
4581 /* DAC DISABLE/MUTE 2? */
4582 /* some bit here disables the other DACs.
4584 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
4585 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
4587 * This laptop has a stereo digital microphone.
4588 * The mics are only 1cm apart which makes the stereo
4589 * useless. However, either the mic or the ALC889
4590 * makes the signal become a difference/sum signal
4591 * instead of standard stereo, which is annoying.
4592 * So instead we flip this bit which makes the
4593 * codec replicate the sum signal to both channels,
4594 * turning it into a normal mono mic.
4596 /* DMIC_CONTROL? Init value = 0x0001 */
4597 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
4598 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
4599 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4600 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4604 [ALC885_FIXUP_MACPRO_GPIO] = {
4605 .type = ALC_FIXUP_FUNC,
4606 .v.func = alc885_fixup_macpro_gpio,
4608 [ALC889_FIXUP_DAC_ROUTE] = {
4609 .type = ALC_FIXUP_FUNC,
4610 .v.func = alc889_fixup_dac_route,
4614 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
4615 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
4616 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
4617 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
4618 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
4619 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
4620 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
4621 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
4622 ALC882_FIXUP_ACER_ASPIRE_4930G),
4623 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
4624 ALC882_FIXUP_ACER_ASPIRE_4930G),
4625 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
4626 ALC882_FIXUP_ACER_ASPIRE_8930G),
4627 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
4628 ALC882_FIXUP_ACER_ASPIRE_8930G),
4629 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
4630 ALC882_FIXUP_ACER_ASPIRE_4930G),
4631 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
4632 ALC882_FIXUP_ACER_ASPIRE_4930G),
4633 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
4634 ALC882_FIXUP_ACER_ASPIRE_4930G),
4635 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
4636 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
4637 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
4638 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
4639 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
4640 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
4641 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
4642 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
4644 /* All Apple entries are in codec SSIDs */
4645 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_FIXUP_MACPRO_GPIO),
4646 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
4647 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
4648 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
4649 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
4651 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
4652 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
4653 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
4654 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
4655 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
4656 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
4657 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
4662 * BIOS auto configuration
4664 /* almost identical with ALC880 parser... */
4665 static int alc882_parse_auto_config(struct hda_codec *codec)
4667 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
4668 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4669 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
4674 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4675 #include "alc882_quirks.c"
4678 static int patch_alc882(struct hda_codec *codec)
4680 struct alc_spec *spec;
4681 int err, board_config;
4683 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4689 spec->mixer_nid = 0x0b;
4691 switch (codec->vendor_id) {
4696 /* ALC883 and variants */
4697 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4701 err = alc_codec_rename_from_preset(codec);
4705 board_config = alc_board_config(codec, ALC882_MODEL_LAST,
4706 alc882_models, NULL);
4707 if (board_config < 0)
4708 board_config = alc_board_codec_sid_config(codec,
4709 ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
4711 if (board_config < 0) {
4712 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4714 board_config = ALC_MODEL_AUTO;
4717 if (board_config == ALC_MODEL_AUTO) {
4718 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
4719 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4722 alc_auto_parse_customize_define(codec);
4724 if (board_config == ALC_MODEL_AUTO) {
4725 /* automatic parse from the BIOS config */
4726 err = alc882_parse_auto_config(codec);
4731 if (board_config != ALC_MODEL_AUTO) {
4732 setup_preset(codec, &alc882_presets[board_config]);
4733 spec->vmaster_nid = 0x0c;
4736 if (!spec->no_analog && !spec->adc_nids) {
4737 alc_auto_fill_adc_caps(codec);
4738 alc_rebuild_imux_for_auto_mic(codec);
4739 alc_remove_invalid_adc_nids(codec);
4742 if (!spec->no_analog && !spec->cap_mixer)
4743 set_capture_mixer(codec);
4745 if (!spec->no_analog && has_cdefine_beep(codec)) {
4746 err = snd_hda_attach_beep_device(codec, 0x1);
4749 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4752 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4754 codec->patch_ops = alc_patch_ops;
4755 if (board_config == ALC_MODEL_AUTO)
4756 spec->init_hook = alc_auto_init_std;
4758 codec->patch_ops.build_controls = __alc_build_controls;
4760 #ifdef CONFIG_SND_HDA_POWER_SAVE
4761 if (!spec->loopback.amplist)
4762 spec->loopback.amplist = alc882_loopbacks;
4776 static int alc262_parse_auto_config(struct hda_codec *codec)
4778 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
4779 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4780 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
4787 ALC262_FIXUP_FSC_H270,
4788 ALC262_FIXUP_HP_Z200,
4790 ALC262_FIXUP_LENOVO_3000,
4792 ALC262_FIXUP_BENQ_T31,
4795 static const struct alc_fixup alc262_fixups[] = {
4796 [ALC262_FIXUP_FSC_H270] = {
4797 .type = ALC_FIXUP_PINS,
4798 .v.pins = (const struct alc_pincfg[]) {
4799 { 0x14, 0x99130110 }, /* speaker */
4800 { 0x15, 0x0221142f }, /* front HP */
4801 { 0x1b, 0x0121141f }, /* rear HP */
4805 [ALC262_FIXUP_HP_Z200] = {
4806 .type = ALC_FIXUP_PINS,
4807 .v.pins = (const struct alc_pincfg[]) {
4808 { 0x16, 0x99130120 }, /* internal speaker */
4812 [ALC262_FIXUP_TYAN] = {
4813 .type = ALC_FIXUP_PINS,
4814 .v.pins = (const struct alc_pincfg[]) {
4815 { 0x14, 0x1993e1f0 }, /* int AUX */
4819 [ALC262_FIXUP_LENOVO_3000] = {
4820 .type = ALC_FIXUP_VERBS,
4821 .v.verbs = (const struct hda_verb[]) {
4822 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
4826 .chain_id = ALC262_FIXUP_BENQ,
4828 [ALC262_FIXUP_BENQ] = {
4829 .type = ALC_FIXUP_VERBS,
4830 .v.verbs = (const struct hda_verb[]) {
4831 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4832 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
4836 [ALC262_FIXUP_BENQ_T31] = {
4837 .type = ALC_FIXUP_VERBS,
4838 .v.verbs = (const struct hda_verb[]) {
4839 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4840 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4846 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
4847 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
4848 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FIXUP_BENQ),
4849 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
4850 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
4851 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
4852 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
4853 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
4854 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
4859 #ifdef CONFIG_SND_HDA_POWER_SAVE
4860 #define alc262_loopbacks alc880_loopbacks
4865 static int patch_alc262(struct hda_codec *codec)
4867 struct alc_spec *spec;
4870 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4876 spec->mixer_nid = 0x0b;
4879 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
4884 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4885 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4886 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4887 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4890 alc_auto_parse_customize_define(codec);
4892 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4894 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
4895 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4897 /* automatic parse from the BIOS config */
4898 err = alc262_parse_auto_config(codec);
4902 if (!spec->no_analog && !spec->adc_nids) {
4903 alc_auto_fill_adc_caps(codec);
4904 alc_rebuild_imux_for_auto_mic(codec);
4905 alc_remove_invalid_adc_nids(codec);
4908 if (!spec->no_analog && !spec->cap_mixer)
4909 set_capture_mixer(codec);
4911 if (!spec->no_analog && has_cdefine_beep(codec)) {
4912 err = snd_hda_attach_beep_device(codec, 0x1);
4915 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4918 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4920 codec->patch_ops = alc_patch_ops;
4921 spec->init_hook = alc_auto_init_std;
4922 spec->shutup = alc_eapd_shutup;
4924 #ifdef CONFIG_SND_HDA_POWER_SAVE
4925 if (!spec->loopback.amplist)
4926 spec->loopback.amplist = alc262_loopbacks;
4939 /* bind Beep switches of both NID 0x0f and 0x10 */
4940 static const struct hda_bind_ctls alc268_bind_beep_sw = {
4941 .ops = &snd_hda_bind_sw,
4943 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
4944 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
4949 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
4950 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
4951 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
4955 /* set PCBEEP vol = 0, mute connections */
4956 static const struct hda_verb alc268_beep_init_verbs[] = {
4957 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4958 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4959 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4964 * BIOS auto configuration
4966 static int alc268_parse_auto_config(struct hda_codec *codec)
4968 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4969 struct alc_spec *spec = codec->spec;
4970 int err = alc_parse_auto_config(codec, NULL, alc268_ssids);
4972 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) {
4973 add_mixer(spec, alc268_beep_mixer);
4974 add_verb(spec, alc268_beep_init_verbs);
4982 static int patch_alc268(struct hda_codec *codec)
4984 struct alc_spec *spec;
4985 int i, has_beep, err;
4987 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4993 /* ALC268 has no aa-loopback mixer */
4995 /* automatic parse from the BIOS config */
4996 err = alc268_parse_auto_config(codec);
5001 for (i = 0; i < spec->num_mixers; i++) {
5002 if (spec->mixers[i] == alc268_beep_mixer) {
5009 err = snd_hda_attach_beep_device(codec, 0x1);
5012 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
5013 /* override the amp caps for beep generator */
5014 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
5015 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
5016 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
5017 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5018 (0 << AC_AMPCAP_MUTE_SHIFT));
5021 if (!spec->no_analog && !spec->adc_nids) {
5022 alc_auto_fill_adc_caps(codec);
5023 alc_rebuild_imux_for_auto_mic(codec);
5024 alc_remove_invalid_adc_nids(codec);
5027 if (!spec->no_analog && !spec->cap_mixer)
5028 set_capture_mixer(codec);
5030 codec->patch_ops = alc_patch_ops;
5031 spec->init_hook = alc_auto_init_std;
5032 spec->shutup = alc_eapd_shutup;
5044 #ifdef CONFIG_SND_HDA_POWER_SAVE
5045 #define alc269_loopbacks alc880_loopbacks
5048 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
5052 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
5053 /* NID is set in alc_build_pcms */
5055 .open = alc_playback_pcm_open,
5056 .prepare = alc_playback_pcm_prepare,
5057 .cleanup = alc_playback_pcm_cleanup
5061 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
5065 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
5066 /* NID is set in alc_build_pcms */
5069 #ifdef CONFIG_SND_HDA_POWER_SAVE
5070 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
5072 switch (codec->subsystem_id) {
5079 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
5081 /* update mute-LED according to the speaker mute state */
5082 if (nid == 0x01 || nid == 0x14) {
5084 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
5089 /* mic2 vref pin is used for mute LED control */
5090 snd_hda_codec_update_cache(codec, 0x19, 0,
5091 AC_VERB_SET_PIN_WIDGET_CONTROL,
5094 return alc_check_power_status(codec, nid);
5096 #endif /* CONFIG_SND_HDA_POWER_SAVE */
5098 /* different alc269-variants */
5100 ALC269_TYPE_ALC269VA,
5101 ALC269_TYPE_ALC269VB,
5102 ALC269_TYPE_ALC269VC,
5106 * BIOS auto configuration
5108 static int alc269_parse_auto_config(struct hda_codec *codec)
5110 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
5111 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
5112 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5113 struct alc_spec *spec = codec->spec;
5114 const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ?
5115 alc269va_ssids : alc269_ssids;
5117 return alc_parse_auto_config(codec, alc269_ignore, ssids);
5120 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
5122 int val = alc_read_coef_idx(codec, 0x04);
5127 alc_write_coef_idx(codec, 0x04, val);
5130 static void alc269_shutup(struct hda_codec *codec)
5132 if ((alc_get_coef0(codec) & 0x00ff) == 0x017)
5133 alc269_toggle_power_output(codec, 0);
5134 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5135 alc269_toggle_power_output(codec, 0);
5141 static int alc269_resume(struct hda_codec *codec)
5143 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5144 alc269_toggle_power_output(codec, 0);
5148 codec->patch_ops.init(codec);
5150 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
5151 alc269_toggle_power_output(codec, 1);
5155 if ((alc_get_coef0(codec) & 0x00ff) == 0x018)
5156 alc269_toggle_power_output(codec, 1);
5158 snd_hda_codec_resume_amp(codec);
5159 snd_hda_codec_resume_cache(codec);
5160 hda_call_check_power_status(codec, 0x01);
5163 #endif /* CONFIG_PM */
5165 static void alc269_fixup_hweq(struct hda_codec *codec,
5166 const struct alc_fixup *fix, int action)
5170 if (action != ALC_FIXUP_ACT_INIT)
5172 coef = alc_read_coef_idx(codec, 0x1e);
5173 alc_write_coef_idx(codec, 0x1e, coef | 0x80);
5176 static void alc271_fixup_dmic(struct hda_codec *codec,
5177 const struct alc_fixup *fix, int action)
5179 static const struct hda_verb verbs[] = {
5180 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
5181 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
5186 if (strcmp(codec->chip_name, "ALC271X"))
5188 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
5189 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
5190 snd_hda_sequence_write(codec, verbs);
5193 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
5194 const struct alc_fixup *fix, int action)
5196 struct alc_spec *spec = codec->spec;
5198 if (action != ALC_FIXUP_ACT_PROBE)
5201 /* Due to a hardware problem on Lenovo Ideadpad, we need to
5202 * fix the sample rate of analog I/O to 44.1kHz
5204 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
5205 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
5208 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
5209 const struct alc_fixup *fix, int action)
5213 if (action != ALC_FIXUP_ACT_INIT)
5215 /* The digital-mic unit sends PDM (differential signal) instead of
5216 * the standard PCM, thus you can't record a valid mono stream as is.
5217 * Below is a workaround specific to ALC269 to control the dmic
5218 * signal source as mono.
5220 coef = alc_read_coef_idx(codec, 0x07);
5221 alc_write_coef_idx(codec, 0x07, coef | 0x80);
5224 static void alc269_quanta_automute(struct hda_codec *codec)
5226 update_outputs(codec);
5228 snd_hda_codec_write(codec, 0x20, 0,
5229 AC_VERB_SET_COEF_INDEX, 0x0c);
5230 snd_hda_codec_write(codec, 0x20, 0,
5231 AC_VERB_SET_PROC_COEF, 0x680);
5233 snd_hda_codec_write(codec, 0x20, 0,
5234 AC_VERB_SET_COEF_INDEX, 0x0c);
5235 snd_hda_codec_write(codec, 0x20, 0,
5236 AC_VERB_SET_PROC_COEF, 0x480);
5239 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
5240 const struct alc_fixup *fix, int action)
5242 struct alc_spec *spec = codec->spec;
5243 if (action != ALC_FIXUP_ACT_PROBE)
5245 spec->automute_hook = alc269_quanta_automute;
5249 ALC269_FIXUP_SONY_VAIO,
5250 ALC275_FIXUP_SONY_VAIO_GPIO2,
5251 ALC269_FIXUP_DELL_M101Z,
5252 ALC269_FIXUP_SKU_IGNORE,
5253 ALC269_FIXUP_ASUS_G73JW,
5254 ALC269_FIXUP_LENOVO_EAPD,
5255 ALC275_FIXUP_SONY_HWEQ,
5257 ALC269_FIXUP_PCM_44K,
5258 ALC269_FIXUP_STEREO_DMIC,
5259 ALC269_FIXUP_QUANTA_MUTE,
5260 ALC269_FIXUP_LIFEBOOK,
5263 ALC269VB_FIXUP_AMIC,
5264 ALC269VB_FIXUP_DMIC,
5267 static const struct alc_fixup alc269_fixups[] = {
5268 [ALC269_FIXUP_SONY_VAIO] = {
5269 .type = ALC_FIXUP_VERBS,
5270 .v.verbs = (const struct hda_verb[]) {
5271 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
5275 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
5276 .type = ALC_FIXUP_VERBS,
5277 .v.verbs = (const struct hda_verb[]) {
5278 {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
5279 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
5280 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5284 .chain_id = ALC269_FIXUP_SONY_VAIO
5286 [ALC269_FIXUP_DELL_M101Z] = {
5287 .type = ALC_FIXUP_VERBS,
5288 .v.verbs = (const struct hda_verb[]) {
5289 /* Enables internal speaker */
5290 {0x20, AC_VERB_SET_COEF_INDEX, 13},
5291 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
5295 [ALC269_FIXUP_SKU_IGNORE] = {
5296 .type = ALC_FIXUP_SKU,
5297 .v.sku = ALC_FIXUP_SKU_IGNORE,
5299 [ALC269_FIXUP_ASUS_G73JW] = {
5300 .type = ALC_FIXUP_PINS,
5301 .v.pins = (const struct alc_pincfg[]) {
5302 { 0x17, 0x99130111 }, /* subwoofer */
5306 [ALC269_FIXUP_LENOVO_EAPD] = {
5307 .type = ALC_FIXUP_VERBS,
5308 .v.verbs = (const struct hda_verb[]) {
5309 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5313 [ALC275_FIXUP_SONY_HWEQ] = {
5314 .type = ALC_FIXUP_FUNC,
5315 .v.func = alc269_fixup_hweq,
5317 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
5319 [ALC271_FIXUP_DMIC] = {
5320 .type = ALC_FIXUP_FUNC,
5321 .v.func = alc271_fixup_dmic,
5323 [ALC269_FIXUP_PCM_44K] = {
5324 .type = ALC_FIXUP_FUNC,
5325 .v.func = alc269_fixup_pcm_44k,
5327 [ALC269_FIXUP_STEREO_DMIC] = {
5328 .type = ALC_FIXUP_FUNC,
5329 .v.func = alc269_fixup_stereo_dmic,
5331 [ALC269_FIXUP_QUANTA_MUTE] = {
5332 .type = ALC_FIXUP_FUNC,
5333 .v.func = alc269_fixup_quanta_mute,
5335 [ALC269_FIXUP_LIFEBOOK] = {
5336 .type = ALC_FIXUP_PINS,
5337 .v.pins = (const struct alc_pincfg[]) {
5338 { 0x1a, 0x2101103f }, /* dock line-out */
5339 { 0x1b, 0x23a11040 }, /* dock mic-in */
5343 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5345 [ALC269_FIXUP_AMIC] = {
5346 .type = ALC_FIXUP_PINS,
5347 .v.pins = (const struct alc_pincfg[]) {
5348 { 0x14, 0x99130110 }, /* speaker */
5349 { 0x15, 0x0121401f }, /* HP out */
5350 { 0x18, 0x01a19c20 }, /* mic */
5351 { 0x19, 0x99a3092f }, /* int-mic */
5355 [ALC269_FIXUP_DMIC] = {
5356 .type = ALC_FIXUP_PINS,
5357 .v.pins = (const struct alc_pincfg[]) {
5358 { 0x12, 0x99a3092f }, /* int-mic */
5359 { 0x14, 0x99130110 }, /* speaker */
5360 { 0x15, 0x0121401f }, /* HP out */
5361 { 0x18, 0x01a19c20 }, /* mic */
5365 [ALC269VB_FIXUP_AMIC] = {
5366 .type = ALC_FIXUP_PINS,
5367 .v.pins = (const struct alc_pincfg[]) {
5368 { 0x14, 0x99130110 }, /* speaker */
5369 { 0x18, 0x01a19c20 }, /* mic */
5370 { 0x19, 0x99a3092f }, /* int-mic */
5371 { 0x21, 0x0121401f }, /* HP out */
5375 [ALC269VB_FIXUP_DMIC] = {
5376 .type = ALC_FIXUP_PINS,
5377 .v.pins = (const struct alc_pincfg[]) {
5378 { 0x12, 0x99a3092f }, /* int-mic */
5379 { 0x14, 0x99130110 }, /* speaker */
5380 { 0x18, 0x01a19c20 }, /* mic */
5381 { 0x21, 0x0121401f }, /* HP out */
5387 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
5388 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
5389 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
5390 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
5391 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
5392 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5393 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5394 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
5395 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5396 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5397 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
5398 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
5399 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
5400 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
5401 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
5402 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
5403 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
5404 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
5405 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
5406 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_QUANTA_MUTE),
5407 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Lenovo Ideapd", ALC269_FIXUP_PCM_44K),
5408 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
5411 /* Below is a quirk table taken from the old code.
5412 * Basically the device should work as is without the fixup table.
5413 * If BIOS doesn't give a proper info, enable the corresponding
5416 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
5418 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
5419 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
5420 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
5421 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
5422 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
5423 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
5424 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
5425 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
5426 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
5427 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
5428 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
5429 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
5430 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
5431 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
5432 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
5433 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
5434 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
5435 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
5436 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
5437 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
5438 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
5439 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
5440 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
5441 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
5442 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
5443 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
5444 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
5445 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
5446 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
5447 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
5448 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
5449 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
5450 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
5451 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
5452 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
5453 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
5454 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
5455 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
5456 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
5461 static const struct alc_model_fixup alc269_fixup_models[] = {
5462 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
5463 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
5468 static int alc269_fill_coef(struct hda_codec *codec)
5472 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
5473 alc_write_coef_idx(codec, 0xf, 0x960b);
5474 alc_write_coef_idx(codec, 0xe, 0x8817);
5477 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
5478 alc_write_coef_idx(codec, 0xf, 0x960b);
5479 alc_write_coef_idx(codec, 0xe, 0x8814);
5482 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
5483 val = alc_read_coef_idx(codec, 0x04);
5484 /* Power up output pin */
5485 alc_write_coef_idx(codec, 0x04, val | (1<<11));
5488 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5489 val = alc_read_coef_idx(codec, 0xd);
5490 if ((val & 0x0c00) >> 10 != 0x1) {
5491 /* Capless ramp up clock control */
5492 alc_write_coef_idx(codec, 0xd, val | (1<<10));
5494 val = alc_read_coef_idx(codec, 0x17);
5495 if ((val & 0x01c0) >> 6 != 0x4) {
5496 /* Class D power on reset */
5497 alc_write_coef_idx(codec, 0x17, val | (1<<7));
5501 val = alc_read_coef_idx(codec, 0xd); /* Class D */
5502 alc_write_coef_idx(codec, 0xd, val | (1<<14));
5504 val = alc_read_coef_idx(codec, 0x4); /* HP */
5505 alc_write_coef_idx(codec, 0x4, val | (1<<11));
5512 static int patch_alc269(struct hda_codec *codec)
5514 struct alc_spec *spec;
5517 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5523 spec->mixer_nid = 0x0b;
5525 alc_auto_parse_customize_define(codec);
5527 err = alc_codec_rename_from_preset(codec);
5531 if (codec->vendor_id == 0x10ec0269) {
5532 spec->codec_variant = ALC269_TYPE_ALC269VA;
5533 switch (alc_get_coef0(codec) & 0x00f0) {
5535 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
5536 spec->cdefine.platform_type == 1)
5537 err = alc_codec_rename(codec, "ALC271X");
5538 spec->codec_variant = ALC269_TYPE_ALC269VB;
5541 if (codec->bus->pci->subsystem_vendor == 0x17aa &&
5542 codec->bus->pci->subsystem_device == 0x21f3)
5543 err = alc_codec_rename(codec, "ALC3202");
5544 spec->codec_variant = ALC269_TYPE_ALC269VC;
5547 alc_fix_pll_init(codec, 0x20, 0x04, 15);
5551 alc269_fill_coef(codec);
5554 alc_pick_fixup(codec, alc269_fixup_models,
5555 alc269_fixup_tbl, alc269_fixups);
5556 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5558 /* automatic parse from the BIOS config */
5559 err = alc269_parse_auto_config(codec);
5563 if (!spec->no_analog && !spec->adc_nids) {
5564 alc_auto_fill_adc_caps(codec);
5565 alc_rebuild_imux_for_auto_mic(codec);
5566 alc_remove_invalid_adc_nids(codec);
5569 if (!spec->no_analog && !spec->cap_mixer)
5570 set_capture_mixer(codec);
5572 if (!spec->no_analog && has_cdefine_beep(codec)) {
5573 err = snd_hda_attach_beep_device(codec, 0x1);
5576 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5579 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5581 codec->patch_ops = alc_patch_ops;
5583 codec->patch_ops.resume = alc269_resume;
5585 spec->init_hook = alc_auto_init_std;
5586 spec->shutup = alc269_shutup;
5588 #ifdef CONFIG_SND_HDA_POWER_SAVE
5589 if (!spec->loopback.amplist)
5590 spec->loopback.amplist = alc269_loopbacks;
5591 if (alc269_mic2_for_mute_led(codec))
5592 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
5606 static int alc861_parse_auto_config(struct hda_codec *codec)
5608 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
5609 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
5610 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
5613 #ifdef CONFIG_SND_HDA_POWER_SAVE
5614 static const struct hda_amp_list alc861_loopbacks[] = {
5615 { 0x15, HDA_INPUT, 0 },
5616 { 0x15, HDA_INPUT, 1 },
5617 { 0x15, HDA_INPUT, 2 },
5618 { 0x15, HDA_INPUT, 3 },
5624 /* Pin config fixes */
5626 PINFIX_FSC_AMILO_PI1505,
5630 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
5631 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
5632 const struct alc_fixup *fix, int action)
5634 struct alc_spec *spec = codec->spec;
5637 if (action != ALC_FIXUP_ACT_INIT)
5639 val = snd_hda_codec_read(codec, 0x0f, 0,
5640 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5641 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
5642 val |= AC_PINCTL_IN_EN;
5643 val |= AC_PINCTL_VREF_50;
5644 snd_hda_codec_write(codec, 0x0f, 0,
5645 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5646 spec->keep_vref_in_automute = 1;
5649 static const struct alc_fixup alc861_fixups[] = {
5650 [PINFIX_FSC_AMILO_PI1505] = {
5651 .type = ALC_FIXUP_PINS,
5652 .v.pins = (const struct alc_pincfg[]) {
5653 { 0x0b, 0x0221101f }, /* HP */
5654 { 0x0f, 0x90170310 }, /* speaker */
5658 [PINFIX_ASUS_A6RP] = {
5659 .type = ALC_FIXUP_FUNC,
5660 .v.func = alc861_fixup_asus_amp_vref_0f,
5664 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
5665 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", PINFIX_ASUS_A6RP),
5666 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", PINFIX_ASUS_A6RP),
5667 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", PINFIX_ASUS_A6RP),
5668 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
5674 static int patch_alc861(struct hda_codec *codec)
5676 struct alc_spec *spec;
5679 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5685 spec->mixer_nid = 0x15;
5687 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
5688 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5690 /* automatic parse from the BIOS config */
5691 err = alc861_parse_auto_config(codec);
5695 if (!spec->no_analog && !spec->adc_nids) {
5696 alc_auto_fill_adc_caps(codec);
5697 alc_rebuild_imux_for_auto_mic(codec);
5698 alc_remove_invalid_adc_nids(codec);
5701 if (!spec->no_analog && !spec->cap_mixer)
5702 set_capture_mixer(codec);
5704 if (!spec->no_analog) {
5705 err = snd_hda_attach_beep_device(codec, 0x23);
5708 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
5711 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5713 codec->patch_ops = alc_patch_ops;
5714 spec->init_hook = alc_auto_init_std;
5715 #ifdef CONFIG_SND_HDA_POWER_SAVE
5716 spec->power_hook = alc_power_eapd;
5717 if (!spec->loopback.amplist)
5718 spec->loopback.amplist = alc861_loopbacks;
5733 * In addition, an independent DAC
5735 #ifdef CONFIG_SND_HDA_POWER_SAVE
5736 #define alc861vd_loopbacks alc880_loopbacks
5739 static int alc861vd_parse_auto_config(struct hda_codec *codec)
5741 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
5742 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5743 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
5747 ALC660VD_FIX_ASUS_GPIO1,
5748 ALC861VD_FIX_DALLAS,
5751 /* exclude VREF80 */
5752 static void alc861vd_fixup_dallas(struct hda_codec *codec,
5753 const struct alc_fixup *fix, int action)
5755 if (action == ALC_FIXUP_ACT_PRE_PROBE) {
5756 snd_hda_override_pin_caps(codec, 0x18, 0x00001714);
5757 snd_hda_override_pin_caps(codec, 0x19, 0x0000171c);
5761 static const struct alc_fixup alc861vd_fixups[] = {
5762 [ALC660VD_FIX_ASUS_GPIO1] = {
5763 .type = ALC_FIXUP_VERBS,
5764 .v.verbs = (const struct hda_verb[]) {
5766 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5767 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5768 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5772 [ALC861VD_FIX_DALLAS] = {
5773 .type = ALC_FIXUP_FUNC,
5774 .v.func = alc861vd_fixup_dallas,
5778 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
5779 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
5780 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
5781 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
5785 static const struct hda_verb alc660vd_eapd_verbs[] = {
5786 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
5787 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
5793 static int patch_alc861vd(struct hda_codec *codec)
5795 struct alc_spec *spec;
5798 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5804 spec->mixer_nid = 0x0b;
5806 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
5807 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5809 /* automatic parse from the BIOS config */
5810 err = alc861vd_parse_auto_config(codec);
5814 if (codec->vendor_id == 0x10ec0660) {
5815 /* always turn on EAPD */
5816 add_verb(spec, alc660vd_eapd_verbs);
5819 if (!spec->no_analog && !spec->adc_nids) {
5820 alc_auto_fill_adc_caps(codec);
5821 alc_rebuild_imux_for_auto_mic(codec);
5822 alc_remove_invalid_adc_nids(codec);
5825 if (!spec->no_analog && !spec->cap_mixer)
5826 set_capture_mixer(codec);
5828 if (!spec->no_analog) {
5829 err = snd_hda_attach_beep_device(codec, 0x23);
5832 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5835 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5837 codec->patch_ops = alc_patch_ops;
5839 spec->init_hook = alc_auto_init_std;
5840 spec->shutup = alc_eapd_shutup;
5841 #ifdef CONFIG_SND_HDA_POWER_SAVE
5842 if (!spec->loopback.amplist)
5843 spec->loopback.amplist = alc861vd_loopbacks;
5856 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5857 * configuration. Each pin widget can choose any input DACs and a mixer.
5858 * Each ADC is connected from a mixer of all inputs. This makes possible
5859 * 6-channel independent captures.
5861 * In addition, an independent DAC for the multi-playback (not used in this
5864 #ifdef CONFIG_SND_HDA_POWER_SAVE
5865 #define alc662_loopbacks alc880_loopbacks
5869 * BIOS auto configuration
5872 static int alc662_parse_auto_config(struct hda_codec *codec)
5874 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
5875 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
5876 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5877 const hda_nid_t *ssids;
5879 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
5880 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
5881 ssids = alc663_ssids;
5883 ssids = alc662_ssids;
5884 return alc_parse_auto_config(codec, alc662_ignore, ssids);
5887 static void alc272_fixup_mario(struct hda_codec *codec,
5888 const struct alc_fixup *fix, int action)
5890 if (action != ALC_FIXUP_ACT_PROBE)
5892 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
5893 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
5894 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
5895 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5896 (0 << AC_AMPCAP_MUTE_SHIFT)))
5898 "hda_codec: failed to override amp caps for NID 0x2\n");
5902 ALC662_FIXUP_ASPIRE,
5903 ALC662_FIXUP_IDEAPAD,
5905 ALC662_FIXUP_CZC_P10T,
5906 ALC662_FIXUP_SKU_IGNORE,
5907 ALC662_FIXUP_HP_RP5800,
5908 ALC662_FIXUP_ASUS_MODE1,
5909 ALC662_FIXUP_ASUS_MODE2,
5910 ALC662_FIXUP_ASUS_MODE3,
5911 ALC662_FIXUP_ASUS_MODE4,
5912 ALC662_FIXUP_ASUS_MODE5,
5913 ALC662_FIXUP_ASUS_MODE6,
5914 ALC662_FIXUP_ASUS_MODE7,
5915 ALC662_FIXUP_ASUS_MODE8,
5918 static const struct alc_fixup alc662_fixups[] = {
5919 [ALC662_FIXUP_ASPIRE] = {
5920 .type = ALC_FIXUP_PINS,
5921 .v.pins = (const struct alc_pincfg[]) {
5922 { 0x15, 0x99130112 }, /* subwoofer */
5926 [ALC662_FIXUP_IDEAPAD] = {
5927 .type = ALC_FIXUP_PINS,
5928 .v.pins = (const struct alc_pincfg[]) {
5929 { 0x17, 0x99130112 }, /* subwoofer */
5933 [ALC272_FIXUP_MARIO] = {
5934 .type = ALC_FIXUP_FUNC,
5935 .v.func = alc272_fixup_mario,
5937 [ALC662_FIXUP_CZC_P10T] = {
5938 .type = ALC_FIXUP_VERBS,
5939 .v.verbs = (const struct hda_verb[]) {
5940 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5944 [ALC662_FIXUP_SKU_IGNORE] = {
5945 .type = ALC_FIXUP_SKU,
5946 .v.sku = ALC_FIXUP_SKU_IGNORE,
5948 [ALC662_FIXUP_HP_RP5800] = {
5949 .type = ALC_FIXUP_PINS,
5950 .v.pins = (const struct alc_pincfg[]) {
5951 { 0x14, 0x0221201f }, /* HP out */
5955 .chain_id = ALC662_FIXUP_SKU_IGNORE
5957 [ALC662_FIXUP_ASUS_MODE1] = {
5958 .type = ALC_FIXUP_PINS,
5959 .v.pins = (const struct alc_pincfg[]) {
5960 { 0x14, 0x99130110 }, /* speaker */
5961 { 0x18, 0x01a19c20 }, /* mic */
5962 { 0x19, 0x99a3092f }, /* int-mic */
5963 { 0x21, 0x0121401f }, /* HP out */
5967 .chain_id = ALC662_FIXUP_SKU_IGNORE
5969 [ALC662_FIXUP_ASUS_MODE2] = {
5970 .type = ALC_FIXUP_PINS,
5971 .v.pins = (const struct alc_pincfg[]) {
5972 { 0x14, 0x99130110 }, /* speaker */
5973 { 0x18, 0x01a19820 }, /* mic */
5974 { 0x19, 0x99a3092f }, /* int-mic */
5975 { 0x1b, 0x0121401f }, /* HP out */
5979 .chain_id = ALC662_FIXUP_SKU_IGNORE
5981 [ALC662_FIXUP_ASUS_MODE3] = {
5982 .type = ALC_FIXUP_PINS,
5983 .v.pins = (const struct alc_pincfg[]) {
5984 { 0x14, 0x99130110 }, /* speaker */
5985 { 0x15, 0x0121441f }, /* HP */
5986 { 0x18, 0x01a19840 }, /* mic */
5987 { 0x19, 0x99a3094f }, /* int-mic */
5988 { 0x21, 0x01211420 }, /* HP2 */
5992 .chain_id = ALC662_FIXUP_SKU_IGNORE
5994 [ALC662_FIXUP_ASUS_MODE4] = {
5995 .type = ALC_FIXUP_PINS,
5996 .v.pins = (const struct alc_pincfg[]) {
5997 { 0x14, 0x99130110 }, /* speaker */
5998 { 0x16, 0x99130111 }, /* speaker */
5999 { 0x18, 0x01a19840 }, /* mic */
6000 { 0x19, 0x99a3094f }, /* int-mic */
6001 { 0x21, 0x0121441f }, /* HP */
6005 .chain_id = ALC662_FIXUP_SKU_IGNORE
6007 [ALC662_FIXUP_ASUS_MODE5] = {
6008 .type = ALC_FIXUP_PINS,
6009 .v.pins = (const struct alc_pincfg[]) {
6010 { 0x14, 0x99130110 }, /* speaker */
6011 { 0x15, 0x0121441f }, /* HP */
6012 { 0x16, 0x99130111 }, /* speaker */
6013 { 0x18, 0x01a19840 }, /* mic */
6014 { 0x19, 0x99a3094f }, /* int-mic */
6018 .chain_id = ALC662_FIXUP_SKU_IGNORE
6020 [ALC662_FIXUP_ASUS_MODE6] = {
6021 .type = ALC_FIXUP_PINS,
6022 .v.pins = (const struct alc_pincfg[]) {
6023 { 0x14, 0x99130110 }, /* speaker */
6024 { 0x15, 0x01211420 }, /* HP2 */
6025 { 0x18, 0x01a19840 }, /* mic */
6026 { 0x19, 0x99a3094f }, /* int-mic */
6027 { 0x1b, 0x0121441f }, /* HP */
6031 .chain_id = ALC662_FIXUP_SKU_IGNORE
6033 [ALC662_FIXUP_ASUS_MODE7] = {
6034 .type = ALC_FIXUP_PINS,
6035 .v.pins = (const struct alc_pincfg[]) {
6036 { 0x14, 0x99130110 }, /* speaker */
6037 { 0x17, 0x99130111 }, /* speaker */
6038 { 0x18, 0x01a19840 }, /* mic */
6039 { 0x19, 0x99a3094f }, /* int-mic */
6040 { 0x1b, 0x01214020 }, /* HP */
6041 { 0x21, 0x0121401f }, /* HP */
6045 .chain_id = ALC662_FIXUP_SKU_IGNORE
6047 [ALC662_FIXUP_ASUS_MODE8] = {
6048 .type = ALC_FIXUP_PINS,
6049 .v.pins = (const struct alc_pincfg[]) {
6050 { 0x14, 0x99130110 }, /* speaker */
6051 { 0x12, 0x99a30970 }, /* int-mic */
6052 { 0x15, 0x01214020 }, /* HP */
6053 { 0x17, 0x99130111 }, /* speaker */
6054 { 0x18, 0x01a19840 }, /* mic */
6055 { 0x21, 0x0121401f }, /* HP */
6059 .chain_id = ALC662_FIXUP_SKU_IGNORE
6063 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
6064 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
6065 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
6066 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
6067 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
6068 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
6069 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
6070 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
6071 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
6072 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
6073 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
6076 /* Below is a quirk table taken from the old code.
6077 * Basically the device should work as is without the fixup table.
6078 * If BIOS doesn't give a proper info, enable the corresponding
6081 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
6082 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
6083 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
6084 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
6085 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6086 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6087 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6088 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
6089 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
6090 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6091 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
6092 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
6093 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
6094 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
6095 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
6096 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6097 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
6098 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
6099 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6100 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6101 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6102 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6103 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
6104 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
6105 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
6106 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6107 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
6108 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6109 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6110 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
6111 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6112 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6113 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
6114 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
6115 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
6116 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
6117 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
6118 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
6119 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
6120 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6121 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
6122 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
6123 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6124 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
6125 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
6126 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
6127 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
6128 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
6129 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6130 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
6135 static const struct alc_model_fixup alc662_fixup_models[] = {
6136 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
6137 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
6138 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
6139 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
6140 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
6141 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
6142 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
6143 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
6144 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
6151 static int patch_alc662(struct hda_codec *codec)
6153 struct alc_spec *spec;
6156 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6162 spec->mixer_nid = 0x0b;
6164 /* handle multiple HPs as is */
6165 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6167 alc_auto_parse_customize_define(codec);
6169 alc_fix_pll_init(codec, 0x20, 0x04, 15);
6171 err = alc_codec_rename_from_preset(codec);
6175 if ((alc_get_coef0(codec) & (1 << 14)) &&
6176 codec->bus->pci->subsystem_vendor == 0x1025 &&
6177 spec->cdefine.platform_type == 1) {
6178 if (alc_codec_rename(codec, "ALC272X") < 0)
6182 alc_pick_fixup(codec, alc662_fixup_models,
6183 alc662_fixup_tbl, alc662_fixups);
6184 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
6185 /* automatic parse from the BIOS config */
6186 err = alc662_parse_auto_config(codec);
6190 if (!spec->no_analog && !spec->adc_nids) {
6191 alc_auto_fill_adc_caps(codec);
6192 alc_rebuild_imux_for_auto_mic(codec);
6193 alc_remove_invalid_adc_nids(codec);
6196 if (!spec->no_analog && !spec->cap_mixer)
6197 set_capture_mixer(codec);
6199 if (!spec->no_analog && has_cdefine_beep(codec)) {
6200 err = snd_hda_attach_beep_device(codec, 0x1);
6203 switch (codec->vendor_id) {
6205 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6210 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
6213 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
6218 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
6220 codec->patch_ops = alc_patch_ops;
6221 spec->init_hook = alc_auto_init_std;
6222 spec->shutup = alc_eapd_shutup;
6224 #ifdef CONFIG_SND_HDA_POWER_SAVE
6225 if (!spec->loopback.amplist)
6226 spec->loopback.amplist = alc662_loopbacks;
6240 static int alc680_parse_auto_config(struct hda_codec *codec)
6242 return alc_parse_auto_config(codec, NULL, NULL);
6247 static int patch_alc680(struct hda_codec *codec)
6249 struct alc_spec *spec;
6252 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6258 /* ALC680 has no aa-loopback mixer */
6260 /* automatic parse from the BIOS config */
6261 err = alc680_parse_auto_config(codec);
6267 if (!spec->no_analog && !spec->cap_mixer)
6268 set_capture_mixer(codec);
6270 codec->patch_ops = alc_patch_ops;
6271 spec->init_hook = alc_auto_init_std;
6279 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
6280 { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
6281 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
6282 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
6283 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
6284 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
6285 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
6286 { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
6287 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
6288 { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
6289 { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
6290 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
6291 .patch = patch_alc861 },
6292 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
6293 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
6294 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
6295 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
6296 .patch = patch_alc882 },
6297 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
6298 .patch = patch_alc662 },
6299 { .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
6300 .patch = patch_alc662 },
6301 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
6302 { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
6303 { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
6304 { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
6305 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
6306 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
6307 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
6308 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
6309 .patch = patch_alc882 },
6310 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
6311 .patch = patch_alc882 },
6312 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
6313 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
6314 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
6315 .patch = patch_alc882 },
6316 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
6317 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
6318 { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
6319 { .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
6323 MODULE_ALIAS("snd-hda-codec-id:10ec*");
6325 MODULE_LICENSE("GPL");
6326 MODULE_DESCRIPTION("Realtek HD-audio codec");
6328 static struct hda_codec_preset_list realtek_list = {
6329 .preset = snd_hda_preset_realtek,
6330 .owner = THIS_MODULE,
6333 static int __init patch_realtek_init(void)
6335 return snd_hda_add_codec_preset(&realtek_list);
6338 static void __exit patch_realtek_exit(void)
6340 snd_hda_delete_codec_preset(&realtek_list);
6343 module_init(patch_realtek_init)
6344 module_exit(patch_realtek_exit)