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 <sound/core.h>
31 #include <sound/jack.h>
32 #include "hda_codec.h"
33 #include "hda_local.h"
36 /* unsol event tags */
37 #define ALC_FRONT_EVENT 0x01
38 #define ALC_DCVOL_EVENT 0x02
39 #define ALC_HP_EVENT 0x04
40 #define ALC_MIC_EVENT 0x08
43 #define GPIO_MASK 0x03
45 /* extra amp-initialization sequence types */
54 struct alc_customize_define {
56 unsigned char port_connectivity;
57 unsigned char check_sum;
58 unsigned char customization;
59 unsigned char external_amp;
60 unsigned int enable_pcbeep:1;
61 unsigned int platform_type:1;
63 unsigned int override:1;
64 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */
70 hda_nid_t pin; /* multi-io widget pin NID */
71 hda_nid_t dac; /* DAC to be connected */
72 unsigned int ctl_in; /* cached input-pin control value */
76 ALC_AUTOMUTE_PIN, /* change the pin control */
77 ALC_AUTOMUTE_AMP, /* mute/unmute the pin AMP */
78 ALC_AUTOMUTE_MIXER, /* mute/unmute mixer widget AMP */
82 /* codec parameterization */
83 const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
84 unsigned int num_mixers;
85 const struct snd_kcontrol_new *cap_mixer; /* capture mixer */
86 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
88 const struct hda_verb *init_verbs[10]; /* initialization verbs
92 unsigned int num_init_verbs;
94 char stream_name_analog[32]; /* analog PCM stream */
95 const struct hda_pcm_stream *stream_analog_playback;
96 const struct hda_pcm_stream *stream_analog_capture;
97 const struct hda_pcm_stream *stream_analog_alt_playback;
98 const struct hda_pcm_stream *stream_analog_alt_capture;
100 char stream_name_digital[32]; /* digital PCM stream */
101 const struct hda_pcm_stream *stream_digital_playback;
102 const struct hda_pcm_stream *stream_digital_capture;
105 struct hda_multi_out multiout; /* playback set-up
106 * max_channels, dacs must be set
107 * dig_out_nid and hp_nid are optional
109 hda_nid_t alt_dac_nid;
110 hda_nid_t slave_dig_outs[3]; /* optional - for auto-parsing */
114 unsigned int num_adc_nids;
115 const hda_nid_t *adc_nids;
116 const hda_nid_t *capsrc_nids;
117 hda_nid_t dig_in_nid; /* digital-in NID; optional */
118 hda_nid_t mixer_nid; /* analog-mixer NID */
120 /* capture setup for dynamic dual-adc switch */
122 unsigned int cur_adc_stream_tag;
123 unsigned int cur_adc_format;
126 unsigned int num_mux_defs;
127 const struct hda_input_mux *input_mux;
128 unsigned int cur_mux[3];
129 hda_nid_t ext_mic_pin;
130 hda_nid_t dock_mic_pin;
131 hda_nid_t int_mic_pin;
134 const struct hda_channel_mode *channel_mode;
135 int num_channel_mode;
137 int const_channel_count;
138 int ext_channel_count;
140 /* PCM information */
141 struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */
143 /* dynamic controls, init_verbs and input_mux */
144 struct auto_pin_cfg autocfg;
145 struct alc_customize_define cdefine;
146 struct snd_array kctls;
147 struct hda_input_mux private_imux[3];
148 hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
149 hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
150 hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
151 hda_nid_t imux_pins[HDA_MAX_NUM_INPUTS];
152 unsigned int dyn_adc_idx[HDA_MAX_NUM_INPUTS];
153 int int_mic_idx, ext_mic_idx, dock_mic_idx; /* for auto-mic */
156 void (*init_hook)(struct hda_codec *codec);
157 void (*unsol_event)(struct hda_codec *codec, unsigned int res);
158 #ifdef CONFIG_SND_HDA_POWER_SAVE
159 void (*power_hook)(struct hda_codec *codec);
161 void (*shutup)(struct hda_codec *codec);
162 void (*automute_hook)(struct hda_codec *codec);
164 /* for pin sensing */
165 unsigned int jack_present: 1;
166 unsigned int line_jack_present:1;
167 unsigned int master_mute:1;
168 unsigned int auto_mic:1;
169 unsigned int auto_mic_valid_imux:1; /* valid imux for auto-mic */
170 unsigned int automute:1; /* HP automute enabled */
171 unsigned int detect_line:1; /* Line-out detection enabled */
172 unsigned int automute_lines:1; /* automute line-out as well */
173 unsigned int automute_hp_lo:1; /* both HP and LO available */
176 unsigned int no_analog :1; /* digital I/O only */
177 unsigned int dyn_adc_switch:1; /* switch ADCs (for ALC275) */
178 unsigned int single_input_src:1;
179 unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */
181 /* auto-mute control */
183 hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];
186 int codec_variant; /* flag for other variants */
188 /* for virtual master */
189 hda_nid_t vmaster_nid;
190 #ifdef CONFIG_SND_HDA_POWER_SAVE
191 struct hda_loopback_check loopback;
196 unsigned int pll_coef_idx, pll_coef_bit;
200 const struct alc_fixup *fixup_list;
201 const char *fixup_name;
205 struct alc_multi_io multi_io[4];
208 struct snd_array bind_ctls;
211 #define ALC_MODEL_AUTO 0 /* common for all chips */
213 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
214 int dir, unsigned int bits)
218 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
219 if (query_amp_caps(codec, nid, dir) & bits)
224 #define nid_has_mute(codec, nid, dir) \
225 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
226 #define nid_has_volume(codec, nid, dir) \
227 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
232 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
233 struct snd_ctl_elem_info *uinfo)
235 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
236 struct alc_spec *spec = codec->spec;
237 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
238 if (mux_idx >= spec->num_mux_defs)
240 if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
242 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
245 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
246 struct snd_ctl_elem_value *ucontrol)
248 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
249 struct alc_spec *spec = codec->spec;
250 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
252 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
256 static bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
258 struct alc_spec *spec = codec->spec;
259 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
261 if (spec->cur_adc && spec->cur_adc != new_adc) {
262 /* stream is running, let's swap the current ADC */
263 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
264 spec->cur_adc = new_adc;
265 snd_hda_codec_setup_stream(codec, new_adc,
266 spec->cur_adc_stream_tag, 0,
267 spec->cur_adc_format);
273 /* select the given imux item; either unmute exclusively or select the route */
274 static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
275 unsigned int idx, bool force)
277 struct alc_spec *spec = codec->spec;
278 const struct hda_input_mux *imux;
279 unsigned int mux_idx;
283 mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
284 imux = &spec->input_mux[mux_idx];
285 if (!imux->num_items && mux_idx > 0)
286 imux = &spec->input_mux[0];
288 if (idx >= imux->num_items)
289 idx = imux->num_items - 1;
290 if (spec->cur_mux[adc_idx] == idx && !force)
292 spec->cur_mux[adc_idx] = idx;
294 if (spec->dyn_adc_switch) {
295 alc_dyn_adc_pcm_resetup(codec, idx);
296 adc_idx = spec->dyn_adc_idx[idx];
299 nid = spec->capsrc_nids ?
300 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
303 if (snd_hda_get_conn_list(codec, nid, NULL) <= 1)
306 type = get_wcaps_type(get_wcaps(codec, nid));
307 if (type == AC_WID_AUD_MIX) {
308 /* Matrix-mixer style (e.g. ALC882) */
309 for (i = 0; i < imux->num_items; i++) {
310 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
311 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
312 imux->items[i].index,
316 /* MUX style (e.g. ALC880) */
317 snd_hda_codec_write_cache(codec, nid, 0,
318 AC_VERB_SET_CONNECT_SEL,
319 imux->items[idx].index);
324 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
325 struct snd_ctl_elem_value *ucontrol)
327 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
328 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
329 return alc_mux_select(codec, adc_idx,
330 ucontrol->value.enumerated.item[0], false);
334 * set up the input pin config (depending on the given auto-pin type)
336 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
339 unsigned int val = PIN_IN;
341 if (auto_pin_type == AUTO_PIN_MIC) {
344 oldval = snd_hda_codec_read(codec, nid, 0,
345 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
346 pincap = snd_hda_query_pin_caps(codec, nid);
347 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
348 /* if the default pin setup is vref50, we give it priority */
349 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
351 else if (pincap & AC_PINCAP_VREF_50)
353 else if (pincap & AC_PINCAP_VREF_100)
355 else if (pincap & AC_PINCAP_VREF_GRD)
358 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
362 * Append the given mixer and verb elements for the later use
363 * The mixer array is referred in build_controls(), and init_verbs are
366 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
368 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
370 spec->mixers[spec->num_mixers++] = mix;
373 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
375 if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
377 spec->init_verbs[spec->num_init_verbs++] = verb;
381 * GPIO setup tables, used in initialization
383 /* Enable GPIO mask and set output */
384 static const struct hda_verb alc_gpio1_init_verbs[] = {
385 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
386 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
387 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
391 static const struct hda_verb alc_gpio2_init_verbs[] = {
392 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
393 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
394 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
398 static const struct hda_verb alc_gpio3_init_verbs[] = {
399 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
400 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
401 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
406 * Fix hardware PLL issue
407 * On some codecs, the analog PLL gating control must be off while
408 * the default value is 1.
410 static void alc_fix_pll(struct hda_codec *codec)
412 struct alc_spec *spec = codec->spec;
417 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
419 val = snd_hda_codec_read(codec, spec->pll_nid, 0,
420 AC_VERB_GET_PROC_COEF, 0);
421 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
423 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
424 val & ~(1 << spec->pll_coef_bit));
427 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
428 unsigned int coef_idx, unsigned int coef_bit)
430 struct alc_spec *spec = codec->spec;
432 spec->pll_coef_idx = coef_idx;
433 spec->pll_coef_bit = coef_bit;
438 * Jack-reporting via input-jack layer
441 /* initialization of jacks; currently checks only a few known pins */
442 static int alc_init_jacks(struct hda_codec *codec)
444 #ifdef CONFIG_SND_HDA_INPUT_JACK
445 struct alc_spec *spec = codec->spec;
447 unsigned int hp_nid = spec->autocfg.hp_pins[0];
448 unsigned int mic_nid = spec->ext_mic_pin;
449 unsigned int dock_nid = spec->dock_mic_pin;
452 err = snd_hda_input_jack_add(codec, hp_nid,
453 SND_JACK_HEADPHONE, NULL);
456 snd_hda_input_jack_report(codec, hp_nid);
460 err = snd_hda_input_jack_add(codec, mic_nid,
461 SND_JACK_MICROPHONE, NULL);
464 snd_hda_input_jack_report(codec, mic_nid);
467 err = snd_hda_input_jack_add(codec, dock_nid,
468 SND_JACK_MICROPHONE, NULL);
471 snd_hda_input_jack_report(codec, dock_nid);
473 #endif /* CONFIG_SND_HDA_INPUT_JACK */
478 * Jack detections for HP auto-mute and mic-switch
481 /* check each pin in the given array; returns true if any of them is plugged */
482 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
486 for (i = 0; i < num_pins; i++) {
487 hda_nid_t nid = pins[i];
490 snd_hda_input_jack_report(codec, nid);
491 present |= snd_hda_jack_detect(codec, nid);
496 /* standard HP/line-out auto-mute helper */
497 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
498 bool mute, bool hp_out)
500 struct alc_spec *spec = codec->spec;
501 unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;
502 unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
505 for (i = 0; i < num_pins; i++) {
506 hda_nid_t nid = pins[i];
509 switch (spec->automute_mode) {
510 case ALC_AUTOMUTE_PIN:
511 snd_hda_codec_write(codec, nid, 0,
512 AC_VERB_SET_PIN_WIDGET_CONTROL,
515 case ALC_AUTOMUTE_AMP:
516 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
517 HDA_AMP_MUTE, mute_bits);
519 case ALC_AUTOMUTE_MIXER:
520 nid = spec->automute_mixer_nid[i];
523 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
524 HDA_AMP_MUTE, mute_bits);
525 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,
526 HDA_AMP_MUTE, mute_bits);
532 /* Toggle internal speakers muting */
533 static void update_speakers(struct hda_codec *codec)
535 struct alc_spec *spec = codec->spec;
538 /* Control HP pins/amps depending on master_mute state;
539 * in general, HP pins/amps control should be enabled in all cases,
540 * but currently set only for master_mute, just to be safe
542 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
543 spec->autocfg.hp_pins, spec->master_mute, true);
548 on = spec->jack_present | spec->line_jack_present;
549 on |= spec->master_mute;
550 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
551 spec->autocfg.speaker_pins, on, false);
553 /* toggle line-out mutes if needed, too */
554 /* if LO is a copy of either HP or Speaker, don't need to handle it */
555 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
556 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
558 if (!spec->automute_lines || !spec->automute)
561 on = spec->jack_present;
562 on |= spec->master_mute;
563 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
564 spec->autocfg.line_out_pins, on, false);
567 static void call_update_speakers(struct hda_codec *codec)
569 struct alc_spec *spec = codec->spec;
570 if (spec->automute_hook)
571 spec->automute_hook(codec);
573 update_speakers(codec);
576 /* standard HP-automute helper */
577 static void alc_hp_automute(struct hda_codec *codec)
579 struct alc_spec *spec = codec->spec;
582 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
583 spec->autocfg.hp_pins);
586 call_update_speakers(codec);
589 /* standard line-out-automute helper */
590 static void alc_line_automute(struct hda_codec *codec)
592 struct alc_spec *spec = codec->spec;
594 spec->line_jack_present =
595 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
596 spec->autocfg.line_out_pins);
597 if (!spec->automute || !spec->detect_line)
599 call_update_speakers(codec);
602 #define get_connection_index(codec, mux, nid) \
603 snd_hda_get_conn_index(codec, mux, nid, 0)
605 /* standard mic auto-switch helper */
606 static void alc_mic_automute(struct hda_codec *codec)
608 struct alc_spec *spec = codec->spec;
609 hda_nid_t *pins = spec->imux_pins;
611 if (!spec->auto_mic || !spec->auto_mic_valid_imux)
613 if (snd_BUG_ON(!spec->adc_nids))
615 if (snd_BUG_ON(spec->int_mic_idx < 0 || spec->ext_mic_idx < 0))
618 if (snd_hda_jack_detect(codec, pins[spec->ext_mic_idx]))
619 alc_mux_select(codec, 0, spec->ext_mic_idx, false);
620 else if (spec->dock_mic_idx >= 0 &&
621 snd_hda_jack_detect(codec, pins[spec->dock_mic_idx]))
622 alc_mux_select(codec, 0, spec->dock_mic_idx, false);
624 alc_mux_select(codec, 0, spec->int_mic_idx, false);
626 snd_hda_input_jack_report(codec, pins[spec->ext_mic_idx]);
627 if (spec->dock_mic_idx >= 0)
628 snd_hda_input_jack_report(codec, pins[spec->dock_mic_idx]);
631 /* unsolicited event for HP jack sensing */
632 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
634 if (codec->vendor_id == 0x10ec0880)
640 alc_hp_automute(codec);
642 case ALC_FRONT_EVENT:
643 alc_line_automute(codec);
646 alc_mic_automute(codec);
651 /* call init functions of standard auto-mute helpers */
652 static void alc_inithook(struct hda_codec *codec)
654 alc_hp_automute(codec);
655 alc_line_automute(codec);
656 alc_mic_automute(codec);
659 /* additional initialization for ALC888 variants */
660 static void alc888_coef_init(struct hda_codec *codec)
664 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
665 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
666 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
667 if ((tmp & 0xf0) == 0x20)
669 snd_hda_codec_read(codec, 0x20, 0,
670 AC_VERB_SET_PROC_COEF, 0x830);
673 snd_hda_codec_read(codec, 0x20, 0,
674 AC_VERB_SET_PROC_COEF, 0x3030);
677 /* additional initialization for ALC889 variants */
678 static void alc889_coef_init(struct hda_codec *codec)
682 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
683 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
684 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
685 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
688 /* turn on/off EAPD control (only if available) */
689 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
691 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
693 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
694 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
698 /* turn on/off EAPD controls of the codec */
699 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
701 /* We currently only handle front, HP */
702 static hda_nid_t pins[] = {
703 0x0f, 0x10, 0x14, 0x15, 0
706 for (p = pins; *p; p++)
707 set_eapd(codec, *p, on);
710 /* generic shutup callback;
711 * just turning off EPAD and a little pause for avoiding pop-noise
713 static void alc_eapd_shutup(struct hda_codec *codec)
715 alc_auto_setup_eapd(codec, false);
719 /* generic EAPD initialization */
720 static void alc_auto_init_amp(struct hda_codec *codec, int type)
724 alc_auto_setup_eapd(codec, true);
727 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
730 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
733 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
735 case ALC_INIT_DEFAULT:
736 switch (codec->vendor_id) {
738 snd_hda_codec_write(codec, 0x1a, 0,
739 AC_VERB_SET_COEF_INDEX, 7);
740 tmp = snd_hda_codec_read(codec, 0x1a, 0,
741 AC_VERB_GET_PROC_COEF, 0);
742 snd_hda_codec_write(codec, 0x1a, 0,
743 AC_VERB_SET_COEF_INDEX, 7);
744 snd_hda_codec_write(codec, 0x1a, 0,
745 AC_VERB_SET_PROC_COEF,
754 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
755 alc889_coef_init(codec);
758 alc888_coef_init(codec);
760 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
763 snd_hda_codec_write(codec, 0x20, 0,
764 AC_VERB_SET_COEF_INDEX, 7);
765 tmp = snd_hda_codec_read(codec, 0x20, 0,
766 AC_VERB_GET_PROC_COEF, 0);
767 snd_hda_codec_write(codec, 0x20, 0,
768 AC_VERB_SET_COEF_INDEX, 7);
769 snd_hda_codec_write(codec, 0x20, 0,
770 AC_VERB_SET_PROC_COEF,
780 * Auto-Mute mode mixer enum support
782 static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
783 struct snd_ctl_elem_info *uinfo)
785 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
786 struct alc_spec *spec = codec->spec;
787 static const char * const texts2[] = {
788 "Disabled", "Enabled"
790 static const char * const texts3[] = {
791 "Disabled", "Speaker Only", "Line-Out+Speaker"
793 const char * const *texts;
795 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
797 if (spec->automute_hp_lo) {
798 uinfo->value.enumerated.items = 3;
801 uinfo->value.enumerated.items = 2;
804 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
805 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
806 strcpy(uinfo->value.enumerated.name,
807 texts[uinfo->value.enumerated.item]);
811 static int alc_automute_mode_get(struct snd_kcontrol *kcontrol,
812 struct snd_ctl_elem_value *ucontrol)
814 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
815 struct alc_spec *spec = codec->spec;
819 else if (!spec->automute_lines)
823 ucontrol->value.enumerated.item[0] = val;
827 static int alc_automute_mode_put(struct snd_kcontrol *kcontrol,
828 struct snd_ctl_elem_value *ucontrol)
830 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
831 struct alc_spec *spec = codec->spec;
833 switch (ucontrol->value.enumerated.item[0]) {
840 if (spec->automute && !spec->automute_lines)
843 spec->automute_lines = 0;
846 if (!spec->automute_hp_lo)
848 if (spec->automute && spec->automute_lines)
851 spec->automute_lines = 1;
856 call_update_speakers(codec);
860 static const struct snd_kcontrol_new alc_automute_mode_enum = {
861 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
862 .name = "Auto-Mute Mode",
863 .info = alc_automute_mode_info,
864 .get = alc_automute_mode_get,
865 .put = alc_automute_mode_put,
868 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
870 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
871 return snd_array_new(&spec->kctls);
874 static int alc_add_automute_mode_enum(struct hda_codec *codec)
876 struct alc_spec *spec = codec->spec;
877 struct snd_kcontrol_new *knew;
879 knew = alc_kcontrol_new(spec);
882 *knew = alc_automute_mode_enum;
883 knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
890 * Check the availability of HP/line-out auto-mute;
891 * Set up appropriately if really supported
893 static void alc_init_auto_hp(struct hda_codec *codec)
895 struct alc_spec *spec = codec->spec;
896 struct auto_pin_cfg *cfg = &spec->autocfg;
902 if (cfg->line_out_pins[0])
904 if (cfg->speaker_pins[0])
906 if (present < 2) /* need two different output types */
909 spec->automute_hp_lo = 1; /* both HP and LO automute */
911 if (!cfg->speaker_pins[0] &&
912 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
913 memcpy(cfg->speaker_pins, cfg->line_out_pins,
914 sizeof(cfg->speaker_pins));
915 cfg->speaker_outs = cfg->line_outs;
918 if (!cfg->hp_pins[0] &&
919 cfg->line_out_type == AUTO_PIN_HP_OUT) {
920 memcpy(cfg->hp_pins, cfg->line_out_pins,
921 sizeof(cfg->hp_pins));
922 cfg->hp_outs = cfg->line_outs;
925 for (i = 0; i < cfg->hp_outs; i++) {
926 hda_nid_t nid = cfg->hp_pins[i];
927 if (!is_jack_detectable(codec, nid))
929 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
931 snd_hda_codec_write_cache(codec, nid, 0,
932 AC_VERB_SET_UNSOLICITED_ENABLE,
933 AC_USRSP_EN | ALC_HP_EVENT);
935 spec->automute_mode = ALC_AUTOMUTE_PIN;
937 if (spec->automute && cfg->line_out_pins[0] &&
938 cfg->speaker_pins[0] &&
939 cfg->line_out_pins[0] != cfg->hp_pins[0] &&
940 cfg->line_out_pins[0] != cfg->speaker_pins[0]) {
941 for (i = 0; i < cfg->line_outs; i++) {
942 hda_nid_t nid = cfg->line_out_pins[i];
943 if (!is_jack_detectable(codec, nid))
945 snd_printdd("realtek: Enable Line-Out auto-muting "
946 "on NID 0x%x\n", nid);
947 snd_hda_codec_write_cache(codec, nid, 0,
948 AC_VERB_SET_UNSOLICITED_ENABLE,
949 AC_USRSP_EN | ALC_FRONT_EVENT);
950 spec->detect_line = 1;
952 spec->automute_lines = spec->detect_line;
955 if (spec->automute) {
956 /* create a control for automute mode */
957 alc_add_automute_mode_enum(codec);
958 spec->unsol_event = alc_sku_unsol_event;
962 /* return the position of NID in the list, or -1 if not found */
963 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
966 for (i = 0; i < nums; i++)
972 /* check whether dynamic ADC-switching is available */
973 static bool alc_check_dyn_adc_switch(struct hda_codec *codec)
975 struct alc_spec *spec = codec->spec;
976 struct hda_input_mux *imux = &spec->private_imux[0];
980 if (imux != spec->input_mux) /* no dynamic imux? */
983 for (n = 0; n < spec->num_adc_nids; n++) {
984 cap = spec->private_capsrc_nids[n];
985 for (i = 0; i < imux->num_items; i++) {
986 pin = spec->imux_pins[i];
989 if (get_connection_index(codec, cap, pin) < 0)
992 if (i >= imux->num_items)
993 return true; /* no ADC-switch is needed */
996 for (i = 0; i < imux->num_items; i++) {
997 pin = spec->imux_pins[i];
998 for (n = 0; n < spec->num_adc_nids; n++) {
999 cap = spec->private_capsrc_nids[n];
1000 idx = get_connection_index(codec, cap, pin);
1002 imux->items[i].index = idx;
1003 spec->dyn_adc_idx[i] = n;
1009 snd_printdd("realtek: enabling ADC switching\n");
1010 spec->dyn_adc_switch = 1;
1014 /* rebuild imux for matching with the given auto-mic pins (if not yet) */
1015 static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec)
1017 struct alc_spec *spec = codec->spec;
1018 struct hda_input_mux *imux;
1019 static char * const texts[3] = {
1020 "Mic", "Internal Mic", "Dock Mic"
1024 if (!spec->auto_mic)
1026 imux = &spec->private_imux[0];
1027 if (spec->input_mux == imux)
1029 spec->imux_pins[0] = spec->ext_mic_pin;
1030 spec->imux_pins[1] = spec->int_mic_pin;
1031 spec->imux_pins[2] = spec->dock_mic_pin;
1032 for (i = 0; i < 3; i++) {
1033 strcpy(imux->items[i].label, texts[i]);
1034 if (spec->imux_pins[i])
1035 imux->num_items = i + 1;
1037 spec->num_mux_defs = 1;
1038 spec->input_mux = imux;
1042 /* check whether all auto-mic pins are valid; setup indices if OK */
1043 static bool alc_auto_mic_check_imux(struct hda_codec *codec)
1045 struct alc_spec *spec = codec->spec;
1046 const struct hda_input_mux *imux;
1048 if (!spec->auto_mic)
1050 if (spec->auto_mic_valid_imux)
1051 return true; /* already checked */
1053 /* fill up imux indices */
1054 if (!alc_check_dyn_adc_switch(codec)) {
1059 imux = spec->input_mux;
1060 spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin,
1061 spec->imux_pins, imux->num_items);
1062 spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin,
1063 spec->imux_pins, imux->num_items);
1064 spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin,
1065 spec->imux_pins, imux->num_items);
1066 if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) {
1068 return false; /* no corresponding imux */
1071 snd_hda_codec_write_cache(codec, spec->ext_mic_pin, 0,
1072 AC_VERB_SET_UNSOLICITED_ENABLE,
1073 AC_USRSP_EN | ALC_MIC_EVENT);
1074 if (spec->dock_mic_pin)
1075 snd_hda_codec_write_cache(codec, spec->dock_mic_pin, 0,
1076 AC_VERB_SET_UNSOLICITED_ENABLE,
1077 AC_USRSP_EN | ALC_MIC_EVENT);
1079 spec->auto_mic_valid_imux = 1;
1085 * Check the availability of auto-mic switch;
1086 * Set up if really supported
1088 static void alc_init_auto_mic(struct hda_codec *codec)
1090 struct alc_spec *spec = codec->spec;
1091 struct auto_pin_cfg *cfg = &spec->autocfg;
1092 hda_nid_t fixed, ext, dock;
1095 spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1;
1097 fixed = ext = dock = 0;
1098 for (i = 0; i < cfg->num_inputs; i++) {
1099 hda_nid_t nid = cfg->inputs[i].pin;
1100 unsigned int defcfg;
1101 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1102 switch (snd_hda_get_input_pin_attr(defcfg)) {
1103 case INPUT_PIN_ATTR_INT:
1105 return; /* already occupied */
1106 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1107 return; /* invalid type */
1110 case INPUT_PIN_ATTR_UNUSED:
1111 return; /* invalid entry */
1112 case INPUT_PIN_ATTR_DOCK:
1114 return; /* already occupied */
1115 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
1116 return; /* invalid type */
1121 return; /* already occupied */
1122 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1123 return; /* invalid type */
1134 if (!is_jack_detectable(codec, ext))
1135 return; /* no unsol support */
1136 if (dock && !is_jack_detectable(codec, dock))
1137 return; /* no unsol support */
1139 /* check imux indices */
1140 spec->ext_mic_pin = ext;
1141 spec->int_mic_pin = fixed;
1142 spec->dock_mic_pin = dock;
1145 if (!alc_auto_mic_check_imux(codec))
1148 snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1150 spec->unsol_event = alc_sku_unsol_event;
1153 /* check the availabilities of auto-mute and auto-mic switches */
1154 static void alc_auto_check_switches(struct hda_codec *codec)
1156 alc_init_auto_hp(codec);
1157 alc_init_auto_mic(codec);
1161 * Realtek SSID verification
1164 /* Could be any non-zero and even value. When used as fixup, tells
1165 * the driver to ignore any present sku defines.
1167 #define ALC_FIXUP_SKU_IGNORE (2)
1169 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1171 unsigned int ass, tmp, i;
1173 struct alc_spec *spec = codec->spec;
1175 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1177 if (spec->cdefine.fixup) {
1178 ass = spec->cdefine.sku_cfg;
1179 if (ass == ALC_FIXUP_SKU_IGNORE)
1184 ass = codec->subsystem_id & 0xffff;
1185 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1189 if (codec->vendor_id == 0x10ec0260)
1191 ass = snd_hda_codec_get_pincfg(codec, nid);
1194 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1195 codec->chip_name, ass);
1201 for (i = 1; i < 16; i++) {
1205 if (((ass >> 16) & 0xf) != tmp)
1208 spec->cdefine.port_connectivity = ass >> 30;
1209 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1210 spec->cdefine.check_sum = (ass >> 16) & 0xf;
1211 spec->cdefine.customization = ass >> 8;
1213 spec->cdefine.sku_cfg = ass;
1214 spec->cdefine.external_amp = (ass & 0x38) >> 3;
1215 spec->cdefine.platform_type = (ass & 0x4) >> 2;
1216 spec->cdefine.swap = (ass & 0x2) >> 1;
1217 spec->cdefine.override = ass & 0x1;
1219 snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1220 nid, spec->cdefine.sku_cfg);
1221 snd_printd("SKU: port_connectivity=0x%x\n",
1222 spec->cdefine.port_connectivity);
1223 snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1224 snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1225 snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1226 snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1227 snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1228 snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1229 snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1234 /* return true if the given NID is found in the list */
1235 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1237 return find_idx_in_nid_list(nid, list, nums) >= 0;
1240 /* check subsystem ID and set up device-specific initialization;
1241 * return 1 if initialized, 0 if invalid SSID
1243 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1244 * 31 ~ 16 : Manufacture ID
1246 * 7 ~ 0 : Assembly ID
1247 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1249 static int alc_subsystem_id(struct hda_codec *codec,
1250 hda_nid_t porta, hda_nid_t porte,
1251 hda_nid_t portd, hda_nid_t porti)
1253 unsigned int ass, tmp, i;
1255 struct alc_spec *spec = codec->spec;
1257 if (spec->cdefine.fixup) {
1258 ass = spec->cdefine.sku_cfg;
1259 if (ass == ALC_FIXUP_SKU_IGNORE)
1264 ass = codec->subsystem_id & 0xffff;
1265 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1268 /* invalid SSID, check the special NID pin defcfg instead */
1270 * 31~30 : port connectivity
1273 * 19~16 : Check sum (15:1)
1278 if (codec->vendor_id == 0x10ec0260)
1280 ass = snd_hda_codec_get_pincfg(codec, nid);
1281 snd_printd("realtek: No valid SSID, "
1282 "checking pincfg 0x%08x for NID 0x%x\n",
1286 if ((ass >> 30) != 1) /* no physical connection */
1291 for (i = 1; i < 16; i++) {
1295 if (((ass >> 16) & 0xf) != tmp)
1298 snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1299 ass & 0xffff, codec->vendor_id);
1303 * 2 : 0 --> Desktop, 1 --> Laptop
1304 * 3~5 : External Amplifier control
1307 tmp = (ass & 0x38) >> 3; /* external Amp control */
1310 spec->init_amp = ALC_INIT_GPIO1;
1313 spec->init_amp = ALC_INIT_GPIO2;
1316 spec->init_amp = ALC_INIT_GPIO3;
1320 spec->init_amp = ALC_INIT_DEFAULT;
1324 /* is laptop or Desktop and enable the function "Mute internal speaker
1325 * when the external headphone out jack is plugged"
1327 if (!(ass & 0x8000))
1330 * 10~8 : Jack location
1331 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1333 * 15 : 1 --> enable the function "Mute internal speaker
1334 * when the external headphone out jack is plugged"
1336 if (!spec->autocfg.hp_pins[0]) {
1338 tmp = (ass >> 11) & 0x3; /* HP to chassis */
1349 if (found_in_nid_list(nid, spec->autocfg.line_out_pins,
1350 spec->autocfg.line_outs))
1352 spec->autocfg.hp_pins[0] = nid;
1357 /* Check the validity of ALC subsystem-id
1358 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
1359 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
1361 if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {
1362 struct alc_spec *spec = codec->spec;
1363 snd_printd("realtek: "
1364 "Enable default setup for auto mode as fallback\n");
1365 spec->init_amp = ALC_INIT_DEFAULT;
1370 * Fix-up pin default configurations and add default verbs
1378 struct alc_model_fixup {
1389 const struct alc_pincfg *pins;
1390 const struct hda_verb *verbs;
1391 void (*func)(struct hda_codec *codec,
1392 const struct alc_fixup *fix,
1406 ALC_FIXUP_ACT_PRE_PROBE,
1407 ALC_FIXUP_ACT_PROBE,
1411 static void alc_apply_fixup(struct hda_codec *codec, int action)
1413 struct alc_spec *spec = codec->spec;
1414 int id = spec->fixup_id;
1415 #ifdef CONFIG_SND_DEBUG_VERBOSE
1416 const char *modelname = spec->fixup_name;
1420 if (!spec->fixup_list)
1424 const struct alc_fixup *fix = spec->fixup_list + id;
1425 const struct alc_pincfg *cfg;
1427 switch (fix->type) {
1429 if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1431 snd_printdd(KERN_INFO "hda_codec: %s: "
1432 "Apply sku override for %s\n",
1433 codec->chip_name, modelname);
1434 spec->cdefine.sku_cfg = fix->v.sku;
1435 spec->cdefine.fixup = 1;
1437 case ALC_FIXUP_PINS:
1439 if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1441 snd_printdd(KERN_INFO "hda_codec: %s: "
1442 "Apply pincfg for %s\n",
1443 codec->chip_name, modelname);
1444 for (; cfg->nid; cfg++)
1445 snd_hda_codec_set_pincfg(codec, cfg->nid,
1448 case ALC_FIXUP_VERBS:
1449 if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1451 snd_printdd(KERN_INFO "hda_codec: %s: "
1452 "Apply fix-verbs for %s\n",
1453 codec->chip_name, modelname);
1454 add_verb(codec->spec, fix->v.verbs);
1456 case ALC_FIXUP_FUNC:
1459 snd_printdd(KERN_INFO "hda_codec: %s: "
1460 "Apply fix-func for %s\n",
1461 codec->chip_name, modelname);
1462 fix->v.func(codec, fix, action);
1465 snd_printk(KERN_ERR "hda_codec: %s: "
1466 "Invalid fixup type %d\n",
1467 codec->chip_name, fix->type);
1478 static void alc_pick_fixup(struct hda_codec *codec,
1479 const struct alc_model_fixup *models,
1480 const struct snd_pci_quirk *quirk,
1481 const struct alc_fixup *fixlist)
1483 struct alc_spec *spec = codec->spec;
1485 const char *name = NULL;
1487 if (codec->modelname && models) {
1488 while (models->name) {
1489 if (!strcmp(codec->modelname, models->name)) {
1491 name = models->name;
1498 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1501 #ifdef CONFIG_SND_DEBUG_VERBOSE
1507 spec->fixup_id = id;
1509 spec->fixup_list = fixlist;
1510 spec->fixup_name = name;
1515 * COEF access helper functions
1517 static int alc_read_coef_idx(struct hda_codec *codec,
1518 unsigned int coef_idx)
1521 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1523 val = snd_hda_codec_read(codec, 0x20, 0,
1524 AC_VERB_GET_PROC_COEF, 0);
1528 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1529 unsigned int coef_val)
1531 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1533 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1538 * Digital I/O handling
1541 /* set right pin controls for digital I/O */
1542 static void alc_auto_init_digital(struct hda_codec *codec)
1544 struct alc_spec *spec = codec->spec;
1548 for (i = 0; i < spec->autocfg.dig_outs; i++) {
1549 pin = spec->autocfg.dig_out_pins[i];
1552 snd_hda_codec_write(codec, pin, 0,
1553 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
1555 dac = spec->multiout.dig_out_nid;
1557 dac = spec->slave_dig_outs[i - 1];
1558 if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
1560 snd_hda_codec_write(codec, dac, 0,
1561 AC_VERB_SET_AMP_GAIN_MUTE,
1564 pin = spec->autocfg.dig_in_pin;
1566 snd_hda_codec_write(codec, pin, 0,
1567 AC_VERB_SET_PIN_WIDGET_CONTROL,
1571 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1572 static void alc_auto_parse_digital(struct hda_codec *codec)
1574 struct alc_spec *spec = codec->spec;
1578 /* support multiple SPDIFs; the secondary is set up as a slave */
1579 for (i = 0; i < spec->autocfg.dig_outs; i++) {
1581 err = snd_hda_get_connections(codec,
1582 spec->autocfg.dig_out_pins[i],
1583 conn, ARRAY_SIZE(conn));
1586 dig_nid = conn[0]; /* assume the first element is audio-out */
1588 spec->multiout.dig_out_nid = dig_nid;
1589 spec->dig_out_type = spec->autocfg.dig_out_type[0];
1591 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1592 if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1594 spec->slave_dig_outs[i - 1] = dig_nid;
1598 if (spec->autocfg.dig_in_pin) {
1599 dig_nid = codec->start_nid;
1600 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1601 unsigned int wcaps = get_wcaps(codec, dig_nid);
1602 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1604 if (!(wcaps & AC_WCAP_DIGITAL))
1606 if (!(wcaps & AC_WCAP_CONN_LIST))
1608 err = get_connection_index(codec, dig_nid,
1609 spec->autocfg.dig_in_pin);
1611 spec->dig_in_nid = dig_nid;
1619 * capture mixer elements
1621 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1622 struct snd_ctl_elem_info *uinfo)
1624 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1625 struct alc_spec *spec = codec->spec;
1629 mutex_lock(&codec->control_mutex);
1630 if (spec->vol_in_capsrc)
1631 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1633 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1634 kcontrol->private_value = val;
1635 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1636 mutex_unlock(&codec->control_mutex);
1640 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1641 unsigned int size, unsigned int __user *tlv)
1643 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1644 struct alc_spec *spec = codec->spec;
1648 mutex_lock(&codec->control_mutex);
1649 if (spec->vol_in_capsrc)
1650 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1652 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1653 kcontrol->private_value = val;
1654 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1655 mutex_unlock(&codec->control_mutex);
1659 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1660 struct snd_ctl_elem_value *ucontrol);
1662 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1663 struct snd_ctl_elem_value *ucontrol,
1664 getput_call_t func, bool check_adc_switch)
1666 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1667 struct alc_spec *spec = codec->spec;
1670 mutex_lock(&codec->control_mutex);
1671 if (check_adc_switch && spec->dyn_adc_switch) {
1672 for (i = 0; i < spec->num_adc_nids; i++) {
1673 kcontrol->private_value =
1674 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1676 err = func(kcontrol, ucontrol);
1681 i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1682 if (spec->vol_in_capsrc)
1683 kcontrol->private_value =
1684 HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i],
1687 kcontrol->private_value =
1688 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1690 err = func(kcontrol, ucontrol);
1693 mutex_unlock(&codec->control_mutex);
1697 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1698 struct snd_ctl_elem_value *ucontrol)
1700 return alc_cap_getput_caller(kcontrol, ucontrol,
1701 snd_hda_mixer_amp_volume_get, false);
1704 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1705 struct snd_ctl_elem_value *ucontrol)
1707 return alc_cap_getput_caller(kcontrol, ucontrol,
1708 snd_hda_mixer_amp_volume_put, true);
1711 /* capture mixer elements */
1712 #define alc_cap_sw_info snd_ctl_boolean_stereo_info
1714 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1715 struct snd_ctl_elem_value *ucontrol)
1717 return alc_cap_getput_caller(kcontrol, ucontrol,
1718 snd_hda_mixer_amp_switch_get, false);
1721 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1722 struct snd_ctl_elem_value *ucontrol)
1724 return alc_cap_getput_caller(kcontrol, ucontrol,
1725 snd_hda_mixer_amp_switch_put, true);
1728 #define _DEFINE_CAPMIX(num) \
1730 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1731 .name = "Capture Switch", \
1732 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1734 .info = alc_cap_sw_info, \
1735 .get = alc_cap_sw_get, \
1736 .put = alc_cap_sw_put, \
1739 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1740 .name = "Capture Volume", \
1741 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1742 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1743 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1745 .info = alc_cap_vol_info, \
1746 .get = alc_cap_vol_get, \
1747 .put = alc_cap_vol_put, \
1748 .tlv = { .c = alc_cap_vol_tlv }, \
1751 #define _DEFINE_CAPSRC(num) \
1753 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1754 /* .name = "Capture Source", */ \
1755 .name = "Input Source", \
1757 .info = alc_mux_enum_info, \
1758 .get = alc_mux_enum_get, \
1759 .put = alc_mux_enum_put, \
1762 #define DEFINE_CAPMIX(num) \
1763 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1764 _DEFINE_CAPMIX(num), \
1765 _DEFINE_CAPSRC(num), \
1769 #define DEFINE_CAPMIX_NOSRC(num) \
1770 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1771 _DEFINE_CAPMIX(num), \
1775 /* up to three ADCs */
1779 DEFINE_CAPMIX_NOSRC(1);
1780 DEFINE_CAPMIX_NOSRC(2);
1781 DEFINE_CAPMIX_NOSRC(3);
1784 * virtual master controls
1788 * slave controls for virtual master
1790 static const char * const alc_slave_vols[] = {
1791 "Front Playback Volume",
1792 "Surround Playback Volume",
1793 "Center Playback Volume",
1794 "LFE Playback Volume",
1795 "Side Playback Volume",
1796 "Headphone Playback Volume",
1797 "Speaker Playback Volume",
1798 "Mono Playback Volume",
1799 "Line-Out Playback Volume",
1800 "PCM Playback Volume",
1804 static const char * const alc_slave_sws[] = {
1805 "Front Playback Switch",
1806 "Surround Playback Switch",
1807 "Center Playback Switch",
1808 "LFE Playback Switch",
1809 "Side Playback Switch",
1810 "Headphone Playback Switch",
1811 "Speaker Playback Switch",
1812 "Mono Playback Switch",
1813 "IEC958 Playback Switch",
1814 "Line-Out Playback Switch",
1815 "PCM Playback Switch",
1820 * build control elements
1823 #define NID_MAPPING (-1)
1825 #define SUBDEV_SPEAKER_ (0 << 6)
1826 #define SUBDEV_HP_ (1 << 6)
1827 #define SUBDEV_LINE_ (2 << 6)
1828 #define SUBDEV_SPEAKER(x) (SUBDEV_SPEAKER_ | ((x) & 0x3f))
1829 #define SUBDEV_HP(x) (SUBDEV_HP_ | ((x) & 0x3f))
1830 #define SUBDEV_LINE(x) (SUBDEV_LINE_ | ((x) & 0x3f))
1832 static void alc_free_kctls(struct hda_codec *codec);
1834 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1835 /* additional beep mixers; the actual parameters are overwritten at build */
1836 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1837 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1838 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1843 static int alc_build_controls(struct hda_codec *codec)
1845 struct alc_spec *spec = codec->spec;
1846 struct snd_kcontrol *kctl = NULL;
1847 const struct snd_kcontrol_new *knew;
1852 for (i = 0; i < spec->num_mixers; i++) {
1853 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1857 if (spec->cap_mixer) {
1858 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
1862 if (spec->multiout.dig_out_nid) {
1863 err = snd_hda_create_spdif_out_ctls(codec,
1864 spec->multiout.dig_out_nid,
1865 spec->multiout.dig_out_nid);
1868 if (!spec->no_analog) {
1869 err = snd_hda_create_spdif_share_sw(codec,
1873 spec->multiout.share_spdif = 1;
1876 if (spec->dig_in_nid) {
1877 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1882 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1883 /* create beep controls if needed */
1884 if (spec->beep_amp) {
1885 const struct snd_kcontrol_new *knew;
1886 for (knew = alc_beep_mixer; knew->name; knew++) {
1887 struct snd_kcontrol *kctl;
1888 kctl = snd_ctl_new1(knew, codec);
1891 kctl->private_value = spec->beep_amp;
1892 err = snd_hda_ctl_add(codec, 0, kctl);
1899 /* if we have no master control, let's create it */
1900 if (!spec->no_analog &&
1901 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1902 unsigned int vmaster_tlv[4];
1903 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1904 HDA_OUTPUT, vmaster_tlv);
1905 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1906 vmaster_tlv, alc_slave_vols);
1910 if (!spec->no_analog &&
1911 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1912 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1913 NULL, alc_slave_sws);
1918 /* assign Capture Source enums to NID */
1919 if (spec->capsrc_nids || spec->adc_nids) {
1920 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
1922 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1923 for (i = 0; kctl && i < kctl->count; i++) {
1924 const hda_nid_t *nids = spec->capsrc_nids;
1926 nids = spec->adc_nids;
1927 err = snd_hda_add_nid(codec, kctl, i, nids[i]);
1932 if (spec->cap_mixer && spec->adc_nids) {
1933 const char *kname = kctl ? kctl->id.name : NULL;
1934 for (knew = spec->cap_mixer; knew->name; knew++) {
1935 if (kname && strcmp(knew->name, kname) == 0)
1937 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
1938 for (i = 0; kctl && i < kctl->count; i++) {
1939 err = snd_hda_add_nid(codec, kctl, i,
1947 /* other nid->control mapping */
1948 for (i = 0; i < spec->num_mixers; i++) {
1949 for (knew = spec->mixers[i]; knew->name; knew++) {
1950 if (knew->iface != NID_MAPPING)
1952 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
1955 u = knew->subdevice;
1956 for (j = 0; j < 4; j++, u >>= 8) {
1961 case SUBDEV_SPEAKER_:
1962 nid = spec->autocfg.speaker_pins[nid];
1965 nid = spec->autocfg.line_out_pins[nid];
1968 nid = spec->autocfg.hp_pins[nid];
1973 err = snd_hda_add_nid(codec, kctl, 0, nid);
1977 u = knew->private_value;
1978 for (j = 0; j < 4; j++, u >>= 8) {
1982 err = snd_hda_add_nid(codec, kctl, 0, nid);
1989 alc_free_kctls(codec); /* no longer needed */
1999 static void alc_init_special_input_src(struct hda_codec *codec);
2001 static int alc_init(struct hda_codec *codec)
2003 struct alc_spec *spec = codec->spec;
2007 alc_auto_init_amp(codec, spec->init_amp);
2009 for (i = 0; i < spec->num_init_verbs; i++)
2010 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2011 alc_init_special_input_src(codec);
2013 if (spec->init_hook)
2014 spec->init_hook(codec);
2016 alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
2018 hda_call_check_power_status(codec, 0x01);
2022 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2024 struct alc_spec *spec = codec->spec;
2026 if (spec->unsol_event)
2027 spec->unsol_event(codec, res);
2030 #ifdef CONFIG_SND_HDA_POWER_SAVE
2031 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2033 struct alc_spec *spec = codec->spec;
2034 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2039 * Analog playback callbacks
2041 static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo,
2042 struct hda_codec *codec,
2043 struct snd_pcm_substream *substream)
2045 struct alc_spec *spec = codec->spec;
2046 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2050 static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2051 struct hda_codec *codec,
2052 unsigned int stream_tag,
2053 unsigned int format,
2054 struct snd_pcm_substream *substream)
2056 struct alc_spec *spec = codec->spec;
2057 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2058 stream_tag, format, substream);
2061 static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2062 struct hda_codec *codec,
2063 struct snd_pcm_substream *substream)
2065 struct alc_spec *spec = codec->spec;
2066 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2072 static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2073 struct hda_codec *codec,
2074 struct snd_pcm_substream *substream)
2076 struct alc_spec *spec = codec->spec;
2077 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2080 static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2081 struct hda_codec *codec,
2082 unsigned int stream_tag,
2083 unsigned int format,
2084 struct snd_pcm_substream *substream)
2086 struct alc_spec *spec = codec->spec;
2087 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2088 stream_tag, format, substream);
2091 static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2092 struct hda_codec *codec,
2093 struct snd_pcm_substream *substream)
2095 struct alc_spec *spec = codec->spec;
2096 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2099 static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2100 struct hda_codec *codec,
2101 struct snd_pcm_substream *substream)
2103 struct alc_spec *spec = codec->spec;
2104 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2110 static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2111 struct hda_codec *codec,
2112 unsigned int stream_tag,
2113 unsigned int format,
2114 struct snd_pcm_substream *substream)
2116 struct alc_spec *spec = codec->spec;
2118 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2119 stream_tag, 0, format);
2123 static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2124 struct hda_codec *codec,
2125 struct snd_pcm_substream *substream)
2127 struct alc_spec *spec = codec->spec;
2129 snd_hda_codec_cleanup_stream(codec,
2130 spec->adc_nids[substream->number + 1]);
2134 /* analog capture with dynamic dual-adc changes */
2135 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2136 struct hda_codec *codec,
2137 unsigned int stream_tag,
2138 unsigned int format,
2139 struct snd_pcm_substream *substream)
2141 struct alc_spec *spec = codec->spec;
2142 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
2143 spec->cur_adc_stream_tag = stream_tag;
2144 spec->cur_adc_format = format;
2145 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
2149 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2150 struct hda_codec *codec,
2151 struct snd_pcm_substream *substream)
2153 struct alc_spec *spec = codec->spec;
2154 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
2159 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
2163 .nid = 0, /* fill later */
2165 .prepare = dyn_adc_capture_pcm_prepare,
2166 .cleanup = dyn_adc_capture_pcm_cleanup
2172 static const struct hda_pcm_stream alc_pcm_analog_playback = {
2176 /* NID is set in alc_build_pcms */
2178 .open = alc_playback_pcm_open,
2179 .prepare = alc_playback_pcm_prepare,
2180 .cleanup = alc_playback_pcm_cleanup
2184 static const struct hda_pcm_stream alc_pcm_analog_capture = {
2188 /* NID is set in alc_build_pcms */
2191 static const struct hda_pcm_stream alc_pcm_analog_alt_playback = {
2195 /* NID is set in alc_build_pcms */
2198 static const struct hda_pcm_stream alc_pcm_analog_alt_capture = {
2199 .substreams = 2, /* can be overridden */
2202 /* NID is set in alc_build_pcms */
2204 .prepare = alc_alt_capture_pcm_prepare,
2205 .cleanup = alc_alt_capture_pcm_cleanup
2209 static const struct hda_pcm_stream alc_pcm_digital_playback = {
2213 /* NID is set in alc_build_pcms */
2215 .open = alc_dig_playback_pcm_open,
2216 .close = alc_dig_playback_pcm_close,
2217 .prepare = alc_dig_playback_pcm_prepare,
2218 .cleanup = alc_dig_playback_pcm_cleanup
2222 static const struct hda_pcm_stream alc_pcm_digital_capture = {
2226 /* NID is set in alc_build_pcms */
2229 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2230 static const struct hda_pcm_stream alc_pcm_null_stream = {
2236 static int alc_build_pcms(struct hda_codec *codec)
2238 struct alc_spec *spec = codec->spec;
2239 struct hda_pcm *info = spec->pcm_rec;
2240 const struct hda_pcm_stream *p;
2243 codec->num_pcms = 1;
2244 codec->pcm_info = info;
2246 if (spec->no_analog)
2249 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
2250 "%s Analog", codec->chip_name);
2251 info->name = spec->stream_name_analog;
2253 if (spec->multiout.dac_nids > 0) {
2254 p = spec->stream_analog_playback;
2256 p = &alc_pcm_analog_playback;
2257 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2258 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2260 if (spec->adc_nids) {
2261 p = spec->stream_analog_capture;
2263 if (spec->dyn_adc_switch)
2264 p = &dyn_adc_pcm_analog_capture;
2266 p = &alc_pcm_analog_capture;
2268 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2269 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2272 if (spec->channel_mode) {
2273 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2274 for (i = 0; i < spec->num_channel_mode; i++) {
2275 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2276 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2282 /* SPDIF for stream index #1 */
2283 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2284 snprintf(spec->stream_name_digital,
2285 sizeof(spec->stream_name_digital),
2286 "%s Digital", codec->chip_name);
2287 codec->num_pcms = 2;
2288 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
2289 info = spec->pcm_rec + 1;
2290 info->name = spec->stream_name_digital;
2291 if (spec->dig_out_type)
2292 info->pcm_type = spec->dig_out_type;
2294 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2295 if (spec->multiout.dig_out_nid) {
2296 p = spec->stream_digital_playback;
2298 p = &alc_pcm_digital_playback;
2299 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2300 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2302 if (spec->dig_in_nid) {
2303 p = spec->stream_digital_capture;
2305 p = &alc_pcm_digital_capture;
2306 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2307 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2309 /* FIXME: do we need this for all Realtek codec models? */
2310 codec->spdif_status_reset = 1;
2313 if (spec->no_analog)
2316 /* If the use of more than one ADC is requested for the current
2317 * model, configure a second analog capture-only PCM.
2319 /* Additional Analaog capture for index #2 */
2320 if (spec->alt_dac_nid || spec->num_adc_nids > 1) {
2321 codec->num_pcms = 3;
2322 info = spec->pcm_rec + 2;
2323 info->name = spec->stream_name_analog;
2324 if (spec->alt_dac_nid) {
2325 p = spec->stream_analog_alt_playback;
2327 p = &alc_pcm_analog_alt_playback;
2328 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2329 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2332 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2333 alc_pcm_null_stream;
2334 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2336 if (spec->num_adc_nids > 1) {
2337 p = spec->stream_analog_alt_capture;
2339 p = &alc_pcm_analog_alt_capture;
2340 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2341 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2343 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2344 spec->num_adc_nids - 1;
2346 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2347 alc_pcm_null_stream;
2348 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2355 static inline void alc_shutup(struct hda_codec *codec)
2357 struct alc_spec *spec = codec->spec;
2359 if (spec && spec->shutup)
2360 spec->shutup(codec);
2361 snd_hda_shutup_pins(codec);
2364 static void alc_free_kctls(struct hda_codec *codec)
2366 struct alc_spec *spec = codec->spec;
2368 if (spec->kctls.list) {
2369 struct snd_kcontrol_new *kctl = spec->kctls.list;
2371 for (i = 0; i < spec->kctls.used; i++)
2372 kfree(kctl[i].name);
2374 snd_array_free(&spec->kctls);
2377 static void alc_free_bind_ctls(struct hda_codec *codec)
2379 struct alc_spec *spec = codec->spec;
2380 if (spec->bind_ctls.list) {
2381 struct hda_bind_ctls **ctl = spec->bind_ctls.list;
2383 for (i = 0; i < spec->bind_ctls.used; i++)
2386 snd_array_free(&spec->bind_ctls);
2389 static void alc_free(struct hda_codec *codec)
2391 struct alc_spec *spec = codec->spec;
2397 snd_hda_input_jack_free(codec);
2398 alc_free_kctls(codec);
2399 alc_free_bind_ctls(codec);
2401 snd_hda_detach_beep_device(codec);
2404 #ifdef CONFIG_SND_HDA_POWER_SAVE
2405 static void alc_power_eapd(struct hda_codec *codec)
2407 alc_auto_setup_eapd(codec, false);
2410 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
2412 struct alc_spec *spec = codec->spec;
2414 if (spec && spec->power_hook)
2415 spec->power_hook(codec);
2421 static int alc_resume(struct hda_codec *codec)
2423 msleep(150); /* to avoid pop noise */
2424 codec->patch_ops.init(codec);
2425 snd_hda_codec_resume_amp(codec);
2426 snd_hda_codec_resume_cache(codec);
2427 hda_call_check_power_status(codec, 0x01);
2434 static const struct hda_codec_ops alc_patch_ops = {
2435 .build_controls = alc_build_controls,
2436 .build_pcms = alc_build_pcms,
2439 .unsol_event = alc_unsol_event,
2441 .resume = alc_resume,
2443 #ifdef CONFIG_SND_HDA_POWER_SAVE
2444 .suspend = alc_suspend,
2445 .check_power_status = alc_check_power_status,
2447 .reboot_notify = alc_shutup,
2450 /* replace the codec chip_name with the given string */
2451 static int alc_codec_rename(struct hda_codec *codec, const char *name)
2453 kfree(codec->chip_name);
2454 codec->chip_name = kstrdup(name, GFP_KERNEL);
2455 if (!codec->chip_name) {
2463 * Automatic parse of I/O pins from the BIOS configuration
2468 ALC_CTL_WIDGET_MUTE,
2473 static const struct snd_kcontrol_new alc_control_templates[] = {
2474 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2475 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2476 HDA_BIND_MUTE(NULL, 0, 0, 0),
2477 HDA_BIND_VOL(NULL, 0),
2478 HDA_BIND_SW(NULL, 0),
2481 /* add dynamic controls */
2482 static int add_control(struct alc_spec *spec, int type, const char *name,
2483 int cidx, unsigned long val)
2485 struct snd_kcontrol_new *knew;
2487 knew = alc_kcontrol_new(spec);
2490 *knew = alc_control_templates[type];
2491 knew->name = kstrdup(name, GFP_KERNEL);
2495 if (get_amp_nid_(val))
2496 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2497 knew->private_value = val;
2501 static int add_control_with_pfx(struct alc_spec *spec, int type,
2502 const char *pfx, const char *dir,
2503 const char *sfx, int cidx, unsigned long val)
2506 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
2507 return add_control(spec, type, name, cidx, val);
2510 #define add_pb_vol_ctrl(spec, type, pfx, val) \
2511 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
2512 #define add_pb_sw_ctrl(spec, type, pfx, val) \
2513 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
2514 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
2515 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
2516 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
2517 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
2519 static const char * const channel_name[4] = {
2520 "Front", "Surround", "CLFE", "Side"
2523 static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch,
2524 bool can_be_master, int *index)
2526 struct auto_pin_cfg *cfg = &spec->autocfg;
2529 if (cfg->line_outs == 1 && !spec->multi_ios &&
2530 !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
2533 switch (cfg->line_out_type) {
2534 case AUTO_PIN_SPEAKER_OUT:
2535 if (cfg->line_outs == 1)
2538 case AUTO_PIN_HP_OUT:
2539 /* for multi-io case, only the primary out */
2540 if (ch && spec->multi_ios)
2545 if (cfg->line_outs == 1 && !spec->multi_ios)
2549 if (snd_BUG_ON(ch >= ARRAY_SIZE(channel_name)))
2552 return channel_name[ch];
2555 /* create input playback/capture controls for the given pin */
2556 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
2557 const char *ctlname, int ctlidx,
2558 int idx, hda_nid_t mix_nid)
2562 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
2563 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2566 err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
2567 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2573 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2575 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2576 return (pincap & AC_PINCAP_IN) != 0;
2579 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
2580 static int alc_auto_fill_adc_caps(struct hda_codec *codec)
2582 struct alc_spec *spec = codec->spec;
2584 hda_nid_t *adc_nids = spec->private_adc_nids;
2585 hda_nid_t *cap_nids = spec->private_capsrc_nids;
2586 int max_nums = ARRAY_SIZE(spec->private_adc_nids);
2587 bool indep_capsrc = false;
2590 nid = codec->start_nid;
2591 for (i = 0; i < codec->num_nodes; i++, nid++) {
2593 const hda_nid_t *list;
2594 unsigned int caps = get_wcaps(codec, nid);
2595 int type = get_wcaps_type(caps);
2597 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2599 adc_nids[nums] = nid;
2600 cap_nids[nums] = nid;
2604 type = get_wcaps_type(get_wcaps(codec, src));
2605 if (type == AC_WID_PIN)
2607 if (type == AC_WID_AUD_SEL) {
2608 cap_nids[nums] = src;
2609 indep_capsrc = true;
2612 n = snd_hda_get_conn_list(codec, src, &list);
2614 cap_nids[nums] = src;
2615 indep_capsrc = true;
2621 if (++nums >= max_nums)
2624 spec->adc_nids = spec->private_adc_nids;
2625 spec->capsrc_nids = spec->private_capsrc_nids;
2626 spec->num_adc_nids = nums;
2630 /* create playback/capture controls for input pins */
2631 static int alc_auto_create_input_ctls(struct hda_codec *codec)
2633 struct alc_spec *spec = codec->spec;
2634 const struct auto_pin_cfg *cfg = &spec->autocfg;
2635 hda_nid_t mixer = spec->mixer_nid;
2636 struct hda_input_mux *imux = &spec->private_imux[0];
2638 int i, c, err, idx, type_idx = 0;
2639 const char *prev_label = NULL;
2641 num_adcs = alc_auto_fill_adc_caps(codec);
2645 for (i = 0; i < cfg->num_inputs; i++) {
2649 pin = cfg->inputs[i].pin;
2650 if (!alc_is_input_pin(codec, pin))
2653 label = hda_get_autocfg_input_label(codec, cfg, i);
2654 if (prev_label && !strcmp(label, prev_label))
2661 idx = get_connection_index(codec, mixer, pin);
2663 err = new_analog_input(spec, pin,
2671 for (c = 0; c < num_adcs; c++) {
2672 hda_nid_t cap = spec->capsrc_nids ?
2673 spec->capsrc_nids[c] : spec->adc_nids[c];
2674 idx = get_connection_index(codec, cap, pin);
2676 spec->imux_pins[imux->num_items] = pin;
2677 snd_hda_add_imux_item(imux, label, idx, NULL);
2683 spec->num_mux_defs = 1;
2684 spec->input_mux = imux;
2689 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
2690 unsigned int pin_type)
2692 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2695 if (nid_has_mute(codec, nid, HDA_OUTPUT))
2696 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2700 static int get_pin_type(int line_out_type)
2702 if (line_out_type == AUTO_PIN_HP_OUT)
2708 static void alc_auto_init_analog_input(struct hda_codec *codec)
2710 struct alc_spec *spec = codec->spec;
2711 struct auto_pin_cfg *cfg = &spec->autocfg;
2714 for (i = 0; i < cfg->num_inputs; i++) {
2715 hda_nid_t nid = cfg->inputs[i].pin;
2716 if (alc_is_input_pin(codec, nid)) {
2717 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
2718 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
2719 snd_hda_codec_write(codec, nid, 0,
2720 AC_VERB_SET_AMP_GAIN_MUTE,
2725 /* mute all loopback inputs */
2726 if (spec->mixer_nid) {
2727 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL);
2728 for (i = 0; i < nums; i++)
2729 snd_hda_codec_write(codec, spec->mixer_nid, 0,
2730 AC_VERB_SET_AMP_GAIN_MUTE,
2735 /* convert from MIX nid to DAC */
2736 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
2741 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT)
2743 num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
2744 for (i = 0; i < num; i++) {
2745 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
2751 /* go down to the selector widget before the mixer */
2752 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
2755 int num = snd_hda_get_connections(codec, pin, srcs,
2758 get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
2763 /* get MIX nid connected to the given pin targeted to DAC */
2764 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
2770 pin = alc_go_down_to_selector(codec, pin);
2771 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2772 for (i = 0; i < num; i++) {
2773 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
2779 /* select the connection from pin to DAC if needed */
2780 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
2786 pin = alc_go_down_to_selector(codec, pin);
2787 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2790 for (i = 0; i < num; i++) {
2791 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
2792 snd_hda_codec_update_cache(codec, pin, 0,
2793 AC_VERB_SET_CONNECT_SEL, i);
2800 /* look for an empty DAC slot */
2801 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
2803 struct alc_spec *spec = codec->spec;
2807 pin = alc_go_down_to_selector(codec, pin);
2808 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2809 for (i = 0; i < num; i++) {
2810 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2813 if (found_in_nid_list(nid, spec->multiout.dac_nids,
2814 spec->multiout.num_dacs))
2816 if (spec->multiout.hp_nid == nid)
2818 if (found_in_nid_list(nid, spec->multiout.extra_out_nid,
2819 ARRAY_SIZE(spec->multiout.extra_out_nid)))
2826 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
2828 hda_nid_t sel = alc_go_down_to_selector(codec, pin);
2829 if (snd_hda_get_conn_list(codec, sel, NULL) == 1)
2830 return alc_auto_look_for_dac(codec, pin);
2834 /* fill in the dac_nids table from the parsed pin configuration */
2835 static int alc_auto_fill_dac_nids(struct hda_codec *codec)
2837 struct alc_spec *spec = codec->spec;
2838 const struct auto_pin_cfg *cfg = &spec->autocfg;
2839 bool redone = false;
2843 /* set num_dacs once to full for alc_auto_look_for_dac() */
2844 spec->multiout.num_dacs = cfg->line_outs;
2845 spec->multiout.hp_nid = 0;
2846 spec->multiout.extra_out_nid[0] = 0;
2847 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
2848 spec->multiout.dac_nids = spec->private_dac_nids;
2850 /* fill hard-wired DACs first */
2852 for (i = 0; i < cfg->line_outs; i++)
2853 spec->private_dac_nids[i] =
2854 get_dac_if_single(codec, cfg->line_out_pins[i]);
2856 spec->multiout.hp_nid =
2857 get_dac_if_single(codec, cfg->hp_pins[0]);
2858 if (cfg->speaker_outs)
2859 spec->multiout.extra_out_nid[0] =
2860 get_dac_if_single(codec, cfg->speaker_pins[0]);
2863 for (i = 0; i < cfg->line_outs; i++) {
2864 hda_nid_t pin = cfg->line_out_pins[i];
2865 if (spec->private_dac_nids[i])
2867 spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin);
2868 if (!spec->private_dac_nids[i] && !redone) {
2869 /* if we can't find primary DACs, re-probe without
2870 * checking the hard-wired DACs
2877 /* re-count num_dacs and squash invalid entries */
2878 spec->multiout.num_dacs = 0;
2879 for (i = 0; i < cfg->line_outs; i++) {
2880 if (spec->private_dac_nids[i])
2881 spec->multiout.num_dacs++;
2883 memmove(spec->private_dac_nids + i,
2884 spec->private_dac_nids + i + 1,
2885 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
2888 if (cfg->hp_outs && !spec->multiout.hp_nid)
2889 spec->multiout.hp_nid =
2890 alc_auto_look_for_dac(codec, cfg->hp_pins[0]);
2891 if (cfg->speaker_outs && !spec->multiout.extra_out_nid[0])
2892 spec->multiout.extra_out_nid[0] =
2893 alc_auto_look_for_dac(codec, cfg->speaker_pins[0]);
2898 /* fill in the dac_nids table for surround speakers, etc */
2899 static int alc_auto_fill_extra_dacs(struct hda_codec *codec)
2901 struct alc_spec *spec = codec->spec;
2902 const struct auto_pin_cfg *cfg = &spec->autocfg;
2905 if (cfg->speaker_outs < 2 || !spec->multiout.extra_out_nid[0])
2908 for (i = 1; i < cfg->speaker_outs; i++)
2909 spec->multiout.extra_out_nid[i] =
2910 get_dac_if_single(codec, cfg->speaker_pins[i]);
2911 for (i = 1; i < cfg->speaker_outs; i++) {
2912 if (spec->multiout.extra_out_nid[i])
2914 spec->multiout.extra_out_nid[i] =
2915 alc_auto_look_for_dac(codec, cfg->speaker_pins[0]);
2920 static int alc_auto_add_vol_ctl(struct hda_codec *codec,
2921 const char *pfx, int cidx,
2922 hda_nid_t nid, unsigned int chs)
2926 return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx,
2927 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2930 #define alc_auto_add_stereo_vol(codec, pfx, cidx, nid) \
2931 alc_auto_add_vol_ctl(codec, pfx, cidx, nid, 3)
2933 /* create a mute-switch for the given mixer widget;
2934 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
2936 static int alc_auto_add_sw_ctl(struct hda_codec *codec,
2937 const char *pfx, int cidx,
2938 hda_nid_t nid, unsigned int chs)
2945 wid_type = get_wcaps_type(get_wcaps(codec, nid));
2946 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) {
2947 type = ALC_CTL_WIDGET_MUTE;
2948 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
2949 } else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) {
2950 type = ALC_CTL_WIDGET_MUTE;
2951 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT);
2953 type = ALC_CTL_BIND_MUTE;
2954 val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT);
2956 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
2959 #define alc_auto_add_stereo_sw(codec, pfx, cidx, nid) \
2960 alc_auto_add_sw_ctl(codec, pfx, cidx, nid, 3)
2962 static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec,
2963 hda_nid_t pin, hda_nid_t dac)
2965 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
2966 if (nid_has_mute(codec, pin, HDA_OUTPUT))
2968 else if (mix && nid_has_mute(codec, mix, HDA_INPUT))
2970 else if (nid_has_mute(codec, dac, HDA_OUTPUT))
2975 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
2976 hda_nid_t pin, hda_nid_t dac)
2978 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
2979 if (nid_has_volume(codec, dac, HDA_OUTPUT))
2981 else if (nid_has_volume(codec, mix, HDA_OUTPUT))
2983 else if (nid_has_volume(codec, pin, HDA_OUTPUT))
2988 /* add playback controls from the parsed DAC table */
2989 static int alc_auto_create_multi_out_ctls(struct hda_codec *codec,
2990 const struct auto_pin_cfg *cfg)
2992 struct alc_spec *spec = codec->spec;
2993 int i, err, noutputs;
2995 noutputs = cfg->line_outs;
2996 if (spec->multi_ios > 0)
2997 noutputs += spec->multi_ios;
2999 for (i = 0; i < noutputs; i++) {
3005 dac = spec->multiout.dac_nids[i];
3008 if (i >= cfg->line_outs)
3009 pin = spec->multi_io[i - 1].pin;
3011 pin = cfg->line_out_pins[i];
3013 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3014 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3015 name = alc_get_line_out_pfx(spec, i, true, &index);
3018 err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1);
3021 err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2);
3024 err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1);
3027 err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2);
3031 err = alc_auto_add_stereo_vol(codec, name, index, vol);
3034 err = alc_auto_add_stereo_sw(codec, name, index, sw);
3042 static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
3043 hda_nid_t dac, const char *pfx)
3045 struct alc_spec *spec = codec->spec;
3050 /* the corresponding DAC is already occupied */
3051 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
3052 return 0; /* no way */
3053 /* create a switch only */
3054 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
3055 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3058 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3059 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3060 err = alc_auto_add_stereo_vol(codec, pfx, 0, vol);
3063 err = alc_auto_add_stereo_sw(codec, pfx, 0, sw);
3069 static struct hda_bind_ctls *new_bind_ctl(struct hda_codec *codec,
3071 struct hda_ctl_ops *ops)
3073 struct alc_spec *spec = codec->spec;
3074 struct hda_bind_ctls **ctlp, *ctl;
3075 snd_array_init(&spec->bind_ctls, sizeof(ctl), 8);
3076 ctlp = snd_array_new(&spec->bind_ctls);
3079 ctl = kzalloc(sizeof(*ctl) + sizeof(long) * (nums + 1), GFP_KERNEL);
3086 /* add playback controls for speaker and HP outputs */
3087 static int alc_auto_create_extra_outs(struct hda_codec *codec, int num_pins,
3088 const hda_nid_t *pins,
3089 const hda_nid_t *dacs,
3092 struct alc_spec *spec = codec->spec;
3093 struct hda_bind_ctls *ctl;
3097 if (!num_pins || !pins[0])
3101 return alc_auto_create_extra_out(codec, *pins, *dacs, pfx);
3103 if (dacs[num_pins - 1]) {
3104 /* OK, we have a multi-output system with individual volumes */
3105 for (i = 0; i < num_pins; i++) {
3106 snprintf(name, sizeof(name), "%s %s",
3107 pfx, channel_name[i]);
3108 err = alc_auto_create_extra_out(codec, pins[i], dacs[i],
3116 /* Let's create a bind-controls */
3117 ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_sw);
3121 for (i = 0; i < num_pins; i++) {
3122 if (get_wcaps(codec, pins[i]) & AC_WCAP_OUT_AMP)
3124 HDA_COMPOSE_AMP_VAL(pins[i], 3, 0, HDA_OUTPUT);
3127 snprintf(name, sizeof(name), "%s Playback Switch", pfx);
3128 err = add_control(spec, ALC_CTL_BIND_SW, name, 0, (long)ctl);
3133 ctl = new_bind_ctl(codec, num_pins, &snd_hda_bind_vol);
3137 for (i = 0; i < num_pins; i++) {
3139 if (!pins[i] || !dacs[i])
3141 vol = alc_look_for_out_vol_nid(codec, pins[i], dacs[i]);
3144 HDA_COMPOSE_AMP_VAL(vol, 3, 0, HDA_OUTPUT);
3147 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
3148 err = add_control(spec, ALC_CTL_BIND_VOL, name, 0, (long)ctl);
3155 static int alc_auto_create_hp_out(struct hda_codec *codec)
3157 struct alc_spec *spec = codec->spec;
3158 return alc_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
3159 spec->multiout.hp_nid,
3163 static int alc_auto_create_speaker_out(struct hda_codec *codec)
3165 struct alc_spec *spec = codec->spec;
3166 return alc_auto_create_extra_outs(codec, spec->autocfg.speaker_outs,
3167 spec->autocfg.speaker_pins,
3168 spec->multiout.extra_out_nid,
3172 static void alc_auto_set_output_and_unmute(struct hda_codec *codec,
3173 hda_nid_t pin, int pin_type,
3177 hda_nid_t nid, mix = 0;
3178 hda_nid_t srcs[HDA_MAX_CONNECTIONS];
3180 alc_set_pin_output(codec, pin, pin_type);
3181 nid = alc_go_down_to_selector(codec, pin);
3182 num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
3183 for (i = 0; i < num; i++) {
3184 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
3192 /* need the manual connection? */
3194 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
3195 /* unmute mixer widget inputs */
3196 if (nid_has_mute(codec, mix, HDA_INPUT)) {
3197 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3199 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3202 /* initialize volume */
3203 nid = alc_look_for_out_vol_nid(codec, pin, dac);
3205 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3209 static void alc_auto_init_multi_out(struct hda_codec *codec)
3211 struct alc_spec *spec = codec->spec;
3212 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3215 for (i = 0; i <= HDA_SIDE; i++) {
3216 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3218 alc_auto_set_output_and_unmute(codec, nid, pin_type,
3219 spec->multiout.dac_nids[i]);
3223 static void alc_auto_init_extra_out(struct hda_codec *codec)
3225 struct alc_spec *spec = codec->spec;
3229 pin = spec->autocfg.hp_pins[0];
3231 dac = spec->multiout.hp_nid;
3233 dac = spec->multiout.dac_nids[0];
3234 alc_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
3236 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3237 pin = spec->autocfg.speaker_pins[i];
3240 dac = spec->multiout.extra_out_nid[i];
3242 if (i > 0 && spec->multiout.extra_out_nid[0])
3243 dac = spec->multiout.extra_out_nid[0];
3245 dac = spec->multiout.dac_nids[0];
3247 alc_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
3254 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
3255 unsigned int location)
3257 struct alc_spec *spec = codec->spec;
3258 struct auto_pin_cfg *cfg = &spec->autocfg;
3259 int type, i, num_pins = 0;
3261 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
3262 for (i = 0; i < cfg->num_inputs; i++) {
3263 hda_nid_t nid = cfg->inputs[i].pin;
3265 unsigned int defcfg, caps;
3266 if (cfg->inputs[i].type != type)
3268 defcfg = snd_hda_codec_get_pincfg(codec, nid);
3269 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
3271 if (location && get_defcfg_location(defcfg) != location)
3273 caps = snd_hda_query_pin_caps(codec, nid);
3274 if (!(caps & AC_PINCAP_OUT))
3276 dac = alc_auto_look_for_dac(codec, nid);
3279 spec->multi_io[num_pins].pin = nid;
3280 spec->multi_io[num_pins].dac = dac;
3282 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
3285 spec->multiout.num_dacs = 1;
3291 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
3292 struct snd_ctl_elem_info *uinfo)
3294 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3295 struct alc_spec *spec = codec->spec;
3297 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3299 uinfo->value.enumerated.items = spec->multi_ios + 1;
3300 if (uinfo->value.enumerated.item > spec->multi_ios)
3301 uinfo->value.enumerated.item = spec->multi_ios;
3302 sprintf(uinfo->value.enumerated.name, "%dch",
3303 (uinfo->value.enumerated.item + 1) * 2);
3307 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
3308 struct snd_ctl_elem_value *ucontrol)
3310 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3311 struct alc_spec *spec = codec->spec;
3312 ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
3316 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
3318 struct alc_spec *spec = codec->spec;
3319 hda_nid_t nid = spec->multi_io[idx].pin;
3321 if (!spec->multi_io[idx].ctl_in)
3322 spec->multi_io[idx].ctl_in =
3323 snd_hda_codec_read(codec, nid, 0,
3324 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3326 snd_hda_codec_update_cache(codec, nid, 0,
3327 AC_VERB_SET_PIN_WIDGET_CONTROL,
3329 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3330 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3332 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
3334 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3335 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3336 HDA_AMP_MUTE, HDA_AMP_MUTE);
3337 snd_hda_codec_update_cache(codec, nid, 0,
3338 AC_VERB_SET_PIN_WIDGET_CONTROL,
3339 spec->multi_io[idx].ctl_in);
3344 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
3345 struct snd_ctl_elem_value *ucontrol)
3347 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3348 struct alc_spec *spec = codec->spec;
3351 ch = ucontrol->value.enumerated.item[0];
3352 if (ch < 0 || ch > spec->multi_ios)
3354 if (ch == (spec->ext_channel_count - 1) / 2)
3356 spec->ext_channel_count = (ch + 1) * 2;
3357 for (i = 0; i < spec->multi_ios; i++)
3358 alc_set_multi_io(codec, i, i < ch);
3359 spec->multiout.max_channels = spec->ext_channel_count;
3360 if (spec->need_dac_fix && !spec->const_channel_count)
3361 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
3365 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
3366 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3367 .name = "Channel Mode",
3368 .info = alc_auto_ch_mode_info,
3369 .get = alc_auto_ch_mode_get,
3370 .put = alc_auto_ch_mode_put,
3373 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec)
3375 struct alc_spec *spec = codec->spec;
3376 struct auto_pin_cfg *cfg = &spec->autocfg;
3377 unsigned int location, defcfg;
3380 if (cfg->line_outs != 1 ||
3381 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
3384 defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
3385 location = get_defcfg_location(defcfg);
3387 num_pins = alc_auto_fill_multi_ios(codec, location);
3389 struct snd_kcontrol_new *knew;
3391 knew = alc_kcontrol_new(spec);
3394 *knew = alc_auto_channel_mode_enum;
3395 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
3399 spec->multi_ios = num_pins;
3400 spec->ext_channel_count = 2;
3401 spec->multiout.num_dacs = num_pins + 1;
3406 /* filter out invalid adc_nids (and capsrc_nids) that don't give all
3409 static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
3411 struct alc_spec *spec = codec->spec;
3412 const struct hda_input_mux *imux;
3413 hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3414 hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3417 imux = spec->input_mux;
3420 if (spec->dyn_adc_switch)
3424 for (n = 0; n < spec->num_adc_nids; n++) {
3425 hda_nid_t cap = spec->private_capsrc_nids[n];
3426 int num_conns = snd_hda_get_conn_list(codec, cap, NULL);
3427 for (i = 0; i < imux->num_items; i++) {
3428 hda_nid_t pin = spec->imux_pins[i];
3430 if (get_connection_index(codec, cap, pin) < 0)
3432 } else if (num_conns <= imux->items[i].index)
3435 if (i >= imux->num_items) {
3436 adc_nids[nums] = spec->private_adc_nids[n];
3437 capsrc_nids[nums++] = cap;
3441 /* check whether ADC-switch is possible */
3442 if (!alc_check_dyn_adc_switch(codec)) {
3443 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
3444 " using fallback 0x%x\n",
3445 codec->chip_name, spec->private_adc_nids[0]);
3446 spec->num_adc_nids = 1;
3450 } else if (nums != spec->num_adc_nids) {
3451 memcpy(spec->private_adc_nids, adc_nids,
3452 nums * sizeof(hda_nid_t));
3453 memcpy(spec->private_capsrc_nids, capsrc_nids,
3454 nums * sizeof(hda_nid_t));
3455 spec->num_adc_nids = nums;
3459 alc_auto_mic_check_imux(codec); /* check auto-mic setups */
3460 else if (spec->input_mux->num_items == 1)
3461 spec->num_adc_nids = 1; /* reduce to a single ADC */
3465 * initialize ADC paths
3467 static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx)
3469 struct alc_spec *spec = codec->spec;
3472 nid = spec->adc_nids[adc_idx];
3474 if (nid_has_mute(codec, nid, HDA_INPUT)) {
3475 snd_hda_codec_write(codec, nid, 0,
3476 AC_VERB_SET_AMP_GAIN_MUTE,
3480 if (!spec->capsrc_nids)
3482 nid = spec->capsrc_nids[adc_idx];
3483 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3484 snd_hda_codec_write(codec, nid, 0,
3485 AC_VERB_SET_AMP_GAIN_MUTE,
3489 static void alc_auto_init_input_src(struct hda_codec *codec)
3491 struct alc_spec *spec = codec->spec;
3494 for (c = 0; c < spec->num_adc_nids; c++)
3495 alc_auto_init_adc(codec, c);
3496 if (spec->dyn_adc_switch)
3499 nums = spec->num_adc_nids;
3500 for (c = 0; c < nums; c++)
3501 alc_mux_select(codec, 0, spec->cur_mux[c], true);
3504 /* add mic boosts if needed */
3505 static int alc_auto_add_mic_boost(struct hda_codec *codec)
3507 struct alc_spec *spec = codec->spec;
3508 struct auto_pin_cfg *cfg = &spec->autocfg;
3512 const char *prev_label = NULL;
3514 for (i = 0; i < cfg->num_inputs; i++) {
3515 if (cfg->inputs[i].type > AUTO_PIN_MIC)
3517 nid = cfg->inputs[i].pin;
3518 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
3520 char boost_label[32];
3522 label = hda_get_autocfg_input_label(codec, cfg, i);
3523 if (prev_label && !strcmp(label, prev_label))
3529 snprintf(boost_label, sizeof(boost_label),
3530 "%s Boost Volume", label);
3531 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3532 boost_label, type_idx,
3533 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
3541 /* select or unmute the given capsrc route */
3542 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
3545 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
3546 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
3548 } else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) {
3549 snd_hda_codec_write_cache(codec, cap, 0,
3550 AC_VERB_SET_CONNECT_SEL, idx);
3554 /* set the default connection to that pin */
3555 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
3557 struct alc_spec *spec = codec->spec;
3562 for (i = 0; i < spec->num_adc_nids; i++) {
3563 hda_nid_t cap = spec->capsrc_nids ?
3564 spec->capsrc_nids[i] : spec->adc_nids[i];
3567 idx = get_connection_index(codec, cap, pin);
3570 select_or_unmute_capsrc(codec, cap, idx);
3571 return i; /* return the found index */
3573 return -1; /* not found */
3576 /* initialize some special cases for input sources */
3577 static void alc_init_special_input_src(struct hda_codec *codec)
3579 struct alc_spec *spec = codec->spec;
3582 for (i = 0; i < spec->autocfg.num_inputs; i++)
3583 init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin);
3586 /* assign appropriate capture mixers */
3587 static void set_capture_mixer(struct hda_codec *codec)
3589 struct alc_spec *spec = codec->spec;
3590 static const struct snd_kcontrol_new *caps[2][3] = {
3591 { alc_capture_mixer_nosrc1,
3592 alc_capture_mixer_nosrc2,
3593 alc_capture_mixer_nosrc3 },
3594 { alc_capture_mixer1,
3596 alc_capture_mixer3 },
3599 /* check whether either of ADC or MUX has a volume control */
3600 if (!nid_has_volume(codec, spec->adc_nids[0], HDA_INPUT)) {
3601 if (!spec->capsrc_nids)
3602 return; /* no volume */
3603 if (!nid_has_volume(codec, spec->capsrc_nids[0], HDA_OUTPUT))
3604 return; /* no volume in capsrc, too */
3605 spec->vol_in_capsrc = 1;
3608 if (spec->num_adc_nids > 0) {
3612 if (spec->input_mux && spec->input_mux->num_items > 1)
3614 if (spec->auto_mic) {
3617 } else if (spec->dyn_adc_switch)
3620 if (spec->num_adc_nids > 3)
3621 spec->num_adc_nids = 3;
3622 else if (!spec->num_adc_nids)
3624 num_adcs = spec->num_adc_nids;
3626 spec->cap_mixer = caps[mux][num_adcs - 1];
3631 * standard auto-parser initializations
3633 static void alc_auto_init_std(struct hda_codec *codec)
3635 struct alc_spec *spec = codec->spec;
3636 alc_auto_init_multi_out(codec);
3637 alc_auto_init_extra_out(codec);
3638 alc_auto_init_analog_input(codec);
3639 alc_auto_init_input_src(codec);
3640 alc_auto_init_digital(codec);
3641 if (spec->unsol_event)
3642 alc_inithook(codec);
3646 * Digital-beep handlers
3648 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3649 #define set_beep_amp(spec, nid, idx, dir) \
3650 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
3652 static const struct snd_pci_quirk beep_white_list[] = {
3653 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
3654 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
3655 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
3656 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
3657 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
3661 static inline int has_cdefine_beep(struct hda_codec *codec)
3663 struct alc_spec *spec = codec->spec;
3664 const struct snd_pci_quirk *q;
3665 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
3668 return spec->cdefine.enable_pcbeep;
3671 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
3672 #define has_cdefine_beep(codec) 0
3675 /* parse the BIOS configuration and set up the alc_spec */
3676 /* return 1 if successful, 0 if the proper config is not found,
3677 * or a negative error code
3679 static int alc_parse_auto_config(struct hda_codec *codec,
3680 const hda_nid_t *ignore_nids,
3681 const hda_nid_t *ssid_nids)
3683 struct alc_spec *spec = codec->spec;
3684 struct auto_pin_cfg *cfg = &spec->autocfg;
3687 err = snd_hda_parse_pin_def_config(codec, cfg, ignore_nids);
3690 if (!cfg->line_outs) {
3691 if (cfg->dig_outs || cfg->dig_in_pin) {
3692 spec->multiout.max_channels = 2;
3693 spec->no_analog = 1;
3696 return 0; /* can't find valid BIOS pin config */
3699 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT && cfg->hp_outs == 1) {
3700 /* use HP as primary out */
3701 cfg->speaker_outs = cfg->line_outs;
3702 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3703 sizeof(cfg->speaker_pins));
3704 cfg->line_outs = cfg->hp_outs;
3705 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
3707 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3708 cfg->line_out_type = AUTO_PIN_HP_OUT;
3711 err = alc_auto_fill_dac_nids(codec);
3714 err = alc_auto_add_multi_channel_mode(codec);
3717 err = alc_auto_fill_extra_dacs(codec);
3720 err = alc_auto_create_multi_out_ctls(codec, cfg);
3723 err = alc_auto_create_hp_out(codec);
3726 err = alc_auto_create_speaker_out(codec);
3729 err = alc_auto_create_input_ctls(codec);
3733 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3736 alc_auto_parse_digital(codec);
3738 if (!spec->no_analog)
3739 alc_remove_invalid_adc_nids(codec);
3742 alc_ssid_check(codec, ssid_nids);
3744 if (!spec->no_analog) {
3745 alc_auto_check_switches(codec);
3746 err = alc_auto_add_mic_boost(codec);
3751 if (spec->kctls.list)
3752 add_mixer(spec, spec->kctls.list);
3757 static int alc880_parse_auto_config(struct hda_codec *codec)
3759 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3760 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3761 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
3764 #ifdef CONFIG_SND_HDA_POWER_SAVE
3765 static const struct hda_amp_list alc880_loopbacks[] = {
3766 { 0x0b, HDA_INPUT, 0 },
3767 { 0x0b, HDA_INPUT, 1 },
3768 { 0x0b, HDA_INPUT, 2 },
3769 { 0x0b, HDA_INPUT, 3 },
3770 { 0x0b, HDA_INPUT, 4 },
3778 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3779 #define alc_board_config \
3780 snd_hda_check_board_config
3781 #define alc_board_codec_sid_config \
3782 snd_hda_check_board_codec_sid_config
3783 #include "alc_quirks.c"
3785 #define alc_board_config(codec, nums, models, tbl) -1
3786 #define alc_board_codec_sid_config(codec, nums, models, tbl) -1
3787 #define setup_preset(codec, x) /* NOP */
3791 * OK, here we have finally the patch for ALC880
3793 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3794 #include "alc880_quirks.c"
3797 static int patch_alc880(struct hda_codec *codec)
3799 struct alc_spec *spec;
3803 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3809 spec->mixer_nid = 0x0b;
3810 spec->need_dac_fix = 1;
3812 board_config = alc_board_config(codec, ALC880_MODEL_LAST,
3813 alc880_models, alc880_cfg_tbl);
3814 if (board_config < 0) {
3815 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3817 board_config = ALC_MODEL_AUTO;
3820 if (board_config == ALC_MODEL_AUTO) {
3821 /* automatic parse from the BIOS config */
3822 err = alc880_parse_auto_config(codec);
3827 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3830 "hda_codec: Cannot set up configuration "
3831 "from BIOS. Using 3-stack mode...\n");
3832 board_config = ALC880_3ST;
3837 if (board_config != ALC_MODEL_AUTO)
3838 setup_preset(codec, &alc880_presets[board_config]);
3840 if (!spec->no_analog && !spec->adc_nids) {
3841 alc_auto_fill_adc_caps(codec);
3842 alc_rebuild_imux_for_auto_mic(codec);
3843 alc_remove_invalid_adc_nids(codec);
3846 if (!spec->no_analog && !spec->cap_mixer)
3847 set_capture_mixer(codec);
3849 if (!spec->no_analog) {
3850 err = snd_hda_attach_beep_device(codec, 0x1);
3855 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
3858 spec->vmaster_nid = 0x0c;
3860 codec->patch_ops = alc_patch_ops;
3861 if (board_config == ALC_MODEL_AUTO)
3862 spec->init_hook = alc_auto_init_std;
3863 #ifdef CONFIG_SND_HDA_POWER_SAVE
3864 if (!spec->loopback.amplist)
3865 spec->loopback.amplist = alc880_loopbacks;
3875 static int alc260_parse_auto_config(struct hda_codec *codec)
3877 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
3878 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
3879 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
3882 #ifdef CONFIG_SND_HDA_POWER_SAVE
3883 static const struct hda_amp_list alc260_loopbacks[] = {
3884 { 0x07, HDA_INPUT, 0 },
3885 { 0x07, HDA_INPUT, 1 },
3886 { 0x07, HDA_INPUT, 2 },
3887 { 0x07, HDA_INPUT, 3 },
3888 { 0x07, HDA_INPUT, 4 },
3900 static const struct alc_fixup alc260_fixups[] = {
3901 [PINFIX_HP_DC5750] = {
3902 .type = ALC_FIXUP_PINS,
3903 .v.pins = (const struct alc_pincfg[]) {
3904 { 0x11, 0x90130110 }, /* speaker */
3910 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
3911 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
3917 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3918 #include "alc260_quirks.c"
3921 static int patch_alc260(struct hda_codec *codec)
3923 struct alc_spec *spec;
3924 int err, board_config;
3926 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3932 spec->mixer_nid = 0x07;
3934 board_config = alc_board_config(codec, ALC260_MODEL_LAST,
3935 alc260_models, alc260_cfg_tbl);
3936 if (board_config < 0) {
3937 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3939 board_config = ALC_MODEL_AUTO;
3942 if (board_config == ALC_MODEL_AUTO) {
3943 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
3944 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
3947 if (board_config == ALC_MODEL_AUTO) {
3948 /* automatic parse from the BIOS config */
3949 err = alc260_parse_auto_config(codec);
3954 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3957 "hda_codec: Cannot set up configuration "
3958 "from BIOS. Using base mode...\n");
3959 board_config = ALC260_BASIC;
3964 if (board_config != ALC_MODEL_AUTO)
3965 setup_preset(codec, &alc260_presets[board_config]);
3967 if (!spec->no_analog && !spec->adc_nids) {
3968 alc_auto_fill_adc_caps(codec);
3969 alc_rebuild_imux_for_auto_mic(codec);
3970 alc_remove_invalid_adc_nids(codec);
3973 if (!spec->no_analog && !spec->cap_mixer)
3974 set_capture_mixer(codec);
3976 if (!spec->no_analog) {
3977 err = snd_hda_attach_beep_device(codec, 0x1);
3982 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
3985 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
3987 spec->vmaster_nid = 0x08;
3989 codec->patch_ops = alc_patch_ops;
3990 if (board_config == ALC_MODEL_AUTO)
3991 spec->init_hook = alc_auto_init_std;
3992 spec->shutup = alc_eapd_shutup;
3993 #ifdef CONFIG_SND_HDA_POWER_SAVE
3994 if (!spec->loopback.amplist)
3995 spec->loopback.amplist = alc260_loopbacks;
4003 * ALC882/883/885/888/889 support
4005 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
4006 * configuration. Each pin widget can choose any input DACs and a mixer.
4007 * Each ADC is connected from a mixer of all inputs. This makes possible
4008 * 6-channel independent captures.
4010 * In addition, an independent DAC for the multi-playback (not used in this
4013 #ifdef CONFIG_SND_HDA_POWER_SAVE
4014 #define alc882_loopbacks alc880_loopbacks
4021 PINFIX_ABIT_AW9D_MAX,
4024 PINFIX_ACER_ASPIRE_7736,
4027 static const struct alc_fixup alc882_fixups[] = {
4028 [PINFIX_ABIT_AW9D_MAX] = {
4029 .type = ALC_FIXUP_PINS,
4030 .v.pins = (const struct alc_pincfg[]) {
4031 { 0x15, 0x01080104 }, /* side */
4032 { 0x16, 0x01011012 }, /* rear */
4033 { 0x17, 0x01016011 }, /* clfe */
4037 [PINFIX_LENOVO_Y530] = {
4038 .type = ALC_FIXUP_PINS,
4039 .v.pins = (const struct alc_pincfg[]) {
4040 { 0x15, 0x99130112 }, /* rear int speakers */
4041 { 0x16, 0x99130111 }, /* subwoofer */
4045 [PINFIX_PB_M5210] = {
4046 .type = ALC_FIXUP_VERBS,
4047 .v.verbs = (const struct hda_verb[]) {
4048 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
4052 [PINFIX_ACER_ASPIRE_7736] = {
4053 .type = ALC_FIXUP_SKU,
4054 .v.sku = ALC_FIXUP_SKU_IGNORE,
4058 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
4059 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
4060 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530),
4061 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
4062 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
4067 * BIOS auto configuration
4069 /* almost identical with ALC880 parser... */
4070 static int alc882_parse_auto_config(struct hda_codec *codec)
4072 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
4073 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4074 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
4079 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4080 #include "alc882_quirks.c"
4083 static int patch_alc882(struct hda_codec *codec)
4085 struct alc_spec *spec;
4086 int err, board_config;
4088 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4094 spec->mixer_nid = 0x0b;
4096 switch (codec->vendor_id) {
4101 /* ALC883 and variants */
4102 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4106 board_config = alc_board_config(codec, ALC882_MODEL_LAST,
4107 alc882_models, alc882_cfg_tbl);
4109 if (board_config < 0)
4110 board_config = alc_board_codec_sid_config(codec,
4111 ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
4113 if (board_config < 0) {
4114 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4116 board_config = ALC_MODEL_AUTO;
4119 if (board_config == ALC_MODEL_AUTO) {
4120 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
4121 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4124 alc_auto_parse_customize_define(codec);
4126 if (board_config == ALC_MODEL_AUTO) {
4127 /* automatic parse from the BIOS config */
4128 err = alc882_parse_auto_config(codec);
4133 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4136 "hda_codec: Cannot set up configuration "
4137 "from BIOS. Using base mode...\n");
4138 board_config = ALC882_3ST_DIG;
4143 if (board_config != ALC_MODEL_AUTO)
4144 setup_preset(codec, &alc882_presets[board_config]);
4146 if (!spec->no_analog && !spec->adc_nids) {
4147 alc_auto_fill_adc_caps(codec);
4148 alc_rebuild_imux_for_auto_mic(codec);
4149 alc_remove_invalid_adc_nids(codec);
4152 if (!spec->no_analog && !spec->cap_mixer)
4153 set_capture_mixer(codec);
4155 if (!spec->no_analog && has_cdefine_beep(codec)) {
4156 err = snd_hda_attach_beep_device(codec, 0x1);
4161 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4164 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4166 spec->vmaster_nid = 0x0c;
4168 codec->patch_ops = alc_patch_ops;
4169 if (board_config == ALC_MODEL_AUTO)
4170 spec->init_hook = alc_auto_init_std;
4172 alc_init_jacks(codec);
4173 #ifdef CONFIG_SND_HDA_POWER_SAVE
4174 if (!spec->loopback.amplist)
4175 spec->loopback.amplist = alc882_loopbacks;
4185 static int alc262_parse_auto_config(struct hda_codec *codec)
4187 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
4188 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4189 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
4200 static const struct alc_fixup alc262_fixups[] = {
4201 [PINFIX_FSC_H270] = {
4202 .type = ALC_FIXUP_PINS,
4203 .v.pins = (const struct alc_pincfg[]) {
4204 { 0x14, 0x99130110 }, /* speaker */
4205 { 0x15, 0x0221142f }, /* front HP */
4206 { 0x1b, 0x0121141f }, /* rear HP */
4210 [PINFIX_HP_Z200] = {
4211 .type = ALC_FIXUP_PINS,
4212 .v.pins = (const struct alc_pincfg[]) {
4213 { 0x16, 0x99130120 }, /* internal speaker */
4219 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
4220 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", PINFIX_HP_Z200),
4221 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
4226 #ifdef CONFIG_SND_HDA_POWER_SAVE
4227 #define alc262_loopbacks alc880_loopbacks
4232 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4233 #include "alc262_quirks.c"
4236 static int patch_alc262(struct hda_codec *codec)
4238 struct alc_spec *spec;
4242 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4248 spec->mixer_nid = 0x0b;
4251 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
4256 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4257 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4258 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4259 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4262 alc_auto_parse_customize_define(codec);
4264 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4266 board_config = alc_board_config(codec, ALC262_MODEL_LAST,
4267 alc262_models, alc262_cfg_tbl);
4269 if (board_config < 0) {
4270 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4272 board_config = ALC_MODEL_AUTO;
4275 if (board_config == ALC_MODEL_AUTO) {
4276 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
4277 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4280 if (board_config == ALC_MODEL_AUTO) {
4281 /* automatic parse from the BIOS config */
4282 err = alc262_parse_auto_config(codec);
4287 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4290 "hda_codec: Cannot set up configuration "
4291 "from BIOS. Using base mode...\n");
4292 board_config = ALC262_BASIC;
4297 if (board_config != ALC_MODEL_AUTO)
4298 setup_preset(codec, &alc262_presets[board_config]);
4300 if (!spec->no_analog && !spec->adc_nids) {
4301 alc_auto_fill_adc_caps(codec);
4302 alc_rebuild_imux_for_auto_mic(codec);
4303 alc_remove_invalid_adc_nids(codec);
4306 if (!spec->no_analog && !spec->cap_mixer)
4307 set_capture_mixer(codec);
4309 if (!spec->no_analog && has_cdefine_beep(codec)) {
4310 err = snd_hda_attach_beep_device(codec, 0x1);
4315 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4318 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4320 spec->vmaster_nid = 0x0c;
4322 codec->patch_ops = alc_patch_ops;
4323 if (board_config == ALC_MODEL_AUTO)
4324 spec->init_hook = alc_auto_init_std;
4325 spec->shutup = alc_eapd_shutup;
4327 alc_init_jacks(codec);
4328 #ifdef CONFIG_SND_HDA_POWER_SAVE
4329 if (!spec->loopback.amplist)
4330 spec->loopback.amplist = alc262_loopbacks;
4339 /* bind Beep switches of both NID 0x0f and 0x10 */
4340 static const struct hda_bind_ctls alc268_bind_beep_sw = {
4341 .ops = &snd_hda_bind_sw,
4343 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
4344 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
4349 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
4350 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
4351 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
4355 /* set PCBEEP vol = 0, mute connections */
4356 static const struct hda_verb alc268_beep_init_verbs[] = {
4357 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4358 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4359 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4364 * BIOS auto configuration
4366 static int alc268_parse_auto_config(struct hda_codec *codec)
4368 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4369 struct alc_spec *spec = codec->spec;
4370 int err = alc_parse_auto_config(codec, NULL, alc268_ssids);
4372 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) {
4373 add_mixer(spec, alc268_beep_mixer);
4374 add_verb(spec, alc268_beep_init_verbs);
4382 static int patch_alc268(struct hda_codec *codec)
4384 struct alc_spec *spec;
4385 int i, has_beep, err;
4387 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4393 /* ALC268 has no aa-loopback mixer */
4395 /* automatic parse from the BIOS config */
4396 err = alc268_parse_auto_config(codec);
4403 for (i = 0; i < spec->num_mixers; i++) {
4404 if (spec->mixers[i] == alc268_beep_mixer) {
4411 err = snd_hda_attach_beep_device(codec, 0x1);
4416 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
4417 /* override the amp caps for beep generator */
4418 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
4419 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
4420 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
4421 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4422 (0 << AC_AMPCAP_MUTE_SHIFT));
4425 if (!spec->no_analog && !spec->adc_nids) {
4426 alc_auto_fill_adc_caps(codec);
4427 alc_rebuild_imux_for_auto_mic(codec);
4428 alc_remove_invalid_adc_nids(codec);
4431 if (!spec->no_analog && !spec->cap_mixer)
4432 set_capture_mixer(codec);
4434 spec->vmaster_nid = 0x02;
4436 codec->patch_ops = alc_patch_ops;
4437 spec->init_hook = alc_auto_init_std;
4438 spec->shutup = alc_eapd_shutup;
4440 alc_init_jacks(codec);
4448 #ifdef CONFIG_SND_HDA_POWER_SAVE
4449 #define alc269_loopbacks alc880_loopbacks
4452 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
4456 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4457 /* NID is set in alc_build_pcms */
4459 .open = alc_playback_pcm_open,
4460 .prepare = alc_playback_pcm_prepare,
4461 .cleanup = alc_playback_pcm_cleanup
4465 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
4469 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4470 /* NID is set in alc_build_pcms */
4473 #ifdef CONFIG_SND_HDA_POWER_SAVE
4474 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
4476 switch (codec->subsystem_id) {
4483 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
4485 /* update mute-LED according to the speaker mute state */
4486 if (nid == 0x01 || nid == 0x14) {
4488 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
4493 /* mic2 vref pin is used for mute LED control */
4494 snd_hda_codec_update_cache(codec, 0x19, 0,
4495 AC_VERB_SET_PIN_WIDGET_CONTROL,
4498 return alc_check_power_status(codec, nid);
4500 #endif /* CONFIG_SND_HDA_POWER_SAVE */
4502 /* different alc269-variants */
4504 ALC269_TYPE_ALC269VA,
4505 ALC269_TYPE_ALC269VB,
4506 ALC269_TYPE_ALC269VC,
4510 * BIOS auto configuration
4512 static int alc269_parse_auto_config(struct hda_codec *codec)
4514 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
4515 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
4516 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4517 struct alc_spec *spec = codec->spec;
4518 const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ?
4519 alc269va_ssids : alc269_ssids;
4521 return alc_parse_auto_config(codec, alc269_ignore, ssids);
4524 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
4526 int val = alc_read_coef_idx(codec, 0x04);
4531 alc_write_coef_idx(codec, 0x04, val);
4534 static void alc269_shutup(struct hda_codec *codec)
4536 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
4537 alc269_toggle_power_output(codec, 0);
4538 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
4539 alc269_toggle_power_output(codec, 0);
4545 static int alc269_resume(struct hda_codec *codec)
4547 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
4548 alc269_toggle_power_output(codec, 0);
4552 codec->patch_ops.init(codec);
4554 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
4555 alc269_toggle_power_output(codec, 1);
4559 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
4560 alc269_toggle_power_output(codec, 1);
4562 snd_hda_codec_resume_amp(codec);
4563 snd_hda_codec_resume_cache(codec);
4564 hda_call_check_power_status(codec, 0x01);
4567 #endif /* CONFIG_PM */
4569 static void alc269_fixup_hweq(struct hda_codec *codec,
4570 const struct alc_fixup *fix, int action)
4574 if (action != ALC_FIXUP_ACT_INIT)
4576 coef = alc_read_coef_idx(codec, 0x1e);
4577 alc_write_coef_idx(codec, 0x1e, coef | 0x80);
4580 static void alc271_fixup_dmic(struct hda_codec *codec,
4581 const struct alc_fixup *fix, int action)
4583 static const struct hda_verb verbs[] = {
4584 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4585 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4590 if (strcmp(codec->chip_name, "ALC271X"))
4592 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4593 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4594 snd_hda_sequence_write(codec, verbs);
4597 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4598 const struct alc_fixup *fix, int action)
4600 struct alc_spec *spec = codec->spec;
4602 if (action != ALC_FIXUP_ACT_PROBE)
4605 /* Due to a hardware problem on Lenovo Ideadpad, we need to
4606 * fix the sample rate of analog I/O to 44.1kHz
4608 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
4609 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
4612 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4613 const struct alc_fixup *fix, int action)
4617 if (action != ALC_FIXUP_ACT_INIT)
4619 /* The digital-mic unit sends PDM (differential signal) instead of
4620 * the standard PCM, thus you can't record a valid mono stream as is.
4621 * Below is a workaround specific to ALC269 to control the dmic
4622 * signal source as mono.
4624 coef = alc_read_coef_idx(codec, 0x07);
4625 alc_write_coef_idx(codec, 0x07, coef | 0x80);
4628 static void alc269_quanta_automute(struct hda_codec *codec)
4630 update_speakers(codec);
4632 snd_hda_codec_write(codec, 0x20, 0,
4633 AC_VERB_SET_COEF_INDEX, 0x0c);
4634 snd_hda_codec_write(codec, 0x20, 0,
4635 AC_VERB_SET_PROC_COEF, 0x680);
4637 snd_hda_codec_write(codec, 0x20, 0,
4638 AC_VERB_SET_COEF_INDEX, 0x0c);
4639 snd_hda_codec_write(codec, 0x20, 0,
4640 AC_VERB_SET_PROC_COEF, 0x480);
4643 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4644 const struct alc_fixup *fix, int action)
4646 struct alc_spec *spec = codec->spec;
4647 if (action != ALC_FIXUP_ACT_PROBE)
4649 spec->automute_hook = alc269_quanta_automute;
4653 ALC269_FIXUP_SONY_VAIO,
4654 ALC275_FIXUP_SONY_VAIO_GPIO2,
4655 ALC269_FIXUP_DELL_M101Z,
4656 ALC269_FIXUP_SKU_IGNORE,
4657 ALC269_FIXUP_ASUS_G73JW,
4658 ALC269_FIXUP_LENOVO_EAPD,
4659 ALC275_FIXUP_SONY_HWEQ,
4661 ALC269_FIXUP_PCM_44K,
4662 ALC269_FIXUP_STEREO_DMIC,
4663 ALC269_FIXUP_QUANTA_MUTE,
4664 ALC269_FIXUP_LIFEBOOK,
4667 static const struct alc_fixup alc269_fixups[] = {
4668 [ALC269_FIXUP_SONY_VAIO] = {
4669 .type = ALC_FIXUP_VERBS,
4670 .v.verbs = (const struct hda_verb[]) {
4671 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
4675 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
4676 .type = ALC_FIXUP_VERBS,
4677 .v.verbs = (const struct hda_verb[]) {
4678 {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
4679 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
4680 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4684 .chain_id = ALC269_FIXUP_SONY_VAIO
4686 [ALC269_FIXUP_DELL_M101Z] = {
4687 .type = ALC_FIXUP_VERBS,
4688 .v.verbs = (const struct hda_verb[]) {
4689 /* Enables internal speaker */
4690 {0x20, AC_VERB_SET_COEF_INDEX, 13},
4691 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
4695 [ALC269_FIXUP_SKU_IGNORE] = {
4696 .type = ALC_FIXUP_SKU,
4697 .v.sku = ALC_FIXUP_SKU_IGNORE,
4699 [ALC269_FIXUP_ASUS_G73JW] = {
4700 .type = ALC_FIXUP_PINS,
4701 .v.pins = (const struct alc_pincfg[]) {
4702 { 0x17, 0x99130111 }, /* subwoofer */
4706 [ALC269_FIXUP_LENOVO_EAPD] = {
4707 .type = ALC_FIXUP_VERBS,
4708 .v.verbs = (const struct hda_verb[]) {
4709 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
4713 [ALC275_FIXUP_SONY_HWEQ] = {
4714 .type = ALC_FIXUP_FUNC,
4715 .v.func = alc269_fixup_hweq,
4717 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
4719 [ALC271_FIXUP_DMIC] = {
4720 .type = ALC_FIXUP_FUNC,
4721 .v.func = alc271_fixup_dmic,
4723 [ALC269_FIXUP_PCM_44K] = {
4724 .type = ALC_FIXUP_FUNC,
4725 .v.func = alc269_fixup_pcm_44k,
4727 [ALC269_FIXUP_STEREO_DMIC] = {
4728 .type = ALC_FIXUP_FUNC,
4729 .v.func = alc269_fixup_stereo_dmic,
4731 [ALC269_FIXUP_QUANTA_MUTE] = {
4732 .type = ALC_FIXUP_FUNC,
4733 .v.func = alc269_fixup_quanta_mute,
4735 [ALC269_FIXUP_LIFEBOOK] = {
4736 .type = ALC_FIXUP_PINS,
4737 .v.pins = (const struct alc_pincfg[]) {
4738 { 0x1a, 0x2101103f }, /* dock line-out */
4739 { 0x1b, 0x23a11040 }, /* dock mic-in */
4743 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4747 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
4748 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
4749 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
4750 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
4751 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
4752 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4753 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4754 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
4755 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4756 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4757 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
4758 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
4759 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
4760 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
4761 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
4762 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
4763 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
4764 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
4765 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
4766 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_QUANTA_MUTE),
4767 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Lenovo Ideapd", ALC269_FIXUP_PCM_44K),
4768 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
4773 static int alc269_fill_coef(struct hda_codec *codec)
4777 if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
4778 alc_write_coef_idx(codec, 0xf, 0x960b);
4779 alc_write_coef_idx(codec, 0xe, 0x8817);
4782 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
4783 alc_write_coef_idx(codec, 0xf, 0x960b);
4784 alc_write_coef_idx(codec, 0xe, 0x8814);
4787 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
4788 val = alc_read_coef_idx(codec, 0x04);
4789 /* Power up output pin */
4790 alc_write_coef_idx(codec, 0x04, val | (1<<11));
4793 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
4794 val = alc_read_coef_idx(codec, 0xd);
4795 if ((val & 0x0c00) >> 10 != 0x1) {
4796 /* Capless ramp up clock control */
4797 alc_write_coef_idx(codec, 0xd, val | (1<<10));
4799 val = alc_read_coef_idx(codec, 0x17);
4800 if ((val & 0x01c0) >> 6 != 0x4) {
4801 /* Class D power on reset */
4802 alc_write_coef_idx(codec, 0x17, val | (1<<7));
4806 val = alc_read_coef_idx(codec, 0xd); /* Class D */
4807 alc_write_coef_idx(codec, 0xd, val | (1<<14));
4809 val = alc_read_coef_idx(codec, 0x4); /* HP */
4810 alc_write_coef_idx(codec, 0x4, val | (1<<11));
4817 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4818 #include "alc269_quirks.c"
4821 static int patch_alc269(struct hda_codec *codec)
4823 struct alc_spec *spec;
4824 int board_config, coef;
4827 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4833 spec->mixer_nid = 0x0b;
4835 alc_auto_parse_customize_define(codec);
4837 if (codec->vendor_id == 0x10ec0269) {
4838 spec->codec_variant = ALC269_TYPE_ALC269VA;
4839 coef = alc_read_coef_idx(codec, 0);
4840 if ((coef & 0x00f0) == 0x0010) {
4841 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
4842 spec->cdefine.platform_type == 1) {
4843 alc_codec_rename(codec, "ALC271X");
4844 } else if ((coef & 0xf000) == 0x2000) {
4845 alc_codec_rename(codec, "ALC259");
4846 } else if ((coef & 0xf000) == 0x3000) {
4847 alc_codec_rename(codec, "ALC258");
4848 } else if ((coef & 0xfff0) == 0x3010) {
4849 alc_codec_rename(codec, "ALC277");
4851 alc_codec_rename(codec, "ALC269VB");
4853 spec->codec_variant = ALC269_TYPE_ALC269VB;
4854 } else if ((coef & 0x00f0) == 0x0020) {
4856 alc_codec_rename(codec, "ALC259");
4857 else if (coef == 0x6023)
4858 alc_codec_rename(codec, "ALC281X");
4859 else if (codec->bus->pci->subsystem_vendor == 0x17aa &&
4860 codec->bus->pci->subsystem_device == 0x21f3)
4861 alc_codec_rename(codec, "ALC3202");
4863 alc_codec_rename(codec, "ALC269VC");
4864 spec->codec_variant = ALC269_TYPE_ALC269VC;
4866 alc_fix_pll_init(codec, 0x20, 0x04, 15);
4867 alc269_fill_coef(codec);
4870 board_config = alc_board_config(codec, ALC269_MODEL_LAST,
4871 alc269_models, alc269_cfg_tbl);
4873 if (board_config < 0) {
4874 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4876 board_config = ALC_MODEL_AUTO;
4879 if (board_config == ALC_MODEL_AUTO) {
4880 alc_pick_fixup(codec, NULL, alc269_fixup_tbl, alc269_fixups);
4881 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4884 if (board_config == ALC_MODEL_AUTO) {
4885 /* automatic parse from the BIOS config */
4886 err = alc269_parse_auto_config(codec);
4891 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4894 "hda_codec: Cannot set up configuration "
4895 "from BIOS. Using base mode...\n");
4896 board_config = ALC269_BASIC;
4901 if (board_config != ALC_MODEL_AUTO)
4902 setup_preset(codec, &alc269_presets[board_config]);
4904 if (!spec->no_analog && !spec->adc_nids) {
4905 alc_auto_fill_adc_caps(codec);
4906 alc_rebuild_imux_for_auto_mic(codec);
4907 alc_remove_invalid_adc_nids(codec);
4910 if (!spec->no_analog && !spec->cap_mixer)
4911 set_capture_mixer(codec);
4913 if (!spec->no_analog && has_cdefine_beep(codec)) {
4914 err = snd_hda_attach_beep_device(codec, 0x1);
4919 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
4922 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4924 spec->vmaster_nid = 0x02;
4926 codec->patch_ops = alc_patch_ops;
4928 codec->patch_ops.resume = alc269_resume;
4930 if (board_config == ALC_MODEL_AUTO)
4931 spec->init_hook = alc_auto_init_std;
4932 spec->shutup = alc269_shutup;
4934 alc_init_jacks(codec);
4935 #ifdef CONFIG_SND_HDA_POWER_SAVE
4936 if (!spec->loopback.amplist)
4937 spec->loopback.amplist = alc269_loopbacks;
4938 if (alc269_mic2_for_mute_led(codec))
4939 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
4949 static int alc861_parse_auto_config(struct hda_codec *codec)
4951 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
4952 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
4953 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
4956 #ifdef CONFIG_SND_HDA_POWER_SAVE
4957 static const struct hda_amp_list alc861_loopbacks[] = {
4958 { 0x15, HDA_INPUT, 0 },
4959 { 0x15, HDA_INPUT, 1 },
4960 { 0x15, HDA_INPUT, 2 },
4961 { 0x15, HDA_INPUT, 3 },
4967 /* Pin config fixes */
4969 PINFIX_FSC_AMILO_PI1505,
4972 static const struct alc_fixup alc861_fixups[] = {
4973 [PINFIX_FSC_AMILO_PI1505] = {
4974 .type = ALC_FIXUP_PINS,
4975 .v.pins = (const struct alc_pincfg[]) {
4976 { 0x0b, 0x0221101f }, /* HP */
4977 { 0x0f, 0x90170310 }, /* speaker */
4983 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
4984 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
4990 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4991 #include "alc861_quirks.c"
4994 static int patch_alc861(struct hda_codec *codec)
4996 struct alc_spec *spec;
5000 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5006 spec->mixer_nid = 0x15;
5008 board_config = alc_board_config(codec, ALC861_MODEL_LAST,
5009 alc861_models, alc861_cfg_tbl);
5011 if (board_config < 0) {
5012 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5014 board_config = ALC_MODEL_AUTO;
5017 if (board_config == ALC_MODEL_AUTO) {
5018 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
5019 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5022 if (board_config == ALC_MODEL_AUTO) {
5023 /* automatic parse from the BIOS config */
5024 err = alc861_parse_auto_config(codec);
5029 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5032 "hda_codec: Cannot set up configuration "
5033 "from BIOS. Using base mode...\n");
5034 board_config = ALC861_3ST_DIG;
5039 if (board_config != ALC_MODEL_AUTO)
5040 setup_preset(codec, &alc861_presets[board_config]);
5042 if (!spec->no_analog && !spec->adc_nids) {
5043 alc_auto_fill_adc_caps(codec);
5044 alc_rebuild_imux_for_auto_mic(codec);
5045 alc_remove_invalid_adc_nids(codec);
5048 if (!spec->no_analog && !spec->cap_mixer)
5049 set_capture_mixer(codec);
5051 if (!spec->no_analog) {
5052 err = snd_hda_attach_beep_device(codec, 0x23);
5057 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
5060 spec->vmaster_nid = 0x03;
5062 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5064 codec->patch_ops = alc_patch_ops;
5065 if (board_config == ALC_MODEL_AUTO) {
5066 spec->init_hook = alc_auto_init_std;
5067 #ifdef CONFIG_SND_HDA_POWER_SAVE
5068 spec->power_hook = alc_power_eapd;
5071 #ifdef CONFIG_SND_HDA_POWER_SAVE
5072 if (!spec->loopback.amplist)
5073 spec->loopback.amplist = alc861_loopbacks;
5084 * In addition, an independent DAC
5086 #ifdef CONFIG_SND_HDA_POWER_SAVE
5087 #define alc861vd_loopbacks alc880_loopbacks
5090 static int alc861vd_parse_auto_config(struct hda_codec *codec)
5092 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
5093 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5094 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
5098 ALC660VD_FIX_ASUS_GPIO1
5102 static const struct alc_fixup alc861vd_fixups[] = {
5103 [ALC660VD_FIX_ASUS_GPIO1] = {
5104 .type = ALC_FIXUP_VERBS,
5105 .v.verbs = (const struct hda_verb[]) {
5106 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5107 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5108 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5114 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
5115 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
5119 static const struct hda_verb alc660vd_eapd_verbs[] = {
5120 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
5121 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
5127 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5128 #include "alc861vd_quirks.c"
5131 static int patch_alc861vd(struct hda_codec *codec)
5133 struct alc_spec *spec;
5134 int err, board_config;
5136 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5142 spec->mixer_nid = 0x0b;
5144 board_config = alc_board_config(codec, ALC861VD_MODEL_LAST,
5145 alc861vd_models, alc861vd_cfg_tbl);
5147 if (board_config < 0) {
5148 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5150 board_config = ALC_MODEL_AUTO;
5153 if (board_config == ALC_MODEL_AUTO) {
5154 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
5155 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5158 if (board_config == ALC_MODEL_AUTO) {
5159 /* automatic parse from the BIOS config */
5160 err = alc861vd_parse_auto_config(codec);
5165 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5168 "hda_codec: Cannot set up configuration "
5169 "from BIOS. Using base mode...\n");
5170 board_config = ALC861VD_3ST;
5175 if (board_config != ALC_MODEL_AUTO)
5176 setup_preset(codec, &alc861vd_presets[board_config]);
5178 if (codec->vendor_id == 0x10ec0660) {
5179 /* always turn on EAPD */
5180 add_verb(spec, alc660vd_eapd_verbs);
5183 if (!spec->no_analog && !spec->adc_nids) {
5184 alc_auto_fill_adc_caps(codec);
5185 alc_rebuild_imux_for_auto_mic(codec);
5186 alc_remove_invalid_adc_nids(codec);
5189 if (!spec->no_analog && !spec->cap_mixer)
5190 set_capture_mixer(codec);
5192 if (!spec->no_analog) {
5193 err = snd_hda_attach_beep_device(codec, 0x23);
5198 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5201 spec->vmaster_nid = 0x02;
5203 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5205 codec->patch_ops = alc_patch_ops;
5207 if (board_config == ALC_MODEL_AUTO)
5208 spec->init_hook = alc_auto_init_std;
5209 spec->shutup = alc_eapd_shutup;
5210 #ifdef CONFIG_SND_HDA_POWER_SAVE
5211 if (!spec->loopback.amplist)
5212 spec->loopback.amplist = alc861vd_loopbacks;
5221 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5222 * configuration. Each pin widget can choose any input DACs and a mixer.
5223 * Each ADC is connected from a mixer of all inputs. This makes possible
5224 * 6-channel independent captures.
5226 * In addition, an independent DAC for the multi-playback (not used in this
5229 #ifdef CONFIG_SND_HDA_POWER_SAVE
5230 #define alc662_loopbacks alc880_loopbacks
5234 * BIOS auto configuration
5237 static int alc662_parse_auto_config(struct hda_codec *codec)
5239 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
5240 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
5241 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5242 const hda_nid_t *ssids;
5244 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
5245 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
5246 ssids = alc663_ssids;
5248 ssids = alc662_ssids;
5249 return alc_parse_auto_config(codec, alc662_ignore, ssids);
5252 static void alc272_fixup_mario(struct hda_codec *codec,
5253 const struct alc_fixup *fix, int action)
5255 if (action != ALC_FIXUP_ACT_PROBE)
5257 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
5258 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
5259 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
5260 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5261 (0 << AC_AMPCAP_MUTE_SHIFT)))
5263 "hda_codec: failed to override amp caps for NID 0x2\n");
5267 ALC662_FIXUP_ASPIRE,
5268 ALC662_FIXUP_IDEAPAD,
5270 ALC662_FIXUP_CZC_P10T,
5271 ALC662_FIXUP_SKU_IGNORE,
5272 ALC662_FIXUP_HP_RP5800,
5276 static const struct alc_fixup alc662_fixups[] = {
5277 [ALC662_FIXUP_ASPIRE] = {
5278 .type = ALC_FIXUP_PINS,
5279 .v.pins = (const struct alc_pincfg[]) {
5280 { 0x15, 0x99130112 }, /* subwoofer */
5284 [ALC662_FIXUP_IDEAPAD] = {
5285 .type = ALC_FIXUP_PINS,
5286 .v.pins = (const struct alc_pincfg[]) {
5287 { 0x17, 0x99130112 }, /* subwoofer */
5291 [ALC272_FIXUP_MARIO] = {
5292 .type = ALC_FIXUP_FUNC,
5293 .v.func = alc272_fixup_mario,
5295 [ALC662_FIXUP_CZC_P10T] = {
5296 .type = ALC_FIXUP_VERBS,
5297 .v.verbs = (const struct hda_verb[]) {
5298 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5302 [ALC662_FIXUP_SKU_IGNORE] = {
5303 .type = ALC_FIXUP_SKU,
5304 .v.sku = ALC_FIXUP_SKU_IGNORE,
5306 [ALC662_FIXUP_HP_RP5800] = {
5307 .type = ALC_FIXUP_PINS,
5308 .v.pins = (const struct alc_pincfg[]) {
5309 { 0x14, 0x0221201f }, /* HP out */
5313 .chain_id = ALC662_FIXUP_SKU_IGNORE
5315 [ALC662_FIXUP_ECS] = {
5316 .type = ALC_FIXUP_PINS,
5317 .v.pins = (const struct alc_pincfg[]) {
5318 { 0x14, 0x99130110 }, /* speaker */
5319 { 0x18, 0x01a19820 }, /* mic */
5320 { 0x19, 0x99a3092f }, /* int-mic */
5321 { 0x1b, 0x0121401f }, /* HP out */
5327 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
5328 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ECS),
5329 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
5330 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
5331 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
5332 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
5333 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ECS),
5334 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
5335 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
5336 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
5337 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
5341 static const struct alc_model_fixup alc662_fixup_models[] = {
5342 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
5349 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5350 #include "alc662_quirks.c"
5353 static int patch_alc662(struct hda_codec *codec)
5355 struct alc_spec *spec;
5356 int err, board_config;
5359 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5365 spec->mixer_nid = 0x0b;
5367 alc_auto_parse_customize_define(codec);
5369 alc_fix_pll_init(codec, 0x20, 0x04, 15);
5371 coef = alc_read_coef_idx(codec, 0);
5372 if (coef == 0x8020 || coef == 0x8011)
5373 alc_codec_rename(codec, "ALC661");
5374 else if (coef & (1 << 14) &&
5375 codec->bus->pci->subsystem_vendor == 0x1025 &&
5376 spec->cdefine.platform_type == 1)
5377 alc_codec_rename(codec, "ALC272X");
5378 else if (coef == 0x4011)
5379 alc_codec_rename(codec, "ALC656");
5381 board_config = alc_board_config(codec, ALC662_MODEL_LAST,
5382 alc662_models, alc662_cfg_tbl);
5383 if (board_config < 0) {
5384 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5386 board_config = ALC_MODEL_AUTO;
5389 if (board_config == ALC_MODEL_AUTO) {
5390 alc_pick_fixup(codec, alc662_fixup_models,
5391 alc662_fixup_tbl, alc662_fixups);
5392 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5393 /* automatic parse from the BIOS config */
5394 err = alc662_parse_auto_config(codec);
5399 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5402 "hda_codec: Cannot set up configuration "
5403 "from BIOS. Using base mode...\n");
5404 board_config = ALC662_3ST_2ch_DIG;
5409 if (board_config != ALC_MODEL_AUTO)
5410 setup_preset(codec, &alc662_presets[board_config]);
5412 if (!spec->no_analog && !spec->adc_nids) {
5413 alc_auto_fill_adc_caps(codec);
5414 alc_rebuild_imux_for_auto_mic(codec);
5415 alc_remove_invalid_adc_nids(codec);
5418 if (!spec->no_analog && !spec->cap_mixer)
5419 set_capture_mixer(codec);
5421 if (!spec->no_analog && has_cdefine_beep(codec)) {
5422 err = snd_hda_attach_beep_device(codec, 0x1);
5427 switch (codec->vendor_id) {
5429 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5434 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5437 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
5441 spec->vmaster_nid = 0x02;
5443 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5445 codec->patch_ops = alc_patch_ops;
5446 if (board_config == ALC_MODEL_AUTO)
5447 spec->init_hook = alc_auto_init_std;
5448 spec->shutup = alc_eapd_shutup;
5450 alc_init_jacks(codec);
5452 #ifdef CONFIG_SND_HDA_POWER_SAVE
5453 if (!spec->loopback.amplist)
5454 spec->loopback.amplist = alc662_loopbacks;
5460 static int patch_alc888(struct hda_codec *codec)
5462 if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
5463 kfree(codec->chip_name);
5464 if (codec->vendor_id == 0x10ec0887)
5465 codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
5467 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
5468 if (!codec->chip_name) {
5472 return patch_alc662(codec);
5474 return patch_alc882(codec);
5477 static int patch_alc899(struct hda_codec *codec)
5479 if ((alc_read_coef_idx(codec, 0) & 0x2000) != 0x2000) {
5480 kfree(codec->chip_name);
5481 codec->chip_name = kstrdup("ALC898", GFP_KERNEL);
5483 return patch_alc882(codec);
5490 static int alc680_parse_auto_config(struct hda_codec *codec)
5492 return alc_parse_auto_config(codec, NULL, NULL);
5497 static int patch_alc680(struct hda_codec *codec)
5499 struct alc_spec *spec;
5502 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5508 /* ALC680 has no aa-loopback mixer */
5510 /* automatic parse from the BIOS config */
5511 err = alc680_parse_auto_config(codec);
5517 if (!spec->no_analog && !spec->cap_mixer)
5518 set_capture_mixer(codec);
5520 spec->vmaster_nid = 0x02;
5522 codec->patch_ops = alc_patch_ops;
5523 spec->init_hook = alc_auto_init_std;
5531 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
5532 { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
5533 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
5534 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
5535 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
5536 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
5537 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
5538 { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
5539 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
5540 { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
5541 { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
5542 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
5543 .patch = patch_alc861 },
5544 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
5545 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
5546 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
5547 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
5548 .patch = patch_alc882 },
5549 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
5550 .patch = patch_alc662 },
5551 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
5552 { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
5553 { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
5554 { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
5555 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
5556 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
5557 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
5558 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
5559 .patch = patch_alc882 },
5560 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
5561 .patch = patch_alc882 },
5562 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
5563 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
5564 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
5565 .patch = patch_alc882 },
5566 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
5567 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
5568 { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
5569 { .id = 0x10ec0899, .name = "ALC899", .patch = patch_alc899 },
5573 MODULE_ALIAS("snd-hda-codec-id:10ec*");
5575 MODULE_LICENSE("GPL");
5576 MODULE_DESCRIPTION("Realtek HD-audio codec");
5578 static struct hda_codec_preset_list realtek_list = {
5579 .preset = snd_hda_preset_realtek,
5580 .owner = THIS_MODULE,
5583 static int __init patch_realtek_init(void)
5585 return snd_hda_add_codec_preset(&realtek_list);
5588 static void __exit patch_realtek_exit(void)
5590 snd_hda_delete_codec_preset(&realtek_list);
5593 module_init(patch_realtek_init)
5594 module_exit(patch_realtek_exit)