2 * Universal Interface for Intel High Definition Audio Codec
4 * HD audio interface patch for Realtek ALC codecs
6 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
7 * PeiSen Hou <pshou@realtek.com.tw>
8 * Takashi Iwai <tiwai@suse.de>
9 * Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
11 * This driver is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This driver is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/pci.h>
30 #include <linux/module.h>
31 #include <sound/core.h>
32 #include <sound/jack.h>
33 #include "hda_codec.h"
34 #include "hda_local.h"
38 /* unsol event tags */
39 #define ALC_FRONT_EVENT 0x01
40 #define ALC_DCVOL_EVENT 0x02
41 #define ALC_HP_EVENT 0x04
42 #define ALC_MIC_EVENT 0x08
45 #define GPIO_MASK 0x03
47 /* extra amp-initialization sequence types */
56 struct alc_customize_define {
58 unsigned char port_connectivity;
59 unsigned char check_sum;
60 unsigned char customization;
61 unsigned char external_amp;
62 unsigned int enable_pcbeep:1;
63 unsigned int platform_type:1;
65 unsigned int override:1;
66 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */
72 hda_nid_t pin; /* multi-io widget pin NID */
73 hda_nid_t dac; /* DAC to be connected */
74 unsigned int ctl_in; /* cached input-pin control value */
78 ALC_AUTOMUTE_PIN, /* change the pin control */
79 ALC_AUTOMUTE_AMP, /* mute/unmute the pin AMP */
80 ALC_AUTOMUTE_MIXER, /* mute/unmute mixer widget AMP */
83 #define MAX_VOL_NIDS 0x40
86 /* codec parameterization */
87 const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
88 unsigned int num_mixers;
89 const struct snd_kcontrol_new *cap_mixer; /* capture mixer */
90 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
92 const struct hda_verb *init_verbs[10]; /* initialization verbs
96 unsigned int num_init_verbs;
98 char stream_name_analog[32]; /* analog PCM stream */
99 const struct hda_pcm_stream *stream_analog_playback;
100 const struct hda_pcm_stream *stream_analog_capture;
101 const struct hda_pcm_stream *stream_analog_alt_playback;
102 const struct hda_pcm_stream *stream_analog_alt_capture;
104 char stream_name_digital[32]; /* digital PCM stream */
105 const struct hda_pcm_stream *stream_digital_playback;
106 const struct hda_pcm_stream *stream_digital_capture;
109 struct hda_multi_out multiout; /* playback set-up
110 * max_channels, dacs must be set
111 * dig_out_nid and hp_nid are optional
113 hda_nid_t alt_dac_nid;
114 hda_nid_t slave_dig_outs[3]; /* optional - for auto-parsing */
118 unsigned int num_adc_nids;
119 const hda_nid_t *adc_nids;
120 const hda_nid_t *capsrc_nids;
121 hda_nid_t dig_in_nid; /* digital-in NID; optional */
122 hda_nid_t mixer_nid; /* analog-mixer NID */
123 DECLARE_BITMAP(vol_ctls, MAX_VOL_NIDS << 1);
124 DECLARE_BITMAP(sw_ctls, MAX_VOL_NIDS << 1);
126 /* capture setup for dynamic dual-adc switch */
128 unsigned int cur_adc_stream_tag;
129 unsigned int cur_adc_format;
132 unsigned int num_mux_defs;
133 const struct hda_input_mux *input_mux;
134 unsigned int cur_mux[3];
135 hda_nid_t ext_mic_pin;
136 hda_nid_t dock_mic_pin;
137 hda_nid_t int_mic_pin;
140 const struct hda_channel_mode *channel_mode;
141 int num_channel_mode;
143 int const_channel_count;
144 int ext_channel_count;
146 /* PCM information */
147 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
149 /* dynamic controls, init_verbs and input_mux */
150 struct auto_pin_cfg autocfg;
151 struct alc_customize_define cdefine;
152 struct snd_array kctls;
153 struct hda_input_mux private_imux[3];
154 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
155 hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
156 hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
157 hda_nid_t imux_pins[HDA_MAX_NUM_INPUTS];
158 unsigned int dyn_adc_idx[HDA_MAX_NUM_INPUTS];
159 int int_mic_idx, ext_mic_idx, dock_mic_idx; /* for auto-mic */
162 void (*init_hook)(struct hda_codec *codec);
163 void (*unsol_event)(struct hda_codec *codec, unsigned int res);
164 #ifdef CONFIG_SND_HDA_POWER_SAVE
165 void (*power_hook)(struct hda_codec *codec);
167 void (*shutup)(struct hda_codec *codec);
168 void (*automute_hook)(struct hda_codec *codec);
170 /* for pin sensing */
171 unsigned int hp_jack_present:1;
172 unsigned int line_jack_present:1;
173 unsigned int master_mute:1;
174 unsigned int auto_mic:1;
175 unsigned int auto_mic_valid_imux:1; /* valid imux for auto-mic */
176 unsigned int automute_speaker:1; /* automute speaker outputs */
177 unsigned int automute_lo:1; /* automute LO outputs */
178 unsigned int detect_hp:1; /* Headphone detection enabled */
179 unsigned int detect_lo:1; /* Line-out detection enabled */
180 unsigned int automute_speaker_possible:1; /* there are speakers and either LO or HP */
181 unsigned int automute_lo_possible:1; /* there are line outs and HP */
182 unsigned int keep_vref_in_automute:1; /* Don't clear VREF in automute */
185 unsigned int no_analog :1; /* digital I/O only */
186 unsigned int dyn_adc_switch:1; /* switch ADCs (for ALC275) */
187 unsigned int single_input_src:1;
188 unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */
189 unsigned int parse_flags; /* passed to snd_hda_parse_pin_defcfg() */
190 unsigned int shared_mic_hp:1; /* HP/Mic-in sharing */
192 /* auto-mute control */
194 hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];
197 int codec_variant; /* flag for other variants */
199 /* for virtual master */
200 hda_nid_t vmaster_nid;
201 #ifdef CONFIG_SND_HDA_POWER_SAVE
202 struct hda_loopback_check loopback;
207 unsigned int pll_coef_idx, pll_coef_bit;
212 const struct alc_fixup *fixup_list;
213 const char *fixup_name;
217 struct alc_multi_io multi_io[4];
220 struct snd_array bind_ctls;
223 #define ALC_MODEL_AUTO 0 /* common for all chips */
225 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
226 int dir, unsigned int bits)
230 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
231 if (query_amp_caps(codec, nid, dir) & bits)
236 #define nid_has_mute(codec, nid, dir) \
237 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
238 #define nid_has_volume(codec, nid, dir) \
239 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
244 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
245 struct snd_ctl_elem_info *uinfo)
247 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
248 struct alc_spec *spec = codec->spec;
249 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
250 if (mux_idx >= spec->num_mux_defs)
252 if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
254 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
257 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
258 struct snd_ctl_elem_value *ucontrol)
260 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
261 struct alc_spec *spec = codec->spec;
262 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
264 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
268 static bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
270 struct alc_spec *spec = codec->spec;
271 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
273 if (spec->cur_adc && spec->cur_adc != new_adc) {
274 /* stream is running, let's swap the current ADC */
275 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
276 spec->cur_adc = new_adc;
277 snd_hda_codec_setup_stream(codec, new_adc,
278 spec->cur_adc_stream_tag, 0,
279 spec->cur_adc_format);
285 static inline hda_nid_t get_capsrc(struct alc_spec *spec, int idx)
287 return spec->capsrc_nids ?
288 spec->capsrc_nids[idx] : spec->adc_nids[idx];
291 static void call_update_outputs(struct hda_codec *codec);
293 /* select the given imux item; either unmute exclusively or select the route */
294 static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
295 unsigned int idx, bool force)
297 struct alc_spec *spec = codec->spec;
298 const struct hda_input_mux *imux;
299 unsigned int mux_idx;
300 int i, type, num_conns;
303 mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
304 imux = &spec->input_mux[mux_idx];
305 if (!imux->num_items && mux_idx > 0)
306 imux = &spec->input_mux[0];
307 if (!imux->num_items)
310 if (idx >= imux->num_items)
311 idx = imux->num_items - 1;
312 if (spec->cur_mux[adc_idx] == idx && !force)
314 spec->cur_mux[adc_idx] = idx;
316 /* for shared I/O, change the pin-control accordingly */
317 if (spec->shared_mic_hp) {
318 /* NOTE: this assumes that there are only two inputs, the
319 * first is the real internal mic and the second is HP jack.
321 snd_hda_codec_write(codec, spec->autocfg.inputs[1].pin, 0,
322 AC_VERB_SET_PIN_WIDGET_CONTROL,
323 spec->cur_mux[adc_idx] ?
324 PIN_VREF80 : PIN_HP);
325 spec->automute_speaker = !spec->cur_mux[adc_idx];
326 call_update_outputs(codec);
329 if (spec->dyn_adc_switch) {
330 alc_dyn_adc_pcm_resetup(codec, idx);
331 adc_idx = spec->dyn_adc_idx[idx];
334 nid = get_capsrc(spec, adc_idx);
337 num_conns = snd_hda_get_conn_list(codec, nid, NULL);
341 type = get_wcaps_type(get_wcaps(codec, nid));
342 if (type == AC_WID_AUD_MIX) {
343 /* Matrix-mixer style (e.g. ALC882) */
344 int active = imux->items[idx].index;
345 for (i = 0; i < num_conns; i++) {
346 unsigned int v = (i == active) ? 0 : HDA_AMP_MUTE;
347 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, i,
351 /* MUX style (e.g. ALC880) */
352 snd_hda_codec_write_cache(codec, nid, 0,
353 AC_VERB_SET_CONNECT_SEL,
354 imux->items[idx].index);
359 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
360 struct snd_ctl_elem_value *ucontrol)
362 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
363 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
364 return alc_mux_select(codec, adc_idx,
365 ucontrol->value.enumerated.item[0], false);
369 * set up the input pin config (depending on the given auto-pin type)
371 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
374 unsigned int val = PIN_IN;
376 if (auto_pin_type == AUTO_PIN_MIC) {
379 oldval = snd_hda_codec_read(codec, nid, 0,
380 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
381 pincap = snd_hda_query_pin_caps(codec, nid);
382 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
383 /* if the default pin setup is vref50, we give it priority */
384 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
386 else if (pincap & AC_PINCAP_VREF_50)
388 else if (pincap & AC_PINCAP_VREF_100)
390 else if (pincap & AC_PINCAP_VREF_GRD)
393 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
397 * Append the given mixer and verb elements for the later use
398 * The mixer array is referred in build_controls(), and init_verbs are
401 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
403 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
405 spec->mixers[spec->num_mixers++] = mix;
408 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
410 if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
412 spec->init_verbs[spec->num_init_verbs++] = verb;
416 * GPIO setup tables, used in initialization
418 /* Enable GPIO mask and set output */
419 static const struct hda_verb alc_gpio1_init_verbs[] = {
420 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
421 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
422 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
426 static const struct hda_verb alc_gpio2_init_verbs[] = {
427 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
428 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
429 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
433 static const struct hda_verb alc_gpio3_init_verbs[] = {
434 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
435 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
436 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
441 * Fix hardware PLL issue
442 * On some codecs, the analog PLL gating control must be off while
443 * the default value is 1.
445 static void alc_fix_pll(struct hda_codec *codec)
447 struct alc_spec *spec = codec->spec;
452 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
454 val = snd_hda_codec_read(codec, spec->pll_nid, 0,
455 AC_VERB_GET_PROC_COEF, 0);
456 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
458 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
459 val & ~(1 << spec->pll_coef_bit));
462 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
463 unsigned int coef_idx, unsigned int coef_bit)
465 struct alc_spec *spec = codec->spec;
467 spec->pll_coef_idx = coef_idx;
468 spec->pll_coef_bit = coef_bit;
473 * Jack detections for HP auto-mute and mic-switch
476 /* check each pin in the given array; returns true if any of them is plugged */
477 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
481 for (i = 0; i < num_pins; i++) {
482 hda_nid_t nid = pins[i];
485 present |= snd_hda_jack_detect(codec, nid);
490 /* standard HP/line-out auto-mute helper */
491 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
492 bool mute, bool hp_out)
494 struct alc_spec *spec = codec->spec;
495 unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;
496 unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
499 for (i = 0; i < num_pins; i++) {
500 hda_nid_t nid = pins[i];
504 switch (spec->automute_mode) {
505 case ALC_AUTOMUTE_PIN:
506 /* don't reset VREF value in case it's controlling
507 * the amp (see alc861_fixup_asus_amp_vref_0f())
509 if (spec->keep_vref_in_automute) {
510 val = snd_hda_codec_read(codec, nid, 0,
511 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
516 snd_hda_codec_write(codec, nid, 0,
517 AC_VERB_SET_PIN_WIDGET_CONTROL,
520 case ALC_AUTOMUTE_AMP:
521 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
522 HDA_AMP_MUTE, mute_bits);
524 case ALC_AUTOMUTE_MIXER:
525 nid = spec->automute_mixer_nid[i];
528 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
529 HDA_AMP_MUTE, mute_bits);
530 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,
531 HDA_AMP_MUTE, mute_bits);
537 /* Toggle outputs muting */
538 static void update_outputs(struct hda_codec *codec)
540 struct alc_spec *spec = codec->spec;
543 /* Control HP pins/amps depending on master_mute state;
544 * in general, HP pins/amps control should be enabled in all cases,
545 * but currently set only for master_mute, just to be safe
547 if (!spec->shared_mic_hp) /* don't change HP-pin when shared with mic */
548 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
549 spec->autocfg.hp_pins, spec->master_mute, true);
551 if (!spec->automute_speaker)
554 on = spec->hp_jack_present | spec->line_jack_present;
555 on |= spec->master_mute;
556 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
557 spec->autocfg.speaker_pins, on, false);
559 /* toggle line-out mutes if needed, too */
560 /* if LO is a copy of either HP or Speaker, don't need to handle it */
561 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
562 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
564 if (!spec->automute_lo)
567 on = spec->hp_jack_present;
568 on |= spec->master_mute;
569 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
570 spec->autocfg.line_out_pins, on, false);
573 static void call_update_outputs(struct hda_codec *codec)
575 struct alc_spec *spec = codec->spec;
576 if (spec->automute_hook)
577 spec->automute_hook(codec);
579 update_outputs(codec);
582 /* standard HP-automute helper */
583 static void alc_hp_automute(struct hda_codec *codec)
585 struct alc_spec *spec = codec->spec;
587 spec->hp_jack_present =
588 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
589 spec->autocfg.hp_pins);
590 if (!spec->detect_hp || (!spec->automute_speaker && !spec->automute_lo))
592 call_update_outputs(codec);
595 /* standard line-out-automute helper */
596 static void alc_line_automute(struct hda_codec *codec)
598 struct alc_spec *spec = codec->spec;
600 /* check LO jack only when it's different from HP */
601 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0])
604 spec->line_jack_present =
605 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
606 spec->autocfg.line_out_pins);
607 if (!spec->automute_speaker || !spec->detect_lo)
609 call_update_outputs(codec);
612 #define get_connection_index(codec, mux, nid) \
613 snd_hda_get_conn_index(codec, mux, nid, 0)
615 /* standard mic auto-switch helper */
616 static void alc_mic_automute(struct hda_codec *codec)
618 struct alc_spec *spec = codec->spec;
619 hda_nid_t *pins = spec->imux_pins;
621 if (!spec->auto_mic || !spec->auto_mic_valid_imux)
623 if (snd_BUG_ON(!spec->adc_nids))
625 if (snd_BUG_ON(spec->int_mic_idx < 0 || spec->ext_mic_idx < 0))
628 if (snd_hda_jack_detect(codec, pins[spec->ext_mic_idx]))
629 alc_mux_select(codec, 0, spec->ext_mic_idx, false);
630 else if (spec->dock_mic_idx >= 0 &&
631 snd_hda_jack_detect(codec, pins[spec->dock_mic_idx]))
632 alc_mux_select(codec, 0, spec->dock_mic_idx, false);
634 alc_mux_select(codec, 0, spec->int_mic_idx, false);
637 /* handle the specified unsol action (ALC_XXX_EVENT) */
638 static void alc_exec_unsol_event(struct hda_codec *codec, int action)
642 alc_hp_automute(codec);
644 case ALC_FRONT_EVENT:
645 alc_line_automute(codec);
648 alc_mic_automute(codec);
651 snd_hda_jack_report_sync(codec);
654 /* unsolicited event for HP jack sensing */
655 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
657 if (codec->vendor_id == 0x10ec0880)
661 res = snd_hda_jack_get_action(codec, res);
662 alc_exec_unsol_event(codec, res);
665 /* call init functions of standard auto-mute helpers */
666 static void alc_inithook(struct hda_codec *codec)
668 alc_hp_automute(codec);
669 alc_line_automute(codec);
670 alc_mic_automute(codec);
673 /* additional initialization for ALC888 variants */
674 static void alc888_coef_init(struct hda_codec *codec)
678 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
679 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
680 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
681 if ((tmp & 0xf0) == 0x20)
683 snd_hda_codec_read(codec, 0x20, 0,
684 AC_VERB_SET_PROC_COEF, 0x830);
687 snd_hda_codec_read(codec, 0x20, 0,
688 AC_VERB_SET_PROC_COEF, 0x3030);
691 /* additional initialization for ALC889 variants */
692 static void alc889_coef_init(struct hda_codec *codec)
696 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
697 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
698 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
699 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
702 /* turn on/off EAPD control (only if available) */
703 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
705 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
707 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
708 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
712 /* turn on/off EAPD controls of the codec */
713 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
715 /* We currently only handle front, HP */
716 static hda_nid_t pins[] = {
717 0x0f, 0x10, 0x14, 0x15, 0
720 for (p = pins; *p; p++)
721 set_eapd(codec, *p, on);
724 /* generic shutup callback;
725 * just turning off EPAD and a little pause for avoiding pop-noise
727 static void alc_eapd_shutup(struct hda_codec *codec)
729 alc_auto_setup_eapd(codec, false);
733 /* generic EAPD initialization */
734 static void alc_auto_init_amp(struct hda_codec *codec, int type)
738 alc_auto_setup_eapd(codec, true);
741 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
744 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
747 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
749 case ALC_INIT_DEFAULT:
750 switch (codec->vendor_id) {
752 snd_hda_codec_write(codec, 0x1a, 0,
753 AC_VERB_SET_COEF_INDEX, 7);
754 tmp = snd_hda_codec_read(codec, 0x1a, 0,
755 AC_VERB_GET_PROC_COEF, 0);
756 snd_hda_codec_write(codec, 0x1a, 0,
757 AC_VERB_SET_COEF_INDEX, 7);
758 snd_hda_codec_write(codec, 0x1a, 0,
759 AC_VERB_SET_PROC_COEF,
768 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
769 alc889_coef_init(codec);
772 alc888_coef_init(codec);
774 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
777 snd_hda_codec_write(codec, 0x20, 0,
778 AC_VERB_SET_COEF_INDEX, 7);
779 tmp = snd_hda_codec_read(codec, 0x20, 0,
780 AC_VERB_GET_PROC_COEF, 0);
781 snd_hda_codec_write(codec, 0x20, 0,
782 AC_VERB_SET_COEF_INDEX, 7);
783 snd_hda_codec_write(codec, 0x20, 0,
784 AC_VERB_SET_PROC_COEF,
794 * Auto-Mute mode mixer enum support
796 static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
797 struct snd_ctl_elem_info *uinfo)
799 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
800 struct alc_spec *spec = codec->spec;
801 static const char * const texts2[] = {
802 "Disabled", "Enabled"
804 static const char * const texts3[] = {
805 "Disabled", "Speaker Only", "Line Out+Speaker"
807 const char * const *texts;
809 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
811 if (spec->automute_speaker_possible && spec->automute_lo_possible) {
812 uinfo->value.enumerated.items = 3;
815 uinfo->value.enumerated.items = 2;
818 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
819 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
820 strcpy(uinfo->value.enumerated.name,
821 texts[uinfo->value.enumerated.item]);
825 static int alc_automute_mode_get(struct snd_kcontrol *kcontrol,
826 struct snd_ctl_elem_value *ucontrol)
828 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
829 struct alc_spec *spec = codec->spec;
830 unsigned int val = 0;
831 if (spec->automute_speaker)
833 if (spec->automute_lo)
836 ucontrol->value.enumerated.item[0] = val;
840 static int alc_automute_mode_put(struct snd_kcontrol *kcontrol,
841 struct snd_ctl_elem_value *ucontrol)
843 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
844 struct alc_spec *spec = codec->spec;
846 switch (ucontrol->value.enumerated.item[0]) {
848 if (!spec->automute_speaker && !spec->automute_lo)
850 spec->automute_speaker = 0;
851 spec->automute_lo = 0;
854 if (spec->automute_speaker_possible) {
855 if (!spec->automute_lo && spec->automute_speaker)
857 spec->automute_speaker = 1;
858 spec->automute_lo = 0;
859 } else if (spec->automute_lo_possible) {
860 if (spec->automute_lo)
862 spec->automute_lo = 1;
867 if (!spec->automute_lo_possible || !spec->automute_speaker_possible)
869 if (spec->automute_speaker && spec->automute_lo)
871 spec->automute_speaker = 1;
872 spec->automute_lo = 1;
877 call_update_outputs(codec);
881 static const struct snd_kcontrol_new alc_automute_mode_enum = {
882 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
883 .name = "Auto-Mute Mode",
884 .info = alc_automute_mode_info,
885 .get = alc_automute_mode_get,
886 .put = alc_automute_mode_put,
889 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
891 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
892 return snd_array_new(&spec->kctls);
895 static int alc_add_automute_mode_enum(struct hda_codec *codec)
897 struct alc_spec *spec = codec->spec;
898 struct snd_kcontrol_new *knew;
900 knew = alc_kcontrol_new(spec);
903 *knew = alc_automute_mode_enum;
904 knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
911 * Check the availability of HP/line-out auto-mute;
912 * Set up appropriately if really supported
914 static void alc_init_automute(struct hda_codec *codec)
916 struct alc_spec *spec = codec->spec;
917 struct auto_pin_cfg *cfg = &spec->autocfg;
923 if (cfg->line_out_pins[0])
925 if (cfg->speaker_pins[0])
927 if (present < 2) /* need two different output types */
930 if (!cfg->speaker_pins[0] &&
931 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
932 memcpy(cfg->speaker_pins, cfg->line_out_pins,
933 sizeof(cfg->speaker_pins));
934 cfg->speaker_outs = cfg->line_outs;
937 if (!cfg->hp_pins[0] &&
938 cfg->line_out_type == AUTO_PIN_HP_OUT) {
939 memcpy(cfg->hp_pins, cfg->line_out_pins,
940 sizeof(cfg->hp_pins));
941 cfg->hp_outs = cfg->line_outs;
944 spec->automute_mode = ALC_AUTOMUTE_PIN;
946 for (i = 0; i < cfg->hp_outs; i++) {
947 hda_nid_t nid = cfg->hp_pins[i];
948 if (!is_jack_detectable(codec, nid))
950 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
952 snd_hda_jack_detect_enable(codec, nid, ALC_HP_EVENT);
956 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && cfg->line_outs) {
957 if (cfg->speaker_outs)
958 for (i = 0; i < cfg->line_outs; i++) {
959 hda_nid_t nid = cfg->line_out_pins[i];
960 if (!is_jack_detectable(codec, nid))
962 snd_printdd("realtek: Enable Line-Out "
963 "auto-muting on NID 0x%x\n", nid);
964 snd_hda_jack_detect_enable(codec, nid,
968 spec->automute_lo_possible = spec->detect_hp;
971 spec->automute_speaker_possible = cfg->speaker_outs &&
972 (spec->detect_hp || spec->detect_lo);
974 spec->automute_lo = spec->automute_lo_possible;
975 spec->automute_speaker = spec->automute_speaker_possible;
977 if (spec->automute_speaker_possible || spec->automute_lo_possible) {
978 /* create a control for automute mode */
979 alc_add_automute_mode_enum(codec);
980 spec->unsol_event = alc_sku_unsol_event;
984 /* return the position of NID in the list, or -1 if not found */
985 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
988 for (i = 0; i < nums; i++)
994 /* check whether dynamic ADC-switching is available */
995 static bool alc_check_dyn_adc_switch(struct hda_codec *codec)
997 struct alc_spec *spec = codec->spec;
998 struct hda_input_mux *imux = &spec->private_imux[0];
1002 if (imux != spec->input_mux) /* no dynamic imux? */
1005 for (n = 0; n < spec->num_adc_nids; n++) {
1006 cap = spec->private_capsrc_nids[n];
1007 for (i = 0; i < imux->num_items; i++) {
1008 pin = spec->imux_pins[i];
1011 if (get_connection_index(codec, cap, pin) < 0)
1014 if (i >= imux->num_items)
1015 return true; /* no ADC-switch is needed */
1018 for (i = 0; i < imux->num_items; i++) {
1019 pin = spec->imux_pins[i];
1020 for (n = 0; n < spec->num_adc_nids; n++) {
1021 cap = spec->private_capsrc_nids[n];
1022 idx = get_connection_index(codec, cap, pin);
1024 imux->items[i].index = idx;
1025 spec->dyn_adc_idx[i] = n;
1031 snd_printdd("realtek: enabling ADC switching\n");
1032 spec->dyn_adc_switch = 1;
1036 /* rebuild imux for matching with the given auto-mic pins (if not yet) */
1037 static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec)
1039 struct alc_spec *spec = codec->spec;
1040 struct hda_input_mux *imux;
1041 static char * const texts[3] = {
1042 "Mic", "Internal Mic", "Dock Mic"
1046 if (!spec->auto_mic)
1048 imux = &spec->private_imux[0];
1049 if (spec->input_mux == imux)
1051 spec->imux_pins[0] = spec->ext_mic_pin;
1052 spec->imux_pins[1] = spec->int_mic_pin;
1053 spec->imux_pins[2] = spec->dock_mic_pin;
1054 for (i = 0; i < 3; i++) {
1055 strcpy(imux->items[i].label, texts[i]);
1056 if (spec->imux_pins[i]) {
1057 hda_nid_t pin = spec->imux_pins[i];
1059 for (c = 0; c < spec->num_adc_nids; c++) {
1060 hda_nid_t cap = get_capsrc(spec, c);
1061 int idx = get_connection_index(codec, cap, pin);
1063 imux->items[i].index = idx;
1067 imux->num_items = i + 1;
1070 spec->num_mux_defs = 1;
1071 spec->input_mux = imux;
1075 /* check whether all auto-mic pins are valid; setup indices if OK */
1076 static bool alc_auto_mic_check_imux(struct hda_codec *codec)
1078 struct alc_spec *spec = codec->spec;
1079 const struct hda_input_mux *imux;
1081 if (!spec->auto_mic)
1083 if (spec->auto_mic_valid_imux)
1084 return true; /* already checked */
1086 /* fill up imux indices */
1087 if (!alc_check_dyn_adc_switch(codec)) {
1092 imux = spec->input_mux;
1093 spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin,
1094 spec->imux_pins, imux->num_items);
1095 spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin,
1096 spec->imux_pins, imux->num_items);
1097 spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin,
1098 spec->imux_pins, imux->num_items);
1099 if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) {
1101 return false; /* no corresponding imux */
1104 snd_hda_jack_detect_enable(codec, spec->ext_mic_pin, ALC_MIC_EVENT);
1105 if (spec->dock_mic_pin)
1106 snd_hda_jack_detect_enable(codec, spec->dock_mic_pin,
1109 spec->auto_mic_valid_imux = 1;
1115 * Check the availability of auto-mic switch;
1116 * Set up if really supported
1118 static void alc_init_auto_mic(struct hda_codec *codec)
1120 struct alc_spec *spec = codec->spec;
1121 struct auto_pin_cfg *cfg = &spec->autocfg;
1122 hda_nid_t fixed, ext, dock;
1125 if (spec->shared_mic_hp)
1126 return; /* no auto-mic for the shared I/O */
1128 spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1;
1130 fixed = ext = dock = 0;
1131 for (i = 0; i < cfg->num_inputs; i++) {
1132 hda_nid_t nid = cfg->inputs[i].pin;
1133 unsigned int defcfg;
1134 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1135 switch (snd_hda_get_input_pin_attr(defcfg)) {
1136 case INPUT_PIN_ATTR_INT:
1138 return; /* already occupied */
1139 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1140 return; /* invalid type */
1143 case INPUT_PIN_ATTR_UNUSED:
1144 return; /* invalid entry */
1145 case INPUT_PIN_ATTR_DOCK:
1147 return; /* already occupied */
1148 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
1149 return; /* invalid type */
1154 return; /* already occupied */
1155 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1156 return; /* invalid type */
1167 if (!is_jack_detectable(codec, ext))
1168 return; /* no unsol support */
1169 if (dock && !is_jack_detectable(codec, dock))
1170 return; /* no unsol support */
1172 /* check imux indices */
1173 spec->ext_mic_pin = ext;
1174 spec->int_mic_pin = fixed;
1175 spec->dock_mic_pin = dock;
1178 if (!alc_auto_mic_check_imux(codec))
1181 snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1183 spec->unsol_event = alc_sku_unsol_event;
1186 /* check the availabilities of auto-mute and auto-mic switches */
1187 static void alc_auto_check_switches(struct hda_codec *codec)
1189 alc_init_automute(codec);
1190 alc_init_auto_mic(codec);
1194 * Realtek SSID verification
1197 /* Could be any non-zero and even value. When used as fixup, tells
1198 * the driver to ignore any present sku defines.
1200 #define ALC_FIXUP_SKU_IGNORE (2)
1202 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1204 unsigned int ass, tmp, i;
1206 struct alc_spec *spec = codec->spec;
1208 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1210 if (spec->cdefine.fixup) {
1211 ass = spec->cdefine.sku_cfg;
1212 if (ass == ALC_FIXUP_SKU_IGNORE)
1217 ass = codec->subsystem_id & 0xffff;
1218 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1222 if (codec->vendor_id == 0x10ec0260)
1224 ass = snd_hda_codec_get_pincfg(codec, nid);
1227 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1228 codec->chip_name, ass);
1234 for (i = 1; i < 16; i++) {
1238 if (((ass >> 16) & 0xf) != tmp)
1241 spec->cdefine.port_connectivity = ass >> 30;
1242 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1243 spec->cdefine.check_sum = (ass >> 16) & 0xf;
1244 spec->cdefine.customization = ass >> 8;
1246 spec->cdefine.sku_cfg = ass;
1247 spec->cdefine.external_amp = (ass & 0x38) >> 3;
1248 spec->cdefine.platform_type = (ass & 0x4) >> 2;
1249 spec->cdefine.swap = (ass & 0x2) >> 1;
1250 spec->cdefine.override = ass & 0x1;
1252 snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1253 nid, spec->cdefine.sku_cfg);
1254 snd_printd("SKU: port_connectivity=0x%x\n",
1255 spec->cdefine.port_connectivity);
1256 snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1257 snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1258 snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1259 snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1260 snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1261 snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1262 snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1267 /* return true if the given NID is found in the list */
1268 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1270 return find_idx_in_nid_list(nid, list, nums) >= 0;
1273 /* check subsystem ID and set up device-specific initialization;
1274 * return 1 if initialized, 0 if invalid SSID
1276 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1277 * 31 ~ 16 : Manufacture ID
1279 * 7 ~ 0 : Assembly ID
1280 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1282 static int alc_subsystem_id(struct hda_codec *codec,
1283 hda_nid_t porta, hda_nid_t porte,
1284 hda_nid_t portd, hda_nid_t porti)
1286 unsigned int ass, tmp, i;
1288 struct alc_spec *spec = codec->spec;
1290 if (spec->cdefine.fixup) {
1291 ass = spec->cdefine.sku_cfg;
1292 if (ass == ALC_FIXUP_SKU_IGNORE)
1297 ass = codec->subsystem_id & 0xffff;
1298 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1301 /* invalid SSID, check the special NID pin defcfg instead */
1303 * 31~30 : port connectivity
1306 * 19~16 : Check sum (15:1)
1311 if (codec->vendor_id == 0x10ec0260)
1313 ass = snd_hda_codec_get_pincfg(codec, nid);
1314 snd_printd("realtek: No valid SSID, "
1315 "checking pincfg 0x%08x for NID 0x%x\n",
1319 if ((ass >> 30) != 1) /* no physical connection */
1324 for (i = 1; i < 16; i++) {
1328 if (((ass >> 16) & 0xf) != tmp)
1331 snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1332 ass & 0xffff, codec->vendor_id);
1336 * 2 : 0 --> Desktop, 1 --> Laptop
1337 * 3~5 : External Amplifier control
1340 tmp = (ass & 0x38) >> 3; /* external Amp control */
1343 spec->init_amp = ALC_INIT_GPIO1;
1346 spec->init_amp = ALC_INIT_GPIO2;
1349 spec->init_amp = ALC_INIT_GPIO3;
1353 spec->init_amp = ALC_INIT_DEFAULT;
1357 /* is laptop or Desktop and enable the function "Mute internal speaker
1358 * when the external headphone out jack is plugged"
1360 if (!(ass & 0x8000))
1363 * 10~8 : Jack location
1364 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1366 * 15 : 1 --> enable the function "Mute internal speaker
1367 * when the external headphone out jack is plugged"
1369 if (!spec->autocfg.hp_pins[0] &&
1370 !(spec->autocfg.line_out_pins[0] &&
1371 spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
1373 tmp = (ass >> 11) & 0x3; /* HP to chassis */
1384 if (found_in_nid_list(nid, spec->autocfg.line_out_pins,
1385 spec->autocfg.line_outs))
1387 spec->autocfg.hp_pins[0] = nid;
1392 /* Check the validity of ALC subsystem-id
1393 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
1394 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
1396 if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {
1397 struct alc_spec *spec = codec->spec;
1398 snd_printd("realtek: "
1399 "Enable default setup for auto mode as fallback\n");
1400 spec->init_amp = ALC_INIT_DEFAULT;
1405 * Fix-up pin default configurations and add default verbs
1413 struct alc_model_fixup {
1424 const struct alc_pincfg *pins;
1425 const struct hda_verb *verbs;
1426 void (*func)(struct hda_codec *codec,
1427 const struct alc_fixup *fix,
1441 ALC_FIXUP_ACT_PRE_PROBE,
1442 ALC_FIXUP_ACT_PROBE,
1446 static void alc_apply_fixup(struct hda_codec *codec, int action)
1448 struct alc_spec *spec = codec->spec;
1449 int id = spec->fixup_id;
1450 #ifdef CONFIG_SND_DEBUG_VERBOSE
1451 const char *modelname = spec->fixup_name;
1455 if (!spec->fixup_list)
1459 const struct alc_fixup *fix = spec->fixup_list + id;
1460 const struct alc_pincfg *cfg;
1462 switch (fix->type) {
1464 if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1466 snd_printdd(KERN_INFO "hda_codec: %s: "
1467 "Apply sku override for %s\n",
1468 codec->chip_name, modelname);
1469 spec->cdefine.sku_cfg = fix->v.sku;
1470 spec->cdefine.fixup = 1;
1472 case ALC_FIXUP_PINS:
1474 if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1476 snd_printdd(KERN_INFO "hda_codec: %s: "
1477 "Apply pincfg for %s\n",
1478 codec->chip_name, modelname);
1479 for (; cfg->nid; cfg++)
1480 snd_hda_codec_set_pincfg(codec, cfg->nid,
1483 case ALC_FIXUP_VERBS:
1484 if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1486 snd_printdd(KERN_INFO "hda_codec: %s: "
1487 "Apply fix-verbs for %s\n",
1488 codec->chip_name, modelname);
1489 add_verb(codec->spec, fix->v.verbs);
1491 case ALC_FIXUP_FUNC:
1494 snd_printdd(KERN_INFO "hda_codec: %s: "
1495 "Apply fix-func for %s\n",
1496 codec->chip_name, modelname);
1497 fix->v.func(codec, fix, action);
1500 snd_printk(KERN_ERR "hda_codec: %s: "
1501 "Invalid fixup type %d\n",
1502 codec->chip_name, fix->type);
1513 static void alc_pick_fixup(struct hda_codec *codec,
1514 const struct alc_model_fixup *models,
1515 const struct snd_pci_quirk *quirk,
1516 const struct alc_fixup *fixlist)
1518 struct alc_spec *spec = codec->spec;
1519 const struct snd_pci_quirk *q;
1521 const char *name = NULL;
1523 if (codec->modelname && models) {
1524 while (models->name) {
1525 if (!strcmp(codec->modelname, models->name)) {
1527 name = models->name;
1534 q = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1537 #ifdef CONFIG_SND_DEBUG_VERBOSE
1543 for (q = quirk; q->subvendor; q++) {
1544 unsigned int vendorid =
1545 q->subdevice | (q->subvendor << 16);
1546 if (vendorid == codec->subsystem_id) {
1548 #ifdef CONFIG_SND_DEBUG_VERBOSE
1556 spec->fixup_id = id;
1558 spec->fixup_list = fixlist;
1559 spec->fixup_name = name;
1564 * COEF access helper functions
1566 static int alc_read_coef_idx(struct hda_codec *codec,
1567 unsigned int coef_idx)
1570 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1572 val = snd_hda_codec_read(codec, 0x20, 0,
1573 AC_VERB_GET_PROC_COEF, 0);
1577 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1578 unsigned int coef_val)
1580 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1582 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1586 /* a special bypass for COEF 0; read the cached value at the second time */
1587 static unsigned int alc_get_coef0(struct hda_codec *codec)
1589 struct alc_spec *spec = codec->spec;
1591 spec->coef0 = alc_read_coef_idx(codec, 0);
1596 * Digital I/O handling
1599 /* set right pin controls for digital I/O */
1600 static void alc_auto_init_digital(struct hda_codec *codec)
1602 struct alc_spec *spec = codec->spec;
1606 for (i = 0; i < spec->autocfg.dig_outs; i++) {
1607 pin = spec->autocfg.dig_out_pins[i];
1610 snd_hda_codec_write(codec, pin, 0,
1611 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
1613 dac = spec->multiout.dig_out_nid;
1615 dac = spec->slave_dig_outs[i - 1];
1616 if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
1618 snd_hda_codec_write(codec, dac, 0,
1619 AC_VERB_SET_AMP_GAIN_MUTE,
1622 pin = spec->autocfg.dig_in_pin;
1624 snd_hda_codec_write(codec, pin, 0,
1625 AC_VERB_SET_PIN_WIDGET_CONTROL,
1629 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1630 static void alc_auto_parse_digital(struct hda_codec *codec)
1632 struct alc_spec *spec = codec->spec;
1636 /* support multiple SPDIFs; the secondary is set up as a slave */
1638 for (i = 0; i < spec->autocfg.dig_outs; i++) {
1640 err = snd_hda_get_connections(codec,
1641 spec->autocfg.dig_out_pins[i],
1642 conn, ARRAY_SIZE(conn));
1645 dig_nid = conn[0]; /* assume the first element is audio-out */
1647 spec->multiout.dig_out_nid = dig_nid;
1648 spec->dig_out_type = spec->autocfg.dig_out_type[0];
1650 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1651 if (nums >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1653 spec->slave_dig_outs[nums - 1] = dig_nid;
1658 if (spec->autocfg.dig_in_pin) {
1659 dig_nid = codec->start_nid;
1660 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1661 unsigned int wcaps = get_wcaps(codec, dig_nid);
1662 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1664 if (!(wcaps & AC_WCAP_DIGITAL))
1666 if (!(wcaps & AC_WCAP_CONN_LIST))
1668 err = get_connection_index(codec, dig_nid,
1669 spec->autocfg.dig_in_pin);
1671 spec->dig_in_nid = dig_nid;
1679 * capture mixer elements
1681 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1682 struct snd_ctl_elem_info *uinfo)
1684 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1685 struct alc_spec *spec = codec->spec;
1689 mutex_lock(&codec->control_mutex);
1690 if (spec->vol_in_capsrc)
1691 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1693 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1694 kcontrol->private_value = val;
1695 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1696 mutex_unlock(&codec->control_mutex);
1700 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1701 unsigned int size, unsigned int __user *tlv)
1703 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1704 struct alc_spec *spec = codec->spec;
1708 mutex_lock(&codec->control_mutex);
1709 if (spec->vol_in_capsrc)
1710 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1712 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1713 kcontrol->private_value = val;
1714 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1715 mutex_unlock(&codec->control_mutex);
1719 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1720 struct snd_ctl_elem_value *ucontrol);
1722 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1723 struct snd_ctl_elem_value *ucontrol,
1724 getput_call_t func, bool check_adc_switch)
1726 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1727 struct alc_spec *spec = codec->spec;
1730 mutex_lock(&codec->control_mutex);
1731 if (check_adc_switch && spec->dyn_adc_switch) {
1732 for (i = 0; i < spec->num_adc_nids; i++) {
1733 kcontrol->private_value =
1734 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1736 err = func(kcontrol, ucontrol);
1741 i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1742 if (spec->vol_in_capsrc)
1743 kcontrol->private_value =
1744 HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i],
1747 kcontrol->private_value =
1748 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1750 err = func(kcontrol, ucontrol);
1753 mutex_unlock(&codec->control_mutex);
1757 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1758 struct snd_ctl_elem_value *ucontrol)
1760 return alc_cap_getput_caller(kcontrol, ucontrol,
1761 snd_hda_mixer_amp_volume_get, false);
1764 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1765 struct snd_ctl_elem_value *ucontrol)
1767 return alc_cap_getput_caller(kcontrol, ucontrol,
1768 snd_hda_mixer_amp_volume_put, true);
1771 /* capture mixer elements */
1772 #define alc_cap_sw_info snd_ctl_boolean_stereo_info
1774 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1775 struct snd_ctl_elem_value *ucontrol)
1777 return alc_cap_getput_caller(kcontrol, ucontrol,
1778 snd_hda_mixer_amp_switch_get, false);
1781 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1782 struct snd_ctl_elem_value *ucontrol)
1784 return alc_cap_getput_caller(kcontrol, ucontrol,
1785 snd_hda_mixer_amp_switch_put, true);
1788 #define _DEFINE_CAPMIX(num) \
1790 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1791 .name = "Capture Switch", \
1792 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1794 .info = alc_cap_sw_info, \
1795 .get = alc_cap_sw_get, \
1796 .put = alc_cap_sw_put, \
1799 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1800 .name = "Capture Volume", \
1801 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1802 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1803 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1805 .info = alc_cap_vol_info, \
1806 .get = alc_cap_vol_get, \
1807 .put = alc_cap_vol_put, \
1808 .tlv = { .c = alc_cap_vol_tlv }, \
1811 #define _DEFINE_CAPSRC(num) \
1813 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1814 /* .name = "Capture Source", */ \
1815 .name = "Input Source", \
1817 .info = alc_mux_enum_info, \
1818 .get = alc_mux_enum_get, \
1819 .put = alc_mux_enum_put, \
1822 #define DEFINE_CAPMIX(num) \
1823 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1824 _DEFINE_CAPMIX(num), \
1825 _DEFINE_CAPSRC(num), \
1829 #define DEFINE_CAPMIX_NOSRC(num) \
1830 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1831 _DEFINE_CAPMIX(num), \
1835 /* up to three ADCs */
1839 DEFINE_CAPMIX_NOSRC(1);
1840 DEFINE_CAPMIX_NOSRC(2);
1841 DEFINE_CAPMIX_NOSRC(3);
1844 * virtual master controls
1848 * slave controls for virtual master
1850 static const char * const alc_slave_vols[] = {
1851 "Front Playback Volume",
1852 "Surround Playback Volume",
1853 "Center Playback Volume",
1854 "LFE Playback Volume",
1855 "Side Playback Volume",
1856 "Headphone Playback Volume",
1857 "Speaker Playback Volume",
1858 "Mono Playback Volume",
1859 "Line Out Playback Volume",
1860 "CLFE Playback Volume",
1861 "Bass Speaker Playback Volume",
1862 "PCM Playback Volume",
1866 static const char * const alc_slave_sws[] = {
1867 "Front Playback Switch",
1868 "Surround Playback Switch",
1869 "Center Playback Switch",
1870 "LFE Playback Switch",
1871 "Side Playback Switch",
1872 "Headphone Playback Switch",
1873 "Speaker Playback Switch",
1874 "Mono Playback Switch",
1875 "IEC958 Playback Switch",
1876 "Line Out Playback Switch",
1877 "CLFE Playback Switch",
1878 "Bass Speaker Playback Switch",
1879 "PCM Playback Switch",
1884 * build control elements
1887 #define NID_MAPPING (-1)
1889 #define SUBDEV_SPEAKER_ (0 << 6)
1890 #define SUBDEV_HP_ (1 << 6)
1891 #define SUBDEV_LINE_ (2 << 6)
1892 #define SUBDEV_SPEAKER(x) (SUBDEV_SPEAKER_ | ((x) & 0x3f))
1893 #define SUBDEV_HP(x) (SUBDEV_HP_ | ((x) & 0x3f))
1894 #define SUBDEV_LINE(x) (SUBDEV_LINE_ | ((x) & 0x3f))
1896 static void alc_free_kctls(struct hda_codec *codec);
1898 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1899 /* additional beep mixers; the actual parameters are overwritten at build */
1900 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1901 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1902 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1907 static int __alc_build_controls(struct hda_codec *codec)
1909 struct alc_spec *spec = codec->spec;
1910 struct snd_kcontrol *kctl = NULL;
1911 const struct snd_kcontrol_new *knew;
1916 for (i = 0; i < spec->num_mixers; i++) {
1917 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1921 if (spec->cap_mixer) {
1922 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
1926 if (spec->multiout.dig_out_nid) {
1927 err = snd_hda_create_spdif_out_ctls(codec,
1928 spec->multiout.dig_out_nid,
1929 spec->multiout.dig_out_nid);
1932 if (!spec->no_analog) {
1933 err = snd_hda_create_spdif_share_sw(codec,
1937 spec->multiout.share_spdif = 1;
1940 if (spec->dig_in_nid) {
1941 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1946 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1947 /* create beep controls if needed */
1948 if (spec->beep_amp) {
1949 const struct snd_kcontrol_new *knew;
1950 for (knew = alc_beep_mixer; knew->name; knew++) {
1951 struct snd_kcontrol *kctl;
1952 kctl = snd_ctl_new1(knew, codec);
1955 kctl->private_value = spec->beep_amp;
1956 err = snd_hda_ctl_add(codec, 0, kctl);
1963 /* if we have no master control, let's create it */
1964 if (!spec->no_analog &&
1965 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1966 unsigned int vmaster_tlv[4];
1967 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1968 HDA_OUTPUT, vmaster_tlv);
1969 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1970 vmaster_tlv, alc_slave_vols);
1974 if (!spec->no_analog &&
1975 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1976 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1977 NULL, alc_slave_sws);
1982 /* assign Capture Source enums to NID */
1983 if (spec->capsrc_nids || spec->adc_nids) {
1984 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
1986 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1987 for (i = 0; kctl && i < kctl->count; i++) {
1988 err = snd_hda_add_nid(codec, kctl, i,
1989 get_capsrc(spec, i));
1994 if (spec->cap_mixer && spec->adc_nids) {
1995 const char *kname = kctl ? kctl->id.name : NULL;
1996 for (knew = spec->cap_mixer; knew->name; knew++) {
1997 if (kname && strcmp(knew->name, kname) == 0)
1999 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2000 for (i = 0; kctl && i < kctl->count; i++) {
2001 err = snd_hda_add_nid(codec, kctl, i,
2009 /* other nid->control mapping */
2010 for (i = 0; i < spec->num_mixers; i++) {
2011 for (knew = spec->mixers[i]; knew->name; knew++) {
2012 if (knew->iface != NID_MAPPING)
2014 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2017 u = knew->subdevice;
2018 for (j = 0; j < 4; j++, u >>= 8) {
2023 case SUBDEV_SPEAKER_:
2024 nid = spec->autocfg.speaker_pins[nid];
2027 nid = spec->autocfg.line_out_pins[nid];
2030 nid = spec->autocfg.hp_pins[nid];
2035 err = snd_hda_add_nid(codec, kctl, 0, nid);
2039 u = knew->private_value;
2040 for (j = 0; j < 4; j++, u >>= 8) {
2044 err = snd_hda_add_nid(codec, kctl, 0, nid);
2051 alc_free_kctls(codec); /* no longer needed */
2056 static int alc_build_controls(struct hda_codec *codec)
2058 struct alc_spec *spec = codec->spec;
2059 int err = __alc_build_controls(codec);
2062 return snd_hda_jack_add_kctls(codec, &spec->autocfg);
2070 static void alc_init_special_input_src(struct hda_codec *codec);
2071 static int alc269_fill_coef(struct hda_codec *codec);
2073 static int alc_init(struct hda_codec *codec)
2075 struct alc_spec *spec = codec->spec;
2078 if (codec->vendor_id == 0x10ec0269)
2079 alc269_fill_coef(codec);
2082 alc_auto_init_amp(codec, spec->init_amp);
2084 for (i = 0; i < spec->num_init_verbs; i++)
2085 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2086 alc_init_special_input_src(codec);
2088 if (spec->init_hook)
2089 spec->init_hook(codec);
2091 alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
2093 snd_hda_jack_report_sync(codec);
2095 hda_call_check_power_status(codec, 0x01);
2099 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2101 struct alc_spec *spec = codec->spec;
2103 if (spec->unsol_event)
2104 spec->unsol_event(codec, res);
2107 #ifdef CONFIG_SND_HDA_POWER_SAVE
2108 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2110 struct alc_spec *spec = codec->spec;
2111 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2116 * Analog playback callbacks
2118 static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo,
2119 struct hda_codec *codec,
2120 struct snd_pcm_substream *substream)
2122 struct alc_spec *spec = codec->spec;
2123 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2127 static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2128 struct hda_codec *codec,
2129 unsigned int stream_tag,
2130 unsigned int format,
2131 struct snd_pcm_substream *substream)
2133 struct alc_spec *spec = codec->spec;
2134 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2135 stream_tag, format, substream);
2138 static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2139 struct hda_codec *codec,
2140 struct snd_pcm_substream *substream)
2142 struct alc_spec *spec = codec->spec;
2143 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2149 static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2150 struct hda_codec *codec,
2151 struct snd_pcm_substream *substream)
2153 struct alc_spec *spec = codec->spec;
2154 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2157 static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2158 struct hda_codec *codec,
2159 unsigned int stream_tag,
2160 unsigned int format,
2161 struct snd_pcm_substream *substream)
2163 struct alc_spec *spec = codec->spec;
2164 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2165 stream_tag, format, substream);
2168 static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2169 struct hda_codec *codec,
2170 struct snd_pcm_substream *substream)
2172 struct alc_spec *spec = codec->spec;
2173 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2176 static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2177 struct hda_codec *codec,
2178 struct snd_pcm_substream *substream)
2180 struct alc_spec *spec = codec->spec;
2181 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2187 static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2188 struct hda_codec *codec,
2189 unsigned int stream_tag,
2190 unsigned int format,
2191 struct snd_pcm_substream *substream)
2193 struct alc_spec *spec = codec->spec;
2195 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2196 stream_tag, 0, format);
2200 static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2201 struct hda_codec *codec,
2202 struct snd_pcm_substream *substream)
2204 struct alc_spec *spec = codec->spec;
2206 snd_hda_codec_cleanup_stream(codec,
2207 spec->adc_nids[substream->number + 1]);
2211 /* analog capture with dynamic dual-adc changes */
2212 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2213 struct hda_codec *codec,
2214 unsigned int stream_tag,
2215 unsigned int format,
2216 struct snd_pcm_substream *substream)
2218 struct alc_spec *spec = codec->spec;
2219 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
2220 spec->cur_adc_stream_tag = stream_tag;
2221 spec->cur_adc_format = format;
2222 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
2226 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2227 struct hda_codec *codec,
2228 struct snd_pcm_substream *substream)
2230 struct alc_spec *spec = codec->spec;
2231 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
2236 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
2240 .nid = 0, /* fill later */
2242 .prepare = dyn_adc_capture_pcm_prepare,
2243 .cleanup = dyn_adc_capture_pcm_cleanup
2249 static const struct hda_pcm_stream alc_pcm_analog_playback = {
2253 /* NID is set in alc_build_pcms */
2255 .open = alc_playback_pcm_open,
2256 .prepare = alc_playback_pcm_prepare,
2257 .cleanup = alc_playback_pcm_cleanup
2261 static const struct hda_pcm_stream alc_pcm_analog_capture = {
2265 /* NID is set in alc_build_pcms */
2268 static const struct hda_pcm_stream alc_pcm_analog_alt_playback = {
2272 /* NID is set in alc_build_pcms */
2275 static const struct hda_pcm_stream alc_pcm_analog_alt_capture = {
2276 .substreams = 2, /* can be overridden */
2279 /* NID is set in alc_build_pcms */
2281 .prepare = alc_alt_capture_pcm_prepare,
2282 .cleanup = alc_alt_capture_pcm_cleanup
2286 static const struct hda_pcm_stream alc_pcm_digital_playback = {
2290 /* NID is set in alc_build_pcms */
2292 .open = alc_dig_playback_pcm_open,
2293 .close = alc_dig_playback_pcm_close,
2294 .prepare = alc_dig_playback_pcm_prepare,
2295 .cleanup = alc_dig_playback_pcm_cleanup
2299 static const struct hda_pcm_stream alc_pcm_digital_capture = {
2303 /* NID is set in alc_build_pcms */
2306 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2307 static const struct hda_pcm_stream alc_pcm_null_stream = {
2313 static int alc_build_pcms(struct hda_codec *codec)
2315 struct alc_spec *spec = codec->spec;
2316 struct hda_pcm *info = spec->pcm_rec;
2317 const struct hda_pcm_stream *p;
2318 bool have_multi_adcs;
2321 codec->num_pcms = 1;
2322 codec->pcm_info = info;
2324 if (spec->no_analog)
2327 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
2328 "%s Analog", codec->chip_name);
2329 info->name = spec->stream_name_analog;
2331 if (spec->multiout.num_dacs > 0) {
2332 p = spec->stream_analog_playback;
2334 p = &alc_pcm_analog_playback;
2335 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2336 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2338 if (spec->adc_nids) {
2339 p = spec->stream_analog_capture;
2341 if (spec->dyn_adc_switch)
2342 p = &dyn_adc_pcm_analog_capture;
2344 p = &alc_pcm_analog_capture;
2346 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2347 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2350 if (spec->channel_mode) {
2351 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2352 for (i = 0; i < spec->num_channel_mode; i++) {
2353 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2354 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2360 /* SPDIF for stream index #1 */
2361 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2362 snprintf(spec->stream_name_digital,
2363 sizeof(spec->stream_name_digital),
2364 "%s Digital", codec->chip_name);
2365 codec->num_pcms = 2;
2366 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
2367 info = spec->pcm_rec + 1;
2368 info->name = spec->stream_name_digital;
2369 if (spec->dig_out_type)
2370 info->pcm_type = spec->dig_out_type;
2372 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2373 if (spec->multiout.dig_out_nid) {
2374 p = spec->stream_digital_playback;
2376 p = &alc_pcm_digital_playback;
2377 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2378 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2380 if (spec->dig_in_nid) {
2381 p = spec->stream_digital_capture;
2383 p = &alc_pcm_digital_capture;
2384 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2385 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2387 /* FIXME: do we need this for all Realtek codec models? */
2388 codec->spdif_status_reset = 1;
2391 if (spec->no_analog)
2394 /* If the use of more than one ADC is requested for the current
2395 * model, configure a second analog capture-only PCM.
2397 have_multi_adcs = (spec->num_adc_nids > 1) &&
2398 !spec->dyn_adc_switch && !spec->auto_mic &&
2399 (!spec->input_mux || spec->input_mux->num_items > 1);
2400 /* Additional Analaog capture for index #2 */
2401 if (spec->alt_dac_nid || have_multi_adcs) {
2402 codec->num_pcms = 3;
2403 info = spec->pcm_rec + 2;
2404 info->name = spec->stream_name_analog;
2405 if (spec->alt_dac_nid) {
2406 p = spec->stream_analog_alt_playback;
2408 p = &alc_pcm_analog_alt_playback;
2409 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2410 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2413 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2414 alc_pcm_null_stream;
2415 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2417 if (have_multi_adcs) {
2418 p = spec->stream_analog_alt_capture;
2420 p = &alc_pcm_analog_alt_capture;
2421 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2422 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2424 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2425 spec->num_adc_nids - 1;
2427 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2428 alc_pcm_null_stream;
2429 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2436 static inline void alc_shutup(struct hda_codec *codec)
2438 struct alc_spec *spec = codec->spec;
2440 if (spec && spec->shutup)
2441 spec->shutup(codec);
2442 snd_hda_shutup_pins(codec);
2445 static void alc_free_kctls(struct hda_codec *codec)
2447 struct alc_spec *spec = codec->spec;
2449 if (spec->kctls.list) {
2450 struct snd_kcontrol_new *kctl = spec->kctls.list;
2452 for (i = 0; i < spec->kctls.used; i++)
2453 kfree(kctl[i].name);
2455 snd_array_free(&spec->kctls);
2458 static void alc_free_bind_ctls(struct hda_codec *codec)
2460 struct alc_spec *spec = codec->spec;
2461 if (spec->bind_ctls.list) {
2462 struct hda_bind_ctls **ctl = spec->bind_ctls.list;
2464 for (i = 0; i < spec->bind_ctls.used; i++)
2467 snd_array_free(&spec->bind_ctls);
2470 static void alc_free(struct hda_codec *codec)
2472 struct alc_spec *spec = codec->spec;
2478 alc_free_kctls(codec);
2479 alc_free_bind_ctls(codec);
2481 snd_hda_detach_beep_device(codec);
2484 #ifdef CONFIG_SND_HDA_POWER_SAVE
2485 static void alc_power_eapd(struct hda_codec *codec)
2487 alc_auto_setup_eapd(codec, false);
2490 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
2492 struct alc_spec *spec = codec->spec;
2494 if (spec && spec->power_hook)
2495 spec->power_hook(codec);
2501 static int alc_resume(struct hda_codec *codec)
2503 msleep(150); /* to avoid pop noise */
2504 codec->patch_ops.init(codec);
2505 snd_hda_codec_resume_amp(codec);
2506 snd_hda_codec_resume_cache(codec);
2507 hda_call_check_power_status(codec, 0x01);
2514 static const struct hda_codec_ops alc_patch_ops = {
2515 .build_controls = alc_build_controls,
2516 .build_pcms = alc_build_pcms,
2519 .unsol_event = alc_unsol_event,
2521 .resume = alc_resume,
2523 #ifdef CONFIG_SND_HDA_POWER_SAVE
2524 .suspend = alc_suspend,
2525 .check_power_status = alc_check_power_status,
2527 .reboot_notify = alc_shutup,
2530 /* replace the codec chip_name with the given string */
2531 static int alc_codec_rename(struct hda_codec *codec, const char *name)
2533 kfree(codec->chip_name);
2534 codec->chip_name = kstrdup(name, GFP_KERNEL);
2535 if (!codec->chip_name) {
2543 * Rename codecs appropriately from COEF value
2545 struct alc_codec_rename_table {
2546 unsigned int vendor_id;
2547 unsigned short coef_mask;
2548 unsigned short coef_bits;
2552 static struct alc_codec_rename_table rename_tbl[] = {
2553 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
2554 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
2555 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
2556 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
2557 { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
2558 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
2559 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
2560 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
2561 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
2562 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
2563 { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
2564 { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
2565 { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
2566 { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
2567 { } /* terminator */
2570 static int alc_codec_rename_from_preset(struct hda_codec *codec)
2572 const struct alc_codec_rename_table *p;
2574 for (p = rename_tbl; p->vendor_id; p++) {
2575 if (p->vendor_id != codec->vendor_id)
2577 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
2578 return alc_codec_rename(codec, p->name);
2584 * Automatic parse of I/O pins from the BIOS configuration
2589 ALC_CTL_WIDGET_MUTE,
2594 static const struct snd_kcontrol_new alc_control_templates[] = {
2595 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2596 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2597 HDA_BIND_MUTE(NULL, 0, 0, 0),
2598 HDA_BIND_VOL(NULL, 0),
2599 HDA_BIND_SW(NULL, 0),
2602 /* add dynamic controls */
2603 static int add_control(struct alc_spec *spec, int type, const char *name,
2604 int cidx, unsigned long val)
2606 struct snd_kcontrol_new *knew;
2608 knew = alc_kcontrol_new(spec);
2611 *knew = alc_control_templates[type];
2612 knew->name = kstrdup(name, GFP_KERNEL);
2616 if (get_amp_nid_(val))
2617 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2618 knew->private_value = val;
2622 static int add_control_with_pfx(struct alc_spec *spec, int type,
2623 const char *pfx, const char *dir,
2624 const char *sfx, int cidx, unsigned long val)
2627 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
2628 return add_control(spec, type, name, cidx, val);
2631 #define add_pb_vol_ctrl(spec, type, pfx, val) \
2632 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
2633 #define add_pb_sw_ctrl(spec, type, pfx, val) \
2634 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
2635 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
2636 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
2637 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
2638 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
2640 static const char * const channel_name[4] = {
2641 "Front", "Surround", "CLFE", "Side"
2644 static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch,
2645 bool can_be_master, int *index)
2647 struct auto_pin_cfg *cfg = &spec->autocfg;
2650 if (cfg->line_outs == 1 && !spec->multi_ios &&
2651 !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
2654 switch (cfg->line_out_type) {
2655 case AUTO_PIN_SPEAKER_OUT:
2656 if (cfg->line_outs == 1)
2658 if (cfg->line_outs == 2)
2659 return ch ? "Bass Speaker" : "Speaker";
2661 case AUTO_PIN_HP_OUT:
2662 /* for multi-io case, only the primary out */
2663 if (ch && spec->multi_ios)
2668 if (cfg->line_outs == 1 && !spec->multi_ios)
2672 if (snd_BUG_ON(ch >= ARRAY_SIZE(channel_name)))
2675 return channel_name[ch];
2678 /* create input playback/capture controls for the given pin */
2679 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
2680 const char *ctlname, int ctlidx,
2681 int idx, hda_nid_t mix_nid)
2685 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
2686 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2689 err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
2690 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2696 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2698 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2699 return (pincap & AC_PINCAP_IN) != 0;
2702 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
2703 static int alc_auto_fill_adc_caps(struct hda_codec *codec)
2705 struct alc_spec *spec = codec->spec;
2707 hda_nid_t *adc_nids = spec->private_adc_nids;
2708 hda_nid_t *cap_nids = spec->private_capsrc_nids;
2709 int max_nums = ARRAY_SIZE(spec->private_adc_nids);
2712 if (spec->shared_mic_hp)
2713 max_nums = 1; /* no multi streams with the shared HP/mic */
2715 nid = codec->start_nid;
2716 for (i = 0; i < codec->num_nodes; i++, nid++) {
2718 const hda_nid_t *list;
2719 unsigned int caps = get_wcaps(codec, nid);
2720 int type = get_wcaps_type(caps);
2722 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2724 adc_nids[nums] = nid;
2725 cap_nids[nums] = nid;
2729 type = get_wcaps_type(get_wcaps(codec, src));
2730 if (type == AC_WID_PIN)
2732 if (type == AC_WID_AUD_SEL) {
2733 cap_nids[nums] = src;
2736 n = snd_hda_get_conn_list(codec, src, &list);
2738 cap_nids[nums] = src;
2744 if (++nums >= max_nums)
2747 spec->adc_nids = spec->private_adc_nids;
2748 spec->capsrc_nids = spec->private_capsrc_nids;
2749 spec->num_adc_nids = nums;
2753 /* create playback/capture controls for input pins */
2754 static int alc_auto_create_input_ctls(struct hda_codec *codec)
2756 struct alc_spec *spec = codec->spec;
2757 const struct auto_pin_cfg *cfg = &spec->autocfg;
2758 hda_nid_t mixer = spec->mixer_nid;
2759 struct hda_input_mux *imux = &spec->private_imux[0];
2761 int i, c, err, idx, type_idx = 0;
2762 const char *prev_label = NULL;
2764 num_adcs = alc_auto_fill_adc_caps(codec);
2768 for (i = 0; i < cfg->num_inputs; i++) {
2772 pin = cfg->inputs[i].pin;
2773 if (!alc_is_input_pin(codec, pin))
2776 label = hda_get_autocfg_input_label(codec, cfg, i);
2777 if (spec->shared_mic_hp && !strcmp(label, "Misc"))
2778 label = "Headphone Mic";
2779 if (prev_label && !strcmp(label, prev_label))
2786 idx = get_connection_index(codec, mixer, pin);
2788 err = new_analog_input(spec, pin,
2796 for (c = 0; c < num_adcs; c++) {
2797 hda_nid_t cap = get_capsrc(spec, c);
2798 idx = get_connection_index(codec, cap, pin);
2800 spec->imux_pins[imux->num_items] = pin;
2801 snd_hda_add_imux_item(imux, label, idx, NULL);
2807 spec->num_mux_defs = 1;
2808 spec->input_mux = imux;
2813 /* create a shared input with the headphone out */
2814 static int alc_auto_create_shared_input(struct hda_codec *codec)
2816 struct alc_spec *spec = codec->spec;
2817 struct auto_pin_cfg *cfg = &spec->autocfg;
2818 unsigned int defcfg;
2821 /* only one internal input pin? */
2822 if (cfg->num_inputs != 1)
2824 defcfg = snd_hda_codec_get_pincfg(codec, cfg->inputs[0].pin);
2825 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
2828 if (cfg->hp_outs == 1 && cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
2829 nid = cfg->hp_pins[0]; /* OK, we have a single HP-out */
2830 else if (cfg->line_outs == 1 && cfg->line_out_type == AUTO_PIN_HP_OUT)
2831 nid = cfg->line_out_pins[0]; /* OK, we have a single line-out */
2833 return 0; /* both not available */
2835 if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_IN))
2836 return 0; /* no input */
2838 cfg->inputs[1].pin = nid;
2839 cfg->inputs[1].type = AUTO_PIN_MIC;
2840 cfg->num_inputs = 2;
2841 spec->shared_mic_hp = 1;
2842 snd_printdd("realtek: Enable shared I/O jack on NID 0x%x\n", nid);
2846 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
2847 unsigned int pin_type)
2849 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2852 if (nid_has_mute(codec, nid, HDA_OUTPUT))
2853 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2857 static int get_pin_type(int line_out_type)
2859 if (line_out_type == AUTO_PIN_HP_OUT)
2865 static void alc_auto_init_analog_input(struct hda_codec *codec)
2867 struct alc_spec *spec = codec->spec;
2868 struct auto_pin_cfg *cfg = &spec->autocfg;
2871 for (i = 0; i < cfg->num_inputs; i++) {
2872 hda_nid_t nid = cfg->inputs[i].pin;
2873 if (alc_is_input_pin(codec, nid)) {
2874 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
2875 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
2876 snd_hda_codec_write(codec, nid, 0,
2877 AC_VERB_SET_AMP_GAIN_MUTE,
2882 /* mute all loopback inputs */
2883 if (spec->mixer_nid) {
2884 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL);
2885 for (i = 0; i < nums; i++)
2886 snd_hda_codec_write(codec, spec->mixer_nid, 0,
2887 AC_VERB_SET_AMP_GAIN_MUTE,
2892 /* convert from MIX nid to DAC */
2893 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
2898 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT)
2900 num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
2901 for (i = 0; i < num; i++) {
2902 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
2908 /* go down to the selector widget before the mixer */
2909 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
2912 int num = snd_hda_get_connections(codec, pin, srcs,
2915 get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
2920 /* get MIX nid connected to the given pin targeted to DAC */
2921 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
2927 pin = alc_go_down_to_selector(codec, pin);
2928 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2929 for (i = 0; i < num; i++) {
2930 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
2936 /* select the connection from pin to DAC if needed */
2937 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
2943 pin = alc_go_down_to_selector(codec, pin);
2944 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2947 for (i = 0; i < num; i++) {
2948 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
2949 snd_hda_codec_update_cache(codec, pin, 0,
2950 AC_VERB_SET_CONNECT_SEL, i);
2957 /* look for an empty DAC slot */
2958 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
2960 struct alc_spec *spec = codec->spec;
2964 pin = alc_go_down_to_selector(codec, pin);
2965 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2966 for (i = 0; i < num; i++) {
2967 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2970 if (found_in_nid_list(nid, spec->multiout.dac_nids,
2971 ARRAY_SIZE(spec->private_dac_nids)))
2973 if (found_in_nid_list(nid, spec->multiout.hp_out_nid,
2974 ARRAY_SIZE(spec->multiout.hp_out_nid)))
2976 if (found_in_nid_list(nid, spec->multiout.extra_out_nid,
2977 ARRAY_SIZE(spec->multiout.extra_out_nid)))
2984 /* check whether the DAC is reachable from the pin */
2985 static bool alc_auto_is_dac_reachable(struct hda_codec *codec,
2986 hda_nid_t pin, hda_nid_t dac)
2991 pin = alc_go_down_to_selector(codec, pin);
2992 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2993 for (i = 0; i < num; i++) {
2994 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
3001 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
3003 hda_nid_t sel = alc_go_down_to_selector(codec, pin);
3004 if (snd_hda_get_conn_list(codec, sel, NULL) == 1)
3005 return alc_auto_look_for_dac(codec, pin);
3009 /* return 0 if no possible DAC is found, 1 if one or more found */
3010 static int alc_auto_fill_extra_dacs(struct hda_codec *codec, int num_outs,
3011 const hda_nid_t *pins, hda_nid_t *dacs)
3015 if (num_outs && !dacs[0]) {
3016 dacs[0] = alc_auto_look_for_dac(codec, pins[0]);
3021 for (i = 1; i < num_outs; i++)
3022 dacs[i] = get_dac_if_single(codec, pins[i]);
3023 for (i = 1; i < num_outs; i++) {
3025 dacs[i] = alc_auto_look_for_dac(codec, pins[i]);
3030 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
3031 unsigned int location, int offset);
3032 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
3033 hda_nid_t pin, hda_nid_t dac);
3035 /* fill in the dac_nids table from the parsed pin configuration */
3036 static int alc_auto_fill_dac_nids(struct hda_codec *codec)
3038 struct alc_spec *spec = codec->spec;
3039 struct auto_pin_cfg *cfg = &spec->autocfg;
3040 unsigned int location, defcfg;
3042 bool redone = false;
3046 /* set num_dacs once to full for alc_auto_look_for_dac() */
3047 spec->multiout.num_dacs = cfg->line_outs;
3048 spec->multiout.hp_out_nid[0] = 0;
3049 spec->multiout.extra_out_nid[0] = 0;
3050 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
3051 spec->multiout.dac_nids = spec->private_dac_nids;
3052 spec->multi_ios = 0;
3054 /* fill hard-wired DACs first */
3056 for (i = 0; i < cfg->line_outs; i++)
3057 spec->private_dac_nids[i] =
3058 get_dac_if_single(codec, cfg->line_out_pins[i]);
3060 spec->multiout.hp_out_nid[0] =
3061 get_dac_if_single(codec, cfg->hp_pins[0]);
3062 if (cfg->speaker_outs)
3063 spec->multiout.extra_out_nid[0] =
3064 get_dac_if_single(codec, cfg->speaker_pins[0]);
3067 for (i = 0; i < cfg->line_outs; i++) {
3068 hda_nid_t pin = cfg->line_out_pins[i];
3069 if (spec->private_dac_nids[i])
3071 spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin);
3072 if (!spec->private_dac_nids[i] && !redone) {
3073 /* if we can't find primary DACs, re-probe without
3074 * checking the hard-wired DACs
3081 /* re-count num_dacs and squash invalid entries */
3082 spec->multiout.num_dacs = 0;
3083 for (i = 0; i < cfg->line_outs; i++) {
3084 if (spec->private_dac_nids[i])
3085 spec->multiout.num_dacs++;
3087 memmove(spec->private_dac_nids + i,
3088 spec->private_dac_nids + i + 1,
3089 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
3090 spec->private_dac_nids[cfg->line_outs - 1] = 0;
3094 if (cfg->line_outs == 1 && cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3095 /* try to fill multi-io first */
3096 defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
3097 location = get_defcfg_location(defcfg);
3099 num_pins = alc_auto_fill_multi_ios(codec, location, 0);
3101 spec->multi_ios = num_pins;
3102 spec->ext_channel_count = 2;
3103 spec->multiout.num_dacs = num_pins + 1;
3107 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
3108 alc_auto_fill_extra_dacs(codec, cfg->hp_outs, cfg->hp_pins,
3109 spec->multiout.hp_out_nid);
3110 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
3111 int err = alc_auto_fill_extra_dacs(codec, cfg->speaker_outs,
3113 spec->multiout.extra_out_nid);
3114 /* if no speaker volume is assigned, try again as the primary
3117 if (!err && cfg->speaker_outs > 0 &&
3118 cfg->line_out_type == AUTO_PIN_HP_OUT) {
3119 cfg->hp_outs = cfg->line_outs;
3120 memcpy(cfg->hp_pins, cfg->line_out_pins,
3121 sizeof(cfg->hp_pins));
3122 cfg->line_outs = cfg->speaker_outs;
3123 memcpy(cfg->line_out_pins, cfg->speaker_pins,
3124 sizeof(cfg->speaker_pins));
3125 cfg->speaker_outs = 0;
3126 memset(cfg->speaker_pins, 0, sizeof(cfg->speaker_pins));
3127 cfg->line_out_type = AUTO_PIN_SPEAKER_OUT;
3133 if (!spec->multi_ios &&
3134 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
3136 /* try multi-ios with HP + inputs */
3137 defcfg = snd_hda_codec_get_pincfg(codec, cfg->hp_pins[0]);
3138 location = get_defcfg_location(defcfg);
3140 num_pins = alc_auto_fill_multi_ios(codec, location, 1);
3142 spec->multi_ios = num_pins;
3143 spec->ext_channel_count = 2;
3144 spec->multiout.num_dacs = num_pins + 1;
3148 if (cfg->line_out_pins[0])
3150 alc_look_for_out_vol_nid(codec, cfg->line_out_pins[0],
3151 spec->multiout.dac_nids[0]);
3155 static inline unsigned int get_ctl_pos(unsigned int data)
3157 hda_nid_t nid = get_amp_nid_(data);
3159 if (snd_BUG_ON(nid >= MAX_VOL_NIDS))
3161 dir = get_amp_direction_(data);
3162 return (nid << 1) | dir;
3165 #define is_ctl_used(bits, data) \
3166 test_bit(get_ctl_pos(data), bits)
3167 #define mark_ctl_usage(bits, data) \
3168 set_bit(get_ctl_pos(data), bits)
3170 static int alc_auto_add_vol_ctl(struct hda_codec *codec,
3171 const char *pfx, int cidx,
3172 hda_nid_t nid, unsigned int chs)
3174 struct alc_spec *spec = codec->spec;
3178 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3179 if (is_ctl_used(spec->vol_ctls, val) && chs != 2) /* exclude LFE */
3181 mark_ctl_usage(spec->vol_ctls, val);
3182 return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx,
3186 static int alc_auto_add_stereo_vol(struct hda_codec *codec,
3187 const char *pfx, int cidx,
3191 if (get_wcaps(codec, nid) & AC_WCAP_STEREO)
3193 return alc_auto_add_vol_ctl(codec, pfx, cidx, nid, chs);
3196 /* create a mute-switch for the given mixer widget;
3197 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
3199 static int alc_auto_add_sw_ctl(struct hda_codec *codec,
3200 const char *pfx, int cidx,
3201 hda_nid_t nid, unsigned int chs)
3203 struct alc_spec *spec = codec->spec;
3209 wid_type = get_wcaps_type(get_wcaps(codec, nid));
3210 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) {
3211 type = ALC_CTL_WIDGET_MUTE;
3212 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
3213 } else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) {
3214 type = ALC_CTL_WIDGET_MUTE;
3215 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT);
3217 type = ALC_CTL_BIND_MUTE;
3218 val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT);
3220 if (is_ctl_used(spec->sw_ctls, val) && chs != 2) /* exclude LFE */
3222 mark_ctl_usage(spec->sw_ctls, val);
3223 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
3226 static int alc_auto_add_stereo_sw(struct hda_codec *codec, const char *pfx,
3227 int cidx, hda_nid_t nid)
3230 if (get_wcaps(codec, nid) & AC_WCAP_STEREO)
3232 return alc_auto_add_sw_ctl(codec, pfx, cidx, nid, chs);
3235 static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec,
3236 hda_nid_t pin, hda_nid_t dac)
3238 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3239 if (nid_has_mute(codec, pin, HDA_OUTPUT))
3241 else if (mix && nid_has_mute(codec, mix, HDA_INPUT))
3243 else if (nid_has_mute(codec, dac, HDA_OUTPUT))
3248 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
3249 hda_nid_t pin, hda_nid_t dac)
3251 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
3252 if (nid_has_volume(codec, dac, HDA_OUTPUT))
3254 else if (nid_has_volume(codec, mix, HDA_OUTPUT))
3256 else if (nid_has_volume(codec, pin, HDA_OUTPUT))
3261 /* add playback controls from the parsed DAC table */
3262 static int alc_auto_create_multi_out_ctls(struct hda_codec *codec,
3263 const struct auto_pin_cfg *cfg)
3265 struct alc_spec *spec = codec->spec;
3266 int i, err, noutputs;
3268 noutputs = cfg->line_outs;
3269 if (spec->multi_ios > 0 && cfg->line_outs < 3)
3270 noutputs += spec->multi_ios;
3272 for (i = 0; i < noutputs; i++) {
3278 dac = spec->multiout.dac_nids[i];
3281 if (i >= cfg->line_outs)
3282 pin = spec->multi_io[i - 1].pin;
3284 pin = cfg->line_out_pins[i];
3286 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3287 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3288 name = alc_get_line_out_pfx(spec, i, true, &index);
3289 if (!name || !strcmp(name, "CLFE")) {
3291 err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1);
3294 err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2);
3297 err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1);
3300 err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2);
3304 err = alc_auto_add_stereo_vol(codec, name, index, vol);
3307 err = alc_auto_add_stereo_sw(codec, name, index, sw);
3315 static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
3316 hda_nid_t dac, const char *pfx,
3319 struct alc_spec *spec = codec->spec;
3325 /* the corresponding DAC is already occupied */
3326 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
3327 return 0; /* no way */
3328 /* create a switch only */
3329 val = HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT);
3330 if (is_ctl_used(spec->sw_ctls, val))
3331 return 0; /* already created */
3332 mark_ctl_usage(spec->sw_ctls, val);
3333 return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, cidx, val);
3336 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3337 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3338 err = alc_auto_add_stereo_vol(codec, pfx, cidx, vol);
3341 err = alc_auto_add_stereo_sw(codec, pfx, cidx, sw);
3347 static struct hda_bind_ctls *new_bind_ctl(struct hda_codec *codec,
3349 struct hda_ctl_ops *ops)
3351 struct alc_spec *spec = codec->spec;
3352 struct hda_bind_ctls **ctlp, *ctl;
3353 snd_array_init(&spec->bind_ctls, sizeof(ctl), 8);
3354 ctlp = snd_array_new(&spec->bind_ctls);
3357 ctl = kzalloc(sizeof(*ctl) + sizeof(long) * (nums + 1), GFP_KERNEL);
3364 /* add playback controls for speaker and HP outputs */
3365 static int alc_auto_create_extra_outs(struct hda_codec *codec, int num_pins,
3366 const hda_nid_t *pins,
3367 const hda_nid_t *dacs,
3370 struct alc_spec *spec = codec->spec;
3371 struct hda_bind_ctls *ctl;
3375 if (!num_pins || !pins[0])
3378 if (num_pins == 1) {
3379 hda_nid_t dac = *dacs;
3381 dac = spec->multiout.dac_nids[0];
3382 return alc_auto_create_extra_out(codec, *pins, dac, pfx, 0);
3385 if (dacs[num_pins - 1]) {
3386 /* OK, we have a multi-output system with individual volumes */
3387 for (i = 0; i < num_pins; i++) {
3388 if (num_pins >= 3) {
3389 snprintf(name, sizeof(name), "%s %s",
3390 pfx, channel_name[i]);
3391 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3394 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3403 /* Let's create a bind-controls */
3404 ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_sw);
3408 for (i = 0; i < num_pins; i++) {
3409 if (get_wcaps(codec, pins[i]) & AC_WCAP_OUT_AMP)
3411 HDA_COMPOSE_AMP_VAL(pins[i], 3, 0, HDA_OUTPUT);
3414 snprintf(name, sizeof(name), "%s Playback Switch", pfx);
3415 err = add_control(spec, ALC_CTL_BIND_SW, name, 0, (long)ctl);
3420 ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_vol);
3424 for (i = 0; i < num_pins; i++) {
3426 if (!pins[i] || !dacs[i])
3428 vol = alc_look_for_out_vol_nid(codec, pins[i], dacs[i]);
3431 HDA_COMPOSE_AMP_VAL(vol, 3, 0, HDA_OUTPUT);
3434 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
3435 err = add_control(spec, ALC_CTL_BIND_VOL, name, 0, (long)ctl);
3442 static int alc_auto_create_hp_out(struct hda_codec *codec)
3444 struct alc_spec *spec = codec->spec;
3445 return alc_auto_create_extra_outs(codec, spec->autocfg.hp_outs,
3446 spec->autocfg.hp_pins,
3447 spec->multiout.hp_out_nid,
3451 static int alc_auto_create_speaker_out(struct hda_codec *codec)
3453 struct alc_spec *spec = codec->spec;
3454 return alc_auto_create_extra_outs(codec, spec->autocfg.speaker_outs,
3455 spec->autocfg.speaker_pins,
3456 spec->multiout.extra_out_nid,
3460 static void alc_auto_set_output_and_unmute(struct hda_codec *codec,
3461 hda_nid_t pin, int pin_type,
3465 hda_nid_t nid, mix = 0;
3466 hda_nid_t srcs[HDA_MAX_CONNECTIONS];
3468 alc_set_pin_output(codec, pin, pin_type);
3469 nid = alc_go_down_to_selector(codec, pin);
3470 num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
3471 for (i = 0; i < num; i++) {
3472 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
3480 /* need the manual connection? */
3482 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
3483 /* unmute mixer widget inputs */
3484 if (nid_has_mute(codec, mix, HDA_INPUT)) {
3485 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3487 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3490 /* initialize volume */
3491 nid = alc_look_for_out_vol_nid(codec, pin, dac);
3493 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3496 /* unmute DAC if it's not assigned to a mixer */
3497 nid = alc_look_for_out_mute_nid(codec, pin, dac);
3498 if (nid == mix && nid_has_mute(codec, dac, HDA_OUTPUT))
3499 snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3503 static void alc_auto_init_multi_out(struct hda_codec *codec)
3505 struct alc_spec *spec = codec->spec;
3506 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3509 for (i = 0; i <= HDA_SIDE; i++) {
3510 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3512 alc_auto_set_output_and_unmute(codec, nid, pin_type,
3513 spec->multiout.dac_nids[i]);
3517 static void alc_auto_init_extra_out(struct hda_codec *codec)
3519 struct alc_spec *spec = codec->spec;
3523 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3524 if (spec->autocfg.line_out_type == AUTO_PIN_HP_OUT)
3526 pin = spec->autocfg.hp_pins[i];
3529 dac = spec->multiout.hp_out_nid[i];
3531 if (i > 0 && spec->multiout.hp_out_nid[0])
3532 dac = spec->multiout.hp_out_nid[0];
3534 dac = spec->multiout.dac_nids[0];
3536 alc_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
3538 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3539 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
3541 pin = spec->autocfg.speaker_pins[i];
3544 dac = spec->multiout.extra_out_nid[i];
3546 if (i > 0 && spec->multiout.extra_out_nid[0])
3547 dac = spec->multiout.extra_out_nid[0];
3549 dac = spec->multiout.dac_nids[0];
3551 alc_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
3558 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
3559 unsigned int location,
3562 struct alc_spec *spec = codec->spec;
3563 struct auto_pin_cfg *cfg = &spec->autocfg;
3564 hda_nid_t prime_dac = spec->private_dac_nids[0];
3565 int type, i, dacs, num_pins = 0;
3567 dacs = spec->multiout.num_dacs;
3568 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
3569 for (i = 0; i < cfg->num_inputs; i++) {
3570 hda_nid_t nid = cfg->inputs[i].pin;
3572 unsigned int defcfg, caps;
3573 if (cfg->inputs[i].type != type)
3575 defcfg = snd_hda_codec_get_pincfg(codec, nid);
3576 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
3578 if (location && get_defcfg_location(defcfg) != location)
3580 caps = snd_hda_query_pin_caps(codec, nid);
3581 if (!(caps & AC_PINCAP_OUT))
3583 if (offset && offset + num_pins < dacs) {
3584 dac = spec->private_dac_nids[offset + num_pins];
3585 if (!alc_auto_is_dac_reachable(codec, nid, dac))
3589 dac = alc_auto_look_for_dac(codec, nid);
3592 spec->multi_io[num_pins].pin = nid;
3593 spec->multi_io[num_pins].dac = dac;
3595 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
3598 spec->multiout.num_dacs = dacs;
3600 /* clear up again */
3601 memset(spec->private_dac_nids + dacs, 0,
3602 sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - dacs));
3603 spec->private_dac_nids[0] = prime_dac;
3609 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
3610 struct snd_ctl_elem_info *uinfo)
3612 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3613 struct alc_spec *spec = codec->spec;
3615 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3617 uinfo->value.enumerated.items = spec->multi_ios + 1;
3618 if (uinfo->value.enumerated.item > spec->multi_ios)
3619 uinfo->value.enumerated.item = spec->multi_ios;
3620 sprintf(uinfo->value.enumerated.name, "%dch",
3621 (uinfo->value.enumerated.item + 1) * 2);
3625 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
3626 struct snd_ctl_elem_value *ucontrol)
3628 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3629 struct alc_spec *spec = codec->spec;
3630 ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
3634 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
3636 struct alc_spec *spec = codec->spec;
3637 hda_nid_t nid = spec->multi_io[idx].pin;
3639 if (!spec->multi_io[idx].ctl_in)
3640 spec->multi_io[idx].ctl_in =
3641 snd_hda_codec_read(codec, nid, 0,
3642 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3644 snd_hda_codec_update_cache(codec, nid, 0,
3645 AC_VERB_SET_PIN_WIDGET_CONTROL,
3647 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3648 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3650 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
3652 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3653 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3654 HDA_AMP_MUTE, HDA_AMP_MUTE);
3655 snd_hda_codec_update_cache(codec, nid, 0,
3656 AC_VERB_SET_PIN_WIDGET_CONTROL,
3657 spec->multi_io[idx].ctl_in);
3662 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
3663 struct snd_ctl_elem_value *ucontrol)
3665 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3666 struct alc_spec *spec = codec->spec;
3669 ch = ucontrol->value.enumerated.item[0];
3670 if (ch < 0 || ch > spec->multi_ios)
3672 if (ch == (spec->ext_channel_count - 1) / 2)
3674 spec->ext_channel_count = (ch + 1) * 2;
3675 for (i = 0; i < spec->multi_ios; i++)
3676 alc_set_multi_io(codec, i, i < ch);
3677 spec->multiout.max_channels = spec->ext_channel_count;
3678 if (spec->need_dac_fix && !spec->const_channel_count)
3679 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
3683 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
3684 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3685 .name = "Channel Mode",
3686 .info = alc_auto_ch_mode_info,
3687 .get = alc_auto_ch_mode_get,
3688 .put = alc_auto_ch_mode_put,
3691 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec)
3693 struct alc_spec *spec = codec->spec;
3695 if (spec->multi_ios > 0) {
3696 struct snd_kcontrol_new *knew;
3698 knew = alc_kcontrol_new(spec);
3701 *knew = alc_auto_channel_mode_enum;
3702 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
3709 /* filter out invalid adc_nids (and capsrc_nids) that don't give all
3712 static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
3714 struct alc_spec *spec = codec->spec;
3715 const struct hda_input_mux *imux;
3716 hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3717 hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3720 imux = spec->input_mux;
3723 if (spec->dyn_adc_switch)
3727 for (n = 0; n < spec->num_adc_nids; n++) {
3728 hda_nid_t cap = spec->private_capsrc_nids[n];
3729 int num_conns = snd_hda_get_conn_list(codec, cap, NULL);
3730 for (i = 0; i < imux->num_items; i++) {
3731 hda_nid_t pin = spec->imux_pins[i];
3733 if (get_connection_index(codec, cap, pin) < 0)
3735 } else if (num_conns <= imux->items[i].index)
3738 if (i >= imux->num_items) {
3739 adc_nids[nums] = spec->private_adc_nids[n];
3740 capsrc_nids[nums++] = cap;
3744 /* check whether ADC-switch is possible */
3745 if (!alc_check_dyn_adc_switch(codec)) {
3746 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
3747 " using fallback 0x%x\n",
3748 codec->chip_name, spec->private_adc_nids[0]);
3749 spec->num_adc_nids = 1;
3753 } else if (nums != spec->num_adc_nids) {
3754 memcpy(spec->private_adc_nids, adc_nids,
3755 nums * sizeof(hda_nid_t));
3756 memcpy(spec->private_capsrc_nids, capsrc_nids,
3757 nums * sizeof(hda_nid_t));
3758 spec->num_adc_nids = nums;
3762 alc_auto_mic_check_imux(codec); /* check auto-mic setups */
3763 else if (spec->input_mux->num_items == 1)
3764 spec->num_adc_nids = 1; /* reduce to a single ADC */
3768 * initialize ADC paths
3770 static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx)
3772 struct alc_spec *spec = codec->spec;
3775 nid = spec->adc_nids[adc_idx];
3777 if (nid_has_mute(codec, nid, HDA_INPUT)) {
3778 snd_hda_codec_write(codec, nid, 0,
3779 AC_VERB_SET_AMP_GAIN_MUTE,
3783 if (!spec->capsrc_nids)
3785 nid = spec->capsrc_nids[adc_idx];
3786 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3787 snd_hda_codec_write(codec, nid, 0,
3788 AC_VERB_SET_AMP_GAIN_MUTE,
3792 static void alc_auto_init_input_src(struct hda_codec *codec)
3794 struct alc_spec *spec = codec->spec;
3797 for (c = 0; c < spec->num_adc_nids; c++)
3798 alc_auto_init_adc(codec, c);
3799 if (spec->dyn_adc_switch)
3802 nums = spec->num_adc_nids;
3803 for (c = 0; c < nums; c++)
3804 alc_mux_select(codec, c, spec->cur_mux[c], true);
3807 /* add mic boosts if needed */
3808 static int alc_auto_add_mic_boost(struct hda_codec *codec)
3810 struct alc_spec *spec = codec->spec;
3811 struct auto_pin_cfg *cfg = &spec->autocfg;
3815 const char *prev_label = NULL;
3817 for (i = 0; i < cfg->num_inputs; i++) {
3818 if (cfg->inputs[i].type > AUTO_PIN_MIC)
3820 nid = cfg->inputs[i].pin;
3821 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
3823 char boost_label[32];
3825 label = hda_get_autocfg_input_label(codec, cfg, i);
3826 if (spec->shared_mic_hp && !strcmp(label, "Misc"))
3827 label = "Headphone Mic";
3828 if (prev_label && !strcmp(label, prev_label))
3834 snprintf(boost_label, sizeof(boost_label),
3835 "%s Boost Volume", label);
3836 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3837 boost_label, type_idx,
3838 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
3846 /* select or unmute the given capsrc route */
3847 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
3850 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
3851 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
3853 } else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) {
3854 snd_hda_codec_write_cache(codec, cap, 0,
3855 AC_VERB_SET_CONNECT_SEL, idx);
3859 /* set the default connection to that pin */
3860 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
3862 struct alc_spec *spec = codec->spec;
3867 for (i = 0; i < spec->num_adc_nids; i++) {
3868 hda_nid_t cap = get_capsrc(spec, i);
3871 idx = get_connection_index(codec, cap, pin);
3874 select_or_unmute_capsrc(codec, cap, idx);
3875 return i; /* return the found index */
3877 return -1; /* not found */
3880 /* initialize some special cases for input sources */
3881 static void alc_init_special_input_src(struct hda_codec *codec)
3883 struct alc_spec *spec = codec->spec;
3886 for (i = 0; i < spec->autocfg.num_inputs; i++)
3887 init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin);
3890 /* assign appropriate capture mixers */
3891 static void set_capture_mixer(struct hda_codec *codec)
3893 struct alc_spec *spec = codec->spec;
3894 static const struct snd_kcontrol_new *caps[2][3] = {
3895 { alc_capture_mixer_nosrc1,
3896 alc_capture_mixer_nosrc2,
3897 alc_capture_mixer_nosrc3 },
3898 { alc_capture_mixer1,
3900 alc_capture_mixer3 },
3903 /* check whether either of ADC or MUX has a volume control */
3904 if (!nid_has_volume(codec, spec->adc_nids[0], HDA_INPUT)) {
3905 if (!spec->capsrc_nids)
3906 return; /* no volume */
3907 if (!nid_has_volume(codec, spec->capsrc_nids[0], HDA_OUTPUT))
3908 return; /* no volume in capsrc, too */
3909 spec->vol_in_capsrc = 1;
3912 if (spec->num_adc_nids > 0) {
3916 if (spec->input_mux && spec->input_mux->num_items > 1)
3918 if (spec->auto_mic) {
3921 } else if (spec->dyn_adc_switch)
3924 if (spec->num_adc_nids > 3)
3925 spec->num_adc_nids = 3;
3926 else if (!spec->num_adc_nids)
3928 num_adcs = spec->num_adc_nids;
3930 spec->cap_mixer = caps[mux][num_adcs - 1];
3935 * standard auto-parser initializations
3937 static void alc_auto_init_std(struct hda_codec *codec)
3939 struct alc_spec *spec = codec->spec;
3940 alc_auto_init_multi_out(codec);
3941 alc_auto_init_extra_out(codec);
3942 alc_auto_init_analog_input(codec);
3943 alc_auto_init_input_src(codec);
3944 alc_auto_init_digital(codec);
3945 if (spec->unsol_event)
3946 alc_inithook(codec);
3950 * Digital-beep handlers
3952 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3953 #define set_beep_amp(spec, nid, idx, dir) \
3954 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
3956 static const struct snd_pci_quirk beep_white_list[] = {
3957 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
3958 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
3959 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
3960 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
3961 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
3965 static inline int has_cdefine_beep(struct hda_codec *codec)
3967 struct alc_spec *spec = codec->spec;
3968 const struct snd_pci_quirk *q;
3969 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
3972 return spec->cdefine.enable_pcbeep;
3975 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
3976 #define has_cdefine_beep(codec) 0
3979 /* parse the BIOS configuration and set up the alc_spec */
3980 /* return 1 if successful, 0 if the proper config is not found,
3981 * or a negative error code
3983 static int alc_parse_auto_config(struct hda_codec *codec,
3984 const hda_nid_t *ignore_nids,
3985 const hda_nid_t *ssid_nids)
3987 struct alc_spec *spec = codec->spec;
3988 struct auto_pin_cfg *cfg = &spec->autocfg;
3991 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
3995 if (!cfg->line_outs) {
3996 if (cfg->dig_outs || cfg->dig_in_pin) {
3997 spec->multiout.max_channels = 2;
3998 spec->no_analog = 1;
4001 return 0; /* can't find valid BIOS pin config */
4004 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
4005 cfg->line_outs <= cfg->hp_outs) {
4006 /* use HP as primary out */
4007 cfg->speaker_outs = cfg->line_outs;
4008 memcpy(cfg->speaker_pins, cfg->line_out_pins,
4009 sizeof(cfg->speaker_pins));
4010 cfg->line_outs = cfg->hp_outs;
4011 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
4013 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
4014 cfg->line_out_type = AUTO_PIN_HP_OUT;
4017 err = alc_auto_fill_dac_nids(codec);
4020 err = alc_auto_add_multi_channel_mode(codec);
4023 err = alc_auto_create_multi_out_ctls(codec, cfg);
4026 err = alc_auto_create_hp_out(codec);
4029 err = alc_auto_create_speaker_out(codec);
4032 err = alc_auto_create_shared_input(codec);
4035 err = alc_auto_create_input_ctls(codec);
4039 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4042 alc_auto_parse_digital(codec);
4044 if (!spec->no_analog)
4045 alc_remove_invalid_adc_nids(codec);
4048 alc_ssid_check(codec, ssid_nids);
4050 if (!spec->no_analog) {
4051 alc_auto_check_switches(codec);
4052 err = alc_auto_add_mic_boost(codec);
4057 if (spec->kctls.list)
4058 add_mixer(spec, spec->kctls.list);
4063 static int alc880_parse_auto_config(struct hda_codec *codec)
4065 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4066 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4067 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
4070 #ifdef CONFIG_SND_HDA_POWER_SAVE
4071 static const struct hda_amp_list alc880_loopbacks[] = {
4072 { 0x0b, HDA_INPUT, 0 },
4073 { 0x0b, HDA_INPUT, 1 },
4074 { 0x0b, HDA_INPUT, 2 },
4075 { 0x0b, HDA_INPUT, 3 },
4076 { 0x0b, HDA_INPUT, 4 },
4086 ALC880_FIXUP_MEDION_RIM,
4089 static const struct alc_fixup alc880_fixups[] = {
4090 [ALC880_FIXUP_GPIO2] = {
4091 .type = ALC_FIXUP_VERBS,
4092 .v.verbs = alc_gpio2_init_verbs,
4094 [ALC880_FIXUP_MEDION_RIM] = {
4095 .type = ALC_FIXUP_VERBS,
4096 .v.verbs = (const struct hda_verb[]) {
4097 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4098 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
4102 .chain_id = ALC880_FIXUP_GPIO2,
4106 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
4107 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
4115 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4116 #define alc_board_config \
4117 snd_hda_check_board_config
4118 #define alc_board_codec_sid_config \
4119 snd_hda_check_board_codec_sid_config
4120 #include "alc_quirks.c"
4122 #define alc_board_config(codec, nums, models, tbl) -1
4123 #define alc_board_codec_sid_config(codec, nums, models, tbl) -1
4124 #define setup_preset(codec, x) /* NOP */
4128 * OK, here we have finally the patch for ALC880
4130 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4131 #include "alc880_quirks.c"
4134 static int patch_alc880(struct hda_codec *codec)
4136 struct alc_spec *spec;
4140 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4146 spec->mixer_nid = 0x0b;
4147 spec->need_dac_fix = 1;
4149 board_config = alc_board_config(codec, ALC880_MODEL_LAST,
4150 alc880_models, alc880_cfg_tbl);
4151 if (board_config < 0) {
4152 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4154 board_config = ALC_MODEL_AUTO;
4157 if (board_config == ALC_MODEL_AUTO) {
4158 alc_pick_fixup(codec, NULL, alc880_fixup_tbl, alc880_fixups);
4159 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4162 if (board_config == ALC_MODEL_AUTO) {
4163 /* automatic parse from the BIOS config */
4164 err = alc880_parse_auto_config(codec);
4167 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4170 "hda_codec: Cannot set up configuration "
4171 "from BIOS. Using 3-stack mode...\n");
4172 board_config = ALC880_3ST;
4177 if (board_config != ALC_MODEL_AUTO) {
4178 spec->vmaster_nid = 0x0c;
4179 setup_preset(codec, &alc880_presets[board_config]);
4182 if (!spec->no_analog && !spec->adc_nids) {
4183 alc_auto_fill_adc_caps(codec);
4184 alc_rebuild_imux_for_auto_mic(codec);
4185 alc_remove_invalid_adc_nids(codec);
4188 if (!spec->no_analog && !spec->cap_mixer)
4189 set_capture_mixer(codec);
4191 if (!spec->no_analog) {
4192 err = snd_hda_attach_beep_device(codec, 0x1);
4195 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4198 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4200 codec->patch_ops = alc_patch_ops;
4201 if (board_config == ALC_MODEL_AUTO)
4202 spec->init_hook = alc_auto_init_std;
4204 codec->patch_ops.build_controls = __alc_build_controls;
4205 #ifdef CONFIG_SND_HDA_POWER_SAVE
4206 if (!spec->loopback.amplist)
4207 spec->loopback.amplist = alc880_loopbacks;
4221 static int alc260_parse_auto_config(struct hda_codec *codec)
4223 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
4224 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
4225 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
4228 #ifdef CONFIG_SND_HDA_POWER_SAVE
4229 static const struct hda_amp_list alc260_loopbacks[] = {
4230 { 0x07, HDA_INPUT, 0 },
4231 { 0x07, HDA_INPUT, 1 },
4232 { 0x07, HDA_INPUT, 2 },
4233 { 0x07, HDA_INPUT, 3 },
4234 { 0x07, HDA_INPUT, 4 },
4246 static const struct alc_fixup alc260_fixups[] = {
4247 [PINFIX_HP_DC5750] = {
4248 .type = ALC_FIXUP_PINS,
4249 .v.pins = (const struct alc_pincfg[]) {
4250 { 0x11, 0x90130110 }, /* speaker */
4256 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
4257 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
4263 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4264 #include "alc260_quirks.c"
4267 static int patch_alc260(struct hda_codec *codec)
4269 struct alc_spec *spec;
4270 int err, board_config;
4272 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4278 spec->mixer_nid = 0x07;
4280 board_config = alc_board_config(codec, ALC260_MODEL_LAST,
4281 alc260_models, alc260_cfg_tbl);
4282 if (board_config < 0) {
4283 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4285 board_config = ALC_MODEL_AUTO;
4288 if (board_config == ALC_MODEL_AUTO) {
4289 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
4290 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4293 if (board_config == ALC_MODEL_AUTO) {
4294 /* automatic parse from the BIOS config */
4295 err = alc260_parse_auto_config(codec);
4298 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4301 "hda_codec: Cannot set up configuration "
4302 "from BIOS. Using base mode...\n");
4303 board_config = ALC260_BASIC;
4308 if (board_config != ALC_MODEL_AUTO) {
4309 setup_preset(codec, &alc260_presets[board_config]);
4310 spec->vmaster_nid = 0x08;
4313 if (!spec->no_analog && !spec->adc_nids) {
4314 alc_auto_fill_adc_caps(codec);
4315 alc_rebuild_imux_for_auto_mic(codec);
4316 alc_remove_invalid_adc_nids(codec);
4319 if (!spec->no_analog && !spec->cap_mixer)
4320 set_capture_mixer(codec);
4322 if (!spec->no_analog) {
4323 err = snd_hda_attach_beep_device(codec, 0x1);
4326 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
4329 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4331 codec->patch_ops = alc_patch_ops;
4332 if (board_config == ALC_MODEL_AUTO)
4333 spec->init_hook = alc_auto_init_std;
4335 codec->patch_ops.build_controls = __alc_build_controls;
4336 spec->shutup = alc_eapd_shutup;
4337 #ifdef CONFIG_SND_HDA_POWER_SAVE
4338 if (!spec->loopback.amplist)
4339 spec->loopback.amplist = alc260_loopbacks;
4351 * ALC882/883/885/888/889 support
4353 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
4354 * configuration. Each pin widget can choose any input DACs and a mixer.
4355 * Each ADC is connected from a mixer of all inputs. This makes possible
4356 * 6-channel independent captures.
4358 * In addition, an independent DAC for the multi-playback (not used in this
4361 #ifdef CONFIG_SND_HDA_POWER_SAVE
4362 #define alc882_loopbacks alc880_loopbacks
4369 ALC882_FIXUP_ABIT_AW9D_MAX,
4370 ALC882_FIXUP_LENOVO_Y530,
4371 ALC882_FIXUP_PB_M5210,
4372 ALC882_FIXUP_ACER_ASPIRE_7736,
4373 ALC882_FIXUP_ASUS_W90V,
4375 ALC889_FIXUP_VAIO_TT,
4376 ALC888_FIXUP_EEE1601,
4379 ALC883_FIXUP_ACER_EAPD,
4382 ALC882_FIXUP_ASUS_W2JC,
4383 ALC882_FIXUP_ACER_ASPIRE_4930G,
4384 ALC882_FIXUP_ACER_ASPIRE_8930G,
4385 ALC882_FIXUP_ASPIRE_8930G_VERBS,
4386 ALC885_FIXUP_MACPRO_GPIO,
4387 ALC889_FIXUP_DAC_ROUTE,
4390 static void alc889_fixup_coef(struct hda_codec *codec,
4391 const struct alc_fixup *fix, int action)
4393 if (action != ALC_FIXUP_ACT_INIT)
4395 alc889_coef_init(codec);
4398 /* toggle speaker-output according to the hp-jack state */
4399 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
4401 unsigned int gpiostate, gpiomask, gpiodir;
4403 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4404 AC_VERB_GET_GPIO_DATA, 0);
4407 gpiostate |= (1 << pin);
4409 gpiostate &= ~(1 << pin);
4411 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4412 AC_VERB_GET_GPIO_MASK, 0);
4413 gpiomask |= (1 << pin);
4415 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4416 AC_VERB_GET_GPIO_DIRECTION, 0);
4417 gpiodir |= (1 << pin);
4420 snd_hda_codec_write(codec, codec->afg, 0,
4421 AC_VERB_SET_GPIO_MASK, gpiomask);
4422 snd_hda_codec_write(codec, codec->afg, 0,
4423 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
4427 snd_hda_codec_write(codec, codec->afg, 0,
4428 AC_VERB_SET_GPIO_DATA, gpiostate);
4431 /* set up GPIO at initialization */
4432 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
4433 const struct alc_fixup *fix, int action)
4435 if (action != ALC_FIXUP_ACT_INIT)
4437 alc882_gpio_mute(codec, 0, 0);
4438 alc882_gpio_mute(codec, 1, 0);
4441 /* Fix the connection of some pins for ALC889:
4442 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
4443 * work correctly (bko#42740)
4445 static void alc889_fixup_dac_route(struct hda_codec *codec,
4446 const struct alc_fixup *fix, int action)
4448 if (action == ALC_FIXUP_ACT_PRE_PROBE) {
4449 /* fake the connections during parsing the tree */
4450 hda_nid_t conn1[2] = { 0x0c, 0x0d };
4451 hda_nid_t conn2[2] = { 0x0e, 0x0f };
4452 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
4453 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
4454 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
4455 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
4456 } else if (action == ALC_FIXUP_ACT_PROBE) {
4457 /* restore the connections */
4458 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
4459 snd_hda_override_conn_list(codec, 0x14, 5, conn);
4460 snd_hda_override_conn_list(codec, 0x15, 5, conn);
4461 snd_hda_override_conn_list(codec, 0x18, 5, conn);
4462 snd_hda_override_conn_list(codec, 0x1a, 5, conn);
4466 static const struct alc_fixup alc882_fixups[] = {
4467 [ALC882_FIXUP_ABIT_AW9D_MAX] = {
4468 .type = ALC_FIXUP_PINS,
4469 .v.pins = (const struct alc_pincfg[]) {
4470 { 0x15, 0x01080104 }, /* side */
4471 { 0x16, 0x01011012 }, /* rear */
4472 { 0x17, 0x01016011 }, /* clfe */
4476 [ALC882_FIXUP_LENOVO_Y530] = {
4477 .type = ALC_FIXUP_PINS,
4478 .v.pins = (const struct alc_pincfg[]) {
4479 { 0x15, 0x99130112 }, /* rear int speakers */
4480 { 0x16, 0x99130111 }, /* subwoofer */
4484 [ALC882_FIXUP_PB_M5210] = {
4485 .type = ALC_FIXUP_VERBS,
4486 .v.verbs = (const struct hda_verb[]) {
4487 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
4491 [ALC882_FIXUP_ACER_ASPIRE_7736] = {
4492 .type = ALC_FIXUP_SKU,
4493 .v.sku = ALC_FIXUP_SKU_IGNORE,
4495 [ALC882_FIXUP_ASUS_W90V] = {
4496 .type = ALC_FIXUP_PINS,
4497 .v.pins = (const struct alc_pincfg[]) {
4498 { 0x16, 0x99130110 }, /* fix sequence for CLFE */
4502 [ALC889_FIXUP_CD] = {
4503 .type = ALC_FIXUP_PINS,
4504 .v.pins = (const struct alc_pincfg[]) {
4505 { 0x1c, 0x993301f0 }, /* CD */
4509 [ALC889_FIXUP_VAIO_TT] = {
4510 .type = ALC_FIXUP_PINS,
4511 .v.pins = (const struct alc_pincfg[]) {
4512 { 0x17, 0x90170111 }, /* hidden surround speaker */
4516 [ALC888_FIXUP_EEE1601] = {
4517 .type = ALC_FIXUP_VERBS,
4518 .v.verbs = (const struct hda_verb[]) {
4519 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
4520 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },
4524 [ALC882_FIXUP_EAPD] = {
4525 .type = ALC_FIXUP_VERBS,
4526 .v.verbs = (const struct hda_verb[]) {
4527 /* change to EAPD mode */
4528 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4529 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
4533 [ALC883_FIXUP_EAPD] = {
4534 .type = ALC_FIXUP_VERBS,
4535 .v.verbs = (const struct hda_verb[]) {
4536 /* change to EAPD mode */
4537 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4538 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
4542 [ALC883_FIXUP_ACER_EAPD] = {
4543 .type = ALC_FIXUP_VERBS,
4544 .v.verbs = (const struct hda_verb[]) {
4545 /* eanable EAPD on Acer laptops */
4546 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4547 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4551 [ALC882_FIXUP_GPIO3] = {
4552 .type = ALC_FIXUP_VERBS,
4553 .v.verbs = alc_gpio3_init_verbs,
4555 [ALC882_FIXUP_ASUS_W2JC] = {
4556 .type = ALC_FIXUP_VERBS,
4557 .v.verbs = alc_gpio1_init_verbs,
4559 .chain_id = ALC882_FIXUP_EAPD,
4561 [ALC889_FIXUP_COEF] = {
4562 .type = ALC_FIXUP_FUNC,
4563 .v.func = alc889_fixup_coef,
4565 [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
4566 .type = ALC_FIXUP_PINS,
4567 .v.pins = (const struct alc_pincfg[]) {
4568 { 0x16, 0x99130111 }, /* CLFE speaker */
4569 { 0x17, 0x99130112 }, /* surround speaker */
4573 [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
4574 .type = ALC_FIXUP_PINS,
4575 .v.pins = (const struct alc_pincfg[]) {
4576 { 0x16, 0x99130111 }, /* CLFE speaker */
4577 { 0x1b, 0x99130112 }, /* surround speaker */
4581 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
4583 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
4584 /* additional init verbs for Acer Aspire 8930G */
4585 .type = ALC_FIXUP_VERBS,
4586 .v.verbs = (const struct hda_verb[]) {
4587 /* Enable all DACs */
4588 /* DAC DISABLE/MUTE 1? */
4589 /* setting bits 1-5 disables DAC nids 0x02-0x06
4590 * apparently. Init=0x38 */
4591 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
4592 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
4593 /* DAC DISABLE/MUTE 2? */
4594 /* some bit here disables the other DACs.
4596 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
4597 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
4599 * This laptop has a stereo digital microphone.
4600 * The mics are only 1cm apart which makes the stereo
4601 * useless. However, either the mic or the ALC889
4602 * makes the signal become a difference/sum signal
4603 * instead of standard stereo, which is annoying.
4604 * So instead we flip this bit which makes the
4605 * codec replicate the sum signal to both channels,
4606 * turning it into a normal mono mic.
4608 /* DMIC_CONTROL? Init value = 0x0001 */
4609 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
4610 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
4611 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4612 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4616 [ALC885_FIXUP_MACPRO_GPIO] = {
4617 .type = ALC_FIXUP_FUNC,
4618 .v.func = alc885_fixup_macpro_gpio,
4620 [ALC889_FIXUP_DAC_ROUTE] = {
4621 .type = ALC_FIXUP_FUNC,
4622 .v.func = alc889_fixup_dac_route,
4626 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
4627 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
4628 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
4629 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
4630 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
4631 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
4632 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
4633 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
4634 ALC882_FIXUP_ACER_ASPIRE_4930G),
4635 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
4636 ALC882_FIXUP_ACER_ASPIRE_4930G),
4637 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
4638 ALC882_FIXUP_ACER_ASPIRE_8930G),
4639 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
4640 ALC882_FIXUP_ACER_ASPIRE_8930G),
4641 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
4642 ALC882_FIXUP_ACER_ASPIRE_4930G),
4643 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
4644 ALC882_FIXUP_ACER_ASPIRE_4930G),
4645 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
4646 ALC882_FIXUP_ACER_ASPIRE_4930G),
4647 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
4648 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
4649 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
4650 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
4651 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
4652 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
4653 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
4654 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
4656 /* All Apple entries are in codec SSIDs */
4657 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_FIXUP_MACPRO_GPIO),
4658 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
4659 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
4660 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
4661 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
4663 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
4664 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
4665 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3", ALC889_FIXUP_CD),
4666 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
4667 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
4668 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
4669 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
4670 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
4675 * BIOS auto configuration
4677 /* almost identical with ALC880 parser... */
4678 static int alc882_parse_auto_config(struct hda_codec *codec)
4680 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
4681 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4682 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
4687 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4688 #include "alc882_quirks.c"
4691 static int patch_alc882(struct hda_codec *codec)
4693 struct alc_spec *spec;
4694 int err, board_config;
4696 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4702 spec->mixer_nid = 0x0b;
4704 switch (codec->vendor_id) {
4709 /* ALC883 and variants */
4710 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4714 err = alc_codec_rename_from_preset(codec);
4718 board_config = alc_board_config(codec, ALC882_MODEL_LAST,
4719 alc882_models, NULL);
4720 if (board_config < 0)
4721 board_config = alc_board_codec_sid_config(codec,
4722 ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
4724 if (board_config < 0) {
4725 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4727 board_config = ALC_MODEL_AUTO;
4730 if (board_config == ALC_MODEL_AUTO) {
4731 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
4732 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4735 alc_auto_parse_customize_define(codec);
4737 if (board_config == ALC_MODEL_AUTO) {
4738 /* automatic parse from the BIOS config */
4739 err = alc882_parse_auto_config(codec);
4744 if (board_config != ALC_MODEL_AUTO) {
4745 setup_preset(codec, &alc882_presets[board_config]);
4746 spec->vmaster_nid = 0x0c;
4749 if (!spec->no_analog && !spec->adc_nids) {
4750 alc_auto_fill_adc_caps(codec);
4751 alc_rebuild_imux_for_auto_mic(codec);
4752 alc_remove_invalid_adc_nids(codec);
4755 if (!spec->no_analog && !spec->cap_mixer)
4756 set_capture_mixer(codec);
4758 if (!spec->no_analog && has_cdefine_beep(codec)) {
4759 err = snd_hda_attach_beep_device(codec, 0x1);
4762 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4765 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4767 codec->patch_ops = alc_patch_ops;
4768 if (board_config == ALC_MODEL_AUTO)
4769 spec->init_hook = alc_auto_init_std;
4771 codec->patch_ops.build_controls = __alc_build_controls;
4773 #ifdef CONFIG_SND_HDA_POWER_SAVE
4774 if (!spec->loopback.amplist)
4775 spec->loopback.amplist = alc882_loopbacks;
4789 static int alc262_parse_auto_config(struct hda_codec *codec)
4791 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
4792 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4793 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
4800 ALC262_FIXUP_FSC_H270,
4801 ALC262_FIXUP_HP_Z200,
4803 ALC262_FIXUP_LENOVO_3000,
4805 ALC262_FIXUP_BENQ_T31,
4808 static const struct alc_fixup alc262_fixups[] = {
4809 [ALC262_FIXUP_FSC_H270] = {
4810 .type = ALC_FIXUP_PINS,
4811 .v.pins = (const struct alc_pincfg[]) {
4812 { 0x14, 0x99130110 }, /* speaker */
4813 { 0x15, 0x0221142f }, /* front HP */
4814 { 0x1b, 0x0121141f }, /* rear HP */
4818 [ALC262_FIXUP_HP_Z200] = {
4819 .type = ALC_FIXUP_PINS,
4820 .v.pins = (const struct alc_pincfg[]) {
4821 { 0x16, 0x99130120 }, /* internal speaker */
4825 [ALC262_FIXUP_TYAN] = {
4826 .type = ALC_FIXUP_PINS,
4827 .v.pins = (const struct alc_pincfg[]) {
4828 { 0x14, 0x1993e1f0 }, /* int AUX */
4832 [ALC262_FIXUP_LENOVO_3000] = {
4833 .type = ALC_FIXUP_VERBS,
4834 .v.verbs = (const struct hda_verb[]) {
4835 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
4839 .chain_id = ALC262_FIXUP_BENQ,
4841 [ALC262_FIXUP_BENQ] = {
4842 .type = ALC_FIXUP_VERBS,
4843 .v.verbs = (const struct hda_verb[]) {
4844 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4845 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
4849 [ALC262_FIXUP_BENQ_T31] = {
4850 .type = ALC_FIXUP_VERBS,
4851 .v.verbs = (const struct hda_verb[]) {
4852 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
4853 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
4859 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
4860 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
4861 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FIXUP_BENQ),
4862 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
4863 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
4864 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
4865 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
4866 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
4867 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
4872 #ifdef CONFIG_SND_HDA_POWER_SAVE
4873 #define alc262_loopbacks alc880_loopbacks
4878 static int patch_alc262(struct hda_codec *codec)
4880 struct alc_spec *spec;
4883 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4889 spec->mixer_nid = 0x0b;
4892 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
4897 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4898 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4899 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4900 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4903 alc_auto_parse_customize_define(codec);
4905 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4907 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
4908 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4910 /* automatic parse from the BIOS config */
4911 err = alc262_parse_auto_config(codec);
4915 if (!spec->no_analog && !spec->adc_nids) {
4916 alc_auto_fill_adc_caps(codec);
4917 alc_rebuild_imux_for_auto_mic(codec);
4918 alc_remove_invalid_adc_nids(codec);
4921 if (!spec->no_analog && !spec->cap_mixer)
4922 set_capture_mixer(codec);
4924 if (!spec->no_analog && has_cdefine_beep(codec)) {
4925 err = snd_hda_attach_beep_device(codec, 0x1);
4928 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4931 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4933 codec->patch_ops = alc_patch_ops;
4934 spec->init_hook = alc_auto_init_std;
4935 spec->shutup = alc_eapd_shutup;
4937 #ifdef CONFIG_SND_HDA_POWER_SAVE
4938 if (!spec->loopback.amplist)
4939 spec->loopback.amplist = alc262_loopbacks;
4952 /* bind Beep switches of both NID 0x0f and 0x10 */
4953 static const struct hda_bind_ctls alc268_bind_beep_sw = {
4954 .ops = &snd_hda_bind_sw,
4956 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
4957 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
4962 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
4963 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
4964 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
4968 /* set PCBEEP vol = 0, mute connections */
4969 static const struct hda_verb alc268_beep_init_verbs[] = {
4970 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4971 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4972 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4977 * BIOS auto configuration
4979 static int alc268_parse_auto_config(struct hda_codec *codec)
4981 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4982 struct alc_spec *spec = codec->spec;
4983 int err = alc_parse_auto_config(codec, NULL, alc268_ssids);
4985 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) {
4986 add_mixer(spec, alc268_beep_mixer);
4987 add_verb(spec, alc268_beep_init_verbs);
4995 static int patch_alc268(struct hda_codec *codec)
4997 struct alc_spec *spec;
4998 int i, has_beep, err;
5000 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5006 /* ALC268 has no aa-loopback mixer */
5008 /* automatic parse from the BIOS config */
5009 err = alc268_parse_auto_config(codec);
5014 for (i = 0; i < spec->num_mixers; i++) {
5015 if (spec->mixers[i] == alc268_beep_mixer) {
5022 err = snd_hda_attach_beep_device(codec, 0x1);
5025 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
5026 /* override the amp caps for beep generator */
5027 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
5028 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
5029 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
5030 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5031 (0 << AC_AMPCAP_MUTE_SHIFT));
5034 if (!spec->no_analog && !spec->adc_nids) {
5035 alc_auto_fill_adc_caps(codec);
5036 alc_rebuild_imux_for_auto_mic(codec);
5037 alc_remove_invalid_adc_nids(codec);
5040 if (!spec->no_analog && !spec->cap_mixer)
5041 set_capture_mixer(codec);
5043 codec->patch_ops = alc_patch_ops;
5044 spec->init_hook = alc_auto_init_std;
5045 spec->shutup = alc_eapd_shutup;
5057 #ifdef CONFIG_SND_HDA_POWER_SAVE
5058 #define alc269_loopbacks alc880_loopbacks
5061 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
5065 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
5066 /* NID is set in alc_build_pcms */
5068 .open = alc_playback_pcm_open,
5069 .prepare = alc_playback_pcm_prepare,
5070 .cleanup = alc_playback_pcm_cleanup
5074 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
5078 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
5079 /* NID is set in alc_build_pcms */
5082 #ifdef CONFIG_SND_HDA_POWER_SAVE
5083 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
5085 switch (codec->subsystem_id) {
5092 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
5094 /* update mute-LED according to the speaker mute state */
5095 if (nid == 0x01 || nid == 0x14) {
5097 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
5102 /* mic2 vref pin is used for mute LED control */
5103 snd_hda_codec_update_cache(codec, 0x19, 0,
5104 AC_VERB_SET_PIN_WIDGET_CONTROL,
5107 return alc_check_power_status(codec, nid);
5109 #endif /* CONFIG_SND_HDA_POWER_SAVE */
5111 /* different alc269-variants */
5113 ALC269_TYPE_ALC269VA,
5114 ALC269_TYPE_ALC269VB,
5115 ALC269_TYPE_ALC269VC,
5119 * BIOS auto configuration
5121 static int alc269_parse_auto_config(struct hda_codec *codec)
5123 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
5124 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
5125 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5126 struct alc_spec *spec = codec->spec;
5127 const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ?
5128 alc269va_ssids : alc269_ssids;
5130 return alc_parse_auto_config(codec, alc269_ignore, ssids);
5133 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
5135 int val = alc_read_coef_idx(codec, 0x04);
5140 alc_write_coef_idx(codec, 0x04, val);
5143 static void alc269_shutup(struct hda_codec *codec)
5145 if ((alc_get_coef0(codec) & 0x00ff) == 0x017)
5146 alc269_toggle_power_output(codec, 0);
5147 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5148 alc269_toggle_power_output(codec, 0);
5154 static int alc269_resume(struct hda_codec *codec)
5156 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5157 alc269_toggle_power_output(codec, 0);
5161 codec->patch_ops.init(codec);
5163 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
5164 alc269_toggle_power_output(codec, 1);
5168 if ((alc_get_coef0(codec) & 0x00ff) == 0x018)
5169 alc269_toggle_power_output(codec, 1);
5171 snd_hda_codec_resume_amp(codec);
5172 snd_hda_codec_resume_cache(codec);
5173 hda_call_check_power_status(codec, 0x01);
5176 #endif /* CONFIG_PM */
5178 static void alc269_fixup_hweq(struct hda_codec *codec,
5179 const struct alc_fixup *fix, int action)
5183 if (action != ALC_FIXUP_ACT_INIT)
5185 coef = alc_read_coef_idx(codec, 0x1e);
5186 alc_write_coef_idx(codec, 0x1e, coef | 0x80);
5189 static void alc271_fixup_dmic(struct hda_codec *codec,
5190 const struct alc_fixup *fix, int action)
5192 static const struct hda_verb verbs[] = {
5193 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
5194 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
5199 if (strcmp(codec->chip_name, "ALC271X"))
5201 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
5202 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
5203 snd_hda_sequence_write(codec, verbs);
5206 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
5207 const struct alc_fixup *fix, int action)
5209 struct alc_spec *spec = codec->spec;
5211 if (action != ALC_FIXUP_ACT_PROBE)
5214 /* Due to a hardware problem on Lenovo Ideadpad, we need to
5215 * fix the sample rate of analog I/O to 44.1kHz
5217 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
5218 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
5221 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
5222 const struct alc_fixup *fix, int action)
5226 if (action != ALC_FIXUP_ACT_INIT)
5228 /* The digital-mic unit sends PDM (differential signal) instead of
5229 * the standard PCM, thus you can't record a valid mono stream as is.
5230 * Below is a workaround specific to ALC269 to control the dmic
5231 * signal source as mono.
5233 coef = alc_read_coef_idx(codec, 0x07);
5234 alc_write_coef_idx(codec, 0x07, coef | 0x80);
5237 static void alc269_quanta_automute(struct hda_codec *codec)
5239 update_outputs(codec);
5241 snd_hda_codec_write(codec, 0x20, 0,
5242 AC_VERB_SET_COEF_INDEX, 0x0c);
5243 snd_hda_codec_write(codec, 0x20, 0,
5244 AC_VERB_SET_PROC_COEF, 0x680);
5246 snd_hda_codec_write(codec, 0x20, 0,
5247 AC_VERB_SET_COEF_INDEX, 0x0c);
5248 snd_hda_codec_write(codec, 0x20, 0,
5249 AC_VERB_SET_PROC_COEF, 0x480);
5252 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
5253 const struct alc_fixup *fix, int action)
5255 struct alc_spec *spec = codec->spec;
5256 if (action != ALC_FIXUP_ACT_PROBE)
5258 spec->automute_hook = alc269_quanta_automute;
5262 ALC269_FIXUP_SONY_VAIO,
5263 ALC275_FIXUP_SONY_VAIO_GPIO2,
5264 ALC269_FIXUP_DELL_M101Z,
5265 ALC269_FIXUP_SKU_IGNORE,
5266 ALC269_FIXUP_ASUS_G73JW,
5267 ALC269_FIXUP_LENOVO_EAPD,
5268 ALC275_FIXUP_SONY_HWEQ,
5270 ALC269_FIXUP_PCM_44K,
5271 ALC269_FIXUP_STEREO_DMIC,
5272 ALC269_FIXUP_QUANTA_MUTE,
5273 ALC269_FIXUP_LIFEBOOK,
5276 ALC269VB_FIXUP_AMIC,
5277 ALC269VB_FIXUP_DMIC,
5280 static const struct alc_fixup alc269_fixups[] = {
5281 [ALC269_FIXUP_SONY_VAIO] = {
5282 .type = ALC_FIXUP_VERBS,
5283 .v.verbs = (const struct hda_verb[]) {
5284 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
5288 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
5289 .type = ALC_FIXUP_VERBS,
5290 .v.verbs = (const struct hda_verb[]) {
5291 {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
5292 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
5293 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5297 .chain_id = ALC269_FIXUP_SONY_VAIO
5299 [ALC269_FIXUP_DELL_M101Z] = {
5300 .type = ALC_FIXUP_VERBS,
5301 .v.verbs = (const struct hda_verb[]) {
5302 /* Enables internal speaker */
5303 {0x20, AC_VERB_SET_COEF_INDEX, 13},
5304 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
5308 [ALC269_FIXUP_SKU_IGNORE] = {
5309 .type = ALC_FIXUP_SKU,
5310 .v.sku = ALC_FIXUP_SKU_IGNORE,
5312 [ALC269_FIXUP_ASUS_G73JW] = {
5313 .type = ALC_FIXUP_PINS,
5314 .v.pins = (const struct alc_pincfg[]) {
5315 { 0x17, 0x99130111 }, /* subwoofer */
5319 [ALC269_FIXUP_LENOVO_EAPD] = {
5320 .type = ALC_FIXUP_VERBS,
5321 .v.verbs = (const struct hda_verb[]) {
5322 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5326 [ALC275_FIXUP_SONY_HWEQ] = {
5327 .type = ALC_FIXUP_FUNC,
5328 .v.func = alc269_fixup_hweq,
5330 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
5332 [ALC271_FIXUP_DMIC] = {
5333 .type = ALC_FIXUP_FUNC,
5334 .v.func = alc271_fixup_dmic,
5336 [ALC269_FIXUP_PCM_44K] = {
5337 .type = ALC_FIXUP_FUNC,
5338 .v.func = alc269_fixup_pcm_44k,
5340 [ALC269_FIXUP_STEREO_DMIC] = {
5341 .type = ALC_FIXUP_FUNC,
5342 .v.func = alc269_fixup_stereo_dmic,
5344 [ALC269_FIXUP_QUANTA_MUTE] = {
5345 .type = ALC_FIXUP_FUNC,
5346 .v.func = alc269_fixup_quanta_mute,
5348 [ALC269_FIXUP_LIFEBOOK] = {
5349 .type = ALC_FIXUP_PINS,
5350 .v.pins = (const struct alc_pincfg[]) {
5351 { 0x1a, 0x2101103f }, /* dock line-out */
5352 { 0x1b, 0x23a11040 }, /* dock mic-in */
5356 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5358 [ALC269_FIXUP_AMIC] = {
5359 .type = ALC_FIXUP_PINS,
5360 .v.pins = (const struct alc_pincfg[]) {
5361 { 0x14, 0x99130110 }, /* speaker */
5362 { 0x15, 0x0121401f }, /* HP out */
5363 { 0x18, 0x01a19c20 }, /* mic */
5364 { 0x19, 0x99a3092f }, /* int-mic */
5368 [ALC269_FIXUP_DMIC] = {
5369 .type = ALC_FIXUP_PINS,
5370 .v.pins = (const struct alc_pincfg[]) {
5371 { 0x12, 0x99a3092f }, /* int-mic */
5372 { 0x14, 0x99130110 }, /* speaker */
5373 { 0x15, 0x0121401f }, /* HP out */
5374 { 0x18, 0x01a19c20 }, /* mic */
5378 [ALC269VB_FIXUP_AMIC] = {
5379 .type = ALC_FIXUP_PINS,
5380 .v.pins = (const struct alc_pincfg[]) {
5381 { 0x14, 0x99130110 }, /* speaker */
5382 { 0x18, 0x01a19c20 }, /* mic */
5383 { 0x19, 0x99a3092f }, /* int-mic */
5384 { 0x21, 0x0121401f }, /* HP out */
5388 [ALC269VB_FIXUP_DMIC] = {
5389 .type = ALC_FIXUP_PINS,
5390 .v.pins = (const struct alc_pincfg[]) {
5391 { 0x12, 0x99a3092f }, /* int-mic */
5392 { 0x14, 0x99130110 }, /* speaker */
5393 { 0x18, 0x01a19c20 }, /* mic */
5394 { 0x21, 0x0121401f }, /* HP out */
5400 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
5401 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
5402 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
5403 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
5404 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
5405 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5406 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5407 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
5408 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5409 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5410 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
5411 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
5412 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
5413 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
5414 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
5415 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
5416 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
5417 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
5418 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
5419 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_QUANTA_MUTE),
5420 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Lenovo Ideapd", ALC269_FIXUP_PCM_44K),
5421 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
5424 /* Below is a quirk table taken from the old code.
5425 * Basically the device should work as is without the fixup table.
5426 * If BIOS doesn't give a proper info, enable the corresponding
5429 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
5431 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
5432 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
5433 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
5434 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
5435 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
5436 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
5437 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
5438 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
5439 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
5440 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
5441 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
5442 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
5443 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
5444 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
5445 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
5446 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
5447 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
5448 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
5449 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
5450 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
5451 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
5452 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
5453 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
5454 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
5455 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
5456 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
5457 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
5458 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
5459 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
5460 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
5461 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
5462 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
5463 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
5464 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
5465 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
5466 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
5467 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
5468 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
5469 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
5474 static const struct alc_model_fixup alc269_fixup_models[] = {
5475 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
5476 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
5481 static int alc269_fill_coef(struct hda_codec *codec)
5483 struct alc_spec *spec = codec->spec;
5486 if (spec->codec_variant != ALC269_TYPE_ALC269VB)
5489 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
5490 alc_write_coef_idx(codec, 0xf, 0x960b);
5491 alc_write_coef_idx(codec, 0xe, 0x8817);
5494 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
5495 alc_write_coef_idx(codec, 0xf, 0x960b);
5496 alc_write_coef_idx(codec, 0xe, 0x8814);
5499 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
5500 val = alc_read_coef_idx(codec, 0x04);
5501 /* Power up output pin */
5502 alc_write_coef_idx(codec, 0x04, val | (1<<11));
5505 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5506 val = alc_read_coef_idx(codec, 0xd);
5507 if ((val & 0x0c00) >> 10 != 0x1) {
5508 /* Capless ramp up clock control */
5509 alc_write_coef_idx(codec, 0xd, val | (1<<10));
5511 val = alc_read_coef_idx(codec, 0x17);
5512 if ((val & 0x01c0) >> 6 != 0x4) {
5513 /* Class D power on reset */
5514 alc_write_coef_idx(codec, 0x17, val | (1<<7));
5518 val = alc_read_coef_idx(codec, 0xd); /* Class D */
5519 alc_write_coef_idx(codec, 0xd, val | (1<<14));
5521 val = alc_read_coef_idx(codec, 0x4); /* HP */
5522 alc_write_coef_idx(codec, 0x4, val | (1<<11));
5529 static int patch_alc269(struct hda_codec *codec)
5531 struct alc_spec *spec;
5534 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5540 spec->mixer_nid = 0x0b;
5542 alc_auto_parse_customize_define(codec);
5544 err = alc_codec_rename_from_preset(codec);
5548 if (codec->vendor_id == 0x10ec0269) {
5549 spec->codec_variant = ALC269_TYPE_ALC269VA;
5550 switch (alc_get_coef0(codec) & 0x00f0) {
5552 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
5553 spec->cdefine.platform_type == 1)
5554 err = alc_codec_rename(codec, "ALC271X");
5555 spec->codec_variant = ALC269_TYPE_ALC269VB;
5558 if (codec->bus->pci->subsystem_vendor == 0x17aa &&
5559 codec->bus->pci->subsystem_device == 0x21f3)
5560 err = alc_codec_rename(codec, "ALC3202");
5561 spec->codec_variant = ALC269_TYPE_ALC269VC;
5564 alc_fix_pll_init(codec, 0x20, 0x04, 15);
5568 alc269_fill_coef(codec);
5571 alc_pick_fixup(codec, alc269_fixup_models,
5572 alc269_fixup_tbl, alc269_fixups);
5573 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5575 /* automatic parse from the BIOS config */
5576 err = alc269_parse_auto_config(codec);
5580 if (!spec->no_analog && !spec->adc_nids) {
5581 alc_auto_fill_adc_caps(codec);
5582 alc_rebuild_imux_for_auto_mic(codec);
5583 alc_remove_invalid_adc_nids(codec);
5586 if (!spec->no_analog && !spec->cap_mixer)
5587 set_capture_mixer(codec);
5589 if (!spec->no_analog && has_cdefine_beep(codec)) {
5590 err = snd_hda_attach_beep_device(codec, 0x1);
5593 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5596 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5598 codec->patch_ops = alc_patch_ops;
5600 codec->patch_ops.resume = alc269_resume;
5602 spec->init_hook = alc_auto_init_std;
5603 spec->shutup = alc269_shutup;
5605 #ifdef CONFIG_SND_HDA_POWER_SAVE
5606 if (!spec->loopback.amplist)
5607 spec->loopback.amplist = alc269_loopbacks;
5608 if (alc269_mic2_for_mute_led(codec))
5609 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
5623 static int alc861_parse_auto_config(struct hda_codec *codec)
5625 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
5626 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
5627 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
5630 #ifdef CONFIG_SND_HDA_POWER_SAVE
5631 static const struct hda_amp_list alc861_loopbacks[] = {
5632 { 0x15, HDA_INPUT, 0 },
5633 { 0x15, HDA_INPUT, 1 },
5634 { 0x15, HDA_INPUT, 2 },
5635 { 0x15, HDA_INPUT, 3 },
5641 /* Pin config fixes */
5643 PINFIX_FSC_AMILO_PI1505,
5647 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
5648 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
5649 const struct alc_fixup *fix, int action)
5651 struct alc_spec *spec = codec->spec;
5654 if (action != ALC_FIXUP_ACT_INIT)
5656 val = snd_hda_codec_read(codec, 0x0f, 0,
5657 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5658 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
5659 val |= AC_PINCTL_IN_EN;
5660 val |= AC_PINCTL_VREF_50;
5661 snd_hda_codec_write(codec, 0x0f, 0,
5662 AC_VERB_SET_PIN_WIDGET_CONTROL, val);
5663 spec->keep_vref_in_automute = 1;
5666 static const struct alc_fixup alc861_fixups[] = {
5667 [PINFIX_FSC_AMILO_PI1505] = {
5668 .type = ALC_FIXUP_PINS,
5669 .v.pins = (const struct alc_pincfg[]) {
5670 { 0x0b, 0x0221101f }, /* HP */
5671 { 0x0f, 0x90170310 }, /* speaker */
5675 [PINFIX_ASUS_A6RP] = {
5676 .type = ALC_FIXUP_FUNC,
5677 .v.func = alc861_fixup_asus_amp_vref_0f,
5681 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
5682 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", PINFIX_ASUS_A6RP),
5683 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", PINFIX_ASUS_A6RP),
5684 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", PINFIX_ASUS_A6RP),
5685 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
5691 static int patch_alc861(struct hda_codec *codec)
5693 struct alc_spec *spec;
5696 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5702 spec->mixer_nid = 0x15;
5704 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
5705 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5707 /* automatic parse from the BIOS config */
5708 err = alc861_parse_auto_config(codec);
5712 if (!spec->no_analog && !spec->adc_nids) {
5713 alc_auto_fill_adc_caps(codec);
5714 alc_rebuild_imux_for_auto_mic(codec);
5715 alc_remove_invalid_adc_nids(codec);
5718 if (!spec->no_analog && !spec->cap_mixer)
5719 set_capture_mixer(codec);
5721 if (!spec->no_analog) {
5722 err = snd_hda_attach_beep_device(codec, 0x23);
5725 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
5728 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5730 codec->patch_ops = alc_patch_ops;
5731 spec->init_hook = alc_auto_init_std;
5732 #ifdef CONFIG_SND_HDA_POWER_SAVE
5733 spec->power_hook = alc_power_eapd;
5734 if (!spec->loopback.amplist)
5735 spec->loopback.amplist = alc861_loopbacks;
5750 * In addition, an independent DAC
5752 #ifdef CONFIG_SND_HDA_POWER_SAVE
5753 #define alc861vd_loopbacks alc880_loopbacks
5756 static int alc861vd_parse_auto_config(struct hda_codec *codec)
5758 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
5759 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5760 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
5764 ALC660VD_FIX_ASUS_GPIO1,
5765 ALC861VD_FIX_DALLAS,
5768 /* exclude VREF80 */
5769 static void alc861vd_fixup_dallas(struct hda_codec *codec,
5770 const struct alc_fixup *fix, int action)
5772 if (action == ALC_FIXUP_ACT_PRE_PROBE) {
5773 snd_hda_override_pin_caps(codec, 0x18, 0x00001714);
5774 snd_hda_override_pin_caps(codec, 0x19, 0x0000171c);
5778 static const struct alc_fixup alc861vd_fixups[] = {
5779 [ALC660VD_FIX_ASUS_GPIO1] = {
5780 .type = ALC_FIXUP_VERBS,
5781 .v.verbs = (const struct hda_verb[]) {
5783 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5784 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5785 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5789 [ALC861VD_FIX_DALLAS] = {
5790 .type = ALC_FIXUP_FUNC,
5791 .v.func = alc861vd_fixup_dallas,
5795 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
5796 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
5797 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
5798 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
5802 static const struct hda_verb alc660vd_eapd_verbs[] = {
5803 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
5804 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
5810 static int patch_alc861vd(struct hda_codec *codec)
5812 struct alc_spec *spec;
5815 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5821 spec->mixer_nid = 0x0b;
5823 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
5824 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5826 /* automatic parse from the BIOS config */
5827 err = alc861vd_parse_auto_config(codec);
5831 if (codec->vendor_id == 0x10ec0660) {
5832 /* always turn on EAPD */
5833 add_verb(spec, alc660vd_eapd_verbs);
5836 if (!spec->no_analog && !spec->adc_nids) {
5837 alc_auto_fill_adc_caps(codec);
5838 alc_rebuild_imux_for_auto_mic(codec);
5839 alc_remove_invalid_adc_nids(codec);
5842 if (!spec->no_analog && !spec->cap_mixer)
5843 set_capture_mixer(codec);
5845 if (!spec->no_analog) {
5846 err = snd_hda_attach_beep_device(codec, 0x23);
5849 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5852 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5854 codec->patch_ops = alc_patch_ops;
5856 spec->init_hook = alc_auto_init_std;
5857 spec->shutup = alc_eapd_shutup;
5858 #ifdef CONFIG_SND_HDA_POWER_SAVE
5859 if (!spec->loopback.amplist)
5860 spec->loopback.amplist = alc861vd_loopbacks;
5873 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5874 * configuration. Each pin widget can choose any input DACs and a mixer.
5875 * Each ADC is connected from a mixer of all inputs. This makes possible
5876 * 6-channel independent captures.
5878 * In addition, an independent DAC for the multi-playback (not used in this
5881 #ifdef CONFIG_SND_HDA_POWER_SAVE
5882 #define alc662_loopbacks alc880_loopbacks
5886 * BIOS auto configuration
5889 static int alc662_parse_auto_config(struct hda_codec *codec)
5891 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
5892 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
5893 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5894 const hda_nid_t *ssids;
5896 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
5897 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
5898 ssids = alc663_ssids;
5900 ssids = alc662_ssids;
5901 return alc_parse_auto_config(codec, alc662_ignore, ssids);
5904 static void alc272_fixup_mario(struct hda_codec *codec,
5905 const struct alc_fixup *fix, int action)
5907 if (action != ALC_FIXUP_ACT_PROBE)
5909 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
5910 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
5911 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
5912 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5913 (0 << AC_AMPCAP_MUTE_SHIFT)))
5915 "hda_codec: failed to override amp caps for NID 0x2\n");
5919 ALC662_FIXUP_ASPIRE,
5920 ALC662_FIXUP_IDEAPAD,
5922 ALC662_FIXUP_CZC_P10T,
5923 ALC662_FIXUP_SKU_IGNORE,
5924 ALC662_FIXUP_HP_RP5800,
5925 ALC662_FIXUP_ASUS_MODE1,
5926 ALC662_FIXUP_ASUS_MODE2,
5927 ALC662_FIXUP_ASUS_MODE3,
5928 ALC662_FIXUP_ASUS_MODE4,
5929 ALC662_FIXUP_ASUS_MODE5,
5930 ALC662_FIXUP_ASUS_MODE6,
5931 ALC662_FIXUP_ASUS_MODE7,
5932 ALC662_FIXUP_ASUS_MODE8,
5935 static const struct alc_fixup alc662_fixups[] = {
5936 [ALC662_FIXUP_ASPIRE] = {
5937 .type = ALC_FIXUP_PINS,
5938 .v.pins = (const struct alc_pincfg[]) {
5939 { 0x15, 0x99130112 }, /* subwoofer */
5943 [ALC662_FIXUP_IDEAPAD] = {
5944 .type = ALC_FIXUP_PINS,
5945 .v.pins = (const struct alc_pincfg[]) {
5946 { 0x17, 0x99130112 }, /* subwoofer */
5950 [ALC272_FIXUP_MARIO] = {
5951 .type = ALC_FIXUP_FUNC,
5952 .v.func = alc272_fixup_mario,
5954 [ALC662_FIXUP_CZC_P10T] = {
5955 .type = ALC_FIXUP_VERBS,
5956 .v.verbs = (const struct hda_verb[]) {
5957 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5961 [ALC662_FIXUP_SKU_IGNORE] = {
5962 .type = ALC_FIXUP_SKU,
5963 .v.sku = ALC_FIXUP_SKU_IGNORE,
5965 [ALC662_FIXUP_HP_RP5800] = {
5966 .type = ALC_FIXUP_PINS,
5967 .v.pins = (const struct alc_pincfg[]) {
5968 { 0x14, 0x0221201f }, /* HP out */
5972 .chain_id = ALC662_FIXUP_SKU_IGNORE
5974 [ALC662_FIXUP_ASUS_MODE1] = {
5975 .type = ALC_FIXUP_PINS,
5976 .v.pins = (const struct alc_pincfg[]) {
5977 { 0x14, 0x99130110 }, /* speaker */
5978 { 0x18, 0x01a19c20 }, /* mic */
5979 { 0x19, 0x99a3092f }, /* int-mic */
5980 { 0x21, 0x0121401f }, /* HP out */
5984 .chain_id = ALC662_FIXUP_SKU_IGNORE
5986 [ALC662_FIXUP_ASUS_MODE2] = {
5987 .type = ALC_FIXUP_PINS,
5988 .v.pins = (const struct alc_pincfg[]) {
5989 { 0x14, 0x99130110 }, /* speaker */
5990 { 0x18, 0x01a19820 }, /* mic */
5991 { 0x19, 0x99a3092f }, /* int-mic */
5992 { 0x1b, 0x0121401f }, /* HP out */
5996 .chain_id = ALC662_FIXUP_SKU_IGNORE
5998 [ALC662_FIXUP_ASUS_MODE3] = {
5999 .type = ALC_FIXUP_PINS,
6000 .v.pins = (const struct alc_pincfg[]) {
6001 { 0x14, 0x99130110 }, /* speaker */
6002 { 0x15, 0x0121441f }, /* HP */
6003 { 0x18, 0x01a19840 }, /* mic */
6004 { 0x19, 0x99a3094f }, /* int-mic */
6005 { 0x21, 0x01211420 }, /* HP2 */
6009 .chain_id = ALC662_FIXUP_SKU_IGNORE
6011 [ALC662_FIXUP_ASUS_MODE4] = {
6012 .type = ALC_FIXUP_PINS,
6013 .v.pins = (const struct alc_pincfg[]) {
6014 { 0x14, 0x99130110 }, /* speaker */
6015 { 0x16, 0x99130111 }, /* speaker */
6016 { 0x18, 0x01a19840 }, /* mic */
6017 { 0x19, 0x99a3094f }, /* int-mic */
6018 { 0x21, 0x0121441f }, /* HP */
6022 .chain_id = ALC662_FIXUP_SKU_IGNORE
6024 [ALC662_FIXUP_ASUS_MODE5] = {
6025 .type = ALC_FIXUP_PINS,
6026 .v.pins = (const struct alc_pincfg[]) {
6027 { 0x14, 0x99130110 }, /* speaker */
6028 { 0x15, 0x0121441f }, /* HP */
6029 { 0x16, 0x99130111 }, /* speaker */
6030 { 0x18, 0x01a19840 }, /* mic */
6031 { 0x19, 0x99a3094f }, /* int-mic */
6035 .chain_id = ALC662_FIXUP_SKU_IGNORE
6037 [ALC662_FIXUP_ASUS_MODE6] = {
6038 .type = ALC_FIXUP_PINS,
6039 .v.pins = (const struct alc_pincfg[]) {
6040 { 0x14, 0x99130110 }, /* speaker */
6041 { 0x15, 0x01211420 }, /* HP2 */
6042 { 0x18, 0x01a19840 }, /* mic */
6043 { 0x19, 0x99a3094f }, /* int-mic */
6044 { 0x1b, 0x0121441f }, /* HP */
6048 .chain_id = ALC662_FIXUP_SKU_IGNORE
6050 [ALC662_FIXUP_ASUS_MODE7] = {
6051 .type = ALC_FIXUP_PINS,
6052 .v.pins = (const struct alc_pincfg[]) {
6053 { 0x14, 0x99130110 }, /* speaker */
6054 { 0x17, 0x99130111 }, /* speaker */
6055 { 0x18, 0x01a19840 }, /* mic */
6056 { 0x19, 0x99a3094f }, /* int-mic */
6057 { 0x1b, 0x01214020 }, /* HP */
6058 { 0x21, 0x0121401f }, /* HP */
6062 .chain_id = ALC662_FIXUP_SKU_IGNORE
6064 [ALC662_FIXUP_ASUS_MODE8] = {
6065 .type = ALC_FIXUP_PINS,
6066 .v.pins = (const struct alc_pincfg[]) {
6067 { 0x14, 0x99130110 }, /* speaker */
6068 { 0x12, 0x99a30970 }, /* int-mic */
6069 { 0x15, 0x01214020 }, /* HP */
6070 { 0x17, 0x99130111 }, /* speaker */
6071 { 0x18, 0x01a19840 }, /* mic */
6072 { 0x21, 0x0121401f }, /* HP */
6076 .chain_id = ALC662_FIXUP_SKU_IGNORE
6080 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
6081 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
6082 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
6083 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
6084 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
6085 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
6086 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
6087 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
6088 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
6089 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
6090 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
6093 /* Below is a quirk table taken from the old code.
6094 * Basically the device should work as is without the fixup table.
6095 * If BIOS doesn't give a proper info, enable the corresponding
6098 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
6099 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
6100 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
6101 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
6102 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6103 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6104 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6105 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
6106 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
6107 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6108 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
6109 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
6110 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
6111 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
6112 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
6113 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6114 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
6115 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
6116 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6117 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6118 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6119 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6120 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
6121 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
6122 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
6123 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6124 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
6125 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6126 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6127 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
6128 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6129 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6130 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
6131 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
6132 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
6133 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
6134 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
6135 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
6136 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
6137 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6138 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
6139 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
6140 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6141 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
6142 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
6143 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
6144 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
6145 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
6146 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6147 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
6152 static const struct alc_model_fixup alc662_fixup_models[] = {
6153 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
6154 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
6155 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
6156 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
6157 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
6158 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
6159 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
6160 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
6161 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
6168 static int patch_alc662(struct hda_codec *codec)
6170 struct alc_spec *spec;
6173 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6179 spec->mixer_nid = 0x0b;
6181 /* handle multiple HPs as is */
6182 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6184 alc_auto_parse_customize_define(codec);
6186 alc_fix_pll_init(codec, 0x20, 0x04, 15);
6188 err = alc_codec_rename_from_preset(codec);
6192 if ((alc_get_coef0(codec) & (1 << 14)) &&
6193 codec->bus->pci->subsystem_vendor == 0x1025 &&
6194 spec->cdefine.platform_type == 1) {
6195 if (alc_codec_rename(codec, "ALC272X") < 0)
6199 alc_pick_fixup(codec, alc662_fixup_models,
6200 alc662_fixup_tbl, alc662_fixups);
6201 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
6202 /* automatic parse from the BIOS config */
6203 err = alc662_parse_auto_config(codec);
6207 if (!spec->no_analog && !spec->adc_nids) {
6208 alc_auto_fill_adc_caps(codec);
6209 alc_rebuild_imux_for_auto_mic(codec);
6210 alc_remove_invalid_adc_nids(codec);
6213 if (!spec->no_analog && !spec->cap_mixer)
6214 set_capture_mixer(codec);
6216 if (!spec->no_analog && has_cdefine_beep(codec)) {
6217 err = snd_hda_attach_beep_device(codec, 0x1);
6220 switch (codec->vendor_id) {
6222 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6227 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
6230 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
6235 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
6237 codec->patch_ops = alc_patch_ops;
6238 spec->init_hook = alc_auto_init_std;
6239 spec->shutup = alc_eapd_shutup;
6241 #ifdef CONFIG_SND_HDA_POWER_SAVE
6242 if (!spec->loopback.amplist)
6243 spec->loopback.amplist = alc662_loopbacks;
6257 static int alc680_parse_auto_config(struct hda_codec *codec)
6259 return alc_parse_auto_config(codec, NULL, NULL);
6264 static int patch_alc680(struct hda_codec *codec)
6266 struct alc_spec *spec;
6269 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6275 /* ALC680 has no aa-loopback mixer */
6277 /* automatic parse from the BIOS config */
6278 err = alc680_parse_auto_config(codec);
6284 if (!spec->no_analog && !spec->cap_mixer)
6285 set_capture_mixer(codec);
6287 codec->patch_ops = alc_patch_ops;
6288 spec->init_hook = alc_auto_init_std;
6296 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
6297 { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
6298 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
6299 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
6300 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
6301 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
6302 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
6303 { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
6304 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
6305 { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
6306 { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
6307 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
6308 .patch = patch_alc861 },
6309 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
6310 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
6311 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
6312 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
6313 .patch = patch_alc882 },
6314 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
6315 .patch = patch_alc662 },
6316 { .id = 0x10ec0662, .rev = 0x100300, .name = "ALC662 rev3",
6317 .patch = patch_alc662 },
6318 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
6319 { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
6320 { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
6321 { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
6322 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
6323 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
6324 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
6325 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
6326 .patch = patch_alc882 },
6327 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
6328 .patch = patch_alc882 },
6329 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
6330 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
6331 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
6332 .patch = patch_alc882 },
6333 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
6334 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
6335 { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
6336 { .id = 0x10ec0899, .name = "ALC898", .patch = patch_alc882 },
6340 MODULE_ALIAS("snd-hda-codec-id:10ec*");
6342 MODULE_LICENSE("GPL");
6343 MODULE_DESCRIPTION("Realtek HD-audio codec");
6345 static struct hda_codec_preset_list realtek_list = {
6346 .preset = snd_hda_preset_realtek,
6347 .owner = THIS_MODULE,
6350 static int __init patch_realtek_init(void)
6352 return snd_hda_add_codec_preset(&realtek_list);
6355 static void __exit patch_realtek_exit(void)
6357 snd_hda_delete_codec_preset(&realtek_list);
6360 module_init(patch_realtek_init)
6361 module_exit(patch_realtek_exit)