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; NOP when automute_hp_lo isn't set */
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 || (spec->automute_hp_lo && !spec->automute_lines))
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;
569 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.hp_pins),
570 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 spec->line_jack_present =
582 detect_jacks(codec, ARRAY_SIZE(spec->autocfg.line_out_pins),
583 spec->autocfg.line_out_pins);
584 if (!spec->automute || !spec->detect_line)
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_hp_lo || !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 &&
828 (!spec->automute_hp_lo || !spec->automute_lines))
831 spec->automute_lines = 0;
834 if (!spec->automute_hp_lo)
836 if (spec->automute && spec->automute_lines)
839 spec->automute_lines = 1;
844 update_speakers(codec);
848 static const struct snd_kcontrol_new alc_automute_mode_enum = {
849 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
850 .name = "Auto-Mute Mode",
851 .info = alc_automute_mode_info,
852 .get = alc_automute_mode_get,
853 .put = alc_automute_mode_put,
856 static struct snd_kcontrol_new *alc_kcontrol_new(struct alc_spec *spec)
858 snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
859 return snd_array_new(&spec->kctls);
862 static int alc_add_automute_mode_enum(struct hda_codec *codec)
864 struct alc_spec *spec = codec->spec;
865 struct snd_kcontrol_new *knew;
867 knew = alc_kcontrol_new(spec);
870 *knew = alc_automute_mode_enum;
871 knew->name = kstrdup("Auto-Mute Mode", GFP_KERNEL);
878 * Check the availability of HP/line-out auto-mute;
879 * Set up appropriately if really supported
881 static void alc_init_auto_hp(struct hda_codec *codec)
883 struct alc_spec *spec = codec->spec;
884 struct auto_pin_cfg *cfg = &spec->autocfg;
890 if (cfg->line_out_pins[0])
892 if (cfg->speaker_pins[0])
894 if (present < 2) /* need two different output types */
897 spec->automute_hp_lo = 1; /* both HP and LO automute */
899 if (!cfg->speaker_pins[0] &&
900 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
901 memcpy(cfg->speaker_pins, cfg->line_out_pins,
902 sizeof(cfg->speaker_pins));
903 cfg->speaker_outs = cfg->line_outs;
906 if (!cfg->hp_pins[0] &&
907 cfg->line_out_type == AUTO_PIN_HP_OUT) {
908 memcpy(cfg->hp_pins, cfg->line_out_pins,
909 sizeof(cfg->hp_pins));
910 cfg->hp_outs = cfg->line_outs;
913 for (i = 0; i < cfg->hp_outs; i++) {
914 hda_nid_t nid = cfg->hp_pins[i];
915 if (!is_jack_detectable(codec, nid))
917 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
919 snd_hda_codec_write_cache(codec, nid, 0,
920 AC_VERB_SET_UNSOLICITED_ENABLE,
921 AC_USRSP_EN | ALC_HP_EVENT);
923 spec->automute_mode = ALC_AUTOMUTE_PIN;
925 if (spec->automute && cfg->line_out_pins[0] &&
926 cfg->speaker_pins[0] &&
927 cfg->line_out_pins[0] != cfg->hp_pins[0] &&
928 cfg->line_out_pins[0] != cfg->speaker_pins[0]) {
929 for (i = 0; i < cfg->line_outs; i++) {
930 hda_nid_t nid = cfg->line_out_pins[i];
931 if (!is_jack_detectable(codec, nid))
933 snd_printdd("realtek: Enable Line-Out auto-muting "
934 "on NID 0x%x\n", nid);
935 snd_hda_codec_write_cache(codec, nid, 0,
936 AC_VERB_SET_UNSOLICITED_ENABLE,
937 AC_USRSP_EN | ALC_FRONT_EVENT);
938 spec->detect_line = 1;
940 spec->automute_lines = spec->detect_line;
943 if (spec->automute) {
944 /* create a control for automute mode */
945 alc_add_automute_mode_enum(codec);
946 spec->unsol_event = alc_sku_unsol_event;
950 /* return the position of NID in the list, or -1 if not found */
951 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
954 for (i = 0; i < nums; i++)
960 /* check whether dynamic ADC-switching is available */
961 static bool alc_check_dyn_adc_switch(struct hda_codec *codec)
963 struct alc_spec *spec = codec->spec;
964 struct hda_input_mux *imux = &spec->private_imux[0];
968 if (imux != spec->input_mux) /* no dynamic imux? */
971 for (n = 0; n < spec->num_adc_nids; n++) {
972 cap = spec->private_capsrc_nids[n];
973 for (i = 0; i < imux->num_items; i++) {
974 pin = spec->imux_pins[i];
977 if (get_connection_index(codec, cap, pin) < 0)
980 if (i >= imux->num_items)
981 return true; /* no ADC-switch is needed */
984 for (i = 0; i < imux->num_items; i++) {
985 pin = spec->imux_pins[i];
986 for (n = 0; n < spec->num_adc_nids; n++) {
987 cap = spec->private_capsrc_nids[n];
988 idx = get_connection_index(codec, cap, pin);
990 imux->items[i].index = idx;
991 spec->dyn_adc_idx[i] = n;
997 snd_printdd("realtek: enabling ADC switching\n");
998 spec->dyn_adc_switch = 1;
1002 /* rebuild imux for matching with the given auto-mic pins (if not yet) */
1003 static bool alc_rebuild_imux_for_auto_mic(struct hda_codec *codec)
1005 struct alc_spec *spec = codec->spec;
1006 struct hda_input_mux *imux;
1007 static char * const texts[3] = {
1008 "Mic", "Internal Mic", "Dock Mic"
1012 if (!spec->auto_mic)
1014 imux = &spec->private_imux[0];
1015 if (spec->input_mux == imux)
1017 spec->imux_pins[0] = spec->ext_mic_pin;
1018 spec->imux_pins[1] = spec->int_mic_pin;
1019 spec->imux_pins[2] = spec->dock_mic_pin;
1020 for (i = 0; i < 3; i++) {
1021 strcpy(imux->items[i].label, texts[i]);
1022 if (spec->imux_pins[i])
1023 imux->num_items = i + 1;
1025 spec->num_mux_defs = 1;
1026 spec->input_mux = imux;
1030 /* check whether all auto-mic pins are valid; setup indices if OK */
1031 static bool alc_auto_mic_check_imux(struct hda_codec *codec)
1033 struct alc_spec *spec = codec->spec;
1034 const struct hda_input_mux *imux;
1036 if (!spec->auto_mic)
1038 if (spec->auto_mic_valid_imux)
1039 return true; /* already checked */
1041 /* fill up imux indices */
1042 if (!alc_check_dyn_adc_switch(codec)) {
1047 imux = spec->input_mux;
1048 spec->ext_mic_idx = find_idx_in_nid_list(spec->ext_mic_pin,
1049 spec->imux_pins, imux->num_items);
1050 spec->int_mic_idx = find_idx_in_nid_list(spec->int_mic_pin,
1051 spec->imux_pins, imux->num_items);
1052 spec->dock_mic_idx = find_idx_in_nid_list(spec->dock_mic_pin,
1053 spec->imux_pins, imux->num_items);
1054 if (spec->ext_mic_idx < 0 || spec->int_mic_idx < 0) {
1056 return false; /* no corresponding imux */
1059 snd_hda_codec_write_cache(codec, spec->ext_mic_pin, 0,
1060 AC_VERB_SET_UNSOLICITED_ENABLE,
1061 AC_USRSP_EN | ALC_MIC_EVENT);
1062 if (spec->dock_mic_pin)
1063 snd_hda_codec_write_cache(codec, spec->dock_mic_pin, 0,
1064 AC_VERB_SET_UNSOLICITED_ENABLE,
1065 AC_USRSP_EN | ALC_MIC_EVENT);
1067 spec->auto_mic_valid_imux = 1;
1073 * Check the availability of auto-mic switch;
1074 * Set up if really supported
1076 static void alc_init_auto_mic(struct hda_codec *codec)
1078 struct alc_spec *spec = codec->spec;
1079 struct auto_pin_cfg *cfg = &spec->autocfg;
1080 hda_nid_t fixed, ext, dock;
1083 spec->ext_mic_idx = spec->int_mic_idx = spec->dock_mic_idx = -1;
1085 fixed = ext = dock = 0;
1086 for (i = 0; i < cfg->num_inputs; i++) {
1087 hda_nid_t nid = cfg->inputs[i].pin;
1088 unsigned int defcfg;
1089 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1090 switch (snd_hda_get_input_pin_attr(defcfg)) {
1091 case INPUT_PIN_ATTR_INT:
1093 return; /* already occupied */
1094 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1095 return; /* invalid type */
1098 case INPUT_PIN_ATTR_UNUSED:
1099 return; /* invalid entry */
1100 case INPUT_PIN_ATTR_DOCK:
1102 return; /* already occupied */
1103 if (cfg->inputs[i].type > AUTO_PIN_LINE_IN)
1104 return; /* invalid type */
1109 return; /* already occupied */
1110 if (cfg->inputs[i].type != AUTO_PIN_MIC)
1111 return; /* invalid type */
1122 if (!is_jack_detectable(codec, ext))
1123 return; /* no unsol support */
1124 if (dock && !is_jack_detectable(codec, dock))
1125 return; /* no unsol support */
1127 /* check imux indices */
1128 spec->ext_mic_pin = ext;
1129 spec->int_mic_pin = fixed;
1130 spec->dock_mic_pin = dock;
1133 if (!alc_auto_mic_check_imux(codec))
1136 snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x/0x%x\n",
1138 spec->unsol_event = alc_sku_unsol_event;
1141 /* check the availabilities of auto-mute and auto-mic switches */
1142 static void alc_auto_check_switches(struct hda_codec *codec)
1144 alc_init_auto_hp(codec);
1145 alc_init_auto_mic(codec);
1149 * Realtek SSID verification
1152 /* Could be any non-zero and even value. When used as fixup, tells
1153 * the driver to ignore any present sku defines.
1155 #define ALC_FIXUP_SKU_IGNORE (2)
1157 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1159 unsigned int ass, tmp, i;
1161 struct alc_spec *spec = codec->spec;
1163 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1165 if (spec->cdefine.fixup) {
1166 ass = spec->cdefine.sku_cfg;
1167 if (ass == ALC_FIXUP_SKU_IGNORE)
1172 ass = codec->subsystem_id & 0xffff;
1173 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1177 if (codec->vendor_id == 0x10ec0260)
1179 ass = snd_hda_codec_get_pincfg(codec, nid);
1182 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1183 codec->chip_name, ass);
1189 for (i = 1; i < 16; i++) {
1193 if (((ass >> 16) & 0xf) != tmp)
1196 spec->cdefine.port_connectivity = ass >> 30;
1197 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1198 spec->cdefine.check_sum = (ass >> 16) & 0xf;
1199 spec->cdefine.customization = ass >> 8;
1201 spec->cdefine.sku_cfg = ass;
1202 spec->cdefine.external_amp = (ass & 0x38) >> 3;
1203 spec->cdefine.platform_type = (ass & 0x4) >> 2;
1204 spec->cdefine.swap = (ass & 0x2) >> 1;
1205 spec->cdefine.override = ass & 0x1;
1207 snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1208 nid, spec->cdefine.sku_cfg);
1209 snd_printd("SKU: port_connectivity=0x%x\n",
1210 spec->cdefine.port_connectivity);
1211 snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1212 snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1213 snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1214 snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1215 snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1216 snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1217 snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1222 /* return true if the given NID is found in the list */
1223 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
1225 return find_idx_in_nid_list(nid, list, nums) >= 0;
1228 /* check subsystem ID and set up device-specific initialization;
1229 * return 1 if initialized, 0 if invalid SSID
1231 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1232 * 31 ~ 16 : Manufacture ID
1234 * 7 ~ 0 : Assembly ID
1235 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1237 static int alc_subsystem_id(struct hda_codec *codec,
1238 hda_nid_t porta, hda_nid_t porte,
1239 hda_nid_t portd, hda_nid_t porti)
1241 unsigned int ass, tmp, i;
1243 struct alc_spec *spec = codec->spec;
1245 if (spec->cdefine.fixup) {
1246 ass = spec->cdefine.sku_cfg;
1247 if (ass == ALC_FIXUP_SKU_IGNORE)
1252 ass = codec->subsystem_id & 0xffff;
1253 if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1256 /* invalid SSID, check the special NID pin defcfg instead */
1258 * 31~30 : port connectivity
1261 * 19~16 : Check sum (15:1)
1266 if (codec->vendor_id == 0x10ec0260)
1268 ass = snd_hda_codec_get_pincfg(codec, nid);
1269 snd_printd("realtek: No valid SSID, "
1270 "checking pincfg 0x%08x for NID 0x%x\n",
1274 if ((ass >> 30) != 1) /* no physical connection */
1279 for (i = 1; i < 16; i++) {
1283 if (((ass >> 16) & 0xf) != tmp)
1286 snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1287 ass & 0xffff, codec->vendor_id);
1291 * 2 : 0 --> Desktop, 1 --> Laptop
1292 * 3~5 : External Amplifier control
1295 tmp = (ass & 0x38) >> 3; /* external Amp control */
1298 spec->init_amp = ALC_INIT_GPIO1;
1301 spec->init_amp = ALC_INIT_GPIO2;
1304 spec->init_amp = ALC_INIT_GPIO3;
1308 spec->init_amp = ALC_INIT_DEFAULT;
1312 /* is laptop or Desktop and enable the function "Mute internal speaker
1313 * when the external headphone out jack is plugged"
1315 if (!(ass & 0x8000))
1318 * 10~8 : Jack location
1319 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1321 * 15 : 1 --> enable the function "Mute internal speaker
1322 * when the external headphone out jack is plugged"
1324 if (!spec->autocfg.hp_pins[0]) {
1326 tmp = (ass >> 11) & 0x3; /* HP to chassis */
1337 if (found_in_nid_list(nid, spec->autocfg.line_out_pins,
1338 spec->autocfg.line_outs))
1340 spec->autocfg.hp_pins[0] = nid;
1345 /* Check the validity of ALC subsystem-id
1346 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
1347 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
1349 if (!alc_subsystem_id(codec, ports[0], ports[1], ports[2], ports[3])) {
1350 struct alc_spec *spec = codec->spec;
1351 snd_printd("realtek: "
1352 "Enable default setup for auto mode as fallback\n");
1353 spec->init_amp = ALC_INIT_DEFAULT;
1358 * Fix-up pin default configurations and add default verbs
1366 struct alc_model_fixup {
1377 const struct alc_pincfg *pins;
1378 const struct hda_verb *verbs;
1379 void (*func)(struct hda_codec *codec,
1380 const struct alc_fixup *fix,
1394 ALC_FIXUP_ACT_PRE_PROBE,
1395 ALC_FIXUP_ACT_PROBE,
1399 static void alc_apply_fixup(struct hda_codec *codec, int action)
1401 struct alc_spec *spec = codec->spec;
1402 int id = spec->fixup_id;
1403 #ifdef CONFIG_SND_DEBUG_VERBOSE
1404 const char *modelname = spec->fixup_name;
1408 if (!spec->fixup_list)
1412 const struct alc_fixup *fix = spec->fixup_list + id;
1413 const struct alc_pincfg *cfg;
1415 switch (fix->type) {
1417 if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1419 snd_printdd(KERN_INFO "hda_codec: %s: "
1420 "Apply sku override for %s\n",
1421 codec->chip_name, modelname);
1422 spec->cdefine.sku_cfg = fix->v.sku;
1423 spec->cdefine.fixup = 1;
1425 case ALC_FIXUP_PINS:
1427 if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1429 snd_printdd(KERN_INFO "hda_codec: %s: "
1430 "Apply pincfg for %s\n",
1431 codec->chip_name, modelname);
1432 for (; cfg->nid; cfg++)
1433 snd_hda_codec_set_pincfg(codec, cfg->nid,
1436 case ALC_FIXUP_VERBS:
1437 if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1439 snd_printdd(KERN_INFO "hda_codec: %s: "
1440 "Apply fix-verbs for %s\n",
1441 codec->chip_name, modelname);
1442 add_verb(codec->spec, fix->v.verbs);
1444 case ALC_FIXUP_FUNC:
1447 snd_printdd(KERN_INFO "hda_codec: %s: "
1448 "Apply fix-func for %s\n",
1449 codec->chip_name, modelname);
1450 fix->v.func(codec, fix, action);
1453 snd_printk(KERN_ERR "hda_codec: %s: "
1454 "Invalid fixup type %d\n",
1455 codec->chip_name, fix->type);
1466 static void alc_pick_fixup(struct hda_codec *codec,
1467 const struct alc_model_fixup *models,
1468 const struct snd_pci_quirk *quirk,
1469 const struct alc_fixup *fixlist)
1471 struct alc_spec *spec = codec->spec;
1473 const char *name = NULL;
1475 if (codec->modelname && models) {
1476 while (models->name) {
1477 if (!strcmp(codec->modelname, models->name)) {
1479 name = models->name;
1486 quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1489 #ifdef CONFIG_SND_DEBUG_VERBOSE
1495 spec->fixup_id = id;
1497 spec->fixup_list = fixlist;
1498 spec->fixup_name = name;
1503 * COEF access helper functions
1505 static int alc_read_coef_idx(struct hda_codec *codec,
1506 unsigned int coef_idx)
1509 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1511 val = snd_hda_codec_read(codec, 0x20, 0,
1512 AC_VERB_GET_PROC_COEF, 0);
1516 static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1517 unsigned int coef_val)
1519 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1521 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1526 * Digital I/O handling
1529 /* set right pin controls for digital I/O */
1530 static void alc_auto_init_digital(struct hda_codec *codec)
1532 struct alc_spec *spec = codec->spec;
1536 for (i = 0; i < spec->autocfg.dig_outs; i++) {
1537 pin = spec->autocfg.dig_out_pins[i];
1540 snd_hda_codec_write(codec, pin, 0,
1541 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
1543 dac = spec->multiout.dig_out_nid;
1545 dac = spec->slave_dig_outs[i - 1];
1546 if (!dac || !(get_wcaps(codec, dac) & AC_WCAP_OUT_AMP))
1548 snd_hda_codec_write(codec, dac, 0,
1549 AC_VERB_SET_AMP_GAIN_MUTE,
1552 pin = spec->autocfg.dig_in_pin;
1554 snd_hda_codec_write(codec, pin, 0,
1555 AC_VERB_SET_PIN_WIDGET_CONTROL,
1559 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1560 static void alc_auto_parse_digital(struct hda_codec *codec)
1562 struct alc_spec *spec = codec->spec;
1566 /* support multiple SPDIFs; the secondary is set up as a slave */
1567 for (i = 0; i < spec->autocfg.dig_outs; i++) {
1569 err = snd_hda_get_connections(codec,
1570 spec->autocfg.dig_out_pins[i],
1571 conn, ARRAY_SIZE(conn));
1574 dig_nid = conn[0]; /* assume the first element is audio-out */
1576 spec->multiout.dig_out_nid = dig_nid;
1577 spec->dig_out_type = spec->autocfg.dig_out_type[0];
1579 spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1580 if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1582 spec->slave_dig_outs[i - 1] = dig_nid;
1586 if (spec->autocfg.dig_in_pin) {
1587 dig_nid = codec->start_nid;
1588 for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1589 unsigned int wcaps = get_wcaps(codec, dig_nid);
1590 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1592 if (!(wcaps & AC_WCAP_DIGITAL))
1594 if (!(wcaps & AC_WCAP_CONN_LIST))
1596 err = get_connection_index(codec, dig_nid,
1597 spec->autocfg.dig_in_pin);
1599 spec->dig_in_nid = dig_nid;
1607 * capture mixer elements
1609 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1610 struct snd_ctl_elem_info *uinfo)
1612 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1613 struct alc_spec *spec = codec->spec;
1617 mutex_lock(&codec->control_mutex);
1618 if (spec->vol_in_capsrc)
1619 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1621 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1622 kcontrol->private_value = val;
1623 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1624 mutex_unlock(&codec->control_mutex);
1628 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1629 unsigned int size, unsigned int __user *tlv)
1631 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1632 struct alc_spec *spec = codec->spec;
1636 mutex_lock(&codec->control_mutex);
1637 if (spec->vol_in_capsrc)
1638 val = HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[0], 3, 0, HDA_OUTPUT);
1640 val = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0, HDA_INPUT);
1641 kcontrol->private_value = val;
1642 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1643 mutex_unlock(&codec->control_mutex);
1647 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1648 struct snd_ctl_elem_value *ucontrol);
1650 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1651 struct snd_ctl_elem_value *ucontrol,
1652 getput_call_t func, bool check_adc_switch)
1654 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1655 struct alc_spec *spec = codec->spec;
1658 mutex_lock(&codec->control_mutex);
1659 if (check_adc_switch && spec->dyn_adc_switch) {
1660 for (i = 0; i < spec->num_adc_nids; i++) {
1661 kcontrol->private_value =
1662 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1664 err = func(kcontrol, ucontrol);
1669 i = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1670 if (spec->vol_in_capsrc)
1671 kcontrol->private_value =
1672 HDA_COMPOSE_AMP_VAL(spec->capsrc_nids[i],
1675 kcontrol->private_value =
1676 HDA_COMPOSE_AMP_VAL(spec->adc_nids[i],
1678 err = func(kcontrol, ucontrol);
1681 mutex_unlock(&codec->control_mutex);
1685 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1686 struct snd_ctl_elem_value *ucontrol)
1688 return alc_cap_getput_caller(kcontrol, ucontrol,
1689 snd_hda_mixer_amp_volume_get, false);
1692 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1693 struct snd_ctl_elem_value *ucontrol)
1695 return alc_cap_getput_caller(kcontrol, ucontrol,
1696 snd_hda_mixer_amp_volume_put, true);
1699 /* capture mixer elements */
1700 #define alc_cap_sw_info snd_ctl_boolean_stereo_info
1702 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1703 struct snd_ctl_elem_value *ucontrol)
1705 return alc_cap_getput_caller(kcontrol, ucontrol,
1706 snd_hda_mixer_amp_switch_get, false);
1709 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1710 struct snd_ctl_elem_value *ucontrol)
1712 return alc_cap_getput_caller(kcontrol, ucontrol,
1713 snd_hda_mixer_amp_switch_put, true);
1716 #define _DEFINE_CAPMIX(num) \
1718 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1719 .name = "Capture Switch", \
1720 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1722 .info = alc_cap_sw_info, \
1723 .get = alc_cap_sw_get, \
1724 .put = alc_cap_sw_put, \
1727 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1728 .name = "Capture Volume", \
1729 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1730 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1731 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1733 .info = alc_cap_vol_info, \
1734 .get = alc_cap_vol_get, \
1735 .put = alc_cap_vol_put, \
1736 .tlv = { .c = alc_cap_vol_tlv }, \
1739 #define _DEFINE_CAPSRC(num) \
1741 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1742 /* .name = "Capture Source", */ \
1743 .name = "Input Source", \
1745 .info = alc_mux_enum_info, \
1746 .get = alc_mux_enum_get, \
1747 .put = alc_mux_enum_put, \
1750 #define DEFINE_CAPMIX(num) \
1751 static const struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1752 _DEFINE_CAPMIX(num), \
1753 _DEFINE_CAPSRC(num), \
1757 #define DEFINE_CAPMIX_NOSRC(num) \
1758 static const struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1759 _DEFINE_CAPMIX(num), \
1763 /* up to three ADCs */
1767 DEFINE_CAPMIX_NOSRC(1);
1768 DEFINE_CAPMIX_NOSRC(2);
1769 DEFINE_CAPMIX_NOSRC(3);
1772 * virtual master controls
1776 * slave controls for virtual master
1778 static const char * const alc_slave_vols[] = {
1779 "Front Playback Volume",
1780 "Surround Playback Volume",
1781 "Center Playback Volume",
1782 "LFE Playback Volume",
1783 "Side Playback Volume",
1784 "Headphone Playback Volume",
1785 "Speaker Playback Volume",
1786 "Mono Playback Volume",
1787 "Line-Out Playback Volume",
1788 "PCM Playback Volume",
1792 static const char * const alc_slave_sws[] = {
1793 "Front Playback Switch",
1794 "Surround Playback Switch",
1795 "Center Playback Switch",
1796 "LFE Playback Switch",
1797 "Side Playback Switch",
1798 "Headphone Playback Switch",
1799 "Speaker Playback Switch",
1800 "Mono Playback Switch",
1801 "IEC958 Playback Switch",
1802 "Line-Out Playback Switch",
1803 "PCM Playback Switch",
1808 * build control elements
1811 #define NID_MAPPING (-1)
1813 #define SUBDEV_SPEAKER_ (0 << 6)
1814 #define SUBDEV_HP_ (1 << 6)
1815 #define SUBDEV_LINE_ (2 << 6)
1816 #define SUBDEV_SPEAKER(x) (SUBDEV_SPEAKER_ | ((x) & 0x3f))
1817 #define SUBDEV_HP(x) (SUBDEV_HP_ | ((x) & 0x3f))
1818 #define SUBDEV_LINE(x) (SUBDEV_LINE_ | ((x) & 0x3f))
1820 static void alc_free_kctls(struct hda_codec *codec);
1822 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1823 /* additional beep mixers; the actual parameters are overwritten at build */
1824 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1825 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1826 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1831 static int alc_build_controls(struct hda_codec *codec)
1833 struct alc_spec *spec = codec->spec;
1834 struct snd_kcontrol *kctl = NULL;
1835 const struct snd_kcontrol_new *knew;
1840 for (i = 0; i < spec->num_mixers; i++) {
1841 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1845 if (spec->cap_mixer) {
1846 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
1850 if (spec->multiout.dig_out_nid) {
1851 err = snd_hda_create_spdif_out_ctls(codec,
1852 spec->multiout.dig_out_nid,
1853 spec->multiout.dig_out_nid);
1856 if (!spec->no_analog) {
1857 err = snd_hda_create_spdif_share_sw(codec,
1861 spec->multiout.share_spdif = 1;
1864 if (spec->dig_in_nid) {
1865 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1870 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1871 /* create beep controls if needed */
1872 if (spec->beep_amp) {
1873 const struct snd_kcontrol_new *knew;
1874 for (knew = alc_beep_mixer; knew->name; knew++) {
1875 struct snd_kcontrol *kctl;
1876 kctl = snd_ctl_new1(knew, codec);
1879 kctl->private_value = spec->beep_amp;
1880 err = snd_hda_ctl_add(codec, 0, kctl);
1887 /* if we have no master control, let's create it */
1888 if (!spec->no_analog &&
1889 !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1890 unsigned int vmaster_tlv[4];
1891 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
1892 HDA_OUTPUT, vmaster_tlv);
1893 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1894 vmaster_tlv, alc_slave_vols);
1898 if (!spec->no_analog &&
1899 !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1900 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1901 NULL, alc_slave_sws);
1906 /* assign Capture Source enums to NID */
1907 if (spec->capsrc_nids || spec->adc_nids) {
1908 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
1910 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1911 for (i = 0; kctl && i < kctl->count; i++) {
1912 const hda_nid_t *nids = spec->capsrc_nids;
1914 nids = spec->adc_nids;
1915 err = snd_hda_add_nid(codec, kctl, i, nids[i]);
1920 if (spec->cap_mixer && spec->adc_nids) {
1921 const char *kname = kctl ? kctl->id.name : NULL;
1922 for (knew = spec->cap_mixer; knew->name; knew++) {
1923 if (kname && strcmp(knew->name, kname) == 0)
1925 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
1926 for (i = 0; kctl && i < kctl->count; i++) {
1927 err = snd_hda_add_nid(codec, kctl, i,
1935 /* other nid->control mapping */
1936 for (i = 0; i < spec->num_mixers; i++) {
1937 for (knew = spec->mixers[i]; knew->name; knew++) {
1938 if (knew->iface != NID_MAPPING)
1940 kctl = snd_hda_find_mixer_ctl(codec, knew->name);
1943 u = knew->subdevice;
1944 for (j = 0; j < 4; j++, u >>= 8) {
1949 case SUBDEV_SPEAKER_:
1950 nid = spec->autocfg.speaker_pins[nid];
1953 nid = spec->autocfg.line_out_pins[nid];
1956 nid = spec->autocfg.hp_pins[nid];
1961 err = snd_hda_add_nid(codec, kctl, 0, nid);
1965 u = knew->private_value;
1966 for (j = 0; j < 4; j++, u >>= 8) {
1970 err = snd_hda_add_nid(codec, kctl, 0, nid);
1977 alc_free_kctls(codec); /* no longer needed */
1987 static void alc_init_special_input_src(struct hda_codec *codec);
1989 static int alc_init(struct hda_codec *codec)
1991 struct alc_spec *spec = codec->spec;
1995 alc_auto_init_amp(codec, spec->init_amp);
1997 for (i = 0; i < spec->num_init_verbs; i++)
1998 snd_hda_sequence_write(codec, spec->init_verbs[i]);
1999 alc_init_special_input_src(codec);
2001 if (spec->init_hook)
2002 spec->init_hook(codec);
2004 alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
2006 hda_call_check_power_status(codec, 0x01);
2010 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2012 struct alc_spec *spec = codec->spec;
2014 if (spec->unsol_event)
2015 spec->unsol_event(codec, res);
2018 #ifdef CONFIG_SND_HDA_POWER_SAVE
2019 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2021 struct alc_spec *spec = codec->spec;
2022 return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2027 * Analog playback callbacks
2029 static int alc_playback_pcm_open(struct hda_pcm_stream *hinfo,
2030 struct hda_codec *codec,
2031 struct snd_pcm_substream *substream)
2033 struct alc_spec *spec = codec->spec;
2034 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2038 static int alc_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2039 struct hda_codec *codec,
2040 unsigned int stream_tag,
2041 unsigned int format,
2042 struct snd_pcm_substream *substream)
2044 struct alc_spec *spec = codec->spec;
2045 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2046 stream_tag, format, substream);
2049 static int alc_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2050 struct hda_codec *codec,
2051 struct snd_pcm_substream *substream)
2053 struct alc_spec *spec = codec->spec;
2054 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2060 static int alc_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2061 struct hda_codec *codec,
2062 struct snd_pcm_substream *substream)
2064 struct alc_spec *spec = codec->spec;
2065 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2068 static int alc_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2069 struct hda_codec *codec,
2070 unsigned int stream_tag,
2071 unsigned int format,
2072 struct snd_pcm_substream *substream)
2074 struct alc_spec *spec = codec->spec;
2075 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2076 stream_tag, format, substream);
2079 static int alc_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2080 struct hda_codec *codec,
2081 struct snd_pcm_substream *substream)
2083 struct alc_spec *spec = codec->spec;
2084 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2087 static int alc_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2088 struct hda_codec *codec,
2089 struct snd_pcm_substream *substream)
2091 struct alc_spec *spec = codec->spec;
2092 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2098 static int alc_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2099 struct hda_codec *codec,
2100 unsigned int stream_tag,
2101 unsigned int format,
2102 struct snd_pcm_substream *substream)
2104 struct alc_spec *spec = codec->spec;
2106 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2107 stream_tag, 0, format);
2111 static int alc_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2112 struct hda_codec *codec,
2113 struct snd_pcm_substream *substream)
2115 struct alc_spec *spec = codec->spec;
2117 snd_hda_codec_cleanup_stream(codec,
2118 spec->adc_nids[substream->number + 1]);
2122 /* analog capture with dynamic dual-adc changes */
2123 static int dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2124 struct hda_codec *codec,
2125 unsigned int stream_tag,
2126 unsigned int format,
2127 struct snd_pcm_substream *substream)
2129 struct alc_spec *spec = codec->spec;
2130 spec->cur_adc = spec->adc_nids[spec->dyn_adc_idx[spec->cur_mux[0]]];
2131 spec->cur_adc_stream_tag = stream_tag;
2132 spec->cur_adc_format = format;
2133 snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
2137 static int dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2138 struct hda_codec *codec,
2139 struct snd_pcm_substream *substream)
2141 struct alc_spec *spec = codec->spec;
2142 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
2147 static const struct hda_pcm_stream dyn_adc_pcm_analog_capture = {
2151 .nid = 0, /* fill later */
2153 .prepare = dyn_adc_capture_pcm_prepare,
2154 .cleanup = dyn_adc_capture_pcm_cleanup
2160 static const struct hda_pcm_stream alc_pcm_analog_playback = {
2164 /* NID is set in alc_build_pcms */
2166 .open = alc_playback_pcm_open,
2167 .prepare = alc_playback_pcm_prepare,
2168 .cleanup = alc_playback_pcm_cleanup
2172 static const struct hda_pcm_stream alc_pcm_analog_capture = {
2176 /* NID is set in alc_build_pcms */
2179 static const struct hda_pcm_stream alc_pcm_analog_alt_playback = {
2183 /* NID is set in alc_build_pcms */
2186 static const struct hda_pcm_stream alc_pcm_analog_alt_capture = {
2187 .substreams = 2, /* can be overridden */
2190 /* NID is set in alc_build_pcms */
2192 .prepare = alc_alt_capture_pcm_prepare,
2193 .cleanup = alc_alt_capture_pcm_cleanup
2197 static const struct hda_pcm_stream alc_pcm_digital_playback = {
2201 /* NID is set in alc_build_pcms */
2203 .open = alc_dig_playback_pcm_open,
2204 .close = alc_dig_playback_pcm_close,
2205 .prepare = alc_dig_playback_pcm_prepare,
2206 .cleanup = alc_dig_playback_pcm_cleanup
2210 static const struct hda_pcm_stream alc_pcm_digital_capture = {
2214 /* NID is set in alc_build_pcms */
2217 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
2218 static const struct hda_pcm_stream alc_pcm_null_stream = {
2224 static int alc_build_pcms(struct hda_codec *codec)
2226 struct alc_spec *spec = codec->spec;
2227 struct hda_pcm *info = spec->pcm_rec;
2228 const struct hda_pcm_stream *p;
2231 codec->num_pcms = 1;
2232 codec->pcm_info = info;
2234 if (spec->no_analog)
2237 snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
2238 "%s Analog", codec->chip_name);
2239 info->name = spec->stream_name_analog;
2241 if (spec->multiout.dac_nids > 0) {
2242 p = spec->stream_analog_playback;
2244 p = &alc_pcm_analog_playback;
2245 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2246 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
2248 if (spec->adc_nids) {
2249 p = spec->stream_analog_capture;
2251 if (spec->dyn_adc_switch)
2252 p = &dyn_adc_pcm_analog_capture;
2254 p = &alc_pcm_analog_capture;
2256 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2257 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2260 if (spec->channel_mode) {
2261 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
2262 for (i = 0; i < spec->num_channel_mode; i++) {
2263 if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
2264 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
2270 /* SPDIF for stream index #1 */
2271 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2272 snprintf(spec->stream_name_digital,
2273 sizeof(spec->stream_name_digital),
2274 "%s Digital", codec->chip_name);
2275 codec->num_pcms = 2;
2276 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
2277 info = spec->pcm_rec + 1;
2278 info->name = spec->stream_name_digital;
2279 if (spec->dig_out_type)
2280 info->pcm_type = spec->dig_out_type;
2282 info->pcm_type = HDA_PCM_TYPE_SPDIF;
2283 if (spec->multiout.dig_out_nid) {
2284 p = spec->stream_digital_playback;
2286 p = &alc_pcm_digital_playback;
2287 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2288 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2290 if (spec->dig_in_nid) {
2291 p = spec->stream_digital_capture;
2293 p = &alc_pcm_digital_capture;
2294 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2295 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2297 /* FIXME: do we need this for all Realtek codec models? */
2298 codec->spdif_status_reset = 1;
2301 if (spec->no_analog)
2304 /* If the use of more than one ADC is requested for the current
2305 * model, configure a second analog capture-only PCM.
2307 /* Additional Analaog capture for index #2 */
2308 if (spec->alt_dac_nid || spec->num_adc_nids > 1) {
2309 codec->num_pcms = 3;
2310 info = spec->pcm_rec + 2;
2311 info->name = spec->stream_name_analog;
2312 if (spec->alt_dac_nid) {
2313 p = spec->stream_analog_alt_playback;
2315 p = &alc_pcm_analog_alt_playback;
2316 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *p;
2317 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2320 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
2321 alc_pcm_null_stream;
2322 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
2324 if (spec->num_adc_nids > 1) {
2325 p = spec->stream_analog_alt_capture;
2327 p = &alc_pcm_analog_alt_capture;
2328 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *p;
2329 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
2331 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
2332 spec->num_adc_nids - 1;
2334 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
2335 alc_pcm_null_stream;
2336 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
2343 static inline void alc_shutup(struct hda_codec *codec)
2345 struct alc_spec *spec = codec->spec;
2347 if (spec && spec->shutup)
2348 spec->shutup(codec);
2349 snd_hda_shutup_pins(codec);
2352 static void alc_free_kctls(struct hda_codec *codec)
2354 struct alc_spec *spec = codec->spec;
2356 if (spec->kctls.list) {
2357 struct snd_kcontrol_new *kctl = spec->kctls.list;
2359 for (i = 0; i < spec->kctls.used; i++)
2360 kfree(kctl[i].name);
2362 snd_array_free(&spec->kctls);
2365 static void alc_free(struct hda_codec *codec)
2367 struct alc_spec *spec = codec->spec;
2373 snd_hda_input_jack_free(codec);
2374 alc_free_kctls(codec);
2376 snd_hda_detach_beep_device(codec);
2379 #ifdef CONFIG_SND_HDA_POWER_SAVE
2380 static void alc_power_eapd(struct hda_codec *codec)
2382 alc_auto_setup_eapd(codec, false);
2385 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
2387 struct alc_spec *spec = codec->spec;
2389 if (spec && spec->power_hook)
2390 spec->power_hook(codec);
2396 static int alc_resume(struct hda_codec *codec)
2398 msleep(150); /* to avoid pop noise */
2399 codec->patch_ops.init(codec);
2400 snd_hda_codec_resume_amp(codec);
2401 snd_hda_codec_resume_cache(codec);
2402 hda_call_check_power_status(codec, 0x01);
2409 static const struct hda_codec_ops alc_patch_ops = {
2410 .build_controls = alc_build_controls,
2411 .build_pcms = alc_build_pcms,
2414 .unsol_event = alc_unsol_event,
2416 .resume = alc_resume,
2418 #ifdef CONFIG_SND_HDA_POWER_SAVE
2419 .suspend = alc_suspend,
2420 .check_power_status = alc_check_power_status,
2422 .reboot_notify = alc_shutup,
2425 /* replace the codec chip_name with the given string */
2426 static int alc_codec_rename(struct hda_codec *codec, const char *name)
2428 kfree(codec->chip_name);
2429 codec->chip_name = kstrdup(name, GFP_KERNEL);
2430 if (!codec->chip_name) {
2438 * Automatic parse of I/O pins from the BIOS configuration
2443 ALC_CTL_WIDGET_MUTE,
2446 static const struct snd_kcontrol_new alc_control_templates[] = {
2447 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2448 HDA_CODEC_MUTE(NULL, 0, 0, 0),
2449 HDA_BIND_MUTE(NULL, 0, 0, 0),
2452 /* add dynamic controls */
2453 static int add_control(struct alc_spec *spec, int type, const char *name,
2454 int cidx, unsigned long val)
2456 struct snd_kcontrol_new *knew;
2458 knew = alc_kcontrol_new(spec);
2461 *knew = alc_control_templates[type];
2462 knew->name = kstrdup(name, GFP_KERNEL);
2466 if (get_amp_nid_(val))
2467 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
2468 knew->private_value = val;
2472 static int add_control_with_pfx(struct alc_spec *spec, int type,
2473 const char *pfx, const char *dir,
2474 const char *sfx, int cidx, unsigned long val)
2477 snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
2478 return add_control(spec, type, name, cidx, val);
2481 #define add_pb_vol_ctrl(spec, type, pfx, val) \
2482 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
2483 #define add_pb_sw_ctrl(spec, type, pfx, val) \
2484 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
2485 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \
2486 add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
2487 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \
2488 add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
2490 static const char *alc_get_line_out_pfx(struct alc_spec *spec, int ch,
2491 bool can_be_master, int *index)
2493 struct auto_pin_cfg *cfg = &spec->autocfg;
2494 static const char * const chname[4] = {
2495 "Front", "Surround", NULL /*CLFE*/, "Side"
2499 if (cfg->line_outs == 1 && !spec->multi_ios &&
2500 !cfg->hp_outs && !cfg->speaker_outs && can_be_master)
2503 switch (cfg->line_out_type) {
2504 case AUTO_PIN_SPEAKER_OUT:
2505 if (cfg->line_outs == 1)
2508 case AUTO_PIN_HP_OUT:
2509 /* for multi-io case, only the primary out */
2510 if (ch && spec->multi_ios)
2515 if (cfg->line_outs == 1 && !spec->multi_ios)
2522 /* create input playback/capture controls for the given pin */
2523 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
2524 const char *ctlname, int ctlidx,
2525 int idx, hda_nid_t mix_nid)
2529 err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
2530 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2533 err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
2534 HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
2540 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
2542 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2543 return (pincap & AC_PINCAP_IN) != 0;
2546 /* Parse the codec tree and retrieve ADCs and corresponding capsrc MUXs */
2547 static int alc_auto_fill_adc_caps(struct hda_codec *codec)
2549 struct alc_spec *spec = codec->spec;
2551 hda_nid_t *adc_nids = spec->private_adc_nids;
2552 hda_nid_t *cap_nids = spec->private_capsrc_nids;
2553 int max_nums = ARRAY_SIZE(spec->private_adc_nids);
2554 bool indep_capsrc = false;
2557 nid = codec->start_nid;
2558 for (i = 0; i < codec->num_nodes; i++, nid++) {
2560 const hda_nid_t *list;
2561 unsigned int caps = get_wcaps(codec, nid);
2562 int type = get_wcaps_type(caps);
2564 if (type != AC_WID_AUD_IN || (caps & AC_WCAP_DIGITAL))
2566 adc_nids[nums] = nid;
2567 cap_nids[nums] = nid;
2571 type = get_wcaps_type(get_wcaps(codec, src));
2572 if (type == AC_WID_PIN)
2574 if (type == AC_WID_AUD_SEL) {
2575 cap_nids[nums] = src;
2576 indep_capsrc = true;
2579 n = snd_hda_get_conn_list(codec, src, &list);
2581 cap_nids[nums] = src;
2582 indep_capsrc = true;
2588 if (++nums >= max_nums)
2591 spec->adc_nids = spec->private_adc_nids;
2592 spec->capsrc_nids = spec->private_capsrc_nids;
2593 spec->num_adc_nids = nums;
2597 /* create playback/capture controls for input pins */
2598 static int alc_auto_create_input_ctls(struct hda_codec *codec)
2600 struct alc_spec *spec = codec->spec;
2601 const struct auto_pin_cfg *cfg = &spec->autocfg;
2602 hda_nid_t mixer = spec->mixer_nid;
2603 struct hda_input_mux *imux = &spec->private_imux[0];
2605 int i, c, err, idx, type_idx = 0;
2606 const char *prev_label = NULL;
2608 num_adcs = alc_auto_fill_adc_caps(codec);
2612 for (i = 0; i < cfg->num_inputs; i++) {
2616 pin = cfg->inputs[i].pin;
2617 if (!alc_is_input_pin(codec, pin))
2620 label = hda_get_autocfg_input_label(codec, cfg, i);
2621 if (prev_label && !strcmp(label, prev_label))
2628 idx = get_connection_index(codec, mixer, pin);
2630 err = new_analog_input(spec, pin,
2638 for (c = 0; c < num_adcs; c++) {
2639 hda_nid_t cap = spec->capsrc_nids ?
2640 spec->capsrc_nids[c] : spec->adc_nids[c];
2641 idx = get_connection_index(codec, cap, pin);
2643 spec->imux_pins[imux->num_items] = pin;
2644 snd_hda_add_imux_item(imux, label, idx, NULL);
2650 spec->num_mux_defs = 1;
2651 spec->input_mux = imux;
2656 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
2657 unsigned int pin_type)
2659 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2662 if (nid_has_mute(codec, nid, HDA_OUTPUT))
2663 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2667 static int get_pin_type(int line_out_type)
2669 if (line_out_type == AUTO_PIN_HP_OUT)
2675 static void alc_auto_init_analog_input(struct hda_codec *codec)
2677 struct alc_spec *spec = codec->spec;
2678 struct auto_pin_cfg *cfg = &spec->autocfg;
2681 for (i = 0; i < cfg->num_inputs; i++) {
2682 hda_nid_t nid = cfg->inputs[i].pin;
2683 if (alc_is_input_pin(codec, nid)) {
2684 alc_set_input_pin(codec, nid, cfg->inputs[i].type);
2685 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
2686 snd_hda_codec_write(codec, nid, 0,
2687 AC_VERB_SET_AMP_GAIN_MUTE,
2692 /* mute all loopback inputs */
2693 if (spec->mixer_nid) {
2694 int nums = snd_hda_get_conn_list(codec, spec->mixer_nid, NULL);
2695 for (i = 0; i < nums; i++)
2696 snd_hda_codec_write(codec, spec->mixer_nid, 0,
2697 AC_VERB_SET_AMP_GAIN_MUTE,
2702 /* convert from MIX nid to DAC */
2703 static hda_nid_t alc_auto_mix_to_dac(struct hda_codec *codec, hda_nid_t nid)
2708 if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_AUD_OUT)
2710 num = snd_hda_get_connections(codec, nid, list, ARRAY_SIZE(list));
2711 for (i = 0; i < num; i++) {
2712 if (get_wcaps_type(get_wcaps(codec, list[i])) == AC_WID_AUD_OUT)
2718 /* go down to the selector widget before the mixer */
2719 static hda_nid_t alc_go_down_to_selector(struct hda_codec *codec, hda_nid_t pin)
2722 int num = snd_hda_get_connections(codec, pin, srcs,
2725 get_wcaps_type(get_wcaps(codec, srcs[0])) != AC_WID_AUD_SEL)
2730 /* get MIX nid connected to the given pin targeted to DAC */
2731 static hda_nid_t alc_auto_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
2737 pin = alc_go_down_to_selector(codec, pin);
2738 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2739 for (i = 0; i < num; i++) {
2740 if (alc_auto_mix_to_dac(codec, mix[i]) == dac)
2746 /* select the connection from pin to DAC if needed */
2747 static int alc_auto_select_dac(struct hda_codec *codec, hda_nid_t pin,
2753 pin = alc_go_down_to_selector(codec, pin);
2754 num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
2757 for (i = 0; i < num; i++) {
2758 if (alc_auto_mix_to_dac(codec, mix[i]) == dac) {
2759 snd_hda_codec_update_cache(codec, pin, 0,
2760 AC_VERB_SET_CONNECT_SEL, i);
2767 /* look for an empty DAC slot */
2768 static hda_nid_t alc_auto_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
2770 struct alc_spec *spec = codec->spec;
2774 pin = alc_go_down_to_selector(codec, pin);
2775 num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
2776 for (i = 0; i < num; i++) {
2777 hda_nid_t nid = alc_auto_mix_to_dac(codec, srcs[i]);
2780 if (found_in_nid_list(nid, spec->multiout.dac_nids,
2781 spec->multiout.num_dacs))
2783 if (spec->multiout.hp_nid == nid)
2785 if (found_in_nid_list(nid, spec->multiout.extra_out_nid,
2786 ARRAY_SIZE(spec->multiout.extra_out_nid)))
2793 static hda_nid_t get_dac_if_single(struct hda_codec *codec, hda_nid_t pin)
2795 hda_nid_t sel = alc_go_down_to_selector(codec, pin);
2796 if (snd_hda_get_conn_list(codec, sel, NULL) == 1)
2797 return alc_auto_look_for_dac(codec, pin);
2801 /* fill in the dac_nids table from the parsed pin configuration */
2802 static int alc_auto_fill_dac_nids(struct hda_codec *codec)
2804 struct alc_spec *spec = codec->spec;
2805 const struct auto_pin_cfg *cfg = &spec->autocfg;
2806 bool redone = false;
2810 /* set num_dacs once to full for alc_auto_look_for_dac() */
2811 spec->multiout.num_dacs = cfg->line_outs;
2812 spec->multiout.hp_nid = 0;
2813 spec->multiout.extra_out_nid[0] = 0;
2814 memset(spec->private_dac_nids, 0, sizeof(spec->private_dac_nids));
2815 spec->multiout.dac_nids = spec->private_dac_nids;
2817 /* fill hard-wired DACs first */
2819 for (i = 0; i < cfg->line_outs; i++)
2820 spec->private_dac_nids[i] =
2821 get_dac_if_single(codec, cfg->line_out_pins[i]);
2823 spec->multiout.hp_nid =
2824 get_dac_if_single(codec, cfg->hp_pins[0]);
2825 if (cfg->speaker_outs)
2826 spec->multiout.extra_out_nid[0] =
2827 get_dac_if_single(codec, cfg->speaker_pins[0]);
2830 for (i = 0; i < cfg->line_outs; i++) {
2831 hda_nid_t pin = cfg->line_out_pins[i];
2832 if (spec->private_dac_nids[i])
2834 spec->private_dac_nids[i] = alc_auto_look_for_dac(codec, pin);
2835 if (!spec->private_dac_nids[i] && !redone) {
2836 /* if we can't find primary DACs, re-probe without
2837 * checking the hard-wired DACs
2844 /* re-count num_dacs and squash invalid entries */
2845 spec->multiout.num_dacs = 0;
2846 for (i = 0; i < cfg->line_outs; i++) {
2847 if (spec->private_dac_nids[i])
2848 spec->multiout.num_dacs++;
2850 memmove(spec->private_dac_nids + i,
2851 spec->private_dac_nids + i + 1,
2852 sizeof(hda_nid_t) * (cfg->line_outs - i - 1));
2855 if (cfg->hp_outs && !spec->multiout.hp_nid)
2856 spec->multiout.hp_nid =
2857 alc_auto_look_for_dac(codec, cfg->hp_pins[0]);
2858 if (cfg->speaker_outs && !spec->multiout.extra_out_nid[0])
2859 spec->multiout.extra_out_nid[0] =
2860 alc_auto_look_for_dac(codec, cfg->speaker_pins[0]);
2865 static int alc_auto_add_vol_ctl(struct hda_codec *codec,
2866 const char *pfx, int cidx,
2867 hda_nid_t nid, unsigned int chs)
2871 return __add_pb_vol_ctrl(codec->spec, ALC_CTL_WIDGET_VOL, pfx, cidx,
2872 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
2875 #define alc_auto_add_stereo_vol(codec, pfx, cidx, nid) \
2876 alc_auto_add_vol_ctl(codec, pfx, cidx, nid, 3)
2878 /* create a mute-switch for the given mixer widget;
2879 * if it has multiple sources (e.g. DAC and loopback), create a bind-mute
2881 static int alc_auto_add_sw_ctl(struct hda_codec *codec,
2882 const char *pfx, int cidx,
2883 hda_nid_t nid, unsigned int chs)
2890 wid_type = get_wcaps_type(get_wcaps(codec, nid));
2891 if (wid_type == AC_WID_PIN || wid_type == AC_WID_AUD_OUT) {
2892 type = ALC_CTL_WIDGET_MUTE;
2893 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT);
2894 } else if (snd_hda_get_conn_list(codec, nid, NULL) == 1) {
2895 type = ALC_CTL_WIDGET_MUTE;
2896 val = HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT);
2898 type = ALC_CTL_BIND_MUTE;
2899 val = HDA_COMPOSE_AMP_VAL(nid, chs, 2, HDA_INPUT);
2901 return __add_pb_sw_ctrl(codec->spec, type, pfx, cidx, val);
2904 #define alc_auto_add_stereo_sw(codec, pfx, cidx, nid) \
2905 alc_auto_add_sw_ctl(codec, pfx, cidx, nid, 3)
2907 static hda_nid_t alc_look_for_out_mute_nid(struct hda_codec *codec,
2908 hda_nid_t pin, hda_nid_t dac)
2910 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
2911 if (nid_has_mute(codec, pin, HDA_OUTPUT))
2913 else if (mix && nid_has_mute(codec, mix, HDA_INPUT))
2915 else if (nid_has_mute(codec, dac, HDA_OUTPUT))
2920 static hda_nid_t alc_look_for_out_vol_nid(struct hda_codec *codec,
2921 hda_nid_t pin, hda_nid_t dac)
2923 hda_nid_t mix = alc_auto_dac_to_mix(codec, pin, dac);
2924 if (nid_has_volume(codec, dac, HDA_OUTPUT))
2926 else if (nid_has_volume(codec, mix, HDA_OUTPUT))
2928 else if (nid_has_volume(codec, pin, HDA_OUTPUT))
2933 /* add playback controls from the parsed DAC table */
2934 static int alc_auto_create_multi_out_ctls(struct hda_codec *codec,
2935 const struct auto_pin_cfg *cfg)
2937 struct alc_spec *spec = codec->spec;
2938 int i, err, noutputs;
2940 noutputs = cfg->line_outs;
2941 if (spec->multi_ios > 0)
2942 noutputs += spec->multi_ios;
2944 for (i = 0; i < noutputs; i++) {
2950 dac = spec->multiout.dac_nids[i];
2953 if (i >= cfg->line_outs)
2954 pin = spec->multi_io[i - 1].pin;
2956 pin = cfg->line_out_pins[i];
2958 sw = alc_look_for_out_mute_nid(codec, pin, dac);
2959 vol = alc_look_for_out_vol_nid(codec, pin, dac);
2960 name = alc_get_line_out_pfx(spec, i, true, &index);
2963 err = alc_auto_add_vol_ctl(codec, "Center", 0, vol, 1);
2966 err = alc_auto_add_vol_ctl(codec, "LFE", 0, vol, 2);
2969 err = alc_auto_add_sw_ctl(codec, "Center", 0, sw, 1);
2972 err = alc_auto_add_sw_ctl(codec, "LFE", 0, sw, 2);
2976 err = alc_auto_add_stereo_vol(codec, name, index, vol);
2979 err = alc_auto_add_stereo_sw(codec, name, index, sw);
2987 /* add playback controls for speaker and HP outputs */
2988 static int alc_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
2989 hda_nid_t dac, const char *pfx)
2991 struct alc_spec *spec = codec->spec;
2998 /* the corresponding DAC is already occupied */
2999 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
3000 return 0; /* no way */
3001 /* create a switch only */
3002 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
3003 HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3006 sw = alc_look_for_out_mute_nid(codec, pin, dac);
3007 vol = alc_look_for_out_vol_nid(codec, pin, dac);
3008 err = alc_auto_add_stereo_vol(codec, pfx, 0, vol);
3011 err = alc_auto_add_stereo_sw(codec, pfx, 0, sw);
3017 static int alc_auto_create_hp_out(struct hda_codec *codec)
3019 struct alc_spec *spec = codec->spec;
3020 return alc_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
3021 spec->multiout.hp_nid,
3025 static int alc_auto_create_speaker_out(struct hda_codec *codec)
3027 struct alc_spec *spec = codec->spec;
3028 return alc_auto_create_extra_out(codec, spec->autocfg.speaker_pins[0],
3029 spec->multiout.extra_out_nid[0],
3033 static void alc_auto_set_output_and_unmute(struct hda_codec *codec,
3034 hda_nid_t pin, int pin_type,
3038 hda_nid_t nid, mix = 0;
3039 hda_nid_t srcs[HDA_MAX_CONNECTIONS];
3041 alc_set_pin_output(codec, pin, pin_type);
3042 nid = alc_go_down_to_selector(codec, pin);
3043 num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
3044 for (i = 0; i < num; i++) {
3045 if (alc_auto_mix_to_dac(codec, srcs[i]) != dac)
3053 /* need the manual connection? */
3055 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
3056 /* unmute mixer widget inputs */
3057 if (nid_has_mute(codec, mix, HDA_INPUT)) {
3058 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3060 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3063 /* initialize volume */
3064 nid = alc_look_for_out_vol_nid(codec, pin, dac);
3066 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3070 static void alc_auto_init_multi_out(struct hda_codec *codec)
3072 struct alc_spec *spec = codec->spec;
3073 int pin_type = get_pin_type(spec->autocfg.line_out_type);
3076 for (i = 0; i <= HDA_SIDE; i++) {
3077 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3079 alc_auto_set_output_and_unmute(codec, nid, pin_type,
3080 spec->multiout.dac_nids[i]);
3084 static void alc_auto_init_extra_out(struct hda_codec *codec)
3086 struct alc_spec *spec = codec->spec;
3089 pin = spec->autocfg.hp_pins[0];
3091 dac = spec->multiout.hp_nid;
3093 dac = spec->multiout.dac_nids[0];
3094 alc_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
3096 pin = spec->autocfg.speaker_pins[0];
3098 dac = spec->multiout.extra_out_nid[0];
3100 dac = spec->multiout.dac_nids[0];
3101 alc_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
3108 static int alc_auto_fill_multi_ios(struct hda_codec *codec,
3109 unsigned int location)
3111 struct alc_spec *spec = codec->spec;
3112 struct auto_pin_cfg *cfg = &spec->autocfg;
3113 int type, i, num_pins = 0;
3115 for (type = AUTO_PIN_LINE_IN; type >= AUTO_PIN_MIC; type--) {
3116 for (i = 0; i < cfg->num_inputs; i++) {
3117 hda_nid_t nid = cfg->inputs[i].pin;
3119 unsigned int defcfg, caps;
3120 if (cfg->inputs[i].type != type)
3122 defcfg = snd_hda_codec_get_pincfg(codec, nid);
3123 if (get_defcfg_connect(defcfg) != AC_JACK_PORT_COMPLEX)
3125 if (location && get_defcfg_location(defcfg) != location)
3127 caps = snd_hda_query_pin_caps(codec, nid);
3128 if (!(caps & AC_PINCAP_OUT))
3130 dac = alc_auto_look_for_dac(codec, nid);
3133 spec->multi_io[num_pins].pin = nid;
3134 spec->multi_io[num_pins].dac = dac;
3136 spec->private_dac_nids[spec->multiout.num_dacs++] = dac;
3139 spec->multiout.num_dacs = 1;
3145 static int alc_auto_ch_mode_info(struct snd_kcontrol *kcontrol,
3146 struct snd_ctl_elem_info *uinfo)
3148 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3149 struct alc_spec *spec = codec->spec;
3151 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3153 uinfo->value.enumerated.items = spec->multi_ios + 1;
3154 if (uinfo->value.enumerated.item > spec->multi_ios)
3155 uinfo->value.enumerated.item = spec->multi_ios;
3156 sprintf(uinfo->value.enumerated.name, "%dch",
3157 (uinfo->value.enumerated.item + 1) * 2);
3161 static int alc_auto_ch_mode_get(struct snd_kcontrol *kcontrol,
3162 struct snd_ctl_elem_value *ucontrol)
3164 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3165 struct alc_spec *spec = codec->spec;
3166 ucontrol->value.enumerated.item[0] = (spec->ext_channel_count - 1) / 2;
3170 static int alc_set_multi_io(struct hda_codec *codec, int idx, bool output)
3172 struct alc_spec *spec = codec->spec;
3173 hda_nid_t nid = spec->multi_io[idx].pin;
3175 if (!spec->multi_io[idx].ctl_in)
3176 spec->multi_io[idx].ctl_in =
3177 snd_hda_codec_read(codec, nid, 0,
3178 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3180 snd_hda_codec_update_cache(codec, nid, 0,
3181 AC_VERB_SET_PIN_WIDGET_CONTROL,
3183 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3184 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3186 alc_auto_select_dac(codec, nid, spec->multi_io[idx].dac);
3188 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
3189 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3190 HDA_AMP_MUTE, HDA_AMP_MUTE);
3191 snd_hda_codec_update_cache(codec, nid, 0,
3192 AC_VERB_SET_PIN_WIDGET_CONTROL,
3193 spec->multi_io[idx].ctl_in);
3198 static int alc_auto_ch_mode_put(struct snd_kcontrol *kcontrol,
3199 struct snd_ctl_elem_value *ucontrol)
3201 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3202 struct alc_spec *spec = codec->spec;
3205 ch = ucontrol->value.enumerated.item[0];
3206 if (ch < 0 || ch > spec->multi_ios)
3208 if (ch == (spec->ext_channel_count - 1) / 2)
3210 spec->ext_channel_count = (ch + 1) * 2;
3211 for (i = 0; i < spec->multi_ios; i++)
3212 alc_set_multi_io(codec, i, i < ch);
3213 spec->multiout.max_channels = spec->ext_channel_count;
3214 if (spec->need_dac_fix && !spec->const_channel_count)
3215 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
3219 static const struct snd_kcontrol_new alc_auto_channel_mode_enum = {
3220 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3221 .name = "Channel Mode",
3222 .info = alc_auto_ch_mode_info,
3223 .get = alc_auto_ch_mode_get,
3224 .put = alc_auto_ch_mode_put,
3227 static int alc_auto_add_multi_channel_mode(struct hda_codec *codec,
3228 int (*fill_dac)(struct hda_codec *))
3230 struct alc_spec *spec = codec->spec;
3231 struct auto_pin_cfg *cfg = &spec->autocfg;
3232 unsigned int location, defcfg;
3235 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT && cfg->hp_outs == 1) {
3236 /* use HP as primary out */
3237 cfg->speaker_outs = cfg->line_outs;
3238 memcpy(cfg->speaker_pins, cfg->line_out_pins,
3239 sizeof(cfg->speaker_pins));
3240 cfg->line_outs = cfg->hp_outs;
3241 memcpy(cfg->line_out_pins, cfg->hp_pins, sizeof(cfg->hp_pins));
3243 memset(cfg->hp_pins, 0, sizeof(cfg->hp_pins));
3244 cfg->line_out_type = AUTO_PIN_HP_OUT;
3248 if (cfg->line_outs != 1 ||
3249 cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
3252 defcfg = snd_hda_codec_get_pincfg(codec, cfg->line_out_pins[0]);
3253 location = get_defcfg_location(defcfg);
3255 num_pins = alc_auto_fill_multi_ios(codec, location);
3257 struct snd_kcontrol_new *knew;
3259 knew = alc_kcontrol_new(spec);
3262 *knew = alc_auto_channel_mode_enum;
3263 knew->name = kstrdup("Channel Mode", GFP_KERNEL);
3267 spec->multi_ios = num_pins;
3268 spec->ext_channel_count = 2;
3269 spec->multiout.num_dacs = num_pins + 1;
3274 /* filter out invalid adc_nids (and capsrc_nids) that don't give all
3277 static void alc_remove_invalid_adc_nids(struct hda_codec *codec)
3279 struct alc_spec *spec = codec->spec;
3280 const struct hda_input_mux *imux;
3281 hda_nid_t adc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3282 hda_nid_t capsrc_nids[ARRAY_SIZE(spec->private_adc_nids)];
3285 imux = spec->input_mux;
3288 if (spec->dyn_adc_switch)
3292 for (n = 0; n < spec->num_adc_nids; n++) {
3293 hda_nid_t cap = spec->private_capsrc_nids[n];
3294 int num_conns = snd_hda_get_conn_list(codec, cap, NULL);
3295 for (i = 0; i < imux->num_items; i++) {
3296 hda_nid_t pin = spec->imux_pins[i];
3298 if (get_connection_index(codec, cap, pin) < 0)
3300 } else if (num_conns <= imux->items[i].index)
3303 if (i >= imux->num_items) {
3304 adc_nids[nums] = spec->private_adc_nids[n];
3305 capsrc_nids[nums++] = cap;
3309 /* check whether ADC-switch is possible */
3310 if (!alc_check_dyn_adc_switch(codec)) {
3311 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
3312 " using fallback 0x%x\n",
3313 codec->chip_name, spec->private_adc_nids[0]);
3314 spec->num_adc_nids = 1;
3318 } else if (nums != spec->num_adc_nids) {
3319 memcpy(spec->private_adc_nids, adc_nids,
3320 nums * sizeof(hda_nid_t));
3321 memcpy(spec->private_capsrc_nids, capsrc_nids,
3322 nums * sizeof(hda_nid_t));
3323 spec->num_adc_nids = nums;
3327 alc_auto_mic_check_imux(codec); /* check auto-mic setups */
3328 else if (spec->input_mux->num_items == 1)
3329 spec->num_adc_nids = 1; /* reduce to a single ADC */
3333 * initialize ADC paths
3335 static void alc_auto_init_adc(struct hda_codec *codec, int adc_idx)
3337 struct alc_spec *spec = codec->spec;
3340 nid = spec->adc_nids[adc_idx];
3342 if (nid_has_mute(codec, nid, HDA_INPUT)) {
3343 snd_hda_codec_write(codec, nid, 0,
3344 AC_VERB_SET_AMP_GAIN_MUTE,
3348 if (!spec->capsrc_nids)
3350 nid = spec->capsrc_nids[adc_idx];
3351 if (nid_has_mute(codec, nid, HDA_OUTPUT))
3352 snd_hda_codec_write(codec, nid, 0,
3353 AC_VERB_SET_AMP_GAIN_MUTE,
3357 static void alc_auto_init_input_src(struct hda_codec *codec)
3359 struct alc_spec *spec = codec->spec;
3362 for (c = 0; c < spec->num_adc_nids; c++)
3363 alc_auto_init_adc(codec, c);
3364 if (spec->dyn_adc_switch)
3367 nums = spec->num_adc_nids;
3368 for (c = 0; c < nums; c++)
3369 alc_mux_select(codec, 0, spec->cur_mux[c], true);
3372 /* add mic boosts if needed */
3373 static int alc_auto_add_mic_boost(struct hda_codec *codec)
3375 struct alc_spec *spec = codec->spec;
3376 struct auto_pin_cfg *cfg = &spec->autocfg;
3380 const char *prev_label = NULL;
3382 for (i = 0; i < cfg->num_inputs; i++) {
3383 if (cfg->inputs[i].type > AUTO_PIN_MIC)
3385 nid = cfg->inputs[i].pin;
3386 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
3388 char boost_label[32];
3390 label = hda_get_autocfg_input_label(codec, cfg, i);
3391 if (prev_label && !strcmp(label, prev_label))
3397 snprintf(boost_label, sizeof(boost_label),
3398 "%s Boost Volume", label);
3399 err = add_control(spec, ALC_CTL_WIDGET_VOL,
3400 boost_label, type_idx,
3401 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
3409 /* select or unmute the given capsrc route */
3410 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
3413 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
3414 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
3416 } else if (snd_hda_get_conn_list(codec, cap, NULL) > 1) {
3417 snd_hda_codec_write_cache(codec, cap, 0,
3418 AC_VERB_SET_CONNECT_SEL, idx);
3422 /* set the default connection to that pin */
3423 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
3425 struct alc_spec *spec = codec->spec;
3430 for (i = 0; i < spec->num_adc_nids; i++) {
3431 hda_nid_t cap = spec->capsrc_nids ?
3432 spec->capsrc_nids[i] : spec->adc_nids[i];
3435 idx = get_connection_index(codec, cap, pin);
3438 select_or_unmute_capsrc(codec, cap, idx);
3439 return i; /* return the found index */
3441 return -1; /* not found */
3444 /* initialize some special cases for input sources */
3445 static void alc_init_special_input_src(struct hda_codec *codec)
3447 struct alc_spec *spec = codec->spec;
3450 for (i = 0; i < spec->autocfg.num_inputs; i++)
3451 init_capsrc_for_pin(codec, spec->autocfg.inputs[i].pin);
3454 /* assign appropriate capture mixers */
3455 static void set_capture_mixer(struct hda_codec *codec)
3457 struct alc_spec *spec = codec->spec;
3458 static const struct snd_kcontrol_new *caps[2][3] = {
3459 { alc_capture_mixer_nosrc1,
3460 alc_capture_mixer_nosrc2,
3461 alc_capture_mixer_nosrc3 },
3462 { alc_capture_mixer1,
3464 alc_capture_mixer3 },
3467 /* check whether either of ADC or MUX has a volume control */
3468 if (!nid_has_volume(codec, spec->adc_nids[0], HDA_INPUT)) {
3469 if (!spec->capsrc_nids)
3470 return; /* no volume */
3471 if (!nid_has_volume(codec, spec->capsrc_nids[0], HDA_OUTPUT))
3472 return; /* no volume in capsrc, too */
3473 spec->vol_in_capsrc = 1;
3476 if (spec->num_adc_nids > 0) {
3480 if (spec->input_mux && spec->input_mux->num_items > 1)
3482 if (spec->auto_mic) {
3485 } else if (spec->dyn_adc_switch)
3488 if (spec->num_adc_nids > 3)
3489 spec->num_adc_nids = 3;
3490 else if (!spec->num_adc_nids)
3492 num_adcs = spec->num_adc_nids;
3494 spec->cap_mixer = caps[mux][num_adcs - 1];
3499 * standard auto-parser initializations
3501 static void alc_auto_init_std(struct hda_codec *codec)
3503 struct alc_spec *spec = codec->spec;
3504 alc_auto_init_multi_out(codec);
3505 alc_auto_init_extra_out(codec);
3506 alc_auto_init_analog_input(codec);
3507 alc_auto_init_input_src(codec);
3508 alc_auto_init_digital(codec);
3509 if (spec->unsol_event)
3510 alc_inithook(codec);
3514 * Digital-beep handlers
3516 #ifdef CONFIG_SND_HDA_INPUT_BEEP
3517 #define set_beep_amp(spec, nid, idx, dir) \
3518 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
3520 static const struct snd_pci_quirk beep_white_list[] = {
3521 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
3522 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
3523 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
3524 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
3525 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
3529 static inline int has_cdefine_beep(struct hda_codec *codec)
3531 struct alc_spec *spec = codec->spec;
3532 const struct snd_pci_quirk *q;
3533 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
3536 return spec->cdefine.enable_pcbeep;
3539 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
3540 #define has_cdefine_beep(codec) 0
3543 /* parse the BIOS configuration and set up the alc_spec */
3544 /* return 1 if successful, 0 if the proper config is not found,
3545 * or a negative error code
3547 static int alc_parse_auto_config(struct hda_codec *codec,
3548 const hda_nid_t *ignore_nids,
3549 const hda_nid_t *ssid_nids)
3551 struct alc_spec *spec = codec->spec;
3554 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3558 if (!spec->autocfg.line_outs) {
3559 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
3560 spec->multiout.max_channels = 2;
3561 spec->no_analog = 1;
3564 return 0; /* can't find valid BIOS pin config */
3566 err = alc_auto_fill_dac_nids(codec);
3569 err = alc_auto_add_multi_channel_mode(codec, alc_auto_fill_dac_nids);
3572 err = alc_auto_create_multi_out_ctls(codec, &spec->autocfg);
3575 err = alc_auto_create_hp_out(codec);
3578 err = alc_auto_create_speaker_out(codec);
3581 err = alc_auto_create_input_ctls(codec);
3585 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3588 alc_auto_parse_digital(codec);
3590 if (!spec->no_analog)
3591 alc_remove_invalid_adc_nids(codec);
3594 alc_ssid_check(codec, ssid_nids);
3596 if (!spec->no_analog) {
3597 alc_auto_check_switches(codec);
3598 err = alc_auto_add_mic_boost(codec);
3603 if (spec->kctls.list)
3604 add_mixer(spec, spec->kctls.list);
3609 static int alc880_parse_auto_config(struct hda_codec *codec)
3611 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
3612 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3613 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
3616 #ifdef CONFIG_SND_HDA_POWER_SAVE
3617 static const struct hda_amp_list alc880_loopbacks[] = {
3618 { 0x0b, HDA_INPUT, 0 },
3619 { 0x0b, HDA_INPUT, 1 },
3620 { 0x0b, HDA_INPUT, 2 },
3621 { 0x0b, HDA_INPUT, 3 },
3622 { 0x0b, HDA_INPUT, 4 },
3630 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3631 #define alc_board_config \
3632 snd_hda_check_board_config
3633 #define alc_board_codec_sid_config \
3634 snd_hda_check_board_codec_sid_config
3635 #include "alc_quirks.c"
3637 #define alc_board_config(codec, nums, models, tbl) -1
3638 #define alc_board_codec_sid_config(codec, nums, models, tbl) -1
3639 #define setup_preset(codec, x) /* NOP */
3643 * OK, here we have finally the patch for ALC880
3645 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3646 #include "alc880_quirks.c"
3649 static int patch_alc880(struct hda_codec *codec)
3651 struct alc_spec *spec;
3655 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3661 spec->mixer_nid = 0x0b;
3662 spec->need_dac_fix = 1;
3664 board_config = alc_board_config(codec, ALC880_MODEL_LAST,
3665 alc880_models, alc880_cfg_tbl);
3666 if (board_config < 0) {
3667 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3669 board_config = ALC_MODEL_AUTO;
3672 if (board_config == ALC_MODEL_AUTO) {
3673 /* automatic parse from the BIOS config */
3674 err = alc880_parse_auto_config(codec);
3679 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3682 "hda_codec: Cannot set up configuration "
3683 "from BIOS. Using 3-stack mode...\n");
3684 board_config = ALC880_3ST;
3689 if (board_config != ALC_MODEL_AUTO)
3690 setup_preset(codec, &alc880_presets[board_config]);
3692 if (!spec->no_analog && !spec->adc_nids) {
3693 alc_auto_fill_adc_caps(codec);
3694 alc_rebuild_imux_for_auto_mic(codec);
3695 alc_remove_invalid_adc_nids(codec);
3698 if (!spec->no_analog && !spec->cap_mixer)
3699 set_capture_mixer(codec);
3701 if (!spec->no_analog) {
3702 err = snd_hda_attach_beep_device(codec, 0x1);
3707 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
3710 spec->vmaster_nid = 0x0c;
3712 codec->patch_ops = alc_patch_ops;
3713 if (board_config == ALC_MODEL_AUTO)
3714 spec->init_hook = alc_auto_init_std;
3715 #ifdef CONFIG_SND_HDA_POWER_SAVE
3716 if (!spec->loopback.amplist)
3717 spec->loopback.amplist = alc880_loopbacks;
3727 static int alc260_parse_auto_config(struct hda_codec *codec)
3729 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
3730 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
3731 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
3734 #ifdef CONFIG_SND_HDA_POWER_SAVE
3735 static const struct hda_amp_list alc260_loopbacks[] = {
3736 { 0x07, HDA_INPUT, 0 },
3737 { 0x07, HDA_INPUT, 1 },
3738 { 0x07, HDA_INPUT, 2 },
3739 { 0x07, HDA_INPUT, 3 },
3740 { 0x07, HDA_INPUT, 4 },
3752 static const struct alc_fixup alc260_fixups[] = {
3753 [PINFIX_HP_DC5750] = {
3754 .type = ALC_FIXUP_PINS,
3755 .v.pins = (const struct alc_pincfg[]) {
3756 { 0x11, 0x90130110 }, /* speaker */
3762 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
3763 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
3769 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3770 #include "alc260_quirks.c"
3773 static int patch_alc260(struct hda_codec *codec)
3775 struct alc_spec *spec;
3776 int err, board_config;
3778 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3784 spec->mixer_nid = 0x07;
3786 board_config = alc_board_config(codec, ALC260_MODEL_LAST,
3787 alc260_models, alc260_cfg_tbl);
3788 if (board_config < 0) {
3789 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3791 board_config = ALC_MODEL_AUTO;
3794 if (board_config == ALC_MODEL_AUTO) {
3795 alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
3796 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
3799 if (board_config == ALC_MODEL_AUTO) {
3800 /* automatic parse from the BIOS config */
3801 err = alc260_parse_auto_config(codec);
3806 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3809 "hda_codec: Cannot set up configuration "
3810 "from BIOS. Using base mode...\n");
3811 board_config = ALC260_BASIC;
3816 if (board_config != ALC_MODEL_AUTO)
3817 setup_preset(codec, &alc260_presets[board_config]);
3819 if (!spec->no_analog && !spec->adc_nids) {
3820 alc_auto_fill_adc_caps(codec);
3821 alc_rebuild_imux_for_auto_mic(codec);
3822 alc_remove_invalid_adc_nids(codec);
3825 if (!spec->no_analog && !spec->cap_mixer)
3826 set_capture_mixer(codec);
3828 if (!spec->no_analog) {
3829 err = snd_hda_attach_beep_device(codec, 0x1);
3834 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
3837 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
3839 spec->vmaster_nid = 0x08;
3841 codec->patch_ops = alc_patch_ops;
3842 if (board_config == ALC_MODEL_AUTO)
3843 spec->init_hook = alc_auto_init_std;
3844 spec->shutup = alc_eapd_shutup;
3845 #ifdef CONFIG_SND_HDA_POWER_SAVE
3846 if (!spec->loopback.amplist)
3847 spec->loopback.amplist = alc260_loopbacks;
3855 * ALC882/883/885/888/889 support
3857 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
3858 * configuration. Each pin widget can choose any input DACs and a mixer.
3859 * Each ADC is connected from a mixer of all inputs. This makes possible
3860 * 6-channel independent captures.
3862 * In addition, an independent DAC for the multi-playback (not used in this
3865 #ifdef CONFIG_SND_HDA_POWER_SAVE
3866 #define alc882_loopbacks alc880_loopbacks
3873 PINFIX_ABIT_AW9D_MAX,
3876 PINFIX_ACER_ASPIRE_7736,
3879 static const struct alc_fixup alc882_fixups[] = {
3880 [PINFIX_ABIT_AW9D_MAX] = {
3881 .type = ALC_FIXUP_PINS,
3882 .v.pins = (const struct alc_pincfg[]) {
3883 { 0x15, 0x01080104 }, /* side */
3884 { 0x16, 0x01011012 }, /* rear */
3885 { 0x17, 0x01016011 }, /* clfe */
3889 [PINFIX_LENOVO_Y530] = {
3890 .type = ALC_FIXUP_PINS,
3891 .v.pins = (const struct alc_pincfg[]) {
3892 { 0x15, 0x99130112 }, /* rear int speakers */
3893 { 0x16, 0x99130111 }, /* subwoofer */
3897 [PINFIX_PB_M5210] = {
3898 .type = ALC_FIXUP_VERBS,
3899 .v.verbs = (const struct hda_verb[]) {
3900 { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
3904 [PINFIX_ACER_ASPIRE_7736] = {
3905 .type = ALC_FIXUP_SKU,
3906 .v.sku = ALC_FIXUP_SKU_IGNORE,
3910 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
3911 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
3912 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530),
3913 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
3914 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
3919 * BIOS auto configuration
3921 /* almost identical with ALC880 parser... */
3922 static int alc882_parse_auto_config(struct hda_codec *codec)
3924 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
3925 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3926 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
3931 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3932 #include "alc882_quirks.c"
3935 static int patch_alc882(struct hda_codec *codec)
3937 struct alc_spec *spec;
3938 int err, board_config;
3940 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3946 spec->mixer_nid = 0x0b;
3948 switch (codec->vendor_id) {
3953 /* ALC883 and variants */
3954 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
3958 board_config = alc_board_config(codec, ALC882_MODEL_LAST,
3959 alc882_models, alc882_cfg_tbl);
3961 if (board_config < 0)
3962 board_config = alc_board_codec_sid_config(codec,
3963 ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
3965 if (board_config < 0) {
3966 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
3968 board_config = ALC_MODEL_AUTO;
3971 if (board_config == ALC_MODEL_AUTO) {
3972 alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
3973 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
3976 alc_auto_parse_customize_define(codec);
3978 if (board_config == ALC_MODEL_AUTO) {
3979 /* automatic parse from the BIOS config */
3980 err = alc882_parse_auto_config(codec);
3985 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
3988 "hda_codec: Cannot set up configuration "
3989 "from BIOS. Using base mode...\n");
3990 board_config = ALC882_3ST_DIG;
3995 if (board_config != ALC_MODEL_AUTO)
3996 setup_preset(codec, &alc882_presets[board_config]);
3998 if (!spec->no_analog && !spec->adc_nids) {
3999 alc_auto_fill_adc_caps(codec);
4000 alc_rebuild_imux_for_auto_mic(codec);
4001 alc_remove_invalid_adc_nids(codec);
4004 if (!spec->no_analog && !spec->cap_mixer)
4005 set_capture_mixer(codec);
4007 if (!spec->no_analog && has_cdefine_beep(codec)) {
4008 err = snd_hda_attach_beep_device(codec, 0x1);
4013 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4016 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4018 spec->vmaster_nid = 0x0c;
4020 codec->patch_ops = alc_patch_ops;
4021 if (board_config == ALC_MODEL_AUTO)
4022 spec->init_hook = alc_auto_init_std;
4024 alc_init_jacks(codec);
4025 #ifdef CONFIG_SND_HDA_POWER_SAVE
4026 if (!spec->loopback.amplist)
4027 spec->loopback.amplist = alc882_loopbacks;
4037 static int alc262_parse_auto_config(struct hda_codec *codec)
4039 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
4040 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4041 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
4052 static const struct alc_fixup alc262_fixups[] = {
4053 [PINFIX_FSC_H270] = {
4054 .type = ALC_FIXUP_PINS,
4055 .v.pins = (const struct alc_pincfg[]) {
4056 { 0x14, 0x99130110 }, /* speaker */
4057 { 0x15, 0x0221142f }, /* front HP */
4058 { 0x1b, 0x0121141f }, /* rear HP */
4062 [PINFIX_HP_Z200] = {
4063 .type = ALC_FIXUP_PINS,
4064 .v.pins = (const struct alc_pincfg[]) {
4065 { 0x16, 0x99130120 }, /* internal speaker */
4071 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
4072 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", PINFIX_HP_Z200),
4073 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
4078 #ifdef CONFIG_SND_HDA_POWER_SAVE
4079 #define alc262_loopbacks alc880_loopbacks
4084 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4085 #include "alc262_quirks.c"
4088 static int patch_alc262(struct hda_codec *codec)
4090 struct alc_spec *spec;
4094 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4100 spec->mixer_nid = 0x0b;
4103 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
4108 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4109 tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
4110 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
4111 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
4114 alc_auto_parse_customize_define(codec);
4116 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
4118 board_config = alc_board_config(codec, ALC262_MODEL_LAST,
4119 alc262_models, alc262_cfg_tbl);
4121 if (board_config < 0) {
4122 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4124 board_config = ALC_MODEL_AUTO;
4127 if (board_config == ALC_MODEL_AUTO) {
4128 alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
4129 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4132 if (board_config == ALC_MODEL_AUTO) {
4133 /* automatic parse from the BIOS config */
4134 err = alc262_parse_auto_config(codec);
4139 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4142 "hda_codec: Cannot set up configuration "
4143 "from BIOS. Using base mode...\n");
4144 board_config = ALC262_BASIC;
4149 if (board_config != ALC_MODEL_AUTO)
4150 setup_preset(codec, &alc262_presets[board_config]);
4152 if (!spec->no_analog && !spec->adc_nids) {
4153 alc_auto_fill_adc_caps(codec);
4154 alc_rebuild_imux_for_auto_mic(codec);
4155 alc_remove_invalid_adc_nids(codec);
4158 if (!spec->no_analog && !spec->cap_mixer)
4159 set_capture_mixer(codec);
4161 if (!spec->no_analog && has_cdefine_beep(codec)) {
4162 err = snd_hda_attach_beep_device(codec, 0x1);
4167 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4170 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4172 spec->vmaster_nid = 0x0c;
4174 codec->patch_ops = alc_patch_ops;
4175 if (board_config == ALC_MODEL_AUTO)
4176 spec->init_hook = alc_auto_init_std;
4177 spec->shutup = alc_eapd_shutup;
4179 alc_init_jacks(codec);
4180 #ifdef CONFIG_SND_HDA_POWER_SAVE
4181 if (!spec->loopback.amplist)
4182 spec->loopback.amplist = alc262_loopbacks;
4191 /* bind Beep switches of both NID 0x0f and 0x10 */
4192 static const struct hda_bind_ctls alc268_bind_beep_sw = {
4193 .ops = &snd_hda_bind_sw,
4195 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
4196 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
4201 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
4202 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
4203 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
4207 /* set PCBEEP vol = 0, mute connections */
4208 static const struct hda_verb alc268_beep_init_verbs[] = {
4209 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4210 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4211 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4216 * BIOS auto configuration
4218 static int alc268_parse_auto_config(struct hda_codec *codec)
4220 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4221 struct alc_spec *spec = codec->spec;
4222 int err = alc_parse_auto_config(codec, NULL, alc268_ssids);
4224 if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d) {
4225 add_mixer(spec, alc268_beep_mixer);
4226 add_verb(spec, alc268_beep_init_verbs);
4234 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4235 #include "alc268_quirks.c"
4238 static int patch_alc268(struct hda_codec *codec)
4240 struct alc_spec *spec;
4242 int i, has_beep, err;
4244 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4250 /* ALC268 has no aa-loopback mixer */
4252 board_config = alc_board_config(codec, ALC268_MODEL_LAST,
4253 alc268_models, alc268_cfg_tbl);
4255 if (board_config < 0)
4256 board_config = alc_board_codec_sid_config(codec,
4257 ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
4259 if (board_config < 0) {
4260 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4262 board_config = ALC_MODEL_AUTO;
4265 if (board_config == ALC_MODEL_AUTO) {
4266 /* automatic parse from the BIOS config */
4267 err = alc268_parse_auto_config(codec);
4272 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4275 "hda_codec: Cannot set up configuration "
4276 "from BIOS. Using base mode...\n");
4277 board_config = ALC268_3ST;
4282 if (board_config != ALC_MODEL_AUTO)
4283 setup_preset(codec, &alc268_presets[board_config]);
4286 for (i = 0; i < spec->num_mixers; i++) {
4287 if (spec->mixers[i] == alc268_beep_mixer) {
4294 err = snd_hda_attach_beep_device(codec, 0x1);
4299 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
4300 /* override the amp caps for beep generator */
4301 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
4302 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
4303 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
4304 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4305 (0 << AC_AMPCAP_MUTE_SHIFT));
4308 if (!spec->no_analog && !spec->adc_nids) {
4309 alc_auto_fill_adc_caps(codec);
4310 alc_rebuild_imux_for_auto_mic(codec);
4311 alc_remove_invalid_adc_nids(codec);
4314 if (!spec->no_analog && !spec->cap_mixer)
4315 set_capture_mixer(codec);
4317 spec->vmaster_nid = 0x02;
4319 codec->patch_ops = alc_patch_ops;
4320 if (board_config == ALC_MODEL_AUTO)
4321 spec->init_hook = alc_auto_init_std;
4322 spec->shutup = alc_eapd_shutup;
4324 alc_init_jacks(codec);
4332 #ifdef CONFIG_SND_HDA_POWER_SAVE
4333 #define alc269_loopbacks alc880_loopbacks
4336 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
4340 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4341 /* NID is set in alc_build_pcms */
4343 .open = alc_playback_pcm_open,
4344 .prepare = alc_playback_pcm_prepare,
4345 .cleanup = alc_playback_pcm_cleanup
4349 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
4353 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
4354 /* NID is set in alc_build_pcms */
4357 #ifdef CONFIG_SND_HDA_POWER_SAVE
4358 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
4360 switch (codec->subsystem_id) {
4367 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
4369 /* update mute-LED according to the speaker mute state */
4370 if (nid == 0x01 || nid == 0x14) {
4372 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
4377 /* mic2 vref pin is used for mute LED control */
4378 snd_hda_codec_update_cache(codec, 0x19, 0,
4379 AC_VERB_SET_PIN_WIDGET_CONTROL,
4382 return alc_check_power_status(codec, nid);
4384 #endif /* CONFIG_SND_HDA_POWER_SAVE */
4386 /* different alc269-variants */
4388 ALC269_TYPE_ALC269VA,
4389 ALC269_TYPE_ALC269VB,
4390 ALC269_TYPE_ALC269VC,
4394 * BIOS auto configuration
4396 static int alc269_parse_auto_config(struct hda_codec *codec)
4398 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
4399 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
4400 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4401 struct alc_spec *spec = codec->spec;
4402 const hda_nid_t *ssids = spec->codec_variant == ALC269_TYPE_ALC269VA ?
4403 alc269va_ssids : alc269_ssids;
4405 return alc_parse_auto_config(codec, alc269_ignore, ssids);
4408 static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
4410 int val = alc_read_coef_idx(codec, 0x04);
4415 alc_write_coef_idx(codec, 0x04, val);
4418 static void alc269_shutup(struct hda_codec *codec)
4420 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
4421 alc269_toggle_power_output(codec, 0);
4422 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
4423 alc269_toggle_power_output(codec, 0);
4429 static int alc269_resume(struct hda_codec *codec)
4431 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
4432 alc269_toggle_power_output(codec, 0);
4436 codec->patch_ops.init(codec);
4438 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
4439 alc269_toggle_power_output(codec, 1);
4443 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
4444 alc269_toggle_power_output(codec, 1);
4446 snd_hda_codec_resume_amp(codec);
4447 snd_hda_codec_resume_cache(codec);
4448 hda_call_check_power_status(codec, 0x01);
4451 #endif /* CONFIG_PM */
4453 static void alc269_fixup_hweq(struct hda_codec *codec,
4454 const struct alc_fixup *fix, int action)
4458 if (action != ALC_FIXUP_ACT_INIT)
4460 coef = alc_read_coef_idx(codec, 0x1e);
4461 alc_write_coef_idx(codec, 0x1e, coef | 0x80);
4464 static void alc271_fixup_dmic(struct hda_codec *codec,
4465 const struct alc_fixup *fix, int action)
4467 static const struct hda_verb verbs[] = {
4468 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4469 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4474 if (strcmp(codec->chip_name, "ALC271X"))
4476 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4477 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4478 snd_hda_sequence_write(codec, verbs);
4481 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4482 const struct alc_fixup *fix, int action)
4484 struct alc_spec *spec = codec->spec;
4486 if (action != ALC_FIXUP_ACT_PROBE)
4489 /* Due to a hardware problem on Lenovo Ideadpad, we need to
4490 * fix the sample rate of analog I/O to 44.1kHz
4492 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
4493 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
4496 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4497 const struct alc_fixup *fix, int action)
4501 if (action != ALC_FIXUP_ACT_INIT)
4503 /* The digital-mic unit sends PDM (differential signal) instead of
4504 * the standard PCM, thus you can't record a valid mono stream as is.
4505 * Below is a workaround specific to ALC269 to control the dmic
4506 * signal source as mono.
4508 coef = alc_read_coef_idx(codec, 0x07);
4509 alc_write_coef_idx(codec, 0x07, coef | 0x80);
4513 ALC269_FIXUP_SONY_VAIO,
4514 ALC275_FIXUP_SONY_VAIO_GPIO2,
4515 ALC269_FIXUP_DELL_M101Z,
4516 ALC269_FIXUP_SKU_IGNORE,
4517 ALC269_FIXUP_ASUS_G73JW,
4518 ALC269_FIXUP_LENOVO_EAPD,
4519 ALC275_FIXUP_SONY_HWEQ,
4521 ALC269_FIXUP_PCM_44K,
4522 ALC269_FIXUP_STEREO_DMIC,
4525 static const struct alc_fixup alc269_fixups[] = {
4526 [ALC269_FIXUP_SONY_VAIO] = {
4527 .type = ALC_FIXUP_VERBS,
4528 .v.verbs = (const struct hda_verb[]) {
4529 {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
4533 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
4534 .type = ALC_FIXUP_VERBS,
4535 .v.verbs = (const struct hda_verb[]) {
4536 {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
4537 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
4538 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4542 .chain_id = ALC269_FIXUP_SONY_VAIO
4544 [ALC269_FIXUP_DELL_M101Z] = {
4545 .type = ALC_FIXUP_VERBS,
4546 .v.verbs = (const struct hda_verb[]) {
4547 /* Enables internal speaker */
4548 {0x20, AC_VERB_SET_COEF_INDEX, 13},
4549 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
4553 [ALC269_FIXUP_SKU_IGNORE] = {
4554 .type = ALC_FIXUP_SKU,
4555 .v.sku = ALC_FIXUP_SKU_IGNORE,
4557 [ALC269_FIXUP_ASUS_G73JW] = {
4558 .type = ALC_FIXUP_PINS,
4559 .v.pins = (const struct alc_pincfg[]) {
4560 { 0x17, 0x99130111 }, /* subwoofer */
4564 [ALC269_FIXUP_LENOVO_EAPD] = {
4565 .type = ALC_FIXUP_VERBS,
4566 .v.verbs = (const struct hda_verb[]) {
4567 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
4571 [ALC275_FIXUP_SONY_HWEQ] = {
4572 .type = ALC_FIXUP_FUNC,
4573 .v.func = alc269_fixup_hweq,
4575 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
4577 [ALC271_FIXUP_DMIC] = {
4578 .type = ALC_FIXUP_FUNC,
4579 .v.func = alc271_fixup_dmic,
4581 [ALC269_FIXUP_PCM_44K] = {
4582 .type = ALC_FIXUP_FUNC,
4583 .v.func = alc269_fixup_pcm_44k,
4585 [ALC269_FIXUP_STEREO_DMIC] = {
4586 .type = ALC_FIXUP_FUNC,
4587 .v.func = alc269_fixup_stereo_dmic,
4591 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
4592 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
4593 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
4594 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
4595 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
4596 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4597 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
4598 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
4599 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4600 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
4601 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
4602 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
4603 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
4604 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
4605 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
4606 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
4607 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
4608 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
4609 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Lenovo Ideapd", ALC269_FIXUP_PCM_44K),
4610 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
4615 static int alc269_fill_coef(struct hda_codec *codec)
4619 if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
4620 alc_write_coef_idx(codec, 0xf, 0x960b);
4621 alc_write_coef_idx(codec, 0xe, 0x8817);
4624 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
4625 alc_write_coef_idx(codec, 0xf, 0x960b);
4626 alc_write_coef_idx(codec, 0xe, 0x8814);
4629 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
4630 val = alc_read_coef_idx(codec, 0x04);
4631 /* Power up output pin */
4632 alc_write_coef_idx(codec, 0x04, val | (1<<11));
4635 if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
4636 val = alc_read_coef_idx(codec, 0xd);
4637 if ((val & 0x0c00) >> 10 != 0x1) {
4638 /* Capless ramp up clock control */
4639 alc_write_coef_idx(codec, 0xd, val | (1<<10));
4641 val = alc_read_coef_idx(codec, 0x17);
4642 if ((val & 0x01c0) >> 6 != 0x4) {
4643 /* Class D power on reset */
4644 alc_write_coef_idx(codec, 0x17, val | (1<<7));
4648 val = alc_read_coef_idx(codec, 0xd); /* Class D */
4649 alc_write_coef_idx(codec, 0xd, val | (1<<14));
4651 val = alc_read_coef_idx(codec, 0x4); /* HP */
4652 alc_write_coef_idx(codec, 0x4, val | (1<<11));
4659 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4660 #include "alc269_quirks.c"
4663 static int patch_alc269(struct hda_codec *codec)
4665 struct alc_spec *spec;
4666 int board_config, coef;
4669 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4675 spec->mixer_nid = 0x0b;
4677 alc_auto_parse_customize_define(codec);
4679 if (codec->vendor_id == 0x10ec0269) {
4680 spec->codec_variant = ALC269_TYPE_ALC269VA;
4681 coef = alc_read_coef_idx(codec, 0);
4682 if ((coef & 0x00f0) == 0x0010) {
4683 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
4684 spec->cdefine.platform_type == 1) {
4685 alc_codec_rename(codec, "ALC271X");
4686 } else if ((coef & 0xf000) == 0x2000) {
4687 alc_codec_rename(codec, "ALC259");
4688 } else if ((coef & 0xf000) == 0x3000) {
4689 alc_codec_rename(codec, "ALC258");
4690 } else if ((coef & 0xfff0) == 0x3010) {
4691 alc_codec_rename(codec, "ALC277");
4693 alc_codec_rename(codec, "ALC269VB");
4695 spec->codec_variant = ALC269_TYPE_ALC269VB;
4696 } else if ((coef & 0x00f0) == 0x0020) {
4698 alc_codec_rename(codec, "ALC259");
4699 else if (coef == 0x6023)
4700 alc_codec_rename(codec, "ALC281X");
4701 else if (codec->bus->pci->subsystem_vendor == 0x17aa &&
4702 codec->bus->pci->subsystem_device == 0x21f3)
4703 alc_codec_rename(codec, "ALC3202");
4705 alc_codec_rename(codec, "ALC269VC");
4706 spec->codec_variant = ALC269_TYPE_ALC269VC;
4708 alc_fix_pll_init(codec, 0x20, 0x04, 15);
4709 alc269_fill_coef(codec);
4712 board_config = alc_board_config(codec, ALC269_MODEL_LAST,
4713 alc269_models, alc269_cfg_tbl);
4715 if (board_config < 0) {
4716 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4718 board_config = ALC_MODEL_AUTO;
4721 if (board_config == ALC_MODEL_AUTO) {
4722 alc_pick_fixup(codec, NULL, alc269_fixup_tbl, alc269_fixups);
4723 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4726 if (board_config == ALC_MODEL_AUTO) {
4727 /* automatic parse from the BIOS config */
4728 err = alc269_parse_auto_config(codec);
4733 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4736 "hda_codec: Cannot set up configuration "
4737 "from BIOS. Using base mode...\n");
4738 board_config = ALC269_BASIC;
4743 if (board_config != ALC_MODEL_AUTO)
4744 setup_preset(codec, &alc269_presets[board_config]);
4746 if (!spec->no_analog && !spec->adc_nids) {
4747 alc_auto_fill_adc_caps(codec);
4748 alc_rebuild_imux_for_auto_mic(codec);
4749 alc_remove_invalid_adc_nids(codec);
4752 if (!spec->no_analog && !spec->cap_mixer)
4753 set_capture_mixer(codec);
4755 if (!spec->no_analog && has_cdefine_beep(codec)) {
4756 err = snd_hda_attach_beep_device(codec, 0x1);
4761 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
4764 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4766 spec->vmaster_nid = 0x02;
4768 codec->patch_ops = alc_patch_ops;
4770 codec->patch_ops.resume = alc269_resume;
4772 if (board_config == ALC_MODEL_AUTO)
4773 spec->init_hook = alc_auto_init_std;
4774 spec->shutup = alc269_shutup;
4776 alc_init_jacks(codec);
4777 #ifdef CONFIG_SND_HDA_POWER_SAVE
4778 if (!spec->loopback.amplist)
4779 spec->loopback.amplist = alc269_loopbacks;
4780 if (alc269_mic2_for_mute_led(codec))
4781 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
4791 static int alc861_parse_auto_config(struct hda_codec *codec)
4793 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
4794 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
4795 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
4798 #ifdef CONFIG_SND_HDA_POWER_SAVE
4799 static const struct hda_amp_list alc861_loopbacks[] = {
4800 { 0x15, HDA_INPUT, 0 },
4801 { 0x15, HDA_INPUT, 1 },
4802 { 0x15, HDA_INPUT, 2 },
4803 { 0x15, HDA_INPUT, 3 },
4809 /* Pin config fixes */
4811 PINFIX_FSC_AMILO_PI1505,
4814 static const struct alc_fixup alc861_fixups[] = {
4815 [PINFIX_FSC_AMILO_PI1505] = {
4816 .type = ALC_FIXUP_PINS,
4817 .v.pins = (const struct alc_pincfg[]) {
4818 { 0x0b, 0x0221101f }, /* HP */
4819 { 0x0f, 0x90170310 }, /* speaker */
4825 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
4826 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
4832 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4833 #include "alc861_quirks.c"
4836 static int patch_alc861(struct hda_codec *codec)
4838 struct alc_spec *spec;
4842 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4848 spec->mixer_nid = 0x15;
4850 board_config = alc_board_config(codec, ALC861_MODEL_LAST,
4851 alc861_models, alc861_cfg_tbl);
4853 if (board_config < 0) {
4854 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4856 board_config = ALC_MODEL_AUTO;
4859 if (board_config == ALC_MODEL_AUTO) {
4860 alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
4861 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
4864 if (board_config == ALC_MODEL_AUTO) {
4865 /* automatic parse from the BIOS config */
4866 err = alc861_parse_auto_config(codec);
4871 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4874 "hda_codec: Cannot set up configuration "
4875 "from BIOS. Using base mode...\n");
4876 board_config = ALC861_3ST_DIG;
4881 if (board_config != ALC_MODEL_AUTO)
4882 setup_preset(codec, &alc861_presets[board_config]);
4884 if (!spec->no_analog && !spec->adc_nids) {
4885 alc_auto_fill_adc_caps(codec);
4886 alc_rebuild_imux_for_auto_mic(codec);
4887 alc_remove_invalid_adc_nids(codec);
4890 if (!spec->no_analog && !spec->cap_mixer)
4891 set_capture_mixer(codec);
4893 if (!spec->no_analog) {
4894 err = snd_hda_attach_beep_device(codec, 0x23);
4899 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
4902 spec->vmaster_nid = 0x03;
4904 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
4906 codec->patch_ops = alc_patch_ops;
4907 if (board_config == ALC_MODEL_AUTO) {
4908 spec->init_hook = alc_auto_init_std;
4909 #ifdef CONFIG_SND_HDA_POWER_SAVE
4910 spec->power_hook = alc_power_eapd;
4913 #ifdef CONFIG_SND_HDA_POWER_SAVE
4914 if (!spec->loopback.amplist)
4915 spec->loopback.amplist = alc861_loopbacks;
4926 * In addition, an independent DAC
4928 #ifdef CONFIG_SND_HDA_POWER_SAVE
4929 #define alc861vd_loopbacks alc880_loopbacks
4932 static int alc861vd_parse_auto_config(struct hda_codec *codec)
4934 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
4935 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
4936 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
4940 ALC660VD_FIX_ASUS_GPIO1
4944 static const struct alc_fixup alc861vd_fixups[] = {
4945 [ALC660VD_FIX_ASUS_GPIO1] = {
4946 .type = ALC_FIXUP_VERBS,
4947 .v.verbs = (const struct hda_verb[]) {
4948 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
4949 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
4950 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
4956 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
4957 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
4961 static const struct hda_verb alc660vd_eapd_verbs[] = {
4962 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
4963 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
4969 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
4970 #include "alc861vd_quirks.c"
4973 static int patch_alc861vd(struct hda_codec *codec)
4975 struct alc_spec *spec;
4976 int err, board_config;
4978 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4984 spec->mixer_nid = 0x0b;
4986 board_config = alc_board_config(codec, ALC861VD_MODEL_LAST,
4987 alc861vd_models, alc861vd_cfg_tbl);
4989 if (board_config < 0) {
4990 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4992 board_config = ALC_MODEL_AUTO;
4995 if (board_config == ALC_MODEL_AUTO) {
4996 alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
4997 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5000 if (board_config == ALC_MODEL_AUTO) {
5001 /* automatic parse from the BIOS config */
5002 err = alc861vd_parse_auto_config(codec);
5007 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5010 "hda_codec: Cannot set up configuration "
5011 "from BIOS. Using base mode...\n");
5012 board_config = ALC861VD_3ST;
5017 if (board_config != ALC_MODEL_AUTO)
5018 setup_preset(codec, &alc861vd_presets[board_config]);
5020 if (codec->vendor_id == 0x10ec0660) {
5021 /* always turn on EAPD */
5022 add_verb(spec, alc660vd_eapd_verbs);
5025 if (!spec->no_analog && !spec->adc_nids) {
5026 alc_auto_fill_adc_caps(codec);
5027 alc_rebuild_imux_for_auto_mic(codec);
5028 alc_remove_invalid_adc_nids(codec);
5031 if (!spec->no_analog && !spec->cap_mixer)
5032 set_capture_mixer(codec);
5034 if (!spec->no_analog) {
5035 err = snd_hda_attach_beep_device(codec, 0x23);
5040 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5043 spec->vmaster_nid = 0x02;
5045 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5047 codec->patch_ops = alc_patch_ops;
5049 if (board_config == ALC_MODEL_AUTO)
5050 spec->init_hook = alc_auto_init_std;
5051 spec->shutup = alc_eapd_shutup;
5052 #ifdef CONFIG_SND_HDA_POWER_SAVE
5053 if (!spec->loopback.amplist)
5054 spec->loopback.amplist = alc861vd_loopbacks;
5063 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5064 * configuration. Each pin widget can choose any input DACs and a mixer.
5065 * Each ADC is connected from a mixer of all inputs. This makes possible
5066 * 6-channel independent captures.
5068 * In addition, an independent DAC for the multi-playback (not used in this
5071 #ifdef CONFIG_SND_HDA_POWER_SAVE
5072 #define alc662_loopbacks alc880_loopbacks
5076 * BIOS auto configuration
5079 static int alc662_parse_auto_config(struct hda_codec *codec)
5081 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
5082 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
5083 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5084 const hda_nid_t *ssids;
5086 if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
5087 codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
5088 ssids = alc663_ssids;
5090 ssids = alc662_ssids;
5091 return alc_parse_auto_config(codec, alc662_ignore, ssids);
5094 static void alc272_fixup_mario(struct hda_codec *codec,
5095 const struct alc_fixup *fix, int action)
5097 if (action != ALC_FIXUP_ACT_PROBE)
5099 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
5100 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
5101 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
5102 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5103 (0 << AC_AMPCAP_MUTE_SHIFT)))
5105 "hda_codec: failed to override amp caps for NID 0x2\n");
5109 ALC662_FIXUP_ASPIRE,
5110 ALC662_FIXUP_IDEAPAD,
5112 ALC662_FIXUP_CZC_P10T,
5113 ALC662_FIXUP_SKU_IGNORE,
5114 ALC662_FIXUP_HP_RP5800,
5117 static const struct alc_fixup alc662_fixups[] = {
5118 [ALC662_FIXUP_ASPIRE] = {
5119 .type = ALC_FIXUP_PINS,
5120 .v.pins = (const struct alc_pincfg[]) {
5121 { 0x15, 0x99130112 }, /* subwoofer */
5125 [ALC662_FIXUP_IDEAPAD] = {
5126 .type = ALC_FIXUP_PINS,
5127 .v.pins = (const struct alc_pincfg[]) {
5128 { 0x17, 0x99130112 }, /* subwoofer */
5132 [ALC272_FIXUP_MARIO] = {
5133 .type = ALC_FIXUP_FUNC,
5134 .v.func = alc272_fixup_mario,
5136 [ALC662_FIXUP_CZC_P10T] = {
5137 .type = ALC_FIXUP_VERBS,
5138 .v.verbs = (const struct hda_verb[]) {
5139 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5143 [ALC662_FIXUP_SKU_IGNORE] = {
5144 .type = ALC_FIXUP_SKU,
5145 .v.sku = ALC_FIXUP_SKU_IGNORE,
5147 [ALC662_FIXUP_HP_RP5800] = {
5148 .type = ALC_FIXUP_PINS,
5149 .v.pins = (const struct alc_pincfg[]) {
5150 { 0x14, 0x0221201f }, /* HP out */
5154 .chain_id = ALC662_FIXUP_SKU_IGNORE
5158 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
5159 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
5160 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
5161 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
5162 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
5163 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
5164 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
5165 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
5166 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
5170 static const struct alc_model_fixup alc662_fixup_models[] = {
5171 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
5178 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5179 #include "alc662_quirks.c"
5182 static int patch_alc662(struct hda_codec *codec)
5184 struct alc_spec *spec;
5185 int err, board_config;
5188 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5194 spec->mixer_nid = 0x0b;
5196 alc_auto_parse_customize_define(codec);
5198 alc_fix_pll_init(codec, 0x20, 0x04, 15);
5200 coef = alc_read_coef_idx(codec, 0);
5201 if (coef == 0x8020 || coef == 0x8011)
5202 alc_codec_rename(codec, "ALC661");
5203 else if (coef & (1 << 14) &&
5204 codec->bus->pci->subsystem_vendor == 0x1025 &&
5205 spec->cdefine.platform_type == 1)
5206 alc_codec_rename(codec, "ALC272X");
5207 else if (coef == 0x4011)
5208 alc_codec_rename(codec, "ALC656");
5210 board_config = alc_board_config(codec, ALC662_MODEL_LAST,
5211 alc662_models, alc662_cfg_tbl);
5212 if (board_config < 0) {
5213 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5215 board_config = ALC_MODEL_AUTO;
5218 if (board_config == ALC_MODEL_AUTO) {
5219 alc_pick_fixup(codec, alc662_fixup_models,
5220 alc662_fixup_tbl, alc662_fixups);
5221 alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
5222 /* automatic parse from the BIOS config */
5223 err = alc662_parse_auto_config(codec);
5228 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5231 "hda_codec: Cannot set up configuration "
5232 "from BIOS. Using base mode...\n");
5233 board_config = ALC662_3ST_2ch_DIG;
5238 if (board_config != ALC_MODEL_AUTO)
5239 setup_preset(codec, &alc662_presets[board_config]);
5241 if (!spec->no_analog && !spec->adc_nids) {
5242 alc_auto_fill_adc_caps(codec);
5243 alc_rebuild_imux_for_auto_mic(codec);
5244 alc_remove_invalid_adc_nids(codec);
5247 if (!spec->no_analog && !spec->cap_mixer)
5248 set_capture_mixer(codec);
5250 if (!spec->no_analog && has_cdefine_beep(codec)) {
5251 err = snd_hda_attach_beep_device(codec, 0x1);
5256 switch (codec->vendor_id) {
5258 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5263 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
5266 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
5270 spec->vmaster_nid = 0x02;
5272 alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
5274 codec->patch_ops = alc_patch_ops;
5275 if (board_config == ALC_MODEL_AUTO)
5276 spec->init_hook = alc_auto_init_std;
5277 spec->shutup = alc_eapd_shutup;
5279 alc_init_jacks(codec);
5281 #ifdef CONFIG_SND_HDA_POWER_SAVE
5282 if (!spec->loopback.amplist)
5283 spec->loopback.amplist = alc662_loopbacks;
5289 static int patch_alc888(struct hda_codec *codec)
5291 if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
5292 kfree(codec->chip_name);
5293 if (codec->vendor_id == 0x10ec0887)
5294 codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
5296 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
5297 if (!codec->chip_name) {
5301 return patch_alc662(codec);
5303 return patch_alc882(codec);
5306 static int patch_alc899(struct hda_codec *codec)
5308 if ((alc_read_coef_idx(codec, 0) & 0x2000) != 0x2000) {
5309 kfree(codec->chip_name);
5310 codec->chip_name = kstrdup("ALC898", GFP_KERNEL);
5312 return patch_alc882(codec);
5319 static int alc680_parse_auto_config(struct hda_codec *codec)
5321 return alc_parse_auto_config(codec, NULL, NULL);
5326 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5327 #include "alc680_quirks.c"
5330 static int patch_alc680(struct hda_codec *codec)
5332 struct alc_spec *spec;
5336 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5342 /* ALC680 has no aa-loopback mixer */
5344 board_config = alc_board_config(codec, ALC680_MODEL_LAST,
5345 alc680_models, alc680_cfg_tbl);
5347 if (board_config < 0) {
5348 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5350 board_config = ALC_MODEL_AUTO;
5353 if (board_config == ALC_MODEL_AUTO) {
5354 /* automatic parse from the BIOS config */
5355 err = alc680_parse_auto_config(codec);
5360 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5363 "hda_codec: Cannot set up configuration "
5364 "from BIOS. Using base mode...\n");
5365 board_config = ALC680_BASE;
5370 if (board_config != ALC_MODEL_AUTO) {
5371 setup_preset(codec, &alc680_presets[board_config]);
5372 #ifdef CONFIG_SND_HDA_ENABLE_REALTEK_QUIRKS
5373 spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
5377 if (!spec->no_analog && !spec->adc_nids) {
5378 alc_auto_fill_adc_caps(codec);
5379 alc_rebuild_imux_for_auto_mic(codec);
5380 alc_remove_invalid_adc_nids(codec);
5383 if (!spec->no_analog && !spec->cap_mixer)
5384 set_capture_mixer(codec);
5386 spec->vmaster_nid = 0x02;
5388 codec->patch_ops = alc_patch_ops;
5389 if (board_config == ALC_MODEL_AUTO)
5390 spec->init_hook = alc_auto_init_std;
5398 static const struct hda_codec_preset snd_hda_preset_realtek[] = {
5399 { .id = 0x10ec0221, .name = "ALC221", .patch = patch_alc269 },
5400 { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
5401 { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
5402 { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
5403 { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
5404 { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
5405 { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
5406 { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
5407 { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
5408 { .id = 0x10ec0276, .name = "ALC276", .patch = patch_alc269 },
5409 { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
5410 .patch = patch_alc861 },
5411 { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
5412 { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
5413 { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
5414 { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
5415 .patch = patch_alc882 },
5416 { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
5417 .patch = patch_alc662 },
5418 { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
5419 { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
5420 { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
5421 { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
5422 { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
5423 { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
5424 { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
5425 { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
5426 .patch = patch_alc882 },
5427 { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
5428 .patch = patch_alc882 },
5429 { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
5430 { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
5431 { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
5432 .patch = patch_alc882 },
5433 { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
5434 { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
5435 { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
5436 { .id = 0x10ec0899, .name = "ALC899", .patch = patch_alc899 },
5440 MODULE_ALIAS("snd-hda-codec-id:10ec*");
5442 MODULE_LICENSE("GPL");
5443 MODULE_DESCRIPTION("Realtek HD-audio codec");
5445 static struct hda_codec_preset_list realtek_list = {
5446 .preset = snd_hda_preset_realtek,
5447 .owner = THIS_MODULE,
5450 static int __init patch_realtek_init(void)
5452 return snd_hda_add_codec_preset(&realtek_list);
5455 static void __exit patch_realtek_exit(void)
5457 snd_hda_delete_codec_preset(&realtek_list);
5460 module_init(patch_realtek_init)
5461 module_exit(patch_realtek_exit)