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"
37 /* unsol event tags */
38 #define ALC_FRONT_EVENT 0x01
39 #define ALC_DCVOL_EVENT 0x02
40 #define ALC_HP_EVENT 0x04
41 #define ALC_MIC_EVENT 0x08
44 #define GPIO_MASK 0x03
46 /* extra amp-initialization sequence types */
55 struct alc_customize_define {
57 unsigned char port_connectivity;
58 unsigned char check_sum;
59 unsigned char customization;
60 unsigned char external_amp;
61 unsigned int enable_pcbeep:1;
62 unsigned int platform_type:1;
64 unsigned int override:1;
65 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */
71 hda_nid_t pin; /* multi-io widget pin NID */
72 hda_nid_t dac; /* DAC to be connected */
73 unsigned int ctl_in; /* cached input-pin control value */
77 ALC_AUTOMUTE_PIN, /* change the pin control */
78 ALC_AUTOMUTE_AMP, /* mute/unmute the pin AMP */
79 ALC_AUTOMUTE_MIXER, /* mute/unmute mixer widget AMP */
82 #define MAX_VOL_NIDS 0x40
85 /* codec parameterization */
86 const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
87 unsigned int num_mixers;
88 const struct snd_kcontrol_new *cap_mixer; /* capture mixer */
89 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
91 const struct hda_verb *init_verbs[10]; /* initialization verbs
95 unsigned int num_init_verbs;
97 char stream_name_analog[32]; /* analog PCM stream */
98 const struct hda_pcm_stream *stream_analog_playback;
99 const struct hda_pcm_stream *stream_analog_capture;
100 const struct hda_pcm_stream *stream_analog_alt_playback;
101 const struct hda_pcm_stream *stream_analog_alt_capture;
103 char stream_name_digital[32]; /* digital PCM stream */
104 const struct hda_pcm_stream *stream_digital_playback;
105 const struct hda_pcm_stream *stream_digital_capture;
108 struct hda_multi_out multiout; /* playback set-up
109 * max_channels, dacs must be set
110 * dig_out_nid and hp_nid are optional
112 hda_nid_t alt_dac_nid;
113 hda_nid_t slave_dig_outs[3]; /* optional - for auto-parsing */
117 unsigned int num_adc_nids;
118 const hda_nid_t *adc_nids;
119 const hda_nid_t *capsrc_nids;
120 hda_nid_t dig_in_nid; /* digital-in NID; optional */
121 hda_nid_t mixer_nid; /* analog-mixer NID */
122 DECLARE_BITMAP(vol_ctls, MAX_VOL_NIDS << 1);
123 DECLARE_BITMAP(sw_ctls, MAX_VOL_NIDS << 1);
125 /* capture setup for dynamic dual-adc switch */
127 unsigned int cur_adc_stream_tag;
128 unsigned int cur_adc_format;
131 unsigned int num_mux_defs;
132 const struct hda_input_mux *input_mux;
133 unsigned int cur_mux[3];
134 hda_nid_t ext_mic_pin;
135 hda_nid_t dock_mic_pin;
136 hda_nid_t int_mic_pin;
139 const struct hda_channel_mode *channel_mode;
140 int num_channel_mode;
142 int const_channel_count;
143 int ext_channel_count;
145 /* PCM information */
146 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
148 /* dynamic controls, init_verbs and input_mux */
149 struct auto_pin_cfg autocfg;
150 struct alc_customize_define cdefine;
151 struct snd_array kctls;
152 struct hda_input_mux private_imux[3];
153 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
154 hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
155 hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
156 hda_nid_t imux_pins[HDA_MAX_NUM_INPUTS];
157 unsigned int dyn_adc_idx[HDA_MAX_NUM_INPUTS];
158 int int_mic_idx, ext_mic_idx, dock_mic_idx; /* for auto-mic */
161 void (*init_hook)(struct hda_codec *codec);
162 void (*unsol_event)(struct hda_codec *codec, unsigned int res);
163 #ifdef CONFIG_SND_HDA_POWER_SAVE
164 void (*power_hook)(struct hda_codec *codec);
166 void (*shutup)(struct hda_codec *codec);
167 void (*automute_hook)(struct hda_codec *codec);
169 /* for pin sensing */
170 unsigned int hp_jack_present:1;
171 unsigned int line_jack_present:1;
172 unsigned int master_mute:1;
173 unsigned int auto_mic:1;
174 unsigned int auto_mic_valid_imux:1; /* valid imux for auto-mic */
175 unsigned int automute_speaker:1; /* automute speaker outputs */
176 unsigned int automute_lo:1; /* automute LO outputs */
177 unsigned int detect_hp:1; /* Headphone detection enabled */
178 unsigned int detect_lo:1; /* Line-out detection enabled */
179 unsigned int automute_speaker_possible:1; /* there are speakers and either LO or HP */
180 unsigned int automute_lo_possible:1; /* there are line outs and HP */
181 unsigned int keep_vref_in_automute:1; /* Don't clear VREF in automute */
184 unsigned int no_analog :1; /* digital I/O only */
185 unsigned int dyn_adc_switch:1; /* switch ADCs (for ALC275) */
186 unsigned int single_input_src:1;
187 unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */
188 unsigned int parse_flags; /* passed to snd_hda_parse_pin_defcfg() */
190 /* auto-mute control */
192 hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];
195 int codec_variant; /* flag for other variants */
197 /* for virtual master */
198 hda_nid_t vmaster_nid;
199 #ifdef CONFIG_SND_HDA_POWER_SAVE
200 struct hda_loopback_check loopback;
205 unsigned int pll_coef_idx, pll_coef_bit;
210 const struct alc_fixup *fixup_list;
211 const char *fixup_name;
215 struct alc_multi_io multi_io[4];
218 struct snd_array bind_ctls;
221 #define ALC_MODEL_AUTO 0 /* common for all chips */
223 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
224 int dir, unsigned int bits)
228 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
229 if (query_amp_caps(codec, nid, dir) & bits)
234 #define nid_has_mute(codec, nid, dir) \
235 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
236 #define nid_has_volume(codec, nid, dir) \
237 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
242 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
243 struct snd_ctl_elem_info *uinfo)
245 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
246 struct alc_spec *spec = codec->spec;
247 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
248 if (mux_idx >= spec->num_mux_defs)
250 if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
252 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
255 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
256 struct snd_ctl_elem_value *ucontrol)
258 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
259 struct alc_spec *spec = codec->spec;
260 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
262 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
266 static bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
268 struct alc_spec *spec = codec->spec;
269 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
271 if (spec->cur_adc && spec->cur_adc != new_adc) {
272 /* stream is running, let's swap the current ADC */
273 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
274 spec->cur_adc = new_adc;
275 snd_hda_codec_setup_stream(codec, new_adc,
276 spec->cur_adc_stream_tag, 0,
277 spec->cur_adc_format);
283 static inline hda_nid_t get_capsrc(struct alc_spec *spec, int idx)
285 return spec->capsrc_nids ?
286 spec->capsrc_nids[idx] : spec->adc_nids[idx];
289 /* select the given imux item; either unmute exclusively or select the route */
290 static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
291 unsigned int idx, bool force)
293 struct alc_spec *spec = codec->spec;
294 const struct hda_input_mux *imux;
295 unsigned int mux_idx;
296 int i, type, num_conns;
299 mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
300 imux = &spec->input_mux[mux_idx];
301 if (!imux->num_items && mux_idx > 0)
302 imux = &spec->input_mux[0];
303 if (!imux->num_items)
306 if (idx >= imux->num_items)
307 idx = imux->num_items - 1;
308 if (spec->cur_mux[adc_idx] == idx && !force)
310 spec->cur_mux[adc_idx] = idx;
312 if (spec->dyn_adc_switch) {
313 alc_dyn_adc_pcm_resetup(codec, idx);
314 adc_idx = spec->dyn_adc_idx[idx];
317 nid = get_capsrc(spec, adc_idx);
320 num_conns = snd_hda_get_conn_list(codec, nid, NULL);
324 type = get_wcaps_type(get_wcaps(codec, nid));
325 if (type == AC_WID_AUD_MIX) {
326 /* Matrix-mixer style (e.g. ALC882) */
327 int active = imux->items[idx].index;
328 for (i = 0; i < num_conns; i++) {
329 unsigned int v = (i == active) ? 0 : HDA_AMP_MUTE;
330 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, i,
334 /* MUX style (e.g. ALC880) */
335 snd_hda_codec_write_cache(codec, nid, 0,
336 AC_VERB_SET_CONNECT_SEL,
337 imux->items[idx].index);
342 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
343 struct snd_ctl_elem_value *ucontrol)
345 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
346 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
347 return alc_mux_select(codec, adc_idx,
348 ucontrol->value.enumerated.item[0], false);
352 * set up the input pin config (depending on the given auto-pin type)
354 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
357 unsigned int val = PIN_IN;
359 if (auto_pin_type == AUTO_PIN_MIC) {
362 oldval = snd_hda_codec_read(codec, nid, 0,
363 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
364 pincap = snd_hda_query_pin_caps(codec, nid);
365 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
366 /* if the default pin setup is vref50, we give it priority */
367 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
369 else if (pincap & AC_PINCAP_VREF_50)
371 else if (pincap & AC_PINCAP_VREF_100)
373 else if (pincap & AC_PINCAP_VREF_GRD)
376 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
380 * Append the given mixer and verb elements for the later use
381 * The mixer array is referred in build_controls(), and init_verbs are
384 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
386 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
388 spec->mixers[spec->num_mixers++] = mix;
391 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
393 if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
395 spec->init_verbs[spec->num_init_verbs++] = verb;
399 * GPIO setup tables, used in initialization
401 /* Enable GPIO mask and set output */
402 static const struct hda_verb alc_gpio1_init_verbs[] = {
403 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
404 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
405 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
409 static const struct hda_verb alc_gpio2_init_verbs[] = {
410 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
411 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
412 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
416 static const struct hda_verb alc_gpio3_init_verbs[] = {
417 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
418 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
419 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
424 * Fix hardware PLL issue
425 * On some codecs, the analog PLL gating control must be off while
426 * the default value is 1.
428 static void alc_fix_pll(struct hda_codec *codec)
430 struct alc_spec *spec = codec->spec;
435 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
437 val = snd_hda_codec_read(codec, spec->pll_nid, 0,
438 AC_VERB_GET_PROC_COEF, 0);
439 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
441 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
442 val & ~(1 << spec->pll_coef_bit));
445 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
446 unsigned int coef_idx, unsigned int coef_bit)
448 struct alc_spec *spec = codec->spec;
450 spec->pll_coef_idx = coef_idx;
451 spec->pll_coef_bit = coef_bit;
456 * Jack-reporting via input-jack layer
459 /* initialization of jacks; currently checks only a few known pins */
460 static int alc_init_jacks(struct hda_codec *codec)
462 #ifdef CONFIG_SND_HDA_INPUT_JACK
463 struct alc_spec *spec = codec->spec;
465 unsigned int hp_nid = spec->autocfg.hp_pins[0];
466 unsigned int mic_nid = spec->ext_mic_pin;
467 unsigned int dock_nid = spec->dock_mic_pin;
470 err = snd_hda_input_jack_add(codec, hp_nid,
471 SND_JACK_HEADPHONE, NULL);
474 snd_hda_input_jack_report(codec, hp_nid);
478 err = snd_hda_input_jack_add(codec, mic_nid,
479 SND_JACK_MICROPHONE, NULL);
482 snd_hda_input_jack_report(codec, mic_nid);
485 err = snd_hda_input_jack_add(codec, dock_nid,
486 SND_JACK_MICROPHONE, NULL);
489 snd_hda_input_jack_report(codec, dock_nid);
491 #endif /* CONFIG_SND_HDA_INPUT_JACK */
496 * Jack detections for HP auto-mute and mic-switch
499 /* check each pin in the given array; returns true if any of them is plugged */
500 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
504 for (i = 0; i < num_pins; i++) {
505 hda_nid_t nid = pins[i];
508 snd_hda_input_jack_report(codec, nid);
509 present |= snd_hda_jack_detect(codec, nid);
514 /* standard HP/line-out auto-mute helper */
515 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
516 bool mute, bool hp_out)
518 struct alc_spec *spec = codec->spec;
519 unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;
520 unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
523 for (i = 0; i < num_pins; i++) {
524 hda_nid_t nid = pins[i];
528 switch (spec->automute_mode) {
529 case ALC_AUTOMUTE_PIN:
530 /* don't reset VREF value in case it's controlling
531 * the amp (see alc861_fixup_asus_amp_vref_0f())
533 if (spec->keep_vref_in_automute) {
534 val = snd_hda_codec_read(codec, nid, 0,
535 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
540 snd_hda_codec_write(codec, nid, 0,
541 AC_VERB_SET_PIN_WIDGET_CONTROL,
544 case ALC_AUTOMUTE_AMP:
545 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
546 HDA_AMP_MUTE, mute_bits);
548 case ALC_AUTOMUTE_MIXER:
549 nid = spec->automute_mixer_nid[i];
552 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
553 HDA_AMP_MUTE, mute_bits);
554 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,
555 HDA_AMP_MUTE, mute_bits);
561 /* Toggle outputs muting */
562 static void update_outputs(struct hda_codec *codec)
564 struct alc_spec *spec = codec->spec;
567 /* Control HP pins/amps depending on master_mute state;
568 * in general, HP pins/amps control should be enabled in all cases,
569 * but currently set only for master_mute, just to be safe
571 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
572 spec->autocfg.hp_pins, spec->master_mute, true);
574 if (!spec->automute_speaker)
577 on = spec->hp_jack_present | spec->line_jack_present;
578 on |= spec->master_mute;
579 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
580 spec->autocfg.speaker_pins, on, false);
582 /* toggle line-out mutes if needed, too */
583 /* if LO is a copy of either HP or Speaker, don't need to handle it */
584 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
585 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
587 if (!spec->automute_lo)
590 on = spec->hp_jack_present;
591 on |= spec->master_mute;
592 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
593 spec->autocfg.line_out_pins, on, false);
596 static void call_update_outputs(struct hda_codec *codec)
598 struct alc_spec *spec = codec->spec;
599 if (spec->automute_hook)
600 spec->automute_hook(codec);
602 update_outputs(codec);
605 /* standard HP-automute helper */
606 static void alc_hp_automute(struct hda_codec *codec)
608 struct alc_spec *spec = codec->spec;
610 spec->hp_jack_present =
611 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
612 spec->autocfg.hp_pins);
613 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
615 call_update_outputs(codec);
618 /* standard line-out-automute helper */
619 static void alc_line_automute(struct hda_codec *codec)
621 struct alc_spec *spec = codec->spec;
623 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
625 /* check LO jack only when it's different from HP */
626 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
629 spec->line_jack_present =
630 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
631 spec->autocfg.line_out_pins);
632 if (!spec->automute_speaker || !spec->detect_lo)
634 call_update_outputs(codec);
637 #define get_connection_index(codec, mux, nid) \
638 snd_hda_get_conn_index(codec, mux, nid, 0)
640 /* standard mic auto-switch helper */
641 static void alc_mic_automute(struct hda_codec *codec)
643 struct alc_spec *spec = codec->spec;
644 hda_nid_t *pins = spec->imux_pins;
646 if (!spec->auto_mic || !spec->auto_mic_valid_imux)
648 if (snd_BUG_ON(!spec->adc_nids))
650 if (snd_BUG_ON(spec->int_mic_idx < 0 || spec->ext_mic_idx < 0))
653 if (snd_hda_jack_detect(codec, pins[spec->ext_mic_idx]))
654 alc_mux_select(codec, 0, spec->ext_mic_idx, false);
655 else if (spec->dock_mic_idx >= 0 &&
656 snd_hda_jack_detect(codec, pins[spec->dock_mic_idx]))
657 alc_mux_select(codec, 0, spec->dock_mic_idx, false);
659 alc_mux_select(codec, 0, spec->int_mic_idx, false);
661 snd_hda_input_jack_report(codec, pins[spec->ext_mic_idx]);
662 if (spec->dock_mic_idx >= 0)
663 snd_hda_input_jack_report(codec, pins[spec->dock_mic_idx]);
666 /* unsolicited event for HP jack sensing */
667 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
669 if (codec->vendor_id == 0x10ec0880)
675 alc_hp_automute(codec);
677 case ALC_FRONT_EVENT:
678 alc_line_automute(codec);
681 alc_mic_automute(codec);
686 /* call init functions of standard auto-mute helpers */
687 static void alc_inithook(struct hda_codec *codec)
689 alc_hp_automute(codec);
690 alc_line_automute(codec);
691 alc_mic_automute(codec);
694 /* additional initialization for ALC888 variants */
695 static void alc888_coef_init(struct hda_codec *codec)
699 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
700 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
701 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
702 if ((tmp & 0xf0) == 0x20)
704 snd_hda_codec_read(codec, 0x20, 0,
705 AC_VERB_SET_PROC_COEF, 0x830);
708 snd_hda_codec_read(codec, 0x20, 0,
709 AC_VERB_SET_PROC_COEF, 0x3030);
712 /* additional initialization for ALC889 variants */
713 static void alc889_coef_init(struct hda_codec *codec)
717 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
718 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
719 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
720 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
723 /* turn on/off EAPD control (only if available) */
724 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
726 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
728 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
729 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
733 /* turn on/off EAPD controls of the codec */
734 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
736 /* We currently only handle front, HP */
737 static hda_nid_t pins[] = {
738 0x0f, 0x10, 0x14, 0x15, 0
741 for (p = pins; *p; p++)
742 set_eapd(codec, *p, on);
745 /* generic shutup callback;
746 * just turning off EPAD and a little pause for avoiding pop-noise
748 static void alc_eapd_shutup(struct hda_codec *codec)
750 alc_auto_setup_eapd(codec, false);
754 /* generic EAPD initialization */
755 static void alc_auto_init_amp(struct hda_codec *codec, int type)
759 alc_auto_setup_eapd(codec, true);
762 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
765 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
768 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
770 case ALC_INIT_DEFAULT:
771 switch (codec->vendor_id) {
773 snd_hda_codec_write(codec, 0x1a, 0,
774 AC_VERB_SET_COEF_INDEX, 7);
775 tmp = snd_hda_codec_read(codec, 0x1a, 0,
776 AC_VERB_GET_PROC_COEF, 0);
777 snd_hda_codec_write(codec, 0x1a, 0,
778 AC_VERB_SET_COEF_INDEX, 7);
779 snd_hda_codec_write(codec, 0x1a, 0,
780 AC_VERB_SET_PROC_COEF,
789 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
790 alc889_coef_init(codec);
793 alc888_coef_init(codec);
795 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
798 snd_hda_codec_write(codec, 0x20, 0,
799 AC_VERB_SET_COEF_INDEX, 7);
800 tmp = snd_hda_codec_read(codec, 0x20, 0,
801 AC_VERB_GET_PROC_COEF, 0);
802 snd_hda_codec_write(codec, 0x20, 0,
803 AC_VERB_SET_COEF_INDEX, 7);
804 snd_hda_codec_write(codec, 0x20, 0,
805 AC_VERB_SET_PROC_COEF,
815 * Auto-Mute mode mixer enum support
817 static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
818 struct snd_ctl_elem_info *uinfo)
820 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
821 struct alc_spec *spec = codec->spec;
822 static const char * const texts2[] = {
823 "Disabled", "Enabled"
825 static const char * const texts3[] = {
826 "Disabled", "Speaker Only", "Line-Out+Speaker"
828 const char * const *texts;
830 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
832 if (spec->automute_speaker_possible && spec->automute_lo_possible) {
833 uinfo->value.enumerated.items = 3;
836 uinfo->value.enumerated.items = 2;
839 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
840 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
841 strcpy(uinfo->value.enumerated.name,
842 texts[uinfo->value.enumerated.item]);
846 static int alc_automute_mode_get(struct snd_kcontrol *kcontrol,
847 struct snd_ctl_elem_value *ucontrol)
849 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
850 struct alc_spec *spec = codec->spec;
851 unsigned int val = 0;
852 if (spec->automute_speaker)
854 if (spec->automute_lo)
857 ucontrol->value.enumerated.item[0] = val;
861 static int alc_automute_mode_put(struct snd_kcontrol *kcontrol,
862 struct snd_ctl_elem_value *ucontrol)
864 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
865 struct alc_spec *spec = codec->spec;
867 switch (ucontrol->value.enumerated.item[0]) {
869 if (!spec->automute_speaker && !spec->automute_lo)
871 spec->automute_speaker = 0;
872 spec->automute_lo = 0;
875 if (spec->automute_speaker_possible) {
876 if (!spec->automute_lo && spec->automute_speaker)
878 spec->automute_speaker = 1;
879 spec->automute_lo = 0;
880 } else if (spec->automute_lo_possible) {
881 if (spec->automute_lo)
883 spec->automute_lo = 1;
888 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
890 if (spec->automute_speaker && spec->automute_lo)
892 spec->automute_speaker = 1;
893 spec->automute_lo = 1;
898 call_update_outputs(codec);
902 static const struct snd_kcontrol_new alc_automute_mode_enum = {
903 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
904 .name = "Auto-Mute Mode",
905 .info = alc_automute_mode_info,
906 .get = alc_automute_mode_get,
907 .put = alc_automute_mode_put,
910 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
912 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
913 return snd_array_new(&spec->kctls);
916 static int alc_add_automute_mode_enum(struct hda_codec *codec)
918 struct alc_spec *spec = codec->spec;
919 struct snd_kcontrol_new *knew;
921 knew = alc_kcontrol_new(spec);
924 *knew = alc_automute_mode_enum;
925 knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
932 * Check the availability of HP/line-out auto-mute;
933 * Set up appropriately if really supported
935 static void alc_init_automute(struct hda_codec *codec)
937 struct alc_spec *spec = codec->spec;
938 struct auto_pin_cfg *cfg = &spec->autocfg;
944 if (cfg->line_out_pins[0])
946 if (cfg->speaker_pins[0])
948 if (present < 2) /* need two different output types */
951 if (!cfg->speaker_pins[0] &&
952 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
953 memcpy(cfg->speaker_pins, cfg->line_out_pins,
954 sizeof(cfg->speaker_pins));
955 cfg->speaker_outs = cfg->line_outs;
958 if (!cfg->hp_pins[0] &&
959 cfg->line_out_type == AUTO_PIN_HP_OUT) {
960 memcpy(cfg->hp_pins, cfg->line_out_pins,
961 sizeof(cfg->hp_pins));
962 cfg->hp_outs = cfg->line_outs;
965 spec->automute_mode = ALC_AUTOMUTE_PIN;
967 for (i = 0; i < cfg->hp_outs; i++) {
968 hda_nid_t nid = cfg->hp_pins[i];
969 if (!is_jack_detectable(codec, nid))
971 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
973 snd_hda_codec_write_cache(codec, nid, 0,
974 AC_VERB_SET_UNSOLICITED_ENABLE,
975 AC_USRSP_EN | ALC_HP_EVENT);
979 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
980 if (cfg->speaker_outs)
981 for (i = 0; i < cfg->line_outs; i++) {
982 hda_nid_t nid = cfg->line_out_pins[i];
983 if (!is_jack_detectable(codec, nid))
985 snd_printdd("realtek: Enable Line-Out "
986 "auto-muting on NID 0x%x\n", nid);
987 snd_hda_codec_write_cache(codec, nid, 0,
988 AC_VERB_SET_UNSOLICITED_ENABLE,
989 AC_USRSP_EN | ALC_FRONT_EVENT);
992 spec->automute_lo_possible = spec->detect_hp;
995 spec->automute_speaker_possible = cfg->speaker_outs &&
996 (spec->detect_hp || spec->detect_lo);
998 spec->automute_lo = spec->automute_lo_possible;
999 spec->automute_speaker = spec->automute_speaker_possible;
1001 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
1002 /* create a control for automute mode */
1003 alc_add_automute_mode_enum(codec);
1004 spec->unsol_event = alc_sku_unsol_event;
1008 /* return the position of NID in the list, or -1 if not found */
1009 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1012 for (i = 0; i < nums; i++)
1018 /* check whether dynamic ADC-switching is available */
1019 static bool alc_check_dyn_adc_switch(struct hda_codec *codec)
1021 struct alc_spec *spec = codec->spec;
1022 struct hda_input_mux *imux = &spec->private_imux[0];
1026 if (imux != spec->input_mux) /* no dynamic imux? */
1029 for (n = 0; n < spec->num_adc_nids; n++) {
1030 cap = spec->private_capsrc_nids[n];
1031 for (i = 0; i < imux->num_items; i++) {
1032 pin = spec->imux_pins[i];
1035 if (get_connection_index(codec, cap, pin) < 0)
1038 if (i >= imux->num_items)
1039 return true; /* no ADC-switch is needed */
1042 for (i = 0; i < imux->num_items; i++) {
1043 pin = spec->imux_pins[i];
1044 for (n = 0; n < spec->num_adc_nids; n++) {
1045 cap = spec->private_capsrc_nids[n];
1046 idx = get_connection_index(codec, cap, pin);
1048 imux->items[i].index = idx;
1049 spec->dyn_adc_idx[i] = n;
1055 snd_printdd("realtek: enabling ADC switching\n");
1056 spec->dyn_adc_switch = 1;
1060 /* rebuild imux for matching with the given auto-mic pins (if not yet) */
1061 static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec)
1063 struct alc_spec *spec = codec->spec;
1064 struct hda_input_mux *imux;
1065 static char * const texts[3] = {
1066 "Mic", "Internal Mic", "Dock Mic"
1070 if (!spec->auto_mic)
1072 imux = &spec->private_imux[0];
1073 if (spec->input_mux == imux)
1075 spec->imux_pins[0] = spec->ext_mic_pin;
1076 spec->imux_pins[1] = spec->int_mic_pin;
1077 spec->imux_pins[2] = spec->dock_mic_pin;
1078 for (i = 0; i < 3; i++) {
1079 strcpy(imux->items[i].label, texts[i]);
1080 if (spec->imux_pins[i]) {
1081 hda_nid_t pin = spec->imux_pins[i];
1083 for (c = 0; c < spec->num_adc_nids; c++) {
1084 hda_nid_t cap = get_capsrc(spec, c);
1085 int idx = get_connection_index(codec, cap, pin);
1087 imux->items[i].index = idx;
1091 imux->num_items = i + 1;
1094 spec->num_mux_defs = 1;
1095 spec->input_mux = imux;
1099 /* check whether all auto-mic pins are valid; setup indices if OK */
1100 static bool alc_auto_mic_check_imux(struct hda_codec *codec)
1102 struct alc_spec *spec = codec->spec;
1103 const struct hda_input_mux *imux;
1105 if (!spec->auto_mic)
1107 if (spec->auto_mic_valid_imux)
1108 return true; /* already checked */
1110 /* fill up imux indices */
1111 if (!alc_check_dyn_adc_switch(codec)) {
1116 imux = spec->input_mux;
1117 spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin,
1118 spec->imux_pins, imux->num_items);
1119 spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin,
1120 spec->imux_pins, imux->num_items);
1121 spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin,
1122 spec->imux_pins, imux->num_items);
1123 if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) {
1125 return false; /* no corresponding imux */
1128 snd_hda_codec_write_cache(codec, spec->ext_mic_pin, 0,
1129 AC_VERB_SET_UNSOLICITED_ENABLE,
1130 AC_USRSP_EN | ALC_MIC_EVENT);
1131 if (spec->dock_mic_pin)
1132 snd_hda_codec_write_cache(codec, spec->dock_mic_pin, 0,
1133 AC_VERB_SET_UNSOLICITED_ENABLE,
1134 AC_USRSP_EN | ALC_MIC_EVENT);
1136 spec->auto_mic_valid_imux = 1;
1142 * Check the availability of auto-mic switch;
1143 * Set up if really supported
1145 static void alc_init_auto_mic(struct hda_codec *codec)
1147 struct alc_spec *spec = codec->spec;
1148 struct auto_pin_cfg *cfg = &spec->autocfg;
1149 hda_nid_t fixed, ext, dock;
1152 spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1;
1154 fixed = ext = dock = 0;
1155 for (i = 0; i < cfg->num_inputs; i++) {
1156 hda_nid_t nid = cfg->inputs[i].pin;
1157 unsigned int defcfg;
1158 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1159 switch (snd_hda_get_input_pin_attr(defcfg)) {
1160 case INPUT_PIN_ATTR_INT:
1162 return; /* already occupied */
1163 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1164 return; /* invalid type */
1167 case INPUT_PIN_ATTR_UNUSED:
1168 return; /* invalid entry */
1169 case INPUT_PIN_ATTR_DOCK:
1171 return; /* already occupied */
1172 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
1173 return; /* invalid type */
1178 return; /* already occupied */
1179 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1180 return; /* invalid type */
1191 if (!is_jack_detectable(codec, ext))
1192 return; /* no unsol support */
1193 if (dock && !is_jack_detectable(codec, dock))
1194 return; /* no unsol support */
1196 /* check imux indices */
1197 spec->ext_mic_pin = ext;
1198 spec->int_mic_pin = fixed;
1199 spec->dock_mic_pin = dock;
1202 if (!alc_auto_mic_check_imux(codec))
1205 snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1207 spec->unsol_event = alc_sku_unsol_event;
1210 /* check the availabilities of auto-mute and auto-mic switches */
1211 static void alc_auto_check_switches(struct hda_codec *codec)
1213 alc_init_automute(codec);
1214 alc_init_auto_mic(codec);
1218 * Realtek SSID verification
1221 /* Could be any non-zero and even value. When used as fixup, tells
1222 * the driver to ignore any present sku defines.
1224 #define ALC_FIXUP_SKU_IGNORE (2)
1226 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1228 unsigned int ass, tmp, i;
1230 struct alc_spec *spec = codec->spec;
1232 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1234 if (spec->cdefine.fixup) {
1235 ass = spec->cdefine.sku_cfg;
1236 if (ass == ALC_FIXUP_SKU_IGNORE)
1241 ass = codec->subsystem_id & 0xffff;
1242 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1246 if (codec->vendor_id == 0x10ec0260)
1248 ass = snd_hda_codec_get_pincfg(codec, nid);
1251 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1252 codec->chip_name, ass);
1258 for (i = 1; i < 16; i++) {
1262 if (((ass >> 16) & 0xf) != tmp)
1265 spec->cdefine.port_connectivity = ass >> 30;
1266 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1267 spec->cdefine.check_sum = (ass >> 16) & 0xf;
1268 spec->cdefine.customization = ass >> 8;
1270 spec->cdefine.sku_cfg = ass;
1271 spec->cdefine.external_amp = (ass & 0x38) >> 3;
1272 spec->cdefine.platform_type = (ass & 0x4) >> 2;
1273 spec->cdefine.swap = (ass & 0x2) >> 1;
1274 spec->cdefine.override = ass & 0x1;
1276 snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1277 nid, spec->cdefine.sku_cfg);
1278 snd_printd("SKU: port_connectivity=0x%x\n",
1279 spec->cdefine.port_connectivity);
1280 snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1281 snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1282 snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1283 snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1284 snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1285 snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1286 snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1291 /* return true if the given NID is found in the list */
1292 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1294 return find_idx_in_nid_list(nid, list, nums) >= 0;
1297 /* check subsystem ID and set up device-specific initialization;
1298 * return 1 if initialized, 0 if invalid SSID
1300 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1301 * 31 ~ 16 : Manufacture ID
1303 * 7 ~ 0 : Assembly ID
1304 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1306 static int alc_subsystem_id(struct hda_codec *codec,
1307 hda_nid_t porta, hda_nid_t porte,
1308 hda_nid_t portd, hda_nid_t porti)
1310 unsigned int ass, tmp, i;
1312 struct alc_spec *spec = codec->spec;
1314 if (spec->cdefine.fixup) {
1315 ass = spec->cdefine.sku_cfg;
1316 if (ass == ALC_FIXUP_SKU_IGNORE)
1321 ass = codec->subsystem_id & 0xffff;
1322 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1325 /* invalid SSID, check the special NID pin defcfg instead */
1327 * 31~30 : port connectivity
1330 * 19~16 : Check sum (15:1)
1335 if (codec->vendor_id == 0x10ec0260)
1337 ass = snd_hda_codec_get_pincfg(codec, nid);
1338 snd_printd("realtek: No valid SSID, "
1339 "checking pincfg 0x%08x for NID 0x%x\n",
1343 if ((ass >> 30) != 1) /* no physical connection */
1348 for (i = 1; i < 16; i++) {
1352 if (((ass >> 16) & 0xf) != tmp)
1355 snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1356 ass & 0xffff, codec->vendor_id);
1360 * 2 : 0 --> Desktop, 1 --> Laptop
1361 * 3~5 : External Amplifier control
1364 tmp = (ass & 0x38) >> 3; /* external Amp control */
1367 spec->init_amp = ALC_INIT_GPIO1;
1370 spec->init_amp = ALC_INIT_GPIO2;
1373 spec->init_amp = ALC_INIT_GPIO3;
1377 spec->init_amp = ALC_INIT_DEFAULT;
1381 /* is laptop or Desktop and enable the function "Mute internal speaker
1382 * when the external headphone out jack is plugged"
1384 if (!(ass & 0x8000))
1387 * 10~8 : Jack location
1388 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1390 * 15 : 1 --> enable the function "Mute internal speaker
1391 * when the external headphone out jack is plugged"
1393 if (!spec->autocfg.hp_pins[0] &&
1394 !(spec->autocfg.line_out_pins[0] &&
1395 spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
1397 tmp = (ass >> 11) & 0x3; /* HP to chassis */
1408 if (found_in_nid_list(nid, spec->autocfg.line_out_pins,
1409 spec->autocfg.line_outs))
1411 spec->autocfg.hp_pins[0] = nid;
1416 /* Check the validity of ALC subsystem-id
1417 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
1418 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
1420 if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {
1421 struct alc_spec *spec = codec->spec;
1422 snd_printd("realtek: "
1423 "Enable default setup for auto mode as fallback\n");
1424 spec->init_amp = ALC_INIT_DEFAULT;
1429 * Fix-up pin default configurations and add default verbs
1437 struct alc_model_fixup {
1448 const struct alc_pincfg *pins;
1449 const struct hda_verb *verbs;
1450 void (*func)(struct hda_codec *codec,
1451 const struct alc_fixup *fix,
1465 ALC_FIXUP_ACT_PRE_PROBE,
1466 ALC_FIXUP_ACT_PROBE,
1470 static void alc_apply_fixup(struct hda_codec *codec, int action)
1472 struct alc_spec *spec = codec->spec;
1473 int id = spec->fixup_id;
1474 #ifdef CONFIG_SND_DEBUG_VERBOSE
1475 const char *modelname = spec->fixup_name;
1479 if (!spec->fixup_list)
1483 const struct alc_fixup *fix = spec->fixup_list + id;
1484 const struct alc_pincfg *cfg;
1486 switch (fix->type) {
1488 if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1490 snd_printdd(KERN_INFO "hda_codec: %s: "
1491 "Apply sku override for %s\n",
1492 codec->chip_name, modelname);
1493 spec->cdefine.sku_cfg = fix->v.sku;
1494 spec->cdefine.fixup = 1;
1496 case ALC_FIXUP_PINS:
1498 if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1500 snd_printdd(KERN_INFO "hda_codec: %s: "
1501 "Apply pincfg for %s\n",
1502 codec->chip_name, modelname);
1503 for (; cfg->nid; cfg++)
1504 snd_hda_codec_set_pincfg(codec, cfg->nid,
1507 case ALC_FIXUP_VERBS:
1508 if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1510 snd_printdd(KERN_INFO "hda_codec: %s: "
1511 "Apply fix-verbs for %s\n",
1512 codec->chip_name, modelname);
1513 add_verb(codec->spec, fix->v.verbs);
1515 case ALC_FIXUP_FUNC:
1518 snd_printdd(KERN_INFO "hda_codec: %s: "
1519 "Apply fix-func for %s\n",
1520 codec->chip_name, modelname);
1521 fix->v.func(codec, fix, action);
1524 snd_printk(KERN_ERR "hda_codec: %s: "
1525 "Invalid fixup type %d\n",
1526 codec->chip_name, fix->type);
1537 static void alc_pick_fixup(struct hda_codec *codec,
1538 const struct alc_model_fixup *models,
1539 const struct snd_pci_quirk *quirk,
1540 const struct alc_fixup *fixlist)
1542 struct alc_spec *spec = codec->spec;
1544 const char *name = NULL;
1546 if (codec->modelname && models) {
1547 while (models->name) {
1548 if (!strcmp(codec->modelname, models->name)) {
1550 name = models->name;
1557 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1560 #ifdef CONFIG_SND_DEBUG_VERBOSE
1566 spec->fixup_id = id;
1568 spec->fixup_list = fixlist;
1569 spec->fixup_name = name;
1574 * COEF access helper functions
1576 static int alc_read_coef_idx(struct hda_codec *codec,
1577 unsigned int coef_idx)
1580 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1582 val = snd_hda_codec_read(codec, 0x20, 0,
1583 AC_VERB_GET_PROC_COEF, 0);
1587 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1588 unsigned int coef_val)
1590 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1592 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1596 /* a special bypass for COEF 0; read the cached value at the second time */
1597 static unsigned int alc_get_coef0(struct hda_codec *codec)
1599 struct alc_spec *spec = codec->spec;
1601 spec->coef0 = alc_read_coef_idx(codec, 0);
1606 * Digital I/O handling
1609 /* set right pin controls for digital I/O */
1610 static void alc_auto_init_digital(struct hda_codec *codec)
1612 struct alc_spec *spec = codec->spec;
1616 for (i = 0; i < spec->autocfg.dig_outs; i++) {
1617 pin = spec->autocfg.dig_out_pins[i];
1620 snd_hda_codec_write(codec, pin, 0,
1621 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
1623 dac = spec->multiout.dig_out_nid;
1625 dac = spec->slave_dig_outs[i - 1];
1626 if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
1628 snd_hda_codec_write(codec, dac, 0,
1629 AC_VERB_SET_AMP_GAIN_MUTE,
1632 pin = spec->autocfg.dig_in_pin;
1634 snd_hda_codec_write(codec, pin, 0,
1635 AC_VERB_SET_PIN_WIDGET_CONTROL,
1639 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1640 static void alc_auto_parse_digital(struct hda_codec *codec)
1642 struct alc_spec *spec = codec->spec;
1646 /* support multiple SPDIFs; the secondary is set up as a slave */
1648 for (i = 0; i < spec->autocfg.dig_outs; i++) {
1650 err = snd_hda_get_connections(codec,
1651 spec->autocfg.dig_out_pins[i],
1652 conn, ARRAY_SIZE(conn));
1655 dig_nid = conn[0]; /* assume the first element is audio-out */
1657 spec->multiout.dig_out_nid = dig_nid;
1658 spec->dig_out_type = spec->autocfg.dig_out_type[0];
1660 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1661 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1663 spec->slave_dig_outs[nums - 1] = dig_nid;
1668 if (spec->autocfg.dig_in_pin) {
1669 dig_nid = codec->start_nid;
1670 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1671 unsigned int wcaps = get_wcaps(codec, dig_nid);
1672 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1674 if (!(wcaps & AC_WCAP_DIGITAL))
1676 if (!(wcaps & AC_WCAP_CONN_LIST))
1678 err = get_connection_index(codec, dig_nid,
1679 spec->autocfg.dig_in_pin);
1681 spec->dig_in_nid = dig_nid;
1689 * capture mixer elements
1691 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1692 struct snd_ctl_elem_info *uinfo)
1694 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1695 struct alc_spec *spec = codec->spec;
1699 mutex_lock(&codec->control_mutex);
1700 if (spec->vol_in_capsrc)
1701 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1703 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1704 kcontrol->private_value = val;
1705 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1706 mutex_unlock(&codec->control_mutex);
1710 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1711 unsigned int size, unsigned int __user *tlv)
1713 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1714 struct alc_spec *spec = codec->spec;
1718 mutex_lock(&codec->control_mutex);
1719 if (spec->vol_in_capsrc)
1720 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1722 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1723 kcontrol->private_value = val;
1724 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1725 mutex_unlock(&codec->control_mutex);
1729 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1730 struct snd_ctl_elem_value *ucontrol);
1732 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1733 struct snd_ctl_elem_value *ucontrol,
1734 getput_call_t func, bool check_adc_switch)
1736 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1737 struct alc_spec *spec = codec->spec;
1740 mutex_lock(&codec->control_mutex);
1741 if (check_adc_switch && spec->dyn_adc_switch) {
1742 for (i = 0; i < spec->num_adc_nids; i++) {
1743 kcontrol->private_value =
1744 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1746 err = func(kcontrol, ucontrol);
1751 i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1752 if (spec->vol_in_capsrc)
1753 kcontrol->private_value =
1754 HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i],
1757 kcontrol->private_value =
1758 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1760 err = func(kcontrol, ucontrol);
1763 mutex_unlock(&codec->control_mutex);
1767 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1768 struct snd_ctl_elem_value *ucontrol)
1770 return alc_cap_getput_caller(kcontrol, ucontrol,
1771 snd_hda_mixer_amp_volume_get, false);
1774 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1775 struct snd_ctl_elem_value *ucontrol)
1777 return alc_cap_getput_caller(kcontrol, ucontrol,
1778 snd_hda_mixer_amp_volume_put, true);
1781 /* capture mixer elements */
1782 #define alc_cap_sw_info snd_ctl_boolean_stereo_info
1784 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1785 struct snd_ctl_elem_value *ucontrol)
1787 return alc_cap_getput_caller(kcontrol, ucontrol,
1788 snd_hda_mixer_amp_switch_get, false);
1791 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1792 struct snd_ctl_elem_value *ucontrol)
1794 return alc_cap_getput_caller(kcontrol, ucontrol,
1795 snd_hda_mixer_amp_switch_put, true);
1798 #define _DEFINE_CAPMIX(num) \
1800 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1801 .name = "Capture Switch", \
1802 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1804 .info = alc_cap_sw_info, \
1805 .get = alc_cap_sw_get, \
1806 .put = alc_cap_sw_put, \
1809 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1810 .name = "Capture Volume", \
1811 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1812 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1813 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1815 .info = alc_cap_vol_info, \
1816 .get = alc_cap_vol_get, \
1817 .put = alc_cap_vol_put, \
1818 .tlv = { .c = alc_cap_vol_tlv }, \
1821 #define _DEFINE_CAPSRC(num) \
1823 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1824 /* .name = "Capture Source", */ \
1825 .name = "Input Source", \
1827 .info = alc_mux_enum_info, \
1828 .get = alc_mux_enum_get, \
1829 .put = alc_mux_enum_put, \
1832 #define DEFINE_CAPMIX(num) \
1833 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1834 _DEFINE_CAPMIX(num), \
1835 _DEFINE_CAPSRC(num), \
1839 #define DEFINE_CAPMIX_NOSRC(num) \
1840 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1841 _DEFINE_CAPMIX(num), \
1845 /* up to three ADCs */
1849 DEFINE_CAPMIX_NOSRC(1);
1850 DEFINE_CAPMIX_NOSRC(2);
1851 DEFINE_CAPMIX_NOSRC(3);
1854 * virtual master controls
1858 * slave controls for virtual master
1860 static const char * const alc_slave_vols[] = {
1861 "Front Playback Volume",
1862 "Surround Playback Volume",
1863 "Center Playback Volume",
1864 "LFE Playback Volume",
1865 "Side Playback Volume",
1866 "Headphone Playback Volume",
1867 "Speaker Playback Volume",
1868 "Mono Playback Volume",
1869 "Line-Out Playback Volume",
1870 "PCM Playback Volume",
1874 static const char * const alc_slave_sws[] = {
1875 "Front Playback Switch",
1876 "Surround Playback Switch",
1877 "Center Playback Switch",
1878 "LFE Playback Switch",
1879 "Side Playback Switch",
1880 "Headphone Playback Switch",
1881 "Speaker Playback Switch",
1882 "Mono Playback Switch",
1883 "IEC958 Playback Switch",
1884 "Line-Out Playback Switch",
1885 "PCM Playback Switch",
1890 * build control elements
1893 #define NID_MAPPING (-1)
1895 #define SUBDEV_SPEAKER_ (0 << 6)
1896 #define SUBDEV_HP_ (1 << 6)
1897 #define SUBDEV_LINE_ (2 << 6)
1898 #define SUBDEV_SPEAKER(x) (SUBDEV_SPEAKER_ | ((x) & 0x3f))
1899 #define SUBDEV_HP(x) (SUBDEV_HP_ | ((x) & 0x3f))
1900 #define SUBDEV_LINE(x) (SUBDEV_LINE_ | ((x) & 0x3f))
1902 static void alc_free_kctls(struct hda_codec *codec);
1904 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1905 /* additional beep mixers; the actual parameters are overwritten at build */
1906 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1907 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1908 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1913 static int alc_build_controls(struct hda_codec *codec)
1915 struct alc_spec *spec = codec->spec;
1916 struct snd_kcontrol *kctl = NULL;
1917 const struct snd_kcontrol_new *knew;
1922 for (i = 0; i < spec->num_mixers; i++) {
1923 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1927 if (spec->cap_mixer) {
1928 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
1932 if (spec->multiout.dig_out_nid) {
1933 err = snd_hda_create_spdif_out_ctls(codec,
1934 spec->multiout.dig_out_nid,
1935 spec->multiout.dig_out_nid);
1938 if (!spec->no_analog) {
1939 err = snd_hda_create_spdif_share_sw(codec,
1943 spec->multiout.share_spdif = 1;
1946 if (spec->dig_in_nid) {
1947 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1952 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1953 /* create beep controls if needed */
1954 if (spec->beep_amp) {
1955 const struct snd_kcontrol_new *knew;
1956 for (knew = alc_beep_mixer; knew->name; knew++) {
1957 struct snd_kcontrol *kctl;
1958 kctl = snd_ctl_new1(knew, codec);
1961 kctl->private_value = spec->beep_amp;
1962 err = snd_hda_ctl_add(codec, 0, kctl);
1969 /* if we have no master control, let's create it */
1970 if (!spec->no_analog &&
1971 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1972 unsigned int vmaster_tlv[4];
1973 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1974 HDA_OUTPUT, vmaster_tlv);
1975 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1976 vmaster_tlv, alc_slave_vols);
1980 if (!spec->no_analog &&
1981 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1982 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1983 NULL, alc_slave_sws);
1988 /* assign Capture Source enums to NID */
1989 if (spec->capsrc_nids || spec->adc_nids) {
1990 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
1992 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1993 for (i = 0; kctl && i < kctl->count; i++) {
1994 err = snd_hda_add_nid(codec, kctl, i,
1995 get_capsrc(spec, i));
2000 if (spec->cap_mixer && spec->adc_nids) {
2001 const char *kname = kctl ? kctl->id.name : NULL;
2002 for (knew = spec->cap_mixer; knew->name; knew++) {
2003 if (kname && strcmp(knew->name, kname) == 0)
2005 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2006 for (i = 0; kctl && i < kctl->count; i++) {
2007 err = snd_hda_add_nid(codec, kctl, i,
2015 /* other nid->control mapping */
2016 for (i = 0; i < spec->num_mixers; i++) {
2017 for (knew = spec->mixers[i]; knew->name; knew++) {
2018 if (knew->iface != NID_MAPPING)
2020 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2023 u = knew->subdevice;
2024 for (j = 0; j < 4; j++, u >>= 8) {
2029 case SUBDEV_SPEAKER_:
2030 nid = spec->autocfg.speaker_pins[nid];
2033 nid = spec->autocfg.line_out_pins[nid];
2036 nid = spec->autocfg.hp_pins[nid];
2041 err = snd_hda_add_nid(codec, kctl, 0, nid);
2045 u = knew->private_value;
2046 for (j = 0; j < 4; j++, u >>= 8) {
2050 err = snd_hda_add_nid(codec, kctl, 0, nid);
2057 alc_free_kctls(codec); /* no longer needed */
2067 static void alc_init_special_input_src(struct hda_codec *codec);
2068 static int alc269_fill_coef(struct hda_codec *codec);
2070 static int alc_init(struct hda_codec *codec)
2072 struct alc_spec *spec = codec->spec;
2075 if (codec->vendor_id == 0x10ec0269)
2076 alc269_fill_coef(codec);
2079 alc_auto_init_amp(codec, spec->init_amp);
2081 for (i = 0; i < spec->num_init_verbs; i++)
2082 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2083 alc_init_special_input_src(codec);
2085 if (spec->init_hook)
2086 spec->init_hook(codec);
2088 alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
2090 hda_call_check_power_status(codec, 0x01);
2094 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2096 struct alc_spec *spec = codec->spec;
2098 if (spec->unsol_event)
2099 spec->unsol_event(codec, res);
2102 #ifdef CONFIG_SND_HDA_POWER_SAVE
2103 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2105 struct alc_spec *spec = codec->spec;
2106 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2111 * Analog playback callbacks
2113 static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo,
2114 struct hda_codec *codec,
2115 struct snd_pcm_substream *substream)
2117 struct alc_spec *spec = codec->spec;
2118 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2122 static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2123 struct hda_codec *codec,
2124 unsigned int stream_tag,
2125 unsigned int format,
2126 struct snd_pcm_substream *substream)
2128 struct alc_spec *spec = codec->spec;
2129 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2130 stream_tag, format, substream);
2133 static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2134 struct hda_codec *codec,
2135 struct snd_pcm_substream *substream)
2137 struct alc_spec *spec = codec->spec;
2138 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2144 static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2145 struct hda_codec *codec,
2146 struct snd_pcm_substream *substream)
2148 struct alc_spec *spec = codec->spec;
2149 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2152 static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2153 struct hda_codec *codec,
2154 unsigned int stream_tag,
2155 unsigned int format,
2156 struct snd_pcm_substream *substream)
2158 struct alc_spec *spec = codec->spec;
2159 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2160 stream_tag, format, substream);
2163 static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2164 struct hda_codec *codec,
2165 struct snd_pcm_substream *substream)
2167 struct alc_spec *spec = codec->spec;
2168 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2171 static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2172 struct hda_codec *codec,
2173 struct snd_pcm_substream *substream)
2175 struct alc_spec *spec = codec->spec;
2176 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2182 static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2183 struct hda_codec *codec,
2184 unsigned int stream_tag,
2185 unsigned int format,
2186 struct snd_pcm_substream *substream)
2188 struct alc_spec *spec = codec->spec;
2190 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2191 stream_tag, 0, format);
2195 static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2196 struct hda_codec *codec,
2197 struct snd_pcm_substream *substream)
2199 struct alc_spec *spec = codec->spec;
2201 snd_hda_codec_cleanup_stream(codec,
2202 spec->adc_nids[substream->number + 1]);
2206 /* analog capture with dynamic dual-adc changes */
2207 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2208 struct hda_codec *codec,
2209 unsigned int stream_tag,
2210 unsigned int format,
2211 struct snd_pcm_substream *substream)
2213 struct alc_spec *spec = codec->spec;
2214 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
2215 spec->cur_adc_stream_tag = stream_tag;
2216 spec->cur_adc_format = format;
2217 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
2221 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2222 struct hda_codec *codec,
2223 struct snd_pcm_substream *substream)
2225 struct alc_spec *spec = codec->spec;
2226 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
2231 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
2235 .nid = 0, /* fill later */
2237 .prepare = dyn_adc_capture_pcm_prepare,
2238 .cleanup = dyn_adc_capture_pcm_cleanup
2244 static const struct hda_pcm_stream alc_pcm_analog_playback = {
2248 /* NID is set in alc_build_pcms */
2250 .open = alc_playback_pcm_open,
2251 .prepare = alc_playback_pcm_prepare,
2252 .cleanup = alc_playback_pcm_cleanup
2256 static const struct hda_pcm_stream alc_pcm_analog_capture = {
2260 /* NID is set in alc_build_pcms */
2263 static const struct hda_pcm_stream alc_pcm_analog_alt_playback = {
2267 /* NID is set in alc_build_pcms */
2270 static const struct hda_pcm_stream alc_pcm_analog_alt_capture = {
2271 .substreams = 2, /* can be overridden */
2274 /* NID is set in alc_build_pcms */
2276 .prepare = alc_alt_capture_pcm_prepare,
2277 .cleanup = alc_alt_capture_pcm_cleanup
2281 static const struct hda_pcm_stream alc_pcm_digital_playback = {
2285 /* NID is set in alc_build_pcms */
2287 .open = alc_dig_playback_pcm_open,
2288 .close = alc_dig_playback_pcm_close,
2289 .prepare = alc_dig_playback_pcm_prepare,
2290 .cleanup = alc_dig_playback_pcm_cleanup
2294 static const struct hda_pcm_stream alc_pcm_digital_capture = {
2298 /* NID is set in alc_build_pcms */
2301 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2302 static const struct hda_pcm_stream alc_pcm_null_stream = {
2308 static int alc_build_pcms(struct hda_codec *codec)
2310 struct alc_spec *spec = codec->spec;
2311 struct hda_pcm *info = spec->pcm_rec;
2312 const struct hda_pcm_stream *p;
2313 bool have_multi_adcs;
2316 codec->num_pcms = 1;
2317 codec->pcm_info = info;
2319 if (spec->no_analog)
2322 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
2323 "%s Analog", codec->chip_name);
2324 info->name = spec->stream_name_analog;
2326 if (spec->multiout.dac_nids > 0) {
2327 p = spec->stream_analog_playback;
2329 p = &alc_pcm_analog_playback;
2330 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2331 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2333 if (spec->adc_nids) {
2334 p = spec->stream_analog_capture;
2336 if (spec->dyn_adc_switch)
2337 p = &dyn_adc_pcm_analog_capture;
2339 p = &alc_pcm_analog_capture;
2341 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2342 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2345 if (spec->channel_mode) {
2346 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2347 for (i = 0; i < spec->num_channel_mode; i++) {
2348 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2349 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2355 /* SPDIF for stream index #1 */
2356 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2357 snprintf(spec->stream_name_digital,
2358 sizeof(spec->stream_name_digital),
2359 "%s Digital", codec->chip_name);
2360 codec->num_pcms = 2;
2361 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
2362 info = spec->pcm_rec + 1;
2363 info->name = spec->stream_name_digital;
2364 if (spec->dig_out_type)
2365 info->pcm_type = spec->dig_out_type;
2367 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2368 if (spec->multiout.dig_out_nid) {
2369 p = spec->stream_digital_playback;
2371 p = &alc_pcm_digital_playback;
2372 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2373 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2375 if (spec->dig_in_nid) {
2376 p = spec->stream_digital_capture;
2378 p = &alc_pcm_digital_capture;
2379 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2380 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2382 /* FIXME: do we need this for all Realtek codec models? */
2383 codec->spdif_status_reset = 1;
2386 if (spec->no_analog)
2389 /* If the use of more than one ADC is requested for the current
2390 * model, configure a second analog capture-only PCM.
2392 have_multi_adcs = (spec->num_adc_nids > 1) &&
2393 !spec->dyn_adc_switch && !spec->auto_mic &&
2394 (!spec->input_mux || spec->input_mux->num_items > 1);
2395 /* Additional Analaog capture for index #2 */
2396 if (spec->alt_dac_nid || have_multi_adcs) {
2397 codec->num_pcms = 3;
2398 info = spec->pcm_rec + 2;
2399 info->name = spec->stream_name_analog;
2400 if (spec->alt_dac_nid) {
2401 p = spec->stream_analog_alt_playback;
2403 p = &alc_pcm_analog_alt_playback;
2404 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2405 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2408 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2409 alc_pcm_null_stream;
2410 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2412 if (have_multi_adcs) {
2413 p = spec->stream_analog_alt_capture;
2415 p = &alc_pcm_analog_alt_capture;
2416 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2417 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2419 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2420 spec->num_adc_nids - 1;
2422 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2423 alc_pcm_null_stream;
2424 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2431 static inline void alc_shutup(struct hda_codec *codec)
2433 struct alc_spec *spec = codec->spec;
2435 if (spec && spec->shutup)
2436 spec->shutup(codec);
2437 snd_hda_shutup_pins(codec);
2440 static void alc_free_kctls(struct hda_codec *codec)
2442 struct alc_spec *spec = codec->spec;
2444 if (spec->kctls.list) {
2445 struct snd_kcontrol_new *kctl = spec->kctls.list;
2447 for (i = 0; i < spec->kctls.used; i++)
2448 kfree(kctl[i].name);
2450 snd_array_free(&spec->kctls);
2453 static void alc_free_bind_ctls(struct hda_codec *codec)
2455 struct alc_spec *spec = codec->spec;
2456 if (spec->bind_ctls.list) {
2457 struct hda_bind_ctls **ctl = spec->bind_ctls.list;
2459 for (i = 0; i < spec->bind_ctls.used; i++)
2462 snd_array_free(&spec->bind_ctls);
2465 static void alc_free(struct hda_codec *codec)
2467 struct alc_spec *spec = codec->spec;
2473 snd_hda_input_jack_free(codec);
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 (ch >= ARRAY_SIZE(channel_name)) {
2673 return channel_name[ch];
2676 /* create input playback/capture controls for the given pin */
2677 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
2678 const char *ctlname, int ctlidx,
2679 int idx, hda_nid_t mix_nid)
2683 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
2684 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2687 err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
2688 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2694 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2696 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2697 return (pincap & AC_PINCAP_IN) != 0;
2700 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
2701 static int alc_auto_fill_adc_caps(struct hda_codec *codec)
2703 struct alc_spec *spec = codec->spec;
2705 hda_nid_t *adc_nids = spec->private_adc_nids;
2706 hda_nid_t *cap_nids = spec->private_capsrc_nids;
2707 int max_nums = ARRAY_SIZE(spec->private_adc_nids);
2710 nid = codec->start_nid;
2711 for (i = 0; i < codec->num_nodes; i++, nid++) {
2713 const hda_nid_t *list;
2714 unsigned int caps = get_wcaps(codec, nid);
2715 int type = get_wcaps_type(caps);
2717 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2719 adc_nids[nums] = nid;
2720 cap_nids[nums] = nid;
2724 type = get_wcaps_type(get_wcaps(codec, src));
2725 if (type == AC_WID_PIN)
2727 if (type == AC_WID_AUD_SEL) {
2728 cap_nids[nums] = src;
2731 n = snd_hda_get_conn_list(codec, src, &list);
2733 cap_nids[nums] = src;
2739 if (++nums >= max_nums)
2742 spec->adc_nids = spec->private_adc_nids;
2743 spec->capsrc_nids = spec->private_capsrc_nids;
2744 spec->num_adc_nids = nums;
2748 /* create playback/capture controls for input pins */
2749 static int alc_auto_create_input_ctls(struct hda_codec *codec)
2751 struct alc_spec *spec = codec->spec;
2752 const struct auto_pin_cfg *cfg = &spec->autocfg;
2753 hda_nid_t mixer = spec->mixer_nid;
2754 struct hda_input_mux *imux = &spec->private_imux[0];
2756 int i, c, err, idx, type_idx = 0;
2757 const char *prev_label = NULL;
2759 num_adcs = alc_auto_fill_adc_caps(codec);
2763 for (i = 0; i < cfg->num_inputs; i++) {
2767 pin = cfg->inputs[i].pin;
2768 if (!alc_is_input_pin(codec, pin))
2771 label = hda_get_autocfg_input_label(codec, cfg, i);
2772 if (prev_label && !strcmp(label, prev_label))
2779 idx = get_connection_index(codec, mixer, pin);
2781 err = new_analog_input(spec, pin,
2789 for (c = 0; c < num_adcs; c++) {
2790 hda_nid_t cap = get_capsrc(spec, c);
2791 idx = get_connection_index(codec, cap, pin);
2793 spec->imux_pins[imux->num_items] = pin;
2794 snd_hda_add_imux_item(imux, label, idx, NULL);
2800 spec->num_mux_defs = 1;
2801 spec->input_mux = imux;
2806 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
2807 unsigned int pin_type)
2809 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2812 if (nid_has_mute(codec, nid, HDA_OUTPUT))
2813 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2817 static int get_pin_type(int line_out_type)
2819 if (line_out_type == AUTO_PIN_HP_OUT)
2825 static void alc_auto_init_analog_input(struct hda_codec *codec)
2827 struct alc_spec *spec = codec->spec;
2828 struct auto_pin_cfg *cfg = &spec->autocfg;
2831 for (i = 0; i < cfg->num_inputs; i++) {
2832 hda_nid_t nid = cfg->inputs[i].pin;
2833 if (alc_is_input_pin(codec, nid)) {
2834 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
2835 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
2836 snd_hda_codec_write(codec, nid, 0,
2837 AC_VERB_SET_AMP_GAIN_MUTE,
2842 /* mute all loopback inputs */
2843 if (spec->mixer_nid) {
2844 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL);
2845 for (i = 0; i < nums; i++)
2846 snd_hda_codec_write(codec, spec->mixer_nid, 0,
2847 AC_VERB_SET_AMP_GAIN_MUTE,
2852 /* convert from MIX nid to DAC */
2853 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
2858 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT)
2860 num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
2861 for (i = 0; i < num; i++) {
2862 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
2868 /* go down to the selector widget before the mixer */
2869 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
2872 int num = snd_hda_get_connections(codec, pin, srcs,
2875 get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
2880 /* get MIX nid connected to the given pin targeted to DAC */
2881 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
2887 pin = alc_go_down_to_selector(codec, pin);
2888 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2889 for (i = 0; i < num; i++) {
2890 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
2896 /* select the connection from pin to DAC if needed */
2897 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
2903 pin = alc_go_down_to_selector(codec, pin);
2904 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2907 for (i = 0; i < num; i++) {
2908 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
2909 snd_hda_codec_update_cache(codec, pin, 0,
2910 AC_VERB_SET_CONNECT_SEL, i);
2917 /* look for an empty DAC slot */
2918 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
2920 struct alc_spec *spec = codec->spec;
2924 pin = alc_go_down_to_selector(codec, pin);
2925 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2926 for (i = 0; i < num; i++) {
2927 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2930 if (found_in_nid_list(nid, spec->multiout.dac_nids,
2931 ARRAY_SIZE(spec->private_dac_nids)))
2933 if (found_in_nid_list(nid, spec->multiout.hp_out_nid,
2934 ARRAY_SIZE(spec->multiout.hp_out_nid)))
2936 if (found_in_nid_list(nid, spec->multiout.extra_out_nid,
2937 ARRAY_SIZE(spec->multiout.extra_out_nid)))
2944 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
2946 hda_nid_t sel = alc_go_down_to_selector(codec, pin);
2947 if (snd_hda_get_conn_list(codec, sel, NULL) == 1)
2948 return alc_auto_look_for_dac(codec, pin);
2952 /* return 0 if no possible DAC is found, 1 if one or more found */
2953 static int alc_auto_fill_extra_dacs(struct hda_codec *codec, int num_outs,
2954 const hda_nid_t *pins, hda_nid_t *dacs)
2958 if (num_outs && !dacs[0]) {
2959 dacs[0] = alc_auto_look_for_dac(codec, pins[0]);
2964 for (i = 1; i < num_outs; i++)
2965 dacs[i] = get_dac_if_single(codec, pins[i]);
2966 for (i = 1; i < num_outs; i++) {
2968 dacs[i] = alc_auto_look_for_dac(codec, pins[i]);
2973 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
2974 unsigned int location);
2976 /* fill in the dac_nids table from the parsed pin configuration */
2977 static int alc_auto_fill_dac_nids(struct hda_codec *codec)
2979 struct alc_spec *spec = codec->spec;
2980 struct auto_pin_cfg *cfg = &spec->autocfg;
2981 bool redone = false;
2985 /* set num_dacs once to full for alc_auto_look_for_dac() */
2986 spec->multiout.num_dacs = cfg->line_outs;
2987 spec->multiout.hp_out_nid[0] = 0;
2988 spec->multiout.extra_out_nid[0] = 0;
2989 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
2990 spec->multiout.dac_nids = spec->private_dac_nids;
2991 spec->multi_ios = 0;
2993 /* fill hard-wired DACs first */
2995 for (i = 0; i < cfg->line_outs; i++)
2996 spec->private_dac_nids[i] =
2997 get_dac_if_single(codec, cfg->line_out_pins[i]);
2999 spec->multiout.hp_out_nid[0] =
3000 get_dac_if_single(codec, cfg->hp_pins[0]);
3001 if (cfg->speaker_outs)
3002 spec->multiout.extra_out_nid[0] =
3003 get_dac_if_single(codec, cfg->speaker_pins[0]);
3006 for (i = 0; i < cfg->line_outs; i++) {
3007 hda_nid_t pin = cfg->line_out_pins[i];
3008 if (spec->private_dac_nids[i])
3010 spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin);
3011 if (!spec->private_dac_nids[i] && !redone) {
3012 /* if we can't find primary DACs, re-probe without
3013 * checking the hard-wired DACs
3020 /* re-count num_dacs and squash invalid entries */
3021 spec->multiout.num_dacs = 0;
3022 for (i = 0; i < cfg->line_outs; i++) {
3023 if (spec->private_dac_nids[i])
3024 spec->multiout.num_dacs++;
3026 memmove(spec->private_dac_nids + i,
3027 spec->private_dac_nids + i + 1,
3028 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
3029 spec->private_dac_nids[cfg->line_outs - 1] = 0;
3033 if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3034 /* try to fill multi-io first */
3035 unsigned int location, defcfg;
3038 defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
3039 location = get_defcfg_location(defcfg);
3041 num_pins = alc_auto_fill_multi_ios(codec, location);
3043 spec->multi_ios = num_pins;
3044 spec->ext_channel_count = 2;
3045 spec->multiout.num_dacs = num_pins + 1;
3049 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
3050 alc_auto_fill_extra_dacs(codec, cfg->hp_outs, cfg->hp_pins,
3051 spec->multiout.hp_out_nid);
3052 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3053 int err = alc_auto_fill_extra_dacs(codec, cfg->speaker_outs,
3055 spec->multiout.extra_out_nid);
3056 /* if no speaker volume is assigned, try again as the primary
3059 if (!err && cfg->speaker_outs > 0 &&
3060 cfg->line_out_type == AUTO_PIN_HP_OUT) {
3061 cfg->hp_outs = cfg->line_outs;
3062 memcpy(cfg->hp_pins, cfg->line_out_pins,
3063 sizeof(cfg->hp_pins));
3064 cfg->line_outs = cfg->speaker_outs;
3065 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3066 sizeof(cfg->speaker_pins));
3067 cfg->speaker_outs = 0;
3068 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3069 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3078 static inline unsigned int get_ctl_pos(unsigned int data)
3080 hda_nid_t nid = get_amp_nid_(data);
3082 if (snd_BUG_ON(nid >= MAX_VOL_NIDS))
3084 dir = get_amp_direction_(data);
3085 return (nid << 1) | dir;
3088 #define is_ctl_used(bits, data) \
3089 test_bit(get_ctl_pos(data), bits)
3090 #define mark_ctl_usage(bits, data) \
3091 set_bit(get_ctl_pos(data), bits)
3093 static int alc_auto_add_vol_ctl(struct hda_codec *codec,
3094 const char *pfx, int cidx,
3095 hda_nid_t nid, unsigned int chs)
3097 struct alc_spec *spec = codec->spec;
3101 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3102 if (is_ctl_used(spec->vol_ctls, val) && chs != 2) /* exclude LFE */
3104 mark_ctl_usage(spec->vol_ctls, val);
3105 return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx,
3109 #define alc_auto_add_stereo_vol(codec, pfx, cidx, nid) \
3110 alc_auto_add_vol_ctl(codec, pfx, cidx, nid, 3)
3112 /* create a mute-switch for the given mixer widget;
3113 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
3115 static int alc_auto_add_sw_ctl(struct hda_codec *codec,
3116 const char *pfx, int cidx,
3117 hda_nid_t nid, unsigned int chs)
3119 struct alc_spec *spec = codec->spec;
3125 wid_type = get_wcaps_type(get_wcaps(codec, nid));
3126 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) {
3127 type = ALC_CTL_WIDGET_MUTE;
3128 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3129 } else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) {
3130 type = ALC_CTL_WIDGET_MUTE;
3131 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT);
3133 type = ALC_CTL_BIND_MUTE;
3134 val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT);
3136 if (is_ctl_used(spec->sw_ctls, val) && chs != 2) /* exclude LFE */
3138 mark_ctl_usage(spec->sw_ctls, val);
3139 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
3142 #define alc_auto_add_stereo_sw(codec, pfx, cidx, nid) \
3143 alc_auto_add_sw_ctl(codec, pfx, cidx, nid, 3)
3145 static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec,
3146 hda_nid_t pin, hda_nid_t dac)
3148 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3149 if (nid_has_mute(codec, pin, HDA_OUTPUT))
3151 else if (mix && nid_has_mute(codec, mix, HDA_INPUT))
3153 else if (nid_has_mute(codec, dac, HDA_OUTPUT))
3158 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
3159 hda_nid_t pin, hda_nid_t dac)
3161 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3162 if (nid_has_volume(codec, dac, HDA_OUTPUT))
3164 else if (nid_has_volume(codec, mix, HDA_OUTPUT))
3166 else if (nid_has_volume(codec, pin, HDA_OUTPUT))
3171 /* add playback controls from the parsed DAC table */
3172 static int alc_auto_create_multi_out_ctls(struct hda_codec *codec,
3173 const struct auto_pin_cfg *cfg)
3175 struct alc_spec *spec = codec->spec;
3176 int i, err, noutputs;
3178 noutputs = cfg->line_outs;
3179 if (spec->multi_ios > 0)
3180 noutputs += spec->multi_ios;
3182 for (i = 0; i < noutputs; i++) {
3188 dac = spec->multiout.dac_nids[i];
3191 if (i >= cfg->line_outs)
3192 pin = spec->multi_io[i - 1].pin;
3194 pin = cfg->line_out_pins[i];
3196 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3197 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3198 name = alc_get_line_out_pfx(spec, i, true, &index);
3199 if (!name || !strcmp(name, "CLFE")) {
3201 err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1);
3204 err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2);
3207 err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1);
3210 err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2);
3214 err = alc_auto_add_stereo_vol(codec, name, index, vol);
3217 err = alc_auto_add_stereo_sw(codec, name, index, sw);
3225 static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
3226 hda_nid_t dac, const char *pfx,
3229 struct alc_spec *spec = codec->spec;
3235 /* the corresponding DAC is already occupied */
3236 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
3237 return 0; /* no way */
3238 /* create a switch only */
3239 val = HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT);
3240 if (is_ctl_used(spec->sw_ctls, val))
3241 return 0; /* already created */
3242 mark_ctl_usage(spec->sw_ctls, val);
3243 return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, cidx, val);
3246 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3247 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3248 err = alc_auto_add_stereo_vol(codec, pfx, cidx, vol);
3251 err = alc_auto_add_stereo_sw(codec, pfx, cidx, sw);
3257 static struct hda_bind_ctls *new_bind_ctl(struct hda_codec *codec,
3259 struct hda_ctl_ops *ops)
3261 struct alc_spec *spec = codec->spec;
3262 struct hda_bind_ctls **ctlp, *ctl;
3263 snd_array_init(&spec->bind_ctls, sizeof(ctl), 8);
3264 ctlp = snd_array_new(&spec->bind_ctls);
3267 ctl = kzalloc(sizeof(*ctl) + sizeof(long) * (nums + 1), GFP_KERNEL);
3274 /* add playback controls for speaker and HP outputs */
3275 static int alc_auto_create_extra_outs(struct hda_codec *codec, int num_pins,
3276 const hda_nid_t *pins,
3277 const hda_nid_t *dacs,
3280 struct alc_spec *spec = codec->spec;
3281 struct hda_bind_ctls *ctl;
3285 if (!num_pins || !pins[0])
3288 if (num_pins == 1) {
3289 hda_nid_t dac = *dacs;
3291 dac = spec->multiout.dac_nids[0];
3292 return alc_auto_create_extra_out(codec, *pins, dac, pfx, 0);
3295 if (dacs[num_pins - 1]) {
3296 /* OK, we have a multi-output system with individual volumes */
3297 for (i = 0; i < num_pins; i++) {
3298 if (num_pins >= 3) {
3299 snprintf(name, sizeof(name), "%s %s",
3300 pfx, channel_name[i]);
3301 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3304 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3313 /* Let's create a bind-controls */
3314 ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_sw);
3318 for (i = 0; i < num_pins; i++) {
3319 if (get_wcaps(codec, pins[i]) & AC_WCAP_OUT_AMP)
3321 HDA_COMPOSE_AMP_VAL(pins[i], 3, 0, HDA_OUTPUT);
3324 snprintf(name, sizeof(name), "%s Playback Switch", pfx);
3325 err = add_control(spec, ALC_CTL_BIND_SW, name, 0, (long)ctl);
3330 ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_vol);
3334 for (i = 0; i < num_pins; i++) {
3336 if (!pins[i] || !dacs[i])
3338 vol = alc_look_for_out_vol_nid(codec, pins[i], dacs[i]);
3341 HDA_COMPOSE_AMP_VAL(vol, 3, 0, HDA_OUTPUT);
3344 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
3345 err = add_control(spec, ALC_CTL_BIND_VOL, name, 0, (long)ctl);
3352 static int alc_auto_create_hp_out(struct hda_codec *codec)
3354 struct alc_spec *spec = codec->spec;
3355 return alc_auto_create_extra_outs(codec, spec->autocfg.hp_outs,
3356 spec->autocfg.hp_pins,
3357 spec->multiout.hp_out_nid,
3361 static int alc_auto_create_speaker_out(struct hda_codec *codec)
3363 struct alc_spec *spec = codec->spec;
3364 return alc_auto_create_extra_outs(codec, spec->autocfg.speaker_outs,
3365 spec->autocfg.speaker_pins,
3366 spec->multiout.extra_out_nid,
3370 static void alc_auto_set_output_and_unmute(struct hda_codec *codec,
3371 hda_nid_t pin, int pin_type,
3375 hda_nid_t nid, mix = 0;
3376 hda_nid_t srcs[HDA_MAX_CONNECTIONS];
3378 alc_set_pin_output(codec, pin, pin_type);
3379 nid = alc_go_down_to_selector(codec, pin);
3380 num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
3381 for (i = 0; i < num; i++) {
3382 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
3390 /* need the manual connection? */
3392 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
3393 /* unmute mixer widget inputs */
3394 if (nid_has_mute(codec, mix, HDA_INPUT)) {
3395 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3397 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3400 /* initialize volume */
3401 nid = alc_look_for_out_vol_nid(codec, pin, dac);
3403 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3406 /* unmute DAC if it's not assigned to a mixer */
3407 nid = alc_look_for_out_mute_nid(codec, pin, dac);
3408 if (nid == mix && nid_has_mute(codec, dac, HDA_OUTPUT))
3409 snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3413 static void alc_auto_init_multi_out(struct hda_codec *codec)
3415 struct alc_spec *spec = codec->spec;
3416 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3419 for (i = 0; i <= HDA_SIDE; i++) {
3420 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3422 alc_auto_set_output_and_unmute(codec, nid, pin_type,
3423 spec->multiout.dac_nids[i]);
3427 static void alc_auto_init_extra_out(struct hda_codec *codec)
3429 struct alc_spec *spec = codec->spec;
3433 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3434 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
3436 pin = spec->autocfg.hp_pins[i];
3439 dac = spec->multiout.hp_out_nid[i];
3441 if (i > 0 && spec->multiout.hp_out_nid[0])
3442 dac = spec->multiout.hp_out_nid[0];
3444 dac = spec->multiout.dac_nids[0];
3446 alc_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
3448 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3449 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3451 pin = spec->autocfg.speaker_pins[i];
3454 dac = spec->multiout.extra_out_nid[i];
3456 if (i > 0 && spec->multiout.extra_out_nid[0])
3457 dac = spec->multiout.extra_out_nid[0];
3459 dac = spec->multiout.dac_nids[0];
3461 alc_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
3468 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
3469 unsigned int location)
3471 struct alc_spec *spec = codec->spec;
3472 struct auto_pin_cfg *cfg = &spec->autocfg;
3473 hda_nid_t prime_dac = spec->private_dac_nids[0];
3474 int type, i, num_pins = 0;
3476 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
3477 for (i = 0; i < cfg->num_inputs; i++) {
3478 hda_nid_t nid = cfg->inputs[i].pin;
3480 unsigned int defcfg, caps;
3481 if (cfg->inputs[i].type != type)
3483 defcfg = snd_hda_codec_get_pincfg(codec, nid);
3484 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
3486 if (location && get_defcfg_location(defcfg) != location)
3488 caps = snd_hda_query_pin_caps(codec, nid);
3489 if (!(caps & AC_PINCAP_OUT))
3491 dac = alc_auto_look_for_dac(codec, nid);
3494 spec->multi_io[num_pins].pin = nid;
3495 spec->multi_io[num_pins].dac = dac;
3497 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
3500 spec->multiout.num_dacs = 1;
3502 /* clear up again */
3503 memset(spec->private_dac_nids, 0,
3504 sizeof(spec->private_dac_nids));
3505 spec->private_dac_nids[0] = prime_dac;
3511 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
3512 struct snd_ctl_elem_info *uinfo)
3514 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3515 struct alc_spec *spec = codec->spec;
3517 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3519 uinfo->value.enumerated.items = spec->multi_ios + 1;
3520 if (uinfo->value.enumerated.item > spec->multi_ios)
3521 uinfo->value.enumerated.item = spec->multi_ios;
3522 sprintf(uinfo->value.enumerated.name, "%dch",
3523 (uinfo->value.enumerated.item + 1) * 2);
3527 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
3528 struct snd_ctl_elem_value *ucontrol)
3530 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3531 struct alc_spec *spec = codec->spec;
3532 ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
3536 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
3538 struct alc_spec *spec = codec->spec;
3539 hda_nid_t nid = spec->multi_io[idx].pin;
3541 if (!spec->multi_io[idx].ctl_in)
3542 spec->multi_io[idx].ctl_in =
3543 snd_hda_codec_read(codec, nid, 0,
3544 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3546 snd_hda_codec_update_cache(codec, nid, 0,
3547 AC_VERB_SET_PIN_WIDGET_CONTROL,
3549 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3550 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3552 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
3554 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3555 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3556 HDA_AMP_MUTE, HDA_AMP_MUTE);
3557 snd_hda_codec_update_cache(codec, nid, 0,
3558 AC_VERB_SET_PIN_WIDGET_CONTROL,
3559 spec->multi_io[idx].ctl_in);
3564 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
3565 struct snd_ctl_elem_value *ucontrol)
3567 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3568 struct alc_spec *spec = codec->spec;
3571 ch = ucontrol->value.enumerated.item[0];
3572 if (ch < 0 || ch > spec->multi_ios)
3574 if (ch == (spec->ext_channel_count - 1) / 2)
3576 spec->ext_channel_count = (ch + 1) * 2;
3577 for (i = 0; i < spec->multi_ios; i++)
3578 alc_set_multi_io(codec, i, i < ch);
3579 spec->multiout.max_channels = spec->ext_channel_count;
3580 if (spec->need_dac_fix && !spec->const_channel_count)
3581 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
3585 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
3586 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3587 .name = "Channel Mode",
3588 .info = alc_auto_ch_mode_info,
3589 .get = alc_auto_ch_mode_get,
3590 .put = alc_auto_ch_mode_put,
3593 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec)
3595 struct alc_spec *spec = codec->spec;
3597 if (spec->multi_ios > 0) {
3598 struct snd_kcontrol_new *knew;
3600 knew = alc_kcontrol_new(spec);
3603 *knew = alc_auto_channel_mode_enum;
3604 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
3611 /* filter out invalid adc_nids (and capsrc_nids) that don't give all
3614 static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
3616 struct alc_spec *spec = codec->spec;
3617 const struct hda_input_mux *imux;
3618 hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3619 hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3622 imux = spec->input_mux;
3625 if (spec->dyn_adc_switch)
3629 for (n = 0; n < spec->num_adc_nids; n++) {
3630 hda_nid_t cap = spec->private_capsrc_nids[n];
3631 int num_conns = snd_hda_get_conn_list(codec, cap, NULL);
3632 for (i = 0; i < imux->num_items; i++) {
3633 hda_nid_t pin = spec->imux_pins[i];
3635 if (get_connection_index(codec, cap, pin) < 0)
3637 } else if (num_conns <= imux->items[i].index)
3640 if (i >= imux->num_items) {
3641 adc_nids[nums] = spec->private_adc_nids[n];
3642 capsrc_nids[nums++] = cap;
3646 /* check whether ADC-switch is possible */
3647 if (!alc_check_dyn_adc_switch(codec)) {
3648 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
3649 " using fallback 0x%x\n",
3650 codec->chip_name, spec->private_adc_nids[0]);
3651 spec->num_adc_nids = 1;
3655 } else if (nums != spec->num_adc_nids) {
3656 memcpy(spec->private_adc_nids, adc_nids,
3657 nums * sizeof(hda_nid_t));
3658 memcpy(spec->private_capsrc_nids, capsrc_nids,
3659 nums * sizeof(hda_nid_t));
3660 spec->num_adc_nids = nums;
3664 alc_auto_mic_check_imux(codec); /* check auto-mic setups */
3665 else if (spec->input_mux->num_items == 1)
3666 spec->num_adc_nids = 1; /* reduce to a single ADC */
3670 * initialize ADC paths
3672 static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx)
3674 struct alc_spec *spec = codec->spec;
3677 nid = spec->adc_nids[adc_idx];
3679 if (nid_has_mute(codec, nid, HDA_INPUT)) {
3680 snd_hda_codec_write(codec, nid, 0,
3681 AC_VERB_SET_AMP_GAIN_MUTE,
3685 if (!spec->capsrc_nids)
3687 nid = spec->capsrc_nids[adc_idx];
3688 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3689 snd_hda_codec_write(codec, nid, 0,
3690 AC_VERB_SET_AMP_GAIN_MUTE,
3694 static void alc_auto_init_input_src(struct hda_codec *codec)
3696 struct alc_spec *spec = codec->spec;
3699 for (c = 0; c < spec->num_adc_nids; c++)
3700 alc_auto_init_adc(codec, c);
3701 if (spec->dyn_adc_switch)
3704 nums = spec->num_adc_nids;
3705 for (c = 0; c < nums; c++)
3706 alc_mux_select(codec, c, spec->cur_mux[c], true);
3709 /* add mic boosts if needed */
3710 static int alc_auto_add_mic_boost(struct hda_codec *codec)
3712 struct alc_spec *spec = codec->spec;
3713 struct auto_pin_cfg *cfg = &spec->autocfg;
3717 const char *prev_label = NULL;
3719 for (i = 0; i < cfg->num_inputs; i++) {
3720 if (cfg->inputs[i].type > AUTO_PIN_MIC)
3722 nid = cfg->inputs[i].pin;
3723 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
3725 char boost_label[32];
3727 label = hda_get_autocfg_input_label(codec, cfg, i);
3728 if (prev_label && !strcmp(label, prev_label))
3734 snprintf(boost_label, sizeof(boost_label),
3735 "%s Boost Volume", label);
3736 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3737 boost_label, type_idx,
3738 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
3746 /* select or unmute the given capsrc route */
3747 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
3750 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
3751 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
3753 } else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) {
3754 snd_hda_codec_write_cache(codec, cap, 0,
3755 AC_VERB_SET_CONNECT_SEL, idx);
3759 /* set the default connection to that pin */
3760 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
3762 struct alc_spec *spec = codec->spec;
3767 for (i = 0; i < spec->num_adc_nids; i++) {
3768 hda_nid_t cap = get_capsrc(spec, i);
3771 idx = get_connection_index(codec, cap, pin);
3774 select_or_unmute_capsrc(codec, cap, idx);
3775 return i; /* return the found index */
3777 return -1; /* not found */
3780 /* initialize some special cases for input sources */
3781 static void alc_init_special_input_src(struct hda_codec *codec)
3783 struct alc_spec *spec = codec->spec;
3786 for (i = 0; i < spec->autocfg.num_inputs; i++)
3787 init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin);
3790 /* assign appropriate capture mixers */
3791 static void set_capture_mixer(struct hda_codec *codec)
3793 struct alc_spec *spec = codec->spec;
3794 static const struct snd_kcontrol_new *caps[2][3] = {
3795 { alc_capture_mixer_nosrc1,
3796 alc_capture_mixer_nosrc2,
3797 alc_capture_mixer_nosrc3 },
3798 { alc_capture_mixer1,
3800 alc_capture_mixer3 },
3803 /* check whether either of ADC or MUX has a volume control */
3804 if (!nid_has_volume(codec, spec->adc_nids[0], HDA_INPUT)) {
3805 if (!spec->capsrc_nids)
3806 return; /* no volume */
3807 if (!nid_has_volume(codec, spec->capsrc_nids[0], HDA_OUTPUT))
3808 return; /* no volume in capsrc, too */
3809 spec->vol_in_capsrc = 1;
3812 if (spec->num_adc_nids > 0) {
3816 if (spec->input_mux && spec->input_mux->num_items > 1)
3818 if (spec->auto_mic) {
3821 } else if (spec->dyn_adc_switch)
3824 if (spec->num_adc_nids > 3)
3825 spec->num_adc_nids = 3;
3826 else if (!spec->num_adc_nids)
3828 num_adcs = spec->num_adc_nids;
3830 spec->cap_mixer = caps[mux][num_adcs - 1];
3835 * standard auto-parser initializations
3837 static void alc_auto_init_std(struct hda_codec *codec)
3839 struct alc_spec *spec = codec->spec;
3840 alc_auto_init_multi_out(codec);
3841 alc_auto_init_extra_out(codec);
3842 alc_auto_init_analog_input(codec);
3843 alc_auto_init_input_src(codec);
3844 alc_auto_init_digital(codec);
3845 if (spec->unsol_event)
3846 alc_inithook(codec);
3850 * Digital-beep handlers
3852 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3853 #define set_beep_amp(spec, nid, idx, dir) \
3854 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
3856 static const struct snd_pci_quirk beep_white_list[] = {
3857 SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
3858 SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
3859 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
3860 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
3861 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
3862 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
3863 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
3867 static inline int has_cdefine_beep(struct hda_codec *codec)
3869 struct alc_spec *spec = codec->spec;
3870 const struct snd_pci_quirk *q;
3871 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
3874 return spec->cdefine.enable_pcbeep;
3877 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
3878 #define has_cdefine_beep(codec) 0
3881 /* parse the BIOS configuration and set up the alc_spec */
3882 /* return 1 if successful, 0 if the proper config is not found,
3883 * or a negative error code
3885 static int alc_parse_auto_config(struct hda_codec *codec,
3886 const hda_nid_t *ignore_nids,
3887 const hda_nid_t *ssid_nids)
3889 struct alc_spec *spec = codec->spec;
3890 struct auto_pin_cfg *cfg = &spec->autocfg;
3893 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
3897 if (!cfg->line_outs) {
3898 if (cfg->dig_outs || cfg->dig_in_pin) {
3899 spec->multiout.max_channels = 2;
3900 spec->no_analog = 1;
3903 return 0; /* can't find valid BIOS pin config */
3906 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3907 cfg->line_outs <= cfg->hp_outs) {
3908 /* use HP as primary out */
3909 cfg->speaker_outs = cfg->line_outs;
3910 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3911 sizeof(cfg->speaker_pins));
3912 cfg->line_outs = cfg->hp_outs;
3913 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
3915 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3916 cfg->line_out_type = AUTO_PIN_HP_OUT;
3919 err = alc_auto_fill_dac_nids(codec);
3922 err = alc_auto_add_multi_channel_mode(codec);
3925 err = alc_auto_create_multi_out_ctls(codec, cfg);
3928 err = alc_auto_create_hp_out(codec);
3931 err = alc_auto_create_speaker_out(codec);
3934 err = alc_auto_create_input_ctls(codec);
3938 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3941 alc_auto_parse_digital(codec);
3943 if (!spec->no_analog)
3944 alc_remove_invalid_adc_nids(codec);
3947 alc_ssid_check(codec, ssid_nids);
3949 if (!spec->no_analog) {
3950 alc_auto_check_switches(codec);
3951 err = alc_auto_add_mic_boost(codec);
3956 if (spec->kctls.list)
3957 add_mixer(spec, spec->kctls.list);
3962 static int alc880_parse_auto_config(struct hda_codec *codec)
3964 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3965 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3966 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
3969 #ifdef CONFIG_SND_HDA_POWER_SAVE
3970 static const struct hda_amp_list alc880_loopbacks[] = {
3971 { 0x0b, HDA_INPUT, 0 },
3972 { 0x0b, HDA_INPUT, 1 },
3973 { 0x0b, HDA_INPUT, 2 },
3974 { 0x0b, HDA_INPUT, 3 },
3975 { 0x0b, HDA_INPUT, 4 },
3983 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3984 #define alc_board_config \
3985 snd_hda_check_board_config
3986 #define alc_board_codec_sid_config \
3987 snd_hda_check_board_codec_sid_config
3988 #include "alc_quirks.c"
3990 #define alc_board_config(codec, nums, models, tbl) -1
3991 #define alc_board_codec_sid_config(codec, nums, models, tbl) -1
3992 #define setup_preset(codec, x) /* NOP */
3996 * OK, here we have finally the patch for ALC880
3998 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3999 #include "alc880_quirks.c"
4002 static int patch_alc880(struct hda_codec *codec)
4004 struct alc_spec *spec;
4008 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4014 spec->mixer_nid = 0x0b;
4015 spec->need_dac_fix = 1;
4017 board_config = alc_board_config(codec, ALC880_MODEL_LAST,
4018 alc880_models, alc880_cfg_tbl);
4019 if (board_config < 0) {
4020 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4022 board_config = ALC_MODEL_AUTO;
4025 if (board_config == ALC_MODEL_AUTO) {
4026 /* automatic parse from the BIOS config */
4027 err = alc880_parse_auto_config(codec);
4030 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4033 "hda_codec: Cannot set up configuration "
4034 "from BIOS. Using 3-stack mode...\n");
4035 board_config = ALC880_3ST;
4040 if (board_config != ALC_MODEL_AUTO)
4041 setup_preset(codec, &alc880_presets[board_config]);
4043 if (!spec->no_analog && !spec->adc_nids) {
4044 alc_auto_fill_adc_caps(codec);
4045 alc_rebuild_imux_for_auto_mic(codec);
4046 alc_remove_invalid_adc_nids(codec);
4049 if (!spec->no_analog && !spec->cap_mixer)
4050 set_capture_mixer(codec);
4052 if (!spec->no_analog) {
4053 err = snd_hda_attach_beep_device(codec, 0x1);
4056 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4059 spec->vmaster_nid = 0x0c;
4061 codec->patch_ops = alc_patch_ops;
4062 if (board_config == ALC_MODEL_AUTO)
4063 spec->init_hook = alc_auto_init_std;
4064 #ifdef CONFIG_SND_HDA_POWER_SAVE
4065 if (!spec->loopback.amplist)
4066 spec->loopback.amplist = alc880_loopbacks;
4080 static int alc260_parse_auto_config(struct hda_codec *codec)
4082 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
4083 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
4084 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
4087 #ifdef CONFIG_SND_HDA_POWER_SAVE
4088 static const struct hda_amp_list alc260_loopbacks[] = {
4089 { 0x07, HDA_INPUT, 0 },
4090 { 0x07, HDA_INPUT, 1 },
4091 { 0x07, HDA_INPUT, 2 },
4092 { 0x07, HDA_INPUT, 3 },
4093 { 0x07, HDA_INPUT, 4 },
4105 static const struct alc_fixup alc260_fixups[] = {
4106 [PINFIX_HP_DC5750] = {
4107 .type = ALC_FIXUP_PINS,
4108 .v.pins = (const struct alc_pincfg[]) {
4109 { 0x11, 0x90130110 }, /* speaker */
4115 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
4116 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
4122 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4123 #include "alc260_quirks.c"
4126 static int patch_alc260(struct hda_codec *codec)
4128 struct alc_spec *spec;
4129 int err, board_config;
4131 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4137 spec->mixer_nid = 0x07;
4139 board_config = alc_board_config(codec, ALC260_MODEL_LAST,
4140 alc260_models, alc260_cfg_tbl);
4141 if (board_config < 0) {
4142 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4144 board_config = ALC_MODEL_AUTO;
4147 if (board_config == ALC_MODEL_AUTO) {
4148 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
4149 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4152 if (board_config == ALC_MODEL_AUTO) {
4153 /* automatic parse from the BIOS config */
4154 err = alc260_parse_auto_config(codec);
4157 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4160 "hda_codec: Cannot set up configuration "
4161 "from BIOS. Using base mode...\n");
4162 board_config = ALC260_BASIC;
4167 if (board_config != ALC_MODEL_AUTO)
4168 setup_preset(codec, &alc260_presets[board_config]);
4170 if (!spec->no_analog && !spec->adc_nids) {
4171 alc_auto_fill_adc_caps(codec);
4172 alc_rebuild_imux_for_auto_mic(codec);
4173 alc_remove_invalid_adc_nids(codec);
4176 if (!spec->no_analog && !spec->cap_mixer)
4177 set_capture_mixer(codec);
4179 if (!spec->no_analog) {
4180 err = snd_hda_attach_beep_device(codec, 0x1);
4183 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
4186 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4188 spec->vmaster_nid = 0x08;
4190 codec->patch_ops = alc_patch_ops;
4191 if (board_config == ALC_MODEL_AUTO)
4192 spec->init_hook = alc_auto_init_std;
4193 spec->shutup = alc_eapd_shutup;
4194 #ifdef CONFIG_SND_HDA_POWER_SAVE
4195 if (!spec->loopback.amplist)
4196 spec->loopback.amplist = alc260_loopbacks;
4208 * ALC882/883/885/888/889 support
4210 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
4211 * configuration. Each pin widget can choose any input DACs and a mixer.
4212 * Each ADC is connected from a mixer of all inputs. This makes possible
4213 * 6-channel independent captures.
4215 * In addition, an independent DAC for the multi-playback (not used in this
4218 #ifdef CONFIG_SND_HDA_POWER_SAVE
4219 #define alc882_loopbacks alc880_loopbacks
4226 PINFIX_ABIT_AW9D_MAX,
4229 PINFIX_ACER_ASPIRE_7736,
4231 ALC889_FIXUP_DAC_ROUTE,
4234 /* Fix the connection of some pins for ALC889:
4235 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
4236 * work correctly (bko#42740)
4238 static void alc889_fixup_dac_route(struct hda_codec *codec,
4239 const struct alc_fixup *fix, int action)
4241 if (action == ALC_FIXUP_ACT_PRE_PROBE) {
4242 /* fake the connections during parsing the tree */
4243 hda_nid_t conn1[2] = { 0x0c, 0x0d };
4244 hda_nid_t conn2[2] = { 0x0e, 0x0f };
4245 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
4246 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
4247 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
4248 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
4249 } else if (action == ALC_FIXUP_ACT_PROBE) {
4250 /* restore the connections */
4251 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
4252 snd_hda_override_conn_list(codec, 0x14, 5, conn);
4253 snd_hda_override_conn_list(codec, 0x15, 5, conn);
4254 snd_hda_override_conn_list(codec, 0x18, 5, conn);
4255 snd_hda_override_conn_list(codec, 0x1a, 5, conn);
4259 static const struct alc_fixup alc882_fixups[] = {
4260 [PINFIX_ABIT_AW9D_MAX] = {
4261 .type = ALC_FIXUP_PINS,
4262 .v.pins = (const struct alc_pincfg[]) {
4263 { 0x15, 0x01080104 }, /* side */
4264 { 0x16, 0x01011012 }, /* rear */
4265 { 0x17, 0x01016011 }, /* clfe */
4269 [PINFIX_LENOVO_Y530] = {
4270 .type = ALC_FIXUP_PINS,
4271 .v.pins = (const struct alc_pincfg[]) {
4272 { 0x15, 0x99130112 }, /* rear int speakers */
4273 { 0x16, 0x99130111 }, /* subwoofer */
4277 [PINFIX_PB_M5210] = {
4278 .type = ALC_FIXUP_VERBS,
4279 .v.verbs = (const struct hda_verb[]) {
4280 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
4284 [PINFIX_ACER_ASPIRE_7736] = {
4285 .type = ALC_FIXUP_SKU,
4286 .v.sku = ALC_FIXUP_SKU_IGNORE,
4288 [PINFIX_ASUS_W90V] = {
4289 .type = ALC_FIXUP_PINS,
4290 .v.pins = (const struct alc_pincfg[]) {
4291 { 0x16, 0x99130110 }, /* fix sequence for CLFE */
4295 [ALC889_FIXUP_DAC_ROUTE] = {
4296 .type = ALC_FIXUP_FUNC,
4297 .v.func = alc889_fixup_dac_route,
4301 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
4302 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
4303 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
4304 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", PINFIX_ASUS_W90V),
4305 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530),
4306 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
4307 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
4312 * BIOS auto configuration
4314 /* almost identical with ALC880 parser... */
4315 static int alc882_parse_auto_config(struct hda_codec *codec)
4317 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
4318 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4319 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
4324 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4325 #include "alc882_quirks.c"
4328 static int patch_alc882(struct hda_codec *codec)
4330 struct alc_spec *spec;
4331 int err, board_config;
4333 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4339 spec->mixer_nid = 0x0b;
4341 switch (codec->vendor_id) {
4346 /* ALC883 and variants */
4347 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4351 err = alc_codec_rename_from_preset(codec);
4355 board_config = alc_board_config(codec, ALC882_MODEL_LAST,
4356 alc882_models, alc882_cfg_tbl);
4358 if (board_config < 0)
4359 board_config = alc_board_codec_sid_config(codec,
4360 ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
4362 if (board_config < 0) {
4363 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4365 board_config = ALC_MODEL_AUTO;
4368 if (board_config == ALC_MODEL_AUTO) {
4369 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
4370 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4373 alc_auto_parse_customize_define(codec);
4375 if (board_config == ALC_MODEL_AUTO) {
4376 /* automatic parse from the BIOS config */
4377 err = alc882_parse_auto_config(codec);
4380 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4383 "hda_codec: Cannot set up configuration "
4384 "from BIOS. Using base mode...\n");
4385 board_config = ALC882_3ST_DIG;
4390 if (board_config != ALC_MODEL_AUTO)
4391 setup_preset(codec, &alc882_presets[board_config]);
4393 if (!spec->no_analog && !spec->adc_nids) {
4394 alc_auto_fill_adc_caps(codec);
4395 alc_rebuild_imux_for_auto_mic(codec);
4396 alc_remove_invalid_adc_nids(codec);
4399 if (!spec->no_analog && !spec->cap_mixer)
4400 set_capture_mixer(codec);
4402 if (!spec->no_analog && has_cdefine_beep(codec)) {
4403 err = snd_hda_attach_beep_device(codec, 0x1);
4406 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4409 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4411 spec->vmaster_nid = 0x0c;
4413 codec->patch_ops = alc_patch_ops;
4414 if (board_config == ALC_MODEL_AUTO)
4415 spec->init_hook = alc_auto_init_std;
4417 alc_init_jacks(codec);
4418 #ifdef CONFIG_SND_HDA_POWER_SAVE
4419 if (!spec->loopback.amplist)
4420 spec->loopback.amplist = alc882_loopbacks;
4434 static int alc262_parse_auto_config(struct hda_codec *codec)
4436 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
4437 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4438 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
4449 static const struct alc_fixup alc262_fixups[] = {
4450 [PINFIX_FSC_H270] = {
4451 .type = ALC_FIXUP_PINS,
4452 .v.pins = (const struct alc_pincfg[]) {
4453 { 0x14, 0x99130110 }, /* speaker */
4454 { 0x15, 0x0221142f }, /* front HP */
4455 { 0x1b, 0x0121141f }, /* rear HP */
4459 [PINFIX_HP_Z200] = {
4460 .type = ALC_FIXUP_PINS,
4461 .v.pins = (const struct alc_pincfg[]) {
4462 { 0x16, 0x99130120 }, /* internal speaker */
4468 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
4469 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", PINFIX_HP_Z200),
4470 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
4475 #ifdef CONFIG_SND_HDA_POWER_SAVE
4476 #define alc262_loopbacks alc880_loopbacks
4481 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4482 #include "alc262_quirks.c"
4485 static int patch_alc262(struct hda_codec *codec)
4487 struct alc_spec *spec;
4491 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4497 spec->mixer_nid = 0x0b;
4500 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
4505 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4506 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4507 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4508 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4511 alc_auto_parse_customize_define(codec);
4513 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4515 board_config = alc_board_config(codec, ALC262_MODEL_LAST,
4516 alc262_models, alc262_cfg_tbl);
4518 if (board_config < 0) {
4519 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4521 board_config = ALC_MODEL_AUTO;
4524 if (board_config == ALC_MODEL_AUTO) {
4525 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
4526 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4529 if (board_config == ALC_MODEL_AUTO) {
4530 /* automatic parse from the BIOS config */
4531 err = alc262_parse_auto_config(codec);
4534 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4537 "hda_codec: Cannot set up configuration "
4538 "from BIOS. Using base mode...\n");
4539 board_config = ALC262_BASIC;
4544 if (board_config != ALC_MODEL_AUTO)
4545 setup_preset(codec, &alc262_presets[board_config]);
4547 if (!spec->no_analog && !spec->adc_nids) {
4548 alc_auto_fill_adc_caps(codec);
4549 alc_rebuild_imux_for_auto_mic(codec);
4550 alc_remove_invalid_adc_nids(codec);
4553 if (!spec->no_analog && !spec->cap_mixer)
4554 set_capture_mixer(codec);
4556 if (!spec->no_analog && has_cdefine_beep(codec)) {
4557 err = snd_hda_attach_beep_device(codec, 0x1);
4560 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4563 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4565 spec->vmaster_nid = 0x0c;
4567 codec->patch_ops = alc_patch_ops;
4568 if (board_config == ALC_MODEL_AUTO)
4569 spec->init_hook = alc_auto_init_std;
4570 spec->shutup = alc_eapd_shutup;
4572 alc_init_jacks(codec);
4573 #ifdef CONFIG_SND_HDA_POWER_SAVE
4574 if (!spec->loopback.amplist)
4575 spec->loopback.amplist = alc262_loopbacks;
4588 /* bind Beep switches of both NID 0x0f and 0x10 */
4589 static const struct hda_bind_ctls alc268_bind_beep_sw = {
4590 .ops = &snd_hda_bind_sw,
4592 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
4593 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
4598 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
4599 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
4600 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
4604 /* set PCBEEP vol = 0, mute connections */
4605 static const struct hda_verb alc268_beep_init_verbs[] = {
4606 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4607 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4608 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4613 * BIOS auto configuration
4615 static int alc268_parse_auto_config(struct hda_codec *codec)
4617 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4618 struct alc_spec *spec = codec->spec;
4619 int err = alc_parse_auto_config(codec, NULL, alc268_ssids);
4621 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) {
4622 add_mixer(spec, alc268_beep_mixer);
4623 add_verb(spec, alc268_beep_init_verbs);
4631 static int patch_alc268(struct hda_codec *codec)
4633 struct alc_spec *spec;
4634 int i, has_beep, err;
4636 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4642 /* ALC268 has no aa-loopback mixer */
4644 /* automatic parse from the BIOS config */
4645 err = alc268_parse_auto_config(codec);
4650 for (i = 0; i < spec->num_mixers; i++) {
4651 if (spec->mixers[i] == alc268_beep_mixer) {
4658 err = snd_hda_attach_beep_device(codec, 0x1);
4661 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
4662 /* override the amp caps for beep generator */
4663 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
4664 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
4665 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
4666 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4667 (0 << AC_AMPCAP_MUTE_SHIFT));
4670 if (!spec->no_analog && !spec->adc_nids) {
4671 alc_auto_fill_adc_caps(codec);
4672 alc_rebuild_imux_for_auto_mic(codec);
4673 alc_remove_invalid_adc_nids(codec);
4676 if (!spec->no_analog && !spec->cap_mixer)
4677 set_capture_mixer(codec);
4679 spec->vmaster_nid = 0x02;
4681 codec->patch_ops = alc_patch_ops;
4682 spec->init_hook = alc_auto_init_std;
4683 spec->shutup = alc_eapd_shutup;
4685 alc_init_jacks(codec);
4697 #ifdef CONFIG_SND_HDA_POWER_SAVE
4698 #define alc269_loopbacks alc880_loopbacks
4701 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
4705 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4706 /* NID is set in alc_build_pcms */
4708 .open = alc_playback_pcm_open,
4709 .prepare = alc_playback_pcm_prepare,
4710 .cleanup = alc_playback_pcm_cleanup
4714 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
4718 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4719 /* NID is set in alc_build_pcms */
4722 #ifdef CONFIG_SND_HDA_POWER_SAVE
4723 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
4725 switch (codec->subsystem_id) {
4732 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
4734 /* update mute-LED according to the speaker mute state */
4735 if (nid == 0x01 || nid == 0x14) {
4737 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
4742 /* mic2 vref pin is used for mute LED control */
4743 snd_hda_codec_update_cache(codec, 0x19, 0,
4744 AC_VERB_SET_PIN_WIDGET_CONTROL,
4747 return alc_check_power_status(codec, nid);
4749 #endif /* CONFIG_SND_HDA_POWER_SAVE */
4751 /* different alc269-variants */
4753 ALC269_TYPE_ALC269VA,
4754 ALC269_TYPE_ALC269VB,
4755 ALC269_TYPE_ALC269VC,
4759 * BIOS auto configuration
4761 static int alc269_parse_auto_config(struct hda_codec *codec)
4763 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
4764 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
4765 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4766 struct alc_spec *spec = codec->spec;
4767 const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ?
4768 alc269va_ssids : alc269_ssids;
4770 return alc_parse_auto_config(codec, alc269_ignore, ssids);
4773 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
4775 int val = alc_read_coef_idx(codec, 0x04);
4780 alc_write_coef_idx(codec, 0x04, val);
4783 static void alc269_shutup(struct hda_codec *codec)
4785 if ((alc_get_coef0(codec) & 0x00ff) == 0x017)
4786 alc269_toggle_power_output(codec, 0);
4787 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
4788 alc269_toggle_power_output(codec, 0);
4794 static int alc269_resume(struct hda_codec *codec)
4796 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
4797 alc269_toggle_power_output(codec, 0);
4801 codec->patch_ops.init(codec);
4803 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
4804 alc269_toggle_power_output(codec, 1);
4808 if ((alc_get_coef0(codec) & 0x00ff) == 0x018)
4809 alc269_toggle_power_output(codec, 1);
4811 snd_hda_codec_resume_amp(codec);
4812 snd_hda_codec_resume_cache(codec);
4813 hda_call_check_power_status(codec, 0x01);
4816 #endif /* CONFIG_PM */
4818 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
4819 const struct alc_fixup *fix, int action)
4821 struct alc_spec *spec = codec->spec;
4823 if (action == ALC_FIXUP_ACT_PRE_PROBE)
4824 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4827 static void alc269_fixup_hweq(struct hda_codec *codec,
4828 const struct alc_fixup *fix, int action)
4832 if (action != ALC_FIXUP_ACT_INIT)
4834 coef = alc_read_coef_idx(codec, 0x1e);
4835 alc_write_coef_idx(codec, 0x1e, coef | 0x80);
4838 static void alc271_fixup_dmic(struct hda_codec *codec,
4839 const struct alc_fixup *fix, int action)
4841 static const struct hda_verb verbs[] = {
4842 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4843 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4848 if (strcmp(codec->chip_name, "ALC271X"))
4850 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4851 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4852 snd_hda_sequence_write(codec, verbs);
4855 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4856 const struct alc_fixup *fix, int action)
4858 struct alc_spec *spec = codec->spec;
4860 if (action != ALC_FIXUP_ACT_PROBE)
4863 /* Due to a hardware problem on Lenovo Ideadpad, we need to
4864 * fix the sample rate of analog I/O to 44.1kHz
4866 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
4867 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
4870 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4871 const struct alc_fixup *fix, int action)
4875 if (action != ALC_FIXUP_ACT_INIT)
4877 /* The digital-mic unit sends PDM (differential signal) instead of
4878 * the standard PCM, thus you can't record a valid mono stream as is.
4879 * Below is a workaround specific to ALC269 to control the dmic
4880 * signal source as mono.
4882 coef = alc_read_coef_idx(codec, 0x07);
4883 alc_write_coef_idx(codec, 0x07, coef | 0x80);
4886 static void alc269_quanta_automute(struct hda_codec *codec)
4888 update_outputs(codec);
4890 snd_hda_codec_write(codec, 0x20, 0,
4891 AC_VERB_SET_COEF_INDEX, 0x0c);
4892 snd_hda_codec_write(codec, 0x20, 0,
4893 AC_VERB_SET_PROC_COEF, 0x680);
4895 snd_hda_codec_write(codec, 0x20, 0,
4896 AC_VERB_SET_COEF_INDEX, 0x0c);
4897 snd_hda_codec_write(codec, 0x20, 0,
4898 AC_VERB_SET_PROC_COEF, 0x480);
4901 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4902 const struct alc_fixup *fix, int action)
4904 struct alc_spec *spec = codec->spec;
4905 if (action != ALC_FIXUP_ACT_PROBE)
4907 spec->automute_hook = alc269_quanta_automute;
4911 ALC269_FIXUP_SONY_VAIO,
4912 ALC275_FIXUP_SONY_VAIO_GPIO2,
4913 ALC269_FIXUP_DELL_M101Z,
4914 ALC269_FIXUP_SKU_IGNORE,
4915 ALC269_FIXUP_ASUS_G73JW,
4916 ALC269_FIXUP_LENOVO_EAPD,
4917 ALC275_FIXUP_SONY_HWEQ,
4919 ALC269_FIXUP_PCM_44K,
4920 ALC269_FIXUP_STEREO_DMIC,
4921 ALC269_FIXUP_QUANTA_MUTE,
4922 ALC269_FIXUP_LIFEBOOK,
4923 ALC269_FIXUP_LIFEBOOK_EXTMIC,
4926 ALC269VB_FIXUP_AMIC,
4927 ALC269VB_FIXUP_DMIC,
4928 ALC269_FIXUP_LENOVO_DOCK,
4929 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
4932 static const struct alc_fixup alc269_fixups[] = {
4933 [ALC269_FIXUP_SONY_VAIO] = {
4934 .type = ALC_FIXUP_VERBS,
4935 .v.verbs = (const struct hda_verb[]) {
4936 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
4940 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
4941 .type = ALC_FIXUP_VERBS,
4942 .v.verbs = (const struct hda_verb[]) {
4943 {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
4944 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
4945 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4949 .chain_id = ALC269_FIXUP_SONY_VAIO
4951 [ALC269_FIXUP_DELL_M101Z] = {
4952 .type = ALC_FIXUP_VERBS,
4953 .v.verbs = (const struct hda_verb[]) {
4954 /* Enables internal speaker */
4955 {0x20, AC_VERB_SET_COEF_INDEX, 13},
4956 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
4960 [ALC269_FIXUP_SKU_IGNORE] = {
4961 .type = ALC_FIXUP_SKU,
4962 .v.sku = ALC_FIXUP_SKU_IGNORE,
4964 [ALC269_FIXUP_ASUS_G73JW] = {
4965 .type = ALC_FIXUP_PINS,
4966 .v.pins = (const struct alc_pincfg[]) {
4967 { 0x17, 0x99130111 }, /* subwoofer */
4971 [ALC269_FIXUP_LENOVO_EAPD] = {
4972 .type = ALC_FIXUP_VERBS,
4973 .v.verbs = (const struct hda_verb[]) {
4974 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
4978 [ALC275_FIXUP_SONY_HWEQ] = {
4979 .type = ALC_FIXUP_FUNC,
4980 .v.func = alc269_fixup_hweq,
4982 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
4984 [ALC271_FIXUP_DMIC] = {
4985 .type = ALC_FIXUP_FUNC,
4986 .v.func = alc271_fixup_dmic,
4988 [ALC269_FIXUP_PCM_44K] = {
4989 .type = ALC_FIXUP_FUNC,
4990 .v.func = alc269_fixup_pcm_44k,
4992 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4994 [ALC269_FIXUP_STEREO_DMIC] = {
4995 .type = ALC_FIXUP_FUNC,
4996 .v.func = alc269_fixup_stereo_dmic,
4998 [ALC269_FIXUP_QUANTA_MUTE] = {
4999 .type = ALC_FIXUP_FUNC,
5000 .v.func = alc269_fixup_quanta_mute,
5002 [ALC269_FIXUP_LIFEBOOK] = {
5003 .type = ALC_FIXUP_PINS,
5004 .v.pins = (const struct alc_pincfg[]) {
5005 { 0x1a, 0x2101103f }, /* dock line-out */
5006 { 0x1b, 0x23a11040 }, /* dock mic-in */
5010 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5012 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
5013 .type = ALC_FIXUP_PINS,
5014 .v.pins = (const struct alc_pincfg[]) {
5015 { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
5019 [ALC269_FIXUP_AMIC] = {
5020 .type = ALC_FIXUP_PINS,
5021 .v.pins = (const struct alc_pincfg[]) {
5022 { 0x14, 0x99130110 }, /* speaker */
5023 { 0x15, 0x0121401f }, /* HP out */
5024 { 0x18, 0x01a19c20 }, /* mic */
5025 { 0x19, 0x99a3092f }, /* int-mic */
5029 [ALC269_FIXUP_DMIC] = {
5030 .type = ALC_FIXUP_PINS,
5031 .v.pins = (const struct alc_pincfg[]) {
5032 { 0x12, 0x99a3092f }, /* int-mic */
5033 { 0x14, 0x99130110 }, /* speaker */
5034 { 0x15, 0x0121401f }, /* HP out */
5035 { 0x18, 0x01a19c20 }, /* mic */
5039 [ALC269VB_FIXUP_AMIC] = {
5040 .type = ALC_FIXUP_PINS,
5041 .v.pins = (const struct alc_pincfg[]) {
5042 { 0x14, 0x99130110 }, /* speaker */
5043 { 0x18, 0x01a19c20 }, /* mic */
5044 { 0x19, 0x99a3092f }, /* int-mic */
5045 { 0x21, 0x0121401f }, /* HP out */
5049 [ALC269_FIXUP_DMIC] = {
5050 .type = ALC_FIXUP_PINS,
5051 .v.pins = (const struct alc_pincfg[]) {
5052 { 0x12, 0x99a3092f }, /* int-mic */
5053 { 0x14, 0x99130110 }, /* speaker */
5054 { 0x18, 0x01a19c20 }, /* mic */
5055 { 0x21, 0x0121401f }, /* HP out */
5059 [ALC269_FIXUP_LENOVO_DOCK] = {
5060 .type = ALC_FIXUP_PINS,
5061 .v.pins = (const struct alc_pincfg[]) {
5062 { 0x19, 0x23a11040 }, /* dock mic */
5063 { 0x1b, 0x2121103f }, /* dock headphone */
5067 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
5069 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
5070 .type = ALC_FIXUP_FUNC,
5071 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
5075 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
5076 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_DMIC),
5077 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
5078 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
5079 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
5080 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
5081 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5082 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5083 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
5084 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5085 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5086 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
5087 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
5088 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
5089 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
5090 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
5091 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
5092 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
5093 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
5094 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
5095 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
5096 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
5097 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
5098 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
5099 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
5100 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
5101 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
5102 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
5105 /* Below is a quirk table taken from the old code.
5106 * Basically the device should work as is without the fixup table.
5107 * If BIOS doesn't give a proper info, enable the corresponding
5110 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
5112 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
5113 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
5114 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
5115 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
5116 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
5117 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
5118 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
5119 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
5120 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
5121 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
5122 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
5123 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
5124 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
5125 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
5126 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
5127 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
5128 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
5129 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
5130 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
5131 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
5132 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
5133 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
5134 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
5135 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
5136 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
5137 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
5138 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
5139 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
5140 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
5141 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
5142 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
5143 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
5144 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
5145 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
5146 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
5147 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
5148 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
5149 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
5150 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
5155 static const struct alc_model_fixup alc269_fixup_models[] = {
5156 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
5157 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
5158 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
5163 static int alc269_fill_coef(struct hda_codec *codec)
5165 struct alc_spec *spec = codec->spec;
5168 if (spec->codec_variant != ALC269_TYPE_ALC269VB)
5170 /* ALC271X doesn't seem to support these COEFs (bko#52181) */
5171 if (!strcmp(codec->chip_name, "ALC271X"))
5174 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
5175 alc_write_coef_idx(codec, 0xf, 0x960b);
5176 alc_write_coef_idx(codec, 0xe, 0x8817);
5179 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
5180 alc_write_coef_idx(codec, 0xf, 0x960b);
5181 alc_write_coef_idx(codec, 0xe, 0x8814);
5184 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
5185 val = alc_read_coef_idx(codec, 0x04);
5186 /* Power up output pin */
5187 alc_write_coef_idx(codec, 0x04, val | (1<<11));
5190 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5191 val = alc_read_coef_idx(codec, 0xd);
5192 if ((val & 0x0c00) >> 10 != 0x1) {
5193 /* Capless ramp up clock control */
5194 alc_write_coef_idx(codec, 0xd, val | (1<<10));
5196 val = alc_read_coef_idx(codec, 0x17);
5197 if ((val & 0x01c0) >> 6 != 0x4) {
5198 /* Class D power on reset */
5199 alc_write_coef_idx(codec, 0x17, val | (1<<7));
5203 val = alc_read_coef_idx(codec, 0xd); /* Class D */
5204 alc_write_coef_idx(codec, 0xd, val | (1<<14));
5206 val = alc_read_coef_idx(codec, 0x4); /* HP */
5207 alc_write_coef_idx(codec, 0x4, val | (1<<11));
5214 static int patch_alc269(struct hda_codec *codec)
5216 struct alc_spec *spec;
5219 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5225 spec->mixer_nid = 0x0b;
5227 alc_auto_parse_customize_define(codec);
5229 err = alc_codec_rename_from_preset(codec);
5233 if (codec->vendor_id == 0x10ec0269) {
5234 spec->codec_variant = ALC269_TYPE_ALC269VA;
5235 switch (alc_get_coef0(codec) & 0x00f0) {
5237 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
5238 spec->cdefine.platform_type == 1)
5239 err = alc_codec_rename(codec, "ALC271X");
5240 spec->codec_variant = ALC269_TYPE_ALC269VB;
5243 if (codec->bus->pci->subsystem_vendor == 0x17aa &&
5244 codec->bus->pci->subsystem_device == 0x21f3)
5245 err = alc_codec_rename(codec, "ALC3202");
5246 spec->codec_variant = ALC269_TYPE_ALC269VC;
5249 alc_fix_pll_init(codec, 0x20, 0x04, 15);
5253 alc269_fill_coef(codec);
5256 alc_pick_fixup(codec, alc269_fixup_models,
5257 alc269_fixup_tbl, alc269_fixups);
5258 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5260 /* automatic parse from the BIOS config */
5261 err = alc269_parse_auto_config(codec);
5265 if (!spec->no_analog && !spec->adc_nids) {
5266 alc_auto_fill_adc_caps(codec);
5267 alc_rebuild_imux_for_auto_mic(codec);
5268 alc_remove_invalid_adc_nids(codec);
5271 if (!spec->no_analog && !spec->cap_mixer)
5272 set_capture_mixer(codec);
5274 if (!spec->no_analog && has_cdefine_beep(codec)) {
5275 err = snd_hda_attach_beep_device(codec, 0x1);
5278 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5281 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5283 spec->vmaster_nid = 0x02;
5285 codec->patch_ops = alc_patch_ops;
5287 codec->patch_ops.resume = alc269_resume;
5289 spec->init_hook = alc_auto_init_std;
5290 spec->shutup = alc269_shutup;
5292 alc_init_jacks(codec);
5293 #ifdef CONFIG_SND_HDA_POWER_SAVE
5294 if (!spec->loopback.amplist)
5295 spec->loopback.amplist = alc269_loopbacks;
5296 if (alc269_mic2_for_mute_led(codec))
5297 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
5311 static int alc861_parse_auto_config(struct hda_codec *codec)
5313 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
5314 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
5315 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
5318 #ifdef CONFIG_SND_HDA_POWER_SAVE
5319 static const struct hda_amp_list alc861_loopbacks[] = {
5320 { 0x15, HDA_INPUT, 0 },
5321 { 0x15, HDA_INPUT, 1 },
5322 { 0x15, HDA_INPUT, 2 },
5323 { 0x15, HDA_INPUT, 3 },
5329 /* Pin config fixes */
5331 ALC861_FIXUP_FSC_AMILO_PI1505,
5332 ALC861_FIXUP_AMP_VREF_0F,
5333 ALC861_FIXUP_NO_JACK_DETECT,
5334 ALC861_FIXUP_ASUS_A6RP,
5337 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
5338 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
5339 const struct alc_fixup *fix, int action)
5341 struct alc_spec *spec = codec->spec;
5344 if (action != ALC_FIXUP_ACT_INIT)
5346 val = snd_hda_codec_read(codec, 0x0f, 0,
5347 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5348 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
5349 val |= AC_PINCTL_IN_EN;
5350 val |= AC_PINCTL_VREF_50;
5351 snd_hda_codec_write(codec, 0x0f, 0,
5352 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5353 spec->keep_vref_in_automute = 1;
5356 /* suppress the jack-detection */
5357 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
5358 const struct alc_fixup *fix, int action)
5360 if (action == ALC_FIXUP_ACT_PRE_PROBE)
5361 codec->no_jack_detect = 1;
5364 static const struct alc_fixup alc861_fixups[] = {
5365 [ALC861_FIXUP_FSC_AMILO_PI1505] = {
5366 .type = ALC_FIXUP_PINS,
5367 .v.pins = (const struct alc_pincfg[]) {
5368 { 0x0b, 0x0221101f }, /* HP */
5369 { 0x0f, 0x90170310 }, /* speaker */
5373 [ALC861_FIXUP_AMP_VREF_0F] = {
5374 .type = ALC_FIXUP_FUNC,
5375 .v.func = alc861_fixup_asus_amp_vref_0f,
5377 [ALC861_FIXUP_NO_JACK_DETECT] = {
5378 .type = ALC_FIXUP_FUNC,
5379 .v.func = alc_fixup_no_jack_detect,
5381 [ALC861_FIXUP_ASUS_A6RP] = {
5382 .type = ALC_FIXUP_FUNC,
5383 .v.func = alc861_fixup_asus_amp_vref_0f,
5385 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
5389 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
5390 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
5391 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
5392 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
5393 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
5394 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
5395 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
5401 static int patch_alc861(struct hda_codec *codec)
5403 struct alc_spec *spec;
5406 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5412 spec->mixer_nid = 0x15;
5414 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
5415 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5417 /* automatic parse from the BIOS config */
5418 err = alc861_parse_auto_config(codec);
5422 if (!spec->no_analog && !spec->adc_nids) {
5423 alc_auto_fill_adc_caps(codec);
5424 alc_rebuild_imux_for_auto_mic(codec);
5425 alc_remove_invalid_adc_nids(codec);
5428 if (!spec->no_analog && !spec->cap_mixer)
5429 set_capture_mixer(codec);
5431 if (!spec->no_analog) {
5432 err = snd_hda_attach_beep_device(codec, 0x23);
5435 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
5438 spec->vmaster_nid = 0x03;
5440 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5442 codec->patch_ops = alc_patch_ops;
5443 spec->init_hook = alc_auto_init_std;
5444 #ifdef CONFIG_SND_HDA_POWER_SAVE
5445 spec->power_hook = alc_power_eapd;
5446 if (!spec->loopback.amplist)
5447 spec->loopback.amplist = alc861_loopbacks;
5462 * In addition, an independent DAC
5464 #ifdef CONFIG_SND_HDA_POWER_SAVE
5465 #define alc861vd_loopbacks alc880_loopbacks
5468 static int alc861vd_parse_auto_config(struct hda_codec *codec)
5470 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
5471 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5472 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
5476 ALC660VD_FIX_ASUS_GPIO1,
5477 ALC861VD_FIX_DALLAS,
5480 /* exclude VREF80 */
5481 static void alc861vd_fixup_dallas(struct hda_codec *codec,
5482 const struct alc_fixup *fix, int action)
5484 if (action == ALC_FIXUP_ACT_PRE_PROBE) {
5485 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
5486 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
5490 static const struct alc_fixup alc861vd_fixups[] = {
5491 [ALC660VD_FIX_ASUS_GPIO1] = {
5492 .type = ALC_FIXUP_VERBS,
5493 .v.verbs = (const struct hda_verb[]) {
5495 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5496 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5497 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5501 [ALC861VD_FIX_DALLAS] = {
5502 .type = ALC_FIXUP_FUNC,
5503 .v.func = alc861vd_fixup_dallas,
5507 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
5508 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
5509 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
5510 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
5514 static const struct hda_verb alc660vd_eapd_verbs[] = {
5515 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
5516 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
5522 static int patch_alc861vd(struct hda_codec *codec)
5524 struct alc_spec *spec;
5527 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5533 spec->mixer_nid = 0x0b;
5535 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
5536 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5538 /* automatic parse from the BIOS config */
5539 err = alc861vd_parse_auto_config(codec);
5543 if (codec->vendor_id == 0x10ec0660) {
5544 /* always turn on EAPD */
5545 add_verb(spec, alc660vd_eapd_verbs);
5548 if (!spec->no_analog && !spec->adc_nids) {
5549 alc_auto_fill_adc_caps(codec);
5550 alc_rebuild_imux_for_auto_mic(codec);
5551 alc_remove_invalid_adc_nids(codec);
5554 if (!spec->no_analog && !spec->cap_mixer)
5555 set_capture_mixer(codec);
5557 if (!spec->no_analog) {
5558 err = snd_hda_attach_beep_device(codec, 0x23);
5561 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5564 spec->vmaster_nid = 0x02;
5566 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5568 codec->patch_ops = alc_patch_ops;
5570 spec->init_hook = alc_auto_init_std;
5571 spec->shutup = alc_eapd_shutup;
5572 #ifdef CONFIG_SND_HDA_POWER_SAVE
5573 if (!spec->loopback.amplist)
5574 spec->loopback.amplist = alc861vd_loopbacks;
5587 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5588 * configuration. Each pin widget can choose any input DACs and a mixer.
5589 * Each ADC is connected from a mixer of all inputs. This makes possible
5590 * 6-channel independent captures.
5592 * In addition, an independent DAC for the multi-playback (not used in this
5595 #ifdef CONFIG_SND_HDA_POWER_SAVE
5596 #define alc662_loopbacks alc880_loopbacks
5600 * BIOS auto configuration
5603 static int alc662_parse_auto_config(struct hda_codec *codec)
5605 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
5606 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
5607 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5608 const hda_nid_t *ssids;
5610 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
5611 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670 ||
5612 codec->vendor_id == 0x10ec0671)
5613 ssids = alc663_ssids;
5615 ssids = alc662_ssids;
5616 return alc_parse_auto_config(codec, alc662_ignore, ssids);
5619 static void alc272_fixup_mario(struct hda_codec *codec,
5620 const struct alc_fixup *fix, int action)
5622 if (action != ALC_FIXUP_ACT_PROBE)
5624 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
5625 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
5626 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
5627 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5628 (0 << AC_AMPCAP_MUTE_SHIFT)))
5630 "hda_codec: failed to override amp caps for NID 0x2\n");
5634 ALC662_FIXUP_ASPIRE,
5635 ALC662_FIXUP_IDEAPAD,
5637 ALC662_FIXUP_CZC_P10T,
5638 ALC662_FIXUP_SKU_IGNORE,
5639 ALC662_FIXUP_HP_RP5800,
5640 ALC662_FIXUP_ASUS_MODE1,
5641 ALC662_FIXUP_ASUS_MODE2,
5642 ALC662_FIXUP_ASUS_MODE3,
5643 ALC662_FIXUP_ASUS_MODE4,
5644 ALC662_FIXUP_ASUS_MODE5,
5645 ALC662_FIXUP_ASUS_MODE6,
5646 ALC662_FIXUP_ASUS_MODE7,
5647 ALC662_FIXUP_ASUS_MODE8,
5648 ALC662_FIXUP_NO_JACK_DETECT,
5649 ALC662_FIXUP_ZOTAC_Z68,
5652 static const struct alc_fixup alc662_fixups[] = {
5653 [ALC662_FIXUP_ASPIRE] = {
5654 .type = ALC_FIXUP_PINS,
5655 .v.pins = (const struct alc_pincfg[]) {
5656 { 0x15, 0x99130112 }, /* subwoofer */
5660 [ALC662_FIXUP_IDEAPAD] = {
5661 .type = ALC_FIXUP_PINS,
5662 .v.pins = (const struct alc_pincfg[]) {
5663 { 0x17, 0x99130112 }, /* subwoofer */
5667 [ALC272_FIXUP_MARIO] = {
5668 .type = ALC_FIXUP_FUNC,
5669 .v.func = alc272_fixup_mario,
5671 [ALC662_FIXUP_CZC_P10T] = {
5672 .type = ALC_FIXUP_VERBS,
5673 .v.verbs = (const struct hda_verb[]) {
5674 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5678 [ALC662_FIXUP_SKU_IGNORE] = {
5679 .type = ALC_FIXUP_SKU,
5680 .v.sku = ALC_FIXUP_SKU_IGNORE,
5682 [ALC662_FIXUP_HP_RP5800] = {
5683 .type = ALC_FIXUP_PINS,
5684 .v.pins = (const struct alc_pincfg[]) {
5685 { 0x14, 0x0221201f }, /* HP out */
5689 .chain_id = ALC662_FIXUP_SKU_IGNORE
5691 [ALC662_FIXUP_ASUS_MODE1] = {
5692 .type = ALC_FIXUP_PINS,
5693 .v.pins = (const struct alc_pincfg[]) {
5694 { 0x14, 0x99130110 }, /* speaker */
5695 { 0x18, 0x01a19c20 }, /* mic */
5696 { 0x19, 0x99a3092f }, /* int-mic */
5697 { 0x21, 0x0121401f }, /* HP out */
5701 .chain_id = ALC662_FIXUP_SKU_IGNORE
5703 [ALC662_FIXUP_ASUS_MODE2] = {
5704 .type = ALC_FIXUP_PINS,
5705 .v.pins = (const struct alc_pincfg[]) {
5706 { 0x14, 0x99130110 }, /* speaker */
5707 { 0x18, 0x01a19820 }, /* mic */
5708 { 0x19, 0x99a3092f }, /* int-mic */
5709 { 0x1b, 0x0121401f }, /* HP out */
5713 .chain_id = ALC662_FIXUP_SKU_IGNORE
5715 [ALC662_FIXUP_ASUS_MODE3] = {
5716 .type = ALC_FIXUP_PINS,
5717 .v.pins = (const struct alc_pincfg[]) {
5718 { 0x14, 0x99130110 }, /* speaker */
5719 { 0x15, 0x0121441f }, /* HP */
5720 { 0x18, 0x01a19840 }, /* mic */
5721 { 0x19, 0x99a3094f }, /* int-mic */
5722 { 0x21, 0x01211420 }, /* HP2 */
5726 .chain_id = ALC662_FIXUP_SKU_IGNORE
5728 [ALC662_FIXUP_ASUS_MODE4] = {
5729 .type = ALC_FIXUP_PINS,
5730 .v.pins = (const struct alc_pincfg[]) {
5731 { 0x14, 0x99130110 }, /* speaker */
5732 { 0x16, 0x99130111 }, /* speaker */
5733 { 0x18, 0x01a19840 }, /* mic */
5734 { 0x19, 0x99a3094f }, /* int-mic */
5735 { 0x21, 0x0121441f }, /* HP */
5739 .chain_id = ALC662_FIXUP_SKU_IGNORE
5741 [ALC662_FIXUP_ASUS_MODE5] = {
5742 .type = ALC_FIXUP_PINS,
5743 .v.pins = (const struct alc_pincfg[]) {
5744 { 0x14, 0x99130110 }, /* speaker */
5745 { 0x15, 0x0121441f }, /* HP */
5746 { 0x16, 0x99130111 }, /* speaker */
5747 { 0x18, 0x01a19840 }, /* mic */
5748 { 0x19, 0x99a3094f }, /* int-mic */
5752 .chain_id = ALC662_FIXUP_SKU_IGNORE
5754 [ALC662_FIXUP_ASUS_MODE6] = {
5755 .type = ALC_FIXUP_PINS,
5756 .v.pins = (const struct alc_pincfg[]) {
5757 { 0x14, 0x99130110 }, /* speaker */
5758 { 0x15, 0x01211420 }, /* HP2 */
5759 { 0x18, 0x01a19840 }, /* mic */
5760 { 0x19, 0x99a3094f }, /* int-mic */
5761 { 0x1b, 0x0121441f }, /* HP */
5765 .chain_id = ALC662_FIXUP_SKU_IGNORE
5767 [ALC662_FIXUP_ASUS_MODE7] = {
5768 .type = ALC_FIXUP_PINS,
5769 .v.pins = (const struct alc_pincfg[]) {
5770 { 0x14, 0x99130110 }, /* speaker */
5771 { 0x17, 0x99130111 }, /* speaker */
5772 { 0x18, 0x01a19840 }, /* mic */
5773 { 0x19, 0x99a3094f }, /* int-mic */
5774 { 0x1b, 0x01214020 }, /* HP */
5775 { 0x21, 0x0121401f }, /* HP */
5779 .chain_id = ALC662_FIXUP_SKU_IGNORE
5781 [ALC662_FIXUP_ASUS_MODE8] = {
5782 .type = ALC_FIXUP_PINS,
5783 .v.pins = (const struct alc_pincfg[]) {
5784 { 0x14, 0x99130110 }, /* speaker */
5785 { 0x12, 0x99a30970 }, /* int-mic */
5786 { 0x15, 0x01214020 }, /* HP */
5787 { 0x17, 0x99130111 }, /* speaker */
5788 { 0x18, 0x01a19840 }, /* mic */
5789 { 0x21, 0x0121401f }, /* HP */
5793 .chain_id = ALC662_FIXUP_SKU_IGNORE
5795 [ALC662_FIXUP_NO_JACK_DETECT] = {
5796 .type = ALC_FIXUP_FUNC,
5797 .v.func = alc_fixup_no_jack_detect,
5799 [ALC662_FIXUP_ZOTAC_Z68] = {
5800 .type = ALC_FIXUP_PINS,
5801 .v.pins = (const struct alc_pincfg[]) {
5802 { 0x1b, 0x02214020 }, /* Front HP */
5808 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
5809 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
5810 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
5811 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
5812 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
5813 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
5814 SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_ASUS_MODE4),
5815 SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_ASUS_MODE4),
5816 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
5817 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
5818 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
5819 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
5820 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
5821 SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
5822 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
5825 /* Below is a quirk table taken from the old code.
5826 * Basically the device should work as is without the fixup table.
5827 * If BIOS doesn't give a proper info, enable the corresponding
5830 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
5831 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
5832 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
5833 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
5834 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5835 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5836 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5837 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
5838 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
5839 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5840 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
5841 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
5842 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
5843 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
5844 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
5845 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5846 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
5847 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
5848 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5849 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5850 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5851 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5852 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
5853 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
5854 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
5855 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5856 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
5857 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
5858 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5859 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
5860 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5861 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5862 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
5863 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
5864 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
5865 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
5866 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
5867 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
5868 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
5869 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
5870 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
5871 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
5872 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5873 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
5874 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
5875 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
5876 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
5877 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
5878 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
5879 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
5884 static const struct alc_model_fixup alc662_fixup_models[] = {
5885 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
5886 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
5887 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
5888 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
5889 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
5890 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
5891 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
5892 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
5893 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
5900 static int patch_alc662(struct hda_codec *codec)
5902 struct alc_spec *spec;
5905 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5911 spec->mixer_nid = 0x0b;
5913 /* handle multiple HPs as is */
5914 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5916 alc_auto_parse_customize_define(codec);
5918 alc_fix_pll_init(codec, 0x20, 0x04, 15);
5920 err = alc_codec_rename_from_preset(codec);
5924 if ((alc_get_coef0(codec) & (1 << 14)) &&
5925 codec->bus->pci->subsystem_vendor == 0x1025 &&
5926 spec->cdefine.platform_type == 1) {
5927 if (alc_codec_rename(codec, "ALC272X") < 0)
5931 alc_pick_fixup(codec, alc662_fixup_models,
5932 alc662_fixup_tbl, alc662_fixups);
5933 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5934 /* automatic parse from the BIOS config */
5935 err = alc662_parse_auto_config(codec);
5939 if (!spec->no_analog && !spec->adc_nids) {
5940 alc_auto_fill_adc_caps(codec);
5941 alc_rebuild_imux_for_auto_mic(codec);
5942 alc_remove_invalid_adc_nids(codec);
5945 if (!spec->no_analog && !spec->cap_mixer)
5946 set_capture_mixer(codec);
5948 if (!spec->no_analog && has_cdefine_beep(codec)) {
5949 err = snd_hda_attach_beep_device(codec, 0x1);
5952 switch (codec->vendor_id) {
5954 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5960 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5963 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
5967 spec->vmaster_nid = 0x02;
5969 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5971 codec->patch_ops = alc_patch_ops;
5972 spec->init_hook = alc_auto_init_std;
5973 spec->shutup = alc_eapd_shutup;
5975 alc_init_jacks(codec);
5977 #ifdef CONFIG_SND_HDA_POWER_SAVE
5978 if (!spec->loopback.amplist)
5979 spec->loopback.amplist = alc662_loopbacks;
5993 static int alc680_parse_auto_config(struct hda_codec *codec)
5995 return alc_parse_auto_config(codec, NULL, NULL);
6000 static int patch_alc680(struct hda_codec *codec)
6002 struct alc_spec *spec;
6005 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6011 /* ALC680 has no aa-loopback mixer */
6013 /* automatic parse from the BIOS config */
6014 err = alc680_parse_auto_config(codec);
6020 if (!spec->no_analog && !spec->cap_mixer)
6021 set_capture_mixer(codec);
6023 spec->vmaster_nid = 0x02;
6025 codec->patch_ops = alc_patch_ops;
6026 spec->init_hook = alc_auto_init_std;
6034 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
6035 { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
6036 { .id = 0x10ec0231, .name = "ALC231", .patch = patch_alc269 },
6037 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
6038 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
6039 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
6040 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
6041 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
6042 { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
6043 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
6044 { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
6045 { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
6046 { .id = 0x10ec0280, .name = "ALC280", .patch = patch_alc269 },
6047 { .id = 0x10ec0282, .name = "ALC282", .patch = patch_alc269 },
6048 { .id = 0x10ec0283, .name = "ALC283", .patch = patch_alc269 },
6049 { .id = 0x10ec0290, .name = "ALC290", .patch = patch_alc269 },
6050 { .id = 0x10ec0292, .name = "ALC292", .patch = patch_alc269 },
6051 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
6052 .patch = patch_alc861 },
6053 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
6054 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
6055 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
6056 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
6057 .patch = patch_alc882 },
6058 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
6059 .patch = patch_alc662 },
6060 { .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
6061 .patch = patch_alc662 },
6062 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
6063 { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
6064 { .id = 0x10ec0668, .name = "ALC668", .patch = patch_alc662 },
6065 { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
6066 { .id = 0x10ec0671, .name = "ALC671", .patch = patch_alc662 },
6067 { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
6068 { .id = 0x10ec0867, .name = "ALC891", .patch = patch_alc882 },
6069 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
6070 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
6071 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
6072 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
6073 .patch = patch_alc882 },
6074 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
6075 .patch = patch_alc882 },
6076 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
6077 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
6078 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
6079 .patch = patch_alc882 },
6080 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
6081 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
6082 { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
6083 { .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
6084 { .id = 0x10ec0900, .name = "ALC1150", .patch = patch_alc882 },
6088 MODULE_ALIAS("snd-hda-codec-id:10ec*");
6090 MODULE_LICENSE("GPL");
6091 MODULE_DESCRIPTION("Realtek HD-audio codec");
6093 static struct hda_codec_preset_list realtek_list = {
6094 .preset = snd_hda_preset_realtek,
6095 .owner = THIS_MODULE,
6098 static int __init patch_realtek_init(void)
6100 return snd_hda_add_codec_preset(&realtek_list);
6103 static void __exit patch_realtek_exit(void)
6105 snd_hda_delete_codec_preset(&realtek_list);
6108 module_init(patch_realtek_init)
6109 module_exit(patch_realtek_exit)