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);
163 /* for pin sensing */
164 unsigned int jack_present: 1;
165 unsigned int line_jack_present:1;
166 unsigned int master_mute:1;
167 unsigned int auto_mic:1;
168 unsigned int auto_mic_valid_imux:1; /* valid imux for auto-mic */
169 unsigned int automute:1; /* HP automute enabled */
170 unsigned int detect_line:1; /* Line-out detection enabled */
171 unsigned int automute_lines:1; /* automute line-out as well */
172 unsigned int automute_hp_lo:1; /* both HP and LO available */
175 unsigned int no_analog :1; /* digital I/O only */
176 unsigned int dyn_adc_switch:1; /* switch ADCs (for ALC275) */
177 unsigned int single_input_src:1;
178 unsigned int vol_in_capsrc:1; /* use capsrc volume (ADC has no vol) */
180 /* auto-mute control */
182 hda_nid_t automute_mixer_nid[AUTO_CFG_MAX_OUTS];
185 int codec_variant; /* flag for other variants */
187 /* for virtual master */
188 hda_nid_t vmaster_nid;
189 #ifdef CONFIG_SND_HDA_POWER_SAVE
190 struct hda_loopback_check loopback;
195 unsigned int pll_coef_idx, pll_coef_bit;
199 const struct alc_fixup *fixup_list;
200 const char *fixup_name;
204 struct alc_multi_io multi_io[4];
207 #define ALC_MODEL_AUTO 0 /* common for all chips */
209 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid,
210 int dir, unsigned int bits)
214 if (get_wcaps(codec, nid) & (1 << (dir + 1)))
215 if (query_amp_caps(codec, nid, dir) & bits)
220 #define nid_has_mute(codec, nid, dir) \
221 check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
222 #define nid_has_volume(codec, nid, dir) \
223 check_amp_caps(codec, nid, dir, AC_AMPCAP_NUM_STEPS)
228 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
229 struct snd_ctl_elem_info *uinfo)
231 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
232 struct alc_spec *spec = codec->spec;
233 unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
234 if (mux_idx >= spec->num_mux_defs)
236 if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
238 return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
241 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
242 struct snd_ctl_elem_value *ucontrol)
244 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
245 struct alc_spec *spec = codec->spec;
246 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
248 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
252 static bool alc_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
254 struct alc_spec *spec = codec->spec;
255 hda_nid_t new_adc = spec->adc_nids[spec->dyn_adc_idx[cur]];
257 if (spec->cur_adc && spec->cur_adc != new_adc) {
258 /* stream is running, let's swap the current ADC */
259 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
260 spec->cur_adc = new_adc;
261 snd_hda_codec_setup_stream(codec, new_adc,
262 spec->cur_adc_stream_tag, 0,
263 spec->cur_adc_format);
269 /* select the given imux item; either unmute exclusively or select the route */
270 static int alc_mux_select(struct hda_codec *codec, unsigned int adc_idx,
271 unsigned int idx, bool force)
273 struct alc_spec *spec = codec->spec;
274 const struct hda_input_mux *imux;
275 unsigned int mux_idx;
279 mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
280 imux = &spec->input_mux[mux_idx];
281 if (!imux->num_items && mux_idx > 0)
282 imux = &spec->input_mux[0];
284 if (idx >= imux->num_items)
285 idx = imux->num_items - 1;
286 if (spec->cur_mux[adc_idx] == idx && !force)
288 spec->cur_mux[adc_idx] = idx;
290 if (spec->dyn_adc_switch) {
291 alc_dyn_adc_pcm_resetup(codec, idx);
292 adc_idx = spec->dyn_adc_idx[idx];
295 nid = spec->capsrc_nids ?
296 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
299 if (snd_hda_get_conn_list(codec, nid, NULL) <= 1)
302 type = get_wcaps_type(get_wcaps(codec, nid));
303 if (type == AC_WID_AUD_MIX) {
304 /* Matrix-mixer style (e.g. ALC882) */
305 for (i = 0; i < imux->num_items; i++) {
306 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
307 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
308 imux->items[i].index,
312 /* MUX style (e.g. ALC880) */
313 snd_hda_codec_write_cache(codec, nid, 0,
314 AC_VERB_SET_CONNECT_SEL,
315 imux->items[idx].index);
320 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
321 struct snd_ctl_elem_value *ucontrol)
323 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
324 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
325 return alc_mux_select(codec, adc_idx,
326 ucontrol->value.enumerated.item[0], false);
330 * set up the input pin config (depending on the given auto-pin type)
332 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
335 unsigned int val = PIN_IN;
337 if (auto_pin_type == AUTO_PIN_MIC) {
340 oldval = snd_hda_codec_read(codec, nid, 0,
341 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
342 pincap = snd_hda_query_pin_caps(codec, nid);
343 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
344 /* if the default pin setup is vref50, we give it priority */
345 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
347 else if (pincap & AC_PINCAP_VREF_50)
349 else if (pincap & AC_PINCAP_VREF_100)
351 else if (pincap & AC_PINCAP_VREF_GRD)
354 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
358 * Append the given mixer and verb elements for the later use
359 * The mixer array is referred in build_controls(), and init_verbs are
362 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
364 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
366 spec->mixers[spec->num_mixers++] = mix;
369 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
371 if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
373 spec->init_verbs[spec->num_init_verbs++] = verb;
377 * GPIO setup tables, used in initialization
379 /* Enable GPIO mask and set output */
380 static const struct hda_verb alc_gpio1_init_verbs[] = {
381 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
382 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
383 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
387 static const struct hda_verb alc_gpio2_init_verbs[] = {
388 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
389 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
390 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
394 static const struct hda_verb alc_gpio3_init_verbs[] = {
395 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
396 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
397 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
402 * Fix hardware PLL issue
403 * On some codecs, the analog PLL gating control must be off while
404 * the default value is 1.
406 static void alc_fix_pll(struct hda_codec *codec)
408 struct alc_spec *spec = codec->spec;
413 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
415 val = snd_hda_codec_read(codec, spec->pll_nid, 0,
416 AC_VERB_GET_PROC_COEF, 0);
417 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
419 snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
420 val & ~(1 << spec->pll_coef_bit));
423 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
424 unsigned int coef_idx, unsigned int coef_bit)
426 struct alc_spec *spec = codec->spec;
428 spec->pll_coef_idx = coef_idx;
429 spec->pll_coef_bit = coef_bit;
434 * Jack-reporting via input-jack layer
437 /* initialization of jacks; currently checks only a few known pins */
438 static int alc_init_jacks(struct hda_codec *codec)
440 #ifdef CONFIG_SND_HDA_INPUT_JACK
441 struct alc_spec *spec = codec->spec;
443 unsigned int hp_nid = spec->autocfg.hp_pins[0];
444 unsigned int mic_nid = spec->ext_mic_pin;
445 unsigned int dock_nid = spec->dock_mic_pin;
448 err = snd_hda_input_jack_add(codec, hp_nid,
449 SND_JACK_HEADPHONE, NULL);
452 snd_hda_input_jack_report(codec, hp_nid);
456 err = snd_hda_input_jack_add(codec, mic_nid,
457 SND_JACK_MICROPHONE, NULL);
460 snd_hda_input_jack_report(codec, mic_nid);
463 err = snd_hda_input_jack_add(codec, dock_nid,
464 SND_JACK_MICROPHONE, NULL);
467 snd_hda_input_jack_report(codec, dock_nid);
469 #endif /* CONFIG_SND_HDA_INPUT_JACK */
474 * Jack detections for HP auto-mute and mic-switch
477 /* check each pin in the given array; returns true if any of them is plugged */
478 static bool detect_jacks(struct hda_codec *codec, int num_pins, hda_nid_t *pins)
482 for (i = 0; i < num_pins; i++) {
483 hda_nid_t nid = pins[i];
486 snd_hda_input_jack_report(codec, nid);
487 present |= snd_hda_jack_detect(codec, nid);
492 /* standard HP/line-out auto-mute helper */
493 static void do_automute(struct hda_codec *codec, int num_pins, hda_nid_t *pins,
494 bool mute, bool hp_out)
496 struct alc_spec *spec = codec->spec;
497 unsigned int mute_bits = mute ? HDA_AMP_MUTE : 0;
498 unsigned int pin_bits = mute ? 0 : (hp_out ? PIN_HP : PIN_OUT);
501 for (i = 0; i < num_pins; i++) {
502 hda_nid_t nid = pins[i];
505 switch (spec->automute_mode) {
506 case ALC_AUTOMUTE_PIN:
507 snd_hda_codec_write(codec, nid, 0,
508 AC_VERB_SET_PIN_WIDGET_CONTROL,
511 case ALC_AUTOMUTE_AMP:
512 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
513 HDA_AMP_MUTE, mute_bits);
515 case ALC_AUTOMUTE_MIXER:
516 nid = spec->automute_mixer_nid[i];
519 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
520 HDA_AMP_MUTE, mute_bits);
521 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 1,
522 HDA_AMP_MUTE, mute_bits);
528 /* Toggle internal speakers muting */
529 static void update_speakers(struct hda_codec *codec)
531 struct alc_spec *spec = codec->spec;
534 /* Control HP pins/amps depending on master_mute state;
535 * in general, HP pins/amps control should be enabled in all cases,
536 * but currently set only for master_mute, just to be safe
538 do_automute(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
539 spec->autocfg.hp_pins, spec->master_mute, true);
544 on = spec->jack_present | spec->line_jack_present;
545 on |= spec->master_mute;
546 do_automute(codec, ARRAY_SIZE(spec->autocfg.speaker_pins),
547 spec->autocfg.speaker_pins, on, false);
549 /* toggle line-out mutes if needed, too */
550 /* if LO is a copy of either HP or Speaker, don't need to handle it */
551 if (spec->autocfg.line_out_pins[0] == spec->autocfg.hp_pins[0] ||
552 spec->autocfg.line_out_pins[0] == spec->autocfg.speaker_pins[0])
554 if (!spec->automute_lines || !spec->automute)
557 on = spec->jack_present;
558 on |= spec->master_mute;
559 do_automute(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
560 spec->autocfg.line_out_pins, on, false);
563 /* standard HP-automute helper */
564 static void alc_hp_automute(struct hda_codec *codec)
566 struct alc_spec *spec = codec->spec;
571 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
572 spec->autocfg.hp_pins);
573 update_speakers(codec);
576 /* standard line-out-automute helper */
577 static void alc_line_automute(struct hda_codec *codec)
579 struct alc_spec *spec = codec->spec;
581 if (!spec->automute || !spec->detect_line)
583 spec->line_jack_present =
584 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
585 spec->autocfg.line_out_pins);
586 update_speakers(codec);
589 #define get_connection_index(codec, mux, nid) \
590 snd_hda_get_conn_index(codec, mux, nid, 0)
592 /* standard mic auto-switch helper */
593 static void alc_mic_automute(struct hda_codec *codec)
595 struct alc_spec *spec = codec->spec;
596 hda_nid_t *pins = spec->imux_pins;
598 if (!spec->auto_mic || !spec->auto_mic_valid_imux)
600 if (snd_BUG_ON(!spec->adc_nids))
602 if (snd_BUG_ON(spec->int_mic_idx < 0 || spec->ext_mic_idx < 0))
605 if (snd_hda_jack_detect(codec, pins[spec->ext_mic_idx]))
606 alc_mux_select(codec, 0, spec->ext_mic_idx, false);
607 else if (spec->dock_mic_idx >= 0 &&
608 snd_hda_jack_detect(codec, pins[spec->dock_mic_idx]))
609 alc_mux_select(codec, 0, spec->dock_mic_idx, false);
611 alc_mux_select(codec, 0, spec->int_mic_idx, false);
613 snd_hda_input_jack_report(codec, pins[spec->ext_mic_idx]);
614 if (spec->dock_mic_idx >= 0)
615 snd_hda_input_jack_report(codec, pins[spec->dock_mic_idx]);
618 /* unsolicited event for HP jack sensing */
619 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
621 if (codec->vendor_id == 0x10ec0880)
627 alc_hp_automute(codec);
629 case ALC_FRONT_EVENT:
630 alc_line_automute(codec);
633 alc_mic_automute(codec);
638 /* call init functions of standard auto-mute helpers */
639 static void alc_inithook(struct hda_codec *codec)
641 alc_hp_automute(codec);
642 alc_line_automute(codec);
643 alc_mic_automute(codec);
646 /* additional initialization for ALC888 variants */
647 static void alc888_coef_init(struct hda_codec *codec)
651 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
652 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
653 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
654 if ((tmp & 0xf0) == 0x20)
656 snd_hda_codec_read(codec, 0x20, 0,
657 AC_VERB_SET_PROC_COEF, 0x830);
660 snd_hda_codec_read(codec, 0x20, 0,
661 AC_VERB_SET_PROC_COEF, 0x3030);
664 /* additional initialization for ALC889 variants */
665 static void alc889_coef_init(struct hda_codec *codec)
669 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
670 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
671 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
672 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
675 /* turn on/off EAPD control (only if available) */
676 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
678 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
680 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
681 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
685 /* turn on/off EAPD controls of the codec */
686 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
688 /* We currently only handle front, HP */
689 static hda_nid_t pins[] = {
690 0x0f, 0x10, 0x14, 0x15, 0
693 for (p = pins; *p; p++)
694 set_eapd(codec, *p, on);
697 /* generic shutup callback;
698 * just turning off EPAD and a little pause for avoiding pop-noise
700 static void alc_eapd_shutup(struct hda_codec *codec)
702 alc_auto_setup_eapd(codec, false);
706 /* generic EAPD initialization */
707 static void alc_auto_init_amp(struct hda_codec *codec, int type)
711 alc_auto_setup_eapd(codec, true);
714 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
717 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
720 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
722 case ALC_INIT_DEFAULT:
723 switch (codec->vendor_id) {
725 snd_hda_codec_write(codec, 0x1a, 0,
726 AC_VERB_SET_COEF_INDEX, 7);
727 tmp = snd_hda_codec_read(codec, 0x1a, 0,
728 AC_VERB_GET_PROC_COEF, 0);
729 snd_hda_codec_write(codec, 0x1a, 0,
730 AC_VERB_SET_COEF_INDEX, 7);
731 snd_hda_codec_write(codec, 0x1a, 0,
732 AC_VERB_SET_PROC_COEF,
741 /*case 0x10ec0889:*/ /* this causes an SPDIF problem */
742 alc889_coef_init(codec);
745 alc888_coef_init(codec);
747 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
750 snd_hda_codec_write(codec, 0x20, 0,
751 AC_VERB_SET_COEF_INDEX, 7);
752 tmp = snd_hda_codec_read(codec, 0x20, 0,
753 AC_VERB_GET_PROC_COEF, 0);
754 snd_hda_codec_write(codec, 0x20, 0,
755 AC_VERB_SET_COEF_INDEX, 7);
756 snd_hda_codec_write(codec, 0x20, 0,
757 AC_VERB_SET_PROC_COEF,
767 * Auto-Mute mode mixer enum support
769 static int alc_automute_mode_info(struct snd_kcontrol *kcontrol,
770 struct snd_ctl_elem_info *uinfo)
772 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
773 struct alc_spec *spec = codec->spec;
774 static const char * const texts2[] = {
775 "Disabled", "Enabled"
777 static const char * const texts3[] = {
778 "Disabled", "Speaker Only", "Line-Out+Speaker"
780 const char * const *texts;
782 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
784 if (spec->automute_hp_lo) {
785 uinfo->value.enumerated.items = 3;
788 uinfo->value.enumerated.items = 2;
791 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
792 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
793 strcpy(uinfo->value.enumerated.name,
794 texts[uinfo->value.enumerated.item]);
798 static int alc_automute_mode_get(struct snd_kcontrol *kcontrol,
799 struct snd_ctl_elem_value *ucontrol)
801 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
802 struct alc_spec *spec = codec->spec;
806 else if (!spec->automute_lines)
810 ucontrol->value.enumerated.item[0] = val;
814 static int alc_automute_mode_put(struct snd_kcontrol *kcontrol,
815 struct snd_ctl_elem_value *ucontrol)
817 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
818 struct alc_spec *spec = codec->spec;
820 switch (ucontrol->value.enumerated.item[0]) {
827 if (spec->automute && !spec->automute_lines)
830 spec->automute_lines = 0;
833 if (!spec->automute_hp_lo)
835 if (spec->automute && spec->automute_lines)
838 spec->automute_lines = 1;
843 update_speakers(codec);
847 static const struct snd_kcontrol_new alc_automute_mode_enum = {
848 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
849 .name = "Auto-Mute Mode",
850 .info = alc_automute_mode_info,
851 .get = alc_automute_mode_get,
852 .put = alc_automute_mode_put,
855 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
857 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
858 return snd_array_new(&spec->kctls);
861 static int alc_add_automute_mode_enum(struct hda_codec *codec)
863 struct alc_spec *spec = codec->spec;
864 struct snd_kcontrol_new *knew;
866 knew = alc_kcontrol_new(spec);
869 *knew = alc_automute_mode_enum;
870 knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
877 * Check the availability of HP/line-out auto-mute;
878 * Set up appropriately if really supported
880 static void alc_init_auto_hp(struct hda_codec *codec)
882 struct alc_spec *spec = codec->spec;
883 struct auto_pin_cfg *cfg = &spec->autocfg;
889 if (cfg->line_out_pins[0])
891 if (cfg->speaker_pins[0])
893 if (present < 2) /* need two different output types */
896 spec->automute_hp_lo = 1; /* both HP and LO automute */
898 if (!cfg->speaker_pins[0] &&
899 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
900 memcpy(cfg->speaker_pins, cfg->line_out_pins,
901 sizeof(cfg->speaker_pins));
902 cfg->speaker_outs = cfg->line_outs;
905 if (!cfg->hp_pins[0] &&
906 cfg->line_out_type == AUTO_PIN_HP_OUT) {
907 memcpy(cfg->hp_pins, cfg->line_out_pins,
908 sizeof(cfg->hp_pins));
909 cfg->hp_outs = cfg->line_outs;
912 for (i = 0; i < cfg->hp_outs; i++) {
913 hda_nid_t nid = cfg->hp_pins[i];
914 if (!is_jack_detectable(codec, nid))
916 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
918 snd_hda_codec_write_cache(codec, nid, 0,
919 AC_VERB_SET_UNSOLICITED_ENABLE,
920 AC_USRSP_EN | ALC_HP_EVENT);
922 spec->automute_mode = ALC_AUTOMUTE_PIN;
924 if (spec->automute && cfg->line_out_pins[0] &&
925 cfg->speaker_pins[0] &&
926 cfg->line_out_pins[0] != cfg->hp_pins[0] &&
927 cfg->line_out_pins[0] != cfg->speaker_pins[0]) {
928 for (i = 0; i < cfg->line_outs; i++) {
929 hda_nid_t nid = cfg->line_out_pins[i];
930 if (!is_jack_detectable(codec, nid))
932 snd_printdd("realtek: Enable Line-Out auto-muting "
933 "on NID 0x%x\n", nid);
934 snd_hda_codec_write_cache(codec, nid, 0,
935 AC_VERB_SET_UNSOLICITED_ENABLE,
936 AC_USRSP_EN | ALC_FRONT_EVENT);
937 spec->detect_line = 1;
939 spec->automute_lines = spec->detect_line;
942 if (spec->automute) {
943 /* create a control for automute mode */
944 alc_add_automute_mode_enum(codec);
945 spec->unsol_event = alc_sku_unsol_event;
949 /* return the position of NID in the list, or -1 if not found */
950 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
953 for (i = 0; i < nums; i++)
959 /* check whether dynamic ADC-switching is available */
960 static bool alc_check_dyn_adc_switch(struct hda_codec *codec)
962 struct alc_spec *spec = codec->spec;
963 struct hda_input_mux *imux = &spec->private_imux[0];
967 if (imux != spec->input_mux) /* no dynamic imux? */
970 for (n = 0; n < spec->num_adc_nids; n++) {
971 cap = spec->private_capsrc_nids[n];
972 for (i = 0; i < imux->num_items; i++) {
973 pin = spec->imux_pins[i];
976 if (get_connection_index(codec, cap, pin) < 0)
979 if (i >= imux->num_items)
980 return true; /* no ADC-switch is needed */
983 for (i = 0; i < imux->num_items; i++) {
984 pin = spec->imux_pins[i];
985 for (n = 0; n < spec->num_adc_nids; n++) {
986 cap = spec->private_capsrc_nids[n];
987 idx = get_connection_index(codec, cap, pin);
989 imux->items[i].index = idx;
990 spec->dyn_adc_idx[i] = n;
996 snd_printdd("realtek: enabling ADC switching\n");
997 spec->dyn_adc_switch = 1;
1001 /* rebuild imux for matching with the given auto-mic pins (if not yet) */
1002 static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec)
1004 struct alc_spec *spec = codec->spec;
1005 struct hda_input_mux *imux;
1006 static char * const texts[3] = {
1007 "Mic", "Internal Mic", "Dock Mic"
1011 if (!spec->auto_mic)
1013 imux = &spec->private_imux[0];
1014 if (spec->input_mux == imux)
1016 spec->imux_pins[0] = spec->ext_mic_pin;
1017 spec->imux_pins[1] = spec->int_mic_pin;
1018 spec->imux_pins[2] = spec->dock_mic_pin;
1019 for (i = 0; i < 3; i++) {
1020 strcpy(imux->items[i].label, texts[i]);
1021 if (spec->imux_pins[i])
1022 imux->num_items = i + 1;
1024 spec->num_mux_defs = 1;
1025 spec->input_mux = imux;
1029 /* check whether all auto-mic pins are valid; setup indices if OK */
1030 static bool alc_auto_mic_check_imux(struct hda_codec *codec)
1032 struct alc_spec *spec = codec->spec;
1033 const struct hda_input_mux *imux;
1035 if (!spec->auto_mic)
1037 if (spec->auto_mic_valid_imux)
1038 return true; /* already checked */
1040 /* fill up imux indices */
1041 if (!alc_check_dyn_adc_switch(codec)) {
1046 imux = spec->input_mux;
1047 spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin,
1048 spec->imux_pins, imux->num_items);
1049 spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin,
1050 spec->imux_pins, imux->num_items);
1051 spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin,
1052 spec->imux_pins, imux->num_items);
1053 if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) {
1055 return false; /* no corresponding imux */
1058 snd_hda_codec_write_cache(codec, spec->ext_mic_pin, 0,
1059 AC_VERB_SET_UNSOLICITED_ENABLE,
1060 AC_USRSP_EN | ALC_MIC_EVENT);
1061 if (spec->dock_mic_pin)
1062 snd_hda_codec_write_cache(codec, spec->dock_mic_pin, 0,
1063 AC_VERB_SET_UNSOLICITED_ENABLE,
1064 AC_USRSP_EN | ALC_MIC_EVENT);
1066 spec->auto_mic_valid_imux = 1;
1072 * Check the availability of auto-mic switch;
1073 * Set up if really supported
1075 static void alc_init_auto_mic(struct hda_codec *codec)
1077 struct alc_spec *spec = codec->spec;
1078 struct auto_pin_cfg *cfg = &spec->autocfg;
1079 hda_nid_t fixed, ext, dock;
1082 spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1;
1084 fixed = ext = dock = 0;
1085 for (i = 0; i < cfg->num_inputs; i++) {
1086 hda_nid_t nid = cfg->inputs[i].pin;
1087 unsigned int defcfg;
1088 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1089 switch (snd_hda_get_input_pin_attr(defcfg)) {
1090 case INPUT_PIN_ATTR_INT:
1092 return; /* already occupied */
1093 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1094 return; /* invalid type */
1097 case INPUT_PIN_ATTR_UNUSED:
1098 return; /* invalid entry */
1099 case INPUT_PIN_ATTR_DOCK:
1101 return; /* already occupied */
1102 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
1103 return; /* invalid type */
1108 return; /* already occupied */
1109 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1110 return; /* invalid type */
1121 if (!is_jack_detectable(codec, ext))
1122 return; /* no unsol support */
1123 if (dock && !is_jack_detectable(codec, dock))
1124 return; /* no unsol support */
1126 /* check imux indices */
1127 spec->ext_mic_pin = ext;
1128 spec->int_mic_pin = fixed;
1129 spec->dock_mic_pin = dock;
1132 if (!alc_auto_mic_check_imux(codec))
1135 snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1137 spec->unsol_event = alc_sku_unsol_event;
1140 /* check the availabilities of auto-mute and auto-mic switches */
1141 static void alc_auto_check_switches(struct hda_codec *codec)
1143 alc_init_auto_hp(codec);
1144 alc_init_auto_mic(codec);
1148 * Realtek SSID verification
1151 /* Could be any non-zero and even value. When used as fixup, tells
1152 * the driver to ignore any present sku defines.
1154 #define ALC_FIXUP_SKU_IGNORE (2)
1156 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1158 unsigned int ass, tmp, i;
1160 struct alc_spec *spec = codec->spec;
1162 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1164 if (spec->cdefine.fixup) {
1165 ass = spec->cdefine.sku_cfg;
1166 if (ass == ALC_FIXUP_SKU_IGNORE)
1171 ass = codec->subsystem_id & 0xffff;
1172 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1176 if (codec->vendor_id == 0x10ec0260)
1178 ass = snd_hda_codec_get_pincfg(codec, nid);
1181 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1182 codec->chip_name, ass);
1188 for (i = 1; i < 16; i++) {
1192 if (((ass >> 16) & 0xf) != tmp)
1195 spec->cdefine.port_connectivity = ass >> 30;
1196 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1197 spec->cdefine.check_sum = (ass >> 16) & 0xf;
1198 spec->cdefine.customization = ass >> 8;
1200 spec->cdefine.sku_cfg = ass;
1201 spec->cdefine.external_amp = (ass & 0x38) >> 3;
1202 spec->cdefine.platform_type = (ass & 0x4) >> 2;
1203 spec->cdefine.swap = (ass & 0x2) >> 1;
1204 spec->cdefine.override = ass & 0x1;
1206 snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1207 nid, spec->cdefine.sku_cfg);
1208 snd_printd("SKU: port_connectivity=0x%x\n",
1209 spec->cdefine.port_connectivity);
1210 snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1211 snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1212 snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1213 snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1214 snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1215 snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1216 snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1221 /* return true if the given NID is found in the list */
1222 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1224 return find_idx_in_nid_list(nid, list, nums) >= 0;
1227 /* check subsystem ID and set up device-specific initialization;
1228 * return 1 if initialized, 0 if invalid SSID
1230 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1231 * 31 ~ 16 : Manufacture ID
1233 * 7 ~ 0 : Assembly ID
1234 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1236 static int alc_subsystem_id(struct hda_codec *codec,
1237 hda_nid_t porta, hda_nid_t porte,
1238 hda_nid_t portd, hda_nid_t porti)
1240 unsigned int ass, tmp, i;
1242 struct alc_spec *spec = codec->spec;
1244 if (spec->cdefine.fixup) {
1245 ass = spec->cdefine.sku_cfg;
1246 if (ass == ALC_FIXUP_SKU_IGNORE)
1251 ass = codec->subsystem_id & 0xffff;
1252 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1255 /* invalid SSID, check the special NID pin defcfg instead */
1257 * 31~30 : port connectivity
1260 * 19~16 : Check sum (15:1)
1265 if (codec->vendor_id == 0x10ec0260)
1267 ass = snd_hda_codec_get_pincfg(codec, nid);
1268 snd_printd("realtek: No valid SSID, "
1269 "checking pincfg 0x%08x for NID 0x%x\n",
1273 if ((ass >> 30) != 1) /* no physical connection */
1278 for (i = 1; i < 16; i++) {
1282 if (((ass >> 16) & 0xf) != tmp)
1285 snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1286 ass & 0xffff, codec->vendor_id);
1290 * 2 : 0 --> Desktop, 1 --> Laptop
1291 * 3~5 : External Amplifier control
1294 tmp = (ass & 0x38) >> 3; /* external Amp control */
1297 spec->init_amp = ALC_INIT_GPIO1;
1300 spec->init_amp = ALC_INIT_GPIO2;
1303 spec->init_amp = ALC_INIT_GPIO3;
1307 spec->init_amp = ALC_INIT_DEFAULT;
1311 /* is laptop or Desktop and enable the function "Mute internal speaker
1312 * when the external headphone out jack is plugged"
1314 if (!(ass & 0x8000))
1317 * 10~8 : Jack location
1318 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1320 * 15 : 1 --> enable the function "Mute internal speaker
1321 * when the external headphone out jack is plugged"
1323 if (!spec->autocfg.hp_pins[0]) {
1325 tmp = (ass >> 11) & 0x3; /* HP to chassis */
1336 if (found_in_nid_list(nid, spec->autocfg.line_out_pins,
1337 spec->autocfg.line_outs))
1339 spec->autocfg.hp_pins[0] = nid;
1344 /* Check the validity of ALC subsystem-id
1345 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
1346 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
1348 if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {
1349 struct alc_spec *spec = codec->spec;
1350 snd_printd("realtek: "
1351 "Enable default setup for auto mode as fallback\n");
1352 spec->init_amp = ALC_INIT_DEFAULT;
1357 * Fix-up pin default configurations and add default verbs
1365 struct alc_model_fixup {
1376 const struct alc_pincfg *pins;
1377 const struct hda_verb *verbs;
1378 void (*func)(struct hda_codec *codec,
1379 const struct alc_fixup *fix,
1393 ALC_FIXUP_ACT_PRE_PROBE,
1394 ALC_FIXUP_ACT_PROBE,
1398 static void alc_apply_fixup(struct hda_codec *codec, int action)
1400 struct alc_spec *spec = codec->spec;
1401 int id = spec->fixup_id;
1402 #ifdef CONFIG_SND_DEBUG_VERBOSE
1403 const char *modelname = spec->fixup_name;
1407 if (!spec->fixup_list)
1411 const struct alc_fixup *fix = spec->fixup_list + id;
1412 const struct alc_pincfg *cfg;
1414 switch (fix->type) {
1416 if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1418 snd_printdd(KERN_INFO "hda_codec: %s: "
1419 "Apply sku override for %s\n",
1420 codec->chip_name, modelname);
1421 spec->cdefine.sku_cfg = fix->v.sku;
1422 spec->cdefine.fixup = 1;
1424 case ALC_FIXUP_PINS:
1426 if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1428 snd_printdd(KERN_INFO "hda_codec: %s: "
1429 "Apply pincfg for %s\n",
1430 codec->chip_name, modelname);
1431 for (; cfg->nid; cfg++)
1432 snd_hda_codec_set_pincfg(codec, cfg->nid,
1435 case ALC_FIXUP_VERBS:
1436 if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1438 snd_printdd(KERN_INFO "hda_codec: %s: "
1439 "Apply fix-verbs for %s\n",
1440 codec->chip_name, modelname);
1441 add_verb(codec->spec, fix->v.verbs);
1443 case ALC_FIXUP_FUNC:
1446 snd_printdd(KERN_INFO "hda_codec: %s: "
1447 "Apply fix-func for %s\n",
1448 codec->chip_name, modelname);
1449 fix->v.func(codec, fix, action);
1452 snd_printk(KERN_ERR "hda_codec: %s: "
1453 "Invalid fixup type %d\n",
1454 codec->chip_name, fix->type);
1465 static void alc_pick_fixup(struct hda_codec *codec,
1466 const struct alc_model_fixup *models,
1467 const struct snd_pci_quirk *quirk,
1468 const struct alc_fixup *fixlist)
1470 struct alc_spec *spec = codec->spec;
1472 const char *name = NULL;
1474 if (codec->modelname && models) {
1475 while (models->name) {
1476 if (!strcmp(codec->modelname, models->name)) {
1478 name = models->name;
1485 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1488 #ifdef CONFIG_SND_DEBUG_VERBOSE
1494 spec->fixup_id = id;
1496 spec->fixup_list = fixlist;
1497 spec->fixup_name = name;
1502 * COEF access helper functions
1504 static int alc_read_coef_idx(struct hda_codec *codec,
1505 unsigned int coef_idx)
1508 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1510 val = snd_hda_codec_read(codec, 0x20, 0,
1511 AC_VERB_GET_PROC_COEF, 0);
1515 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1516 unsigned int coef_val)
1518 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1520 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1525 * Digital I/O handling
1528 /* set right pin controls for digital I/O */
1529 static void alc_auto_init_digital(struct hda_codec *codec)
1531 struct alc_spec *spec = codec->spec;
1535 for (i = 0; i < spec->autocfg.dig_outs; i++) {
1536 pin = spec->autocfg.dig_out_pins[i];
1539 snd_hda_codec_write(codec, pin, 0,
1540 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
1542 dac = spec->multiout.dig_out_nid;
1544 dac = spec->slave_dig_outs[i - 1];
1545 if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
1547 snd_hda_codec_write(codec, dac, 0,
1548 AC_VERB_SET_AMP_GAIN_MUTE,
1551 pin = spec->autocfg.dig_in_pin;
1553 snd_hda_codec_write(codec, pin, 0,
1554 AC_VERB_SET_PIN_WIDGET_CONTROL,
1558 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1559 static void alc_auto_parse_digital(struct hda_codec *codec)
1561 struct alc_spec *spec = codec->spec;
1565 /* support multiple SPDIFs; the secondary is set up as a slave */
1566 for (i = 0; i < spec->autocfg.dig_outs; i++) {
1568 err = snd_hda_get_connections(codec,
1569 spec->autocfg.dig_out_pins[i],
1570 conn, ARRAY_SIZE(conn));
1573 dig_nid = conn[0]; /* assume the first element is audio-out */
1575 spec->multiout.dig_out_nid = dig_nid;
1576 spec->dig_out_type = spec->autocfg.dig_out_type[0];
1578 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1579 if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1581 spec->slave_dig_outs[i - 1] = dig_nid;
1585 if (spec->autocfg.dig_in_pin) {
1586 dig_nid = codec->start_nid;
1587 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1588 unsigned int wcaps = get_wcaps(codec, dig_nid);
1589 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1591 if (!(wcaps & AC_WCAP_DIGITAL))
1593 if (!(wcaps & AC_WCAP_CONN_LIST))
1595 err = get_connection_index(codec, dig_nid,
1596 spec->autocfg.dig_in_pin);
1598 spec->dig_in_nid = dig_nid;
1606 * capture mixer elements
1608 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1609 struct snd_ctl_elem_info *uinfo)
1611 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1612 struct alc_spec *spec = codec->spec;
1616 mutex_lock(&codec->control_mutex);
1617 if (spec->vol_in_capsrc)
1618 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1620 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1621 kcontrol->private_value = val;
1622 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1623 mutex_unlock(&codec->control_mutex);
1627 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1628 unsigned int size, unsigned int __user *tlv)
1630 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1631 struct alc_spec *spec = codec->spec;
1635 mutex_lock(&codec->control_mutex);
1636 if (spec->vol_in_capsrc)
1637 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1639 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1640 kcontrol->private_value = val;
1641 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1642 mutex_unlock(&codec->control_mutex);
1646 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1647 struct snd_ctl_elem_value *ucontrol);
1649 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1650 struct snd_ctl_elem_value *ucontrol,
1651 getput_call_t func, bool check_adc_switch)
1653 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1654 struct alc_spec *spec = codec->spec;
1657 mutex_lock(&codec->control_mutex);
1658 if (check_adc_switch && spec->dyn_adc_switch) {
1659 for (i = 0; i < spec->num_adc_nids; i++) {
1660 kcontrol->private_value =
1661 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1663 err = func(kcontrol, ucontrol);
1668 i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1669 if (spec->vol_in_capsrc)
1670 kcontrol->private_value =
1671 HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i],
1674 kcontrol->private_value =
1675 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1677 err = func(kcontrol, ucontrol);
1680 mutex_unlock(&codec->control_mutex);
1684 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1685 struct snd_ctl_elem_value *ucontrol)
1687 return alc_cap_getput_caller(kcontrol, ucontrol,
1688 snd_hda_mixer_amp_volume_get, false);
1691 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1692 struct snd_ctl_elem_value *ucontrol)
1694 return alc_cap_getput_caller(kcontrol, ucontrol,
1695 snd_hda_mixer_amp_volume_put, true);
1698 /* capture mixer elements */
1699 #define alc_cap_sw_info snd_ctl_boolean_stereo_info
1701 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1702 struct snd_ctl_elem_value *ucontrol)
1704 return alc_cap_getput_caller(kcontrol, ucontrol,
1705 snd_hda_mixer_amp_switch_get, false);
1708 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1709 struct snd_ctl_elem_value *ucontrol)
1711 return alc_cap_getput_caller(kcontrol, ucontrol,
1712 snd_hda_mixer_amp_switch_put, true);
1715 #define _DEFINE_CAPMIX(num) \
1717 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1718 .name = "Capture Switch", \
1719 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1721 .info = alc_cap_sw_info, \
1722 .get = alc_cap_sw_get, \
1723 .put = alc_cap_sw_put, \
1726 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1727 .name = "Capture Volume", \
1728 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1729 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1730 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1732 .info = alc_cap_vol_info, \
1733 .get = alc_cap_vol_get, \
1734 .put = alc_cap_vol_put, \
1735 .tlv = { .c = alc_cap_vol_tlv }, \
1738 #define _DEFINE_CAPSRC(num) \
1740 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1741 /* .name = "Capture Source", */ \
1742 .name = "Input Source", \
1744 .info = alc_mux_enum_info, \
1745 .get = alc_mux_enum_get, \
1746 .put = alc_mux_enum_put, \
1749 #define DEFINE_CAPMIX(num) \
1750 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1751 _DEFINE_CAPMIX(num), \
1752 _DEFINE_CAPSRC(num), \
1756 #define DEFINE_CAPMIX_NOSRC(num) \
1757 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1758 _DEFINE_CAPMIX(num), \
1762 /* up to three ADCs */
1766 DEFINE_CAPMIX_NOSRC(1);
1767 DEFINE_CAPMIX_NOSRC(2);
1768 DEFINE_CAPMIX_NOSRC(3);
1771 * virtual master controls
1775 * slave controls for virtual master
1777 static const char * const alc_slave_vols[] = {
1778 "Front Playback Volume",
1779 "Surround Playback Volume",
1780 "Center Playback Volume",
1781 "LFE Playback Volume",
1782 "Side Playback Volume",
1783 "Headphone Playback Volume",
1784 "Speaker Playback Volume",
1785 "Mono Playback Volume",
1786 "Line-Out Playback Volume",
1787 "PCM Playback Volume",
1791 static const char * const alc_slave_sws[] = {
1792 "Front Playback Switch",
1793 "Surround Playback Switch",
1794 "Center Playback Switch",
1795 "LFE Playback Switch",
1796 "Side Playback Switch",
1797 "Headphone Playback Switch",
1798 "Speaker Playback Switch",
1799 "Mono Playback Switch",
1800 "IEC958 Playback Switch",
1801 "Line-Out Playback Switch",
1802 "PCM Playback Switch",
1807 * build control elements
1810 #define NID_MAPPING (-1)
1812 #define SUBDEV_SPEAKER_ (0 << 6)
1813 #define SUBDEV_HP_ (1 << 6)
1814 #define SUBDEV_LINE_ (2 << 6)
1815 #define SUBDEV_SPEAKER(x) (SUBDEV_SPEAKER_ | ((x) & 0x3f))
1816 #define SUBDEV_HP(x) (SUBDEV_HP_ | ((x) & 0x3f))
1817 #define SUBDEV_LINE(x) (SUBDEV_LINE_ | ((x) & 0x3f))
1819 static void alc_free_kctls(struct hda_codec *codec);
1821 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1822 /* additional beep mixers; the actual parameters are overwritten at build */
1823 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1824 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1825 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1830 static int alc_build_controls(struct hda_codec *codec)
1832 struct alc_spec *spec = codec->spec;
1833 struct snd_kcontrol *kctl = NULL;
1834 const struct snd_kcontrol_new *knew;
1839 for (i = 0; i < spec->num_mixers; i++) {
1840 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1844 if (spec->cap_mixer) {
1845 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
1849 if (spec->multiout.dig_out_nid) {
1850 err = snd_hda_create_spdif_out_ctls(codec,
1851 spec->multiout.dig_out_nid,
1852 spec->multiout.dig_out_nid);
1855 if (!spec->no_analog) {
1856 err = snd_hda_create_spdif_share_sw(codec,
1860 spec->multiout.share_spdif = 1;
1863 if (spec->dig_in_nid) {
1864 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1869 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1870 /* create beep controls if needed */
1871 if (spec->beep_amp) {
1872 const struct snd_kcontrol_new *knew;
1873 for (knew = alc_beep_mixer; knew->name; knew++) {
1874 struct snd_kcontrol *kctl;
1875 kctl = snd_ctl_new1(knew, codec);
1878 kctl->private_value = spec->beep_amp;
1879 err = snd_hda_ctl_add(codec, 0, kctl);
1886 /* if we have no master control, let's create it */
1887 if (!spec->no_analog &&
1888 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1889 unsigned int vmaster_tlv[4];
1890 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1891 HDA_OUTPUT, vmaster_tlv);
1892 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1893 vmaster_tlv, alc_slave_vols);
1897 if (!spec->no_analog &&
1898 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1899 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1900 NULL, alc_slave_sws);
1905 /* assign Capture Source enums to NID */
1906 if (spec->capsrc_nids || spec->adc_nids) {
1907 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
1909 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1910 for (i = 0; kctl && i < kctl->count; i++) {
1911 const hda_nid_t *nids = spec->capsrc_nids;
1913 nids = spec->adc_nids;
1914 err = snd_hda_add_nid(codec, kctl, i, nids[i]);
1919 if (spec->cap_mixer && spec->adc_nids) {
1920 const char *kname = kctl ? kctl->id.name : NULL;
1921 for (knew = spec->cap_mixer; knew->name; knew++) {
1922 if (kname && strcmp(knew->name, kname) == 0)
1924 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
1925 for (i = 0; kctl && i < kctl->count; i++) {
1926 err = snd_hda_add_nid(codec, kctl, i,
1934 /* other nid->control mapping */
1935 for (i = 0; i < spec->num_mixers; i++) {
1936 for (knew = spec->mixers[i]; knew->name; knew++) {
1937 if (knew->iface != NID_MAPPING)
1939 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
1942 u = knew->subdevice;
1943 for (j = 0; j < 4; j++, u >>= 8) {
1948 case SUBDEV_SPEAKER_:
1949 nid = spec->autocfg.speaker_pins[nid];
1952 nid = spec->autocfg.line_out_pins[nid];
1955 nid = spec->autocfg.hp_pins[nid];
1960 err = snd_hda_add_nid(codec, kctl, 0, nid);
1964 u = knew->private_value;
1965 for (j = 0; j < 4; j++, u >>= 8) {
1969 err = snd_hda_add_nid(codec, kctl, 0, nid);
1976 alc_free_kctls(codec); /* no longer needed */
1986 static void alc_init_special_input_src(struct hda_codec *codec);
1988 static int alc_init(struct hda_codec *codec)
1990 struct alc_spec *spec = codec->spec;
1994 alc_auto_init_amp(codec, spec->init_amp);
1996 for (i = 0; i < spec->num_init_verbs; i++)
1997 snd_hda_sequence_write(codec, spec->init_verbs[i]);
1998 alc_init_special_input_src(codec);
2000 if (spec->init_hook)
2001 spec->init_hook(codec);
2003 alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
2005 hda_call_check_power_status(codec, 0x01);
2009 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2011 struct alc_spec *spec = codec->spec;
2013 if (spec->unsol_event)
2014 spec->unsol_event(codec, res);
2017 #ifdef CONFIG_SND_HDA_POWER_SAVE
2018 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2020 struct alc_spec *spec = codec->spec;
2021 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2026 * Analog playback callbacks
2028 static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo,
2029 struct hda_codec *codec,
2030 struct snd_pcm_substream *substream)
2032 struct alc_spec *spec = codec->spec;
2033 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2037 static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2038 struct hda_codec *codec,
2039 unsigned int stream_tag,
2040 unsigned int format,
2041 struct snd_pcm_substream *substream)
2043 struct alc_spec *spec = codec->spec;
2044 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2045 stream_tag, format, substream);
2048 static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2049 struct hda_codec *codec,
2050 struct snd_pcm_substream *substream)
2052 struct alc_spec *spec = codec->spec;
2053 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2059 static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2060 struct hda_codec *codec,
2061 struct snd_pcm_substream *substream)
2063 struct alc_spec *spec = codec->spec;
2064 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2067 static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2068 struct hda_codec *codec,
2069 unsigned int stream_tag,
2070 unsigned int format,
2071 struct snd_pcm_substream *substream)
2073 struct alc_spec *spec = codec->spec;
2074 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2075 stream_tag, format, substream);
2078 static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2079 struct hda_codec *codec,
2080 struct snd_pcm_substream *substream)
2082 struct alc_spec *spec = codec->spec;
2083 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2086 static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2087 struct hda_codec *codec,
2088 struct snd_pcm_substream *substream)
2090 struct alc_spec *spec = codec->spec;
2091 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2097 static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2098 struct hda_codec *codec,
2099 unsigned int stream_tag,
2100 unsigned int format,
2101 struct snd_pcm_substream *substream)
2103 struct alc_spec *spec = codec->spec;
2105 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2106 stream_tag, 0, format);
2110 static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2111 struct hda_codec *codec,
2112 struct snd_pcm_substream *substream)
2114 struct alc_spec *spec = codec->spec;
2116 snd_hda_codec_cleanup_stream(codec,
2117 spec->adc_nids[substream->number + 1]);
2121 /* analog capture with dynamic dual-adc changes */
2122 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2123 struct hda_codec *codec,
2124 unsigned int stream_tag,
2125 unsigned int format,
2126 struct snd_pcm_substream *substream)
2128 struct alc_spec *spec = codec->spec;
2129 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
2130 spec->cur_adc_stream_tag = stream_tag;
2131 spec->cur_adc_format = format;
2132 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
2136 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2137 struct hda_codec *codec,
2138 struct snd_pcm_substream *substream)
2140 struct alc_spec *spec = codec->spec;
2141 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
2146 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
2150 .nid = 0, /* fill later */
2152 .prepare = dyn_adc_capture_pcm_prepare,
2153 .cleanup = dyn_adc_capture_pcm_cleanup
2159 static const struct hda_pcm_stream alc_pcm_analog_playback = {
2163 /* NID is set in alc_build_pcms */
2165 .open = alc_playback_pcm_open,
2166 .prepare = alc_playback_pcm_prepare,
2167 .cleanup = alc_playback_pcm_cleanup
2171 static const struct hda_pcm_stream alc_pcm_analog_capture = {
2175 /* NID is set in alc_build_pcms */
2178 static const struct hda_pcm_stream alc_pcm_analog_alt_playback = {
2182 /* NID is set in alc_build_pcms */
2185 static const struct hda_pcm_stream alc_pcm_analog_alt_capture = {
2186 .substreams = 2, /* can be overridden */
2189 /* NID is set in alc_build_pcms */
2191 .prepare = alc_alt_capture_pcm_prepare,
2192 .cleanup = alc_alt_capture_pcm_cleanup
2196 static const struct hda_pcm_stream alc_pcm_digital_playback = {
2200 /* NID is set in alc_build_pcms */
2202 .open = alc_dig_playback_pcm_open,
2203 .close = alc_dig_playback_pcm_close,
2204 .prepare = alc_dig_playback_pcm_prepare,
2205 .cleanup = alc_dig_playback_pcm_cleanup
2209 static const struct hda_pcm_stream alc_pcm_digital_capture = {
2213 /* NID is set in alc_build_pcms */
2216 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2217 static const struct hda_pcm_stream alc_pcm_null_stream = {
2223 static int alc_build_pcms(struct hda_codec *codec)
2225 struct alc_spec *spec = codec->spec;
2226 struct hda_pcm *info = spec->pcm_rec;
2227 const struct hda_pcm_stream *p;
2230 codec->num_pcms = 1;
2231 codec->pcm_info = info;
2233 if (spec->no_analog)
2236 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
2237 "%s Analog", codec->chip_name);
2238 info->name = spec->stream_name_analog;
2240 if (spec->multiout.dac_nids > 0) {
2241 p = spec->stream_analog_playback;
2243 p = &alc_pcm_analog_playback;
2244 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2245 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2247 if (spec->adc_nids) {
2248 p = spec->stream_analog_capture;
2250 if (spec->dyn_adc_switch)
2251 p = &dyn_adc_pcm_analog_capture;
2253 p = &alc_pcm_analog_capture;
2255 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2256 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2259 if (spec->channel_mode) {
2260 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2261 for (i = 0; i < spec->num_channel_mode; i++) {
2262 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2263 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2269 /* SPDIF for stream index #1 */
2270 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2271 snprintf(spec->stream_name_digital,
2272 sizeof(spec->stream_name_digital),
2273 "%s Digital", codec->chip_name);
2274 codec->num_pcms = 2;
2275 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
2276 info = spec->pcm_rec + 1;
2277 info->name = spec->stream_name_digital;
2278 if (spec->dig_out_type)
2279 info->pcm_type = spec->dig_out_type;
2281 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2282 if (spec->multiout.dig_out_nid) {
2283 p = spec->stream_digital_playback;
2285 p = &alc_pcm_digital_playback;
2286 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2287 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2289 if (spec->dig_in_nid) {
2290 p = spec->stream_digital_capture;
2292 p = &alc_pcm_digital_capture;
2293 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2294 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2296 /* FIXME: do we need this for all Realtek codec models? */
2297 codec->spdif_status_reset = 1;
2300 if (spec->no_analog)
2303 /* If the use of more than one ADC is requested for the current
2304 * model, configure a second analog capture-only PCM.
2306 /* Additional Analaog capture for index #2 */
2307 if (spec->alt_dac_nid || spec->num_adc_nids > 1) {
2308 codec->num_pcms = 3;
2309 info = spec->pcm_rec + 2;
2310 info->name = spec->stream_name_analog;
2311 if (spec->alt_dac_nid) {
2312 p = spec->stream_analog_alt_playback;
2314 p = &alc_pcm_analog_alt_playback;
2315 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2316 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2319 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2320 alc_pcm_null_stream;
2321 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2323 if (spec->num_adc_nids > 1) {
2324 p = spec->stream_analog_alt_capture;
2326 p = &alc_pcm_analog_alt_capture;
2327 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2328 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2330 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2331 spec->num_adc_nids - 1;
2333 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2334 alc_pcm_null_stream;
2335 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2342 static inline void alc_shutup(struct hda_codec *codec)
2344 struct alc_spec *spec = codec->spec;
2346 if (spec && spec->shutup)
2347 spec->shutup(codec);
2348 snd_hda_shutup_pins(codec);
2351 static void alc_free_kctls(struct hda_codec *codec)
2353 struct alc_spec *spec = codec->spec;
2355 if (spec->kctls.list) {
2356 struct snd_kcontrol_new *kctl = spec->kctls.list;
2358 for (i = 0; i < spec->kctls.used; i++)
2359 kfree(kctl[i].name);
2361 snd_array_free(&spec->kctls);
2364 static void alc_free(struct hda_codec *codec)
2366 struct alc_spec *spec = codec->spec;
2372 snd_hda_input_jack_free(codec);
2373 alc_free_kctls(codec);
2375 snd_hda_detach_beep_device(codec);
2378 #ifdef CONFIG_SND_HDA_POWER_SAVE
2379 static void alc_power_eapd(struct hda_codec *codec)
2381 alc_auto_setup_eapd(codec, false);
2384 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
2386 struct alc_spec *spec = codec->spec;
2388 if (spec && spec->power_hook)
2389 spec->power_hook(codec);
2395 static int alc_resume(struct hda_codec *codec)
2397 msleep(150); /* to avoid pop noise */
2398 codec->patch_ops.init(codec);
2399 snd_hda_codec_resume_amp(codec);
2400 snd_hda_codec_resume_cache(codec);
2401 hda_call_check_power_status(codec, 0x01);
2408 static const struct hda_codec_ops alc_patch_ops = {
2409 .build_controls = alc_build_controls,
2410 .build_pcms = alc_build_pcms,
2413 .unsol_event = alc_unsol_event,
2415 .resume = alc_resume,
2417 #ifdef CONFIG_SND_HDA_POWER_SAVE
2418 .suspend = alc_suspend,
2419 .check_power_status = alc_check_power_status,
2421 .reboot_notify = alc_shutup,
2424 /* replace the codec chip_name with the given string */
2425 static int alc_codec_rename(struct hda_codec *codec, const char *name)
2427 kfree(codec->chip_name);
2428 codec->chip_name = kstrdup(name, GFP_KERNEL);
2429 if (!codec->chip_name) {
2437 * Automatic parse of I/O pins from the BIOS configuration
2442 ALC_CTL_WIDGET_MUTE,
2445 static const struct snd_kcontrol_new alc_control_templates[] = {
2446 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2447 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2448 HDA_BIND_MUTE(NULL, 0, 0, 0),
2451 /* add dynamic controls */
2452 static int add_control(struct alc_spec *spec, int type, const char *name,
2453 int cidx, unsigned long val)
2455 struct snd_kcontrol_new *knew;
2457 knew = alc_kcontrol_new(spec);
2460 *knew = alc_control_templates[type];
2461 knew->name = kstrdup(name, GFP_KERNEL);
2465 if (get_amp_nid_(val))
2466 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2467 knew->private_value = val;
2471 static int add_control_with_pfx(struct alc_spec *spec, int type,
2472 const char *pfx, const char *dir,
2473 const char *sfx, int cidx, unsigned long val)
2476 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
2477 return add_control(spec, type, name, cidx, val);
2480 #define add_pb_vol_ctrl(spec, type, pfx, val) \
2481 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
2482 #define add_pb_sw_ctrl(spec, type, pfx, val) \
2483 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
2484 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
2485 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
2486 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
2487 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
2489 static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch,
2490 bool can_be_master, int *index)
2492 struct auto_pin_cfg *cfg = &spec->autocfg;
2493 static const char * const chname[4] = {
2494 "Front", "Surround", NULL /*CLFE*/, "Side"
2498 if (cfg->line_outs == 1 && !spec->multi_ios &&
2499 !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
2502 switch (cfg->line_out_type) {
2503 case AUTO_PIN_SPEAKER_OUT:
2504 if (cfg->line_outs == 1)
2507 case AUTO_PIN_HP_OUT:
2508 /* for multi-io case, only the primary out */
2509 if (ch && spec->multi_ios)
2514 if (cfg->line_outs == 1 && !spec->multi_ios)
2521 /* create input playback/capture controls for the given pin */
2522 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
2523 const char *ctlname, int ctlidx,
2524 int idx, hda_nid_t mix_nid)
2528 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
2529 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2532 err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
2533 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2539 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2541 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2542 return (pincap & AC_PINCAP_IN) != 0;
2545 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
2546 static int alc_auto_fill_adc_caps(struct hda_codec *codec)
2548 struct alc_spec *spec = codec->spec;
2550 hda_nid_t *adc_nids = spec->private_adc_nids;
2551 hda_nid_t *cap_nids = spec->private_capsrc_nids;
2552 int max_nums = ARRAY_SIZE(spec->private_adc_nids);
2553 bool indep_capsrc = false;
2556 nid = codec->start_nid;
2557 for (i = 0; i < codec->num_nodes; i++, nid++) {
2559 const hda_nid_t *list;
2560 unsigned int caps = get_wcaps(codec, nid);
2561 int type = get_wcaps_type(caps);
2563 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2565 adc_nids[nums] = nid;
2566 cap_nids[nums] = nid;
2570 type = get_wcaps_type(get_wcaps(codec, src));
2571 if (type == AC_WID_PIN)
2573 if (type == AC_WID_AUD_SEL) {
2574 cap_nids[nums] = src;
2575 indep_capsrc = true;
2578 n = snd_hda_get_conn_list(codec, src, &list);
2580 cap_nids[nums] = src;
2581 indep_capsrc = true;
2587 if (++nums >= max_nums)
2590 spec->adc_nids = spec->private_adc_nids;
2591 spec->capsrc_nids = spec->private_capsrc_nids;
2592 spec->num_adc_nids = nums;
2596 /* create playback/capture controls for input pins */
2597 static int alc_auto_create_input_ctls(struct hda_codec *codec)
2599 struct alc_spec *spec = codec->spec;
2600 const struct auto_pin_cfg *cfg = &spec->autocfg;
2601 hda_nid_t mixer = spec->mixer_nid;
2602 struct hda_input_mux *imux = &spec->private_imux[0];
2604 int i, c, err, idx, type_idx = 0;
2605 const char *prev_label = NULL;
2607 num_adcs = alc_auto_fill_adc_caps(codec);
2611 for (i = 0; i < cfg->num_inputs; i++) {
2615 pin = cfg->inputs[i].pin;
2616 if (!alc_is_input_pin(codec, pin))
2619 label = hda_get_autocfg_input_label(codec, cfg, i);
2620 if (prev_label && !strcmp(label, prev_label))
2627 idx = get_connection_index(codec, mixer, pin);
2629 err = new_analog_input(spec, pin,
2637 for (c = 0; c < num_adcs; c++) {
2638 hda_nid_t cap = spec->capsrc_nids ?
2639 spec->capsrc_nids[c] : spec->adc_nids[c];
2640 idx = get_connection_index(codec, cap, pin);
2642 spec->imux_pins[imux->num_items] = pin;
2643 snd_hda_add_imux_item(imux, label, idx, NULL);
2649 spec->num_mux_defs = 1;
2650 spec->input_mux = imux;
2655 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
2656 unsigned int pin_type)
2658 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2661 if (nid_has_mute(codec, nid, HDA_OUTPUT))
2662 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2666 static int get_pin_type(int line_out_type)
2668 if (line_out_type == AUTO_PIN_HP_OUT)
2674 static void alc_auto_init_analog_input(struct hda_codec *codec)
2676 struct alc_spec *spec = codec->spec;
2677 struct auto_pin_cfg *cfg = &spec->autocfg;
2680 for (i = 0; i < cfg->num_inputs; i++) {
2681 hda_nid_t nid = cfg->inputs[i].pin;
2682 if (alc_is_input_pin(codec, nid)) {
2683 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
2684 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
2685 snd_hda_codec_write(codec, nid, 0,
2686 AC_VERB_SET_AMP_GAIN_MUTE,
2691 /* mute all loopback inputs */
2692 if (spec->mixer_nid) {
2693 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL);
2694 for (i = 0; i < nums; i++)
2695 snd_hda_codec_write(codec, spec->mixer_nid, 0,
2696 AC_VERB_SET_AMP_GAIN_MUTE,
2701 /* convert from MIX nid to DAC */
2702 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
2707 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT)
2709 num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
2710 for (i = 0; i < num; i++) {
2711 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
2717 /* go down to the selector widget before the mixer */
2718 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
2721 int num = snd_hda_get_connections(codec, pin, srcs,
2724 get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
2729 /* get MIX nid connected to the given pin targeted to DAC */
2730 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
2736 pin = alc_go_down_to_selector(codec, pin);
2737 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2738 for (i = 0; i < num; i++) {
2739 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
2745 /* select the connection from pin to DAC if needed */
2746 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
2752 pin = alc_go_down_to_selector(codec, pin);
2753 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2756 for (i = 0; i < num; i++) {
2757 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
2758 snd_hda_codec_update_cache(codec, pin, 0,
2759 AC_VERB_SET_CONNECT_SEL, i);
2766 /* look for an empty DAC slot */
2767 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
2769 struct alc_spec *spec = codec->spec;
2773 pin = alc_go_down_to_selector(codec, pin);
2774 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2775 for (i = 0; i < num; i++) {
2776 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2779 if (found_in_nid_list(nid, spec->multiout.dac_nids,
2780 spec->multiout.num_dacs))
2782 if (spec->multiout.hp_nid == nid)
2784 if (found_in_nid_list(nid, spec->multiout.extra_out_nid,
2785 ARRAY_SIZE(spec->multiout.extra_out_nid)))
2792 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
2794 hda_nid_t sel = alc_go_down_to_selector(codec, pin);
2795 if (snd_hda_get_conn_list(codec, sel, NULL) == 1)
2796 return alc_auto_look_for_dac(codec, pin);
2800 /* fill in the dac_nids table from the parsed pin configuration */
2801 static int alc_auto_fill_dac_nids(struct hda_codec *codec)
2803 struct alc_spec *spec = codec->spec;
2804 const struct auto_pin_cfg *cfg = &spec->autocfg;
2805 bool redone = false;
2809 /* set num_dacs once to full for alc_auto_look_for_dac() */
2810 spec->multiout.num_dacs = cfg->line_outs;
2811 spec->multiout.hp_nid = 0;
2812 spec->multiout.extra_out_nid[0] = 0;
2813 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
2814 spec->multiout.dac_nids = spec->private_dac_nids;
2816 /* fill hard-wired DACs first */
2818 for (i = 0; i < cfg->line_outs; i++)
2819 spec->private_dac_nids[i] =
2820 get_dac_if_single(codec, cfg->line_out_pins[i]);
2822 spec->multiout.hp_nid =
2823 get_dac_if_single(codec, cfg->hp_pins[0]);
2824 if (cfg->speaker_outs)
2825 spec->multiout.extra_out_nid[0] =
2826 get_dac_if_single(codec, cfg->speaker_pins[0]);
2829 for (i = 0; i < cfg->line_outs; i++) {
2830 hda_nid_t pin = cfg->line_out_pins[i];
2831 if (spec->private_dac_nids[i])
2833 spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin);
2834 if (!spec->private_dac_nids[i] && !redone) {
2835 /* if we can't find primary DACs, re-probe without
2836 * checking the hard-wired DACs
2843 /* re-count num_dacs and squash invalid entries */
2844 spec->multiout.num_dacs = 0;
2845 for (i = 0; i < cfg->line_outs; i++) {
2846 if (spec->private_dac_nids[i])
2847 spec->multiout.num_dacs++;
2849 memmove(spec->private_dac_nids + i,
2850 spec->private_dac_nids + i + 1,
2851 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
2854 if (cfg->hp_outs && !spec->multiout.hp_nid)
2855 spec->multiout.hp_nid =
2856 alc_auto_look_for_dac(codec, cfg->hp_pins[0]);
2857 if (cfg->speaker_outs && !spec->multiout.extra_out_nid[0])
2858 spec->multiout.extra_out_nid[0] =
2859 alc_auto_look_for_dac(codec, cfg->speaker_pins[0]);
2864 static int alc_auto_add_vol_ctl(struct hda_codec *codec,
2865 const char *pfx, int cidx,
2866 hda_nid_t nid, unsigned int chs)
2870 return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx,
2871 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2874 #define alc_auto_add_stereo_vol(codec, pfx, cidx, nid) \
2875 alc_auto_add_vol_ctl(codec, pfx, cidx, nid, 3)
2877 /* create a mute-switch for the given mixer widget;
2878 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
2880 static int alc_auto_add_sw_ctl(struct hda_codec *codec,
2881 const char *pfx, int cidx,
2882 hda_nid_t nid, unsigned int chs)
2889 wid_type = get_wcaps_type(get_wcaps(codec, nid));
2890 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) {
2891 type = ALC_CTL_WIDGET_MUTE;
2892 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
2893 } else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) {
2894 type = ALC_CTL_WIDGET_MUTE;
2895 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT);
2897 type = ALC_CTL_BIND_MUTE;
2898 val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT);
2900 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
2903 #define alc_auto_add_stereo_sw(codec, pfx, cidx, nid) \
2904 alc_auto_add_sw_ctl(codec, pfx, cidx, nid, 3)
2906 static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec,
2907 hda_nid_t pin, hda_nid_t dac)
2909 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
2910 if (nid_has_mute(codec, pin, HDA_OUTPUT))
2912 else if (mix && nid_has_mute(codec, mix, HDA_INPUT))
2914 else if (nid_has_mute(codec, dac, HDA_OUTPUT))
2919 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
2920 hda_nid_t pin, hda_nid_t dac)
2922 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
2923 if (nid_has_volume(codec, dac, HDA_OUTPUT))
2925 else if (nid_has_volume(codec, mix, HDA_OUTPUT))
2927 else if (nid_has_volume(codec, pin, HDA_OUTPUT))
2932 /* add playback controls from the parsed DAC table */
2933 static int alc_auto_create_multi_out_ctls(struct hda_codec *codec,
2934 const struct auto_pin_cfg *cfg)
2936 struct alc_spec *spec = codec->spec;
2937 int i, err, noutputs;
2939 noutputs = cfg->line_outs;
2940 if (spec->multi_ios > 0)
2941 noutputs += spec->multi_ios;
2943 for (i = 0; i < noutputs; i++) {
2949 dac = spec->multiout.dac_nids[i];
2952 if (i >= cfg->line_outs)
2953 pin = spec->multi_io[i - 1].pin;
2955 pin = cfg->line_out_pins[i];
2957 sw = alc_look_for_out_mute_nid(codec, pin, dac);
2958 vol = alc_look_for_out_vol_nid(codec, pin, dac);
2959 name = alc_get_line_out_pfx(spec, i, true, &index);
2962 err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1);
2965 err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2);
2968 err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1);
2971 err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2);
2975 err = alc_auto_add_stereo_vol(codec, name, index, vol);
2978 err = alc_auto_add_stereo_sw(codec, name, index, sw);
2986 /* add playback controls for speaker and HP outputs */
2987 static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
2988 hda_nid_t dac, const char *pfx)
2990 struct alc_spec *spec = codec->spec;
2997 /* the corresponding DAC is already occupied */
2998 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
2999 return 0; /* no way */
3000 /* create a switch only */
3001 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
3002 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3005 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3006 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3007 err = alc_auto_add_stereo_vol(codec, pfx, 0, vol);
3010 err = alc_auto_add_stereo_sw(codec, pfx, 0, sw);
3016 static int alc_auto_create_hp_out(struct hda_codec *codec)
3018 struct alc_spec *spec = codec->spec;
3019 return alc_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
3020 spec->multiout.hp_nid,
3024 static int alc_auto_create_speaker_out(struct hda_codec *codec)
3026 struct alc_spec *spec = codec->spec;
3027 return alc_auto_create_extra_out(codec, spec->autocfg.speaker_pins[0],
3028 spec->multiout.extra_out_nid[0],
3032 static void alc_auto_set_output_and_unmute(struct hda_codec *codec,
3033 hda_nid_t pin, int pin_type,
3037 hda_nid_t nid, mix = 0;
3038 hda_nid_t srcs[HDA_MAX_CONNECTIONS];
3040 alc_set_pin_output(codec, pin, pin_type);
3041 nid = alc_go_down_to_selector(codec, pin);
3042 num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
3043 for (i = 0; i < num; i++) {
3044 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
3052 /* need the manual connection? */
3054 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
3055 /* unmute mixer widget inputs */
3056 if (nid_has_mute(codec, mix, HDA_INPUT)) {
3057 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3059 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3062 /* initialize volume */
3063 nid = alc_look_for_out_vol_nid(codec, pin, dac);
3065 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3069 static void alc_auto_init_multi_out(struct hda_codec *codec)
3071 struct alc_spec *spec = codec->spec;
3072 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3075 for (i = 0; i <= HDA_SIDE; i++) {
3076 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3078 alc_auto_set_output_and_unmute(codec, nid, pin_type,
3079 spec->multiout.dac_nids[i]);
3083 static void alc_auto_init_extra_out(struct hda_codec *codec)
3085 struct alc_spec *spec = codec->spec;
3088 pin = spec->autocfg.hp_pins[0];
3090 alc_auto_set_output_and_unmute(codec, pin, PIN_HP,
3091 spec->multiout.hp_nid);
3092 pin = spec->autocfg.speaker_pins[0];
3094 alc_auto_set_output_and_unmute(codec, pin, PIN_OUT,
3095 spec->multiout.extra_out_nid[0]);
3101 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
3102 unsigned int location)
3104 struct alc_spec *spec = codec->spec;
3105 struct auto_pin_cfg *cfg = &spec->autocfg;
3106 int type, i, num_pins = 0;
3108 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
3109 for (i = 0; i < cfg->num_inputs; i++) {
3110 hda_nid_t nid = cfg->inputs[i].pin;
3112 unsigned int defcfg, caps;
3113 if (cfg->inputs[i].type != type)
3115 defcfg = snd_hda_codec_get_pincfg(codec, nid);
3116 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
3118 if (location && get_defcfg_location(defcfg) != location)
3120 caps = snd_hda_query_pin_caps(codec, nid);
3121 if (!(caps & AC_PINCAP_OUT))
3123 dac = alc_auto_look_for_dac(codec, nid);
3126 spec->multi_io[num_pins].pin = nid;
3127 spec->multi_io[num_pins].dac = dac;
3129 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
3132 spec->multiout.num_dacs = 1;
3138 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
3139 struct snd_ctl_elem_info *uinfo)
3141 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3142 struct alc_spec *spec = codec->spec;
3144 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3146 uinfo->value.enumerated.items = spec->multi_ios + 1;
3147 if (uinfo->value.enumerated.item > spec->multi_ios)
3148 uinfo->value.enumerated.item = spec->multi_ios;
3149 sprintf(uinfo->value.enumerated.name, "%dch",
3150 (uinfo->value.enumerated.item + 1) * 2);
3154 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
3155 struct snd_ctl_elem_value *ucontrol)
3157 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3158 struct alc_spec *spec = codec->spec;
3159 ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
3163 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
3165 struct alc_spec *spec = codec->spec;
3166 hda_nid_t nid = spec->multi_io[idx].pin;
3168 if (!spec->multi_io[idx].ctl_in)
3169 spec->multi_io[idx].ctl_in =
3170 snd_hda_codec_read(codec, nid, 0,
3171 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3173 snd_hda_codec_update_cache(codec, nid, 0,
3174 AC_VERB_SET_PIN_WIDGET_CONTROL,
3176 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3177 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3179 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
3181 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3182 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3183 HDA_AMP_MUTE, HDA_AMP_MUTE);
3184 snd_hda_codec_update_cache(codec, nid, 0,
3185 AC_VERB_SET_PIN_WIDGET_CONTROL,
3186 spec->multi_io[idx].ctl_in);
3191 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
3192 struct snd_ctl_elem_value *ucontrol)
3194 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3195 struct alc_spec *spec = codec->spec;
3198 ch = ucontrol->value.enumerated.item[0];
3199 if (ch < 0 || ch > spec->multi_ios)
3201 if (ch == (spec->ext_channel_count - 1) / 2)
3203 spec->ext_channel_count = (ch + 1) * 2;
3204 for (i = 0; i < spec->multi_ios; i++)
3205 alc_set_multi_io(codec, i, i < ch);
3206 spec->multiout.max_channels = spec->ext_channel_count;
3207 if (spec->need_dac_fix && !spec->const_channel_count)
3208 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
3212 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
3213 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3214 .name = "Channel Mode",
3215 .info = alc_auto_ch_mode_info,
3216 .get = alc_auto_ch_mode_get,
3217 .put = alc_auto_ch_mode_put,
3220 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec,
3221 int (*fill_dac)(struct hda_codec *))
3223 struct alc_spec *spec = codec->spec;
3224 struct auto_pin_cfg *cfg = &spec->autocfg;
3225 unsigned int location, defcfg;
3228 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT && cfg->hp_outs == 1) {
3229 /* use HP as primary out */
3230 cfg->speaker_outs = cfg->line_outs;
3231 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3232 sizeof(cfg->speaker_pins));
3233 cfg->line_outs = cfg->hp_outs;
3234 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
3236 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3237 cfg->line_out_type = AUTO_PIN_HP_OUT;
3241 if (cfg->line_outs != 1 ||
3242 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
3245 defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
3246 location = get_defcfg_location(defcfg);
3248 num_pins = alc_auto_fill_multi_ios(codec, location);
3250 struct snd_kcontrol_new *knew;
3252 knew = alc_kcontrol_new(spec);
3255 *knew = alc_auto_channel_mode_enum;
3256 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
3260 spec->multi_ios = num_pins;
3261 spec->ext_channel_count = 2;
3262 spec->multiout.num_dacs = num_pins + 1;
3267 /* filter out invalid adc_nids (and capsrc_nids) that don't give all
3270 static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
3272 struct alc_spec *spec = codec->spec;
3273 const struct hda_input_mux *imux;
3274 hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3275 hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3278 imux = spec->input_mux;
3281 if (spec->dyn_adc_switch)
3285 for (n = 0; n < spec->num_adc_nids; n++) {
3286 hda_nid_t cap = spec->private_capsrc_nids[n];
3287 int num_conns = snd_hda_get_conn_list(codec, cap, NULL);
3288 for (i = 0; i < imux->num_items; i++) {
3289 hda_nid_t pin = spec->imux_pins[i];
3291 if (get_connection_index(codec, cap, pin) < 0)
3293 } else if (num_conns <= imux->items[i].index)
3296 if (i >= imux->num_items) {
3297 adc_nids[nums] = spec->private_adc_nids[n];
3298 capsrc_nids[nums++] = cap;
3302 /* check whether ADC-switch is possible */
3303 if (!alc_check_dyn_adc_switch(codec)) {
3304 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
3305 " using fallback 0x%x\n",
3306 codec->chip_name, spec->private_adc_nids[0]);
3307 spec->num_adc_nids = 1;
3311 } else if (nums != spec->num_adc_nids) {
3312 memcpy(spec->private_adc_nids, adc_nids,
3313 nums * sizeof(hda_nid_t));
3314 memcpy(spec->private_capsrc_nids, capsrc_nids,
3315 nums * sizeof(hda_nid_t));
3316 spec->num_adc_nids = nums;
3320 alc_auto_mic_check_imux(codec); /* check auto-mic setups */
3321 else if (spec->input_mux->num_items == 1)
3322 spec->num_adc_nids = 1; /* reduce to a single ADC */
3326 * initialize ADC paths
3328 static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx)
3330 struct alc_spec *spec = codec->spec;
3333 nid = spec->adc_nids[adc_idx];
3335 if (nid_has_mute(codec, nid, HDA_INPUT)) {
3336 snd_hda_codec_write(codec, nid, 0,
3337 AC_VERB_SET_AMP_GAIN_MUTE,
3341 if (!spec->capsrc_nids)
3343 nid = spec->capsrc_nids[adc_idx];
3344 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3345 snd_hda_codec_write(codec, nid, 0,
3346 AC_VERB_SET_AMP_GAIN_MUTE,
3350 static void alc_auto_init_input_src(struct hda_codec *codec)
3352 struct alc_spec *spec = codec->spec;
3355 for (c = 0; c < spec->num_adc_nids; c++)
3356 alc_auto_init_adc(codec, c);
3357 if (spec->dyn_adc_switch)
3360 nums = spec->num_adc_nids;
3361 for (c = 0; c < nums; c++)
3362 alc_mux_select(codec, 0, spec->cur_mux[c], true);
3365 /* add mic boosts if needed */
3366 static int alc_auto_add_mic_boost(struct hda_codec *codec)
3368 struct alc_spec *spec = codec->spec;
3369 struct auto_pin_cfg *cfg = &spec->autocfg;
3373 const char *prev_label = NULL;
3375 for (i = 0; i < cfg->num_inputs; i++) {
3376 if (cfg->inputs[i].type > AUTO_PIN_MIC)
3378 nid = cfg->inputs[i].pin;
3379 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
3381 char boost_label[32];
3383 label = hda_get_autocfg_input_label(codec, cfg, i);
3384 if (prev_label && !strcmp(label, prev_label))
3390 snprintf(boost_label, sizeof(boost_label),
3391 "%s Boost Volume", label);
3392 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3393 boost_label, type_idx,
3394 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
3402 /* select or unmute the given capsrc route */
3403 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
3406 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
3407 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
3409 } else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) {
3410 snd_hda_codec_write_cache(codec, cap, 0,
3411 AC_VERB_SET_CONNECT_SEL, idx);
3415 /* set the default connection to that pin */
3416 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
3418 struct alc_spec *spec = codec->spec;
3423 for (i = 0; i < spec->num_adc_nids; i++) {
3424 hda_nid_t cap = spec->capsrc_nids ?
3425 spec->capsrc_nids[i] : spec->adc_nids[i];
3428 idx = get_connection_index(codec, cap, pin);
3431 select_or_unmute_capsrc(codec, cap, idx);
3432 return i; /* return the found index */
3434 return -1; /* not found */
3437 /* initialize some special cases for input sources */
3438 static void alc_init_special_input_src(struct hda_codec *codec)
3440 struct alc_spec *spec = codec->spec;
3443 for (i = 0; i < spec->autocfg.num_inputs; i++)
3444 init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin);
3447 /* assign appropriate capture mixers */
3448 static void set_capture_mixer(struct hda_codec *codec)
3450 struct alc_spec *spec = codec->spec;
3451 static const struct snd_kcontrol_new *caps[2][3] = {
3452 { alc_capture_mixer_nosrc1,
3453 alc_capture_mixer_nosrc2,
3454 alc_capture_mixer_nosrc3 },
3455 { alc_capture_mixer1,
3457 alc_capture_mixer3 },
3460 /* check whether either of ADC or MUX has a volume control */
3461 if (!nid_has_volume(codec, spec->adc_nids[0], HDA_INPUT)) {
3462 if (!spec->capsrc_nids)
3463 return; /* no volume */
3464 if (!nid_has_volume(codec, spec->capsrc_nids[0], HDA_OUTPUT))
3465 return; /* no volume in capsrc, too */
3466 spec->vol_in_capsrc = 1;
3469 if (spec->num_adc_nids > 0) {
3473 if (spec->input_mux && spec->input_mux->num_items > 1)
3475 if (spec->auto_mic) {
3478 } else if (spec->dyn_adc_switch)
3481 if (spec->num_adc_nids > 3)
3482 spec->num_adc_nids = 3;
3483 else if (!spec->num_adc_nids)
3485 num_adcs = spec->num_adc_nids;
3487 spec->cap_mixer = caps[mux][num_adcs - 1];
3492 * standard auto-parser initializations
3494 static void alc_auto_init_std(struct hda_codec *codec)
3496 struct alc_spec *spec = codec->spec;
3497 alc_auto_init_multi_out(codec);
3498 alc_auto_init_extra_out(codec);
3499 alc_auto_init_analog_input(codec);
3500 alc_auto_init_input_src(codec);
3501 alc_auto_init_digital(codec);
3502 if (spec->unsol_event)
3503 alc_inithook(codec);
3507 * Digital-beep handlers
3509 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3510 #define set_beep_amp(spec, nid, idx, dir) \
3511 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
3513 static const struct snd_pci_quirk beep_white_list[] = {
3514 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
3515 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
3516 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
3517 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
3518 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
3522 static inline int has_cdefine_beep(struct hda_codec *codec)
3524 struct alc_spec *spec = codec->spec;
3525 const struct snd_pci_quirk *q;
3526 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
3529 return spec->cdefine.enable_pcbeep;
3532 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
3533 #define has_cdefine_beep(codec) 0
3536 /* parse the BIOS configuration and set up the alc_spec */
3537 /* return 1 if successful, 0 if the proper config is not found,
3538 * or a negative error code
3540 static int alc_parse_auto_config(struct hda_codec *codec,
3541 const hda_nid_t *ignore_nids,
3542 const hda_nid_t *ssid_nids)
3544 struct alc_spec *spec = codec->spec;
3547 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3551 if (!spec->autocfg.line_outs) {
3552 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
3553 spec->multiout.max_channels = 2;
3554 spec->no_analog = 1;
3557 return 0; /* can't find valid BIOS pin config */
3559 err = alc_auto_fill_dac_nids(codec);
3562 err = alc_auto_add_multi_channel_mode(codec, alc_auto_fill_dac_nids);
3565 err = alc_auto_create_multi_out_ctls(codec, &spec->autocfg);
3568 err = alc_auto_create_hp_out(codec);
3571 err = alc_auto_create_speaker_out(codec);
3574 err = alc_auto_create_input_ctls(codec);
3578 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3581 alc_auto_parse_digital(codec);
3583 if (!spec->no_analog)
3584 alc_remove_invalid_adc_nids(codec);
3587 alc_ssid_check(codec, ssid_nids);
3589 if (!spec->no_analog) {
3590 alc_auto_check_switches(codec);
3591 err = alc_auto_add_mic_boost(codec);
3596 if (spec->kctls.list)
3597 add_mixer(spec, spec->kctls.list);
3602 static int alc880_parse_auto_config(struct hda_codec *codec)
3604 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3605 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3606 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
3609 #ifdef CONFIG_SND_HDA_POWER_SAVE
3610 static const struct hda_amp_list alc880_loopbacks[] = {
3611 { 0x0b, HDA_INPUT, 0 },
3612 { 0x0b, HDA_INPUT, 1 },
3613 { 0x0b, HDA_INPUT, 2 },
3614 { 0x0b, HDA_INPUT, 3 },
3615 { 0x0b, HDA_INPUT, 4 },
3623 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3624 #define alc_board_config \
3625 snd_hda_check_board_config
3626 #define alc_board_codec_sid_config \
3627 snd_hda_check_board_codec_sid_config
3628 #include "alc_quirks.c"
3630 #define alc_board_config(codec, nums, models, tbl) -1
3631 #define alc_board_codec_sid_config(codec, nums, models, tbl) -1
3632 #define setup_preset(codec, x) /* NOP */
3636 * OK, here we have finally the patch for ALC880
3638 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3639 #include "alc880_quirks.c"
3642 static int patch_alc880(struct hda_codec *codec)
3644 struct alc_spec *spec;
3648 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3654 spec->mixer_nid = 0x0b;
3655 spec->need_dac_fix = 1;
3657 board_config = alc_board_config(codec, ALC880_MODEL_LAST,
3658 alc880_models, alc880_cfg_tbl);
3659 if (board_config < 0) {
3660 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3662 board_config = ALC_MODEL_AUTO;
3665 if (board_config == ALC_MODEL_AUTO) {
3666 /* automatic parse from the BIOS config */
3667 err = alc880_parse_auto_config(codec);
3672 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3675 "hda_codec: Cannot set up configuration "
3676 "from BIOS. Using 3-stack mode...\n");
3677 board_config = ALC880_3ST;
3682 if (board_config != ALC_MODEL_AUTO)
3683 setup_preset(codec, &alc880_presets[board_config]);
3685 if (!spec->no_analog && !spec->adc_nids) {
3686 alc_auto_fill_adc_caps(codec);
3687 alc_rebuild_imux_for_auto_mic(codec);
3688 alc_remove_invalid_adc_nids(codec);
3691 if (!spec->no_analog && !spec->cap_mixer)
3692 set_capture_mixer(codec);
3694 if (!spec->no_analog) {
3695 err = snd_hda_attach_beep_device(codec, 0x1);
3700 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
3703 spec->vmaster_nid = 0x0c;
3705 codec->patch_ops = alc_patch_ops;
3706 if (board_config == ALC_MODEL_AUTO)
3707 spec->init_hook = alc_auto_init_std;
3708 #ifdef CONFIG_SND_HDA_POWER_SAVE
3709 if (!spec->loopback.amplist)
3710 spec->loopback.amplist = alc880_loopbacks;
3720 static int alc260_parse_auto_config(struct hda_codec *codec)
3722 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
3723 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
3724 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
3727 #ifdef CONFIG_SND_HDA_POWER_SAVE
3728 static const struct hda_amp_list alc260_loopbacks[] = {
3729 { 0x07, HDA_INPUT, 0 },
3730 { 0x07, HDA_INPUT, 1 },
3731 { 0x07, HDA_INPUT, 2 },
3732 { 0x07, HDA_INPUT, 3 },
3733 { 0x07, HDA_INPUT, 4 },
3745 static const struct alc_fixup alc260_fixups[] = {
3746 [PINFIX_HP_DC5750] = {
3747 .type = ALC_FIXUP_PINS,
3748 .v.pins = (const struct alc_pincfg[]) {
3749 { 0x11, 0x90130110 }, /* speaker */
3755 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
3756 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
3762 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3763 #include "alc260_quirks.c"
3766 static int patch_alc260(struct hda_codec *codec)
3768 struct alc_spec *spec;
3769 int err, board_config;
3771 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3777 spec->mixer_nid = 0x07;
3779 board_config = alc_board_config(codec, ALC260_MODEL_LAST,
3780 alc260_models, alc260_cfg_tbl);
3781 if (board_config < 0) {
3782 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3784 board_config = ALC_MODEL_AUTO;
3787 if (board_config == ALC_MODEL_AUTO) {
3788 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
3789 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
3792 if (board_config == ALC_MODEL_AUTO) {
3793 /* automatic parse from the BIOS config */
3794 err = alc260_parse_auto_config(codec);
3799 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3802 "hda_codec: Cannot set up configuration "
3803 "from BIOS. Using base mode...\n");
3804 board_config = ALC260_BASIC;
3809 if (board_config != ALC_MODEL_AUTO)
3810 setup_preset(codec, &alc260_presets[board_config]);
3812 if (!spec->no_analog && !spec->adc_nids) {
3813 alc_auto_fill_adc_caps(codec);
3814 alc_rebuild_imux_for_auto_mic(codec);
3815 alc_remove_invalid_adc_nids(codec);
3818 if (!spec->no_analog && !spec->cap_mixer)
3819 set_capture_mixer(codec);
3821 if (!spec->no_analog) {
3822 err = snd_hda_attach_beep_device(codec, 0x1);
3827 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
3830 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
3832 spec->vmaster_nid = 0x08;
3834 codec->patch_ops = alc_patch_ops;
3835 if (board_config == ALC_MODEL_AUTO)
3836 spec->init_hook = alc_auto_init_std;
3837 spec->shutup = alc_eapd_shutup;
3838 #ifdef CONFIG_SND_HDA_POWER_SAVE
3839 if (!spec->loopback.amplist)
3840 spec->loopback.amplist = alc260_loopbacks;
3848 * ALC882/883/885/888/889 support
3850 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
3851 * configuration. Each pin widget can choose any input DACs and a mixer.
3852 * Each ADC is connected from a mixer of all inputs. This makes possible
3853 * 6-channel independent captures.
3855 * In addition, an independent DAC for the multi-playback (not used in this
3858 #ifdef CONFIG_SND_HDA_POWER_SAVE
3859 #define alc882_loopbacks alc880_loopbacks
3866 PINFIX_ABIT_AW9D_MAX,
3869 PINFIX_ACER_ASPIRE_7736,
3872 static const struct alc_fixup alc882_fixups[] = {
3873 [PINFIX_ABIT_AW9D_MAX] = {
3874 .type = ALC_FIXUP_PINS,
3875 .v.pins = (const struct alc_pincfg[]) {
3876 { 0x15, 0x01080104 }, /* side */
3877 { 0x16, 0x01011012 }, /* rear */
3878 { 0x17, 0x01016011 }, /* clfe */
3882 [PINFIX_LENOVO_Y530] = {
3883 .type = ALC_FIXUP_PINS,
3884 .v.pins = (const struct alc_pincfg[]) {
3885 { 0x15, 0x99130112 }, /* rear int speakers */
3886 { 0x16, 0x99130111 }, /* subwoofer */
3890 [PINFIX_PB_M5210] = {
3891 .type = ALC_FIXUP_VERBS,
3892 .v.verbs = (const struct hda_verb[]) {
3893 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
3897 [PINFIX_ACER_ASPIRE_7736] = {
3898 .type = ALC_FIXUP_SKU,
3899 .v.sku = ALC_FIXUP_SKU_IGNORE,
3903 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
3904 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
3905 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530),
3906 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
3907 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
3912 * BIOS auto configuration
3914 /* almost identical with ALC880 parser... */
3915 static int alc882_parse_auto_config(struct hda_codec *codec)
3917 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
3918 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3919 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
3924 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3925 #include "alc882_quirks.c"
3928 static int patch_alc882(struct hda_codec *codec)
3930 struct alc_spec *spec;
3931 int err, board_config;
3933 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3939 spec->mixer_nid = 0x0b;
3941 switch (codec->vendor_id) {
3946 /* ALC883 and variants */
3947 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
3951 board_config = alc_board_config(codec, ALC882_MODEL_LAST,
3952 alc882_models, alc882_cfg_tbl);
3954 if (board_config < 0)
3955 board_config = alc_board_codec_sid_config(codec,
3956 ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
3958 if (board_config < 0) {
3959 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3961 board_config = ALC_MODEL_AUTO;
3964 if (board_config == ALC_MODEL_AUTO) {
3965 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
3966 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
3969 alc_auto_parse_customize_define(codec);
3971 if (board_config == ALC_MODEL_AUTO) {
3972 /* automatic parse from the BIOS config */
3973 err = alc882_parse_auto_config(codec);
3978 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3981 "hda_codec: Cannot set up configuration "
3982 "from BIOS. Using base mode...\n");
3983 board_config = ALC882_3ST_DIG;
3988 if (board_config != ALC_MODEL_AUTO)
3989 setup_preset(codec, &alc882_presets[board_config]);
3991 if (!spec->no_analog && !spec->adc_nids) {
3992 alc_auto_fill_adc_caps(codec);
3993 alc_rebuild_imux_for_auto_mic(codec);
3994 alc_remove_invalid_adc_nids(codec);
3997 if (!spec->no_analog && !spec->cap_mixer)
3998 set_capture_mixer(codec);
4000 if (!spec->no_analog && has_cdefine_beep(codec)) {
4001 err = snd_hda_attach_beep_device(codec, 0x1);
4006 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4009 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4011 spec->vmaster_nid = 0x0c;
4013 codec->patch_ops = alc_patch_ops;
4014 if (board_config == ALC_MODEL_AUTO)
4015 spec->init_hook = alc_auto_init_std;
4017 alc_init_jacks(codec);
4018 #ifdef CONFIG_SND_HDA_POWER_SAVE
4019 if (!spec->loopback.amplist)
4020 spec->loopback.amplist = alc882_loopbacks;
4030 static int alc262_parse_auto_config(struct hda_codec *codec)
4032 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
4033 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4034 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
4045 static const struct alc_fixup alc262_fixups[] = {
4046 [PINFIX_FSC_H270] = {
4047 .type = ALC_FIXUP_PINS,
4048 .v.pins = (const struct alc_pincfg[]) {
4049 { 0x14, 0x99130110 }, /* speaker */
4050 { 0x15, 0x0221142f }, /* front HP */
4051 { 0x1b, 0x0121141f }, /* rear HP */
4055 [PINFIX_HP_Z200] = {
4056 .type = ALC_FIXUP_PINS,
4057 .v.pins = (const struct alc_pincfg[]) {
4058 { 0x16, 0x99130120 }, /* internal speaker */
4064 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
4065 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", PINFIX_HP_Z200),
4066 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
4071 #ifdef CONFIG_SND_HDA_POWER_SAVE
4072 #define alc262_loopbacks alc880_loopbacks
4077 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4078 #include "alc262_quirks.c"
4081 static int patch_alc262(struct hda_codec *codec)
4083 struct alc_spec *spec;
4087 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4093 spec->mixer_nid = 0x0b;
4096 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
4101 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4102 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4103 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4104 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4107 alc_auto_parse_customize_define(codec);
4109 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4111 board_config = alc_board_config(codec, ALC262_MODEL_LAST,
4112 alc262_models, alc262_cfg_tbl);
4114 if (board_config < 0) {
4115 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4117 board_config = ALC_MODEL_AUTO;
4120 if (board_config == ALC_MODEL_AUTO) {
4121 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
4122 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4125 if (board_config == ALC_MODEL_AUTO) {
4126 /* automatic parse from the BIOS config */
4127 err = alc262_parse_auto_config(codec);
4132 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4135 "hda_codec: Cannot set up configuration "
4136 "from BIOS. Using base mode...\n");
4137 board_config = ALC262_BASIC;
4142 if (board_config != ALC_MODEL_AUTO)
4143 setup_preset(codec, &alc262_presets[board_config]);
4145 if (!spec->no_analog && !spec->adc_nids) {
4146 alc_auto_fill_adc_caps(codec);
4147 alc_rebuild_imux_for_auto_mic(codec);
4148 alc_remove_invalid_adc_nids(codec);
4151 if (!spec->no_analog && !spec->cap_mixer)
4152 set_capture_mixer(codec);
4154 if (!spec->no_analog && has_cdefine_beep(codec)) {
4155 err = snd_hda_attach_beep_device(codec, 0x1);
4160 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4163 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4165 spec->vmaster_nid = 0x0c;
4167 codec->patch_ops = alc_patch_ops;
4168 if (board_config == ALC_MODEL_AUTO)
4169 spec->init_hook = alc_auto_init_std;
4170 spec->shutup = alc_eapd_shutup;
4172 alc_init_jacks(codec);
4173 #ifdef CONFIG_SND_HDA_POWER_SAVE
4174 if (!spec->loopback.amplist)
4175 spec->loopback.amplist = alc262_loopbacks;
4184 /* bind Beep switches of both NID 0x0f and 0x10 */
4185 static const struct hda_bind_ctls alc268_bind_beep_sw = {
4186 .ops = &snd_hda_bind_sw,
4188 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
4189 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
4194 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
4195 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
4196 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
4200 /* set PCBEEP vol = 0, mute connections */
4201 static const struct hda_verb alc268_beep_init_verbs[] = {
4202 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4203 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4204 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4209 * BIOS auto configuration
4211 static int alc268_parse_auto_config(struct hda_codec *codec)
4213 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4214 struct alc_spec *spec = codec->spec;
4215 int err = alc_parse_auto_config(codec, NULL, alc268_ssids);
4217 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) {
4218 add_mixer(spec, alc268_beep_mixer);
4219 add_verb(spec, alc268_beep_init_verbs);
4227 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4228 #include "alc268_quirks.c"
4231 static int patch_alc268(struct hda_codec *codec)
4233 struct alc_spec *spec;
4235 int i, has_beep, err;
4237 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4243 /* ALC268 has no aa-loopback mixer */
4245 board_config = alc_board_config(codec, ALC268_MODEL_LAST,
4246 alc268_models, alc268_cfg_tbl);
4248 if (board_config < 0)
4249 board_config = alc_board_codec_sid_config(codec,
4250 ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
4252 if (board_config < 0) {
4253 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4255 board_config = ALC_MODEL_AUTO;
4258 if (board_config == ALC_MODEL_AUTO) {
4259 /* automatic parse from the BIOS config */
4260 err = alc268_parse_auto_config(codec);
4265 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4268 "hda_codec: Cannot set up configuration "
4269 "from BIOS. Using base mode...\n");
4270 board_config = ALC268_3ST;
4275 if (board_config != ALC_MODEL_AUTO)
4276 setup_preset(codec, &alc268_presets[board_config]);
4279 for (i = 0; i < spec->num_mixers; i++) {
4280 if (spec->mixers[i] == alc268_beep_mixer) {
4287 err = snd_hda_attach_beep_device(codec, 0x1);
4292 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
4293 /* override the amp caps for beep generator */
4294 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
4295 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
4296 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
4297 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4298 (0 << AC_AMPCAP_MUTE_SHIFT));
4301 if (!spec->no_analog && !spec->adc_nids) {
4302 alc_auto_fill_adc_caps(codec);
4303 alc_rebuild_imux_for_auto_mic(codec);
4304 alc_remove_invalid_adc_nids(codec);
4307 if (!spec->no_analog && !spec->cap_mixer)
4308 set_capture_mixer(codec);
4310 spec->vmaster_nid = 0x02;
4312 codec->patch_ops = alc_patch_ops;
4313 if (board_config == ALC_MODEL_AUTO)
4314 spec->init_hook = alc_auto_init_std;
4315 spec->shutup = alc_eapd_shutup;
4317 alc_init_jacks(codec);
4325 #ifdef CONFIG_SND_HDA_POWER_SAVE
4326 #define alc269_loopbacks alc880_loopbacks
4329 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
4333 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4334 /* NID is set in alc_build_pcms */
4336 .open = alc_playback_pcm_open,
4337 .prepare = alc_playback_pcm_prepare,
4338 .cleanup = alc_playback_pcm_cleanup
4342 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
4346 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4347 /* NID is set in alc_build_pcms */
4350 #ifdef CONFIG_SND_HDA_POWER_SAVE
4351 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
4353 switch (codec->subsystem_id) {
4360 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
4362 /* update mute-LED according to the speaker mute state */
4363 if (nid == 0x01 || nid == 0x14) {
4365 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
4370 /* mic2 vref pin is used for mute LED control */
4371 snd_hda_codec_update_cache(codec, 0x19, 0,
4372 AC_VERB_SET_PIN_WIDGET_CONTROL,
4375 return alc_check_power_status(codec, nid);
4377 #endif /* CONFIG_SND_HDA_POWER_SAVE */
4379 /* different alc269-variants */
4381 ALC269_TYPE_ALC269VA,
4382 ALC269_TYPE_ALC269VB,
4383 ALC269_TYPE_ALC269VC,
4387 * BIOS auto configuration
4389 static int alc269_parse_auto_config(struct hda_codec *codec)
4391 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
4392 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
4393 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4394 struct alc_spec *spec = codec->spec;
4395 const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ?
4396 alc269va_ssids : alc269_ssids;
4398 return alc_parse_auto_config(codec, alc269_ignore, ssids);
4401 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
4403 int val = alc_read_coef_idx(codec, 0x04);
4408 alc_write_coef_idx(codec, 0x04, val);
4411 static void alc269_shutup(struct hda_codec *codec)
4413 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
4414 alc269_toggle_power_output(codec, 0);
4415 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
4416 alc269_toggle_power_output(codec, 0);
4422 static int alc269_resume(struct hda_codec *codec)
4424 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
4425 alc269_toggle_power_output(codec, 0);
4429 codec->patch_ops.init(codec);
4431 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
4432 alc269_toggle_power_output(codec, 1);
4436 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
4437 alc269_toggle_power_output(codec, 1);
4439 snd_hda_codec_resume_amp(codec);
4440 snd_hda_codec_resume_cache(codec);
4441 hda_call_check_power_status(codec, 0x01);
4444 #endif /* CONFIG_PM */
4446 static void alc269_fixup_hweq(struct hda_codec *codec,
4447 const struct alc_fixup *fix, int action)
4451 if (action != ALC_FIXUP_ACT_INIT)
4453 coef = alc_read_coef_idx(codec, 0x1e);
4454 alc_write_coef_idx(codec, 0x1e, coef | 0x80);
4457 static void alc271_fixup_dmic(struct hda_codec *codec,
4458 const struct alc_fixup *fix, int action)
4460 static const struct hda_verb verbs[] = {
4461 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4462 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4467 if (strcmp(codec->chip_name, "ALC271X"))
4469 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4470 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4471 snd_hda_sequence_write(codec, verbs);
4474 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4475 const struct alc_fixup *fix, int action)
4477 struct alc_spec *spec = codec->spec;
4479 if (action != ALC_FIXUP_ACT_PROBE)
4482 /* Due to a hardware problem on Lenovo Ideadpad, we need to
4483 * fix the sample rate of analog I/O to 44.1kHz
4485 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
4486 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
4489 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4490 const struct alc_fixup *fix, int action)
4494 if (action != ALC_FIXUP_ACT_INIT)
4496 /* The digital-mic unit sends PDM (differential signal) instead of
4497 * the standard PCM, thus you can't record a valid mono stream as is.
4498 * Below is a workaround specific to ALC269 to control the dmic
4499 * signal source as mono.
4501 coef = alc_read_coef_idx(codec, 0x07);
4502 alc_write_coef_idx(codec, 0x07, coef | 0x80);
4506 ALC269_FIXUP_SONY_VAIO,
4507 ALC275_FIXUP_SONY_VAIO_GPIO2,
4508 ALC269_FIXUP_DELL_M101Z,
4509 ALC269_FIXUP_SKU_IGNORE,
4510 ALC269_FIXUP_ASUS_G73JW,
4511 ALC269_FIXUP_LENOVO_EAPD,
4512 ALC275_FIXUP_SONY_HWEQ,
4514 ALC269_FIXUP_PCM_44K,
4515 ALC269_FIXUP_STEREO_DMIC,
4518 static const struct alc_fixup alc269_fixups[] = {
4519 [ALC269_FIXUP_SONY_VAIO] = {
4520 .type = ALC_FIXUP_VERBS,
4521 .v.verbs = (const struct hda_verb[]) {
4522 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
4526 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
4527 .type = ALC_FIXUP_VERBS,
4528 .v.verbs = (const struct hda_verb[]) {
4529 {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
4530 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
4531 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4535 .chain_id = ALC269_FIXUP_SONY_VAIO
4537 [ALC269_FIXUP_DELL_M101Z] = {
4538 .type = ALC_FIXUP_VERBS,
4539 .v.verbs = (const struct hda_verb[]) {
4540 /* Enables internal speaker */
4541 {0x20, AC_VERB_SET_COEF_INDEX, 13},
4542 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
4546 [ALC269_FIXUP_SKU_IGNORE] = {
4547 .type = ALC_FIXUP_SKU,
4548 .v.sku = ALC_FIXUP_SKU_IGNORE,
4550 [ALC269_FIXUP_ASUS_G73JW] = {
4551 .type = ALC_FIXUP_PINS,
4552 .v.pins = (const struct alc_pincfg[]) {
4553 { 0x17, 0x99130111 }, /* subwoofer */
4557 [ALC269_FIXUP_LENOVO_EAPD] = {
4558 .type = ALC_FIXUP_VERBS,
4559 .v.verbs = (const struct hda_verb[]) {
4560 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
4564 [ALC275_FIXUP_SONY_HWEQ] = {
4565 .type = ALC_FIXUP_FUNC,
4566 .v.func = alc269_fixup_hweq,
4568 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
4570 [ALC271_FIXUP_DMIC] = {
4571 .type = ALC_FIXUP_FUNC,
4572 .v.func = alc271_fixup_dmic,
4574 [ALC269_FIXUP_PCM_44K] = {
4575 .type = ALC_FIXUP_FUNC,
4576 .v.func = alc269_fixup_pcm_44k,
4578 [ALC269_FIXUP_STEREO_DMIC] = {
4579 .type = ALC_FIXUP_FUNC,
4580 .v.func = alc269_fixup_stereo_dmic,
4584 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
4585 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
4586 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
4587 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
4588 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
4589 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4590 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4591 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
4592 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4593 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4594 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
4595 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
4596 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
4597 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
4598 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
4599 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
4600 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
4601 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
4602 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Lenovo Ideapd", ALC269_FIXUP_PCM_44K),
4603 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
4608 static int alc269_fill_coef(struct hda_codec *codec)
4612 if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
4613 alc_write_coef_idx(codec, 0xf, 0x960b);
4614 alc_write_coef_idx(codec, 0xe, 0x8817);
4617 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
4618 alc_write_coef_idx(codec, 0xf, 0x960b);
4619 alc_write_coef_idx(codec, 0xe, 0x8814);
4622 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
4623 val = alc_read_coef_idx(codec, 0x04);
4624 /* Power up output pin */
4625 alc_write_coef_idx(codec, 0x04, val | (1<<11));
4628 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
4629 val = alc_read_coef_idx(codec, 0xd);
4630 if ((val & 0x0c00) >> 10 != 0x1) {
4631 /* Capless ramp up clock control */
4632 alc_write_coef_idx(codec, 0xd, val | (1<<10));
4634 val = alc_read_coef_idx(codec, 0x17);
4635 if ((val & 0x01c0) >> 6 != 0x4) {
4636 /* Class D power on reset */
4637 alc_write_coef_idx(codec, 0x17, val | (1<<7));
4641 val = alc_read_coef_idx(codec, 0xd); /* Class D */
4642 alc_write_coef_idx(codec, 0xd, val | (1<<14));
4644 val = alc_read_coef_idx(codec, 0x4); /* HP */
4645 alc_write_coef_idx(codec, 0x4, val | (1<<11));
4652 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4653 #include "alc269_quirks.c"
4656 static int patch_alc269(struct hda_codec *codec)
4658 struct alc_spec *spec;
4659 int board_config, coef;
4662 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4668 spec->mixer_nid = 0x0b;
4670 alc_auto_parse_customize_define(codec);
4672 if (codec->vendor_id == 0x10ec0269) {
4673 spec->codec_variant = ALC269_TYPE_ALC269VA;
4674 coef = alc_read_coef_idx(codec, 0);
4675 if ((coef & 0x00f0) == 0x0010) {
4676 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
4677 spec->cdefine.platform_type == 1) {
4678 alc_codec_rename(codec, "ALC271X");
4679 } else if ((coef & 0xf000) == 0x2000) {
4680 alc_codec_rename(codec, "ALC259");
4681 } else if ((coef & 0xf000) == 0x3000) {
4682 alc_codec_rename(codec, "ALC258");
4683 } else if ((coef & 0xfff0) == 0x3010) {
4684 alc_codec_rename(codec, "ALC277");
4686 alc_codec_rename(codec, "ALC269VB");
4688 spec->codec_variant = ALC269_TYPE_ALC269VB;
4689 } else if ((coef & 0x00f0) == 0x0020) {
4691 alc_codec_rename(codec, "ALC259");
4692 else if (coef == 0x6023)
4693 alc_codec_rename(codec, "ALC281X");
4694 else if (codec->bus->pci->subsystem_vendor == 0x17aa &&
4695 codec->bus->pci->subsystem_device == 0x21f3)
4696 alc_codec_rename(codec, "ALC3202");
4698 alc_codec_rename(codec, "ALC269VC");
4699 spec->codec_variant = ALC269_TYPE_ALC269VC;
4701 alc_fix_pll_init(codec, 0x20, 0x04, 15);
4702 alc269_fill_coef(codec);
4705 board_config = alc_board_config(codec, ALC269_MODEL_LAST,
4706 alc269_models, alc269_cfg_tbl);
4708 if (board_config < 0) {
4709 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4711 board_config = ALC_MODEL_AUTO;
4714 if (board_config == ALC_MODEL_AUTO) {
4715 alc_pick_fixup(codec, NULL, alc269_fixup_tbl, alc269_fixups);
4716 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4719 if (board_config == ALC_MODEL_AUTO) {
4720 /* automatic parse from the BIOS config */
4721 err = alc269_parse_auto_config(codec);
4726 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4729 "hda_codec: Cannot set up configuration "
4730 "from BIOS. Using base mode...\n");
4731 board_config = ALC269_BASIC;
4736 if (board_config != ALC_MODEL_AUTO)
4737 setup_preset(codec, &alc269_presets[board_config]);
4739 if (!spec->no_analog && !spec->adc_nids) {
4740 alc_auto_fill_adc_caps(codec);
4741 alc_rebuild_imux_for_auto_mic(codec);
4742 alc_remove_invalid_adc_nids(codec);
4745 if (!spec->no_analog && !spec->cap_mixer)
4746 set_capture_mixer(codec);
4748 if (!spec->no_analog && has_cdefine_beep(codec)) {
4749 err = snd_hda_attach_beep_device(codec, 0x1);
4754 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
4757 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4759 spec->vmaster_nid = 0x02;
4761 codec->patch_ops = alc_patch_ops;
4763 codec->patch_ops.resume = alc269_resume;
4765 if (board_config == ALC_MODEL_AUTO)
4766 spec->init_hook = alc_auto_init_std;
4767 spec->shutup = alc269_shutup;
4769 alc_init_jacks(codec);
4770 #ifdef CONFIG_SND_HDA_POWER_SAVE
4771 if (!spec->loopback.amplist)
4772 spec->loopback.amplist = alc269_loopbacks;
4773 if (alc269_mic2_for_mute_led(codec))
4774 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
4784 static int alc861_parse_auto_config(struct hda_codec *codec)
4786 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
4787 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
4788 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
4791 #ifdef CONFIG_SND_HDA_POWER_SAVE
4792 static const struct hda_amp_list alc861_loopbacks[] = {
4793 { 0x15, HDA_INPUT, 0 },
4794 { 0x15, HDA_INPUT, 1 },
4795 { 0x15, HDA_INPUT, 2 },
4796 { 0x15, HDA_INPUT, 3 },
4802 /* Pin config fixes */
4804 PINFIX_FSC_AMILO_PI1505,
4807 static const struct alc_fixup alc861_fixups[] = {
4808 [PINFIX_FSC_AMILO_PI1505] = {
4809 .type = ALC_FIXUP_PINS,
4810 .v.pins = (const struct alc_pincfg[]) {
4811 { 0x0b, 0x0221101f }, /* HP */
4812 { 0x0f, 0x90170310 }, /* speaker */
4818 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
4819 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
4825 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4826 #include "alc861_quirks.c"
4829 static int patch_alc861(struct hda_codec *codec)
4831 struct alc_spec *spec;
4835 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4841 spec->mixer_nid = 0x15;
4843 board_config = alc_board_config(codec, ALC861_MODEL_LAST,
4844 alc861_models, alc861_cfg_tbl);
4846 if (board_config < 0) {
4847 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4849 board_config = ALC_MODEL_AUTO;
4852 if (board_config == ALC_MODEL_AUTO) {
4853 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
4854 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4857 if (board_config == ALC_MODEL_AUTO) {
4858 /* automatic parse from the BIOS config */
4859 err = alc861_parse_auto_config(codec);
4864 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4867 "hda_codec: Cannot set up configuration "
4868 "from BIOS. Using base mode...\n");
4869 board_config = ALC861_3ST_DIG;
4874 if (board_config != ALC_MODEL_AUTO)
4875 setup_preset(codec, &alc861_presets[board_config]);
4877 if (!spec->no_analog && !spec->adc_nids) {
4878 alc_auto_fill_adc_caps(codec);
4879 alc_rebuild_imux_for_auto_mic(codec);
4880 alc_remove_invalid_adc_nids(codec);
4883 if (!spec->no_analog && !spec->cap_mixer)
4884 set_capture_mixer(codec);
4886 if (!spec->no_analog) {
4887 err = snd_hda_attach_beep_device(codec, 0x23);
4892 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
4895 spec->vmaster_nid = 0x03;
4897 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4899 codec->patch_ops = alc_patch_ops;
4900 if (board_config == ALC_MODEL_AUTO) {
4901 spec->init_hook = alc_auto_init_std;
4902 #ifdef CONFIG_SND_HDA_POWER_SAVE
4903 spec->power_hook = alc_power_eapd;
4906 #ifdef CONFIG_SND_HDA_POWER_SAVE
4907 if (!spec->loopback.amplist)
4908 spec->loopback.amplist = alc861_loopbacks;
4919 * In addition, an independent DAC
4921 #ifdef CONFIG_SND_HDA_POWER_SAVE
4922 #define alc861vd_loopbacks alc880_loopbacks
4925 static int alc861vd_parse_auto_config(struct hda_codec *codec)
4927 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
4928 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4929 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
4933 ALC660VD_FIX_ASUS_GPIO1
4937 static const struct alc_fixup alc861vd_fixups[] = {
4938 [ALC660VD_FIX_ASUS_GPIO1] = {
4939 .type = ALC_FIXUP_VERBS,
4940 .v.verbs = (const struct hda_verb[]) {
4941 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
4942 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4943 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
4949 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
4950 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
4954 static const struct hda_verb alc660vd_eapd_verbs[] = {
4955 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
4956 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
4962 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4963 #include "alc861vd_quirks.c"
4966 static int patch_alc861vd(struct hda_codec *codec)
4968 struct alc_spec *spec;
4969 int err, board_config;
4971 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4977 spec->mixer_nid = 0x0b;
4979 board_config = alc_board_config(codec, ALC861VD_MODEL_LAST,
4980 alc861vd_models, alc861vd_cfg_tbl);
4982 if (board_config < 0) {
4983 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4985 board_config = ALC_MODEL_AUTO;
4988 if (board_config == ALC_MODEL_AUTO) {
4989 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
4990 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4993 if (board_config == ALC_MODEL_AUTO) {
4994 /* automatic parse from the BIOS config */
4995 err = alc861vd_parse_auto_config(codec);
5000 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5003 "hda_codec: Cannot set up configuration "
5004 "from BIOS. Using base mode...\n");
5005 board_config = ALC861VD_3ST;
5010 if (board_config != ALC_MODEL_AUTO)
5011 setup_preset(codec, &alc861vd_presets[board_config]);
5013 if (codec->vendor_id == 0x10ec0660) {
5014 /* always turn on EAPD */
5015 add_verb(spec, alc660vd_eapd_verbs);
5018 if (!spec->no_analog && !spec->adc_nids) {
5019 alc_auto_fill_adc_caps(codec);
5020 alc_rebuild_imux_for_auto_mic(codec);
5021 alc_remove_invalid_adc_nids(codec);
5024 if (!spec->no_analog && !spec->cap_mixer)
5025 set_capture_mixer(codec);
5027 if (!spec->no_analog) {
5028 err = snd_hda_attach_beep_device(codec, 0x23);
5033 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5036 spec->vmaster_nid = 0x02;
5038 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5040 codec->patch_ops = alc_patch_ops;
5042 if (board_config == ALC_MODEL_AUTO)
5043 spec->init_hook = alc_auto_init_std;
5044 spec->shutup = alc_eapd_shutup;
5045 #ifdef CONFIG_SND_HDA_POWER_SAVE
5046 if (!spec->loopback.amplist)
5047 spec->loopback.amplist = alc861vd_loopbacks;
5056 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5057 * configuration. Each pin widget can choose any input DACs and a mixer.
5058 * Each ADC is connected from a mixer of all inputs. This makes possible
5059 * 6-channel independent captures.
5061 * In addition, an independent DAC for the multi-playback (not used in this
5064 #ifdef CONFIG_SND_HDA_POWER_SAVE
5065 #define alc662_loopbacks alc880_loopbacks
5069 * BIOS auto configuration
5072 static int alc662_parse_auto_config(struct hda_codec *codec)
5074 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
5075 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
5076 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5077 const hda_nid_t *ssids;
5079 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
5080 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
5081 ssids = alc663_ssids;
5083 ssids = alc662_ssids;
5084 return alc_parse_auto_config(codec, alc662_ignore, ssids);
5087 static void alc272_fixup_mario(struct hda_codec *codec,
5088 const struct alc_fixup *fix, int action)
5090 if (action != ALC_FIXUP_ACT_PROBE)
5092 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
5093 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
5094 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
5095 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5096 (0 << AC_AMPCAP_MUTE_SHIFT)))
5098 "hda_codec: failed to override amp caps for NID 0x2\n");
5102 ALC662_FIXUP_ASPIRE,
5103 ALC662_FIXUP_IDEAPAD,
5105 ALC662_FIXUP_CZC_P10T,
5106 ALC662_FIXUP_SKU_IGNORE,
5107 ALC662_FIXUP_HP_RP5800,
5110 static const struct alc_fixup alc662_fixups[] = {
5111 [ALC662_FIXUP_ASPIRE] = {
5112 .type = ALC_FIXUP_PINS,
5113 .v.pins = (const struct alc_pincfg[]) {
5114 { 0x15, 0x99130112 }, /* subwoofer */
5118 [ALC662_FIXUP_IDEAPAD] = {
5119 .type = ALC_FIXUP_PINS,
5120 .v.pins = (const struct alc_pincfg[]) {
5121 { 0x17, 0x99130112 }, /* subwoofer */
5125 [ALC272_FIXUP_MARIO] = {
5126 .type = ALC_FIXUP_FUNC,
5127 .v.func = alc272_fixup_mario,
5129 [ALC662_FIXUP_CZC_P10T] = {
5130 .type = ALC_FIXUP_VERBS,
5131 .v.verbs = (const struct hda_verb[]) {
5132 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5136 [ALC662_FIXUP_SKU_IGNORE] = {
5137 .type = ALC_FIXUP_SKU,
5138 .v.sku = ALC_FIXUP_SKU_IGNORE,
5140 [ALC662_FIXUP_HP_RP5800] = {
5141 .type = ALC_FIXUP_PINS,
5142 .v.pins = (const struct alc_pincfg[]) {
5143 { 0x14, 0x0221201f }, /* HP out */
5147 .chain_id = ALC662_FIXUP_SKU_IGNORE
5151 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
5152 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
5153 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
5154 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
5155 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
5156 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
5157 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
5158 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
5159 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
5163 static const struct alc_model_fixup alc662_fixup_models[] = {
5164 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
5171 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5172 #include "alc662_quirks.c"
5175 static int patch_alc662(struct hda_codec *codec)
5177 struct alc_spec *spec;
5178 int err, board_config;
5181 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5187 spec->mixer_nid = 0x0b;
5189 alc_auto_parse_customize_define(codec);
5191 alc_fix_pll_init(codec, 0x20, 0x04, 15);
5193 coef = alc_read_coef_idx(codec, 0);
5194 if (coef == 0x8020 || coef == 0x8011)
5195 alc_codec_rename(codec, "ALC661");
5196 else if (coef & (1 << 14) &&
5197 codec->bus->pci->subsystem_vendor == 0x1025 &&
5198 spec->cdefine.platform_type == 1)
5199 alc_codec_rename(codec, "ALC272X");
5200 else if (coef == 0x4011)
5201 alc_codec_rename(codec, "ALC656");
5203 board_config = alc_board_config(codec, ALC662_MODEL_LAST,
5204 alc662_models, alc662_cfg_tbl);
5205 if (board_config < 0) {
5206 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5208 board_config = ALC_MODEL_AUTO;
5211 if (board_config == ALC_MODEL_AUTO) {
5212 alc_pick_fixup(codec, alc662_fixup_models,
5213 alc662_fixup_tbl, alc662_fixups);
5214 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5215 /* automatic parse from the BIOS config */
5216 err = alc662_parse_auto_config(codec);
5221 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5224 "hda_codec: Cannot set up configuration "
5225 "from BIOS. Using base mode...\n");
5226 board_config = ALC662_3ST_2ch_DIG;
5231 if (board_config != ALC_MODEL_AUTO)
5232 setup_preset(codec, &alc662_presets[board_config]);
5234 if (!spec->no_analog && !spec->adc_nids) {
5235 alc_auto_fill_adc_caps(codec);
5236 alc_rebuild_imux_for_auto_mic(codec);
5237 alc_remove_invalid_adc_nids(codec);
5240 if (!spec->no_analog && !spec->cap_mixer)
5241 set_capture_mixer(codec);
5243 if (!spec->no_analog && has_cdefine_beep(codec)) {
5244 err = snd_hda_attach_beep_device(codec, 0x1);
5249 switch (codec->vendor_id) {
5251 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5256 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5259 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
5263 spec->vmaster_nid = 0x02;
5265 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5267 codec->patch_ops = alc_patch_ops;
5268 if (board_config == ALC_MODEL_AUTO)
5269 spec->init_hook = alc_auto_init_std;
5270 spec->shutup = alc_eapd_shutup;
5272 alc_init_jacks(codec);
5274 #ifdef CONFIG_SND_HDA_POWER_SAVE
5275 if (!spec->loopback.amplist)
5276 spec->loopback.amplist = alc662_loopbacks;
5282 static int patch_alc888(struct hda_codec *codec)
5284 if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
5285 kfree(codec->chip_name);
5286 if (codec->vendor_id == 0x10ec0887)
5287 codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
5289 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
5290 if (!codec->chip_name) {
5294 return patch_alc662(codec);
5296 return patch_alc882(codec);
5299 static int patch_alc899(struct hda_codec *codec)
5301 if ((alc_read_coef_idx(codec, 0) & 0x2000) != 0x2000) {
5302 kfree(codec->chip_name);
5303 codec->chip_name = kstrdup("ALC898", GFP_KERNEL);
5305 return patch_alc882(codec);
5312 static int alc680_parse_auto_config(struct hda_codec *codec)
5314 return alc_parse_auto_config(codec, NULL, NULL);
5319 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5320 #include "alc680_quirks.c"
5323 static int patch_alc680(struct hda_codec *codec)
5325 struct alc_spec *spec;
5329 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5335 /* ALC680 has no aa-loopback mixer */
5337 board_config = alc_board_config(codec, ALC680_MODEL_LAST,
5338 alc680_models, alc680_cfg_tbl);
5340 if (board_config < 0) {
5341 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5343 board_config = ALC_MODEL_AUTO;
5346 if (board_config == ALC_MODEL_AUTO) {
5347 /* automatic parse from the BIOS config */
5348 err = alc680_parse_auto_config(codec);
5353 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5356 "hda_codec: Cannot set up configuration "
5357 "from BIOS. Using base mode...\n");
5358 board_config = ALC680_BASE;
5363 if (board_config != ALC_MODEL_AUTO) {
5364 setup_preset(codec, &alc680_presets[board_config]);
5365 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5366 spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
5370 if (!spec->no_analog && !spec->adc_nids) {
5371 alc_auto_fill_adc_caps(codec);
5372 alc_rebuild_imux_for_auto_mic(codec);
5373 alc_remove_invalid_adc_nids(codec);
5376 if (!spec->no_analog && !spec->cap_mixer)
5377 set_capture_mixer(codec);
5379 spec->vmaster_nid = 0x02;
5381 codec->patch_ops = alc_patch_ops;
5382 if (board_config == ALC_MODEL_AUTO)
5383 spec->init_hook = alc_auto_init_std;
5391 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
5392 { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
5393 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
5394 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
5395 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
5396 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
5397 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
5398 { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
5399 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
5400 { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
5401 { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
5402 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
5403 .patch = patch_alc861 },
5404 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
5405 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
5406 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
5407 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
5408 .patch = patch_alc882 },
5409 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
5410 .patch = patch_alc662 },
5411 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
5412 { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
5413 { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
5414 { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
5415 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
5416 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
5417 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
5418 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
5419 .patch = patch_alc882 },
5420 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
5421 .patch = patch_alc882 },
5422 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
5423 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
5424 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
5425 .patch = patch_alc882 },
5426 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
5427 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
5428 { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
5429 { .id = 0x10ec0899, .name = "ALC899", .patch = patch_alc899 },
5433 MODULE_ALIAS("snd-hda-codec-id:10ec*");
5435 MODULE_LICENSE("GPL");
5436 MODULE_DESCRIPTION("Realtek HD-audio codec");
5438 static struct hda_codec_preset_list realtek_list = {
5439 .preset = snd_hda_preset_realtek,
5440 .owner = THIS_MODULE,
5443 static int __init patch_realtek_init(void)
5445 return snd_hda_add_codec_preset(&realtek_list);
5448 static void __exit patch_realtek_exit(void)
5450 snd_hda_delete_codec_preset(&realtek_list);
5453 module_init(patch_realtek_init)
5454 module_exit(patch_realtek_exit)