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@just42.net>
11 * This driver is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This driver is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/pci.h>
30 #include <linux/dmi.h>
31 #include <linux/module.h>
32 #include <linux/input.h>
33 #include <sound/core.h>
34 #include <sound/jack.h>
35 #include "hda_codec.h"
36 #include "hda_local.h"
37 #include "hda_auto_parser.h"
39 #include "hda_generic.h"
41 /* keep halting ALC5505 DSP, for power saving */
42 #define HALT_REALTEK_ALC5505
45 #define GPIO_MASK 0x03
47 /* extra amp-initialization sequence types */
57 ALC_HEADSET_MODE_UNKNOWN,
58 ALC_HEADSET_MODE_UNPLUGGED,
59 ALC_HEADSET_MODE_HEADSET,
61 ALC_HEADSET_MODE_HEADPHONE,
65 ALC_HEADSET_TYPE_UNKNOWN,
66 ALC_HEADSET_TYPE_CTIA,
67 ALC_HEADSET_TYPE_OMTP,
70 struct alc_customize_define {
72 unsigned char port_connectivity;
73 unsigned char check_sum;
74 unsigned char customization;
75 unsigned char external_amp;
76 unsigned int enable_pcbeep:1;
77 unsigned int platform_type:1;
79 unsigned int override:1;
80 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */
84 struct hda_gen_spec gen; /* must be at head */
86 /* codec parameterization */
87 const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
88 unsigned int num_mixers;
89 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
91 struct alc_customize_define cdefine;
92 unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
94 /* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */
95 int mute_led_polarity;
96 hda_nid_t mute_led_nid;
97 hda_nid_t cap_mute_led_nid;
99 unsigned int gpio_led; /* used for alc269_fixup_hp_gpio_led() */
100 unsigned int gpio_mute_led_mask;
101 unsigned int gpio_mic_led_mask;
103 hda_nid_t headset_mic_pin;
104 hda_nid_t headphone_mic_pin;
105 int current_headset_mode;
106 int current_headset_type;
109 void (*init_hook)(struct hda_codec *codec);
111 void (*power_hook)(struct hda_codec *codec);
113 void (*shutup)(struct hda_codec *codec);
114 void (*reboot_notify)(struct hda_codec *codec);
117 int codec_variant; /* flag for other variants */
118 unsigned int has_alc5505_dsp:1;
119 unsigned int no_depop_delay:1;
123 unsigned int pll_coef_idx, pll_coef_bit;
125 struct input_dev *kb_dev;
129 * COEF access helper functions
132 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
133 unsigned int coef_idx)
137 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
138 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
142 #define alc_read_coef_idx(codec, coef_idx) \
143 alc_read_coefex_idx(codec, 0x20, coef_idx)
145 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
146 unsigned int coef_idx, unsigned int coef_val)
148 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
149 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
152 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
153 alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
155 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
156 unsigned int coef_idx, unsigned int mask,
157 unsigned int bits_set)
159 unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);
162 alc_write_coefex_idx(codec, nid, coef_idx,
163 (val & ~mask) | bits_set);
166 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \
167 alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
169 /* a special bypass for COEF 0; read the cached value at the second time */
170 static unsigned int alc_get_coef0(struct hda_codec *codec)
172 struct alc_spec *spec = codec->spec;
175 spec->coef0 = alc_read_coef_idx(codec, 0);
179 /* coef writes/updates batch */
187 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
188 { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
189 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
190 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
191 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
193 static void alc_process_coef_fw(struct hda_codec *codec,
194 const struct coef_fw *fw)
196 for (; fw->nid; fw++) {
197 if (fw->mask == (unsigned short)-1)
198 alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
200 alc_update_coefex_idx(codec, fw->nid, fw->idx,
206 * Append the given mixer and verb elements for the later use
207 * The mixer array is referred in build_controls(), and init_verbs are
210 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
212 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
214 spec->mixers[spec->num_mixers++] = mix;
218 * GPIO setup tables, used in initialization
220 /* Enable GPIO mask and set output */
221 static const struct hda_verb alc_gpio1_init_verbs[] = {
222 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
223 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
224 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
228 static const struct hda_verb alc_gpio2_init_verbs[] = {
229 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
230 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
231 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
235 static const struct hda_verb alc_gpio3_init_verbs[] = {
236 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
237 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
238 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
243 * Fix hardware PLL issue
244 * On some codecs, the analog PLL gating control must be off while
245 * the default value is 1.
247 static void alc_fix_pll(struct hda_codec *codec)
249 struct alc_spec *spec = codec->spec;
252 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
253 1 << spec->pll_coef_bit, 0);
256 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
257 unsigned int coef_idx, unsigned int coef_bit)
259 struct alc_spec *spec = codec->spec;
261 spec->pll_coef_idx = coef_idx;
262 spec->pll_coef_bit = coef_bit;
266 /* update the master volume per volume-knob's unsol event */
267 static void alc_update_knob_master(struct hda_codec *codec,
268 struct hda_jack_callback *jack)
271 struct snd_kcontrol *kctl;
272 struct snd_ctl_elem_value *uctl;
274 kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
277 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
280 val = snd_hda_codec_read(codec, jack->tbl->nid, 0,
281 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
282 val &= HDA_AMP_VOLMASK;
283 uctl->value.integer.value[0] = val;
284 uctl->value.integer.value[1] = val;
285 kctl->put(kctl, uctl);
289 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
291 /* For some reason, the res given from ALC880 is broken.
292 Here we adjust it properly. */
293 snd_hda_jack_unsol_event(codec, res >> 2);
296 /* Change EAPD to verb control */
297 static void alc_fill_eapd_coef(struct hda_codec *codec)
301 coef = alc_get_coef0(codec);
303 switch (codec->core.vendor_id) {
305 alc_update_coef_idx(codec, 0x7, 0, 1<<5);
309 alc_update_coef_idx(codec, 0x7, 0, 1<<13);
312 if ((coef & 0x00f0) == 0x0010)
313 alc_update_coef_idx(codec, 0xd, 0, 1<<14);
314 if ((coef & 0x00f0) == 0x0020)
315 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
316 if ((coef & 0x00f0) == 0x0030)
317 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
323 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
333 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
337 alc_update_coef_idx(codec, 0xa, 1<<13, 0);
340 if ((coef & 0x00f0) == 0x0030)
341 alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
350 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
353 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
356 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
359 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
360 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
363 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
367 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
372 /* additional initialization for ALC888 variants */
373 static void alc888_coef_init(struct hda_codec *codec)
375 switch (alc_get_coef0(codec) & 0x00f0) {
380 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
385 /* turn on/off EAPD control (only if available) */
386 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
388 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
390 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
391 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
395 /* turn on/off EAPD controls of the codec */
396 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
398 /* We currently only handle front, HP */
399 static hda_nid_t pins[] = {
400 0x0f, 0x10, 0x14, 0x15, 0x17, 0
403 for (p = pins; *p; p++)
404 set_eapd(codec, *p, on);
407 /* generic shutup callback;
408 * just turning off EPAD and a little pause for avoiding pop-noise
410 static void alc_eapd_shutup(struct hda_codec *codec)
412 struct alc_spec *spec = codec->spec;
414 alc_auto_setup_eapd(codec, false);
415 if (!spec->no_depop_delay)
417 snd_hda_shutup_pins(codec);
420 /* generic EAPD initialization */
421 static void alc_auto_init_amp(struct hda_codec *codec, int type)
423 alc_fill_eapd_coef(codec);
424 alc_auto_setup_eapd(codec, true);
427 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
430 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
433 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
435 case ALC_INIT_DEFAULT:
436 switch (codec->core.vendor_id) {
438 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
444 alc_update_coef_idx(codec, 7, 0, 0x2030);
447 alc888_coef_init(codec);
456 * Realtek SSID verification
459 /* Could be any non-zero and even value. When used as fixup, tells
460 * the driver to ignore any present sku defines.
462 #define ALC_FIXUP_SKU_IGNORE (2)
464 static void alc_fixup_sku_ignore(struct hda_codec *codec,
465 const struct hda_fixup *fix, int action)
467 struct alc_spec *spec = codec->spec;
468 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
469 spec->cdefine.fixup = 1;
470 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
474 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
475 const struct hda_fixup *fix, int action)
477 struct alc_spec *spec = codec->spec;
479 if (action == HDA_FIXUP_ACT_PROBE) {
480 spec->no_depop_delay = 1;
481 codec->depop_delay = 0;
485 static int alc_auto_parse_customize_define(struct hda_codec *codec)
487 unsigned int ass, tmp, i;
489 struct alc_spec *spec = codec->spec;
491 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
493 if (spec->cdefine.fixup) {
494 ass = spec->cdefine.sku_cfg;
495 if (ass == ALC_FIXUP_SKU_IGNORE)
500 if (!codec->bus->pci)
502 ass = codec->core.subsystem_id & 0xffff;
503 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
507 if (codec->core.vendor_id == 0x10ec0260)
509 ass = snd_hda_codec_get_pincfg(codec, nid);
512 codec_info(codec, "%s: SKU not ready 0x%08x\n",
513 codec->core.chip_name, ass);
519 for (i = 1; i < 16; i++) {
523 if (((ass >> 16) & 0xf) != tmp)
526 spec->cdefine.port_connectivity = ass >> 30;
527 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
528 spec->cdefine.check_sum = (ass >> 16) & 0xf;
529 spec->cdefine.customization = ass >> 8;
531 spec->cdefine.sku_cfg = ass;
532 spec->cdefine.external_amp = (ass & 0x38) >> 3;
533 spec->cdefine.platform_type = (ass & 0x4) >> 2;
534 spec->cdefine.swap = (ass & 0x2) >> 1;
535 spec->cdefine.override = ass & 0x1;
537 codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
538 nid, spec->cdefine.sku_cfg);
539 codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
540 spec->cdefine.port_connectivity);
541 codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
542 codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
543 codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
544 codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
545 codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
546 codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
547 codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
552 /* return the position of NID in the list, or -1 if not found */
553 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
556 for (i = 0; i < nums; i++)
561 /* return true if the given NID is found in the list */
562 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
564 return find_idx_in_nid_list(nid, list, nums) >= 0;
567 /* check subsystem ID and set up device-specific initialization;
568 * return 1 if initialized, 0 if invalid SSID
570 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
571 * 31 ~ 16 : Manufacture ID
573 * 7 ~ 0 : Assembly ID
574 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
576 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
578 unsigned int ass, tmp, i;
580 struct alc_spec *spec = codec->spec;
582 if (spec->cdefine.fixup) {
583 ass = spec->cdefine.sku_cfg;
584 if (ass == ALC_FIXUP_SKU_IGNORE)
589 ass = codec->core.subsystem_id & 0xffff;
590 if (codec->bus->pci &&
591 ass != codec->bus->pci->subsystem_device && (ass & 1))
594 /* invalid SSID, check the special NID pin defcfg instead */
596 * 31~30 : port connectivity
599 * 19~16 : Check sum (15:1)
604 if (codec->core.vendor_id == 0x10ec0260)
606 ass = snd_hda_codec_get_pincfg(codec, nid);
608 "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
612 if ((ass >> 30) != 1) /* no physical connection */
617 for (i = 1; i < 16; i++) {
621 if (((ass >> 16) & 0xf) != tmp)
624 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
625 ass & 0xffff, codec->core.vendor_id);
629 * 2 : 0 --> Desktop, 1 --> Laptop
630 * 3~5 : External Amplifier control
633 tmp = (ass & 0x38) >> 3; /* external Amp control */
636 spec->init_amp = ALC_INIT_GPIO1;
639 spec->init_amp = ALC_INIT_GPIO2;
642 spec->init_amp = ALC_INIT_GPIO3;
646 spec->init_amp = ALC_INIT_DEFAULT;
650 /* is laptop or Desktop and enable the function "Mute internal speaker
651 * when the external headphone out jack is plugged"
656 * 10~8 : Jack location
657 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
659 * 15 : 1 --> enable the function "Mute internal speaker
660 * when the external headphone out jack is plugged"
662 if (!spec->gen.autocfg.hp_pins[0] &&
663 !(spec->gen.autocfg.line_out_pins[0] &&
664 spec->gen.autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
666 tmp = (ass >> 11) & 0x3; /* HP to chassis */
668 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
669 spec->gen.autocfg.line_outs))
671 spec->gen.autocfg.hp_pins[0] = nid;
676 /* Check the validity of ALC subsystem-id
677 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
678 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
680 if (!alc_subsystem_id(codec, ports)) {
681 struct alc_spec *spec = codec->spec;
683 "realtek: Enable default setup for auto mode as fallback\n");
684 spec->init_amp = ALC_INIT_DEFAULT;
691 static void alc_fixup_inv_dmic(struct hda_codec *codec,
692 const struct hda_fixup *fix, int action)
694 struct alc_spec *spec = codec->spec;
696 spec->gen.inv_dmic_split = 1;
700 #ifdef CONFIG_SND_HDA_INPUT_BEEP
701 /* additional beep mixers; the actual parameters are overwritten at build */
702 static const struct snd_kcontrol_new alc_beep_mixer[] = {
703 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
704 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
709 static int alc_build_controls(struct hda_codec *codec)
711 struct alc_spec *spec = codec->spec;
714 err = snd_hda_gen_build_controls(codec);
718 for (i = 0; i < spec->num_mixers; i++) {
719 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
724 #ifdef CONFIG_SND_HDA_INPUT_BEEP
725 /* create beep controls if needed */
726 if (spec->beep_amp) {
727 const struct snd_kcontrol_new *knew;
728 for (knew = alc_beep_mixer; knew->name; knew++) {
729 struct snd_kcontrol *kctl;
730 kctl = snd_ctl_new1(knew, codec);
733 kctl->private_value = spec->beep_amp;
734 err = snd_hda_ctl_add(codec, 0, kctl);
741 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
750 static int alc_init(struct hda_codec *codec)
752 struct alc_spec *spec = codec->spec;
755 spec->init_hook(codec);
758 alc_auto_init_amp(codec, spec->init_amp);
760 snd_hda_gen_init(codec);
762 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
767 static inline void alc_shutup(struct hda_codec *codec)
769 struct alc_spec *spec = codec->spec;
771 if (spec && spec->shutup)
774 snd_hda_shutup_pins(codec);
777 static void alc_reboot_notify(struct hda_codec *codec)
779 struct alc_spec *spec = codec->spec;
781 if (spec && spec->reboot_notify)
782 spec->reboot_notify(codec);
787 /* power down codec to D3 at reboot/shutdown; set as reboot_notify ops */
788 static void alc_d3_at_reboot(struct hda_codec *codec)
790 snd_hda_codec_set_power_to_all(codec, codec->core.afg, AC_PWRST_D3);
791 snd_hda_codec_write(codec, codec->core.afg, 0,
792 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
796 #define alc_free snd_hda_gen_free
799 static void alc_power_eapd(struct hda_codec *codec)
801 alc_auto_setup_eapd(codec, false);
804 static int alc_suspend(struct hda_codec *codec)
806 struct alc_spec *spec = codec->spec;
808 if (spec && spec->power_hook)
809 spec->power_hook(codec);
815 static int alc_resume(struct hda_codec *codec)
817 struct alc_spec *spec = codec->spec;
819 if (!spec->no_depop_delay)
820 msleep(150); /* to avoid pop noise */
821 codec->patch_ops.init(codec);
822 regcache_sync(codec->core.regmap);
823 hda_call_check_power_status(codec, 0x01);
830 static const struct hda_codec_ops alc_patch_ops = {
831 .build_controls = alc_build_controls,
832 .build_pcms = snd_hda_gen_build_pcms,
835 .unsol_event = snd_hda_jack_unsol_event,
837 .resume = alc_resume,
838 .suspend = alc_suspend,
839 .check_power_status = snd_hda_gen_check_power_status,
841 .reboot_notify = alc_reboot_notify,
845 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
848 * Rename codecs appropriately from COEF value or subvendor id
850 struct alc_codec_rename_table {
851 unsigned int vendor_id;
852 unsigned short coef_mask;
853 unsigned short coef_bits;
857 struct alc_codec_rename_pci_table {
858 unsigned int codec_vendor_id;
859 unsigned short pci_subvendor;
860 unsigned short pci_subdevice;
864 static struct alc_codec_rename_table rename_tbl[] = {
865 { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
866 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
867 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
868 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
869 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
870 { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
871 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
872 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
873 { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
874 { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
875 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
876 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
877 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
878 { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
879 { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
880 { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
881 { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
885 static struct alc_codec_rename_pci_table rename_pci_tbl[] = {
886 { 0x10ec0280, 0x1028, 0, "ALC3220" },
887 { 0x10ec0282, 0x1028, 0, "ALC3221" },
888 { 0x10ec0283, 0x1028, 0, "ALC3223" },
889 { 0x10ec0288, 0x1028, 0, "ALC3263" },
890 { 0x10ec0292, 0x1028, 0, "ALC3226" },
891 { 0x10ec0293, 0x1028, 0, "ALC3235" },
892 { 0x10ec0255, 0x1028, 0, "ALC3234" },
893 { 0x10ec0668, 0x1028, 0, "ALC3661" },
894 { 0x10ec0275, 0x1028, 0, "ALC3260" },
895 { 0x10ec0899, 0x1028, 0, "ALC3861" },
896 { 0x10ec0298, 0x1028, 0, "ALC3266" },
897 { 0x10ec0256, 0x1028, 0, "ALC3246" },
898 { 0x10ec0670, 0x1025, 0, "ALC669X" },
899 { 0x10ec0676, 0x1025, 0, "ALC679X" },
900 { 0x10ec0282, 0x1043, 0, "ALC3229" },
901 { 0x10ec0233, 0x1043, 0, "ALC3236" },
902 { 0x10ec0280, 0x103c, 0, "ALC3228" },
903 { 0x10ec0282, 0x103c, 0, "ALC3227" },
904 { 0x10ec0286, 0x103c, 0, "ALC3242" },
905 { 0x10ec0290, 0x103c, 0, "ALC3241" },
906 { 0x10ec0668, 0x103c, 0, "ALC3662" },
907 { 0x10ec0283, 0x17aa, 0, "ALC3239" },
908 { 0x10ec0292, 0x17aa, 0, "ALC3232" },
912 static int alc_codec_rename_from_preset(struct hda_codec *codec)
914 const struct alc_codec_rename_table *p;
915 const struct alc_codec_rename_pci_table *q;
917 for (p = rename_tbl; p->vendor_id; p++) {
918 if (p->vendor_id != codec->core.vendor_id)
920 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
921 return alc_codec_rename(codec, p->name);
924 if (!codec->bus->pci)
926 for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
927 if (q->codec_vendor_id != codec->core.vendor_id)
929 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
931 if (!q->pci_subdevice ||
932 q->pci_subdevice == codec->bus->pci->subsystem_device)
933 return alc_codec_rename(codec, q->name);
941 * Digital-beep handlers
943 #ifdef CONFIG_SND_HDA_INPUT_BEEP
944 #define set_beep_amp(spec, nid, idx, dir) \
945 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
947 static const struct snd_pci_quirk beep_white_list[] = {
948 SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
949 SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
950 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
951 SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
952 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
953 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
954 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
955 SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
956 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
960 static inline int has_cdefine_beep(struct hda_codec *codec)
962 struct alc_spec *spec = codec->spec;
963 const struct snd_pci_quirk *q;
964 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
967 return spec->cdefine.enable_pcbeep;
970 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
971 #define has_cdefine_beep(codec) 0
974 /* parse the BIOS configuration and set up the alc_spec */
975 /* return 1 if successful, 0 if the proper config is not found,
976 * or a negative error code
978 static int alc_parse_auto_config(struct hda_codec *codec,
979 const hda_nid_t *ignore_nids,
980 const hda_nid_t *ssid_nids)
982 struct alc_spec *spec = codec->spec;
983 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
986 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
992 alc_ssid_check(codec, ssid_nids);
994 err = snd_hda_gen_parse_auto_config(codec, cfg);
1001 /* common preparation job for alc_spec */
1002 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1004 struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1010 snd_hda_gen_spec_init(&spec->gen);
1011 spec->gen.mixer_nid = mixer_nid;
1012 spec->gen.own_eapd_ctl = 1;
1013 codec->single_adc_amp = 1;
1014 /* FIXME: do we need this for all Realtek codec models? */
1015 codec->spdif_status_reset = 1;
1016 codec->patch_ops = alc_patch_ops;
1018 err = alc_codec_rename_from_preset(codec);
1026 static int alc880_parse_auto_config(struct hda_codec *codec)
1028 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1029 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1030 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1039 ALC880_FIXUP_MEDION_RIM,
1041 ALC880_FIXUP_LG_LW25,
1043 ALC880_FIXUP_EAPD_COEF,
1044 ALC880_FIXUP_TCL_S700,
1045 ALC880_FIXUP_VOL_KNOB,
1046 ALC880_FIXUP_FUJITSU,
1048 ALC880_FIXUP_UNIWILL,
1049 ALC880_FIXUP_UNIWILL_DIG,
1051 ALC880_FIXUP_ASUS_W5A,
1052 ALC880_FIXUP_3ST_BASE,
1054 ALC880_FIXUP_3ST_DIG,
1055 ALC880_FIXUP_5ST_BASE,
1057 ALC880_FIXUP_5ST_DIG,
1058 ALC880_FIXUP_6ST_BASE,
1060 ALC880_FIXUP_6ST_DIG,
1061 ALC880_FIXUP_6ST_AUTOMUTE,
1064 /* enable the volume-knob widget support on NID 0x21 */
1065 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1066 const struct hda_fixup *fix, int action)
1068 if (action == HDA_FIXUP_ACT_PROBE)
1069 snd_hda_jack_detect_enable_callback(codec, 0x21,
1070 alc_update_knob_master);
1073 static const struct hda_fixup alc880_fixups[] = {
1074 [ALC880_FIXUP_GPIO1] = {
1075 .type = HDA_FIXUP_VERBS,
1076 .v.verbs = alc_gpio1_init_verbs,
1078 [ALC880_FIXUP_GPIO2] = {
1079 .type = HDA_FIXUP_VERBS,
1080 .v.verbs = alc_gpio2_init_verbs,
1082 [ALC880_FIXUP_MEDION_RIM] = {
1083 .type = HDA_FIXUP_VERBS,
1084 .v.verbs = (const struct hda_verb[]) {
1085 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1086 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1090 .chain_id = ALC880_FIXUP_GPIO2,
1092 [ALC880_FIXUP_LG] = {
1093 .type = HDA_FIXUP_PINS,
1094 .v.pins = (const struct hda_pintbl[]) {
1095 /* disable bogus unused pins */
1096 { 0x16, 0x411111f0 },
1097 { 0x18, 0x411111f0 },
1098 { 0x1a, 0x411111f0 },
1102 [ALC880_FIXUP_LG_LW25] = {
1103 .type = HDA_FIXUP_PINS,
1104 .v.pins = (const struct hda_pintbl[]) {
1105 { 0x1a, 0x0181344f }, /* line-in */
1106 { 0x1b, 0x0321403f }, /* headphone */
1110 [ALC880_FIXUP_W810] = {
1111 .type = HDA_FIXUP_PINS,
1112 .v.pins = (const struct hda_pintbl[]) {
1113 /* disable bogus unused pins */
1114 { 0x17, 0x411111f0 },
1118 .chain_id = ALC880_FIXUP_GPIO2,
1120 [ALC880_FIXUP_EAPD_COEF] = {
1121 .type = HDA_FIXUP_VERBS,
1122 .v.verbs = (const struct hda_verb[]) {
1123 /* change to EAPD mode */
1124 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1125 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1129 [ALC880_FIXUP_TCL_S700] = {
1130 .type = HDA_FIXUP_VERBS,
1131 .v.verbs = (const struct hda_verb[]) {
1132 /* change to EAPD mode */
1133 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1134 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
1138 .chain_id = ALC880_FIXUP_GPIO2,
1140 [ALC880_FIXUP_VOL_KNOB] = {
1141 .type = HDA_FIXUP_FUNC,
1142 .v.func = alc880_fixup_vol_knob,
1144 [ALC880_FIXUP_FUJITSU] = {
1145 /* override all pins as BIOS on old Amilo is broken */
1146 .type = HDA_FIXUP_PINS,
1147 .v.pins = (const struct hda_pintbl[]) {
1148 { 0x14, 0x0121401f }, /* HP */
1149 { 0x15, 0x99030120 }, /* speaker */
1150 { 0x16, 0x99030130 }, /* bass speaker */
1151 { 0x17, 0x411111f0 }, /* N/A */
1152 { 0x18, 0x411111f0 }, /* N/A */
1153 { 0x19, 0x01a19950 }, /* mic-in */
1154 { 0x1a, 0x411111f0 }, /* N/A */
1155 { 0x1b, 0x411111f0 }, /* N/A */
1156 { 0x1c, 0x411111f0 }, /* N/A */
1157 { 0x1d, 0x411111f0 }, /* N/A */
1158 { 0x1e, 0x01454140 }, /* SPDIF out */
1162 .chain_id = ALC880_FIXUP_VOL_KNOB,
1164 [ALC880_FIXUP_F1734] = {
1165 /* almost compatible with FUJITSU, but no bass and SPDIF */
1166 .type = HDA_FIXUP_PINS,
1167 .v.pins = (const struct hda_pintbl[]) {
1168 { 0x14, 0x0121401f }, /* HP */
1169 { 0x15, 0x99030120 }, /* speaker */
1170 { 0x16, 0x411111f0 }, /* N/A */
1171 { 0x17, 0x411111f0 }, /* N/A */
1172 { 0x18, 0x411111f0 }, /* N/A */
1173 { 0x19, 0x01a19950 }, /* mic-in */
1174 { 0x1a, 0x411111f0 }, /* N/A */
1175 { 0x1b, 0x411111f0 }, /* N/A */
1176 { 0x1c, 0x411111f0 }, /* N/A */
1177 { 0x1d, 0x411111f0 }, /* N/A */
1178 { 0x1e, 0x411111f0 }, /* N/A */
1182 .chain_id = ALC880_FIXUP_VOL_KNOB,
1184 [ALC880_FIXUP_UNIWILL] = {
1185 /* need to fix HP and speaker pins to be parsed correctly */
1186 .type = HDA_FIXUP_PINS,
1187 .v.pins = (const struct hda_pintbl[]) {
1188 { 0x14, 0x0121411f }, /* HP */
1189 { 0x15, 0x99030120 }, /* speaker */
1190 { 0x16, 0x99030130 }, /* bass speaker */
1194 [ALC880_FIXUP_UNIWILL_DIG] = {
1195 .type = HDA_FIXUP_PINS,
1196 .v.pins = (const struct hda_pintbl[]) {
1197 /* disable bogus unused pins */
1198 { 0x17, 0x411111f0 },
1199 { 0x19, 0x411111f0 },
1200 { 0x1b, 0x411111f0 },
1201 { 0x1f, 0x411111f0 },
1205 [ALC880_FIXUP_Z71V] = {
1206 .type = HDA_FIXUP_PINS,
1207 .v.pins = (const struct hda_pintbl[]) {
1208 /* set up the whole pins as BIOS is utterly broken */
1209 { 0x14, 0x99030120 }, /* speaker */
1210 { 0x15, 0x0121411f }, /* HP */
1211 { 0x16, 0x411111f0 }, /* N/A */
1212 { 0x17, 0x411111f0 }, /* N/A */
1213 { 0x18, 0x01a19950 }, /* mic-in */
1214 { 0x19, 0x411111f0 }, /* N/A */
1215 { 0x1a, 0x01813031 }, /* line-in */
1216 { 0x1b, 0x411111f0 }, /* N/A */
1217 { 0x1c, 0x411111f0 }, /* N/A */
1218 { 0x1d, 0x411111f0 }, /* N/A */
1219 { 0x1e, 0x0144111e }, /* SPDIF */
1223 [ALC880_FIXUP_ASUS_W5A] = {
1224 .type = HDA_FIXUP_PINS,
1225 .v.pins = (const struct hda_pintbl[]) {
1226 /* set up the whole pins as BIOS is utterly broken */
1227 { 0x14, 0x0121411f }, /* HP */
1228 { 0x15, 0x411111f0 }, /* N/A */
1229 { 0x16, 0x411111f0 }, /* N/A */
1230 { 0x17, 0x411111f0 }, /* N/A */
1231 { 0x18, 0x90a60160 }, /* mic */
1232 { 0x19, 0x411111f0 }, /* N/A */
1233 { 0x1a, 0x411111f0 }, /* N/A */
1234 { 0x1b, 0x411111f0 }, /* N/A */
1235 { 0x1c, 0x411111f0 }, /* N/A */
1236 { 0x1d, 0x411111f0 }, /* N/A */
1237 { 0x1e, 0xb743111e }, /* SPDIF out */
1241 .chain_id = ALC880_FIXUP_GPIO1,
1243 [ALC880_FIXUP_3ST_BASE] = {
1244 .type = HDA_FIXUP_PINS,
1245 .v.pins = (const struct hda_pintbl[]) {
1246 { 0x14, 0x01014010 }, /* line-out */
1247 { 0x15, 0x411111f0 }, /* N/A */
1248 { 0x16, 0x411111f0 }, /* N/A */
1249 { 0x17, 0x411111f0 }, /* N/A */
1250 { 0x18, 0x01a19c30 }, /* mic-in */
1251 { 0x19, 0x0121411f }, /* HP */
1252 { 0x1a, 0x01813031 }, /* line-in */
1253 { 0x1b, 0x02a19c40 }, /* front-mic */
1254 { 0x1c, 0x411111f0 }, /* N/A */
1255 { 0x1d, 0x411111f0 }, /* N/A */
1256 /* 0x1e is filled in below */
1257 { 0x1f, 0x411111f0 }, /* N/A */
1261 [ALC880_FIXUP_3ST] = {
1262 .type = HDA_FIXUP_PINS,
1263 .v.pins = (const struct hda_pintbl[]) {
1264 { 0x1e, 0x411111f0 }, /* N/A */
1268 .chain_id = ALC880_FIXUP_3ST_BASE,
1270 [ALC880_FIXUP_3ST_DIG] = {
1271 .type = HDA_FIXUP_PINS,
1272 .v.pins = (const struct hda_pintbl[]) {
1273 { 0x1e, 0x0144111e }, /* SPDIF */
1277 .chain_id = ALC880_FIXUP_3ST_BASE,
1279 [ALC880_FIXUP_5ST_BASE] = {
1280 .type = HDA_FIXUP_PINS,
1281 .v.pins = (const struct hda_pintbl[]) {
1282 { 0x14, 0x01014010 }, /* front */
1283 { 0x15, 0x411111f0 }, /* N/A */
1284 { 0x16, 0x01011411 }, /* CLFE */
1285 { 0x17, 0x01016412 }, /* surr */
1286 { 0x18, 0x01a19c30 }, /* mic-in */
1287 { 0x19, 0x0121411f }, /* HP */
1288 { 0x1a, 0x01813031 }, /* line-in */
1289 { 0x1b, 0x02a19c40 }, /* front-mic */
1290 { 0x1c, 0x411111f0 }, /* N/A */
1291 { 0x1d, 0x411111f0 }, /* N/A */
1292 /* 0x1e is filled in below */
1293 { 0x1f, 0x411111f0 }, /* N/A */
1297 [ALC880_FIXUP_5ST] = {
1298 .type = HDA_FIXUP_PINS,
1299 .v.pins = (const struct hda_pintbl[]) {
1300 { 0x1e, 0x411111f0 }, /* N/A */
1304 .chain_id = ALC880_FIXUP_5ST_BASE,
1306 [ALC880_FIXUP_5ST_DIG] = {
1307 .type = HDA_FIXUP_PINS,
1308 .v.pins = (const struct hda_pintbl[]) {
1309 { 0x1e, 0x0144111e }, /* SPDIF */
1313 .chain_id = ALC880_FIXUP_5ST_BASE,
1315 [ALC880_FIXUP_6ST_BASE] = {
1316 .type = HDA_FIXUP_PINS,
1317 .v.pins = (const struct hda_pintbl[]) {
1318 { 0x14, 0x01014010 }, /* front */
1319 { 0x15, 0x01016412 }, /* surr */
1320 { 0x16, 0x01011411 }, /* CLFE */
1321 { 0x17, 0x01012414 }, /* side */
1322 { 0x18, 0x01a19c30 }, /* mic-in */
1323 { 0x19, 0x02a19c40 }, /* front-mic */
1324 { 0x1a, 0x01813031 }, /* line-in */
1325 { 0x1b, 0x0121411f }, /* HP */
1326 { 0x1c, 0x411111f0 }, /* N/A */
1327 { 0x1d, 0x411111f0 }, /* N/A */
1328 /* 0x1e is filled in below */
1329 { 0x1f, 0x411111f0 }, /* N/A */
1333 [ALC880_FIXUP_6ST] = {
1334 .type = HDA_FIXUP_PINS,
1335 .v.pins = (const struct hda_pintbl[]) {
1336 { 0x1e, 0x411111f0 }, /* N/A */
1340 .chain_id = ALC880_FIXUP_6ST_BASE,
1342 [ALC880_FIXUP_6ST_DIG] = {
1343 .type = HDA_FIXUP_PINS,
1344 .v.pins = (const struct hda_pintbl[]) {
1345 { 0x1e, 0x0144111e }, /* SPDIF */
1349 .chain_id = ALC880_FIXUP_6ST_BASE,
1351 [ALC880_FIXUP_6ST_AUTOMUTE] = {
1352 .type = HDA_FIXUP_PINS,
1353 .v.pins = (const struct hda_pintbl[]) {
1354 { 0x1b, 0x0121401f }, /* HP with jack detect */
1357 .chained_before = true,
1358 .chain_id = ALC880_FIXUP_6ST_BASE,
1362 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1363 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1364 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1365 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1366 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1367 SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1368 SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1369 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1370 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1371 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1372 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1373 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1374 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1375 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1376 SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1377 SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1378 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1379 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1380 SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1381 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1382 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1383 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1384 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1385 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1387 /* Below is the copied entries from alc880_quirks.c.
1388 * It's not quite sure whether BIOS sets the correct pin-config table
1389 * on these machines, thus they are kept to be compatible with
1390 * the old static quirks. Once when it's confirmed to work without
1391 * these overrides, it'd be better to remove.
1393 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1394 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1395 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1396 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1397 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1398 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1399 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1400 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1401 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1402 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1403 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1404 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1405 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1406 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1407 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1408 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1409 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1410 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1411 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1412 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1413 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1414 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1415 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1416 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1417 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1418 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1419 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1420 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1421 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1422 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1423 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1424 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1425 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1427 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1428 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1429 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1433 static const struct hda_model_fixup alc880_fixup_models[] = {
1434 {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1435 {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1436 {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1437 {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1438 {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1439 {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1440 {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1446 * OK, here we have finally the patch for ALC880
1448 static int patch_alc880(struct hda_codec *codec)
1450 struct alc_spec *spec;
1453 err = alc_alloc_spec(codec, 0x0b);
1458 spec->gen.need_dac_fix = 1;
1459 spec->gen.beep_nid = 0x01;
1461 codec->patch_ops.unsol_event = alc880_unsol_event;
1463 snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1465 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1467 /* automatic parse from the BIOS config */
1468 err = alc880_parse_auto_config(codec);
1472 if (!spec->gen.no_analog)
1473 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1475 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1488 static int alc260_parse_auto_config(struct hda_codec *codec)
1490 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1491 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1492 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1499 ALC260_FIXUP_HP_DC5750,
1500 ALC260_FIXUP_HP_PIN_0F,
1503 ALC260_FIXUP_GPIO1_TOGGLE,
1504 ALC260_FIXUP_REPLACER,
1505 ALC260_FIXUP_HP_B1900,
1507 ALC260_FIXUP_FSC_S7020,
1508 ALC260_FIXUP_FSC_S7020_JWSE,
1509 ALC260_FIXUP_VAIO_PINS,
1512 static void alc260_gpio1_automute(struct hda_codec *codec)
1514 struct alc_spec *spec = codec->spec;
1515 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1516 spec->gen.hp_jack_present);
1519 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1520 const struct hda_fixup *fix, int action)
1522 struct alc_spec *spec = codec->spec;
1523 if (action == HDA_FIXUP_ACT_PROBE) {
1524 /* although the machine has only one output pin, we need to
1525 * toggle GPIO1 according to the jack state
1527 spec->gen.automute_hook = alc260_gpio1_automute;
1528 spec->gen.detect_hp = 1;
1529 spec->gen.automute_speaker = 1;
1530 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1531 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1532 snd_hda_gen_hp_automute);
1533 snd_hda_add_verbs(codec, alc_gpio1_init_verbs);
1537 static void alc260_fixup_kn1(struct hda_codec *codec,
1538 const struct hda_fixup *fix, int action)
1540 struct alc_spec *spec = codec->spec;
1541 static const struct hda_pintbl pincfgs[] = {
1542 { 0x0f, 0x02214000 }, /* HP/speaker */
1543 { 0x12, 0x90a60160 }, /* int mic */
1544 { 0x13, 0x02a19000 }, /* ext mic */
1545 { 0x18, 0x01446000 }, /* SPDIF out */
1546 /* disable bogus I/O pins */
1547 { 0x10, 0x411111f0 },
1548 { 0x11, 0x411111f0 },
1549 { 0x14, 0x411111f0 },
1550 { 0x15, 0x411111f0 },
1551 { 0x16, 0x411111f0 },
1552 { 0x17, 0x411111f0 },
1553 { 0x19, 0x411111f0 },
1558 case HDA_FIXUP_ACT_PRE_PROBE:
1559 snd_hda_apply_pincfgs(codec, pincfgs);
1561 case HDA_FIXUP_ACT_PROBE:
1562 spec->init_amp = ALC_INIT_NONE;
1567 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1568 const struct hda_fixup *fix, int action)
1570 struct alc_spec *spec = codec->spec;
1571 if (action == HDA_FIXUP_ACT_PROBE)
1572 spec->init_amp = ALC_INIT_NONE;
1575 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1576 const struct hda_fixup *fix, int action)
1578 struct alc_spec *spec = codec->spec;
1579 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1580 spec->gen.add_jack_modes = 1;
1581 spec->gen.hp_mic = 1;
1585 static const struct hda_fixup alc260_fixups[] = {
1586 [ALC260_FIXUP_HP_DC5750] = {
1587 .type = HDA_FIXUP_PINS,
1588 .v.pins = (const struct hda_pintbl[]) {
1589 { 0x11, 0x90130110 }, /* speaker */
1593 [ALC260_FIXUP_HP_PIN_0F] = {
1594 .type = HDA_FIXUP_PINS,
1595 .v.pins = (const struct hda_pintbl[]) {
1596 { 0x0f, 0x01214000 }, /* HP */
1600 [ALC260_FIXUP_COEF] = {
1601 .type = HDA_FIXUP_VERBS,
1602 .v.verbs = (const struct hda_verb[]) {
1603 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1604 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 },
1608 [ALC260_FIXUP_GPIO1] = {
1609 .type = HDA_FIXUP_VERBS,
1610 .v.verbs = alc_gpio1_init_verbs,
1612 [ALC260_FIXUP_GPIO1_TOGGLE] = {
1613 .type = HDA_FIXUP_FUNC,
1614 .v.func = alc260_fixup_gpio1_toggle,
1616 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1618 [ALC260_FIXUP_REPLACER] = {
1619 .type = HDA_FIXUP_VERBS,
1620 .v.verbs = (const struct hda_verb[]) {
1621 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1622 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 },
1626 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1628 [ALC260_FIXUP_HP_B1900] = {
1629 .type = HDA_FIXUP_FUNC,
1630 .v.func = alc260_fixup_gpio1_toggle,
1632 .chain_id = ALC260_FIXUP_COEF,
1634 [ALC260_FIXUP_KN1] = {
1635 .type = HDA_FIXUP_FUNC,
1636 .v.func = alc260_fixup_kn1,
1638 [ALC260_FIXUP_FSC_S7020] = {
1639 .type = HDA_FIXUP_FUNC,
1640 .v.func = alc260_fixup_fsc_s7020,
1642 [ALC260_FIXUP_FSC_S7020_JWSE] = {
1643 .type = HDA_FIXUP_FUNC,
1644 .v.func = alc260_fixup_fsc_s7020_jwse,
1646 .chain_id = ALC260_FIXUP_FSC_S7020,
1648 [ALC260_FIXUP_VAIO_PINS] = {
1649 .type = HDA_FIXUP_PINS,
1650 .v.pins = (const struct hda_pintbl[]) {
1651 /* Pin configs are missing completely on some VAIOs */
1652 { 0x0f, 0x01211020 },
1653 { 0x10, 0x0001003f },
1654 { 0x11, 0x411111f0 },
1655 { 0x12, 0x01a15930 },
1656 { 0x13, 0x411111f0 },
1657 { 0x14, 0x411111f0 },
1658 { 0x15, 0x411111f0 },
1659 { 0x16, 0x411111f0 },
1660 { 0x17, 0x411111f0 },
1661 { 0x18, 0x411111f0 },
1662 { 0x19, 0x411111f0 },
1668 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1669 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1670 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1671 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1672 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1673 SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1674 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1675 SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1676 SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1677 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1678 SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1679 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1680 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1684 static const struct hda_model_fixup alc260_fixup_models[] = {
1685 {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1686 {.id = ALC260_FIXUP_COEF, .name = "coef"},
1687 {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1688 {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1694 static int patch_alc260(struct hda_codec *codec)
1696 struct alc_spec *spec;
1699 err = alc_alloc_spec(codec, 0x07);
1704 /* as quite a few machines require HP amp for speaker outputs,
1705 * it's easier to enable it unconditionally; even if it's unneeded,
1706 * it's almost harmless.
1708 spec->gen.prefer_hp_amp = 1;
1709 spec->gen.beep_nid = 0x01;
1711 spec->shutup = alc_eapd_shutup;
1713 snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1715 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1717 /* automatic parse from the BIOS config */
1718 err = alc260_parse_auto_config(codec);
1722 if (!spec->gen.no_analog)
1723 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1725 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1736 * ALC882/883/885/888/889 support
1738 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1739 * configuration. Each pin widget can choose any input DACs and a mixer.
1740 * Each ADC is connected from a mixer of all inputs. This makes possible
1741 * 6-channel independent captures.
1743 * In addition, an independent DAC for the multi-playback (not used in this
1751 ALC882_FIXUP_ABIT_AW9D_MAX,
1752 ALC882_FIXUP_LENOVO_Y530,
1753 ALC882_FIXUP_PB_M5210,
1754 ALC882_FIXUP_ACER_ASPIRE_7736,
1755 ALC882_FIXUP_ASUS_W90V,
1757 ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1758 ALC889_FIXUP_VAIO_TT,
1759 ALC888_FIXUP_EEE1601,
1762 ALC883_FIXUP_ACER_EAPD,
1767 ALC882_FIXUP_ASUS_W2JC,
1768 ALC882_FIXUP_ACER_ASPIRE_4930G,
1769 ALC882_FIXUP_ACER_ASPIRE_8930G,
1770 ALC882_FIXUP_ASPIRE_8930G_VERBS,
1771 ALC885_FIXUP_MACPRO_GPIO,
1772 ALC889_FIXUP_DAC_ROUTE,
1773 ALC889_FIXUP_MBP_VREF,
1774 ALC889_FIXUP_IMAC91_VREF,
1775 ALC889_FIXUP_MBA11_VREF,
1776 ALC889_FIXUP_MBA21_VREF,
1777 ALC889_FIXUP_MP11_VREF,
1778 ALC882_FIXUP_INV_DMIC,
1779 ALC882_FIXUP_NO_PRIMARY_HP,
1780 ALC887_FIXUP_ASUS_BASS,
1781 ALC887_FIXUP_BASS_CHMAP,
1782 ALC882_FIXUP_DISABLE_AAMIX,
1785 static void alc889_fixup_coef(struct hda_codec *codec,
1786 const struct hda_fixup *fix, int action)
1788 if (action != HDA_FIXUP_ACT_INIT)
1790 alc_update_coef_idx(codec, 7, 0, 0x2030);
1793 /* toggle speaker-output according to the hp-jack state */
1794 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
1796 unsigned int gpiostate, gpiomask, gpiodir;
1798 gpiostate = snd_hda_codec_read(codec, codec->core.afg, 0,
1799 AC_VERB_GET_GPIO_DATA, 0);
1802 gpiostate |= (1 << pin);
1804 gpiostate &= ~(1 << pin);
1806 gpiomask = snd_hda_codec_read(codec, codec->core.afg, 0,
1807 AC_VERB_GET_GPIO_MASK, 0);
1808 gpiomask |= (1 << pin);
1810 gpiodir = snd_hda_codec_read(codec, codec->core.afg, 0,
1811 AC_VERB_GET_GPIO_DIRECTION, 0);
1812 gpiodir |= (1 << pin);
1815 snd_hda_codec_write(codec, codec->core.afg, 0,
1816 AC_VERB_SET_GPIO_MASK, gpiomask);
1817 snd_hda_codec_write(codec, codec->core.afg, 0,
1818 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
1822 snd_hda_codec_write(codec, codec->core.afg, 0,
1823 AC_VERB_SET_GPIO_DATA, gpiostate);
1826 /* set up GPIO at initialization */
1827 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1828 const struct hda_fixup *fix, int action)
1830 if (action != HDA_FIXUP_ACT_INIT)
1832 alc882_gpio_mute(codec, 0, 0);
1833 alc882_gpio_mute(codec, 1, 0);
1836 /* Fix the connection of some pins for ALC889:
1837 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
1838 * work correctly (bko#42740)
1840 static void alc889_fixup_dac_route(struct hda_codec *codec,
1841 const struct hda_fixup *fix, int action)
1843 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1844 /* fake the connections during parsing the tree */
1845 hda_nid_t conn1[2] = { 0x0c, 0x0d };
1846 hda_nid_t conn2[2] = { 0x0e, 0x0f };
1847 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
1848 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
1849 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
1850 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
1851 } else if (action == HDA_FIXUP_ACT_PROBE) {
1852 /* restore the connections */
1853 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
1854 snd_hda_override_conn_list(codec, 0x14, 5, conn);
1855 snd_hda_override_conn_list(codec, 0x15, 5, conn);
1856 snd_hda_override_conn_list(codec, 0x18, 5, conn);
1857 snd_hda_override_conn_list(codec, 0x1a, 5, conn);
1861 /* Set VREF on HP pin */
1862 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
1863 const struct hda_fixup *fix, int action)
1865 struct alc_spec *spec = codec->spec;
1866 static hda_nid_t nids[2] = { 0x14, 0x15 };
1869 if (action != HDA_FIXUP_ACT_INIT)
1871 for (i = 0; i < ARRAY_SIZE(nids); i++) {
1872 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
1873 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
1875 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1876 val |= AC_PINCTL_VREF_80;
1877 snd_hda_set_pin_ctl(codec, nids[i], val);
1878 spec->gen.keep_vref_in_automute = 1;
1883 static void alc889_fixup_mac_pins(struct hda_codec *codec,
1884 const hda_nid_t *nids, int num_nids)
1886 struct alc_spec *spec = codec->spec;
1889 for (i = 0; i < num_nids; i++) {
1891 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1892 val |= AC_PINCTL_VREF_50;
1893 snd_hda_set_pin_ctl(codec, nids[i], val);
1895 spec->gen.keep_vref_in_automute = 1;
1898 /* Set VREF on speaker pins on imac91 */
1899 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
1900 const struct hda_fixup *fix, int action)
1902 static hda_nid_t nids[2] = { 0x18, 0x1a };
1904 if (action == HDA_FIXUP_ACT_INIT)
1905 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1908 /* Set VREF on speaker pins on mba11 */
1909 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
1910 const struct hda_fixup *fix, int action)
1912 static hda_nid_t nids[1] = { 0x18 };
1914 if (action == HDA_FIXUP_ACT_INIT)
1915 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1918 /* Set VREF on speaker pins on mba21 */
1919 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
1920 const struct hda_fixup *fix, int action)
1922 static hda_nid_t nids[2] = { 0x18, 0x19 };
1924 if (action == HDA_FIXUP_ACT_INIT)
1925 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1928 /* Don't take HP output as primary
1929 * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
1930 * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
1932 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
1933 const struct hda_fixup *fix, int action)
1935 struct alc_spec *spec = codec->spec;
1936 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1937 spec->gen.no_primary_hp = 1;
1938 spec->gen.no_multi_io = 1;
1942 static void alc_fixup_bass_chmap(struct hda_codec *codec,
1943 const struct hda_fixup *fix, int action);
1944 static void alc_fixup_disable_aamix(struct hda_codec *codec,
1945 const struct hda_fixup *fix, int action);
1947 static const struct hda_fixup alc882_fixups[] = {
1948 [ALC882_FIXUP_ABIT_AW9D_MAX] = {
1949 .type = HDA_FIXUP_PINS,
1950 .v.pins = (const struct hda_pintbl[]) {
1951 { 0x15, 0x01080104 }, /* side */
1952 { 0x16, 0x01011012 }, /* rear */
1953 { 0x17, 0x01016011 }, /* clfe */
1957 [ALC882_FIXUP_LENOVO_Y530] = {
1958 .type = HDA_FIXUP_PINS,
1959 .v.pins = (const struct hda_pintbl[]) {
1960 { 0x15, 0x99130112 }, /* rear int speakers */
1961 { 0x16, 0x99130111 }, /* subwoofer */
1965 [ALC882_FIXUP_PB_M5210] = {
1966 .type = HDA_FIXUP_PINCTLS,
1967 .v.pins = (const struct hda_pintbl[]) {
1968 { 0x19, PIN_VREF50 },
1972 [ALC882_FIXUP_ACER_ASPIRE_7736] = {
1973 .type = HDA_FIXUP_FUNC,
1974 .v.func = alc_fixup_sku_ignore,
1976 [ALC882_FIXUP_ASUS_W90V] = {
1977 .type = HDA_FIXUP_PINS,
1978 .v.pins = (const struct hda_pintbl[]) {
1979 { 0x16, 0x99130110 }, /* fix sequence for CLFE */
1983 [ALC889_FIXUP_CD] = {
1984 .type = HDA_FIXUP_PINS,
1985 .v.pins = (const struct hda_pintbl[]) {
1986 { 0x1c, 0x993301f0 }, /* CD */
1990 [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
1991 .type = HDA_FIXUP_PINS,
1992 .v.pins = (const struct hda_pintbl[]) {
1993 { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
1997 .chain_id = ALC889_FIXUP_CD,
1999 [ALC889_FIXUP_VAIO_TT] = {
2000 .type = HDA_FIXUP_PINS,
2001 .v.pins = (const struct hda_pintbl[]) {
2002 { 0x17, 0x90170111 }, /* hidden surround speaker */
2006 [ALC888_FIXUP_EEE1601] = {
2007 .type = HDA_FIXUP_VERBS,
2008 .v.verbs = (const struct hda_verb[]) {
2009 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2010 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },
2014 [ALC882_FIXUP_EAPD] = {
2015 .type = HDA_FIXUP_VERBS,
2016 .v.verbs = (const struct hda_verb[]) {
2017 /* change to EAPD mode */
2018 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2019 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2023 [ALC883_FIXUP_EAPD] = {
2024 .type = HDA_FIXUP_VERBS,
2025 .v.verbs = (const struct hda_verb[]) {
2026 /* change to EAPD mode */
2027 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2028 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2032 [ALC883_FIXUP_ACER_EAPD] = {
2033 .type = HDA_FIXUP_VERBS,
2034 .v.verbs = (const struct hda_verb[]) {
2035 /* eanable EAPD on Acer laptops */
2036 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2037 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2041 [ALC882_FIXUP_GPIO1] = {
2042 .type = HDA_FIXUP_VERBS,
2043 .v.verbs = alc_gpio1_init_verbs,
2045 [ALC882_FIXUP_GPIO2] = {
2046 .type = HDA_FIXUP_VERBS,
2047 .v.verbs = alc_gpio2_init_verbs,
2049 [ALC882_FIXUP_GPIO3] = {
2050 .type = HDA_FIXUP_VERBS,
2051 .v.verbs = alc_gpio3_init_verbs,
2053 [ALC882_FIXUP_ASUS_W2JC] = {
2054 .type = HDA_FIXUP_VERBS,
2055 .v.verbs = alc_gpio1_init_verbs,
2057 .chain_id = ALC882_FIXUP_EAPD,
2059 [ALC889_FIXUP_COEF] = {
2060 .type = HDA_FIXUP_FUNC,
2061 .v.func = alc889_fixup_coef,
2063 [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2064 .type = HDA_FIXUP_PINS,
2065 .v.pins = (const struct hda_pintbl[]) {
2066 { 0x16, 0x99130111 }, /* CLFE speaker */
2067 { 0x17, 0x99130112 }, /* surround speaker */
2071 .chain_id = ALC882_FIXUP_GPIO1,
2073 [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2074 .type = HDA_FIXUP_PINS,
2075 .v.pins = (const struct hda_pintbl[]) {
2076 { 0x16, 0x99130111 }, /* CLFE speaker */
2077 { 0x1b, 0x99130112 }, /* surround speaker */
2081 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2083 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2084 /* additional init verbs for Acer Aspire 8930G */
2085 .type = HDA_FIXUP_VERBS,
2086 .v.verbs = (const struct hda_verb[]) {
2087 /* Enable all DACs */
2088 /* DAC DISABLE/MUTE 1? */
2089 /* setting bits 1-5 disables DAC nids 0x02-0x06
2090 * apparently. Init=0x38 */
2091 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2092 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2093 /* DAC DISABLE/MUTE 2? */
2094 /* some bit here disables the other DACs.
2096 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2097 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2099 * This laptop has a stereo digital microphone.
2100 * The mics are only 1cm apart which makes the stereo
2101 * useless. However, either the mic or the ALC889
2102 * makes the signal become a difference/sum signal
2103 * instead of standard stereo, which is annoying.
2104 * So instead we flip this bit which makes the
2105 * codec replicate the sum signal to both channels,
2106 * turning it into a normal mono mic.
2108 /* DMIC_CONTROL? Init value = 0x0001 */
2109 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2110 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2111 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2112 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2116 .chain_id = ALC882_FIXUP_GPIO1,
2118 [ALC885_FIXUP_MACPRO_GPIO] = {
2119 .type = HDA_FIXUP_FUNC,
2120 .v.func = alc885_fixup_macpro_gpio,
2122 [ALC889_FIXUP_DAC_ROUTE] = {
2123 .type = HDA_FIXUP_FUNC,
2124 .v.func = alc889_fixup_dac_route,
2126 [ALC889_FIXUP_MBP_VREF] = {
2127 .type = HDA_FIXUP_FUNC,
2128 .v.func = alc889_fixup_mbp_vref,
2130 .chain_id = ALC882_FIXUP_GPIO1,
2132 [ALC889_FIXUP_IMAC91_VREF] = {
2133 .type = HDA_FIXUP_FUNC,
2134 .v.func = alc889_fixup_imac91_vref,
2136 .chain_id = ALC882_FIXUP_GPIO1,
2138 [ALC889_FIXUP_MBA11_VREF] = {
2139 .type = HDA_FIXUP_FUNC,
2140 .v.func = alc889_fixup_mba11_vref,
2142 .chain_id = ALC889_FIXUP_MBP_VREF,
2144 [ALC889_FIXUP_MBA21_VREF] = {
2145 .type = HDA_FIXUP_FUNC,
2146 .v.func = alc889_fixup_mba21_vref,
2148 .chain_id = ALC889_FIXUP_MBP_VREF,
2150 [ALC889_FIXUP_MP11_VREF] = {
2151 .type = HDA_FIXUP_FUNC,
2152 .v.func = alc889_fixup_mba11_vref,
2154 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2156 [ALC882_FIXUP_INV_DMIC] = {
2157 .type = HDA_FIXUP_FUNC,
2158 .v.func = alc_fixup_inv_dmic,
2160 [ALC882_FIXUP_NO_PRIMARY_HP] = {
2161 .type = HDA_FIXUP_FUNC,
2162 .v.func = alc882_fixup_no_primary_hp,
2164 [ALC887_FIXUP_ASUS_BASS] = {
2165 .type = HDA_FIXUP_PINS,
2166 .v.pins = (const struct hda_pintbl[]) {
2167 {0x16, 0x99130130}, /* bass speaker */
2171 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2173 [ALC887_FIXUP_BASS_CHMAP] = {
2174 .type = HDA_FIXUP_FUNC,
2175 .v.func = alc_fixup_bass_chmap,
2177 [ALC882_FIXUP_DISABLE_AAMIX] = {
2178 .type = HDA_FIXUP_FUNC,
2179 .v.func = alc_fixup_disable_aamix,
2183 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2184 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2185 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2186 SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2187 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2188 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2189 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2190 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2191 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2192 ALC882_FIXUP_ACER_ASPIRE_4930G),
2193 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2194 ALC882_FIXUP_ACER_ASPIRE_4930G),
2195 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2196 ALC882_FIXUP_ACER_ASPIRE_8930G),
2197 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2198 ALC882_FIXUP_ACER_ASPIRE_8930G),
2199 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2200 ALC882_FIXUP_ACER_ASPIRE_4930G),
2201 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2202 ALC882_FIXUP_ACER_ASPIRE_4930G),
2203 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2204 ALC882_FIXUP_ACER_ASPIRE_4930G),
2205 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2206 SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2207 ALC882_FIXUP_ACER_ASPIRE_4930G),
2208 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2209 SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2210 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2211 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2212 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2213 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2214 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2215 SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2216 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2217 SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2218 SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2220 /* All Apple entries are in codec SSIDs */
2221 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2222 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2223 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2224 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2225 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2226 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2227 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2228 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2229 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2230 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2231 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2232 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2233 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2234 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2235 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2236 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2237 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2238 SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 5,1", ALC885_FIXUP_MACPRO_GPIO),
2239 SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2240 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2241 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2242 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2244 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2245 SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2246 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2247 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2248 SND_PCI_QUIRK(0x1458, 0xa182, "Gigabyte Z170X-UD3", ALC882_FIXUP_DISABLE_AAMIX),
2249 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2250 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2251 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2252 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2253 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2257 static const struct hda_model_fixup alc882_fixup_models[] = {
2258 {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2259 {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2260 {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2261 {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2262 {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2267 * BIOS auto configuration
2269 /* almost identical with ALC880 parser... */
2270 static int alc882_parse_auto_config(struct hda_codec *codec)
2272 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2273 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2274 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2279 static int patch_alc882(struct hda_codec *codec)
2281 struct alc_spec *spec;
2284 err = alc_alloc_spec(codec, 0x0b);
2290 switch (codec->core.vendor_id) {
2296 /* ALC883 and variants */
2297 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2301 snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2303 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2305 alc_auto_parse_customize_define(codec);
2307 if (has_cdefine_beep(codec))
2308 spec->gen.beep_nid = 0x01;
2310 /* automatic parse from the BIOS config */
2311 err = alc882_parse_auto_config(codec);
2315 if (!spec->gen.no_analog && spec->gen.beep_nid)
2316 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2318 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2331 static int alc262_parse_auto_config(struct hda_codec *codec)
2333 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2334 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2335 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2342 ALC262_FIXUP_FSC_H270,
2343 ALC262_FIXUP_FSC_S7110,
2344 ALC262_FIXUP_HP_Z200,
2346 ALC262_FIXUP_LENOVO_3000,
2348 ALC262_FIXUP_BENQ_T31,
2349 ALC262_FIXUP_INV_DMIC,
2350 ALC262_FIXUP_INTEL_BAYLEYBAY,
2353 static const struct hda_fixup alc262_fixups[] = {
2354 [ALC262_FIXUP_FSC_H270] = {
2355 .type = HDA_FIXUP_PINS,
2356 .v.pins = (const struct hda_pintbl[]) {
2357 { 0x14, 0x99130110 }, /* speaker */
2358 { 0x15, 0x0221142f }, /* front HP */
2359 { 0x1b, 0x0121141f }, /* rear HP */
2363 [ALC262_FIXUP_FSC_S7110] = {
2364 .type = HDA_FIXUP_PINS,
2365 .v.pins = (const struct hda_pintbl[]) {
2366 { 0x15, 0x90170110 }, /* speaker */
2370 .chain_id = ALC262_FIXUP_BENQ,
2372 [ALC262_FIXUP_HP_Z200] = {
2373 .type = HDA_FIXUP_PINS,
2374 .v.pins = (const struct hda_pintbl[]) {
2375 { 0x16, 0x99130120 }, /* internal speaker */
2379 [ALC262_FIXUP_TYAN] = {
2380 .type = HDA_FIXUP_PINS,
2381 .v.pins = (const struct hda_pintbl[]) {
2382 { 0x14, 0x1993e1f0 }, /* int AUX */
2386 [ALC262_FIXUP_LENOVO_3000] = {
2387 .type = HDA_FIXUP_PINCTLS,
2388 .v.pins = (const struct hda_pintbl[]) {
2389 { 0x19, PIN_VREF50 },
2393 .chain_id = ALC262_FIXUP_BENQ,
2395 [ALC262_FIXUP_BENQ] = {
2396 .type = HDA_FIXUP_VERBS,
2397 .v.verbs = (const struct hda_verb[]) {
2398 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2399 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2403 [ALC262_FIXUP_BENQ_T31] = {
2404 .type = HDA_FIXUP_VERBS,
2405 .v.verbs = (const struct hda_verb[]) {
2406 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2407 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2411 [ALC262_FIXUP_INV_DMIC] = {
2412 .type = HDA_FIXUP_FUNC,
2413 .v.func = alc_fixup_inv_dmic,
2415 [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2416 .type = HDA_FIXUP_FUNC,
2417 .v.func = alc_fixup_no_depop_delay,
2421 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2422 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2423 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2424 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2425 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2426 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2427 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2428 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2429 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2430 SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2434 static const struct hda_model_fixup alc262_fixup_models[] = {
2435 {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2441 static int patch_alc262(struct hda_codec *codec)
2443 struct alc_spec *spec;
2446 err = alc_alloc_spec(codec, 0x0b);
2451 spec->gen.shared_mic_vref_pin = 0x18;
2453 spec->shutup = alc_eapd_shutup;
2456 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
2459 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2461 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2463 snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2465 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2467 alc_auto_parse_customize_define(codec);
2469 if (has_cdefine_beep(codec))
2470 spec->gen.beep_nid = 0x01;
2472 /* automatic parse from the BIOS config */
2473 err = alc262_parse_auto_config(codec);
2477 if (!spec->gen.no_analog && spec->gen.beep_nid)
2478 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2480 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2492 /* bind Beep switches of both NID 0x0f and 0x10 */
2493 static const struct hda_bind_ctls alc268_bind_beep_sw = {
2494 .ops = &snd_hda_bind_sw,
2496 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
2497 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
2502 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2503 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2504 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
2508 /* set PCBEEP vol = 0, mute connections */
2509 static const struct hda_verb alc268_beep_init_verbs[] = {
2510 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2511 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2512 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2517 ALC268_FIXUP_INV_DMIC,
2518 ALC268_FIXUP_HP_EAPD,
2522 static const struct hda_fixup alc268_fixups[] = {
2523 [ALC268_FIXUP_INV_DMIC] = {
2524 .type = HDA_FIXUP_FUNC,
2525 .v.func = alc_fixup_inv_dmic,
2527 [ALC268_FIXUP_HP_EAPD] = {
2528 .type = HDA_FIXUP_VERBS,
2529 .v.verbs = (const struct hda_verb[]) {
2530 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
2534 [ALC268_FIXUP_SPDIF] = {
2535 .type = HDA_FIXUP_PINS,
2536 .v.pins = (const struct hda_pintbl[]) {
2537 { 0x1e, 0x014b1180 }, /* enable SPDIF out */
2543 static const struct hda_model_fixup alc268_fixup_models[] = {
2544 {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2545 {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
2549 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2550 SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
2551 SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2552 /* below is codec SSID since multiple Toshiba laptops have the
2553 * same PCI SSID 1179:ff00
2555 SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
2560 * BIOS auto configuration
2562 static int alc268_parse_auto_config(struct hda_codec *codec)
2564 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2565 return alc_parse_auto_config(codec, NULL, alc268_ssids);
2570 static int patch_alc268(struct hda_codec *codec)
2572 struct alc_spec *spec;
2575 /* ALC268 has no aa-loopback mixer */
2576 err = alc_alloc_spec(codec, 0);
2581 spec->gen.beep_nid = 0x01;
2583 spec->shutup = alc_eapd_shutup;
2585 snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
2586 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2588 /* automatic parse from the BIOS config */
2589 err = alc268_parse_auto_config(codec);
2593 if (err > 0 && !spec->gen.no_analog &&
2594 spec->gen.autocfg.speaker_pins[0] != 0x1d) {
2595 add_mixer(spec, alc268_beep_mixer);
2596 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
2597 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
2598 /* override the amp caps for beep generator */
2599 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
2600 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
2601 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
2602 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2603 (0 << AC_AMPCAP_MUTE_SHIFT));
2606 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2619 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
2620 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2623 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
2624 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2627 /* different alc269-variants */
2629 ALC269_TYPE_ALC269VA,
2630 ALC269_TYPE_ALC269VB,
2631 ALC269_TYPE_ALC269VC,
2632 ALC269_TYPE_ALC269VD,
2645 * BIOS auto configuration
2647 static int alc269_parse_auto_config(struct hda_codec *codec)
2649 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
2650 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
2651 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2652 struct alc_spec *spec = codec->spec;
2653 const hda_nid_t *ssids;
2655 switch (spec->codec_variant) {
2656 case ALC269_TYPE_ALC269VA:
2657 case ALC269_TYPE_ALC269VC:
2658 case ALC269_TYPE_ALC280:
2659 case ALC269_TYPE_ALC284:
2660 case ALC269_TYPE_ALC285:
2661 ssids = alc269va_ssids;
2663 case ALC269_TYPE_ALC269VB:
2664 case ALC269_TYPE_ALC269VD:
2665 case ALC269_TYPE_ALC282:
2666 case ALC269_TYPE_ALC283:
2667 case ALC269_TYPE_ALC286:
2668 case ALC269_TYPE_ALC298:
2669 case ALC269_TYPE_ALC255:
2670 case ALC269_TYPE_ALC256:
2671 ssids = alc269_ssids;
2674 ssids = alc269_ssids;
2678 return alc_parse_auto_config(codec, alc269_ignore, ssids);
2681 static int find_ext_mic_pin(struct hda_codec *codec);
2683 static void alc286_shutup(struct hda_codec *codec)
2686 int mic_pin = find_ext_mic_pin(codec);
2687 /* don't shut up pins when unloading the driver; otherwise it breaks
2688 * the default pin setup at the next load of the driver
2690 if (codec->bus->shutdown)
2692 for (i = 0; i < codec->init_pins.used; i++) {
2693 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
2694 /* use read here for syncing after issuing each verb */
2695 if (pin->nid != mic_pin)
2696 snd_hda_codec_read(codec, pin->nid, 0,
2697 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
2699 codec->pins_shutup = 1;
2702 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
2704 alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
2707 static void alc269_shutup(struct hda_codec *codec)
2709 struct alc_spec *spec = codec->spec;
2711 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
2712 alc269vb_toggle_power_output(codec, 0);
2713 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
2714 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
2717 snd_hda_shutup_pins(codec);
2720 static struct coef_fw alc282_coefs[] = {
2721 WRITE_COEF(0x03, 0x0002), /* Power Down Control */
2722 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
2723 WRITE_COEF(0x07, 0x0200), /* DMIC control */
2724 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
2725 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
2726 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
2727 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
2728 WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
2729 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
2730 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
2731 WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
2732 UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
2733 WRITE_COEF(0x34, 0xa0c0), /* ANC */
2734 UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
2735 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
2736 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
2737 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
2738 WRITE_COEF(0x63, 0x2902), /* PLL */
2739 WRITE_COEF(0x68, 0xa080), /* capless control 2 */
2740 WRITE_COEF(0x69, 0x3400), /* capless control 3 */
2741 WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
2742 WRITE_COEF(0x6b, 0x0), /* capless control 5 */
2743 UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
2744 WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
2745 UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
2746 WRITE_COEF(0x71, 0x0014), /* class D test 6 */
2747 WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
2748 UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
2749 WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
2753 static void alc282_restore_default_value(struct hda_codec *codec)
2755 alc_process_coef_fw(codec, alc282_coefs);
2758 static void alc282_init(struct hda_codec *codec)
2760 struct alc_spec *spec = codec->spec;
2761 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2765 alc282_restore_default_value(codec);
2769 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2770 coef78 = alc_read_coef_idx(codec, 0x78);
2772 /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
2773 /* Headphone capless set to high power mode */
2774 alc_write_coef_idx(codec, 0x78, 0x9004);
2779 snd_hda_codec_write(codec, hp_pin, 0,
2780 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2785 snd_hda_codec_write(codec, hp_pin, 0,
2786 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
2791 /* Headphone capless set to normal mode */
2792 alc_write_coef_idx(codec, 0x78, coef78);
2795 static void alc282_shutup(struct hda_codec *codec)
2797 struct alc_spec *spec = codec->spec;
2798 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2803 alc269_shutup(codec);
2807 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2808 coef78 = alc_read_coef_idx(codec, 0x78);
2809 alc_write_coef_idx(codec, 0x78, 0x9004);
2814 snd_hda_codec_write(codec, hp_pin, 0,
2815 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2820 snd_hda_codec_write(codec, hp_pin, 0,
2821 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
2826 alc_auto_setup_eapd(codec, false);
2827 snd_hda_shutup_pins(codec);
2828 alc_write_coef_idx(codec, 0x78, coef78);
2831 static struct coef_fw alc283_coefs[] = {
2832 WRITE_COEF(0x03, 0x0002), /* Power Down Control */
2833 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
2834 WRITE_COEF(0x07, 0x0200), /* DMIC control */
2835 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
2836 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
2837 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
2838 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
2839 WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
2840 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
2841 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
2842 WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
2843 UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
2844 WRITE_COEF(0x22, 0xa0c0), /* ANC */
2845 UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
2846 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
2847 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
2848 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
2849 WRITE_COEF(0x2e, 0x2902), /* PLL */
2850 WRITE_COEF(0x33, 0xa080), /* capless control 2 */
2851 WRITE_COEF(0x34, 0x3400), /* capless control 3 */
2852 WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
2853 WRITE_COEF(0x36, 0x0), /* capless control 5 */
2854 UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
2855 WRITE_COEF(0x39, 0x110a), /* class D test 3 */
2856 UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
2857 WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
2858 WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
2859 UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
2860 WRITE_COEF(0x49, 0x0), /* test mode */
2861 UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
2862 UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
2863 WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
2864 UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
2868 static void alc283_restore_default_value(struct hda_codec *codec)
2870 alc_process_coef_fw(codec, alc283_coefs);
2873 static void alc283_init(struct hda_codec *codec)
2875 struct alc_spec *spec = codec->spec;
2876 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2879 if (!spec->gen.autocfg.hp_outs) {
2880 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
2881 hp_pin = spec->gen.autocfg.line_out_pins[0];
2884 alc283_restore_default_value(codec);
2890 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2892 /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
2893 /* Headphone capless set to high power mode */
2894 alc_write_coef_idx(codec, 0x43, 0x9004);
2896 snd_hda_codec_write(codec, hp_pin, 0,
2897 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2902 snd_hda_codec_write(codec, hp_pin, 0,
2903 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
2907 /* Index 0x46 Combo jack auto switch control 2 */
2908 /* 3k pull low control for Headset jack. */
2909 alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
2910 /* Headphone capless set to normal mode */
2911 alc_write_coef_idx(codec, 0x43, 0x9614);
2914 static void alc283_shutup(struct hda_codec *codec)
2916 struct alc_spec *spec = codec->spec;
2917 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2920 if (!spec->gen.autocfg.hp_outs) {
2921 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
2922 hp_pin = spec->gen.autocfg.line_out_pins[0];
2926 alc269_shutup(codec);
2930 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2932 alc_write_coef_idx(codec, 0x43, 0x9004);
2934 /*depop hp during suspend*/
2935 alc_write_coef_idx(codec, 0x06, 0x2100);
2937 snd_hda_codec_write(codec, hp_pin, 0,
2938 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2943 snd_hda_codec_write(codec, hp_pin, 0,
2944 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
2946 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
2950 alc_auto_setup_eapd(codec, false);
2951 snd_hda_shutup_pins(codec);
2952 alc_write_coef_idx(codec, 0x43, 0x9614);
2955 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
2958 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
2959 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
2960 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
2963 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
2967 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
2968 val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
2970 val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
2975 static void alc5505_dsp_halt(struct hda_codec *codec)
2979 alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
2980 alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
2981 alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
2982 alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
2983 alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
2984 alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
2985 alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
2986 val = alc5505_coef_get(codec, 0x6220);
2987 alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
2990 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
2992 alc5505_coef_set(codec, 0x61b8, 0x04133302);
2993 alc5505_coef_set(codec, 0x61b0, 0x00005b16);
2994 alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
2995 alc5505_coef_set(codec, 0x6230, 0xf80d4011);
2996 alc5505_coef_set(codec, 0x6220, 0x2002010f);
2997 alc5505_coef_set(codec, 0x880c, 0x00000004);
3000 static void alc5505_dsp_init(struct hda_codec *codec)
3004 alc5505_dsp_halt(codec);
3005 alc5505_dsp_back_from_halt(codec);
3006 alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3007 alc5505_coef_set(codec, 0x61b0, 0x5b16);
3008 alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
3009 alc5505_coef_set(codec, 0x61b4, 0x04132b02);
3010 alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
3011 alc5505_coef_set(codec, 0x61b8, 0x041f3302);
3012 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
3013 alc5505_coef_set(codec, 0x61b8, 0x041b3302);
3014 alc5505_coef_set(codec, 0x61b8, 0x04173302);
3015 alc5505_coef_set(codec, 0x61b8, 0x04163302);
3016 alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
3017 alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
3018 alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
3020 val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
3022 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
3024 alc5505_coef_set(codec, 0x6220, 0x6002018f);
3026 alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
3027 alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
3028 alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
3029 alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
3030 alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
3031 alc5505_coef_set(codec, 0x880c, 0x00000003);
3032 alc5505_coef_set(codec, 0x880c, 0x00000010);
3034 #ifdef HALT_REALTEK_ALC5505
3035 alc5505_dsp_halt(codec);
3039 #ifdef HALT_REALTEK_ALC5505
3040 #define alc5505_dsp_suspend(codec) /* NOP */
3041 #define alc5505_dsp_resume(codec) /* NOP */
3043 #define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec)
3044 #define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec)
3048 static int alc269_suspend(struct hda_codec *codec)
3050 struct alc_spec *spec = codec->spec;
3052 if (spec->has_alc5505_dsp)
3053 alc5505_dsp_suspend(codec);
3054 return alc_suspend(codec);
3057 static int alc269_resume(struct hda_codec *codec)
3059 struct alc_spec *spec = codec->spec;
3061 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3062 alc269vb_toggle_power_output(codec, 0);
3063 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3064 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3068 codec->patch_ops.init(codec);
3070 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3071 alc269vb_toggle_power_output(codec, 1);
3072 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3073 (alc_get_coef0(codec) & 0x00ff) == 0x017) {
3077 regcache_sync(codec->core.regmap);
3078 hda_call_check_power_status(codec, 0x01);
3080 /* on some machine, the BIOS will clear the codec gpio data when enter
3081 * suspend, and won't restore the data after resume, so we restore it
3085 snd_hda_codec_write(codec, codec->core.afg, 0, AC_VERB_SET_GPIO_DATA,
3088 if (spec->has_alc5505_dsp)
3089 alc5505_dsp_resume(codec);
3093 #endif /* CONFIG_PM */
3095 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
3096 const struct hda_fixup *fix, int action)
3098 struct alc_spec *spec = codec->spec;
3100 if (action == HDA_FIXUP_ACT_PRE_PROBE)
3101 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
3104 static void alc269_fixup_hweq(struct hda_codec *codec,
3105 const struct hda_fixup *fix, int action)
3107 if (action == HDA_FIXUP_ACT_INIT)
3108 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
3111 static void alc269_fixup_headset_mic(struct hda_codec *codec,
3112 const struct hda_fixup *fix, int action)
3114 struct alc_spec *spec = codec->spec;
3116 if (action == HDA_FIXUP_ACT_PRE_PROBE)
3117 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3120 static void alc271_fixup_dmic(struct hda_codec *codec,
3121 const struct hda_fixup *fix, int action)
3123 static const struct hda_verb verbs[] = {
3124 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
3125 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
3130 if (strcmp(codec->core.chip_name, "ALC271X") &&
3131 strcmp(codec->core.chip_name, "ALC269VB"))
3133 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
3134 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
3135 snd_hda_sequence_write(codec, verbs);
3138 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
3139 const struct hda_fixup *fix, int action)
3141 struct alc_spec *spec = codec->spec;
3143 if (action != HDA_FIXUP_ACT_PROBE)
3146 /* Due to a hardware problem on Lenovo Ideadpad, we need to
3147 * fix the sample rate of analog I/O to 44.1kHz
3149 spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
3150 spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
3153 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
3154 const struct hda_fixup *fix, int action)
3156 /* The digital-mic unit sends PDM (differential signal) instead of
3157 * the standard PCM, thus you can't record a valid mono stream as is.
3158 * Below is a workaround specific to ALC269 to control the dmic
3159 * signal source as mono.
3161 if (action == HDA_FIXUP_ACT_INIT)
3162 alc_update_coef_idx(codec, 0x07, 0, 0x80);
3165 static void alc269_quanta_automute(struct hda_codec *codec)
3167 snd_hda_gen_update_outputs(codec);
3169 alc_write_coef_idx(codec, 0x0c, 0x680);
3170 alc_write_coef_idx(codec, 0x0c, 0x480);
3173 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
3174 const struct hda_fixup *fix, int action)
3176 struct alc_spec *spec = codec->spec;
3177 if (action != HDA_FIXUP_ACT_PROBE)
3179 spec->gen.automute_hook = alc269_quanta_automute;
3182 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
3183 struct hda_jack_callback *jack)
3185 struct alc_spec *spec = codec->spec;
3188 snd_hda_gen_hp_automute(codec, jack);
3190 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
3192 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3195 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3199 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
3200 const struct hda_fixup *fix, int action)
3202 struct alc_spec *spec = codec->spec;
3203 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3204 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3205 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
3210 /* update mute-LED according to the speaker mute state via mic VREF pin */
3211 static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)
3213 struct hda_codec *codec = private_data;
3214 struct alc_spec *spec = codec->spec;
3215 unsigned int pinval;
3217 if (spec->mute_led_polarity)
3219 pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);
3220 pinval &= ~AC_PINCTL_VREFEN;
3221 pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;
3222 if (spec->mute_led_nid)
3223 snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
3226 /* Make sure the led works even in runtime suspend */
3227 static unsigned int led_power_filter(struct hda_codec *codec,
3229 unsigned int power_state)
3231 struct alc_spec *spec = codec->spec;
3233 if (power_state != AC_PWRST_D3 || nid == 0 ||
3234 (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
3237 /* Set pin ctl again, it might have just been set to 0 */
3238 snd_hda_set_pin_ctl(codec, nid,
3239 snd_hda_codec_get_pin_target(codec, nid));
3241 return snd_hda_gen_path_power_filter(codec, nid, power_state);
3244 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
3245 const struct hda_fixup *fix, int action)
3247 struct alc_spec *spec = codec->spec;
3248 const struct dmi_device *dev = NULL;
3250 if (action != HDA_FIXUP_ACT_PRE_PROBE)
3253 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
3255 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
3257 if (pin < 0x0a || pin >= 0x10)
3259 spec->mute_led_polarity = pol;
3260 spec->mute_led_nid = pin - 0x0a + 0x18;
3261 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3262 spec->gen.vmaster_mute_enum = 1;
3263 codec->power_filter = led_power_filter;
3265 "Detected mute LED for %x:%d\n", spec->mute_led_nid,
3266 spec->mute_led_polarity);
3271 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
3272 const struct hda_fixup *fix, int action)
3274 struct alc_spec *spec = codec->spec;
3275 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3276 spec->mute_led_polarity = 0;
3277 spec->mute_led_nid = 0x18;
3278 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3279 spec->gen.vmaster_mute_enum = 1;
3280 codec->power_filter = led_power_filter;
3284 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
3285 const struct hda_fixup *fix, int action)
3287 struct alc_spec *spec = codec->spec;
3288 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3289 spec->mute_led_polarity = 0;
3290 spec->mute_led_nid = 0x19;
3291 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3292 spec->gen.vmaster_mute_enum = 1;
3293 codec->power_filter = led_power_filter;
3297 /* update LED status via GPIO */
3298 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
3301 struct alc_spec *spec = codec->spec;
3302 unsigned int oldval = spec->gpio_led;
3304 if (spec->mute_led_polarity)
3308 spec->gpio_led &= ~mask;
3310 spec->gpio_led |= mask;
3311 if (spec->gpio_led != oldval)
3312 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
3316 /* turn on/off mute LED via GPIO per vmaster hook */
3317 static void alc_fixup_gpio_mute_hook(void *private_data, int enabled)
3319 struct hda_codec *codec = private_data;
3320 struct alc_spec *spec = codec->spec;
3322 alc_update_gpio_led(codec, spec->gpio_mute_led_mask, enabled);
3325 /* turn on/off mic-mute LED via GPIO per capture hook */
3326 static void alc_fixup_gpio_mic_mute_hook(struct hda_codec *codec,
3327 struct snd_kcontrol *kcontrol,
3328 struct snd_ctl_elem_value *ucontrol)
3330 struct alc_spec *spec = codec->spec;
3333 alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
3334 ucontrol->value.integer.value[0] ||
3335 ucontrol->value.integer.value[1]);
3338 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
3339 const struct hda_fixup *fix, int action)
3341 struct alc_spec *spec = codec->spec;
3342 static const struct hda_verb gpio_init[] = {
3343 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
3344 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
3348 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3349 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3350 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3352 spec->mute_led_polarity = 0;
3353 spec->gpio_mute_led_mask = 0x08;
3354 spec->gpio_mic_led_mask = 0x10;
3355 snd_hda_add_verbs(codec, gpio_init);
3359 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
3360 const struct hda_fixup *fix, int action)
3362 struct alc_spec *spec = codec->spec;
3363 static const struct hda_verb gpio_init[] = {
3364 { 0x01, AC_VERB_SET_GPIO_MASK, 0x22 },
3365 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x22 },
3369 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3370 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3371 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3373 spec->mute_led_polarity = 0;
3374 spec->gpio_mute_led_mask = 0x02;
3375 spec->gpio_mic_led_mask = 0x20;
3376 snd_hda_add_verbs(codec, gpio_init);
3380 /* turn on/off mic-mute LED per capture hook */
3381 static void alc269_fixup_hp_cap_mic_mute_hook(struct hda_codec *codec,
3382 struct snd_kcontrol *kcontrol,
3383 struct snd_ctl_elem_value *ucontrol)
3385 struct alc_spec *spec = codec->spec;
3386 unsigned int pinval, enable, disable;
3388 pinval = snd_hda_codec_get_pin_target(codec, spec->cap_mute_led_nid);
3389 pinval &= ~AC_PINCTL_VREFEN;
3390 enable = pinval | AC_PINCTL_VREF_80;
3391 disable = pinval | AC_PINCTL_VREF_HIZ;
3396 if (ucontrol->value.integer.value[0] ||
3397 ucontrol->value.integer.value[1])
3402 if (spec->cap_mute_led_nid)
3403 snd_hda_set_pin_ctl_cache(codec, spec->cap_mute_led_nid, pinval);
3406 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
3407 const struct hda_fixup *fix, int action)
3409 struct alc_spec *spec = codec->spec;
3410 static const struct hda_verb gpio_init[] = {
3411 { 0x01, AC_VERB_SET_GPIO_MASK, 0x08 },
3412 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x08 },
3416 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3417 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3418 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
3420 spec->mute_led_polarity = 0;
3421 spec->gpio_mute_led_mask = 0x08;
3422 spec->cap_mute_led_nid = 0x18;
3423 snd_hda_add_verbs(codec, gpio_init);
3424 codec->power_filter = led_power_filter;
3428 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
3429 const struct hda_fixup *fix, int action)
3431 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to enable headphone amp */
3432 struct alc_spec *spec = codec->spec;
3433 static const struct hda_verb gpio_init[] = {
3434 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
3435 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
3439 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3440 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3441 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
3443 spec->mute_led_polarity = 0;
3444 spec->gpio_mute_led_mask = 0x08;
3445 spec->cap_mute_led_nid = 0x18;
3446 snd_hda_add_verbs(codec, gpio_init);
3447 codec->power_filter = led_power_filter;
3451 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
3452 struct hda_jack_callback *event)
3454 struct alc_spec *spec = codec->spec;
3456 /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
3457 send both key on and key off event for every interrupt. */
3458 input_report_key(spec->kb_dev, KEY_MICMUTE, 1);
3459 input_sync(spec->kb_dev);
3460 input_report_key(spec->kb_dev, KEY_MICMUTE, 0);
3461 input_sync(spec->kb_dev);
3464 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
3465 const struct hda_fixup *fix, int action)
3467 /* GPIO1 = set according to SKU external amp
3468 GPIO2 = mic mute hotkey
3470 GPIO4 = mic mute LED */
3471 static const struct hda_verb gpio_init[] = {
3472 { 0x01, AC_VERB_SET_GPIO_MASK, 0x1e },
3473 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x1a },
3474 { 0x01, AC_VERB_SET_GPIO_DATA, 0x02 },
3478 struct alc_spec *spec = codec->spec;
3480 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3481 spec->kb_dev = input_allocate_device();
3482 if (!spec->kb_dev) {
3483 codec_err(codec, "Out of memory (input_allocate_device)\n");
3486 spec->kb_dev->name = "Microphone Mute Button";
3487 spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
3488 spec->kb_dev->keybit[BIT_WORD(KEY_MICMUTE)] = BIT_MASK(KEY_MICMUTE);
3489 if (input_register_device(spec->kb_dev)) {
3490 codec_err(codec, "input_register_device failed\n");
3491 input_free_device(spec->kb_dev);
3492 spec->kb_dev = NULL;
3496 snd_hda_add_verbs(codec, gpio_init);
3497 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
3498 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
3499 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
3500 gpio2_mic_hotkey_event);
3502 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3503 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3505 spec->mute_led_polarity = 0;
3506 spec->gpio_mute_led_mask = 0x08;
3507 spec->gpio_mic_led_mask = 0x10;
3515 case HDA_FIXUP_ACT_PROBE:
3516 spec->init_amp = ALC_INIT_DEFAULT;
3518 case HDA_FIXUP_ACT_FREE:
3519 input_unregister_device(spec->kb_dev);
3520 spec->kb_dev = NULL;
3524 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
3525 const struct hda_fixup *fix, int action)
3527 struct alc_spec *spec = codec->spec;
3529 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3530 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3531 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
3532 spec->mute_led_polarity = 0;
3533 spec->mute_led_nid = 0x1a;
3534 spec->cap_mute_led_nid = 0x18;
3535 spec->gen.vmaster_mute_enum = 1;
3536 codec->power_filter = led_power_filter;
3540 static void alc_headset_mode_unplugged(struct hda_codec *codec)
3542 static struct coef_fw coef0255[] = {
3543 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
3544 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
3545 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
3546 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
3547 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
3550 static struct coef_fw coef0233[] = {
3551 WRITE_COEF(0x1b, 0x0c0b),
3552 WRITE_COEF(0x45, 0xc429),
3553 UPDATE_COEF(0x35, 0x4000, 0),
3554 WRITE_COEF(0x06, 0x2104),
3555 WRITE_COEF(0x1a, 0x0001),
3556 WRITE_COEF(0x26, 0x0004),
3557 WRITE_COEF(0x32, 0x42a3),
3560 static struct coef_fw coef0288[] = {
3561 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
3562 UPDATE_COEF(0x50, 0x2000, 0x2000),
3563 UPDATE_COEF(0x56, 0x0006, 0x0006),
3564 UPDATE_COEF(0x66, 0x0008, 0),
3565 UPDATE_COEF(0x67, 0x2000, 0),
3568 static struct coef_fw coef0292[] = {
3569 WRITE_COEF(0x76, 0x000e),
3570 WRITE_COEF(0x6c, 0x2400),
3571 WRITE_COEF(0x18, 0x7308),
3572 WRITE_COEF(0x6b, 0xc429),
3575 static struct coef_fw coef0293[] = {
3576 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
3577 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
3578 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
3579 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
3580 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
3581 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
3584 static struct coef_fw coef0668[] = {
3585 WRITE_COEF(0x15, 0x0d40),
3586 WRITE_COEF(0xb7, 0x802b),
3590 switch (codec->core.vendor_id) {
3593 alc_process_coef_fw(codec, coef0255);
3597 alc_process_coef_fw(codec, coef0233);
3602 alc_process_coef_fw(codec, coef0288);
3605 alc_process_coef_fw(codec, coef0292);
3608 alc_process_coef_fw(codec, coef0293);
3611 alc_process_coef_fw(codec, coef0668);
3614 codec_dbg(codec, "Headset jack set to unplugged mode.\n");
3618 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
3621 static struct coef_fw coef0255[] = {
3622 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
3623 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
3626 static struct coef_fw coef0233[] = {
3627 UPDATE_COEF(0x35, 0, 1<<14),
3628 WRITE_COEF(0x06, 0x2100),
3629 WRITE_COEF(0x1a, 0x0021),
3630 WRITE_COEF(0x26, 0x008c),
3633 static struct coef_fw coef0288[] = {
3634 UPDATE_COEF(0x50, 0x2000, 0),
3635 UPDATE_COEF(0x56, 0x0006, 0),
3636 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
3637 UPDATE_COEF(0x66, 0x0008, 0x0008),
3638 UPDATE_COEF(0x67, 0x2000, 0x2000),
3641 static struct coef_fw coef0292[] = {
3642 WRITE_COEF(0x19, 0xa208),
3643 WRITE_COEF(0x2e, 0xacf0),
3646 static struct coef_fw coef0293[] = {
3647 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
3648 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
3649 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
3652 static struct coef_fw coef0688[] = {
3653 WRITE_COEF(0xb7, 0x802b),
3654 WRITE_COEF(0xb5, 0x1040),
3655 UPDATE_COEF(0xc3, 0, 1<<12),
3659 switch (codec->core.vendor_id) {
3662 alc_write_coef_idx(codec, 0x45, 0xc489);
3663 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3664 alc_process_coef_fw(codec, coef0255);
3665 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3669 alc_write_coef_idx(codec, 0x45, 0xc429);
3670 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3671 alc_process_coef_fw(codec, coef0233);
3672 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3677 alc_update_coef_idx(codec, 0x4f, 0x000c, 0);
3678 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3679 alc_process_coef_fw(codec, coef0288);
3680 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3683 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3684 alc_process_coef_fw(codec, coef0292);
3687 /* Set to TRS mode */
3688 alc_write_coef_idx(codec, 0x45, 0xc429);
3689 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3690 alc_process_coef_fw(codec, coef0293);
3691 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3694 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3695 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3698 alc_write_coef_idx(codec, 0x11, 0x0001);
3699 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3700 alc_process_coef_fw(codec, coef0688);
3701 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3704 codec_dbg(codec, "Headset jack set to mic-in mode.\n");
3707 static void alc_headset_mode_default(struct hda_codec *codec)
3709 static struct coef_fw coef0255[] = {
3710 WRITE_COEF(0x45, 0xc089),
3711 WRITE_COEF(0x45, 0xc489),
3712 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
3713 WRITE_COEF(0x49, 0x0049),
3716 static struct coef_fw coef0233[] = {
3717 WRITE_COEF(0x06, 0x2100),
3718 WRITE_COEF(0x32, 0x4ea3),
3721 static struct coef_fw coef0288[] = {
3722 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
3723 UPDATE_COEF(0x50, 0x2000, 0x2000),
3724 UPDATE_COEF(0x56, 0x0006, 0x0006),
3725 UPDATE_COEF(0x66, 0x0008, 0),
3726 UPDATE_COEF(0x67, 0x2000, 0),
3729 static struct coef_fw coef0292[] = {
3730 WRITE_COEF(0x76, 0x000e),
3731 WRITE_COEF(0x6c, 0x2400),
3732 WRITE_COEF(0x6b, 0xc429),
3733 WRITE_COEF(0x18, 0x7308),
3736 static struct coef_fw coef0293[] = {
3737 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
3738 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
3739 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
3742 static struct coef_fw coef0688[] = {
3743 WRITE_COEF(0x11, 0x0041),
3744 WRITE_COEF(0x15, 0x0d40),
3745 WRITE_COEF(0xb7, 0x802b),
3749 switch (codec->core.vendor_id) {
3752 alc_process_coef_fw(codec, coef0255);
3756 alc_process_coef_fw(codec, coef0233);
3761 alc_process_coef_fw(codec, coef0288);
3764 alc_process_coef_fw(codec, coef0292);
3767 alc_process_coef_fw(codec, coef0293);
3770 alc_process_coef_fw(codec, coef0688);
3773 codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
3777 static void alc_headset_mode_ctia(struct hda_codec *codec)
3779 static struct coef_fw coef0255[] = {
3780 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
3781 WRITE_COEF(0x1b, 0x0c2b),
3782 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
3785 static struct coef_fw coef0233[] = {
3786 WRITE_COEF(0x45, 0xd429),
3787 WRITE_COEF(0x1b, 0x0c2b),
3788 WRITE_COEF(0x32, 0x4ea3),
3791 static struct coef_fw coef0288[] = {
3792 UPDATE_COEF(0x50, 0x2000, 0x2000),
3793 UPDATE_COEF(0x56, 0x0006, 0x0006),
3794 UPDATE_COEF(0x66, 0x0008, 0),
3795 UPDATE_COEF(0x67, 0x2000, 0),
3798 static struct coef_fw coef0292[] = {
3799 WRITE_COEF(0x6b, 0xd429),
3800 WRITE_COEF(0x76, 0x0008),
3801 WRITE_COEF(0x18, 0x7388),
3804 static struct coef_fw coef0293[] = {
3805 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
3806 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
3809 static struct coef_fw coef0688[] = {
3810 WRITE_COEF(0x11, 0x0001),
3811 WRITE_COEF(0x15, 0x0d60),
3812 WRITE_COEF(0xc3, 0x0000),
3816 switch (codec->core.vendor_id) {
3819 alc_process_coef_fw(codec, coef0255);
3823 alc_process_coef_fw(codec, coef0233);
3826 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);/* Headset output enable */
3827 /* ALC298 jack type setting is the same with ALC286/ALC288 */
3830 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
3832 alc_process_coef_fw(codec, coef0288);
3835 alc_process_coef_fw(codec, coef0292);
3838 alc_process_coef_fw(codec, coef0293);
3841 alc_process_coef_fw(codec, coef0688);
3844 codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
3848 static void alc_headset_mode_omtp(struct hda_codec *codec)
3850 static struct coef_fw coef0255[] = {
3851 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
3852 WRITE_COEF(0x1b, 0x0c2b),
3853 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
3856 static struct coef_fw coef0233[] = {
3857 WRITE_COEF(0x45, 0xe429),
3858 WRITE_COEF(0x1b, 0x0c2b),
3859 WRITE_COEF(0x32, 0x4ea3),
3862 static struct coef_fw coef0288[] = {
3863 UPDATE_COEF(0x50, 0x2000, 0x2000),
3864 UPDATE_COEF(0x56, 0x0006, 0x0006),
3865 UPDATE_COEF(0x66, 0x0008, 0),
3866 UPDATE_COEF(0x67, 0x2000, 0),
3869 static struct coef_fw coef0292[] = {
3870 WRITE_COEF(0x6b, 0xe429),
3871 WRITE_COEF(0x76, 0x0008),
3872 WRITE_COEF(0x18, 0x7388),
3875 static struct coef_fw coef0293[] = {
3876 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
3877 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
3880 static struct coef_fw coef0688[] = {
3881 WRITE_COEF(0x11, 0x0001),
3882 WRITE_COEF(0x15, 0x0d50),
3883 WRITE_COEF(0xc3, 0x0000),
3887 switch (codec->core.vendor_id) {
3890 alc_process_coef_fw(codec, coef0255);
3894 alc_process_coef_fw(codec, coef0233);
3897 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
3898 /* ALC298 jack type setting is the same with ALC286/ALC288 */
3901 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
3903 alc_process_coef_fw(codec, coef0288);
3906 alc_process_coef_fw(codec, coef0292);
3909 alc_process_coef_fw(codec, coef0293);
3912 alc_process_coef_fw(codec, coef0688);
3915 codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
3918 static void alc_determine_headset_type(struct hda_codec *codec)
3921 bool is_ctia = false;
3922 struct alc_spec *spec = codec->spec;
3923 static struct coef_fw coef0255[] = {
3924 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
3925 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
3929 static struct coef_fw coef0288[] = {
3930 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
3933 static struct coef_fw coef0293[] = {
3934 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
3935 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
3938 static struct coef_fw coef0688[] = {
3939 WRITE_COEF(0x11, 0x0001),
3940 WRITE_COEF(0xb7, 0x802b),
3941 WRITE_COEF(0x15, 0x0d60),
3942 WRITE_COEF(0xc3, 0x0c00),
3946 switch (codec->core.vendor_id) {
3949 alc_process_coef_fw(codec, coef0255);
3951 val = alc_read_coef_idx(codec, 0x46);
3952 is_ctia = (val & 0x0070) == 0x0070;
3956 alc_write_coef_idx(codec, 0x45, 0xd029);
3958 val = alc_read_coef_idx(codec, 0x46);
3959 is_ctia = (val & 0x0070) == 0x0070;
3962 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); /* Headset output enable */
3963 /* ALC298 check jack type is the same with ALC286/ALC288 */
3966 alc_process_coef_fw(codec, coef0288);
3968 val = alc_read_coef_idx(codec, 0x50);
3969 is_ctia = (val & 0x0070) == 0x0070;
3972 alc_write_coef_idx(codec, 0x6b, 0xd429);
3974 val = alc_read_coef_idx(codec, 0x6c);
3975 is_ctia = (val & 0x001c) == 0x001c;
3978 alc_process_coef_fw(codec, coef0293);
3980 val = alc_read_coef_idx(codec, 0x46);
3981 is_ctia = (val & 0x0070) == 0x0070;
3984 alc_process_coef_fw(codec, coef0688);
3986 val = alc_read_coef_idx(codec, 0xbe);
3987 is_ctia = (val & 0x1c02) == 0x1c02;
3991 codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
3992 is_ctia ? "yes" : "no");
3993 spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
3996 static void alc_update_headset_mode(struct hda_codec *codec)
3998 struct alc_spec *spec = codec->spec;
4000 hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
4001 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
4003 int new_headset_mode;
4005 if (!snd_hda_jack_detect(codec, hp_pin))
4006 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
4007 else if (mux_pin == spec->headset_mic_pin)
4008 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
4009 else if (mux_pin == spec->headphone_mic_pin)
4010 new_headset_mode = ALC_HEADSET_MODE_MIC;
4012 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
4014 if (new_headset_mode == spec->current_headset_mode) {
4015 snd_hda_gen_update_outputs(codec);
4019 switch (new_headset_mode) {
4020 case ALC_HEADSET_MODE_UNPLUGGED:
4021 alc_headset_mode_unplugged(codec);
4022 spec->gen.hp_jack_present = false;
4024 case ALC_HEADSET_MODE_HEADSET:
4025 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
4026 alc_determine_headset_type(codec);
4027 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
4028 alc_headset_mode_ctia(codec);
4029 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
4030 alc_headset_mode_omtp(codec);
4031 spec->gen.hp_jack_present = true;
4033 case ALC_HEADSET_MODE_MIC:
4034 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
4035 spec->gen.hp_jack_present = false;
4037 case ALC_HEADSET_MODE_HEADPHONE:
4038 alc_headset_mode_default(codec);
4039 spec->gen.hp_jack_present = true;
4042 if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
4043 snd_hda_set_pin_ctl_cache(codec, hp_pin,
4044 AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
4045 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
4046 snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
4049 spec->current_headset_mode = new_headset_mode;
4051 snd_hda_gen_update_outputs(codec);
4054 static void alc_update_headset_mode_hook(struct hda_codec *codec,
4055 struct snd_kcontrol *kcontrol,
4056 struct snd_ctl_elem_value *ucontrol)
4058 alc_update_headset_mode(codec);
4061 static void alc_update_headset_jack_cb(struct hda_codec *codec,
4062 struct hda_jack_callback *jack)
4064 struct alc_spec *spec = codec->spec;
4065 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
4066 snd_hda_gen_hp_automute(codec, jack);
4069 static void alc_probe_headset_mode(struct hda_codec *codec)
4072 struct alc_spec *spec = codec->spec;
4073 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
4076 for (i = 0; i < cfg->num_inputs; i++) {
4077 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
4078 spec->headset_mic_pin = cfg->inputs[i].pin;
4079 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
4080 spec->headphone_mic_pin = cfg->inputs[i].pin;
4083 spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
4084 spec->gen.automute_hook = alc_update_headset_mode;
4085 spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
4088 static void alc_fixup_headset_mode(struct hda_codec *codec,
4089 const struct hda_fixup *fix, int action)
4091 struct alc_spec *spec = codec->spec;
4094 case HDA_FIXUP_ACT_PRE_PROBE:
4095 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
4097 case HDA_FIXUP_ACT_PROBE:
4098 alc_probe_headset_mode(codec);
4100 case HDA_FIXUP_ACT_INIT:
4101 spec->current_headset_mode = 0;
4102 alc_update_headset_mode(codec);
4107 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
4108 const struct hda_fixup *fix, int action)
4110 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4111 struct alc_spec *spec = codec->spec;
4112 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4115 alc_fixup_headset_mode(codec, fix, action);
4118 static void alc255_set_default_jack_type(struct hda_codec *codec)
4120 /* Set to iphone type */
4121 static struct coef_fw fw[] = {
4122 WRITE_COEF(0x1b, 0x880b),
4123 WRITE_COEF(0x45, 0xd089),
4124 WRITE_COEF(0x1b, 0x080b),
4125 WRITE_COEF(0x46, 0x0004),
4126 WRITE_COEF(0x1b, 0x0c0b),
4129 alc_process_coef_fw(codec, fw);
4133 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
4134 const struct hda_fixup *fix, int action)
4136 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4137 alc255_set_default_jack_type(codec);
4139 alc_fixup_headset_mode(codec, fix, action);
4142 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
4143 const struct hda_fixup *fix, int action)
4145 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4146 struct alc_spec *spec = codec->spec;
4147 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4148 alc255_set_default_jack_type(codec);
4151 alc_fixup_headset_mode(codec, fix, action);
4154 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
4155 struct hda_jack_callback *jack)
4157 struct alc_spec *spec = codec->spec;
4160 alc_update_headset_jack_cb(codec, jack);
4161 /* Headset Mic enable or disable, only for Dell Dino */
4162 present = spec->gen.hp_jack_present ? 0x40 : 0;
4163 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
4167 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
4168 const struct hda_fixup *fix, int action)
4170 alc_fixup_headset_mode(codec, fix, action);
4171 if (action == HDA_FIXUP_ACT_PROBE) {
4172 struct alc_spec *spec = codec->spec;
4173 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
4177 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
4178 const struct hda_fixup *fix, int action)
4180 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4181 struct alc_spec *spec = codec->spec;
4182 spec->gen.auto_mute_via_amp = 1;
4186 static void alc_no_shutup(struct hda_codec *codec)
4190 static void alc_fixup_no_shutup(struct hda_codec *codec,
4191 const struct hda_fixup *fix, int action)
4193 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4194 struct alc_spec *spec = codec->spec;
4195 spec->shutup = alc_no_shutup;
4199 static void alc_fixup_disable_aamix(struct hda_codec *codec,
4200 const struct hda_fixup *fix, int action)
4202 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4203 struct alc_spec *spec = codec->spec;
4204 /* Disable AA-loopback as it causes white noise */
4205 spec->gen.mixer_nid = 0;
4209 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
4210 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
4211 const struct hda_fixup *fix, int action)
4213 static const struct hda_pintbl pincfgs[] = {
4214 { 0x16, 0x21211010 }, /* dock headphone */
4215 { 0x19, 0x21a11010 }, /* dock mic */
4218 struct alc_spec *spec = codec->spec;
4220 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4221 spec->shutup = alc_no_shutup; /* reduce click noise */
4222 spec->reboot_notify = alc_d3_at_reboot; /* reduce noise */
4223 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4224 codec->power_save_node = 0; /* avoid click noises */
4225 snd_hda_apply_pincfgs(codec, pincfgs);
4229 static void alc_shutup_dell_xps13(struct hda_codec *codec)
4231 struct alc_spec *spec = codec->spec;
4232 int hp_pin = spec->gen.autocfg.hp_pins[0];
4234 /* Prevent pop noises when headphones are plugged in */
4235 snd_hda_codec_write(codec, hp_pin, 0,
4236 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
4240 static void alc_fixup_dell_xps13(struct hda_codec *codec,
4241 const struct hda_fixup *fix, int action)
4243 struct alc_spec *spec = codec->spec;
4244 struct hda_input_mux *imux = &spec->gen.input_mux;
4248 case HDA_FIXUP_ACT_PRE_PROBE:
4249 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
4250 * it causes a click noise at start up
4252 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
4254 case HDA_FIXUP_ACT_PROBE:
4255 spec->shutup = alc_shutup_dell_xps13;
4257 /* Make the internal mic the default input source. */
4258 for (i = 0; i < imux->num_items; i++) {
4259 if (spec->gen.imux_pins[i] == 0x12) {
4260 spec->gen.cur_mux[0] = i;
4268 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
4269 const struct hda_fixup *fix, int action)
4271 struct alc_spec *spec = codec->spec;
4273 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4274 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4275 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
4277 /* Disable boost for mic-in permanently. (This code is only called
4278 from quirks that guarantee that the headphone is at NID 0x1b.) */
4279 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
4280 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
4282 alc_fixup_headset_mode(codec, fix, action);
4285 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
4286 const struct hda_fixup *fix, int action)
4288 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4289 alc_write_coef_idx(codec, 0xc4, 0x8000);
4290 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
4291 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
4293 alc_fixup_headset_mode(codec, fix, action);
4296 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
4297 static int find_ext_mic_pin(struct hda_codec *codec)
4299 struct alc_spec *spec = codec->spec;
4300 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
4302 unsigned int defcfg;
4305 for (i = 0; i < cfg->num_inputs; i++) {
4306 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4308 nid = cfg->inputs[i].pin;
4309 defcfg = snd_hda_codec_get_pincfg(codec, nid);
4310 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
4318 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
4319 const struct hda_fixup *fix,
4322 struct alc_spec *spec = codec->spec;
4324 if (action == HDA_FIXUP_ACT_PROBE) {
4325 int mic_pin = find_ext_mic_pin(codec);
4326 int hp_pin = spec->gen.autocfg.hp_pins[0];
4328 if (snd_BUG_ON(!mic_pin || !hp_pin))
4330 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
4334 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
4335 const struct hda_fixup *fix,
4338 struct alc_spec *spec = codec->spec;
4339 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
4342 /* The mic boosts on level 2 and 3 are too noisy
4343 on the internal mic input.
4344 Therefore limit the boost to 0 or 1. */
4346 if (action != HDA_FIXUP_ACT_PROBE)
4349 for (i = 0; i < cfg->num_inputs; i++) {
4350 hda_nid_t nid = cfg->inputs[i].pin;
4351 unsigned int defcfg;
4352 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4354 defcfg = snd_hda_codec_get_pincfg(codec, nid);
4355 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
4358 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
4359 (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
4360 (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4361 (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
4362 (0 << AC_AMPCAP_MUTE_SHIFT));
4366 static void alc283_hp_automute_hook(struct hda_codec *codec,
4367 struct hda_jack_callback *jack)
4369 struct alc_spec *spec = codec->spec;
4373 snd_hda_gen_hp_automute(codec, jack);
4375 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4378 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4382 static void alc283_fixup_chromebook(struct hda_codec *codec,
4383 const struct hda_fixup *fix, int action)
4385 struct alc_spec *spec = codec->spec;
4388 case HDA_FIXUP_ACT_PRE_PROBE:
4389 snd_hda_override_wcaps(codec, 0x03, 0);
4390 /* Disable AA-loopback as it causes white noise */
4391 spec->gen.mixer_nid = 0;
4393 case HDA_FIXUP_ACT_INIT:
4394 /* MIC2-VREF control */
4395 /* Set to manual mode */
4396 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
4397 /* Enable Line1 input control by verb */
4398 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
4403 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
4404 const struct hda_fixup *fix, int action)
4406 struct alc_spec *spec = codec->spec;
4409 case HDA_FIXUP_ACT_PRE_PROBE:
4410 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
4412 case HDA_FIXUP_ACT_INIT:
4413 /* MIC2-VREF control */
4414 /* Set to manual mode */
4415 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
4420 /* mute tablet speaker pin (0x14) via dock plugging in addition */
4421 static void asus_tx300_automute(struct hda_codec *codec)
4423 struct alc_spec *spec = codec->spec;
4424 snd_hda_gen_update_outputs(codec);
4425 if (snd_hda_jack_detect(codec, 0x1b))
4426 spec->gen.mute_bits |= (1ULL << 0x14);
4429 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
4430 const struct hda_fixup *fix, int action)
4432 struct alc_spec *spec = codec->spec;
4433 /* TX300 needs to set up GPIO2 for the speaker amp */
4434 static const struct hda_verb gpio2_verbs[] = {
4435 { 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },
4436 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },
4437 { 0x01, AC_VERB_SET_GPIO_DATA, 0x04 },
4440 static const struct hda_pintbl dock_pins[] = {
4441 { 0x1b, 0x21114000 }, /* dock speaker pin */
4444 struct snd_kcontrol *kctl;
4447 case HDA_FIXUP_ACT_PRE_PROBE:
4448 snd_hda_add_verbs(codec, gpio2_verbs);
4449 snd_hda_apply_pincfgs(codec, dock_pins);
4450 spec->gen.auto_mute_via_amp = 1;
4451 spec->gen.automute_hook = asus_tx300_automute;
4452 snd_hda_jack_detect_enable_callback(codec, 0x1b,
4453 snd_hda_gen_hp_automute);
4455 case HDA_FIXUP_ACT_BUILD:
4456 /* this is a bit tricky; give more sane names for the main
4457 * (tablet) speaker and the dock speaker, respectively
4459 kctl = snd_hda_find_mixer_ctl(codec, "Speaker Playback Switch");
4461 strcpy(kctl->id.name, "Dock Speaker Playback Switch");
4462 kctl = snd_hda_find_mixer_ctl(codec, "Bass Speaker Playback Switch");
4464 strcpy(kctl->id.name, "Speaker Playback Switch");
4469 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
4470 const struct hda_fixup *fix, int action)
4472 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4473 /* DAC node 0x03 is giving mono output. We therefore want to
4474 make sure 0x14 (front speaker) and 0x15 (headphones) use the
4475 stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
4476 hda_nid_t conn1[2] = { 0x0c };
4477 snd_hda_override_conn_list(codec, 0x14, 1, conn1);
4478 snd_hda_override_conn_list(codec, 0x15, 1, conn1);
4482 /* Hook to update amp GPIO4 for automute */
4483 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
4484 struct hda_jack_callback *jack)
4486 struct alc_spec *spec = codec->spec;
4488 snd_hda_gen_hp_automute(codec, jack);
4489 /* mute_led_polarity is set to 0, so we pass inverted value here */
4490 alc_update_gpio_led(codec, 0x10, !spec->gen.hp_jack_present);
4493 /* Manage GPIOs for HP EliteBook Folio 9480m.
4495 * GPIO4 is the headphone amplifier power control
4496 * GPIO3 is the audio output mute indicator LED
4499 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
4500 const struct hda_fixup *fix,
4503 struct alc_spec *spec = codec->spec;
4504 static const struct hda_verb gpio_init[] = {
4505 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
4506 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
4510 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4511 /* Set the hooks to turn the headphone amp on/off
4514 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
4515 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
4517 /* The GPIOs are currently off */
4520 /* GPIO3 is connected to the output mute LED,
4521 * high is on, low is off
4523 spec->mute_led_polarity = 0;
4524 spec->gpio_mute_led_mask = 0x08;
4526 /* Initialize GPIO configuration */
4527 snd_hda_add_verbs(codec, gpio_init);
4531 /* for hda_fixup_thinkpad_acpi() */
4532 #include "thinkpad_helper.c"
4534 /* for dell wmi mic mute led */
4535 #include "dell_wmi_helper.c"
4538 ALC269_FIXUP_SONY_VAIO,
4539 ALC275_FIXUP_SONY_VAIO_GPIO2,
4540 ALC269_FIXUP_DELL_M101Z,
4541 ALC269_FIXUP_SKU_IGNORE,
4542 ALC269_FIXUP_ASUS_G73JW,
4543 ALC269_FIXUP_LENOVO_EAPD,
4544 ALC275_FIXUP_SONY_HWEQ,
4545 ALC275_FIXUP_SONY_DISABLE_AAMIX,
4547 ALC269_FIXUP_PCM_44K,
4548 ALC269_FIXUP_STEREO_DMIC,
4549 ALC269_FIXUP_HEADSET_MIC,
4550 ALC269_FIXUP_QUANTA_MUTE,
4551 ALC269_FIXUP_LIFEBOOK,
4552 ALC269_FIXUP_LIFEBOOK_EXTMIC,
4553 ALC269_FIXUP_LIFEBOOK_HP_PIN,
4554 ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
4557 ALC269VB_FIXUP_AMIC,
4558 ALC269VB_FIXUP_DMIC,
4559 ALC269_FIXUP_HP_MUTE_LED,
4560 ALC269_FIXUP_HP_MUTE_LED_MIC1,
4561 ALC269_FIXUP_HP_MUTE_LED_MIC2,
4562 ALC269_FIXUP_HP_GPIO_LED,
4563 ALC269_FIXUP_HP_GPIO_MIC1_LED,
4564 ALC269_FIXUP_HP_LINE1_MIC1_LED,
4565 ALC269_FIXUP_INV_DMIC,
4566 ALC269_FIXUP_LENOVO_DOCK,
4567 ALC269_FIXUP_NO_SHUTUP,
4568 ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
4569 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
4570 ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
4571 ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
4572 ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
4573 ALC269_FIXUP_HEADSET_MODE,
4574 ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
4575 ALC269_FIXUP_ASPIRE_HEADSET_MIC,
4576 ALC269_FIXUP_ASUS_X101_FUNC,
4577 ALC269_FIXUP_ASUS_X101_VERB,
4578 ALC269_FIXUP_ASUS_X101,
4579 ALC271_FIXUP_AMIC_MIC2,
4580 ALC271_FIXUP_HP_GATE_MIC_JACK,
4581 ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
4582 ALC269_FIXUP_ACER_AC700,
4583 ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
4584 ALC269VB_FIXUP_ASUS_ZENBOOK,
4585 ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
4586 ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
4587 ALC269VB_FIXUP_ORDISSIMO_EVE2,
4588 ALC283_FIXUP_CHROME_BOOK,
4589 ALC283_FIXUP_SENSE_COMBO_JACK,
4590 ALC282_FIXUP_ASUS_TX300,
4591 ALC283_FIXUP_INT_MIC,
4592 ALC290_FIXUP_MONO_SPEAKERS,
4593 ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
4594 ALC290_FIXUP_SUBWOOFER,
4595 ALC290_FIXUP_SUBWOOFER_HSJACK,
4596 ALC269_FIXUP_THINKPAD_ACPI,
4597 ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
4598 ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
4599 ALC255_FIXUP_HEADSET_MODE,
4600 ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
4601 ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
4602 ALC292_FIXUP_TPT440_DOCK,
4603 ALC292_FIXUP_TPT440,
4604 ALC283_FIXUP_BXBT2807_MIC,
4605 ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED,
4606 ALC282_FIXUP_ASPIRE_V5_PINS,
4607 ALC280_FIXUP_HP_GPIO4,
4608 ALC286_FIXUP_HP_GPIO_LED,
4609 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
4610 ALC280_FIXUP_HP_DOCK_PINS,
4611 ALC280_FIXUP_HP_9480M,
4612 ALC288_FIXUP_DELL_HEADSET_MODE,
4613 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
4614 ALC288_FIXUP_DELL_XPS_13_GPIO6,
4615 ALC288_FIXUP_DELL_XPS_13,
4616 ALC288_FIXUP_DISABLE_AAMIX,
4617 ALC292_FIXUP_DELL_E7X,
4618 ALC292_FIXUP_DISABLE_AAMIX,
4619 ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
4620 ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
4621 ALC275_FIXUP_DELL_XPS,
4622 ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE,
4623 ALC293_FIXUP_LENOVO_SPK_NOISE,
4626 static const struct hda_fixup alc269_fixups[] = {
4627 [ALC269_FIXUP_SONY_VAIO] = {
4628 .type = HDA_FIXUP_PINCTLS,
4629 .v.pins = (const struct hda_pintbl[]) {
4630 {0x19, PIN_VREFGRD},
4634 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
4635 .type = HDA_FIXUP_VERBS,
4636 .v.verbs = (const struct hda_verb[]) {
4637 {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
4638 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
4639 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4643 .chain_id = ALC269_FIXUP_SONY_VAIO
4645 [ALC269_FIXUP_DELL_M101Z] = {
4646 .type = HDA_FIXUP_VERBS,
4647 .v.verbs = (const struct hda_verb[]) {
4648 /* Enables internal speaker */
4649 {0x20, AC_VERB_SET_COEF_INDEX, 13},
4650 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
4654 [ALC269_FIXUP_SKU_IGNORE] = {
4655 .type = HDA_FIXUP_FUNC,
4656 .v.func = alc_fixup_sku_ignore,
4658 [ALC269_FIXUP_ASUS_G73JW] = {
4659 .type = HDA_FIXUP_PINS,
4660 .v.pins = (const struct hda_pintbl[]) {
4661 { 0x17, 0x99130111 }, /* subwoofer */
4665 [ALC269_FIXUP_LENOVO_EAPD] = {
4666 .type = HDA_FIXUP_VERBS,
4667 .v.verbs = (const struct hda_verb[]) {
4668 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
4672 [ALC275_FIXUP_SONY_HWEQ] = {
4673 .type = HDA_FIXUP_FUNC,
4674 .v.func = alc269_fixup_hweq,
4676 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
4678 [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
4679 .type = HDA_FIXUP_FUNC,
4680 .v.func = alc_fixup_disable_aamix,
4682 .chain_id = ALC269_FIXUP_SONY_VAIO
4684 [ALC271_FIXUP_DMIC] = {
4685 .type = HDA_FIXUP_FUNC,
4686 .v.func = alc271_fixup_dmic,
4688 [ALC269_FIXUP_PCM_44K] = {
4689 .type = HDA_FIXUP_FUNC,
4690 .v.func = alc269_fixup_pcm_44k,
4692 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4694 [ALC269_FIXUP_STEREO_DMIC] = {
4695 .type = HDA_FIXUP_FUNC,
4696 .v.func = alc269_fixup_stereo_dmic,
4698 [ALC269_FIXUP_HEADSET_MIC] = {
4699 .type = HDA_FIXUP_FUNC,
4700 .v.func = alc269_fixup_headset_mic,
4702 [ALC269_FIXUP_QUANTA_MUTE] = {
4703 .type = HDA_FIXUP_FUNC,
4704 .v.func = alc269_fixup_quanta_mute,
4706 [ALC269_FIXUP_LIFEBOOK] = {
4707 .type = HDA_FIXUP_PINS,
4708 .v.pins = (const struct hda_pintbl[]) {
4709 { 0x1a, 0x2101103f }, /* dock line-out */
4710 { 0x1b, 0x23a11040 }, /* dock mic-in */
4714 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4716 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
4717 .type = HDA_FIXUP_PINS,
4718 .v.pins = (const struct hda_pintbl[]) {
4719 { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
4723 [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
4724 .type = HDA_FIXUP_PINS,
4725 .v.pins = (const struct hda_pintbl[]) {
4726 { 0x21, 0x0221102f }, /* HP out */
4730 [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
4731 .type = HDA_FIXUP_FUNC,
4732 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
4734 [ALC269_FIXUP_AMIC] = {
4735 .type = HDA_FIXUP_PINS,
4736 .v.pins = (const struct hda_pintbl[]) {
4737 { 0x14, 0x99130110 }, /* speaker */
4738 { 0x15, 0x0121401f }, /* HP out */
4739 { 0x18, 0x01a19c20 }, /* mic */
4740 { 0x19, 0x99a3092f }, /* int-mic */
4744 [ALC269_FIXUP_DMIC] = {
4745 .type = HDA_FIXUP_PINS,
4746 .v.pins = (const struct hda_pintbl[]) {
4747 { 0x12, 0x99a3092f }, /* int-mic */
4748 { 0x14, 0x99130110 }, /* speaker */
4749 { 0x15, 0x0121401f }, /* HP out */
4750 { 0x18, 0x01a19c20 }, /* mic */
4754 [ALC269VB_FIXUP_AMIC] = {
4755 .type = HDA_FIXUP_PINS,
4756 .v.pins = (const struct hda_pintbl[]) {
4757 { 0x14, 0x99130110 }, /* speaker */
4758 { 0x18, 0x01a19c20 }, /* mic */
4759 { 0x19, 0x99a3092f }, /* int-mic */
4760 { 0x21, 0x0121401f }, /* HP out */
4764 [ALC269VB_FIXUP_DMIC] = {
4765 .type = HDA_FIXUP_PINS,
4766 .v.pins = (const struct hda_pintbl[]) {
4767 { 0x12, 0x99a3092f }, /* int-mic */
4768 { 0x14, 0x99130110 }, /* speaker */
4769 { 0x18, 0x01a19c20 }, /* mic */
4770 { 0x21, 0x0121401f }, /* HP out */
4774 [ALC269_FIXUP_HP_MUTE_LED] = {
4775 .type = HDA_FIXUP_FUNC,
4776 .v.func = alc269_fixup_hp_mute_led,
4778 [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
4779 .type = HDA_FIXUP_FUNC,
4780 .v.func = alc269_fixup_hp_mute_led_mic1,
4782 [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
4783 .type = HDA_FIXUP_FUNC,
4784 .v.func = alc269_fixup_hp_mute_led_mic2,
4786 [ALC269_FIXUP_HP_GPIO_LED] = {
4787 .type = HDA_FIXUP_FUNC,
4788 .v.func = alc269_fixup_hp_gpio_led,
4790 [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
4791 .type = HDA_FIXUP_FUNC,
4792 .v.func = alc269_fixup_hp_gpio_mic1_led,
4794 [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
4795 .type = HDA_FIXUP_FUNC,
4796 .v.func = alc269_fixup_hp_line1_mic1_led,
4798 [ALC269_FIXUP_INV_DMIC] = {
4799 .type = HDA_FIXUP_FUNC,
4800 .v.func = alc_fixup_inv_dmic,
4802 [ALC269_FIXUP_NO_SHUTUP] = {
4803 .type = HDA_FIXUP_FUNC,
4804 .v.func = alc_fixup_no_shutup,
4806 [ALC269_FIXUP_LENOVO_DOCK] = {
4807 .type = HDA_FIXUP_PINS,
4808 .v.pins = (const struct hda_pintbl[]) {
4809 { 0x19, 0x23a11040 }, /* dock mic */
4810 { 0x1b, 0x2121103f }, /* dock headphone */
4814 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
4816 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
4817 .type = HDA_FIXUP_FUNC,
4818 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
4820 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
4822 [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
4823 .type = HDA_FIXUP_PINS,
4824 .v.pins = (const struct hda_pintbl[]) {
4825 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4826 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
4830 .chain_id = ALC269_FIXUP_HEADSET_MODE
4832 [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
4833 .type = HDA_FIXUP_PINS,
4834 .v.pins = (const struct hda_pintbl[]) {
4835 { 0x16, 0x21014020 }, /* dock line out */
4836 { 0x19, 0x21a19030 }, /* dock mic */
4837 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4841 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
4843 [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
4844 .type = HDA_FIXUP_PINS,
4845 .v.pins = (const struct hda_pintbl[]) {
4846 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4850 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
4852 [ALC269_FIXUP_HEADSET_MODE] = {
4853 .type = HDA_FIXUP_FUNC,
4854 .v.func = alc_fixup_headset_mode,
4856 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
4858 [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
4859 .type = HDA_FIXUP_FUNC,
4860 .v.func = alc_fixup_headset_mode_no_hp_mic,
4862 [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
4863 .type = HDA_FIXUP_PINS,
4864 .v.pins = (const struct hda_pintbl[]) {
4865 { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
4869 .chain_id = ALC269_FIXUP_HEADSET_MODE,
4871 [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
4872 .type = HDA_FIXUP_PINS,
4873 .v.pins = (const struct hda_pintbl[]) {
4874 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4878 .chain_id = ALC269_FIXUP_HEADSET_MIC
4880 [ALC269_FIXUP_ASUS_X101_FUNC] = {
4881 .type = HDA_FIXUP_FUNC,
4882 .v.func = alc269_fixup_x101_headset_mic,
4884 [ALC269_FIXUP_ASUS_X101_VERB] = {
4885 .type = HDA_FIXUP_VERBS,
4886 .v.verbs = (const struct hda_verb[]) {
4887 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4888 {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
4889 {0x20, AC_VERB_SET_PROC_COEF, 0x0310},
4893 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
4895 [ALC269_FIXUP_ASUS_X101] = {
4896 .type = HDA_FIXUP_PINS,
4897 .v.pins = (const struct hda_pintbl[]) {
4898 { 0x18, 0x04a1182c }, /* Headset mic */
4902 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
4904 [ALC271_FIXUP_AMIC_MIC2] = {
4905 .type = HDA_FIXUP_PINS,
4906 .v.pins = (const struct hda_pintbl[]) {
4907 { 0x14, 0x99130110 }, /* speaker */
4908 { 0x19, 0x01a19c20 }, /* mic */
4909 { 0x1b, 0x99a7012f }, /* int-mic */
4910 { 0x21, 0x0121401f }, /* HP out */
4914 [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
4915 .type = HDA_FIXUP_FUNC,
4916 .v.func = alc271_hp_gate_mic_jack,
4918 .chain_id = ALC271_FIXUP_AMIC_MIC2,
4920 [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
4921 .type = HDA_FIXUP_FUNC,
4922 .v.func = alc269_fixup_limit_int_mic_boost,
4924 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
4926 [ALC269_FIXUP_ACER_AC700] = {
4927 .type = HDA_FIXUP_PINS,
4928 .v.pins = (const struct hda_pintbl[]) {
4929 { 0x12, 0x99a3092f }, /* int-mic */
4930 { 0x14, 0x99130110 }, /* speaker */
4931 { 0x18, 0x03a11c20 }, /* mic */
4932 { 0x1e, 0x0346101e }, /* SPDIF1 */
4933 { 0x21, 0x0321101f }, /* HP out */
4937 .chain_id = ALC271_FIXUP_DMIC,
4939 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
4940 .type = HDA_FIXUP_FUNC,
4941 .v.func = alc269_fixup_limit_int_mic_boost,
4943 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
4945 [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
4946 .type = HDA_FIXUP_FUNC,
4947 .v.func = alc269_fixup_limit_int_mic_boost,
4949 .chain_id = ALC269VB_FIXUP_DMIC,
4951 [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
4952 .type = HDA_FIXUP_VERBS,
4953 .v.verbs = (const struct hda_verb[]) {
4954 /* class-D output amp +5dB */
4955 { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
4956 { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
4960 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
4962 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
4963 .type = HDA_FIXUP_FUNC,
4964 .v.func = alc269_fixup_limit_int_mic_boost,
4966 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
4968 [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
4969 .type = HDA_FIXUP_PINS,
4970 .v.pins = (const struct hda_pintbl[]) {
4971 { 0x12, 0x99a3092f }, /* int-mic */
4972 { 0x18, 0x03a11d20 }, /* mic */
4973 { 0x19, 0x411111f0 }, /* Unused bogus pin */
4977 [ALC283_FIXUP_CHROME_BOOK] = {
4978 .type = HDA_FIXUP_FUNC,
4979 .v.func = alc283_fixup_chromebook,
4981 [ALC283_FIXUP_SENSE_COMBO_JACK] = {
4982 .type = HDA_FIXUP_FUNC,
4983 .v.func = alc283_fixup_sense_combo_jack,
4985 .chain_id = ALC283_FIXUP_CHROME_BOOK,
4987 [ALC282_FIXUP_ASUS_TX300] = {
4988 .type = HDA_FIXUP_FUNC,
4989 .v.func = alc282_fixup_asus_tx300,
4991 [ALC283_FIXUP_INT_MIC] = {
4992 .type = HDA_FIXUP_VERBS,
4993 .v.verbs = (const struct hda_verb[]) {
4994 {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
4995 {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
4999 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
5001 [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
5002 .type = HDA_FIXUP_PINS,
5003 .v.pins = (const struct hda_pintbl[]) {
5004 { 0x17, 0x90170112 }, /* subwoofer */
5008 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
5010 [ALC290_FIXUP_SUBWOOFER] = {
5011 .type = HDA_FIXUP_PINS,
5012 .v.pins = (const struct hda_pintbl[]) {
5013 { 0x17, 0x90170112 }, /* subwoofer */
5017 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
5019 [ALC290_FIXUP_MONO_SPEAKERS] = {
5020 .type = HDA_FIXUP_FUNC,
5021 .v.func = alc290_fixup_mono_speakers,
5023 [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
5024 .type = HDA_FIXUP_FUNC,
5025 .v.func = alc290_fixup_mono_speakers,
5027 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
5029 [ALC269_FIXUP_THINKPAD_ACPI] = {
5030 .type = HDA_FIXUP_FUNC,
5031 .v.func = hda_fixup_thinkpad_acpi,
5033 [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5034 .type = HDA_FIXUP_PINS,
5035 .v.pins = (const struct hda_pintbl[]) {
5036 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5037 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5041 .chain_id = ALC255_FIXUP_HEADSET_MODE
5043 [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
5044 .type = HDA_FIXUP_PINS,
5045 .v.pins = (const struct hda_pintbl[]) {
5046 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5050 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
5052 [ALC255_FIXUP_HEADSET_MODE] = {
5053 .type = HDA_FIXUP_FUNC,
5054 .v.func = alc_fixup_headset_mode_alc255,
5056 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
5058 [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
5059 .type = HDA_FIXUP_FUNC,
5060 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
5062 [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5063 .type = HDA_FIXUP_PINS,
5064 .v.pins = (const struct hda_pintbl[]) {
5065 { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5066 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5070 .chain_id = ALC269_FIXUP_HEADSET_MODE
5072 [ALC292_FIXUP_TPT440_DOCK] = {
5073 .type = HDA_FIXUP_FUNC,
5074 .v.func = alc_fixup_tpt440_dock,
5076 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
5078 [ALC292_FIXUP_TPT440] = {
5079 .type = HDA_FIXUP_FUNC,
5080 .v.func = alc_fixup_disable_aamix,
5082 .chain_id = ALC292_FIXUP_TPT440_DOCK,
5084 [ALC283_FIXUP_BXBT2807_MIC] = {
5085 .type = HDA_FIXUP_PINS,
5086 .v.pins = (const struct hda_pintbl[]) {
5087 { 0x19, 0x04a110f0 },
5091 [ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED] = {
5092 .type = HDA_FIXUP_FUNC,
5093 .v.func = alc_fixup_dell_wmi,
5095 [ALC282_FIXUP_ASPIRE_V5_PINS] = {
5096 .type = HDA_FIXUP_PINS,
5097 .v.pins = (const struct hda_pintbl[]) {
5098 { 0x12, 0x90a60130 },
5099 { 0x14, 0x90170110 },
5100 { 0x17, 0x40000008 },
5101 { 0x18, 0x411111f0 },
5102 { 0x19, 0x01a1913c },
5103 { 0x1a, 0x411111f0 },
5104 { 0x1b, 0x411111f0 },
5105 { 0x1d, 0x40f89b2d },
5106 { 0x1e, 0x411111f0 },
5107 { 0x21, 0x0321101f },
5111 [ALC280_FIXUP_HP_GPIO4] = {
5112 .type = HDA_FIXUP_FUNC,
5113 .v.func = alc280_fixup_hp_gpio4,
5115 [ALC286_FIXUP_HP_GPIO_LED] = {
5116 .type = HDA_FIXUP_FUNC,
5117 .v.func = alc286_fixup_hp_gpio_led,
5119 [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
5120 .type = HDA_FIXUP_FUNC,
5121 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
5123 [ALC280_FIXUP_HP_DOCK_PINS] = {
5124 .type = HDA_FIXUP_PINS,
5125 .v.pins = (const struct hda_pintbl[]) {
5126 { 0x1b, 0x21011020 }, /* line-out */
5127 { 0x1a, 0x01a1903c }, /* headset mic */
5128 { 0x18, 0x2181103f }, /* line-in */
5132 .chain_id = ALC280_FIXUP_HP_GPIO4
5134 [ALC280_FIXUP_HP_9480M] = {
5135 .type = HDA_FIXUP_FUNC,
5136 .v.func = alc280_fixup_hp_9480m,
5138 [ALC288_FIXUP_DELL_HEADSET_MODE] = {
5139 .type = HDA_FIXUP_FUNC,
5140 .v.func = alc_fixup_headset_mode_dell_alc288,
5142 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
5144 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5145 .type = HDA_FIXUP_PINS,
5146 .v.pins = (const struct hda_pintbl[]) {
5147 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5148 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5152 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
5154 [ALC288_FIXUP_DELL_XPS_13_GPIO6] = {
5155 .type = HDA_FIXUP_VERBS,
5156 .v.verbs = (const struct hda_verb[]) {
5157 {0x01, AC_VERB_SET_GPIO_MASK, 0x40},
5158 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x40},
5159 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5163 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
5165 [ALC288_FIXUP_DISABLE_AAMIX] = {
5166 .type = HDA_FIXUP_FUNC,
5167 .v.func = alc_fixup_disable_aamix,
5169 .chain_id = ALC288_FIXUP_DELL_XPS_13_GPIO6
5171 [ALC288_FIXUP_DELL_XPS_13] = {
5172 .type = HDA_FIXUP_FUNC,
5173 .v.func = alc_fixup_dell_xps13,
5175 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
5177 [ALC292_FIXUP_DISABLE_AAMIX] = {
5178 .type = HDA_FIXUP_FUNC,
5179 .v.func = alc_fixup_disable_aamix,
5181 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
5183 [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
5184 .type = HDA_FIXUP_FUNC,
5185 .v.func = alc_fixup_disable_aamix,
5187 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
5189 [ALC292_FIXUP_DELL_E7X] = {
5190 .type = HDA_FIXUP_FUNC,
5191 .v.func = alc_fixup_dell_xps13,
5193 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
5195 [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5196 .type = HDA_FIXUP_PINS,
5197 .v.pins = (const struct hda_pintbl[]) {
5198 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5199 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5203 .chain_id = ALC269_FIXUP_HEADSET_MODE
5205 [ALC275_FIXUP_DELL_XPS] = {
5206 .type = HDA_FIXUP_VERBS,
5207 .v.verbs = (const struct hda_verb[]) {
5208 /* Enables internal speaker */
5209 {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
5210 {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
5211 {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
5212 {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
5216 [ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE] = {
5217 .type = HDA_FIXUP_VERBS,
5218 .v.verbs = (const struct hda_verb[]) {
5219 /* Disable pass-through path for FRONT 14h */
5220 {0x20, AC_VERB_SET_COEF_INDEX, 0x36},
5221 {0x20, AC_VERB_SET_PROC_COEF, 0x1737},
5225 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
5227 [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
5228 .type = HDA_FIXUP_FUNC,
5229 .v.func = alc_fixup_disable_aamix,
5231 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
5235 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
5236 SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
5237 SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
5238 SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
5239 SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
5240 SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
5241 SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
5242 SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
5243 SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
5244 SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
5245 SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
5246 SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
5247 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
5248 SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
5249 SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
5250 SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
5251 SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
5252 SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
5253 SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
5254 SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
5255 SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
5256 SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
5257 SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
5258 SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
5259 SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
5260 SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5261 SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5262 SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
5263 SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
5264 SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
5265 SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5266 SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5267 SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5268 SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5269 SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5270 SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5271 SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5272 SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
5273 SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5274 SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5275 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
5276 SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
5277 SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
5278 SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
5280 SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5281 SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5282 SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5283 SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5284 SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5285 SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5286 SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5287 SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5288 SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5289 SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5290 SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5291 SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5292 SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
5293 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
5294 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
5295 SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5296 SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5297 SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5298 SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5299 SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5300 SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
5301 SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5302 SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5304 SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5305 SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5306 SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5307 SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5308 SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5309 SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5310 SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5311 SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5312 SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5313 SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5314 SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5315 SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5316 SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5317 SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5318 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5319 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5320 SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5321 SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5322 SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5323 SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5324 SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5325 SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5326 SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5327 SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5328 SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5329 SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5330 SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5331 SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5332 SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5333 SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
5334 SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5335 SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5336 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
5337 SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
5338 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
5339 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
5340 SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
5341 SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5342 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
5343 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
5344 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5345 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5346 SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
5347 SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
5348 SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
5349 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
5350 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5351 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5352 SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
5353 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
5354 SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
5355 SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
5356 SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
5357 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
5358 SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
5359 SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_BXBT2807_MIC),
5360 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
5361 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
5362 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
5363 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
5364 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
5365 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
5366 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
5367 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
5368 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
5369 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
5370 SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
5371 SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
5372 SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
5373 SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
5374 SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
5375 SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
5376 SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
5377 SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5378 SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
5379 SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
5380 SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
5381 SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
5382 SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
5383 SND_PCI_QUIRK(0x17aa, 0x3978, "IdeaPad Y410P", ALC269_FIXUP_NO_SHUTUP),
5384 SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5385 SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
5386 SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
5387 SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5388 SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
5389 SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
5390 SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
5391 SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
5392 SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5393 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
5394 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
5395 SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
5398 /* Below is a quirk table taken from the old code.
5399 * Basically the device should work as is without the fixup table.
5400 * If BIOS doesn't give a proper info, enable the corresponding
5403 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
5405 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
5406 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
5407 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
5408 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
5409 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
5410 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
5411 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
5412 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
5413 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
5414 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
5415 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
5416 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
5417 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
5418 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
5419 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
5420 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
5421 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
5422 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
5423 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
5424 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
5425 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
5426 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
5427 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
5428 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
5429 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
5430 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
5431 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
5432 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
5433 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
5434 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
5435 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
5436 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
5437 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
5438 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
5439 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
5440 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
5441 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
5442 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
5443 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
5448 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
5449 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
5450 SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
5451 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
5452 SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
5456 static const struct hda_model_fixup alc269_fixup_models[] = {
5457 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
5458 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
5459 {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
5460 {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
5461 {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
5462 {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
5463 {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
5464 {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
5465 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
5466 {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
5467 {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
5468 {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
5469 {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
5470 {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
5471 {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
5472 {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
5476 #define ALC256_STANDARD_PINS \
5477 {0x12, 0x90a60140}, \
5478 {0x14, 0x90170110}, \
5481 #define ALC282_STANDARD_PINS \
5484 #define ALC290_STANDARD_PINS \
5487 #define ALC292_STANDARD_PINS \
5488 {0x14, 0x90170110}, \
5491 #define ALC298_STANDARD_PINS \
5492 {0x12, 0x90a60130}, \
5495 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
5496 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
5498 {0x21, 0x02211020}),
5499 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5502 {0x21, 0x02211020}),
5503 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5506 {0x21, 0x02211030}),
5507 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5510 {0x21, 0x0221103f}),
5511 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5514 {0x21, 0x0221105f}),
5515 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5518 {0x21, 0x0221101f}),
5519 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5523 {0x21, 0x0321102f}),
5524 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5527 {0x21, 0x02211040}),
5528 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5531 {0x21, 0x02211050}),
5532 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5535 {0x21, 0x02211030}),
5536 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5539 {0x21, 0x02211040}),
5540 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5543 {0x21, 0x02211050}),
5544 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5547 {0x21, 0x02211040}),
5548 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5551 {0x21, 0x02211030}),
5552 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5553 ALC256_STANDARD_PINS),
5554 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
5558 {0x1a, 0x04a11020}),
5559 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
5565 {0x1b, 0x02011020}),
5566 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5567 ALC282_STANDARD_PINS,
5570 {0x21, 0x0321101f}),
5571 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5572 ALC282_STANDARD_PINS,
5575 {0x21, 0x03211040}),
5576 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5577 ALC282_STANDARD_PINS,
5580 {0x21, 0x03211020}),
5581 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5582 ALC282_STANDARD_PINS,
5585 {0x21, 0x0421101f}),
5586 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
5587 ALC282_STANDARD_PINS,
5590 {0x21, 0x04211020}),
5591 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5592 ALC282_STANDARD_PINS,
5594 {0x21, 0x0321101f}),
5595 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5598 {0x21, 0x02211030}),
5599 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5600 ALC282_STANDARD_PINS,
5603 {0x21, 0x0321101f}),
5604 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL_XPS_13_GPIO6,
5607 {0x21, 0x0321101f}),
5608 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5609 ALC290_STANDARD_PINS,
5612 {0x1a, 0x04a11020}),
5613 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5614 ALC290_STANDARD_PINS,
5617 {0x1a, 0x04a11020}),
5618 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5619 ALC290_STANDARD_PINS,
5621 {0x1a, 0x04a11020}),
5622 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5623 ALC290_STANDARD_PINS,
5625 {0x1a, 0x04a11040}),
5626 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5627 ALC290_STANDARD_PINS,
5630 {0x1a, 0x04a11040}),
5631 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5632 ALC290_STANDARD_PINS,
5635 {0x1a, 0x04a11020}),
5636 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5637 ALC290_STANDARD_PINS,
5640 {0x1a, 0x04a11020}),
5641 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
5642 ALC292_STANDARD_PINS,
5645 {0x19, 0x01a19030}),
5646 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
5647 ALC292_STANDARD_PINS,
5651 {0x19, 0x01a1903e}),
5652 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
5653 ALC292_STANDARD_PINS,
5654 {0x12, 0x90a60140}),
5655 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
5656 ALC292_STANDARD_PINS,
5659 {0x19, 0x21a19030}),
5660 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
5661 ALC292_STANDARD_PINS,
5662 {0x13, 0x90a60140}),
5663 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
5664 ALC298_STANDARD_PINS,
5665 {0x17, 0x90170110}),
5666 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
5667 ALC298_STANDARD_PINS,
5668 {0x17, 0x90170140}),
5669 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
5670 ALC298_STANDARD_PINS,
5671 {0x17, 0x90170150}),
5675 static void alc269_fill_coef(struct hda_codec *codec)
5677 struct alc_spec *spec = codec->spec;
5680 if (spec->codec_variant != ALC269_TYPE_ALC269VB)
5683 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
5684 alc_write_coef_idx(codec, 0xf, 0x960b);
5685 alc_write_coef_idx(codec, 0xe, 0x8817);
5688 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
5689 alc_write_coef_idx(codec, 0xf, 0x960b);
5690 alc_write_coef_idx(codec, 0xe, 0x8814);
5693 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
5694 /* Power up output pin */
5695 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
5698 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5699 val = alc_read_coef_idx(codec, 0xd);
5700 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
5701 /* Capless ramp up clock control */
5702 alc_write_coef_idx(codec, 0xd, val | (1<<10));
5704 val = alc_read_coef_idx(codec, 0x17);
5705 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
5706 /* Class D power on reset */
5707 alc_write_coef_idx(codec, 0x17, val | (1<<7));
5712 alc_update_coef_idx(codec, 0x4, 0, 1<<11);
5717 static int patch_alc269(struct hda_codec *codec)
5719 struct alc_spec *spec;
5722 err = alc_alloc_spec(codec, 0x0b);
5727 spec->gen.shared_mic_vref_pin = 0x18;
5728 codec->power_save_node = 1;
5731 codec->patch_ops.suspend = alc269_suspend;
5732 codec->patch_ops.resume = alc269_resume;
5734 spec->shutup = alc269_shutup;
5736 snd_hda_pick_fixup(codec, alc269_fixup_models,
5737 alc269_fixup_tbl, alc269_fixups);
5738 snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups);
5739 snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
5741 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
5743 alc_auto_parse_customize_define(codec);
5745 if (has_cdefine_beep(codec))
5746 spec->gen.beep_nid = 0x01;
5748 switch (codec->core.vendor_id) {
5750 spec->codec_variant = ALC269_TYPE_ALC269VA;
5751 switch (alc_get_coef0(codec) & 0x00f0) {
5753 if (codec->bus->pci &&
5754 codec->bus->pci->subsystem_vendor == 0x1025 &&
5755 spec->cdefine.platform_type == 1)
5756 err = alc_codec_rename(codec, "ALC271X");
5757 spec->codec_variant = ALC269_TYPE_ALC269VB;
5760 if (codec->bus->pci &&
5761 codec->bus->pci->subsystem_vendor == 0x17aa &&
5762 codec->bus->pci->subsystem_device == 0x21f3)
5763 err = alc_codec_rename(codec, "ALC3202");
5764 spec->codec_variant = ALC269_TYPE_ALC269VC;
5767 spec->codec_variant = ALC269_TYPE_ALC269VD;
5770 alc_fix_pll_init(codec, 0x20, 0x04, 15);
5774 spec->init_hook = alc269_fill_coef;
5775 alc269_fill_coef(codec);
5780 spec->codec_variant = ALC269_TYPE_ALC280;
5783 spec->codec_variant = ALC269_TYPE_ALC282;
5784 spec->shutup = alc282_shutup;
5785 spec->init_hook = alc282_init;
5789 spec->codec_variant = ALC269_TYPE_ALC283;
5790 spec->shutup = alc283_shutup;
5791 spec->init_hook = alc283_init;
5795 spec->codec_variant = ALC269_TYPE_ALC284;
5799 spec->codec_variant = ALC269_TYPE_ALC285;
5803 spec->codec_variant = ALC269_TYPE_ALC286;
5804 spec->shutup = alc286_shutup;
5807 spec->codec_variant = ALC269_TYPE_ALC298;
5810 spec->codec_variant = ALC269_TYPE_ALC255;
5813 spec->codec_variant = ALC269_TYPE_ALC256;
5814 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
5815 alc_update_coef_idx(codec, 0x36, 1 << 13, 1 << 5); /* Switch pcbeep path to Line in path*/
5819 if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
5820 spec->has_alc5505_dsp = 1;
5821 spec->init_hook = alc5505_dsp_init;
5824 /* automatic parse from the BIOS config */
5825 err = alc269_parse_auto_config(codec);
5829 if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid)
5830 set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
5832 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
5845 static int alc861_parse_auto_config(struct hda_codec *codec)
5847 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
5848 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
5849 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
5852 /* Pin config fixes */
5854 ALC861_FIXUP_FSC_AMILO_PI1505,
5855 ALC861_FIXUP_AMP_VREF_0F,
5856 ALC861_FIXUP_NO_JACK_DETECT,
5857 ALC861_FIXUP_ASUS_A6RP,
5858 ALC660_FIXUP_ASUS_W7J,
5861 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
5862 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
5863 const struct hda_fixup *fix, int action)
5865 struct alc_spec *spec = codec->spec;
5868 if (action != HDA_FIXUP_ACT_INIT)
5870 val = snd_hda_codec_get_pin_target(codec, 0x0f);
5871 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
5872 val |= AC_PINCTL_IN_EN;
5873 val |= AC_PINCTL_VREF_50;
5874 snd_hda_set_pin_ctl(codec, 0x0f, val);
5875 spec->gen.keep_vref_in_automute = 1;
5878 /* suppress the jack-detection */
5879 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
5880 const struct hda_fixup *fix, int action)
5882 if (action == HDA_FIXUP_ACT_PRE_PROBE)
5883 codec->no_jack_detect = 1;
5886 static const struct hda_fixup alc861_fixups[] = {
5887 [ALC861_FIXUP_FSC_AMILO_PI1505] = {
5888 .type = HDA_FIXUP_PINS,
5889 .v.pins = (const struct hda_pintbl[]) {
5890 { 0x0b, 0x0221101f }, /* HP */
5891 { 0x0f, 0x90170310 }, /* speaker */
5895 [ALC861_FIXUP_AMP_VREF_0F] = {
5896 .type = HDA_FIXUP_FUNC,
5897 .v.func = alc861_fixup_asus_amp_vref_0f,
5899 [ALC861_FIXUP_NO_JACK_DETECT] = {
5900 .type = HDA_FIXUP_FUNC,
5901 .v.func = alc_fixup_no_jack_detect,
5903 [ALC861_FIXUP_ASUS_A6RP] = {
5904 .type = HDA_FIXUP_FUNC,
5905 .v.func = alc861_fixup_asus_amp_vref_0f,
5907 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
5909 [ALC660_FIXUP_ASUS_W7J] = {
5910 .type = HDA_FIXUP_VERBS,
5911 .v.verbs = (const struct hda_verb[]) {
5912 /* ASUS W7J needs a magic pin setup on unused NID 0x10
5913 * for enabling outputs
5915 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5921 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
5922 SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
5923 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
5924 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
5925 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
5926 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
5927 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
5928 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
5929 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
5935 static int patch_alc861(struct hda_codec *codec)
5937 struct alc_spec *spec;
5940 err = alc_alloc_spec(codec, 0x15);
5945 spec->gen.beep_nid = 0x23;
5948 spec->power_hook = alc_power_eapd;
5951 snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
5952 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
5954 /* automatic parse from the BIOS config */
5955 err = alc861_parse_auto_config(codec);
5959 if (!spec->gen.no_analog)
5960 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
5962 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
5976 * In addition, an independent DAC
5978 static int alc861vd_parse_auto_config(struct hda_codec *codec)
5980 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
5981 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5982 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
5986 ALC660VD_FIX_ASUS_GPIO1,
5987 ALC861VD_FIX_DALLAS,
5990 /* exclude VREF80 */
5991 static void alc861vd_fixup_dallas(struct hda_codec *codec,
5992 const struct hda_fixup *fix, int action)
5994 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5995 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
5996 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
6000 static const struct hda_fixup alc861vd_fixups[] = {
6001 [ALC660VD_FIX_ASUS_GPIO1] = {
6002 .type = HDA_FIXUP_VERBS,
6003 .v.verbs = (const struct hda_verb[]) {
6005 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6006 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6007 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6011 [ALC861VD_FIX_DALLAS] = {
6012 .type = HDA_FIXUP_FUNC,
6013 .v.func = alc861vd_fixup_dallas,
6017 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
6018 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
6019 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
6020 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
6026 static int patch_alc861vd(struct hda_codec *codec)
6028 struct alc_spec *spec;
6031 err = alc_alloc_spec(codec, 0x0b);
6036 spec->gen.beep_nid = 0x23;
6038 spec->shutup = alc_eapd_shutup;
6040 snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
6041 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
6043 /* automatic parse from the BIOS config */
6044 err = alc861vd_parse_auto_config(codec);
6048 if (!spec->gen.no_analog)
6049 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6051 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
6063 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
6064 * configuration. Each pin widget can choose any input DACs and a mixer.
6065 * Each ADC is connected from a mixer of all inputs. This makes possible
6066 * 6-channel independent captures.
6068 * In addition, an independent DAC for the multi-playback (not used in this
6073 * BIOS auto configuration
6076 static int alc662_parse_auto_config(struct hda_codec *codec)
6078 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
6079 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
6080 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
6081 const hda_nid_t *ssids;
6083 if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
6084 codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
6085 codec->core.vendor_id == 0x10ec0671)
6086 ssids = alc663_ssids;
6088 ssids = alc662_ssids;
6089 return alc_parse_auto_config(codec, alc662_ignore, ssids);
6092 static void alc272_fixup_mario(struct hda_codec *codec,
6093 const struct hda_fixup *fix, int action)
6095 if (action != HDA_FIXUP_ACT_PRE_PROBE)
6097 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
6098 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
6099 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
6100 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
6101 (0 << AC_AMPCAP_MUTE_SHIFT)))
6102 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
6105 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
6107 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
6109 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
6110 SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
6114 /* override the 2.1 chmap */
6115 static void alc_fixup_bass_chmap(struct hda_codec *codec,
6116 const struct hda_fixup *fix, int action)
6118 if (action == HDA_FIXUP_ACT_BUILD) {
6119 struct alc_spec *spec = codec->spec;
6120 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
6124 /* avoid D3 for keeping GPIO up */
6125 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
6127 unsigned int power_state)
6129 struct alc_spec *spec = codec->spec;
6130 if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_led)
6135 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
6136 const struct hda_fixup *fix, int action)
6138 struct alc_spec *spec = codec->spec;
6139 static const struct hda_verb gpio_init[] = {
6140 { 0x01, AC_VERB_SET_GPIO_MASK, 0x01 },
6141 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01 },
6145 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6146 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
6148 spec->mute_led_polarity = 1;
6149 spec->gpio_mute_led_mask = 0x01;
6150 snd_hda_add_verbs(codec, gpio_init);
6151 codec->power_filter = gpio_led_power_filter;
6155 static struct coef_fw alc668_coefs[] = {
6156 WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0),
6157 WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80),
6158 WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0),
6159 WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
6160 WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
6161 WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
6162 WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0),
6163 WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418),
6164 WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
6165 WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
6166 WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
6167 WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
6168 WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0),
6169 WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
6170 WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0),
6171 WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040),
6172 WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
6173 WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
6174 WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
6175 WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
6179 static void alc668_restore_default_value(struct hda_codec *codec)
6181 alc_process_coef_fw(codec, alc668_coefs);
6185 ALC662_FIXUP_ASPIRE,
6186 ALC662_FIXUP_LED_GPIO1,
6187 ALC662_FIXUP_IDEAPAD,
6189 ALC662_FIXUP_CZC_P10T,
6190 ALC662_FIXUP_SKU_IGNORE,
6191 ALC662_FIXUP_HP_RP5800,
6192 ALC662_FIXUP_ASUS_MODE1,
6193 ALC662_FIXUP_ASUS_MODE2,
6194 ALC662_FIXUP_ASUS_MODE3,
6195 ALC662_FIXUP_ASUS_MODE4,
6196 ALC662_FIXUP_ASUS_MODE5,
6197 ALC662_FIXUP_ASUS_MODE6,
6198 ALC662_FIXUP_ASUS_MODE7,
6199 ALC662_FIXUP_ASUS_MODE8,
6200 ALC662_FIXUP_NO_JACK_DETECT,
6201 ALC662_FIXUP_ZOTAC_Z68,
6202 ALC662_FIXUP_INV_DMIC,
6203 ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
6204 ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
6205 ALC662_FIXUP_HEADSET_MODE,
6206 ALC668_FIXUP_HEADSET_MODE,
6207 ALC662_FIXUP_BASS_MODE4_CHMAP,
6208 ALC662_FIXUP_BASS_16,
6209 ALC662_FIXUP_BASS_1A,
6210 ALC662_FIXUP_BASS_CHMAP,
6211 ALC668_FIXUP_AUTO_MUTE,
6212 ALC668_FIXUP_DELL_DISABLE_AAMIX,
6213 ALC668_FIXUP_DELL_XPS13,
6216 static const struct hda_fixup alc662_fixups[] = {
6217 [ALC662_FIXUP_ASPIRE] = {
6218 .type = HDA_FIXUP_PINS,
6219 .v.pins = (const struct hda_pintbl[]) {
6220 { 0x15, 0x99130112 }, /* subwoofer */
6224 [ALC662_FIXUP_LED_GPIO1] = {
6225 .type = HDA_FIXUP_FUNC,
6226 .v.func = alc662_fixup_led_gpio1,
6228 [ALC662_FIXUP_IDEAPAD] = {
6229 .type = HDA_FIXUP_PINS,
6230 .v.pins = (const struct hda_pintbl[]) {
6231 { 0x17, 0x99130112 }, /* subwoofer */
6235 .chain_id = ALC662_FIXUP_LED_GPIO1,
6237 [ALC272_FIXUP_MARIO] = {
6238 .type = HDA_FIXUP_FUNC,
6239 .v.func = alc272_fixup_mario,
6241 [ALC662_FIXUP_CZC_P10T] = {
6242 .type = HDA_FIXUP_VERBS,
6243 .v.verbs = (const struct hda_verb[]) {
6244 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
6248 [ALC662_FIXUP_SKU_IGNORE] = {
6249 .type = HDA_FIXUP_FUNC,
6250 .v.func = alc_fixup_sku_ignore,
6252 [ALC662_FIXUP_HP_RP5800] = {
6253 .type = HDA_FIXUP_PINS,
6254 .v.pins = (const struct hda_pintbl[]) {
6255 { 0x14, 0x0221201f }, /* HP out */
6259 .chain_id = ALC662_FIXUP_SKU_IGNORE
6261 [ALC662_FIXUP_ASUS_MODE1] = {
6262 .type = HDA_FIXUP_PINS,
6263 .v.pins = (const struct hda_pintbl[]) {
6264 { 0x14, 0x99130110 }, /* speaker */
6265 { 0x18, 0x01a19c20 }, /* mic */
6266 { 0x19, 0x99a3092f }, /* int-mic */
6267 { 0x21, 0x0121401f }, /* HP out */
6271 .chain_id = ALC662_FIXUP_SKU_IGNORE
6273 [ALC662_FIXUP_ASUS_MODE2] = {
6274 .type = HDA_FIXUP_PINS,
6275 .v.pins = (const struct hda_pintbl[]) {
6276 { 0x14, 0x99130110 }, /* speaker */
6277 { 0x18, 0x01a19820 }, /* mic */
6278 { 0x19, 0x99a3092f }, /* int-mic */
6279 { 0x1b, 0x0121401f }, /* HP out */
6283 .chain_id = ALC662_FIXUP_SKU_IGNORE
6285 [ALC662_FIXUP_ASUS_MODE3] = {
6286 .type = HDA_FIXUP_PINS,
6287 .v.pins = (const struct hda_pintbl[]) {
6288 { 0x14, 0x99130110 }, /* speaker */
6289 { 0x15, 0x0121441f }, /* HP */
6290 { 0x18, 0x01a19840 }, /* mic */
6291 { 0x19, 0x99a3094f }, /* int-mic */
6292 { 0x21, 0x01211420 }, /* HP2 */
6296 .chain_id = ALC662_FIXUP_SKU_IGNORE
6298 [ALC662_FIXUP_ASUS_MODE4] = {
6299 .type = HDA_FIXUP_PINS,
6300 .v.pins = (const struct hda_pintbl[]) {
6301 { 0x14, 0x99130110 }, /* speaker */
6302 { 0x16, 0x99130111 }, /* speaker */
6303 { 0x18, 0x01a19840 }, /* mic */
6304 { 0x19, 0x99a3094f }, /* int-mic */
6305 { 0x21, 0x0121441f }, /* HP */
6309 .chain_id = ALC662_FIXUP_SKU_IGNORE
6311 [ALC662_FIXUP_ASUS_MODE5] = {
6312 .type = HDA_FIXUP_PINS,
6313 .v.pins = (const struct hda_pintbl[]) {
6314 { 0x14, 0x99130110 }, /* speaker */
6315 { 0x15, 0x0121441f }, /* HP */
6316 { 0x16, 0x99130111 }, /* speaker */
6317 { 0x18, 0x01a19840 }, /* mic */
6318 { 0x19, 0x99a3094f }, /* int-mic */
6322 .chain_id = ALC662_FIXUP_SKU_IGNORE
6324 [ALC662_FIXUP_ASUS_MODE6] = {
6325 .type = HDA_FIXUP_PINS,
6326 .v.pins = (const struct hda_pintbl[]) {
6327 { 0x14, 0x99130110 }, /* speaker */
6328 { 0x15, 0x01211420 }, /* HP2 */
6329 { 0x18, 0x01a19840 }, /* mic */
6330 { 0x19, 0x99a3094f }, /* int-mic */
6331 { 0x1b, 0x0121441f }, /* HP */
6335 .chain_id = ALC662_FIXUP_SKU_IGNORE
6337 [ALC662_FIXUP_ASUS_MODE7] = {
6338 .type = HDA_FIXUP_PINS,
6339 .v.pins = (const struct hda_pintbl[]) {
6340 { 0x14, 0x99130110 }, /* speaker */
6341 { 0x17, 0x99130111 }, /* speaker */
6342 { 0x18, 0x01a19840 }, /* mic */
6343 { 0x19, 0x99a3094f }, /* int-mic */
6344 { 0x1b, 0x01214020 }, /* HP */
6345 { 0x21, 0x0121401f }, /* HP */
6349 .chain_id = ALC662_FIXUP_SKU_IGNORE
6351 [ALC662_FIXUP_ASUS_MODE8] = {
6352 .type = HDA_FIXUP_PINS,
6353 .v.pins = (const struct hda_pintbl[]) {
6354 { 0x14, 0x99130110 }, /* speaker */
6355 { 0x12, 0x99a30970 }, /* int-mic */
6356 { 0x15, 0x01214020 }, /* HP */
6357 { 0x17, 0x99130111 }, /* speaker */
6358 { 0x18, 0x01a19840 }, /* mic */
6359 { 0x21, 0x0121401f }, /* HP */
6363 .chain_id = ALC662_FIXUP_SKU_IGNORE
6365 [ALC662_FIXUP_NO_JACK_DETECT] = {
6366 .type = HDA_FIXUP_FUNC,
6367 .v.func = alc_fixup_no_jack_detect,
6369 [ALC662_FIXUP_ZOTAC_Z68] = {
6370 .type = HDA_FIXUP_PINS,
6371 .v.pins = (const struct hda_pintbl[]) {
6372 { 0x1b, 0x02214020 }, /* Front HP */
6376 [ALC662_FIXUP_INV_DMIC] = {
6377 .type = HDA_FIXUP_FUNC,
6378 .v.func = alc_fixup_inv_dmic,
6380 [ALC668_FIXUP_DELL_XPS13] = {
6381 .type = HDA_FIXUP_FUNC,
6382 .v.func = alc_fixup_dell_xps13,
6384 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
6386 [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
6387 .type = HDA_FIXUP_FUNC,
6388 .v.func = alc_fixup_disable_aamix,
6390 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
6392 [ALC668_FIXUP_AUTO_MUTE] = {
6393 .type = HDA_FIXUP_FUNC,
6394 .v.func = alc_fixup_auto_mute_via_amp,
6396 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
6398 [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
6399 .type = HDA_FIXUP_PINS,
6400 .v.pins = (const struct hda_pintbl[]) {
6401 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
6402 /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
6406 .chain_id = ALC662_FIXUP_HEADSET_MODE
6408 [ALC662_FIXUP_HEADSET_MODE] = {
6409 .type = HDA_FIXUP_FUNC,
6410 .v.func = alc_fixup_headset_mode_alc662,
6412 [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
6413 .type = HDA_FIXUP_PINS,
6414 .v.pins = (const struct hda_pintbl[]) {
6415 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
6416 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
6420 .chain_id = ALC668_FIXUP_HEADSET_MODE
6422 [ALC668_FIXUP_HEADSET_MODE] = {
6423 .type = HDA_FIXUP_FUNC,
6424 .v.func = alc_fixup_headset_mode_alc668,
6426 [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
6427 .type = HDA_FIXUP_FUNC,
6428 .v.func = alc_fixup_bass_chmap,
6430 .chain_id = ALC662_FIXUP_ASUS_MODE4
6432 [ALC662_FIXUP_BASS_16] = {
6433 .type = HDA_FIXUP_PINS,
6434 .v.pins = (const struct hda_pintbl[]) {
6435 {0x16, 0x80106111}, /* bass speaker */
6439 .chain_id = ALC662_FIXUP_BASS_CHMAP,
6441 [ALC662_FIXUP_BASS_1A] = {
6442 .type = HDA_FIXUP_PINS,
6443 .v.pins = (const struct hda_pintbl[]) {
6444 {0x1a, 0x80106111}, /* bass speaker */
6448 .chain_id = ALC662_FIXUP_BASS_CHMAP,
6450 [ALC662_FIXUP_BASS_CHMAP] = {
6451 .type = HDA_FIXUP_FUNC,
6452 .v.func = alc_fixup_bass_chmap,
6456 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
6457 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
6458 SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
6459 SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
6460 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
6461 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
6462 SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
6463 SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
6464 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
6465 SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6466 SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6467 SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
6468 SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
6469 SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
6470 SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6471 SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6472 SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6473 SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6474 SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6475 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
6476 SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_BASS_1A),
6477 SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
6478 SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
6479 SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
6480 SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
6481 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
6482 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
6483 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
6484 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
6485 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
6486 SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
6487 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
6490 /* Below is a quirk table taken from the old code.
6491 * Basically the device should work as is without the fixup table.
6492 * If BIOS doesn't give a proper info, enable the corresponding
6495 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
6496 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
6497 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
6498 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
6499 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6500 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6501 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6502 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
6503 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
6504 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6505 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
6506 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
6507 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
6508 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
6509 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
6510 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6511 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
6512 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
6513 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6514 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6515 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6516 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6517 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
6518 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
6519 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
6520 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6521 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
6522 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6523 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6524 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
6525 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6526 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6527 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
6528 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
6529 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
6530 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
6531 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
6532 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
6533 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
6534 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6535 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
6536 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
6537 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6538 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
6539 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
6540 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
6541 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
6542 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
6543 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6544 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
6549 static const struct hda_model_fixup alc662_fixup_models[] = {
6550 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
6551 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
6552 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
6553 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
6554 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
6555 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
6556 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
6557 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
6558 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
6559 {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
6560 {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
6564 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
6565 SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
6569 {0x1b, 0x0221401f}),
6570 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
6574 {0x16, 0x03011020}),
6575 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
6579 {0x16, 0x03011020}),
6580 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
6584 {0x16, 0x03011020}),
6585 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
6588 {0x16, 0x03011020}),
6589 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
6592 {0x15, 0x0321101f}),
6598 static int patch_alc662(struct hda_codec *codec)
6600 struct alc_spec *spec;
6603 err = alc_alloc_spec(codec, 0x0b);
6609 spec->shutup = alc_eapd_shutup;
6611 /* handle multiple HPs as is */
6612 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6614 alc_fix_pll_init(codec, 0x20, 0x04, 15);
6616 switch (codec->core.vendor_id) {
6618 spec->init_hook = alc668_restore_default_value;
6622 snd_hda_pick_fixup(codec, alc662_fixup_models,
6623 alc662_fixup_tbl, alc662_fixups);
6624 snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups);
6625 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
6627 alc_auto_parse_customize_define(codec);
6629 if (has_cdefine_beep(codec))
6630 spec->gen.beep_nid = 0x01;
6632 if ((alc_get_coef0(codec) & (1 << 14)) &&
6633 codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
6634 spec->cdefine.platform_type == 1) {
6635 err = alc_codec_rename(codec, "ALC272X");
6640 /* automatic parse from the BIOS config */
6641 err = alc662_parse_auto_config(codec);
6645 if (!spec->gen.no_analog && spec->gen.beep_nid) {
6646 switch (codec->core.vendor_id) {
6648 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6654 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
6657 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
6662 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
6675 static int alc680_parse_auto_config(struct hda_codec *codec)
6677 return alc_parse_auto_config(codec, NULL, NULL);
6682 static int patch_alc680(struct hda_codec *codec)
6686 /* ALC680 has no aa-loopback mixer */
6687 err = alc_alloc_spec(codec, 0);
6691 /* automatic parse from the BIOS config */
6692 err = alc680_parse_auto_config(codec);
6704 static const struct hda_device_id snd_hda_id_realtek[] = {
6705 HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
6706 HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
6707 HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
6708 HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
6709 HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
6710 HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
6711 HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
6712 HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
6713 HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
6714 HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
6715 HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
6716 HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
6717 HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
6718 HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
6719 HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
6720 HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
6721 HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
6722 HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
6723 HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
6724 HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
6725 HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
6726 HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
6727 HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
6728 HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
6729 HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
6730 HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
6731 HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
6732 HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
6733 HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
6734 HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
6735 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
6736 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
6737 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
6738 HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
6739 HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
6740 HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
6741 HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
6742 HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
6743 HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
6744 HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
6745 HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc882),
6746 HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
6747 HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
6748 HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
6749 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
6750 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
6751 HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
6752 HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
6753 HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
6754 HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
6755 HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
6756 HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
6757 HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
6758 HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
6761 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
6763 MODULE_LICENSE("GPL");
6764 MODULE_DESCRIPTION("Realtek HD-audio codec");
6766 static struct hda_codec_driver realtek_driver = {
6767 .id = snd_hda_id_realtek,
6770 module_hda_codec_driver(realtek_driver);