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,
71 ALC_KEY_MICMUTE_INDEX,
74 struct alc_customize_define {
76 unsigned char port_connectivity;
77 unsigned char check_sum;
78 unsigned char customization;
79 unsigned char external_amp;
80 unsigned int enable_pcbeep:1;
81 unsigned int platform_type:1;
83 unsigned int override:1;
84 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */
88 struct hda_gen_spec gen; /* must be at head */
90 /* codec parameterization */
91 const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
92 unsigned int num_mixers;
93 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
95 struct alc_customize_define cdefine;
96 unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
98 /* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */
99 int mute_led_polarity;
100 hda_nid_t mute_led_nid;
101 hda_nid_t cap_mute_led_nid;
103 unsigned int gpio_led; /* used for alc269_fixup_hp_gpio_led() */
104 unsigned int gpio_mute_led_mask;
105 unsigned int gpio_mic_led_mask;
107 hda_nid_t headset_mic_pin;
108 hda_nid_t headphone_mic_pin;
109 int current_headset_mode;
110 int current_headset_type;
113 void (*init_hook)(struct hda_codec *codec);
115 void (*power_hook)(struct hda_codec *codec);
117 void (*shutup)(struct hda_codec *codec);
118 void (*reboot_notify)(struct hda_codec *codec);
121 int codec_variant; /* flag for other variants */
122 unsigned int has_alc5505_dsp:1;
123 unsigned int no_depop_delay:1;
127 unsigned int pll_coef_idx, pll_coef_bit;
129 struct input_dev *kb_dev;
130 u8 alc_mute_keycode_map[1];
134 * COEF access helper functions
137 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
138 unsigned int coef_idx)
142 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
143 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
147 #define alc_read_coef_idx(codec, coef_idx) \
148 alc_read_coefex_idx(codec, 0x20, coef_idx)
150 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
151 unsigned int coef_idx, unsigned int coef_val)
153 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
154 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
157 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
158 alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
160 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
161 unsigned int coef_idx, unsigned int mask,
162 unsigned int bits_set)
164 unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);
167 alc_write_coefex_idx(codec, nid, coef_idx,
168 (val & ~mask) | bits_set);
171 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \
172 alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
174 /* a special bypass for COEF 0; read the cached value at the second time */
175 static unsigned int alc_get_coef0(struct hda_codec *codec)
177 struct alc_spec *spec = codec->spec;
180 spec->coef0 = alc_read_coef_idx(codec, 0);
184 /* coef writes/updates batch */
192 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
193 { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
194 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
195 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
196 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
198 static void alc_process_coef_fw(struct hda_codec *codec,
199 const struct coef_fw *fw)
201 for (; fw->nid; fw++) {
202 if (fw->mask == (unsigned short)-1)
203 alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
205 alc_update_coefex_idx(codec, fw->nid, fw->idx,
211 * Append the given mixer and verb elements for the later use
212 * The mixer array is referred in build_controls(), and init_verbs are
215 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
217 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
219 spec->mixers[spec->num_mixers++] = mix;
223 * GPIO setup tables, used in initialization
225 /* Enable GPIO mask and set output */
226 static const struct hda_verb alc_gpio1_init_verbs[] = {
227 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
228 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
229 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
233 static const struct hda_verb alc_gpio2_init_verbs[] = {
234 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
235 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
236 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
240 static const struct hda_verb alc_gpio3_init_verbs[] = {
241 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
242 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
243 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
248 * Fix hardware PLL issue
249 * On some codecs, the analog PLL gating control must be off while
250 * the default value is 1.
252 static void alc_fix_pll(struct hda_codec *codec)
254 struct alc_spec *spec = codec->spec;
257 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
258 1 << spec->pll_coef_bit, 0);
261 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
262 unsigned int coef_idx, unsigned int coef_bit)
264 struct alc_spec *spec = codec->spec;
266 spec->pll_coef_idx = coef_idx;
267 spec->pll_coef_bit = coef_bit;
271 /* update the master volume per volume-knob's unsol event */
272 static void alc_update_knob_master(struct hda_codec *codec,
273 struct hda_jack_callback *jack)
276 struct snd_kcontrol *kctl;
277 struct snd_ctl_elem_value *uctl;
279 kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
282 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
285 val = snd_hda_codec_read(codec, jack->nid, 0,
286 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
287 val &= HDA_AMP_VOLMASK;
288 uctl->value.integer.value[0] = val;
289 uctl->value.integer.value[1] = val;
290 kctl->put(kctl, uctl);
294 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
296 /* For some reason, the res given from ALC880 is broken.
297 Here we adjust it properly. */
298 snd_hda_jack_unsol_event(codec, res >> 2);
301 /* Change EAPD to verb control */
302 static void alc_fill_eapd_coef(struct hda_codec *codec)
306 coef = alc_get_coef0(codec);
308 switch (codec->core.vendor_id) {
310 alc_update_coef_idx(codec, 0x7, 0, 1<<5);
314 alc_update_coef_idx(codec, 0x7, 0, 1<<13);
317 if ((coef & 0x00f0) == 0x0010)
318 alc_update_coef_idx(codec, 0xd, 0, 1<<14);
319 if ((coef & 0x00f0) == 0x0020)
320 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
321 if ((coef & 0x00f0) == 0x0030)
322 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
328 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
342 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
346 alc_write_coef_idx(codec, 0x36, 0x5757);
347 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
351 alc_update_coef_idx(codec, 0xa, 1<<13, 0);
360 alc_update_coef_idx(codec, 0x10, 1<<15, 0);
363 if ((coef & 0x00f0) == 0x0030)
364 alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
373 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
376 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
379 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
382 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
383 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
387 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
391 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
396 /* additional initialization for ALC888 variants */
397 static void alc888_coef_init(struct hda_codec *codec)
399 switch (alc_get_coef0(codec) & 0x00f0) {
404 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
409 /* turn on/off EAPD control (only if available) */
410 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
412 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
414 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
415 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
419 /* turn on/off EAPD controls of the codec */
420 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
422 /* We currently only handle front, HP */
423 static hda_nid_t pins[] = {
424 0x0f, 0x10, 0x14, 0x15, 0x17, 0
427 for (p = pins; *p; p++)
428 set_eapd(codec, *p, on);
431 /* generic shutup callback;
432 * just turning off EPAD and a little pause for avoiding pop-noise
434 static void alc_eapd_shutup(struct hda_codec *codec)
436 struct alc_spec *spec = codec->spec;
438 alc_auto_setup_eapd(codec, false);
439 if (!spec->no_depop_delay)
441 snd_hda_shutup_pins(codec);
444 /* generic EAPD initialization */
445 static void alc_auto_init_amp(struct hda_codec *codec, int type)
447 alc_fill_eapd_coef(codec);
448 alc_auto_setup_eapd(codec, true);
451 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
454 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
457 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
459 case ALC_INIT_DEFAULT:
460 switch (codec->core.vendor_id) {
462 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
468 alc_update_coef_idx(codec, 7, 0, 0x2030);
471 alc888_coef_init(codec);
480 * Realtek SSID verification
483 /* Could be any non-zero and even value. When used as fixup, tells
484 * the driver to ignore any present sku defines.
486 #define ALC_FIXUP_SKU_IGNORE (2)
488 static void alc_fixup_sku_ignore(struct hda_codec *codec,
489 const struct hda_fixup *fix, int action)
491 struct alc_spec *spec = codec->spec;
492 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
493 spec->cdefine.fixup = 1;
494 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
498 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
499 const struct hda_fixup *fix, int action)
501 struct alc_spec *spec = codec->spec;
503 if (action == HDA_FIXUP_ACT_PROBE) {
504 spec->no_depop_delay = 1;
505 codec->depop_delay = 0;
509 static int alc_auto_parse_customize_define(struct hda_codec *codec)
511 unsigned int ass, tmp, i;
513 struct alc_spec *spec = codec->spec;
515 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
517 if (spec->cdefine.fixup) {
518 ass = spec->cdefine.sku_cfg;
519 if (ass == ALC_FIXUP_SKU_IGNORE)
524 if (!codec->bus->pci)
526 ass = codec->core.subsystem_id & 0xffff;
527 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
531 if (codec->core.vendor_id == 0x10ec0260)
533 ass = snd_hda_codec_get_pincfg(codec, nid);
536 codec_info(codec, "%s: SKU not ready 0x%08x\n",
537 codec->core.chip_name, ass);
543 for (i = 1; i < 16; i++) {
547 if (((ass >> 16) & 0xf) != tmp)
550 spec->cdefine.port_connectivity = ass >> 30;
551 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
552 spec->cdefine.check_sum = (ass >> 16) & 0xf;
553 spec->cdefine.customization = ass >> 8;
555 spec->cdefine.sku_cfg = ass;
556 spec->cdefine.external_amp = (ass & 0x38) >> 3;
557 spec->cdefine.platform_type = (ass & 0x4) >> 2;
558 spec->cdefine.swap = (ass & 0x2) >> 1;
559 spec->cdefine.override = ass & 0x1;
561 codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
562 nid, spec->cdefine.sku_cfg);
563 codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
564 spec->cdefine.port_connectivity);
565 codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
566 codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
567 codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
568 codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
569 codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
570 codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
571 codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
576 /* return the position of NID in the list, or -1 if not found */
577 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
580 for (i = 0; i < nums; i++)
585 /* return true if the given NID is found in the list */
586 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
588 return find_idx_in_nid_list(nid, list, nums) >= 0;
591 /* check subsystem ID and set up device-specific initialization;
592 * return 1 if initialized, 0 if invalid SSID
594 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
595 * 31 ~ 16 : Manufacture ID
597 * 7 ~ 0 : Assembly ID
598 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
600 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
602 unsigned int ass, tmp, i;
604 struct alc_spec *spec = codec->spec;
606 if (spec->cdefine.fixup) {
607 ass = spec->cdefine.sku_cfg;
608 if (ass == ALC_FIXUP_SKU_IGNORE)
613 ass = codec->core.subsystem_id & 0xffff;
614 if (codec->bus->pci &&
615 ass != codec->bus->pci->subsystem_device && (ass & 1))
618 /* invalid SSID, check the special NID pin defcfg instead */
620 * 31~30 : port connectivity
623 * 19~16 : Check sum (15:1)
628 if (codec->core.vendor_id == 0x10ec0260)
630 ass = snd_hda_codec_get_pincfg(codec, nid);
632 "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
636 if ((ass >> 30) != 1) /* no physical connection */
641 for (i = 1; i < 16; i++) {
645 if (((ass >> 16) & 0xf) != tmp)
648 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
649 ass & 0xffff, codec->core.vendor_id);
653 * 2 : 0 --> Desktop, 1 --> Laptop
654 * 3~5 : External Amplifier control
657 tmp = (ass & 0x38) >> 3; /* external Amp control */
660 spec->init_amp = ALC_INIT_GPIO1;
663 spec->init_amp = ALC_INIT_GPIO2;
666 spec->init_amp = ALC_INIT_GPIO3;
670 spec->init_amp = ALC_INIT_DEFAULT;
674 /* is laptop or Desktop and enable the function "Mute internal speaker
675 * when the external headphone out jack is plugged"
680 * 10~8 : Jack location
681 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
683 * 15 : 1 --> enable the function "Mute internal speaker
684 * when the external headphone out jack is plugged"
686 if (!spec->gen.autocfg.hp_pins[0] &&
687 !(spec->gen.autocfg.line_out_pins[0] &&
688 spec->gen.autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
690 tmp = (ass >> 11) & 0x3; /* HP to chassis */
692 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
693 spec->gen.autocfg.line_outs))
695 spec->gen.autocfg.hp_pins[0] = nid;
700 /* Check the validity of ALC subsystem-id
701 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
702 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
704 if (!alc_subsystem_id(codec, ports)) {
705 struct alc_spec *spec = codec->spec;
707 "realtek: Enable default setup for auto mode as fallback\n");
708 spec->init_amp = ALC_INIT_DEFAULT;
715 static void alc_fixup_inv_dmic(struct hda_codec *codec,
716 const struct hda_fixup *fix, int action)
718 struct alc_spec *spec = codec->spec;
720 spec->gen.inv_dmic_split = 1;
724 #ifdef CONFIG_SND_HDA_INPUT_BEEP
725 /* additional beep mixers; the actual parameters are overwritten at build */
726 static const struct snd_kcontrol_new alc_beep_mixer[] = {
727 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
728 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
733 static int alc_build_controls(struct hda_codec *codec)
735 struct alc_spec *spec = codec->spec;
738 err = snd_hda_gen_build_controls(codec);
742 for (i = 0; i < spec->num_mixers; i++) {
743 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
748 #ifdef CONFIG_SND_HDA_INPUT_BEEP
749 /* create beep controls if needed */
750 if (spec->beep_amp) {
751 const struct snd_kcontrol_new *knew;
752 for (knew = alc_beep_mixer; knew->name; knew++) {
753 struct snd_kcontrol *kctl;
754 kctl = snd_ctl_new1(knew, codec);
757 kctl->private_value = spec->beep_amp;
758 err = snd_hda_ctl_add(codec, 0, kctl);
765 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
774 static int alc_init(struct hda_codec *codec)
776 struct alc_spec *spec = codec->spec;
779 spec->init_hook(codec);
781 spec->gen.skip_verbs = 1; /* applied in below */
782 snd_hda_gen_init(codec);
784 alc_auto_init_amp(codec, spec->init_amp);
785 snd_hda_apply_verbs(codec); /* apply verbs here after own init */
787 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
792 static inline void alc_shutup(struct hda_codec *codec)
794 struct alc_spec *spec = codec->spec;
796 if (spec && spec->shutup)
799 snd_hda_shutup_pins(codec);
802 static void alc_reboot_notify(struct hda_codec *codec)
804 struct alc_spec *spec = codec->spec;
806 if (spec && spec->reboot_notify)
807 spec->reboot_notify(codec);
812 #define alc_free snd_hda_gen_free
815 static void alc_power_eapd(struct hda_codec *codec)
817 alc_auto_setup_eapd(codec, false);
820 static int alc_suspend(struct hda_codec *codec)
822 struct alc_spec *spec = codec->spec;
824 if (spec && spec->power_hook)
825 spec->power_hook(codec);
831 static int alc_resume(struct hda_codec *codec)
833 struct alc_spec *spec = codec->spec;
835 if (!spec->no_depop_delay)
836 msleep(150); /* to avoid pop noise */
837 codec->patch_ops.init(codec);
838 regcache_sync(codec->core.regmap);
839 hda_call_check_power_status(codec, 0x01);
846 static const struct hda_codec_ops alc_patch_ops = {
847 .build_controls = alc_build_controls,
848 .build_pcms = snd_hda_gen_build_pcms,
851 .unsol_event = snd_hda_jack_unsol_event,
853 .resume = alc_resume,
854 .suspend = alc_suspend,
855 .check_power_status = snd_hda_gen_check_power_status,
857 .reboot_notify = alc_reboot_notify,
861 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
864 * Rename codecs appropriately from COEF value or subvendor id
866 struct alc_codec_rename_table {
867 unsigned int vendor_id;
868 unsigned short coef_mask;
869 unsigned short coef_bits;
873 struct alc_codec_rename_pci_table {
874 unsigned int codec_vendor_id;
875 unsigned short pci_subvendor;
876 unsigned short pci_subdevice;
880 static struct alc_codec_rename_table rename_tbl[] = {
881 { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
882 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
883 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
884 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
885 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
886 { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
887 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
888 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
889 { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
890 { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
891 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
892 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
893 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
894 { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
895 { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
896 { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
897 { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
901 static struct alc_codec_rename_pci_table rename_pci_tbl[] = {
902 { 0x10ec0280, 0x1028, 0, "ALC3220" },
903 { 0x10ec0282, 0x1028, 0, "ALC3221" },
904 { 0x10ec0283, 0x1028, 0, "ALC3223" },
905 { 0x10ec0288, 0x1028, 0, "ALC3263" },
906 { 0x10ec0292, 0x1028, 0, "ALC3226" },
907 { 0x10ec0293, 0x1028, 0, "ALC3235" },
908 { 0x10ec0255, 0x1028, 0, "ALC3234" },
909 { 0x10ec0668, 0x1028, 0, "ALC3661" },
910 { 0x10ec0275, 0x1028, 0, "ALC3260" },
911 { 0x10ec0899, 0x1028, 0, "ALC3861" },
912 { 0x10ec0298, 0x1028, 0, "ALC3266" },
913 { 0x10ec0236, 0x1028, 0, "ALC3204" },
914 { 0x10ec0256, 0x1028, 0, "ALC3246" },
915 { 0x10ec0225, 0x1028, 0, "ALC3253" },
916 { 0x10ec0295, 0x1028, 0, "ALC3254" },
917 { 0x10ec0299, 0x1028, 0, "ALC3271" },
918 { 0x10ec0670, 0x1025, 0, "ALC669X" },
919 { 0x10ec0676, 0x1025, 0, "ALC679X" },
920 { 0x10ec0282, 0x1043, 0, "ALC3229" },
921 { 0x10ec0233, 0x1043, 0, "ALC3236" },
922 { 0x10ec0280, 0x103c, 0, "ALC3228" },
923 { 0x10ec0282, 0x103c, 0, "ALC3227" },
924 { 0x10ec0286, 0x103c, 0, "ALC3242" },
925 { 0x10ec0290, 0x103c, 0, "ALC3241" },
926 { 0x10ec0668, 0x103c, 0, "ALC3662" },
927 { 0x10ec0283, 0x17aa, 0, "ALC3239" },
928 { 0x10ec0292, 0x17aa, 0, "ALC3232" },
932 static int alc_codec_rename_from_preset(struct hda_codec *codec)
934 const struct alc_codec_rename_table *p;
935 const struct alc_codec_rename_pci_table *q;
937 for (p = rename_tbl; p->vendor_id; p++) {
938 if (p->vendor_id != codec->core.vendor_id)
940 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
941 return alc_codec_rename(codec, p->name);
944 if (!codec->bus->pci)
946 for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
947 if (q->codec_vendor_id != codec->core.vendor_id)
949 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
951 if (!q->pci_subdevice ||
952 q->pci_subdevice == codec->bus->pci->subsystem_device)
953 return alc_codec_rename(codec, q->name);
961 * Digital-beep handlers
963 #ifdef CONFIG_SND_HDA_INPUT_BEEP
964 #define set_beep_amp(spec, nid, idx, dir) \
965 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
967 static const struct snd_pci_quirk beep_white_list[] = {
968 SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
969 SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
970 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
971 SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
972 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
973 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
974 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
975 SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
976 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
977 /* blacklist -- no beep available */
978 SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
979 SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
983 static inline int has_cdefine_beep(struct hda_codec *codec)
985 struct alc_spec *spec = codec->spec;
986 const struct snd_pci_quirk *q;
987 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
990 return spec->cdefine.enable_pcbeep;
993 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
994 #define has_cdefine_beep(codec) 0
997 /* parse the BIOS configuration and set up the alc_spec */
998 /* return 1 if successful, 0 if the proper config is not found,
999 * or a negative error code
1001 static int alc_parse_auto_config(struct hda_codec *codec,
1002 const hda_nid_t *ignore_nids,
1003 const hda_nid_t *ssid_nids)
1005 struct alc_spec *spec = codec->spec;
1006 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1009 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1015 alc_ssid_check(codec, ssid_nids);
1017 err = snd_hda_gen_parse_auto_config(codec, cfg);
1024 /* common preparation job for alc_spec */
1025 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1027 struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1033 snd_hda_gen_spec_init(&spec->gen);
1034 spec->gen.mixer_nid = mixer_nid;
1035 spec->gen.own_eapd_ctl = 1;
1036 codec->single_adc_amp = 1;
1037 /* FIXME: do we need this for all Realtek codec models? */
1038 codec->spdif_status_reset = 1;
1039 codec->patch_ops = alc_patch_ops;
1041 err = alc_codec_rename_from_preset(codec);
1049 static int alc880_parse_auto_config(struct hda_codec *codec)
1051 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1052 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1053 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1062 ALC880_FIXUP_MEDION_RIM,
1064 ALC880_FIXUP_LG_LW25,
1066 ALC880_FIXUP_EAPD_COEF,
1067 ALC880_FIXUP_TCL_S700,
1068 ALC880_FIXUP_VOL_KNOB,
1069 ALC880_FIXUP_FUJITSU,
1071 ALC880_FIXUP_UNIWILL,
1072 ALC880_FIXUP_UNIWILL_DIG,
1074 ALC880_FIXUP_ASUS_W5A,
1075 ALC880_FIXUP_3ST_BASE,
1077 ALC880_FIXUP_3ST_DIG,
1078 ALC880_FIXUP_5ST_BASE,
1080 ALC880_FIXUP_5ST_DIG,
1081 ALC880_FIXUP_6ST_BASE,
1083 ALC880_FIXUP_6ST_DIG,
1084 ALC880_FIXUP_6ST_AUTOMUTE,
1087 /* enable the volume-knob widget support on NID 0x21 */
1088 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1089 const struct hda_fixup *fix, int action)
1091 if (action == HDA_FIXUP_ACT_PROBE)
1092 snd_hda_jack_detect_enable_callback(codec, 0x21,
1093 alc_update_knob_master);
1096 static const struct hda_fixup alc880_fixups[] = {
1097 [ALC880_FIXUP_GPIO1] = {
1098 .type = HDA_FIXUP_VERBS,
1099 .v.verbs = alc_gpio1_init_verbs,
1101 [ALC880_FIXUP_GPIO2] = {
1102 .type = HDA_FIXUP_VERBS,
1103 .v.verbs = alc_gpio2_init_verbs,
1105 [ALC880_FIXUP_MEDION_RIM] = {
1106 .type = HDA_FIXUP_VERBS,
1107 .v.verbs = (const struct hda_verb[]) {
1108 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1109 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1113 .chain_id = ALC880_FIXUP_GPIO2,
1115 [ALC880_FIXUP_LG] = {
1116 .type = HDA_FIXUP_PINS,
1117 .v.pins = (const struct hda_pintbl[]) {
1118 /* disable bogus unused pins */
1119 { 0x16, 0x411111f0 },
1120 { 0x18, 0x411111f0 },
1121 { 0x1a, 0x411111f0 },
1125 [ALC880_FIXUP_LG_LW25] = {
1126 .type = HDA_FIXUP_PINS,
1127 .v.pins = (const struct hda_pintbl[]) {
1128 { 0x1a, 0x0181344f }, /* line-in */
1129 { 0x1b, 0x0321403f }, /* headphone */
1133 [ALC880_FIXUP_W810] = {
1134 .type = HDA_FIXUP_PINS,
1135 .v.pins = (const struct hda_pintbl[]) {
1136 /* disable bogus unused pins */
1137 { 0x17, 0x411111f0 },
1141 .chain_id = ALC880_FIXUP_GPIO2,
1143 [ALC880_FIXUP_EAPD_COEF] = {
1144 .type = HDA_FIXUP_VERBS,
1145 .v.verbs = (const struct hda_verb[]) {
1146 /* change to EAPD mode */
1147 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1148 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1152 [ALC880_FIXUP_TCL_S700] = {
1153 .type = HDA_FIXUP_VERBS,
1154 .v.verbs = (const struct hda_verb[]) {
1155 /* change to EAPD mode */
1156 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1157 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
1161 .chain_id = ALC880_FIXUP_GPIO2,
1163 [ALC880_FIXUP_VOL_KNOB] = {
1164 .type = HDA_FIXUP_FUNC,
1165 .v.func = alc880_fixup_vol_knob,
1167 [ALC880_FIXUP_FUJITSU] = {
1168 /* override all pins as BIOS on old Amilo is broken */
1169 .type = HDA_FIXUP_PINS,
1170 .v.pins = (const struct hda_pintbl[]) {
1171 { 0x14, 0x0121401f }, /* HP */
1172 { 0x15, 0x99030120 }, /* speaker */
1173 { 0x16, 0x99030130 }, /* bass speaker */
1174 { 0x17, 0x411111f0 }, /* N/A */
1175 { 0x18, 0x411111f0 }, /* N/A */
1176 { 0x19, 0x01a19950 }, /* mic-in */
1177 { 0x1a, 0x411111f0 }, /* N/A */
1178 { 0x1b, 0x411111f0 }, /* N/A */
1179 { 0x1c, 0x411111f0 }, /* N/A */
1180 { 0x1d, 0x411111f0 }, /* N/A */
1181 { 0x1e, 0x01454140 }, /* SPDIF out */
1185 .chain_id = ALC880_FIXUP_VOL_KNOB,
1187 [ALC880_FIXUP_F1734] = {
1188 /* almost compatible with FUJITSU, but no bass and SPDIF */
1189 .type = HDA_FIXUP_PINS,
1190 .v.pins = (const struct hda_pintbl[]) {
1191 { 0x14, 0x0121401f }, /* HP */
1192 { 0x15, 0x99030120 }, /* speaker */
1193 { 0x16, 0x411111f0 }, /* N/A */
1194 { 0x17, 0x411111f0 }, /* N/A */
1195 { 0x18, 0x411111f0 }, /* N/A */
1196 { 0x19, 0x01a19950 }, /* mic-in */
1197 { 0x1a, 0x411111f0 }, /* N/A */
1198 { 0x1b, 0x411111f0 }, /* N/A */
1199 { 0x1c, 0x411111f0 }, /* N/A */
1200 { 0x1d, 0x411111f0 }, /* N/A */
1201 { 0x1e, 0x411111f0 }, /* N/A */
1205 .chain_id = ALC880_FIXUP_VOL_KNOB,
1207 [ALC880_FIXUP_UNIWILL] = {
1208 /* need to fix HP and speaker pins to be parsed correctly */
1209 .type = HDA_FIXUP_PINS,
1210 .v.pins = (const struct hda_pintbl[]) {
1211 { 0x14, 0x0121411f }, /* HP */
1212 { 0x15, 0x99030120 }, /* speaker */
1213 { 0x16, 0x99030130 }, /* bass speaker */
1217 [ALC880_FIXUP_UNIWILL_DIG] = {
1218 .type = HDA_FIXUP_PINS,
1219 .v.pins = (const struct hda_pintbl[]) {
1220 /* disable bogus unused pins */
1221 { 0x17, 0x411111f0 },
1222 { 0x19, 0x411111f0 },
1223 { 0x1b, 0x411111f0 },
1224 { 0x1f, 0x411111f0 },
1228 [ALC880_FIXUP_Z71V] = {
1229 .type = HDA_FIXUP_PINS,
1230 .v.pins = (const struct hda_pintbl[]) {
1231 /* set up the whole pins as BIOS is utterly broken */
1232 { 0x14, 0x99030120 }, /* speaker */
1233 { 0x15, 0x0121411f }, /* HP */
1234 { 0x16, 0x411111f0 }, /* N/A */
1235 { 0x17, 0x411111f0 }, /* N/A */
1236 { 0x18, 0x01a19950 }, /* mic-in */
1237 { 0x19, 0x411111f0 }, /* N/A */
1238 { 0x1a, 0x01813031 }, /* line-in */
1239 { 0x1b, 0x411111f0 }, /* N/A */
1240 { 0x1c, 0x411111f0 }, /* N/A */
1241 { 0x1d, 0x411111f0 }, /* N/A */
1242 { 0x1e, 0x0144111e }, /* SPDIF */
1246 [ALC880_FIXUP_ASUS_W5A] = {
1247 .type = HDA_FIXUP_PINS,
1248 .v.pins = (const struct hda_pintbl[]) {
1249 /* set up the whole pins as BIOS is utterly broken */
1250 { 0x14, 0x0121411f }, /* HP */
1251 { 0x15, 0x411111f0 }, /* N/A */
1252 { 0x16, 0x411111f0 }, /* N/A */
1253 { 0x17, 0x411111f0 }, /* N/A */
1254 { 0x18, 0x90a60160 }, /* mic */
1255 { 0x19, 0x411111f0 }, /* N/A */
1256 { 0x1a, 0x411111f0 }, /* N/A */
1257 { 0x1b, 0x411111f0 }, /* N/A */
1258 { 0x1c, 0x411111f0 }, /* N/A */
1259 { 0x1d, 0x411111f0 }, /* N/A */
1260 { 0x1e, 0xb743111e }, /* SPDIF out */
1264 .chain_id = ALC880_FIXUP_GPIO1,
1266 [ALC880_FIXUP_3ST_BASE] = {
1267 .type = HDA_FIXUP_PINS,
1268 .v.pins = (const struct hda_pintbl[]) {
1269 { 0x14, 0x01014010 }, /* line-out */
1270 { 0x15, 0x411111f0 }, /* N/A */
1271 { 0x16, 0x411111f0 }, /* N/A */
1272 { 0x17, 0x411111f0 }, /* N/A */
1273 { 0x18, 0x01a19c30 }, /* mic-in */
1274 { 0x19, 0x0121411f }, /* HP */
1275 { 0x1a, 0x01813031 }, /* line-in */
1276 { 0x1b, 0x02a19c40 }, /* front-mic */
1277 { 0x1c, 0x411111f0 }, /* N/A */
1278 { 0x1d, 0x411111f0 }, /* N/A */
1279 /* 0x1e is filled in below */
1280 { 0x1f, 0x411111f0 }, /* N/A */
1284 [ALC880_FIXUP_3ST] = {
1285 .type = HDA_FIXUP_PINS,
1286 .v.pins = (const struct hda_pintbl[]) {
1287 { 0x1e, 0x411111f0 }, /* N/A */
1291 .chain_id = ALC880_FIXUP_3ST_BASE,
1293 [ALC880_FIXUP_3ST_DIG] = {
1294 .type = HDA_FIXUP_PINS,
1295 .v.pins = (const struct hda_pintbl[]) {
1296 { 0x1e, 0x0144111e }, /* SPDIF */
1300 .chain_id = ALC880_FIXUP_3ST_BASE,
1302 [ALC880_FIXUP_5ST_BASE] = {
1303 .type = HDA_FIXUP_PINS,
1304 .v.pins = (const struct hda_pintbl[]) {
1305 { 0x14, 0x01014010 }, /* front */
1306 { 0x15, 0x411111f0 }, /* N/A */
1307 { 0x16, 0x01011411 }, /* CLFE */
1308 { 0x17, 0x01016412 }, /* surr */
1309 { 0x18, 0x01a19c30 }, /* mic-in */
1310 { 0x19, 0x0121411f }, /* HP */
1311 { 0x1a, 0x01813031 }, /* line-in */
1312 { 0x1b, 0x02a19c40 }, /* front-mic */
1313 { 0x1c, 0x411111f0 }, /* N/A */
1314 { 0x1d, 0x411111f0 }, /* N/A */
1315 /* 0x1e is filled in below */
1316 { 0x1f, 0x411111f0 }, /* N/A */
1320 [ALC880_FIXUP_5ST] = {
1321 .type = HDA_FIXUP_PINS,
1322 .v.pins = (const struct hda_pintbl[]) {
1323 { 0x1e, 0x411111f0 }, /* N/A */
1327 .chain_id = ALC880_FIXUP_5ST_BASE,
1329 [ALC880_FIXUP_5ST_DIG] = {
1330 .type = HDA_FIXUP_PINS,
1331 .v.pins = (const struct hda_pintbl[]) {
1332 { 0x1e, 0x0144111e }, /* SPDIF */
1336 .chain_id = ALC880_FIXUP_5ST_BASE,
1338 [ALC880_FIXUP_6ST_BASE] = {
1339 .type = HDA_FIXUP_PINS,
1340 .v.pins = (const struct hda_pintbl[]) {
1341 { 0x14, 0x01014010 }, /* front */
1342 { 0x15, 0x01016412 }, /* surr */
1343 { 0x16, 0x01011411 }, /* CLFE */
1344 { 0x17, 0x01012414 }, /* side */
1345 { 0x18, 0x01a19c30 }, /* mic-in */
1346 { 0x19, 0x02a19c40 }, /* front-mic */
1347 { 0x1a, 0x01813031 }, /* line-in */
1348 { 0x1b, 0x0121411f }, /* HP */
1349 { 0x1c, 0x411111f0 }, /* N/A */
1350 { 0x1d, 0x411111f0 }, /* N/A */
1351 /* 0x1e is filled in below */
1352 { 0x1f, 0x411111f0 }, /* N/A */
1356 [ALC880_FIXUP_6ST] = {
1357 .type = HDA_FIXUP_PINS,
1358 .v.pins = (const struct hda_pintbl[]) {
1359 { 0x1e, 0x411111f0 }, /* N/A */
1363 .chain_id = ALC880_FIXUP_6ST_BASE,
1365 [ALC880_FIXUP_6ST_DIG] = {
1366 .type = HDA_FIXUP_PINS,
1367 .v.pins = (const struct hda_pintbl[]) {
1368 { 0x1e, 0x0144111e }, /* SPDIF */
1372 .chain_id = ALC880_FIXUP_6ST_BASE,
1374 [ALC880_FIXUP_6ST_AUTOMUTE] = {
1375 .type = HDA_FIXUP_PINS,
1376 .v.pins = (const struct hda_pintbl[]) {
1377 { 0x1b, 0x0121401f }, /* HP with jack detect */
1380 .chained_before = true,
1381 .chain_id = ALC880_FIXUP_6ST_BASE,
1385 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1386 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1387 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1388 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1389 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1390 SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1391 SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1392 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1393 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1394 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1395 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1396 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1397 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1398 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1399 SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1400 SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1401 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1402 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1403 SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1404 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1405 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1406 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1407 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1408 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1410 /* Below is the copied entries from alc880_quirks.c.
1411 * It's not quite sure whether BIOS sets the correct pin-config table
1412 * on these machines, thus they are kept to be compatible with
1413 * the old static quirks. Once when it's confirmed to work without
1414 * these overrides, it'd be better to remove.
1416 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1417 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1418 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1419 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1420 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1421 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1422 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1423 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1424 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1425 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1426 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1427 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1428 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1429 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1430 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1431 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1432 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1433 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1434 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1435 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1436 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1437 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1438 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1439 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1440 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1441 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1442 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1443 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1444 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1445 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1446 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1447 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1448 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1450 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1451 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1452 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1456 static const struct hda_model_fixup alc880_fixup_models[] = {
1457 {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1458 {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1459 {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1460 {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1461 {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1462 {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1463 {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1469 * OK, here we have finally the patch for ALC880
1471 static int patch_alc880(struct hda_codec *codec)
1473 struct alc_spec *spec;
1476 err = alc_alloc_spec(codec, 0x0b);
1481 spec->gen.need_dac_fix = 1;
1482 spec->gen.beep_nid = 0x01;
1484 codec->patch_ops.unsol_event = alc880_unsol_event;
1486 snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1488 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1490 /* automatic parse from the BIOS config */
1491 err = alc880_parse_auto_config(codec);
1495 if (!spec->gen.no_analog)
1496 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1498 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1511 static int alc260_parse_auto_config(struct hda_codec *codec)
1513 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1514 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1515 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1522 ALC260_FIXUP_HP_DC5750,
1523 ALC260_FIXUP_HP_PIN_0F,
1526 ALC260_FIXUP_GPIO1_TOGGLE,
1527 ALC260_FIXUP_REPLACER,
1528 ALC260_FIXUP_HP_B1900,
1530 ALC260_FIXUP_FSC_S7020,
1531 ALC260_FIXUP_FSC_S7020_JWSE,
1532 ALC260_FIXUP_VAIO_PINS,
1535 static void alc260_gpio1_automute(struct hda_codec *codec)
1537 struct alc_spec *spec = codec->spec;
1538 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1539 spec->gen.hp_jack_present);
1542 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1543 const struct hda_fixup *fix, int action)
1545 struct alc_spec *spec = codec->spec;
1546 if (action == HDA_FIXUP_ACT_PROBE) {
1547 /* although the machine has only one output pin, we need to
1548 * toggle GPIO1 according to the jack state
1550 spec->gen.automute_hook = alc260_gpio1_automute;
1551 spec->gen.detect_hp = 1;
1552 spec->gen.automute_speaker = 1;
1553 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1554 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1555 snd_hda_gen_hp_automute);
1556 snd_hda_add_verbs(codec, alc_gpio1_init_verbs);
1560 static void alc260_fixup_kn1(struct hda_codec *codec,
1561 const struct hda_fixup *fix, int action)
1563 struct alc_spec *spec = codec->spec;
1564 static const struct hda_pintbl pincfgs[] = {
1565 { 0x0f, 0x02214000 }, /* HP/speaker */
1566 { 0x12, 0x90a60160 }, /* int mic */
1567 { 0x13, 0x02a19000 }, /* ext mic */
1568 { 0x18, 0x01446000 }, /* SPDIF out */
1569 /* disable bogus I/O pins */
1570 { 0x10, 0x411111f0 },
1571 { 0x11, 0x411111f0 },
1572 { 0x14, 0x411111f0 },
1573 { 0x15, 0x411111f0 },
1574 { 0x16, 0x411111f0 },
1575 { 0x17, 0x411111f0 },
1576 { 0x19, 0x411111f0 },
1581 case HDA_FIXUP_ACT_PRE_PROBE:
1582 snd_hda_apply_pincfgs(codec, pincfgs);
1584 case HDA_FIXUP_ACT_PROBE:
1585 spec->init_amp = ALC_INIT_NONE;
1590 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1591 const struct hda_fixup *fix, int action)
1593 struct alc_spec *spec = codec->spec;
1594 if (action == HDA_FIXUP_ACT_PROBE)
1595 spec->init_amp = ALC_INIT_NONE;
1598 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1599 const struct hda_fixup *fix, int action)
1601 struct alc_spec *spec = codec->spec;
1602 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1603 spec->gen.add_jack_modes = 1;
1604 spec->gen.hp_mic = 1;
1608 static const struct hda_fixup alc260_fixups[] = {
1609 [ALC260_FIXUP_HP_DC5750] = {
1610 .type = HDA_FIXUP_PINS,
1611 .v.pins = (const struct hda_pintbl[]) {
1612 { 0x11, 0x90130110 }, /* speaker */
1616 [ALC260_FIXUP_HP_PIN_0F] = {
1617 .type = HDA_FIXUP_PINS,
1618 .v.pins = (const struct hda_pintbl[]) {
1619 { 0x0f, 0x01214000 }, /* HP */
1623 [ALC260_FIXUP_COEF] = {
1624 .type = HDA_FIXUP_VERBS,
1625 .v.verbs = (const struct hda_verb[]) {
1626 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1627 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 },
1631 [ALC260_FIXUP_GPIO1] = {
1632 .type = HDA_FIXUP_VERBS,
1633 .v.verbs = alc_gpio1_init_verbs,
1635 [ALC260_FIXUP_GPIO1_TOGGLE] = {
1636 .type = HDA_FIXUP_FUNC,
1637 .v.func = alc260_fixup_gpio1_toggle,
1639 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1641 [ALC260_FIXUP_REPLACER] = {
1642 .type = HDA_FIXUP_VERBS,
1643 .v.verbs = (const struct hda_verb[]) {
1644 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1645 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 },
1649 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1651 [ALC260_FIXUP_HP_B1900] = {
1652 .type = HDA_FIXUP_FUNC,
1653 .v.func = alc260_fixup_gpio1_toggle,
1655 .chain_id = ALC260_FIXUP_COEF,
1657 [ALC260_FIXUP_KN1] = {
1658 .type = HDA_FIXUP_FUNC,
1659 .v.func = alc260_fixup_kn1,
1661 [ALC260_FIXUP_FSC_S7020] = {
1662 .type = HDA_FIXUP_FUNC,
1663 .v.func = alc260_fixup_fsc_s7020,
1665 [ALC260_FIXUP_FSC_S7020_JWSE] = {
1666 .type = HDA_FIXUP_FUNC,
1667 .v.func = alc260_fixup_fsc_s7020_jwse,
1669 .chain_id = ALC260_FIXUP_FSC_S7020,
1671 [ALC260_FIXUP_VAIO_PINS] = {
1672 .type = HDA_FIXUP_PINS,
1673 .v.pins = (const struct hda_pintbl[]) {
1674 /* Pin configs are missing completely on some VAIOs */
1675 { 0x0f, 0x01211020 },
1676 { 0x10, 0x0001003f },
1677 { 0x11, 0x411111f0 },
1678 { 0x12, 0x01a15930 },
1679 { 0x13, 0x411111f0 },
1680 { 0x14, 0x411111f0 },
1681 { 0x15, 0x411111f0 },
1682 { 0x16, 0x411111f0 },
1683 { 0x17, 0x411111f0 },
1684 { 0x18, 0x411111f0 },
1685 { 0x19, 0x411111f0 },
1691 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1692 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1693 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1694 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1695 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1696 SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1697 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1698 SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1699 SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1700 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1701 SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1702 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1703 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1707 static const struct hda_model_fixup alc260_fixup_models[] = {
1708 {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1709 {.id = ALC260_FIXUP_COEF, .name = "coef"},
1710 {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1711 {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1717 static int patch_alc260(struct hda_codec *codec)
1719 struct alc_spec *spec;
1722 err = alc_alloc_spec(codec, 0x07);
1727 /* as quite a few machines require HP amp for speaker outputs,
1728 * it's easier to enable it unconditionally; even if it's unneeded,
1729 * it's almost harmless.
1731 spec->gen.prefer_hp_amp = 1;
1732 spec->gen.beep_nid = 0x01;
1734 spec->shutup = alc_eapd_shutup;
1736 snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1738 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1740 /* automatic parse from the BIOS config */
1741 err = alc260_parse_auto_config(codec);
1745 if (!spec->gen.no_analog)
1746 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1748 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1759 * ALC882/883/885/888/889 support
1761 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1762 * configuration. Each pin widget can choose any input DACs and a mixer.
1763 * Each ADC is connected from a mixer of all inputs. This makes possible
1764 * 6-channel independent captures.
1766 * In addition, an independent DAC for the multi-playback (not used in this
1774 ALC882_FIXUP_ABIT_AW9D_MAX,
1775 ALC882_FIXUP_LENOVO_Y530,
1776 ALC882_FIXUP_PB_M5210,
1777 ALC882_FIXUP_ACER_ASPIRE_7736,
1778 ALC882_FIXUP_ASUS_W90V,
1780 ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1781 ALC889_FIXUP_VAIO_TT,
1782 ALC888_FIXUP_EEE1601,
1785 ALC883_FIXUP_ACER_EAPD,
1790 ALC882_FIXUP_ASUS_W2JC,
1791 ALC882_FIXUP_ACER_ASPIRE_4930G,
1792 ALC882_FIXUP_ACER_ASPIRE_8930G,
1793 ALC882_FIXUP_ASPIRE_8930G_VERBS,
1794 ALC885_FIXUP_MACPRO_GPIO,
1795 ALC889_FIXUP_DAC_ROUTE,
1796 ALC889_FIXUP_MBP_VREF,
1797 ALC889_FIXUP_IMAC91_VREF,
1798 ALC889_FIXUP_MBA11_VREF,
1799 ALC889_FIXUP_MBA21_VREF,
1800 ALC889_FIXUP_MP11_VREF,
1801 ALC889_FIXUP_MP41_VREF,
1802 ALC882_FIXUP_INV_DMIC,
1803 ALC882_FIXUP_NO_PRIMARY_HP,
1804 ALC887_FIXUP_ASUS_BASS,
1805 ALC887_FIXUP_BASS_CHMAP,
1808 static void alc889_fixup_coef(struct hda_codec *codec,
1809 const struct hda_fixup *fix, int action)
1811 if (action != HDA_FIXUP_ACT_INIT)
1813 alc_update_coef_idx(codec, 7, 0, 0x2030);
1816 /* toggle speaker-output according to the hp-jack state */
1817 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
1819 unsigned int gpiostate, gpiomask, gpiodir;
1821 gpiostate = snd_hda_codec_read(codec, codec->core.afg, 0,
1822 AC_VERB_GET_GPIO_DATA, 0);
1825 gpiostate |= (1 << pin);
1827 gpiostate &= ~(1 << pin);
1829 gpiomask = snd_hda_codec_read(codec, codec->core.afg, 0,
1830 AC_VERB_GET_GPIO_MASK, 0);
1831 gpiomask |= (1 << pin);
1833 gpiodir = snd_hda_codec_read(codec, codec->core.afg, 0,
1834 AC_VERB_GET_GPIO_DIRECTION, 0);
1835 gpiodir |= (1 << pin);
1838 snd_hda_codec_write(codec, codec->core.afg, 0,
1839 AC_VERB_SET_GPIO_MASK, gpiomask);
1840 snd_hda_codec_write(codec, codec->core.afg, 0,
1841 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
1845 snd_hda_codec_write(codec, codec->core.afg, 0,
1846 AC_VERB_SET_GPIO_DATA, gpiostate);
1849 /* set up GPIO at initialization */
1850 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1851 const struct hda_fixup *fix, int action)
1853 if (action != HDA_FIXUP_ACT_INIT)
1855 alc882_gpio_mute(codec, 0, 0);
1856 alc882_gpio_mute(codec, 1, 0);
1859 /* Fix the connection of some pins for ALC889:
1860 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
1861 * work correctly (bko#42740)
1863 static void alc889_fixup_dac_route(struct hda_codec *codec,
1864 const struct hda_fixup *fix, int action)
1866 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1867 /* fake the connections during parsing the tree */
1868 hda_nid_t conn1[2] = { 0x0c, 0x0d };
1869 hda_nid_t conn2[2] = { 0x0e, 0x0f };
1870 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
1871 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
1872 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
1873 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
1874 } else if (action == HDA_FIXUP_ACT_PROBE) {
1875 /* restore the connections */
1876 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
1877 snd_hda_override_conn_list(codec, 0x14, 5, conn);
1878 snd_hda_override_conn_list(codec, 0x15, 5, conn);
1879 snd_hda_override_conn_list(codec, 0x18, 5, conn);
1880 snd_hda_override_conn_list(codec, 0x1a, 5, conn);
1884 /* Set VREF on HP pin */
1885 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
1886 const struct hda_fixup *fix, int action)
1888 struct alc_spec *spec = codec->spec;
1889 static hda_nid_t nids[3] = { 0x14, 0x15, 0x19 };
1892 if (action != HDA_FIXUP_ACT_INIT)
1894 for (i = 0; i < ARRAY_SIZE(nids); i++) {
1895 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
1896 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
1898 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1899 val |= AC_PINCTL_VREF_80;
1900 snd_hda_set_pin_ctl(codec, nids[i], val);
1901 spec->gen.keep_vref_in_automute = 1;
1906 static void alc889_fixup_mac_pins(struct hda_codec *codec,
1907 const hda_nid_t *nids, int num_nids)
1909 struct alc_spec *spec = codec->spec;
1912 for (i = 0; i < num_nids; i++) {
1914 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1915 val |= AC_PINCTL_VREF_50;
1916 snd_hda_set_pin_ctl(codec, nids[i], val);
1918 spec->gen.keep_vref_in_automute = 1;
1921 /* Set VREF on speaker pins on imac91 */
1922 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
1923 const struct hda_fixup *fix, int action)
1925 static hda_nid_t nids[2] = { 0x18, 0x1a };
1927 if (action == HDA_FIXUP_ACT_INIT)
1928 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1931 /* Set VREF on speaker pins on mba11 */
1932 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
1933 const struct hda_fixup *fix, int action)
1935 static hda_nid_t nids[1] = { 0x18 };
1937 if (action == HDA_FIXUP_ACT_INIT)
1938 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1941 /* Set VREF on speaker pins on mba21 */
1942 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
1943 const struct hda_fixup *fix, int action)
1945 static hda_nid_t nids[2] = { 0x18, 0x19 };
1947 if (action == HDA_FIXUP_ACT_INIT)
1948 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1951 /* Don't take HP output as primary
1952 * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
1953 * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
1955 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
1956 const struct hda_fixup *fix, int action)
1958 struct alc_spec *spec = codec->spec;
1959 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1960 spec->gen.no_primary_hp = 1;
1961 spec->gen.no_multi_io = 1;
1965 static void alc_fixup_bass_chmap(struct hda_codec *codec,
1966 const struct hda_fixup *fix, int action);
1968 static const struct hda_fixup alc882_fixups[] = {
1969 [ALC882_FIXUP_ABIT_AW9D_MAX] = {
1970 .type = HDA_FIXUP_PINS,
1971 .v.pins = (const struct hda_pintbl[]) {
1972 { 0x15, 0x01080104 }, /* side */
1973 { 0x16, 0x01011012 }, /* rear */
1974 { 0x17, 0x01016011 }, /* clfe */
1978 [ALC882_FIXUP_LENOVO_Y530] = {
1979 .type = HDA_FIXUP_PINS,
1980 .v.pins = (const struct hda_pintbl[]) {
1981 { 0x15, 0x99130112 }, /* rear int speakers */
1982 { 0x16, 0x99130111 }, /* subwoofer */
1986 [ALC882_FIXUP_PB_M5210] = {
1987 .type = HDA_FIXUP_PINCTLS,
1988 .v.pins = (const struct hda_pintbl[]) {
1989 { 0x19, PIN_VREF50 },
1993 [ALC882_FIXUP_ACER_ASPIRE_7736] = {
1994 .type = HDA_FIXUP_FUNC,
1995 .v.func = alc_fixup_sku_ignore,
1997 [ALC882_FIXUP_ASUS_W90V] = {
1998 .type = HDA_FIXUP_PINS,
1999 .v.pins = (const struct hda_pintbl[]) {
2000 { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2004 [ALC889_FIXUP_CD] = {
2005 .type = HDA_FIXUP_PINS,
2006 .v.pins = (const struct hda_pintbl[]) {
2007 { 0x1c, 0x993301f0 }, /* CD */
2011 [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2012 .type = HDA_FIXUP_PINS,
2013 .v.pins = (const struct hda_pintbl[]) {
2014 { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2018 .chain_id = ALC889_FIXUP_CD,
2020 [ALC889_FIXUP_VAIO_TT] = {
2021 .type = HDA_FIXUP_PINS,
2022 .v.pins = (const struct hda_pintbl[]) {
2023 { 0x17, 0x90170111 }, /* hidden surround speaker */
2027 [ALC888_FIXUP_EEE1601] = {
2028 .type = HDA_FIXUP_VERBS,
2029 .v.verbs = (const struct hda_verb[]) {
2030 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2031 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },
2035 [ALC882_FIXUP_EAPD] = {
2036 .type = HDA_FIXUP_VERBS,
2037 .v.verbs = (const struct hda_verb[]) {
2038 /* change to EAPD mode */
2039 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2040 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2044 [ALC883_FIXUP_EAPD] = {
2045 .type = HDA_FIXUP_VERBS,
2046 .v.verbs = (const struct hda_verb[]) {
2047 /* change to EAPD mode */
2048 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2049 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2053 [ALC883_FIXUP_ACER_EAPD] = {
2054 .type = HDA_FIXUP_VERBS,
2055 .v.verbs = (const struct hda_verb[]) {
2056 /* eanable EAPD on Acer laptops */
2057 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2058 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2062 [ALC882_FIXUP_GPIO1] = {
2063 .type = HDA_FIXUP_VERBS,
2064 .v.verbs = alc_gpio1_init_verbs,
2066 [ALC882_FIXUP_GPIO2] = {
2067 .type = HDA_FIXUP_VERBS,
2068 .v.verbs = alc_gpio2_init_verbs,
2070 [ALC882_FIXUP_GPIO3] = {
2071 .type = HDA_FIXUP_VERBS,
2072 .v.verbs = alc_gpio3_init_verbs,
2074 [ALC882_FIXUP_ASUS_W2JC] = {
2075 .type = HDA_FIXUP_VERBS,
2076 .v.verbs = alc_gpio1_init_verbs,
2078 .chain_id = ALC882_FIXUP_EAPD,
2080 [ALC889_FIXUP_COEF] = {
2081 .type = HDA_FIXUP_FUNC,
2082 .v.func = alc889_fixup_coef,
2084 [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2085 .type = HDA_FIXUP_PINS,
2086 .v.pins = (const struct hda_pintbl[]) {
2087 { 0x16, 0x99130111 }, /* CLFE speaker */
2088 { 0x17, 0x99130112 }, /* surround speaker */
2092 .chain_id = ALC882_FIXUP_GPIO1,
2094 [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2095 .type = HDA_FIXUP_PINS,
2096 .v.pins = (const struct hda_pintbl[]) {
2097 { 0x16, 0x99130111 }, /* CLFE speaker */
2098 { 0x1b, 0x99130112 }, /* surround speaker */
2102 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2104 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2105 /* additional init verbs for Acer Aspire 8930G */
2106 .type = HDA_FIXUP_VERBS,
2107 .v.verbs = (const struct hda_verb[]) {
2108 /* Enable all DACs */
2109 /* DAC DISABLE/MUTE 1? */
2110 /* setting bits 1-5 disables DAC nids 0x02-0x06
2111 * apparently. Init=0x38 */
2112 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2113 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2114 /* DAC DISABLE/MUTE 2? */
2115 /* some bit here disables the other DACs.
2117 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2118 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2120 * This laptop has a stereo digital microphone.
2121 * The mics are only 1cm apart which makes the stereo
2122 * useless. However, either the mic or the ALC889
2123 * makes the signal become a difference/sum signal
2124 * instead of standard stereo, which is annoying.
2125 * So instead we flip this bit which makes the
2126 * codec replicate the sum signal to both channels,
2127 * turning it into a normal mono mic.
2129 /* DMIC_CONTROL? Init value = 0x0001 */
2130 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2131 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2132 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2133 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2137 .chain_id = ALC882_FIXUP_GPIO1,
2139 [ALC885_FIXUP_MACPRO_GPIO] = {
2140 .type = HDA_FIXUP_FUNC,
2141 .v.func = alc885_fixup_macpro_gpio,
2143 [ALC889_FIXUP_DAC_ROUTE] = {
2144 .type = HDA_FIXUP_FUNC,
2145 .v.func = alc889_fixup_dac_route,
2147 [ALC889_FIXUP_MBP_VREF] = {
2148 .type = HDA_FIXUP_FUNC,
2149 .v.func = alc889_fixup_mbp_vref,
2151 .chain_id = ALC882_FIXUP_GPIO1,
2153 [ALC889_FIXUP_IMAC91_VREF] = {
2154 .type = HDA_FIXUP_FUNC,
2155 .v.func = alc889_fixup_imac91_vref,
2157 .chain_id = ALC882_FIXUP_GPIO1,
2159 [ALC889_FIXUP_MBA11_VREF] = {
2160 .type = HDA_FIXUP_FUNC,
2161 .v.func = alc889_fixup_mba11_vref,
2163 .chain_id = ALC889_FIXUP_MBP_VREF,
2165 [ALC889_FIXUP_MBA21_VREF] = {
2166 .type = HDA_FIXUP_FUNC,
2167 .v.func = alc889_fixup_mba21_vref,
2169 .chain_id = ALC889_FIXUP_MBP_VREF,
2171 [ALC889_FIXUP_MP11_VREF] = {
2172 .type = HDA_FIXUP_FUNC,
2173 .v.func = alc889_fixup_mba11_vref,
2175 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2177 [ALC889_FIXUP_MP41_VREF] = {
2178 .type = HDA_FIXUP_FUNC,
2179 .v.func = alc889_fixup_mbp_vref,
2181 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2183 [ALC882_FIXUP_INV_DMIC] = {
2184 .type = HDA_FIXUP_FUNC,
2185 .v.func = alc_fixup_inv_dmic,
2187 [ALC882_FIXUP_NO_PRIMARY_HP] = {
2188 .type = HDA_FIXUP_FUNC,
2189 .v.func = alc882_fixup_no_primary_hp,
2191 [ALC887_FIXUP_ASUS_BASS] = {
2192 .type = HDA_FIXUP_PINS,
2193 .v.pins = (const struct hda_pintbl[]) {
2194 {0x16, 0x99130130}, /* bass speaker */
2198 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2200 [ALC887_FIXUP_BASS_CHMAP] = {
2201 .type = HDA_FIXUP_FUNC,
2202 .v.func = alc_fixup_bass_chmap,
2206 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2207 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2208 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2209 SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2210 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2211 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2212 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2213 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2214 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2215 ALC882_FIXUP_ACER_ASPIRE_4930G),
2216 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2217 ALC882_FIXUP_ACER_ASPIRE_4930G),
2218 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2219 ALC882_FIXUP_ACER_ASPIRE_8930G),
2220 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2221 ALC882_FIXUP_ACER_ASPIRE_8930G),
2222 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2223 ALC882_FIXUP_ACER_ASPIRE_4930G),
2224 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2225 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2226 ALC882_FIXUP_ACER_ASPIRE_4930G),
2227 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2228 ALC882_FIXUP_ACER_ASPIRE_4930G),
2229 SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2230 ALC882_FIXUP_ACER_ASPIRE_4930G),
2231 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2232 SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2233 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2234 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2235 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2236 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2237 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2238 SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2239 SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2240 SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2241 SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2242 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2243 SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2244 SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2246 /* All Apple entries are in codec SSIDs */
2247 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2248 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2249 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2250 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2251 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2252 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2253 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2254 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2255 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2256 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2257 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2258 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2259 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2260 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2261 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2262 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2263 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2264 SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2265 SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2266 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2267 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2268 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2270 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2271 SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2272 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2273 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2274 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2275 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2276 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2277 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2278 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2282 static const struct hda_model_fixup alc882_fixup_models[] = {
2283 {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2284 {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2285 {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2286 {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2287 {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2292 * BIOS auto configuration
2294 /* almost identical with ALC880 parser... */
2295 static int alc882_parse_auto_config(struct hda_codec *codec)
2297 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2298 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2299 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2304 static int patch_alc882(struct hda_codec *codec)
2306 struct alc_spec *spec;
2309 err = alc_alloc_spec(codec, 0x0b);
2315 switch (codec->core.vendor_id) {
2321 /* ALC883 and variants */
2322 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2326 snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2328 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2330 alc_auto_parse_customize_define(codec);
2332 if (has_cdefine_beep(codec))
2333 spec->gen.beep_nid = 0x01;
2335 /* automatic parse from the BIOS config */
2336 err = alc882_parse_auto_config(codec);
2340 if (!spec->gen.no_analog && spec->gen.beep_nid)
2341 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2343 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2356 static int alc262_parse_auto_config(struct hda_codec *codec)
2358 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2359 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2360 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2367 ALC262_FIXUP_FSC_H270,
2368 ALC262_FIXUP_FSC_S7110,
2369 ALC262_FIXUP_HP_Z200,
2371 ALC262_FIXUP_LENOVO_3000,
2373 ALC262_FIXUP_BENQ_T31,
2374 ALC262_FIXUP_INV_DMIC,
2375 ALC262_FIXUP_INTEL_BAYLEYBAY,
2378 static const struct hda_fixup alc262_fixups[] = {
2379 [ALC262_FIXUP_FSC_H270] = {
2380 .type = HDA_FIXUP_PINS,
2381 .v.pins = (const struct hda_pintbl[]) {
2382 { 0x14, 0x99130110 }, /* speaker */
2383 { 0x15, 0x0221142f }, /* front HP */
2384 { 0x1b, 0x0121141f }, /* rear HP */
2388 [ALC262_FIXUP_FSC_S7110] = {
2389 .type = HDA_FIXUP_PINS,
2390 .v.pins = (const struct hda_pintbl[]) {
2391 { 0x15, 0x90170110 }, /* speaker */
2395 .chain_id = ALC262_FIXUP_BENQ,
2397 [ALC262_FIXUP_HP_Z200] = {
2398 .type = HDA_FIXUP_PINS,
2399 .v.pins = (const struct hda_pintbl[]) {
2400 { 0x16, 0x99130120 }, /* internal speaker */
2404 [ALC262_FIXUP_TYAN] = {
2405 .type = HDA_FIXUP_PINS,
2406 .v.pins = (const struct hda_pintbl[]) {
2407 { 0x14, 0x1993e1f0 }, /* int AUX */
2411 [ALC262_FIXUP_LENOVO_3000] = {
2412 .type = HDA_FIXUP_PINCTLS,
2413 .v.pins = (const struct hda_pintbl[]) {
2414 { 0x19, PIN_VREF50 },
2418 .chain_id = ALC262_FIXUP_BENQ,
2420 [ALC262_FIXUP_BENQ] = {
2421 .type = HDA_FIXUP_VERBS,
2422 .v.verbs = (const struct hda_verb[]) {
2423 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2424 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2428 [ALC262_FIXUP_BENQ_T31] = {
2429 .type = HDA_FIXUP_VERBS,
2430 .v.verbs = (const struct hda_verb[]) {
2431 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2432 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2436 [ALC262_FIXUP_INV_DMIC] = {
2437 .type = HDA_FIXUP_FUNC,
2438 .v.func = alc_fixup_inv_dmic,
2440 [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2441 .type = HDA_FIXUP_FUNC,
2442 .v.func = alc_fixup_no_depop_delay,
2446 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2447 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2448 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2449 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2450 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2451 SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2452 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2453 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2454 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2455 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2456 SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2460 static const struct hda_model_fixup alc262_fixup_models[] = {
2461 {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2467 static int patch_alc262(struct hda_codec *codec)
2469 struct alc_spec *spec;
2472 err = alc_alloc_spec(codec, 0x0b);
2477 spec->gen.shared_mic_vref_pin = 0x18;
2479 spec->shutup = alc_eapd_shutup;
2482 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
2485 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2487 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2489 snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2491 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2493 alc_auto_parse_customize_define(codec);
2495 if (has_cdefine_beep(codec))
2496 spec->gen.beep_nid = 0x01;
2498 /* automatic parse from the BIOS config */
2499 err = alc262_parse_auto_config(codec);
2503 if (!spec->gen.no_analog && spec->gen.beep_nid)
2504 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2506 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2518 /* bind Beep switches of both NID 0x0f and 0x10 */
2519 static const struct hda_bind_ctls alc268_bind_beep_sw = {
2520 .ops = &snd_hda_bind_sw,
2522 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
2523 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
2528 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2529 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2530 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
2534 /* set PCBEEP vol = 0, mute connections */
2535 static const struct hda_verb alc268_beep_init_verbs[] = {
2536 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2537 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2538 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2543 ALC268_FIXUP_INV_DMIC,
2544 ALC268_FIXUP_HP_EAPD,
2548 static const struct hda_fixup alc268_fixups[] = {
2549 [ALC268_FIXUP_INV_DMIC] = {
2550 .type = HDA_FIXUP_FUNC,
2551 .v.func = alc_fixup_inv_dmic,
2553 [ALC268_FIXUP_HP_EAPD] = {
2554 .type = HDA_FIXUP_VERBS,
2555 .v.verbs = (const struct hda_verb[]) {
2556 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
2560 [ALC268_FIXUP_SPDIF] = {
2561 .type = HDA_FIXUP_PINS,
2562 .v.pins = (const struct hda_pintbl[]) {
2563 { 0x1e, 0x014b1180 }, /* enable SPDIF out */
2569 static const struct hda_model_fixup alc268_fixup_models[] = {
2570 {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2571 {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
2575 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2576 SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
2577 SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2578 /* below is codec SSID since multiple Toshiba laptops have the
2579 * same PCI SSID 1179:ff00
2581 SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
2586 * BIOS auto configuration
2588 static int alc268_parse_auto_config(struct hda_codec *codec)
2590 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2591 return alc_parse_auto_config(codec, NULL, alc268_ssids);
2596 static int patch_alc268(struct hda_codec *codec)
2598 struct alc_spec *spec;
2601 /* ALC268 has no aa-loopback mixer */
2602 err = alc_alloc_spec(codec, 0);
2607 spec->gen.beep_nid = 0x01;
2609 spec->shutup = alc_eapd_shutup;
2611 snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
2612 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2614 /* automatic parse from the BIOS config */
2615 err = alc268_parse_auto_config(codec);
2619 if (err > 0 && !spec->gen.no_analog &&
2620 spec->gen.autocfg.speaker_pins[0] != 0x1d) {
2621 add_mixer(spec, alc268_beep_mixer);
2622 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
2623 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
2624 /* override the amp caps for beep generator */
2625 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
2626 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
2627 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
2628 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2629 (0 << AC_AMPCAP_MUTE_SHIFT));
2632 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2645 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
2646 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2649 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
2650 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2653 /* different alc269-variants */
2655 ALC269_TYPE_ALC269VA,
2656 ALC269_TYPE_ALC269VB,
2657 ALC269_TYPE_ALC269VC,
2658 ALC269_TYPE_ALC269VD,
2675 * BIOS auto configuration
2677 static int alc269_parse_auto_config(struct hda_codec *codec)
2679 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
2680 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
2681 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2682 struct alc_spec *spec = codec->spec;
2683 const hda_nid_t *ssids;
2685 switch (spec->codec_variant) {
2686 case ALC269_TYPE_ALC269VA:
2687 case ALC269_TYPE_ALC269VC:
2688 case ALC269_TYPE_ALC280:
2689 case ALC269_TYPE_ALC284:
2690 case ALC269_TYPE_ALC285:
2691 ssids = alc269va_ssids;
2693 case ALC269_TYPE_ALC269VB:
2694 case ALC269_TYPE_ALC269VD:
2695 case ALC269_TYPE_ALC282:
2696 case ALC269_TYPE_ALC283:
2697 case ALC269_TYPE_ALC286:
2698 case ALC269_TYPE_ALC298:
2699 case ALC269_TYPE_ALC255:
2700 case ALC269_TYPE_ALC256:
2701 case ALC269_TYPE_ALC257:
2702 case ALC269_TYPE_ALC225:
2703 case ALC269_TYPE_ALC294:
2704 case ALC269_TYPE_ALC700:
2705 ssids = alc269_ssids;
2708 ssids = alc269_ssids;
2712 return alc_parse_auto_config(codec, alc269_ignore, ssids);
2715 static int find_ext_mic_pin(struct hda_codec *codec);
2717 static void alc286_shutup(struct hda_codec *codec)
2720 int mic_pin = find_ext_mic_pin(codec);
2721 /* don't shut up pins when unloading the driver; otherwise it breaks
2722 * the default pin setup at the next load of the driver
2724 if (codec->bus->shutdown)
2726 for (i = 0; i < codec->init_pins.used; i++) {
2727 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
2728 /* use read here for syncing after issuing each verb */
2729 if (pin->nid != mic_pin)
2730 snd_hda_codec_read(codec, pin->nid, 0,
2731 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
2733 codec->pins_shutup = 1;
2736 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
2738 alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
2741 static void alc269_shutup(struct hda_codec *codec)
2743 struct alc_spec *spec = codec->spec;
2745 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
2746 alc269vb_toggle_power_output(codec, 0);
2747 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
2748 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
2751 snd_hda_shutup_pins(codec);
2754 static struct coef_fw alc282_coefs[] = {
2755 WRITE_COEF(0x03, 0x0002), /* Power Down Control */
2756 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
2757 WRITE_COEF(0x07, 0x0200), /* DMIC control */
2758 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
2759 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
2760 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
2761 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
2762 WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
2763 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
2764 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
2765 WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
2766 UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
2767 WRITE_COEF(0x34, 0xa0c0), /* ANC */
2768 UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
2769 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
2770 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
2771 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
2772 WRITE_COEF(0x63, 0x2902), /* PLL */
2773 WRITE_COEF(0x68, 0xa080), /* capless control 2 */
2774 WRITE_COEF(0x69, 0x3400), /* capless control 3 */
2775 WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
2776 WRITE_COEF(0x6b, 0x0), /* capless control 5 */
2777 UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
2778 WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
2779 UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
2780 WRITE_COEF(0x71, 0x0014), /* class D test 6 */
2781 WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
2782 UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
2783 WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
2787 static void alc282_restore_default_value(struct hda_codec *codec)
2789 alc_process_coef_fw(codec, alc282_coefs);
2792 static void alc282_init(struct hda_codec *codec)
2794 struct alc_spec *spec = codec->spec;
2795 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2799 alc282_restore_default_value(codec);
2803 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2804 coef78 = alc_read_coef_idx(codec, 0x78);
2806 /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
2807 /* Headphone capless set to high power mode */
2808 alc_write_coef_idx(codec, 0x78, 0x9004);
2813 snd_hda_codec_write(codec, hp_pin, 0,
2814 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2819 snd_hda_codec_write(codec, hp_pin, 0,
2820 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
2825 /* Headphone capless set to normal mode */
2826 alc_write_coef_idx(codec, 0x78, coef78);
2829 static void alc282_shutup(struct hda_codec *codec)
2831 struct alc_spec *spec = codec->spec;
2832 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2837 alc269_shutup(codec);
2841 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2842 coef78 = alc_read_coef_idx(codec, 0x78);
2843 alc_write_coef_idx(codec, 0x78, 0x9004);
2848 snd_hda_codec_write(codec, hp_pin, 0,
2849 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2854 snd_hda_codec_write(codec, hp_pin, 0,
2855 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
2860 alc_auto_setup_eapd(codec, false);
2861 snd_hda_shutup_pins(codec);
2862 alc_write_coef_idx(codec, 0x78, coef78);
2865 static struct coef_fw alc283_coefs[] = {
2866 WRITE_COEF(0x03, 0x0002), /* Power Down Control */
2867 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
2868 WRITE_COEF(0x07, 0x0200), /* DMIC control */
2869 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
2870 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
2871 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
2872 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
2873 WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
2874 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
2875 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
2876 WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
2877 UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
2878 WRITE_COEF(0x22, 0xa0c0), /* ANC */
2879 UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
2880 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
2881 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
2882 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
2883 WRITE_COEF(0x2e, 0x2902), /* PLL */
2884 WRITE_COEF(0x33, 0xa080), /* capless control 2 */
2885 WRITE_COEF(0x34, 0x3400), /* capless control 3 */
2886 WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
2887 WRITE_COEF(0x36, 0x0), /* capless control 5 */
2888 UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
2889 WRITE_COEF(0x39, 0x110a), /* class D test 3 */
2890 UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
2891 WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
2892 WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
2893 UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
2894 WRITE_COEF(0x49, 0x0), /* test mode */
2895 UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
2896 UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
2897 WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
2898 UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
2902 static void alc283_restore_default_value(struct hda_codec *codec)
2904 alc_process_coef_fw(codec, alc283_coefs);
2907 static void alc283_init(struct hda_codec *codec)
2909 struct alc_spec *spec = codec->spec;
2910 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2913 if (!spec->gen.autocfg.hp_outs) {
2914 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
2915 hp_pin = spec->gen.autocfg.line_out_pins[0];
2918 alc283_restore_default_value(codec);
2924 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2926 /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
2927 /* Headphone capless set to high power mode */
2928 alc_write_coef_idx(codec, 0x43, 0x9004);
2930 snd_hda_codec_write(codec, hp_pin, 0,
2931 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2936 snd_hda_codec_write(codec, hp_pin, 0,
2937 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
2941 /* Index 0x46 Combo jack auto switch control 2 */
2942 /* 3k pull low control for Headset jack. */
2943 alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
2944 /* Headphone capless set to normal mode */
2945 alc_write_coef_idx(codec, 0x43, 0x9614);
2948 static void alc283_shutup(struct hda_codec *codec)
2950 struct alc_spec *spec = codec->spec;
2951 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2954 if (!spec->gen.autocfg.hp_outs) {
2955 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
2956 hp_pin = spec->gen.autocfg.line_out_pins[0];
2960 alc269_shutup(codec);
2964 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2966 alc_write_coef_idx(codec, 0x43, 0x9004);
2968 /*depop hp during suspend*/
2969 alc_write_coef_idx(codec, 0x06, 0x2100);
2971 snd_hda_codec_write(codec, hp_pin, 0,
2972 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2977 snd_hda_codec_write(codec, hp_pin, 0,
2978 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
2980 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
2984 alc_auto_setup_eapd(codec, false);
2985 snd_hda_shutup_pins(codec);
2986 alc_write_coef_idx(codec, 0x43, 0x9614);
2989 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
2992 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
2993 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
2994 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
2997 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3001 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3002 val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3004 val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3009 static void alc5505_dsp_halt(struct hda_codec *codec)
3013 alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3014 alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3015 alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3016 alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3017 alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3018 alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3019 alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3020 val = alc5505_coef_get(codec, 0x6220);
3021 alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3024 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3026 alc5505_coef_set(codec, 0x61b8, 0x04133302);
3027 alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3028 alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3029 alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3030 alc5505_coef_set(codec, 0x6220, 0x2002010f);
3031 alc5505_coef_set(codec, 0x880c, 0x00000004);
3034 static void alc5505_dsp_init(struct hda_codec *codec)
3038 alc5505_dsp_halt(codec);
3039 alc5505_dsp_back_from_halt(codec);
3040 alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3041 alc5505_coef_set(codec, 0x61b0, 0x5b16);
3042 alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
3043 alc5505_coef_set(codec, 0x61b4, 0x04132b02);
3044 alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
3045 alc5505_coef_set(codec, 0x61b8, 0x041f3302);
3046 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
3047 alc5505_coef_set(codec, 0x61b8, 0x041b3302);
3048 alc5505_coef_set(codec, 0x61b8, 0x04173302);
3049 alc5505_coef_set(codec, 0x61b8, 0x04163302);
3050 alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
3051 alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
3052 alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
3054 val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
3056 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
3058 alc5505_coef_set(codec, 0x6220, 0x6002018f);
3060 alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
3061 alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
3062 alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
3063 alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
3064 alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
3065 alc5505_coef_set(codec, 0x880c, 0x00000003);
3066 alc5505_coef_set(codec, 0x880c, 0x00000010);
3068 #ifdef HALT_REALTEK_ALC5505
3069 alc5505_dsp_halt(codec);
3073 #ifdef HALT_REALTEK_ALC5505
3074 #define alc5505_dsp_suspend(codec) /* NOP */
3075 #define alc5505_dsp_resume(codec) /* NOP */
3077 #define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec)
3078 #define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec)
3082 static int alc269_suspend(struct hda_codec *codec)
3084 struct alc_spec *spec = codec->spec;
3086 if (spec->has_alc5505_dsp)
3087 alc5505_dsp_suspend(codec);
3088 return alc_suspend(codec);
3091 static int alc269_resume(struct hda_codec *codec)
3093 struct alc_spec *spec = codec->spec;
3095 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3096 alc269vb_toggle_power_output(codec, 0);
3097 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3098 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3102 codec->patch_ops.init(codec);
3104 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3105 alc269vb_toggle_power_output(codec, 1);
3106 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3107 (alc_get_coef0(codec) & 0x00ff) == 0x017) {
3111 regcache_sync(codec->core.regmap);
3112 hda_call_check_power_status(codec, 0x01);
3114 /* on some machine, the BIOS will clear the codec gpio data when enter
3115 * suspend, and won't restore the data after resume, so we restore it
3119 snd_hda_codec_write(codec, codec->core.afg, 0, AC_VERB_SET_GPIO_DATA,
3122 if (spec->has_alc5505_dsp)
3123 alc5505_dsp_resume(codec);
3127 #endif /* CONFIG_PM */
3129 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
3130 const struct hda_fixup *fix, int action)
3132 struct alc_spec *spec = codec->spec;
3134 if (action == HDA_FIXUP_ACT_PRE_PROBE)
3135 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
3138 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
3139 const struct hda_fixup *fix,
3142 unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
3143 unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
3145 if (cfg_headphone && cfg_headset_mic == 0x411111f0)
3146 snd_hda_codec_set_pincfg(codec, 0x19,
3147 (cfg_headphone & ~AC_DEFCFG_DEVICE) |
3148 (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
3151 static void alc269_fixup_hweq(struct hda_codec *codec,
3152 const struct hda_fixup *fix, int action)
3154 if (action == HDA_FIXUP_ACT_INIT)
3155 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
3158 static void alc269_fixup_headset_mic(struct hda_codec *codec,
3159 const struct hda_fixup *fix, int action)
3161 struct alc_spec *spec = codec->spec;
3163 if (action == HDA_FIXUP_ACT_PRE_PROBE)
3164 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3167 static void alc271_fixup_dmic(struct hda_codec *codec,
3168 const struct hda_fixup *fix, int action)
3170 static const struct hda_verb verbs[] = {
3171 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
3172 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
3177 if (strcmp(codec->core.chip_name, "ALC271X") &&
3178 strcmp(codec->core.chip_name, "ALC269VB"))
3180 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
3181 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
3182 snd_hda_sequence_write(codec, verbs);
3185 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
3186 const struct hda_fixup *fix, int action)
3188 struct alc_spec *spec = codec->spec;
3190 if (action != HDA_FIXUP_ACT_PROBE)
3193 /* Due to a hardware problem on Lenovo Ideadpad, we need to
3194 * fix the sample rate of analog I/O to 44.1kHz
3196 spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
3197 spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
3200 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
3201 const struct hda_fixup *fix, int action)
3203 /* The digital-mic unit sends PDM (differential signal) instead of
3204 * the standard PCM, thus you can't record a valid mono stream as is.
3205 * Below is a workaround specific to ALC269 to control the dmic
3206 * signal source as mono.
3208 if (action == HDA_FIXUP_ACT_INIT)
3209 alc_update_coef_idx(codec, 0x07, 0, 0x80);
3212 static void alc269_quanta_automute(struct hda_codec *codec)
3214 snd_hda_gen_update_outputs(codec);
3216 alc_write_coef_idx(codec, 0x0c, 0x680);
3217 alc_write_coef_idx(codec, 0x0c, 0x480);
3220 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
3221 const struct hda_fixup *fix, int action)
3223 struct alc_spec *spec = codec->spec;
3224 if (action != HDA_FIXUP_ACT_PROBE)
3226 spec->gen.automute_hook = alc269_quanta_automute;
3229 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
3230 struct hda_jack_callback *jack)
3232 struct alc_spec *spec = codec->spec;
3235 snd_hda_gen_hp_automute(codec, jack);
3237 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
3239 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3242 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3246 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
3247 const struct hda_fixup *fix, int action)
3249 struct alc_spec *spec = codec->spec;
3250 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3251 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3252 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
3257 /* update mute-LED according to the speaker mute state via mic VREF pin */
3258 static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)
3260 struct hda_codec *codec = private_data;
3261 struct alc_spec *spec = codec->spec;
3262 unsigned int pinval;
3264 if (spec->mute_led_polarity)
3266 pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);
3267 pinval &= ~AC_PINCTL_VREFEN;
3268 pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;
3269 if (spec->mute_led_nid) {
3270 /* temporarily power up/down for setting VREF */
3271 snd_hda_power_up_pm(codec);
3272 snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
3273 snd_hda_power_down_pm(codec);
3277 /* Make sure the led works even in runtime suspend */
3278 static unsigned int led_power_filter(struct hda_codec *codec,
3280 unsigned int power_state)
3282 struct alc_spec *spec = codec->spec;
3284 if (power_state != AC_PWRST_D3 || nid == 0 ||
3285 (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
3288 /* Set pin ctl again, it might have just been set to 0 */
3289 snd_hda_set_pin_ctl(codec, nid,
3290 snd_hda_codec_get_pin_target(codec, nid));
3292 return snd_hda_gen_path_power_filter(codec, nid, power_state);
3295 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
3296 const struct hda_fixup *fix, int action)
3298 struct alc_spec *spec = codec->spec;
3299 const struct dmi_device *dev = NULL;
3301 if (action != HDA_FIXUP_ACT_PRE_PROBE)
3304 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
3306 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
3308 if (pin < 0x0a || pin >= 0x10)
3310 spec->mute_led_polarity = pol;
3311 spec->mute_led_nid = pin - 0x0a + 0x18;
3312 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3313 spec->gen.vmaster_mute_enum = 1;
3314 codec->power_filter = led_power_filter;
3316 "Detected mute LED for %x:%d\n", spec->mute_led_nid,
3317 spec->mute_led_polarity);
3322 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
3323 const struct hda_fixup *fix, int action)
3325 struct alc_spec *spec = codec->spec;
3326 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3327 spec->mute_led_polarity = 0;
3328 spec->mute_led_nid = 0x18;
3329 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3330 spec->gen.vmaster_mute_enum = 1;
3331 codec->power_filter = led_power_filter;
3335 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
3336 const struct hda_fixup *fix, int action)
3338 struct alc_spec *spec = codec->spec;
3339 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3340 spec->mute_led_polarity = 0;
3341 spec->mute_led_nid = 0x19;
3342 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3343 spec->gen.vmaster_mute_enum = 1;
3344 codec->power_filter = led_power_filter;
3348 /* update LED status via GPIO */
3349 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
3352 struct alc_spec *spec = codec->spec;
3353 unsigned int oldval = spec->gpio_led;
3355 if (spec->mute_led_polarity)
3359 spec->gpio_led &= ~mask;
3361 spec->gpio_led |= mask;
3362 if (spec->gpio_led != oldval)
3363 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
3367 /* turn on/off mute LED via GPIO per vmaster hook */
3368 static void alc_fixup_gpio_mute_hook(void *private_data, int enabled)
3370 struct hda_codec *codec = private_data;
3371 struct alc_spec *spec = codec->spec;
3373 alc_update_gpio_led(codec, spec->gpio_mute_led_mask, enabled);
3376 /* turn on/off mic-mute LED via GPIO per capture hook */
3377 static void alc_fixup_gpio_mic_mute_hook(struct hda_codec *codec,
3378 struct snd_kcontrol *kcontrol,
3379 struct snd_ctl_elem_value *ucontrol)
3381 struct alc_spec *spec = codec->spec;
3384 alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
3385 ucontrol->value.integer.value[0] ||
3386 ucontrol->value.integer.value[1]);
3389 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
3390 const struct hda_fixup *fix, int action)
3392 struct alc_spec *spec = codec->spec;
3393 static const struct hda_verb gpio_init[] = {
3394 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
3395 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
3399 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3400 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3401 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3403 spec->mute_led_polarity = 0;
3404 spec->gpio_mute_led_mask = 0x08;
3405 spec->gpio_mic_led_mask = 0x10;
3406 snd_hda_add_verbs(codec, gpio_init);
3410 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
3411 const struct hda_fixup *fix, int action)
3413 struct alc_spec *spec = codec->spec;
3414 static const struct hda_verb gpio_init[] = {
3415 { 0x01, AC_VERB_SET_GPIO_MASK, 0x22 },
3416 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x22 },
3420 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3421 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3422 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3424 spec->mute_led_polarity = 0;
3425 spec->gpio_mute_led_mask = 0x02;
3426 spec->gpio_mic_led_mask = 0x20;
3427 snd_hda_add_verbs(codec, gpio_init);
3431 /* turn on/off mic-mute LED per capture hook */
3432 static void alc269_fixup_hp_cap_mic_mute_hook(struct hda_codec *codec,
3433 struct snd_kcontrol *kcontrol,
3434 struct snd_ctl_elem_value *ucontrol)
3436 struct alc_spec *spec = codec->spec;
3437 unsigned int pinval, enable, disable;
3439 pinval = snd_hda_codec_get_pin_target(codec, spec->cap_mute_led_nid);
3440 pinval &= ~AC_PINCTL_VREFEN;
3441 enable = pinval | AC_PINCTL_VREF_80;
3442 disable = pinval | AC_PINCTL_VREF_HIZ;
3447 if (ucontrol->value.integer.value[0] ||
3448 ucontrol->value.integer.value[1])
3453 if (spec->cap_mute_led_nid)
3454 snd_hda_set_pin_ctl_cache(codec, spec->cap_mute_led_nid, pinval);
3457 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
3458 const struct hda_fixup *fix, int action)
3460 struct alc_spec *spec = codec->spec;
3461 static const struct hda_verb gpio_init[] = {
3462 { 0x01, AC_VERB_SET_GPIO_MASK, 0x08 },
3463 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x08 },
3467 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3468 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3469 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
3471 spec->mute_led_polarity = 0;
3472 spec->gpio_mute_led_mask = 0x08;
3473 spec->cap_mute_led_nid = 0x18;
3474 snd_hda_add_verbs(codec, gpio_init);
3475 codec->power_filter = led_power_filter;
3479 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
3480 const struct hda_fixup *fix, int action)
3482 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to enable headphone amp */
3483 struct alc_spec *spec = codec->spec;
3484 static const struct hda_verb gpio_init[] = {
3485 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
3486 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
3490 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3491 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3492 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
3494 spec->mute_led_polarity = 0;
3495 spec->gpio_mute_led_mask = 0x08;
3496 spec->cap_mute_led_nid = 0x18;
3497 snd_hda_add_verbs(codec, gpio_init);
3498 codec->power_filter = led_power_filter;
3502 #if IS_REACHABLE(CONFIG_INPUT)
3503 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
3504 struct hda_jack_callback *event)
3506 struct alc_spec *spec = codec->spec;
3508 /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
3509 send both key on and key off event for every interrupt. */
3510 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
3511 input_sync(spec->kb_dev);
3512 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
3513 input_sync(spec->kb_dev);
3516 static int alc_register_micmute_input_device(struct hda_codec *codec)
3518 struct alc_spec *spec = codec->spec;
3521 spec->kb_dev = input_allocate_device();
3522 if (!spec->kb_dev) {
3523 codec_err(codec, "Out of memory (input_allocate_device)\n");
3527 spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
3529 spec->kb_dev->name = "Microphone Mute Button";
3530 spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
3531 spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
3532 spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
3533 spec->kb_dev->keycode = spec->alc_mute_keycode_map;
3534 for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
3535 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
3537 if (input_register_device(spec->kb_dev)) {
3538 codec_err(codec, "input_register_device failed\n");
3539 input_free_device(spec->kb_dev);
3540 spec->kb_dev = NULL;
3547 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
3548 const struct hda_fixup *fix, int action)
3550 /* GPIO1 = set according to SKU external amp
3551 GPIO2 = mic mute hotkey
3553 GPIO4 = mic mute LED */
3554 static const struct hda_verb gpio_init[] = {
3555 { 0x01, AC_VERB_SET_GPIO_MASK, 0x1e },
3556 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x1a },
3557 { 0x01, AC_VERB_SET_GPIO_DATA, 0x02 },
3561 struct alc_spec *spec = codec->spec;
3563 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3564 if (alc_register_micmute_input_device(codec) != 0)
3567 snd_hda_add_verbs(codec, gpio_init);
3568 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
3569 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
3570 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
3571 gpio2_mic_hotkey_event);
3573 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3574 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3576 spec->mute_led_polarity = 0;
3577 spec->gpio_mute_led_mask = 0x08;
3578 spec->gpio_mic_led_mask = 0x10;
3586 case HDA_FIXUP_ACT_PROBE:
3587 spec->init_amp = ALC_INIT_DEFAULT;
3589 case HDA_FIXUP_ACT_FREE:
3590 input_unregister_device(spec->kb_dev);
3591 spec->kb_dev = NULL;
3595 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
3596 const struct hda_fixup *fix, int action)
3598 /* Line2 = mic mute hotkey
3599 GPIO2 = mic mute LED */
3600 static const struct hda_verb gpio_init[] = {
3601 { 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },
3602 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },
3606 struct alc_spec *spec = codec->spec;
3608 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3609 if (alc_register_micmute_input_device(codec) != 0)
3612 snd_hda_add_verbs(codec, gpio_init);
3613 snd_hda_jack_detect_enable_callback(codec, 0x1b,
3614 gpio2_mic_hotkey_event);
3616 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3618 spec->mute_led_polarity = 0;
3619 spec->gpio_mic_led_mask = 0x04;
3627 case HDA_FIXUP_ACT_PROBE:
3628 spec->init_amp = ALC_INIT_DEFAULT;
3630 case HDA_FIXUP_ACT_FREE:
3631 input_unregister_device(spec->kb_dev);
3632 spec->kb_dev = NULL;
3636 #define alc280_fixup_hp_gpio2_mic_hotkey NULL
3637 #define alc233_fixup_lenovo_line2_mic_hotkey NULL
3640 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
3641 const struct hda_fixup *fix, int action)
3643 struct alc_spec *spec = codec->spec;
3645 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3646 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3647 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
3648 spec->mute_led_polarity = 0;
3649 spec->mute_led_nid = 0x1a;
3650 spec->cap_mute_led_nid = 0x18;
3651 spec->gen.vmaster_mute_enum = 1;
3652 codec->power_filter = led_power_filter;
3656 static void alc_headset_mode_unplugged(struct hda_codec *codec)
3658 static struct coef_fw coef0255[] = {
3659 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
3660 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
3661 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
3662 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
3665 static struct coef_fw coef0255_1[] = {
3666 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
3669 static struct coef_fw coef0256[] = {
3670 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
3673 static struct coef_fw coef0233[] = {
3674 WRITE_COEF(0x1b, 0x0c0b),
3675 WRITE_COEF(0x45, 0xc429),
3676 UPDATE_COEF(0x35, 0x4000, 0),
3677 WRITE_COEF(0x06, 0x2104),
3678 WRITE_COEF(0x1a, 0x0001),
3679 WRITE_COEF(0x26, 0x0004),
3680 WRITE_COEF(0x32, 0x42a3),
3683 static struct coef_fw coef0288[] = {
3684 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
3685 UPDATE_COEF(0x50, 0x2000, 0x2000),
3686 UPDATE_COEF(0x56, 0x0006, 0x0006),
3687 UPDATE_COEF(0x66, 0x0008, 0),
3688 UPDATE_COEF(0x67, 0x2000, 0),
3691 static struct coef_fw coef0292[] = {
3692 WRITE_COEF(0x76, 0x000e),
3693 WRITE_COEF(0x6c, 0x2400),
3694 WRITE_COEF(0x18, 0x7308),
3695 WRITE_COEF(0x6b, 0xc429),
3698 static struct coef_fw coef0293[] = {
3699 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
3700 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
3701 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
3702 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
3703 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
3704 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
3707 static struct coef_fw coef0668[] = {
3708 WRITE_COEF(0x15, 0x0d40),
3709 WRITE_COEF(0xb7, 0x802b),
3712 static struct coef_fw coef0225[] = {
3713 UPDATE_COEF(0x4a, 1<<8, 0),
3714 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
3715 UPDATE_COEF(0x63, 3<<14, 3<<14),
3716 UPDATE_COEF(0x4a, 3<<4, 2<<4),
3717 UPDATE_COEF(0x4a, 3<<10, 3<<10),
3718 UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
3719 UPDATE_COEF(0x4a, 3<<10, 0),
3723 switch (codec->core.vendor_id) {
3725 alc_process_coef_fw(codec, coef0255_1);
3726 alc_process_coef_fw(codec, coef0255);
3730 alc_process_coef_fw(codec, coef0256);
3731 alc_process_coef_fw(codec, coef0255);
3735 alc_process_coef_fw(codec, coef0233);
3740 alc_process_coef_fw(codec, coef0288);
3743 alc_process_coef_fw(codec, coef0292);
3746 alc_process_coef_fw(codec, coef0293);
3749 alc_process_coef_fw(codec, coef0668);
3754 alc_process_coef_fw(codec, coef0225);
3757 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
3760 codec_dbg(codec, "Headset jack set to unplugged mode.\n");
3764 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
3767 static struct coef_fw coef0255[] = {
3768 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
3769 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
3772 static struct coef_fw coef0233[] = {
3773 UPDATE_COEF(0x35, 0, 1<<14),
3774 WRITE_COEF(0x06, 0x2100),
3775 WRITE_COEF(0x1a, 0x0021),
3776 WRITE_COEF(0x26, 0x008c),
3779 static struct coef_fw coef0288[] = {
3780 UPDATE_COEF(0x50, 0x2000, 0),
3781 UPDATE_COEF(0x56, 0x0006, 0),
3782 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
3783 UPDATE_COEF(0x66, 0x0008, 0x0008),
3784 UPDATE_COEF(0x67, 0x2000, 0x2000),
3787 static struct coef_fw coef0292[] = {
3788 WRITE_COEF(0x19, 0xa208),
3789 WRITE_COEF(0x2e, 0xacf0),
3792 static struct coef_fw coef0293[] = {
3793 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
3794 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
3795 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
3798 static struct coef_fw coef0688[] = {
3799 WRITE_COEF(0xb7, 0x802b),
3800 WRITE_COEF(0xb5, 0x1040),
3801 UPDATE_COEF(0xc3, 0, 1<<12),
3804 static struct coef_fw coef0225[] = {
3805 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
3806 UPDATE_COEF(0x4a, 3<<4, 2<<4),
3807 UPDATE_COEF(0x63, 3<<14, 0),
3812 switch (codec->core.vendor_id) {
3816 alc_write_coef_idx(codec, 0x45, 0xc489);
3817 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3818 alc_process_coef_fw(codec, coef0255);
3819 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3823 alc_write_coef_idx(codec, 0x45, 0xc429);
3824 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3825 alc_process_coef_fw(codec, coef0233);
3826 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3831 alc_update_coef_idx(codec, 0x4f, 0x000c, 0);
3832 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3833 alc_process_coef_fw(codec, coef0288);
3834 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3837 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3838 alc_process_coef_fw(codec, coef0292);
3841 /* Set to TRS mode */
3842 alc_write_coef_idx(codec, 0x45, 0xc429);
3843 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3844 alc_process_coef_fw(codec, coef0293);
3845 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3848 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
3851 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3852 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3855 alc_write_coef_idx(codec, 0x11, 0x0001);
3856 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3857 alc_process_coef_fw(codec, coef0688);
3858 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3863 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
3864 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3865 alc_process_coef_fw(codec, coef0225);
3866 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3869 codec_dbg(codec, "Headset jack set to mic-in mode.\n");
3872 static void alc_headset_mode_default(struct hda_codec *codec)
3874 static struct coef_fw coef0225[] = {
3875 UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
3878 static struct coef_fw coef0255[] = {
3879 WRITE_COEF(0x45, 0xc089),
3880 WRITE_COEF(0x45, 0xc489),
3881 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
3882 WRITE_COEF(0x49, 0x0049),
3885 static struct coef_fw coef0233[] = {
3886 WRITE_COEF(0x06, 0x2100),
3887 WRITE_COEF(0x32, 0x4ea3),
3890 static struct coef_fw coef0288[] = {
3891 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
3892 UPDATE_COEF(0x50, 0x2000, 0x2000),
3893 UPDATE_COEF(0x56, 0x0006, 0x0006),
3894 UPDATE_COEF(0x66, 0x0008, 0),
3895 UPDATE_COEF(0x67, 0x2000, 0),
3898 static struct coef_fw coef0292[] = {
3899 WRITE_COEF(0x76, 0x000e),
3900 WRITE_COEF(0x6c, 0x2400),
3901 WRITE_COEF(0x6b, 0xc429),
3902 WRITE_COEF(0x18, 0x7308),
3905 static struct coef_fw coef0293[] = {
3906 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
3907 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
3908 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
3911 static struct coef_fw coef0688[] = {
3912 WRITE_COEF(0x11, 0x0041),
3913 WRITE_COEF(0x15, 0x0d40),
3914 WRITE_COEF(0xb7, 0x802b),
3918 switch (codec->core.vendor_id) {
3922 alc_process_coef_fw(codec, coef0225);
3927 alc_process_coef_fw(codec, coef0255);
3931 alc_process_coef_fw(codec, coef0233);
3936 alc_process_coef_fw(codec, coef0288);
3939 alc_process_coef_fw(codec, coef0292);
3942 alc_process_coef_fw(codec, coef0293);
3945 alc_process_coef_fw(codec, coef0688);
3948 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
3951 codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
3955 static void alc_headset_mode_ctia(struct hda_codec *codec)
3957 static struct coef_fw coef0255[] = {
3958 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
3959 WRITE_COEF(0x1b, 0x0c2b),
3960 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
3963 static struct coef_fw coef0256[] = {
3964 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
3965 WRITE_COEF(0x1b, 0x0c6b),
3966 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
3969 static struct coef_fw coef0233[] = {
3970 WRITE_COEF(0x45, 0xd429),
3971 WRITE_COEF(0x1b, 0x0c2b),
3972 WRITE_COEF(0x32, 0x4ea3),
3975 static struct coef_fw coef0288[] = {
3976 UPDATE_COEF(0x50, 0x2000, 0x2000),
3977 UPDATE_COEF(0x56, 0x0006, 0x0006),
3978 UPDATE_COEF(0x66, 0x0008, 0),
3979 UPDATE_COEF(0x67, 0x2000, 0),
3982 static struct coef_fw coef0292[] = {
3983 WRITE_COEF(0x6b, 0xd429),
3984 WRITE_COEF(0x76, 0x0008),
3985 WRITE_COEF(0x18, 0x7388),
3988 static struct coef_fw coef0293[] = {
3989 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
3990 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
3993 static struct coef_fw coef0688[] = {
3994 WRITE_COEF(0x11, 0x0001),
3995 WRITE_COEF(0x15, 0x0d60),
3996 WRITE_COEF(0xc3, 0x0000),
3999 static struct coef_fw coef0225[] = {
4000 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
4001 UPDATE_COEF(0x49, 1<<8, 1<<8),
4002 UPDATE_COEF(0x4a, 7<<6, 7<<6),
4003 UPDATE_COEF(0x4a, 3<<4, 3<<4),
4007 switch (codec->core.vendor_id) {
4009 alc_process_coef_fw(codec, coef0255);
4013 alc_process_coef_fw(codec, coef0256);
4017 alc_process_coef_fw(codec, coef0233);
4020 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);/* Headset output enable */
4021 /* ALC298 jack type setting is the same with ALC286/ALC288 */
4024 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4026 alc_process_coef_fw(codec, coef0288);
4029 alc_process_coef_fw(codec, coef0292);
4032 alc_process_coef_fw(codec, coef0293);
4035 alc_process_coef_fw(codec, coef0688);
4040 alc_process_coef_fw(codec, coef0225);
4043 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4046 codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
4050 static void alc_headset_mode_omtp(struct hda_codec *codec)
4052 static struct coef_fw coef0255[] = {
4053 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
4054 WRITE_COEF(0x1b, 0x0c2b),
4055 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4058 static struct coef_fw coef0256[] = {
4059 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
4060 WRITE_COEF(0x1b, 0x0c6b),
4061 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4064 static struct coef_fw coef0233[] = {
4065 WRITE_COEF(0x45, 0xe429),
4066 WRITE_COEF(0x1b, 0x0c2b),
4067 WRITE_COEF(0x32, 0x4ea3),
4070 static struct coef_fw coef0288[] = {
4071 UPDATE_COEF(0x50, 0x2000, 0x2000),
4072 UPDATE_COEF(0x56, 0x0006, 0x0006),
4073 UPDATE_COEF(0x66, 0x0008, 0),
4074 UPDATE_COEF(0x67, 0x2000, 0),
4077 static struct coef_fw coef0292[] = {
4078 WRITE_COEF(0x6b, 0xe429),
4079 WRITE_COEF(0x76, 0x0008),
4080 WRITE_COEF(0x18, 0x7388),
4083 static struct coef_fw coef0293[] = {
4084 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
4085 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
4088 static struct coef_fw coef0688[] = {
4089 WRITE_COEF(0x11, 0x0001),
4090 WRITE_COEF(0x15, 0x0d50),
4091 WRITE_COEF(0xc3, 0x0000),
4094 static struct coef_fw coef0225[] = {
4095 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
4096 UPDATE_COEF(0x49, 1<<8, 1<<8),
4097 UPDATE_COEF(0x4a, 7<<6, 7<<6),
4098 UPDATE_COEF(0x4a, 3<<4, 3<<4),
4102 switch (codec->core.vendor_id) {
4104 alc_process_coef_fw(codec, coef0255);
4108 alc_process_coef_fw(codec, coef0256);
4112 alc_process_coef_fw(codec, coef0233);
4115 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
4116 /* ALC298 jack type setting is the same with ALC286/ALC288 */
4119 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
4121 alc_process_coef_fw(codec, coef0288);
4124 alc_process_coef_fw(codec, coef0292);
4127 alc_process_coef_fw(codec, coef0293);
4130 alc_process_coef_fw(codec, coef0688);
4135 alc_process_coef_fw(codec, coef0225);
4138 codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
4141 static void alc_determine_headset_type(struct hda_codec *codec)
4144 bool is_ctia = false;
4145 struct alc_spec *spec = codec->spec;
4146 static struct coef_fw coef0255[] = {
4147 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
4148 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
4152 static struct coef_fw coef0288[] = {
4153 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
4156 static struct coef_fw coef0293[] = {
4157 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
4158 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
4161 static struct coef_fw coef0688[] = {
4162 WRITE_COEF(0x11, 0x0001),
4163 WRITE_COEF(0xb7, 0x802b),
4164 WRITE_COEF(0x15, 0x0d60),
4165 WRITE_COEF(0xc3, 0x0c00),
4168 static struct coef_fw coef0225[] = {
4169 UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4170 UPDATE_COEF(0x49, 1<<8, 1<<8),
4174 switch (codec->core.vendor_id) {
4178 alc_process_coef_fw(codec, coef0255);
4180 val = alc_read_coef_idx(codec, 0x46);
4181 is_ctia = (val & 0x0070) == 0x0070;
4185 alc_write_coef_idx(codec, 0x45, 0xd029);
4187 val = alc_read_coef_idx(codec, 0x46);
4188 is_ctia = (val & 0x0070) == 0x0070;
4191 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); /* Headset output enable */
4192 /* ALC298 check jack type is the same with ALC286/ALC288 */
4195 alc_process_coef_fw(codec, coef0288);
4197 val = alc_read_coef_idx(codec, 0x50);
4198 is_ctia = (val & 0x0070) == 0x0070;
4201 alc_write_coef_idx(codec, 0x6b, 0xd429);
4203 val = alc_read_coef_idx(codec, 0x6c);
4204 is_ctia = (val & 0x001c) == 0x001c;
4207 alc_process_coef_fw(codec, coef0293);
4209 val = alc_read_coef_idx(codec, 0x46);
4210 is_ctia = (val & 0x0070) == 0x0070;
4213 alc_process_coef_fw(codec, coef0688);
4215 val = alc_read_coef_idx(codec, 0xbe);
4216 is_ctia = (val & 0x1c02) == 0x1c02;
4221 alc_process_coef_fw(codec, coef0225);
4223 val = alc_read_coef_idx(codec, 0x46);
4224 is_ctia = (val & 0x00f0) == 0x00f0;
4231 codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
4232 is_ctia ? "yes" : "no");
4233 spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
4236 static void alc_update_headset_mode(struct hda_codec *codec)
4238 struct alc_spec *spec = codec->spec;
4240 hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
4241 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
4243 int new_headset_mode;
4245 if (!snd_hda_jack_detect(codec, hp_pin))
4246 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
4247 else if (mux_pin == spec->headset_mic_pin)
4248 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
4249 else if (mux_pin == spec->headphone_mic_pin)
4250 new_headset_mode = ALC_HEADSET_MODE_MIC;
4252 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
4254 if (new_headset_mode == spec->current_headset_mode) {
4255 snd_hda_gen_update_outputs(codec);
4259 switch (new_headset_mode) {
4260 case ALC_HEADSET_MODE_UNPLUGGED:
4261 alc_headset_mode_unplugged(codec);
4262 spec->gen.hp_jack_present = false;
4264 case ALC_HEADSET_MODE_HEADSET:
4265 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
4266 alc_determine_headset_type(codec);
4267 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
4268 alc_headset_mode_ctia(codec);
4269 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
4270 alc_headset_mode_omtp(codec);
4271 spec->gen.hp_jack_present = true;
4273 case ALC_HEADSET_MODE_MIC:
4274 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
4275 spec->gen.hp_jack_present = false;
4277 case ALC_HEADSET_MODE_HEADPHONE:
4278 alc_headset_mode_default(codec);
4279 spec->gen.hp_jack_present = true;
4282 if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
4283 snd_hda_set_pin_ctl_cache(codec, hp_pin,
4284 AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
4285 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
4286 snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
4289 spec->current_headset_mode = new_headset_mode;
4291 snd_hda_gen_update_outputs(codec);
4294 static void alc_update_headset_mode_hook(struct hda_codec *codec,
4295 struct snd_kcontrol *kcontrol,
4296 struct snd_ctl_elem_value *ucontrol)
4298 alc_update_headset_mode(codec);
4301 static void alc_update_headset_jack_cb(struct hda_codec *codec,
4302 struct hda_jack_callback *jack)
4304 struct alc_spec *spec = codec->spec;
4305 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
4306 snd_hda_gen_hp_automute(codec, jack);
4307 alc_update_headset_mode(codec);
4310 static void alc_probe_headset_mode(struct hda_codec *codec)
4313 struct alc_spec *spec = codec->spec;
4314 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
4317 for (i = 0; i < cfg->num_inputs; i++) {
4318 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
4319 spec->headset_mic_pin = cfg->inputs[i].pin;
4320 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
4321 spec->headphone_mic_pin = cfg->inputs[i].pin;
4324 spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
4325 spec->gen.automute_hook = alc_update_headset_mode;
4326 spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
4329 static void alc_fixup_headset_mode(struct hda_codec *codec,
4330 const struct hda_fixup *fix, int action)
4332 struct alc_spec *spec = codec->spec;
4335 case HDA_FIXUP_ACT_PRE_PROBE:
4336 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
4338 case HDA_FIXUP_ACT_PROBE:
4339 alc_probe_headset_mode(codec);
4341 case HDA_FIXUP_ACT_INIT:
4342 spec->current_headset_mode = 0;
4343 alc_update_headset_mode(codec);
4348 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
4349 const struct hda_fixup *fix, int action)
4351 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4352 struct alc_spec *spec = codec->spec;
4353 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4356 alc_fixup_headset_mode(codec, fix, action);
4359 static void alc255_set_default_jack_type(struct hda_codec *codec)
4361 /* Set to iphone type */
4362 static struct coef_fw alc255fw[] = {
4363 WRITE_COEF(0x1b, 0x880b),
4364 WRITE_COEF(0x45, 0xd089),
4365 WRITE_COEF(0x1b, 0x080b),
4366 WRITE_COEF(0x46, 0x0004),
4367 WRITE_COEF(0x1b, 0x0c0b),
4370 static struct coef_fw alc256fw[] = {
4371 WRITE_COEF(0x1b, 0x884b),
4372 WRITE_COEF(0x45, 0xd089),
4373 WRITE_COEF(0x1b, 0x084b),
4374 WRITE_COEF(0x46, 0x0004),
4375 WRITE_COEF(0x1b, 0x0c4b),
4378 switch (codec->core.vendor_id) {
4380 alc_process_coef_fw(codec, alc255fw);
4384 alc_process_coef_fw(codec, alc256fw);
4390 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
4391 const struct hda_fixup *fix, int action)
4393 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4394 alc255_set_default_jack_type(codec);
4396 alc_fixup_headset_mode(codec, fix, action);
4399 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
4400 const struct hda_fixup *fix, int action)
4402 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4403 struct alc_spec *spec = codec->spec;
4404 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4405 alc255_set_default_jack_type(codec);
4408 alc_fixup_headset_mode(codec, fix, action);
4411 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
4412 struct hda_jack_callback *jack)
4414 struct alc_spec *spec = codec->spec;
4417 alc_update_headset_jack_cb(codec, jack);
4418 /* Headset Mic enable or disable, only for Dell Dino */
4419 present = spec->gen.hp_jack_present ? 0x40 : 0;
4420 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
4424 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
4425 const struct hda_fixup *fix, int action)
4427 alc_fixup_headset_mode(codec, fix, action);
4428 if (action == HDA_FIXUP_ACT_PROBE) {
4429 struct alc_spec *spec = codec->spec;
4430 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
4434 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
4435 const struct hda_fixup *fix, int action)
4437 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4438 struct alc_spec *spec = codec->spec;
4439 spec->gen.auto_mute_via_amp = 1;
4443 static void alc_no_shutup(struct hda_codec *codec)
4447 static void alc_fixup_no_shutup(struct hda_codec *codec,
4448 const struct hda_fixup *fix, int action)
4450 if (action == HDA_FIXUP_ACT_PROBE) {
4451 struct alc_spec *spec = codec->spec;
4452 spec->shutup = alc_no_shutup;
4456 static void alc_fixup_disable_aamix(struct hda_codec *codec,
4457 const struct hda_fixup *fix, int action)
4459 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4460 struct alc_spec *spec = codec->spec;
4461 /* Disable AA-loopback as it causes white noise */
4462 spec->gen.mixer_nid = 0;
4466 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
4467 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
4468 const struct hda_fixup *fix, int action)
4470 static const struct hda_pintbl pincfgs[] = {
4471 { 0x16, 0x21211010 }, /* dock headphone */
4472 { 0x19, 0x21a11010 }, /* dock mic */
4475 struct alc_spec *spec = codec->spec;
4477 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4478 spec->reboot_notify = snd_hda_gen_reboot_notify; /* reduce noise */
4479 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4480 codec->power_save_node = 0; /* avoid click noises */
4481 snd_hda_apply_pincfgs(codec, pincfgs);
4485 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
4486 const struct hda_fixup *fix, int action)
4488 static const struct hda_pintbl pincfgs[] = {
4489 { 0x17, 0x21211010 }, /* dock headphone */
4490 { 0x19, 0x21a11010 }, /* dock mic */
4493 /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
4494 * the speaker output becomes too low by some reason on Thinkpads with
4497 static hda_nid_t preferred_pairs[] = {
4498 0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
4501 struct alc_spec *spec = codec->spec;
4503 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4504 spec->gen.preferred_dacs = preferred_pairs;
4505 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4506 snd_hda_apply_pincfgs(codec, pincfgs);
4507 } else if (action == HDA_FIXUP_ACT_INIT) {
4508 /* Enable DOCK device */
4509 snd_hda_codec_write(codec, 0x17, 0,
4510 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
4511 /* Enable DOCK device */
4512 snd_hda_codec_write(codec, 0x19, 0,
4513 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
4517 static void alc_shutup_dell_xps13(struct hda_codec *codec)
4519 struct alc_spec *spec = codec->spec;
4520 int hp_pin = spec->gen.autocfg.hp_pins[0];
4522 /* Prevent pop noises when headphones are plugged in */
4523 snd_hda_codec_write(codec, hp_pin, 0,
4524 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
4528 static void alc_fixup_dell_xps13(struct hda_codec *codec,
4529 const struct hda_fixup *fix, int action)
4531 struct alc_spec *spec = codec->spec;
4532 struct hda_input_mux *imux = &spec->gen.input_mux;
4536 case HDA_FIXUP_ACT_PRE_PROBE:
4537 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
4538 * it causes a click noise at start up
4540 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
4542 case HDA_FIXUP_ACT_PROBE:
4543 spec->shutup = alc_shutup_dell_xps13;
4545 /* Make the internal mic the default input source. */
4546 for (i = 0; i < imux->num_items; i++) {
4547 if (spec->gen.imux_pins[i] == 0x12) {
4548 spec->gen.cur_mux[0] = i;
4556 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
4557 const struct hda_fixup *fix, int action)
4559 struct alc_spec *spec = codec->spec;
4561 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4562 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4563 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
4565 /* Disable boost for mic-in permanently. (This code is only called
4566 from quirks that guarantee that the headphone is at NID 0x1b.) */
4567 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
4568 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
4570 alc_fixup_headset_mode(codec, fix, action);
4573 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
4574 const struct hda_fixup *fix, int action)
4576 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4577 alc_write_coef_idx(codec, 0xc4, 0x8000);
4578 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
4579 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
4581 alc_fixup_headset_mode(codec, fix, action);
4584 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
4585 static int find_ext_mic_pin(struct hda_codec *codec)
4587 struct alc_spec *spec = codec->spec;
4588 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
4590 unsigned int defcfg;
4593 for (i = 0; i < cfg->num_inputs; i++) {
4594 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4596 nid = cfg->inputs[i].pin;
4597 defcfg = snd_hda_codec_get_pincfg(codec, nid);
4598 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
4606 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
4607 const struct hda_fixup *fix,
4610 struct alc_spec *spec = codec->spec;
4612 if (action == HDA_FIXUP_ACT_PROBE) {
4613 int mic_pin = find_ext_mic_pin(codec);
4614 int hp_pin = spec->gen.autocfg.hp_pins[0];
4616 if (snd_BUG_ON(!mic_pin || !hp_pin))
4618 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
4622 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
4623 const struct hda_fixup *fix,
4626 struct alc_spec *spec = codec->spec;
4627 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
4630 /* The mic boosts on level 2 and 3 are too noisy
4631 on the internal mic input.
4632 Therefore limit the boost to 0 or 1. */
4634 if (action != HDA_FIXUP_ACT_PROBE)
4637 for (i = 0; i < cfg->num_inputs; i++) {
4638 hda_nid_t nid = cfg->inputs[i].pin;
4639 unsigned int defcfg;
4640 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4642 defcfg = snd_hda_codec_get_pincfg(codec, nid);
4643 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
4646 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
4647 (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
4648 (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4649 (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
4650 (0 << AC_AMPCAP_MUTE_SHIFT));
4654 static void alc283_hp_automute_hook(struct hda_codec *codec,
4655 struct hda_jack_callback *jack)
4657 struct alc_spec *spec = codec->spec;
4661 snd_hda_gen_hp_automute(codec, jack);
4663 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4666 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4670 static void alc283_fixup_chromebook(struct hda_codec *codec,
4671 const struct hda_fixup *fix, int action)
4673 struct alc_spec *spec = codec->spec;
4676 case HDA_FIXUP_ACT_PRE_PROBE:
4677 snd_hda_override_wcaps(codec, 0x03, 0);
4678 /* Disable AA-loopback as it causes white noise */
4679 spec->gen.mixer_nid = 0;
4681 case HDA_FIXUP_ACT_INIT:
4682 /* MIC2-VREF control */
4683 /* Set to manual mode */
4684 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
4685 /* Enable Line1 input control by verb */
4686 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
4691 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
4692 const struct hda_fixup *fix, int action)
4694 struct alc_spec *spec = codec->spec;
4697 case HDA_FIXUP_ACT_PRE_PROBE:
4698 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
4700 case HDA_FIXUP_ACT_INIT:
4701 /* MIC2-VREF control */
4702 /* Set to manual mode */
4703 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
4708 /* mute tablet speaker pin (0x14) via dock plugging in addition */
4709 static void asus_tx300_automute(struct hda_codec *codec)
4711 struct alc_spec *spec = codec->spec;
4712 snd_hda_gen_update_outputs(codec);
4713 if (snd_hda_jack_detect(codec, 0x1b))
4714 spec->gen.mute_bits |= (1ULL << 0x14);
4717 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
4718 const struct hda_fixup *fix, int action)
4720 struct alc_spec *spec = codec->spec;
4721 /* TX300 needs to set up GPIO2 for the speaker amp */
4722 static const struct hda_verb gpio2_verbs[] = {
4723 { 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },
4724 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },
4725 { 0x01, AC_VERB_SET_GPIO_DATA, 0x04 },
4728 static const struct hda_pintbl dock_pins[] = {
4729 { 0x1b, 0x21114000 }, /* dock speaker pin */
4732 struct snd_kcontrol *kctl;
4735 case HDA_FIXUP_ACT_PRE_PROBE:
4736 snd_hda_add_verbs(codec, gpio2_verbs);
4737 snd_hda_apply_pincfgs(codec, dock_pins);
4738 spec->gen.auto_mute_via_amp = 1;
4739 spec->gen.automute_hook = asus_tx300_automute;
4740 snd_hda_jack_detect_enable_callback(codec, 0x1b,
4741 snd_hda_gen_hp_automute);
4743 case HDA_FIXUP_ACT_BUILD:
4744 /* this is a bit tricky; give more sane names for the main
4745 * (tablet) speaker and the dock speaker, respectively
4747 kctl = snd_hda_find_mixer_ctl(codec, "Speaker Playback Switch");
4749 strcpy(kctl->id.name, "Dock Speaker Playback Switch");
4750 kctl = snd_hda_find_mixer_ctl(codec, "Bass Speaker Playback Switch");
4752 strcpy(kctl->id.name, "Speaker Playback Switch");
4757 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
4758 const struct hda_fixup *fix, int action)
4760 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4761 /* DAC node 0x03 is giving mono output. We therefore want to
4762 make sure 0x14 (front speaker) and 0x15 (headphones) use the
4763 stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
4764 hda_nid_t conn1[2] = { 0x0c };
4765 snd_hda_override_conn_list(codec, 0x14, 1, conn1);
4766 snd_hda_override_conn_list(codec, 0x15, 1, conn1);
4770 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
4771 const struct hda_fixup *fix, int action)
4773 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4774 /* The speaker is routed to the Node 0x06 by a mistake, as a result
4775 we can't adjust the speaker's volume since this node does not has
4776 Amp-out capability. we change the speaker's route to:
4777 Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
4778 Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
4779 speaker's volume now. */
4781 hda_nid_t conn1[1] = { 0x0c };
4782 snd_hda_override_conn_list(codec, 0x17, 1, conn1);
4786 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
4787 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
4788 const struct hda_fixup *fix, int action)
4790 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4791 hda_nid_t conn[2] = { 0x02, 0x03 };
4792 snd_hda_override_conn_list(codec, 0x17, 2, conn);
4796 /* Hook to update amp GPIO4 for automute */
4797 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
4798 struct hda_jack_callback *jack)
4800 struct alc_spec *spec = codec->spec;
4802 snd_hda_gen_hp_automute(codec, jack);
4803 /* mute_led_polarity is set to 0, so we pass inverted value here */
4804 alc_update_gpio_led(codec, 0x10, !spec->gen.hp_jack_present);
4807 /* Manage GPIOs for HP EliteBook Folio 9480m.
4809 * GPIO4 is the headphone amplifier power control
4810 * GPIO3 is the audio output mute indicator LED
4813 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
4814 const struct hda_fixup *fix,
4817 struct alc_spec *spec = codec->spec;
4818 static const struct hda_verb gpio_init[] = {
4819 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
4820 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
4824 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4825 /* Set the hooks to turn the headphone amp on/off
4828 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
4829 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
4831 /* The GPIOs are currently off */
4834 /* GPIO3 is connected to the output mute LED,
4835 * high is on, low is off
4837 spec->mute_led_polarity = 0;
4838 spec->gpio_mute_led_mask = 0x08;
4840 /* Initialize GPIO configuration */
4841 snd_hda_add_verbs(codec, gpio_init);
4845 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
4846 const struct hda_fixup *fix, int action)
4848 if (action == HDA_FIXUP_ACT_PRE_PROBE)
4849 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
4852 /* for hda_fixup_thinkpad_acpi() */
4853 #include "thinkpad_helper.c"
4855 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
4856 const struct hda_fixup *fix, int action)
4858 alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
4859 hda_fixup_thinkpad_acpi(codec, fix, action);
4862 /* for dell wmi mic mute led */
4863 #include "dell_wmi_helper.c"
4866 ALC269_FIXUP_SONY_VAIO,
4867 ALC275_FIXUP_SONY_VAIO_GPIO2,
4868 ALC269_FIXUP_DELL_M101Z,
4869 ALC269_FIXUP_SKU_IGNORE,
4870 ALC269_FIXUP_ASUS_G73JW,
4871 ALC269_FIXUP_LENOVO_EAPD,
4872 ALC275_FIXUP_SONY_HWEQ,
4873 ALC275_FIXUP_SONY_DISABLE_AAMIX,
4875 ALC269_FIXUP_PCM_44K,
4876 ALC269_FIXUP_STEREO_DMIC,
4877 ALC269_FIXUP_HEADSET_MIC,
4878 ALC269_FIXUP_QUANTA_MUTE,
4879 ALC269_FIXUP_LIFEBOOK,
4880 ALC269_FIXUP_LIFEBOOK_EXTMIC,
4881 ALC269_FIXUP_LIFEBOOK_HP_PIN,
4882 ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
4883 ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
4886 ALC269VB_FIXUP_AMIC,
4887 ALC269VB_FIXUP_DMIC,
4888 ALC269_FIXUP_HP_MUTE_LED,
4889 ALC269_FIXUP_HP_MUTE_LED_MIC1,
4890 ALC269_FIXUP_HP_MUTE_LED_MIC2,
4891 ALC269_FIXUP_HP_GPIO_LED,
4892 ALC269_FIXUP_HP_GPIO_MIC1_LED,
4893 ALC269_FIXUP_HP_LINE1_MIC1_LED,
4894 ALC269_FIXUP_INV_DMIC,
4895 ALC269_FIXUP_LENOVO_DOCK,
4896 ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
4897 ALC269_FIXUP_NO_SHUTUP,
4898 ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
4899 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
4900 ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
4901 ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
4902 ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
4903 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
4904 ALC269_FIXUP_HEADSET_MODE,
4905 ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
4906 ALC269_FIXUP_ASPIRE_HEADSET_MIC,
4907 ALC269_FIXUP_ASUS_X101_FUNC,
4908 ALC269_FIXUP_ASUS_X101_VERB,
4909 ALC269_FIXUP_ASUS_X101,
4910 ALC271_FIXUP_AMIC_MIC2,
4911 ALC271_FIXUP_HP_GATE_MIC_JACK,
4912 ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
4913 ALC269_FIXUP_ACER_AC700,
4914 ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
4915 ALC269VB_FIXUP_ASUS_ZENBOOK,
4916 ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
4917 ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
4918 ALC269VB_FIXUP_ORDISSIMO_EVE2,
4919 ALC283_FIXUP_CHROME_BOOK,
4920 ALC283_FIXUP_SENSE_COMBO_JACK,
4921 ALC282_FIXUP_ASUS_TX300,
4922 ALC283_FIXUP_INT_MIC,
4923 ALC290_FIXUP_MONO_SPEAKERS,
4924 ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
4925 ALC290_FIXUP_SUBWOOFER,
4926 ALC290_FIXUP_SUBWOOFER_HSJACK,
4927 ALC269_FIXUP_THINKPAD_ACPI,
4928 ALC269_FIXUP_DMIC_THINKPAD_ACPI,
4929 ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
4930 ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
4931 ALC255_FIXUP_HEADSET_MODE,
4932 ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
4933 ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
4934 ALC292_FIXUP_TPT440_DOCK,
4935 ALC292_FIXUP_TPT440,
4936 ALC283_FIXUP_HEADSET_MIC,
4937 ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED,
4938 ALC282_FIXUP_ASPIRE_V5_PINS,
4939 ALC280_FIXUP_HP_GPIO4,
4940 ALC286_FIXUP_HP_GPIO_LED,
4941 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
4942 ALC280_FIXUP_HP_DOCK_PINS,
4943 ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
4944 ALC280_FIXUP_HP_9480M,
4945 ALC288_FIXUP_DELL_HEADSET_MODE,
4946 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
4947 ALC288_FIXUP_DELL_XPS_13_GPIO6,
4948 ALC288_FIXUP_DELL_XPS_13,
4949 ALC288_FIXUP_DISABLE_AAMIX,
4950 ALC292_FIXUP_DELL_E7X,
4951 ALC292_FIXUP_DISABLE_AAMIX,
4952 ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
4953 ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
4954 ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
4955 ALC275_FIXUP_DELL_XPS,
4956 ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE,
4957 ALC293_FIXUP_LENOVO_SPK_NOISE,
4958 ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
4959 ALC255_FIXUP_DELL_SPK_NOISE,
4960 ALC225_FIXUP_DISABLE_MIC_VREF,
4961 ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
4962 ALC295_FIXUP_DISABLE_DAC3,
4963 ALC280_FIXUP_HP_HEADSET_MIC,
4964 ALC221_FIXUP_HP_FRONT_MIC,
4965 ALC292_FIXUP_TPT460,
4966 ALC298_FIXUP_SPK_VOLUME,
4967 ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
4968 ALC298_FIXUP_TPT470_DOCK,
4971 static const struct hda_fixup alc269_fixups[] = {
4972 [ALC269_FIXUP_SONY_VAIO] = {
4973 .type = HDA_FIXUP_PINCTLS,
4974 .v.pins = (const struct hda_pintbl[]) {
4975 {0x19, PIN_VREFGRD},
4979 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
4980 .type = HDA_FIXUP_VERBS,
4981 .v.verbs = (const struct hda_verb[]) {
4982 {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
4983 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
4984 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4988 .chain_id = ALC269_FIXUP_SONY_VAIO
4990 [ALC269_FIXUP_DELL_M101Z] = {
4991 .type = HDA_FIXUP_VERBS,
4992 .v.verbs = (const struct hda_verb[]) {
4993 /* Enables internal speaker */
4994 {0x20, AC_VERB_SET_COEF_INDEX, 13},
4995 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
4999 [ALC269_FIXUP_SKU_IGNORE] = {
5000 .type = HDA_FIXUP_FUNC,
5001 .v.func = alc_fixup_sku_ignore,
5003 [ALC269_FIXUP_ASUS_G73JW] = {
5004 .type = HDA_FIXUP_PINS,
5005 .v.pins = (const struct hda_pintbl[]) {
5006 { 0x17, 0x99130111 }, /* subwoofer */
5010 [ALC269_FIXUP_LENOVO_EAPD] = {
5011 .type = HDA_FIXUP_VERBS,
5012 .v.verbs = (const struct hda_verb[]) {
5013 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5017 [ALC275_FIXUP_SONY_HWEQ] = {
5018 .type = HDA_FIXUP_FUNC,
5019 .v.func = alc269_fixup_hweq,
5021 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
5023 [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
5024 .type = HDA_FIXUP_FUNC,
5025 .v.func = alc_fixup_disable_aamix,
5027 .chain_id = ALC269_FIXUP_SONY_VAIO
5029 [ALC271_FIXUP_DMIC] = {
5030 .type = HDA_FIXUP_FUNC,
5031 .v.func = alc271_fixup_dmic,
5033 [ALC269_FIXUP_PCM_44K] = {
5034 .type = HDA_FIXUP_FUNC,
5035 .v.func = alc269_fixup_pcm_44k,
5037 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5039 [ALC269_FIXUP_STEREO_DMIC] = {
5040 .type = HDA_FIXUP_FUNC,
5041 .v.func = alc269_fixup_stereo_dmic,
5043 [ALC269_FIXUP_HEADSET_MIC] = {
5044 .type = HDA_FIXUP_FUNC,
5045 .v.func = alc269_fixup_headset_mic,
5047 [ALC269_FIXUP_QUANTA_MUTE] = {
5048 .type = HDA_FIXUP_FUNC,
5049 .v.func = alc269_fixup_quanta_mute,
5051 [ALC269_FIXUP_LIFEBOOK] = {
5052 .type = HDA_FIXUP_PINS,
5053 .v.pins = (const struct hda_pintbl[]) {
5054 { 0x1a, 0x2101103f }, /* dock line-out */
5055 { 0x1b, 0x23a11040 }, /* dock mic-in */
5059 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5061 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
5062 .type = HDA_FIXUP_PINS,
5063 .v.pins = (const struct hda_pintbl[]) {
5064 { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
5068 [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
5069 .type = HDA_FIXUP_PINS,
5070 .v.pins = (const struct hda_pintbl[]) {
5071 { 0x21, 0x0221102f }, /* HP out */
5075 [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
5076 .type = HDA_FIXUP_FUNC,
5077 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
5079 [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
5080 .type = HDA_FIXUP_FUNC,
5081 .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
5083 [ALC269_FIXUP_AMIC] = {
5084 .type = HDA_FIXUP_PINS,
5085 .v.pins = (const struct hda_pintbl[]) {
5086 { 0x14, 0x99130110 }, /* speaker */
5087 { 0x15, 0x0121401f }, /* HP out */
5088 { 0x18, 0x01a19c20 }, /* mic */
5089 { 0x19, 0x99a3092f }, /* int-mic */
5093 [ALC269_FIXUP_DMIC] = {
5094 .type = HDA_FIXUP_PINS,
5095 .v.pins = (const struct hda_pintbl[]) {
5096 { 0x12, 0x99a3092f }, /* int-mic */
5097 { 0x14, 0x99130110 }, /* speaker */
5098 { 0x15, 0x0121401f }, /* HP out */
5099 { 0x18, 0x01a19c20 }, /* mic */
5103 [ALC269VB_FIXUP_AMIC] = {
5104 .type = HDA_FIXUP_PINS,
5105 .v.pins = (const struct hda_pintbl[]) {
5106 { 0x14, 0x99130110 }, /* speaker */
5107 { 0x18, 0x01a19c20 }, /* mic */
5108 { 0x19, 0x99a3092f }, /* int-mic */
5109 { 0x21, 0x0121401f }, /* HP out */
5113 [ALC269VB_FIXUP_DMIC] = {
5114 .type = HDA_FIXUP_PINS,
5115 .v.pins = (const struct hda_pintbl[]) {
5116 { 0x12, 0x99a3092f }, /* int-mic */
5117 { 0x14, 0x99130110 }, /* speaker */
5118 { 0x18, 0x01a19c20 }, /* mic */
5119 { 0x21, 0x0121401f }, /* HP out */
5123 [ALC269_FIXUP_HP_MUTE_LED] = {
5124 .type = HDA_FIXUP_FUNC,
5125 .v.func = alc269_fixup_hp_mute_led,
5127 [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
5128 .type = HDA_FIXUP_FUNC,
5129 .v.func = alc269_fixup_hp_mute_led_mic1,
5131 [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
5132 .type = HDA_FIXUP_FUNC,
5133 .v.func = alc269_fixup_hp_mute_led_mic2,
5135 [ALC269_FIXUP_HP_GPIO_LED] = {
5136 .type = HDA_FIXUP_FUNC,
5137 .v.func = alc269_fixup_hp_gpio_led,
5139 [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
5140 .type = HDA_FIXUP_FUNC,
5141 .v.func = alc269_fixup_hp_gpio_mic1_led,
5143 [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
5144 .type = HDA_FIXUP_FUNC,
5145 .v.func = alc269_fixup_hp_line1_mic1_led,
5147 [ALC269_FIXUP_INV_DMIC] = {
5148 .type = HDA_FIXUP_FUNC,
5149 .v.func = alc_fixup_inv_dmic,
5151 [ALC269_FIXUP_NO_SHUTUP] = {
5152 .type = HDA_FIXUP_FUNC,
5153 .v.func = alc_fixup_no_shutup,
5155 [ALC269_FIXUP_LENOVO_DOCK] = {
5156 .type = HDA_FIXUP_PINS,
5157 .v.pins = (const struct hda_pintbl[]) {
5158 { 0x19, 0x23a11040 }, /* dock mic */
5159 { 0x1b, 0x2121103f }, /* dock headphone */
5163 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
5165 [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
5166 .type = HDA_FIXUP_FUNC,
5167 .v.func = alc269_fixup_limit_int_mic_boost,
5169 .chain_id = ALC269_FIXUP_LENOVO_DOCK,
5171 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
5172 .type = HDA_FIXUP_FUNC,
5173 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
5175 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
5177 [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5178 .type = HDA_FIXUP_PINS,
5179 .v.pins = (const struct hda_pintbl[]) {
5180 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5181 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5185 .chain_id = ALC269_FIXUP_HEADSET_MODE
5187 [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
5188 .type = HDA_FIXUP_PINS,
5189 .v.pins = (const struct hda_pintbl[]) {
5190 { 0x16, 0x21014020 }, /* dock line out */
5191 { 0x19, 0x21a19030 }, /* dock mic */
5192 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5196 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
5198 [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
5199 .type = HDA_FIXUP_PINS,
5200 .v.pins = (const struct hda_pintbl[]) {
5201 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5205 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
5207 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
5208 .type = HDA_FIXUP_PINS,
5209 .v.pins = (const struct hda_pintbl[]) {
5210 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5211 { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5215 .chain_id = ALC269_FIXUP_HEADSET_MODE
5217 [ALC269_FIXUP_HEADSET_MODE] = {
5218 .type = HDA_FIXUP_FUNC,
5219 .v.func = alc_fixup_headset_mode,
5221 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
5223 [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
5224 .type = HDA_FIXUP_FUNC,
5225 .v.func = alc_fixup_headset_mode_no_hp_mic,
5227 [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
5228 .type = HDA_FIXUP_PINS,
5229 .v.pins = (const struct hda_pintbl[]) {
5230 { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
5234 .chain_id = ALC269_FIXUP_HEADSET_MODE,
5236 [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
5237 .type = HDA_FIXUP_PINS,
5238 .v.pins = (const struct hda_pintbl[]) {
5239 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5243 .chain_id = ALC269_FIXUP_HEADSET_MIC
5245 [ALC269_FIXUP_ASUS_X101_FUNC] = {
5246 .type = HDA_FIXUP_FUNC,
5247 .v.func = alc269_fixup_x101_headset_mic,
5249 [ALC269_FIXUP_ASUS_X101_VERB] = {
5250 .type = HDA_FIXUP_VERBS,
5251 .v.verbs = (const struct hda_verb[]) {
5252 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5253 {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
5254 {0x20, AC_VERB_SET_PROC_COEF, 0x0310},
5258 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
5260 [ALC269_FIXUP_ASUS_X101] = {
5261 .type = HDA_FIXUP_PINS,
5262 .v.pins = (const struct hda_pintbl[]) {
5263 { 0x18, 0x04a1182c }, /* Headset mic */
5267 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
5269 [ALC271_FIXUP_AMIC_MIC2] = {
5270 .type = HDA_FIXUP_PINS,
5271 .v.pins = (const struct hda_pintbl[]) {
5272 { 0x14, 0x99130110 }, /* speaker */
5273 { 0x19, 0x01a19c20 }, /* mic */
5274 { 0x1b, 0x99a7012f }, /* int-mic */
5275 { 0x21, 0x0121401f }, /* HP out */
5279 [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
5280 .type = HDA_FIXUP_FUNC,
5281 .v.func = alc271_hp_gate_mic_jack,
5283 .chain_id = ALC271_FIXUP_AMIC_MIC2,
5285 [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
5286 .type = HDA_FIXUP_FUNC,
5287 .v.func = alc269_fixup_limit_int_mic_boost,
5289 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
5291 [ALC269_FIXUP_ACER_AC700] = {
5292 .type = HDA_FIXUP_PINS,
5293 .v.pins = (const struct hda_pintbl[]) {
5294 { 0x12, 0x99a3092f }, /* int-mic */
5295 { 0x14, 0x99130110 }, /* speaker */
5296 { 0x18, 0x03a11c20 }, /* mic */
5297 { 0x1e, 0x0346101e }, /* SPDIF1 */
5298 { 0x21, 0x0321101f }, /* HP out */
5302 .chain_id = ALC271_FIXUP_DMIC,
5304 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
5305 .type = HDA_FIXUP_FUNC,
5306 .v.func = alc269_fixup_limit_int_mic_boost,
5308 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
5310 [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
5311 .type = HDA_FIXUP_FUNC,
5312 .v.func = alc269_fixup_limit_int_mic_boost,
5314 .chain_id = ALC269VB_FIXUP_DMIC,
5316 [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
5317 .type = HDA_FIXUP_VERBS,
5318 .v.verbs = (const struct hda_verb[]) {
5319 /* class-D output amp +5dB */
5320 { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
5321 { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
5325 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
5327 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
5328 .type = HDA_FIXUP_FUNC,
5329 .v.func = alc269_fixup_limit_int_mic_boost,
5331 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
5333 [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
5334 .type = HDA_FIXUP_PINS,
5335 .v.pins = (const struct hda_pintbl[]) {
5336 { 0x12, 0x99a3092f }, /* int-mic */
5337 { 0x18, 0x03a11d20 }, /* mic */
5338 { 0x19, 0x411111f0 }, /* Unused bogus pin */
5342 [ALC283_FIXUP_CHROME_BOOK] = {
5343 .type = HDA_FIXUP_FUNC,
5344 .v.func = alc283_fixup_chromebook,
5346 [ALC283_FIXUP_SENSE_COMBO_JACK] = {
5347 .type = HDA_FIXUP_FUNC,
5348 .v.func = alc283_fixup_sense_combo_jack,
5350 .chain_id = ALC283_FIXUP_CHROME_BOOK,
5352 [ALC282_FIXUP_ASUS_TX300] = {
5353 .type = HDA_FIXUP_FUNC,
5354 .v.func = alc282_fixup_asus_tx300,
5356 [ALC283_FIXUP_INT_MIC] = {
5357 .type = HDA_FIXUP_VERBS,
5358 .v.verbs = (const struct hda_verb[]) {
5359 {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
5360 {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
5364 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
5366 [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
5367 .type = HDA_FIXUP_PINS,
5368 .v.pins = (const struct hda_pintbl[]) {
5369 { 0x17, 0x90170112 }, /* subwoofer */
5373 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
5375 [ALC290_FIXUP_SUBWOOFER] = {
5376 .type = HDA_FIXUP_PINS,
5377 .v.pins = (const struct hda_pintbl[]) {
5378 { 0x17, 0x90170112 }, /* subwoofer */
5382 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
5384 [ALC290_FIXUP_MONO_SPEAKERS] = {
5385 .type = HDA_FIXUP_FUNC,
5386 .v.func = alc290_fixup_mono_speakers,
5388 [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
5389 .type = HDA_FIXUP_FUNC,
5390 .v.func = alc290_fixup_mono_speakers,
5392 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
5394 [ALC269_FIXUP_THINKPAD_ACPI] = {
5395 .type = HDA_FIXUP_FUNC,
5396 .v.func = alc_fixup_thinkpad_acpi,
5398 .chain_id = ALC269_FIXUP_SKU_IGNORE,
5400 [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
5401 .type = HDA_FIXUP_FUNC,
5402 .v.func = alc_fixup_inv_dmic,
5404 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
5406 [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5407 .type = HDA_FIXUP_PINS,
5408 .v.pins = (const struct hda_pintbl[]) {
5409 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5410 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5414 .chain_id = ALC255_FIXUP_HEADSET_MODE
5416 [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
5417 .type = HDA_FIXUP_PINS,
5418 .v.pins = (const struct hda_pintbl[]) {
5419 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5423 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
5425 [ALC255_FIXUP_HEADSET_MODE] = {
5426 .type = HDA_FIXUP_FUNC,
5427 .v.func = alc_fixup_headset_mode_alc255,
5429 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
5431 [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
5432 .type = HDA_FIXUP_FUNC,
5433 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
5435 [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5436 .type = HDA_FIXUP_PINS,
5437 .v.pins = (const struct hda_pintbl[]) {
5438 { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5439 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5443 .chain_id = ALC269_FIXUP_HEADSET_MODE
5445 [ALC292_FIXUP_TPT440_DOCK] = {
5446 .type = HDA_FIXUP_FUNC,
5447 .v.func = alc_fixup_tpt440_dock,
5449 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
5451 [ALC292_FIXUP_TPT440] = {
5452 .type = HDA_FIXUP_FUNC,
5453 .v.func = alc_fixup_disable_aamix,
5455 .chain_id = ALC292_FIXUP_TPT440_DOCK,
5457 [ALC283_FIXUP_HEADSET_MIC] = {
5458 .type = HDA_FIXUP_PINS,
5459 .v.pins = (const struct hda_pintbl[]) {
5460 { 0x19, 0x04a110f0 },
5464 [ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED] = {
5465 .type = HDA_FIXUP_FUNC,
5466 .v.func = alc_fixup_dell_wmi,
5468 [ALC282_FIXUP_ASPIRE_V5_PINS] = {
5469 .type = HDA_FIXUP_PINS,
5470 .v.pins = (const struct hda_pintbl[]) {
5471 { 0x12, 0x90a60130 },
5472 { 0x14, 0x90170110 },
5473 { 0x17, 0x40000008 },
5474 { 0x18, 0x411111f0 },
5475 { 0x19, 0x01a1913c },
5476 { 0x1a, 0x411111f0 },
5477 { 0x1b, 0x411111f0 },
5478 { 0x1d, 0x40f89b2d },
5479 { 0x1e, 0x411111f0 },
5480 { 0x21, 0x0321101f },
5484 [ALC280_FIXUP_HP_GPIO4] = {
5485 .type = HDA_FIXUP_FUNC,
5486 .v.func = alc280_fixup_hp_gpio4,
5488 [ALC286_FIXUP_HP_GPIO_LED] = {
5489 .type = HDA_FIXUP_FUNC,
5490 .v.func = alc286_fixup_hp_gpio_led,
5492 [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
5493 .type = HDA_FIXUP_FUNC,
5494 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
5496 [ALC280_FIXUP_HP_DOCK_PINS] = {
5497 .type = HDA_FIXUP_PINS,
5498 .v.pins = (const struct hda_pintbl[]) {
5499 { 0x1b, 0x21011020 }, /* line-out */
5500 { 0x1a, 0x01a1903c }, /* headset mic */
5501 { 0x18, 0x2181103f }, /* line-in */
5505 .chain_id = ALC280_FIXUP_HP_GPIO4
5507 [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
5508 .type = HDA_FIXUP_PINS,
5509 .v.pins = (const struct hda_pintbl[]) {
5510 { 0x1b, 0x21011020 }, /* line-out */
5511 { 0x18, 0x2181103f }, /* line-in */
5515 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
5517 [ALC280_FIXUP_HP_9480M] = {
5518 .type = HDA_FIXUP_FUNC,
5519 .v.func = alc280_fixup_hp_9480m,
5521 [ALC288_FIXUP_DELL_HEADSET_MODE] = {
5522 .type = HDA_FIXUP_FUNC,
5523 .v.func = alc_fixup_headset_mode_dell_alc288,
5525 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
5527 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5528 .type = HDA_FIXUP_PINS,
5529 .v.pins = (const struct hda_pintbl[]) {
5530 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5531 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5535 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
5537 [ALC288_FIXUP_DELL_XPS_13_GPIO6] = {
5538 .type = HDA_FIXUP_VERBS,
5539 .v.verbs = (const struct hda_verb[]) {
5540 {0x01, AC_VERB_SET_GPIO_MASK, 0x40},
5541 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x40},
5542 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5546 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
5548 [ALC288_FIXUP_DISABLE_AAMIX] = {
5549 .type = HDA_FIXUP_FUNC,
5550 .v.func = alc_fixup_disable_aamix,
5552 .chain_id = ALC288_FIXUP_DELL_XPS_13_GPIO6
5554 [ALC288_FIXUP_DELL_XPS_13] = {
5555 .type = HDA_FIXUP_FUNC,
5556 .v.func = alc_fixup_dell_xps13,
5558 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
5560 [ALC292_FIXUP_DISABLE_AAMIX] = {
5561 .type = HDA_FIXUP_FUNC,
5562 .v.func = alc_fixup_disable_aamix,
5564 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
5566 [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
5567 .type = HDA_FIXUP_FUNC,
5568 .v.func = alc_fixup_disable_aamix,
5570 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
5572 [ALC292_FIXUP_DELL_E7X] = {
5573 .type = HDA_FIXUP_FUNC,
5574 .v.func = alc_fixup_dell_xps13,
5576 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
5578 [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5579 .type = HDA_FIXUP_PINS,
5580 .v.pins = (const struct hda_pintbl[]) {
5581 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5582 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5586 .chain_id = ALC269_FIXUP_HEADSET_MODE
5588 [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
5589 .type = HDA_FIXUP_PINS,
5590 .v.pins = (const struct hda_pintbl[]) {
5591 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5595 .chain_id = ALC269_FIXUP_HEADSET_MODE
5597 [ALC275_FIXUP_DELL_XPS] = {
5598 .type = HDA_FIXUP_VERBS,
5599 .v.verbs = (const struct hda_verb[]) {
5600 /* Enables internal speaker */
5601 {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
5602 {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
5603 {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
5604 {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
5608 [ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE] = {
5609 .type = HDA_FIXUP_VERBS,
5610 .v.verbs = (const struct hda_verb[]) {
5611 /* Disable pass-through path for FRONT 14h */
5612 {0x20, AC_VERB_SET_COEF_INDEX, 0x36},
5613 {0x20, AC_VERB_SET_PROC_COEF, 0x1737},
5617 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
5619 [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
5620 .type = HDA_FIXUP_FUNC,
5621 .v.func = alc_fixup_disable_aamix,
5623 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
5625 [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
5626 .type = HDA_FIXUP_FUNC,
5627 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
5629 [ALC255_FIXUP_DELL_SPK_NOISE] = {
5630 .type = HDA_FIXUP_FUNC,
5631 .v.func = alc_fixup_disable_aamix,
5633 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
5635 [ALC225_FIXUP_DISABLE_MIC_VREF] = {
5636 .type = HDA_FIXUP_FUNC,
5637 .v.func = alc_fixup_disable_mic_vref,
5639 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
5641 [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5642 .type = HDA_FIXUP_VERBS,
5643 .v.verbs = (const struct hda_verb[]) {
5644 /* Disable pass-through path for FRONT 14h */
5645 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
5646 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
5650 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
5652 [ALC280_FIXUP_HP_HEADSET_MIC] = {
5653 .type = HDA_FIXUP_FUNC,
5654 .v.func = alc_fixup_disable_aamix,
5656 .chain_id = ALC269_FIXUP_HEADSET_MIC,
5658 [ALC221_FIXUP_HP_FRONT_MIC] = {
5659 .type = HDA_FIXUP_PINS,
5660 .v.pins = (const struct hda_pintbl[]) {
5661 { 0x19, 0x02a19020 }, /* Front Mic */
5665 [ALC292_FIXUP_TPT460] = {
5666 .type = HDA_FIXUP_FUNC,
5667 .v.func = alc_fixup_tpt440_dock,
5669 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
5671 [ALC298_FIXUP_SPK_VOLUME] = {
5672 .type = HDA_FIXUP_FUNC,
5673 .v.func = alc298_fixup_speaker_volume,
5675 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
5677 [ALC295_FIXUP_DISABLE_DAC3] = {
5678 .type = HDA_FIXUP_FUNC,
5679 .v.func = alc295_fixup_disable_dac3,
5681 [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
5682 .type = HDA_FIXUP_PINS,
5683 .v.pins = (const struct hda_pintbl[]) {
5684 { 0x1b, 0x90170151 },
5688 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
5690 [ALC298_FIXUP_TPT470_DOCK] = {
5691 .type = HDA_FIXUP_FUNC,
5692 .v.func = alc_fixup_tpt470_dock,
5694 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
5698 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
5699 SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
5700 SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
5701 SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
5702 SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
5703 SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
5704 SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
5705 SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
5706 SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
5707 SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
5708 SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
5709 SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
5710 SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
5711 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
5712 SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
5713 SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
5714 SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
5715 SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
5716 SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
5717 SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
5718 SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
5719 SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
5720 SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
5721 SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
5722 SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
5723 SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
5724 SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
5725 SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
5726 SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5727 SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5728 SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
5729 SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
5730 SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
5731 SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
5732 SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5733 SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5734 SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5735 SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5736 SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5737 SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5738 SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
5739 SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13 9350", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
5740 SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
5741 SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
5742 SND_PCI_QUIRK(0x1028, 0x075b, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
5743 SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
5744 SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
5745 SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
5746 SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
5747 SND_PCI_QUIRK(0x1028, 0x082a, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
5748 SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5749 SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5750 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
5751 SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
5752 SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
5753 SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
5755 SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5756 SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5757 SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5758 SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5759 SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5760 SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5761 SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5762 SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5763 SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5764 SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5765 SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5766 SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5767 SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
5768 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
5769 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
5770 SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5771 SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5772 SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5773 SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5774 SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5775 SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
5776 SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5777 SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5779 SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5780 SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5781 SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5782 SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5783 SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5784 SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5785 SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5786 SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5787 SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5788 SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
5789 SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5790 SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5791 SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5792 SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5793 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5794 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5795 SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5796 SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5797 SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5798 SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5799 SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5800 SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5801 SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5802 SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5803 SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5804 SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5805 SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5806 SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5807 SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5808 SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
5809 SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
5810 SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
5811 SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5812 SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5813 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
5814 SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
5815 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
5816 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
5817 SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
5818 SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5819 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
5820 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
5821 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5822 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5823 SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
5824 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
5825 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5826 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5827 SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
5828 SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
5829 SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
5830 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
5831 SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
5832 SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
5833 SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
5834 SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
5835 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
5836 SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
5837 SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
5838 SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
5839 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
5840 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
5841 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
5842 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
5843 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
5844 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
5845 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
5846 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
5847 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
5848 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
5849 SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
5850 SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
5851 SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
5852 SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
5853 SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
5854 SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
5855 SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
5856 SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5857 SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
5858 SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
5859 SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
5860 SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
5861 SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
5862 SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
5863 SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
5864 SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
5865 SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
5866 SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
5867 SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
5868 SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
5869 SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
5870 SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
5871 SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5872 SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
5873 SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
5874 SND_PCI_QUIRK(0x17aa, 0x3112, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
5875 SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
5876 SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
5877 SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
5878 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
5879 SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5880 SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
5881 SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
5882 SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5883 SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
5884 SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
5885 SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
5886 SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
5887 SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
5888 SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
5889 SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
5890 SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
5891 SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
5892 SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
5893 SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
5894 SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5895 SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
5896 SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
5897 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
5898 SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
5901 /* Below is a quirk table taken from the old code.
5902 * Basically the device should work as is without the fixup table.
5903 * If BIOS doesn't give a proper info, enable the corresponding
5906 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
5908 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
5909 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
5910 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
5911 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
5912 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
5913 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
5914 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
5915 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
5916 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
5917 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
5918 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
5919 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
5920 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
5921 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
5922 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
5923 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
5924 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
5925 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
5926 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
5927 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
5928 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
5929 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
5930 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
5931 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
5932 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
5933 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
5934 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
5935 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
5936 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
5937 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
5938 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
5939 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
5940 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
5941 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
5942 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
5943 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
5944 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
5945 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
5946 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
5951 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
5952 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
5953 SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
5954 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
5955 SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
5959 static const struct hda_model_fixup alc269_fixup_models[] = {
5960 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
5961 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
5962 {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
5963 {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
5964 {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
5965 {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
5966 {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
5967 {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
5968 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
5969 {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
5970 {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
5971 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
5972 {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
5973 {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
5974 {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
5975 {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
5976 {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
5977 {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
5978 {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
5981 #define ALC225_STANDARD_PINS \
5984 #define ALC256_STANDARD_PINS \
5985 {0x12, 0x90a60140}, \
5986 {0x14, 0x90170110}, \
5989 #define ALC282_STANDARD_PINS \
5992 #define ALC290_STANDARD_PINS \
5995 #define ALC292_STANDARD_PINS \
5996 {0x14, 0x90170110}, \
5999 #define ALC295_STANDARD_PINS \
6000 {0x12, 0xb7a60130}, \
6001 {0x14, 0x90170110}, \
6004 #define ALC298_STANDARD_PINS \
6005 {0x12, 0x90a60130}, \
6008 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
6009 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
6010 ALC225_STANDARD_PINS,
6012 {0x14, 0x901701a0}),
6013 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
6014 ALC225_STANDARD_PINS,
6016 {0x14, 0x901701b0}),
6017 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
6018 ALC225_STANDARD_PINS,
6020 {0x14, 0x901701a0}),
6021 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
6022 ALC225_STANDARD_PINS,
6024 {0x14, 0x901701b0}),
6025 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
6026 ALC225_STANDARD_PINS,
6028 {0x1b, 0x90170110}),
6029 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6032 {0x21, 0x02211020}),
6033 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6036 {0x21, 0x02211020}),
6037 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
6039 {0x21, 0x02211020}),
6040 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6042 {0x21, 0x02211040}),
6043 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6046 {0x21, 0x02211020}),
6047 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6050 {0x21, 0x02211030}),
6051 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6054 {0x21, 0x0221101f}),
6055 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6058 {0x21, 0x0221101f}),
6059 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6062 {0x21, 0x0221103f}),
6063 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6066 {0x21, 0x0221103f}),
6067 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6070 {0x21, 0x0221103f}),
6071 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6074 {0x21, 0x0221105f}),
6075 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6078 {0x21, 0x0221101f}),
6079 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6083 {0x21, 0x0321102f}),
6084 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6087 {0x21, 0x02211040}),
6088 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6091 {0x21, 0x02211050}),
6092 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6095 {0x21, 0x02211030}),
6096 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6099 {0x21, 0x02211040}),
6100 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6103 {0x21, 0x02211040}),
6104 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6107 {0x21, 0x02211050}),
6108 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6111 {0x21, 0x02211040}),
6112 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6115 {0x21, 0x02211030}),
6116 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6118 {0x21, 0x02211010}),
6119 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6123 {0x21, 0x0221101f}),
6124 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6127 {0x21, 0x02211030}),
6128 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6131 {0x21, 0x02211030}),
6132 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell Inspiron 5468", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6135 {0x21, 0x02211030}),
6136 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6139 {0x21, 0x02211020}),
6140 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6144 {0x21, 0x0221101f}),
6145 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6146 ALC256_STANDARD_PINS),
6147 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
6151 {0x1a, 0x04a11020}),
6152 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
6158 {0x1b, 0x02011020}),
6159 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6160 ALC282_STANDARD_PINS,
6163 {0x21, 0x0321101f}),
6164 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6165 ALC282_STANDARD_PINS,
6168 {0x21, 0x03211040}),
6169 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6170 ALC282_STANDARD_PINS,
6173 {0x21, 0x03211020}),
6174 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6175 ALC282_STANDARD_PINS,
6178 {0x21, 0x0421101f}),
6179 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
6180 ALC282_STANDARD_PINS,
6183 {0x21, 0x04211020}),
6184 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
6185 ALC282_STANDARD_PINS,
6187 {0x21, 0x0321101f}),
6188 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
6191 {0x21, 0x02211030}),
6192 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
6193 ALC282_STANDARD_PINS,
6196 {0x21, 0x0321101f}),
6197 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL_XPS_13_GPIO6,
6200 {0x21, 0x0321101f}),
6201 SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
6204 {0x21, 0x04211020}),
6205 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6206 ALC290_STANDARD_PINS,
6209 {0x1a, 0x04a11020}),
6210 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6211 ALC290_STANDARD_PINS,
6214 {0x1a, 0x04a11020}),
6215 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6216 ALC290_STANDARD_PINS,
6218 {0x1a, 0x04a11020}),
6219 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6220 ALC290_STANDARD_PINS,
6222 {0x1a, 0x04a11040}),
6223 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6224 ALC290_STANDARD_PINS,
6227 {0x1a, 0x04a11040}),
6228 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6229 ALC290_STANDARD_PINS,
6232 {0x1a, 0x04a11020}),
6233 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
6234 ALC290_STANDARD_PINS,
6237 {0x1a, 0x04a11020}),
6238 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
6239 ALC292_STANDARD_PINS,
6242 {0x19, 0x01a19030}),
6243 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
6244 ALC292_STANDARD_PINS,
6248 {0x19, 0x01a1903e}),
6249 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
6250 ALC292_STANDARD_PINS,
6251 {0x12, 0x90a60140}),
6252 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
6253 ALC292_STANDARD_PINS,
6256 {0x19, 0x21a19030}),
6257 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
6258 ALC292_STANDARD_PINS,
6259 {0x13, 0x90a60140}),
6260 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
6261 ALC295_STANDARD_PINS,
6263 {0x18, 0x21a19030}),
6264 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
6265 ALC295_STANDARD_PINS,
6267 {0x18, 0x21a19050}),
6268 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
6269 ALC295_STANDARD_PINS),
6270 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
6271 ALC298_STANDARD_PINS,
6272 {0x17, 0x90170110}),
6273 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
6274 ALC298_STANDARD_PINS,
6275 {0x17, 0x90170140}),
6276 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
6277 ALC298_STANDARD_PINS,
6278 {0x17, 0x90170150}),
6279 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
6284 {0x21, 0x03211030}),
6285 SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
6286 ALC225_STANDARD_PINS,
6288 {0x17, 0x90170110}),
6292 static void alc269_fill_coef(struct hda_codec *codec)
6294 struct alc_spec *spec = codec->spec;
6297 if (spec->codec_variant != ALC269_TYPE_ALC269VB)
6300 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
6301 alc_write_coef_idx(codec, 0xf, 0x960b);
6302 alc_write_coef_idx(codec, 0xe, 0x8817);
6305 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
6306 alc_write_coef_idx(codec, 0xf, 0x960b);
6307 alc_write_coef_idx(codec, 0xe, 0x8814);
6310 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
6311 /* Power up output pin */
6312 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
6315 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
6316 val = alc_read_coef_idx(codec, 0xd);
6317 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
6318 /* Capless ramp up clock control */
6319 alc_write_coef_idx(codec, 0xd, val | (1<<10));
6321 val = alc_read_coef_idx(codec, 0x17);
6322 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
6323 /* Class D power on reset */
6324 alc_write_coef_idx(codec, 0x17, val | (1<<7));
6329 alc_update_coef_idx(codec, 0x4, 0, 1<<11);
6334 static int patch_alc269(struct hda_codec *codec)
6336 struct alc_spec *spec;
6339 err = alc_alloc_spec(codec, 0x0b);
6344 spec->gen.shared_mic_vref_pin = 0x18;
6345 codec->power_save_node = 0;
6348 codec->patch_ops.suspend = alc269_suspend;
6349 codec->patch_ops.resume = alc269_resume;
6351 spec->shutup = alc269_shutup;
6353 snd_hda_pick_fixup(codec, alc269_fixup_models,
6354 alc269_fixup_tbl, alc269_fixups);
6355 snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups);
6356 snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
6358 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
6360 alc_auto_parse_customize_define(codec);
6362 if (has_cdefine_beep(codec))
6363 spec->gen.beep_nid = 0x01;
6365 switch (codec->core.vendor_id) {
6367 spec->codec_variant = ALC269_TYPE_ALC269VA;
6368 switch (alc_get_coef0(codec) & 0x00f0) {
6370 if (codec->bus->pci &&
6371 codec->bus->pci->subsystem_vendor == 0x1025 &&
6372 spec->cdefine.platform_type == 1)
6373 err = alc_codec_rename(codec, "ALC271X");
6374 spec->codec_variant = ALC269_TYPE_ALC269VB;
6377 if (codec->bus->pci &&
6378 codec->bus->pci->subsystem_vendor == 0x17aa &&
6379 codec->bus->pci->subsystem_device == 0x21f3)
6380 err = alc_codec_rename(codec, "ALC3202");
6381 spec->codec_variant = ALC269_TYPE_ALC269VC;
6384 spec->codec_variant = ALC269_TYPE_ALC269VD;
6387 alc_fix_pll_init(codec, 0x20, 0x04, 15);
6391 spec->init_hook = alc269_fill_coef;
6392 alc269_fill_coef(codec);
6397 spec->codec_variant = ALC269_TYPE_ALC280;
6400 spec->codec_variant = ALC269_TYPE_ALC282;
6401 spec->shutup = alc282_shutup;
6402 spec->init_hook = alc282_init;
6406 spec->codec_variant = ALC269_TYPE_ALC283;
6407 spec->shutup = alc283_shutup;
6408 spec->init_hook = alc283_init;
6412 spec->codec_variant = ALC269_TYPE_ALC284;
6416 spec->codec_variant = ALC269_TYPE_ALC285;
6420 spec->codec_variant = ALC269_TYPE_ALC286;
6421 spec->shutup = alc286_shutup;
6424 spec->codec_variant = ALC269_TYPE_ALC298;
6428 spec->codec_variant = ALC269_TYPE_ALC255;
6432 spec->codec_variant = ALC269_TYPE_ALC256;
6433 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
6434 alc_update_coef_idx(codec, 0x36, 1 << 13, 1 << 5); /* Switch pcbeep path to Line in path*/
6437 spec->codec_variant = ALC269_TYPE_ALC257;
6438 spec->gen.mixer_nid = 0;
6442 spec->codec_variant = ALC269_TYPE_ALC225;
6445 spec->codec_variant = ALC269_TYPE_ALC225;
6446 spec->gen.mixer_nid = 0; /* no loopback on ALC299 */
6451 spec->codec_variant = ALC269_TYPE_ALC294;
6457 spec->codec_variant = ALC269_TYPE_ALC700;
6458 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
6459 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
6464 if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
6465 spec->has_alc5505_dsp = 1;
6466 spec->init_hook = alc5505_dsp_init;
6469 /* automatic parse from the BIOS config */
6470 err = alc269_parse_auto_config(codec);
6474 if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid)
6475 set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
6477 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
6490 static int alc861_parse_auto_config(struct hda_codec *codec)
6492 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
6493 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
6494 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
6497 /* Pin config fixes */
6499 ALC861_FIXUP_FSC_AMILO_PI1505,
6500 ALC861_FIXUP_AMP_VREF_0F,
6501 ALC861_FIXUP_NO_JACK_DETECT,
6502 ALC861_FIXUP_ASUS_A6RP,
6503 ALC660_FIXUP_ASUS_W7J,
6506 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
6507 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
6508 const struct hda_fixup *fix, int action)
6510 struct alc_spec *spec = codec->spec;
6513 if (action != HDA_FIXUP_ACT_INIT)
6515 val = snd_hda_codec_get_pin_target(codec, 0x0f);
6516 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
6517 val |= AC_PINCTL_IN_EN;
6518 val |= AC_PINCTL_VREF_50;
6519 snd_hda_set_pin_ctl(codec, 0x0f, val);
6520 spec->gen.keep_vref_in_automute = 1;
6523 /* suppress the jack-detection */
6524 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
6525 const struct hda_fixup *fix, int action)
6527 if (action == HDA_FIXUP_ACT_PRE_PROBE)
6528 codec->no_jack_detect = 1;
6531 static const struct hda_fixup alc861_fixups[] = {
6532 [ALC861_FIXUP_FSC_AMILO_PI1505] = {
6533 .type = HDA_FIXUP_PINS,
6534 .v.pins = (const struct hda_pintbl[]) {
6535 { 0x0b, 0x0221101f }, /* HP */
6536 { 0x0f, 0x90170310 }, /* speaker */
6540 [ALC861_FIXUP_AMP_VREF_0F] = {
6541 .type = HDA_FIXUP_FUNC,
6542 .v.func = alc861_fixup_asus_amp_vref_0f,
6544 [ALC861_FIXUP_NO_JACK_DETECT] = {
6545 .type = HDA_FIXUP_FUNC,
6546 .v.func = alc_fixup_no_jack_detect,
6548 [ALC861_FIXUP_ASUS_A6RP] = {
6549 .type = HDA_FIXUP_FUNC,
6550 .v.func = alc861_fixup_asus_amp_vref_0f,
6552 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
6554 [ALC660_FIXUP_ASUS_W7J] = {
6555 .type = HDA_FIXUP_VERBS,
6556 .v.verbs = (const struct hda_verb[]) {
6557 /* ASUS W7J needs a magic pin setup on unused NID 0x10
6558 * for enabling outputs
6560 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6566 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
6567 SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
6568 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
6569 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
6570 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
6571 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
6572 SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F),
6573 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
6579 static int patch_alc861(struct hda_codec *codec)
6581 struct alc_spec *spec;
6584 err = alc_alloc_spec(codec, 0x15);
6589 spec->gen.beep_nid = 0x23;
6592 spec->power_hook = alc_power_eapd;
6595 snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
6596 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
6598 /* automatic parse from the BIOS config */
6599 err = alc861_parse_auto_config(codec);
6603 if (!spec->gen.no_analog)
6604 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
6606 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
6620 * In addition, an independent DAC
6622 static int alc861vd_parse_auto_config(struct hda_codec *codec)
6624 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
6625 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
6626 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
6630 ALC660VD_FIX_ASUS_GPIO1,
6631 ALC861VD_FIX_DALLAS,
6634 /* exclude VREF80 */
6635 static void alc861vd_fixup_dallas(struct hda_codec *codec,
6636 const struct hda_fixup *fix, int action)
6638 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6639 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
6640 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
6644 static const struct hda_fixup alc861vd_fixups[] = {
6645 [ALC660VD_FIX_ASUS_GPIO1] = {
6646 .type = HDA_FIXUP_VERBS,
6647 .v.verbs = (const struct hda_verb[]) {
6649 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6650 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6651 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6655 [ALC861VD_FIX_DALLAS] = {
6656 .type = HDA_FIXUP_FUNC,
6657 .v.func = alc861vd_fixup_dallas,
6661 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
6662 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
6663 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
6664 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
6670 static int patch_alc861vd(struct hda_codec *codec)
6672 struct alc_spec *spec;
6675 err = alc_alloc_spec(codec, 0x0b);
6680 spec->gen.beep_nid = 0x23;
6682 spec->shutup = alc_eapd_shutup;
6684 snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
6685 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
6687 /* automatic parse from the BIOS config */
6688 err = alc861vd_parse_auto_config(codec);
6692 if (!spec->gen.no_analog)
6693 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6695 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
6707 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
6708 * configuration. Each pin widget can choose any input DACs and a mixer.
6709 * Each ADC is connected from a mixer of all inputs. This makes possible
6710 * 6-channel independent captures.
6712 * In addition, an independent DAC for the multi-playback (not used in this
6717 * BIOS auto configuration
6720 static int alc662_parse_auto_config(struct hda_codec *codec)
6722 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
6723 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
6724 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
6725 const hda_nid_t *ssids;
6727 if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
6728 codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
6729 codec->core.vendor_id == 0x10ec0671)
6730 ssids = alc663_ssids;
6732 ssids = alc662_ssids;
6733 return alc_parse_auto_config(codec, alc662_ignore, ssids);
6736 static void alc272_fixup_mario(struct hda_codec *codec,
6737 const struct hda_fixup *fix, int action)
6739 if (action != HDA_FIXUP_ACT_PRE_PROBE)
6741 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
6742 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
6743 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
6744 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
6745 (0 << AC_AMPCAP_MUTE_SHIFT)))
6746 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
6749 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
6751 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
6753 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
6754 SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
6758 /* override the 2.1 chmap */
6759 static void alc_fixup_bass_chmap(struct hda_codec *codec,
6760 const struct hda_fixup *fix, int action)
6762 if (action == HDA_FIXUP_ACT_BUILD) {
6763 struct alc_spec *spec = codec->spec;
6764 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
6768 /* avoid D3 for keeping GPIO up */
6769 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
6771 unsigned int power_state)
6773 struct alc_spec *spec = codec->spec;
6774 if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_led)
6779 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
6780 const struct hda_fixup *fix, int action)
6782 struct alc_spec *spec = codec->spec;
6783 static const struct hda_verb gpio_init[] = {
6784 { 0x01, AC_VERB_SET_GPIO_MASK, 0x01 },
6785 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01 },
6789 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6790 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
6792 spec->mute_led_polarity = 1;
6793 spec->gpio_mute_led_mask = 0x01;
6794 snd_hda_add_verbs(codec, gpio_init);
6795 codec->power_filter = gpio_led_power_filter;
6799 static struct coef_fw alc668_coefs[] = {
6800 WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0),
6801 WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80),
6802 WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0),
6803 WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
6804 WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
6805 WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
6806 WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0),
6807 WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418),
6808 WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
6809 WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
6810 WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
6811 WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
6812 WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0),
6813 WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
6814 WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0),
6815 WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040),
6816 WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
6817 WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
6818 WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
6819 WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
6823 static void alc668_restore_default_value(struct hda_codec *codec)
6825 alc_process_coef_fw(codec, alc668_coefs);
6829 ALC662_FIXUP_ASPIRE,
6830 ALC662_FIXUP_LED_GPIO1,
6831 ALC662_FIXUP_IDEAPAD,
6833 ALC662_FIXUP_CZC_P10T,
6834 ALC662_FIXUP_SKU_IGNORE,
6835 ALC662_FIXUP_HP_RP5800,
6836 ALC662_FIXUP_ASUS_MODE1,
6837 ALC662_FIXUP_ASUS_MODE2,
6838 ALC662_FIXUP_ASUS_MODE3,
6839 ALC662_FIXUP_ASUS_MODE4,
6840 ALC662_FIXUP_ASUS_MODE5,
6841 ALC662_FIXUP_ASUS_MODE6,
6842 ALC662_FIXUP_ASUS_MODE7,
6843 ALC662_FIXUP_ASUS_MODE8,
6844 ALC662_FIXUP_NO_JACK_DETECT,
6845 ALC662_FIXUP_ZOTAC_Z68,
6846 ALC662_FIXUP_INV_DMIC,
6847 ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
6848 ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
6849 ALC662_FIXUP_HEADSET_MODE,
6850 ALC668_FIXUP_HEADSET_MODE,
6851 ALC662_FIXUP_BASS_MODE4_CHMAP,
6852 ALC662_FIXUP_BASS_16,
6853 ALC662_FIXUP_BASS_1A,
6854 ALC662_FIXUP_BASS_CHMAP,
6855 ALC668_FIXUP_AUTO_MUTE,
6856 ALC668_FIXUP_DELL_DISABLE_AAMIX,
6857 ALC668_FIXUP_DELL_XPS13,
6858 ALC662_FIXUP_ASUS_Nx50,
6859 ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
6860 ALC668_FIXUP_ASUS_Nx51,
6861 ALC668_FIXUP_MIC_COEF,
6862 ALC668_FIXUP_ASUS_G751,
6863 ALC891_FIXUP_HEADSET_MODE,
6864 ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
6865 ALC662_FIXUP_ACER_VERITON,
6866 ALC892_FIXUP_ASROCK_MOBO,
6869 static const struct hda_fixup alc662_fixups[] = {
6870 [ALC662_FIXUP_ASPIRE] = {
6871 .type = HDA_FIXUP_PINS,
6872 .v.pins = (const struct hda_pintbl[]) {
6873 { 0x15, 0x99130112 }, /* subwoofer */
6877 [ALC662_FIXUP_LED_GPIO1] = {
6878 .type = HDA_FIXUP_FUNC,
6879 .v.func = alc662_fixup_led_gpio1,
6881 [ALC662_FIXUP_IDEAPAD] = {
6882 .type = HDA_FIXUP_PINS,
6883 .v.pins = (const struct hda_pintbl[]) {
6884 { 0x17, 0x99130112 }, /* subwoofer */
6888 .chain_id = ALC662_FIXUP_LED_GPIO1,
6890 [ALC272_FIXUP_MARIO] = {
6891 .type = HDA_FIXUP_FUNC,
6892 .v.func = alc272_fixup_mario,
6894 [ALC662_FIXUP_CZC_P10T] = {
6895 .type = HDA_FIXUP_VERBS,
6896 .v.verbs = (const struct hda_verb[]) {
6897 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
6901 [ALC662_FIXUP_SKU_IGNORE] = {
6902 .type = HDA_FIXUP_FUNC,
6903 .v.func = alc_fixup_sku_ignore,
6905 [ALC662_FIXUP_HP_RP5800] = {
6906 .type = HDA_FIXUP_PINS,
6907 .v.pins = (const struct hda_pintbl[]) {
6908 { 0x14, 0x0221201f }, /* HP out */
6912 .chain_id = ALC662_FIXUP_SKU_IGNORE
6914 [ALC662_FIXUP_ASUS_MODE1] = {
6915 .type = HDA_FIXUP_PINS,
6916 .v.pins = (const struct hda_pintbl[]) {
6917 { 0x14, 0x99130110 }, /* speaker */
6918 { 0x18, 0x01a19c20 }, /* mic */
6919 { 0x19, 0x99a3092f }, /* int-mic */
6920 { 0x21, 0x0121401f }, /* HP out */
6924 .chain_id = ALC662_FIXUP_SKU_IGNORE
6926 [ALC662_FIXUP_ASUS_MODE2] = {
6927 .type = HDA_FIXUP_PINS,
6928 .v.pins = (const struct hda_pintbl[]) {
6929 { 0x14, 0x99130110 }, /* speaker */
6930 { 0x18, 0x01a19820 }, /* mic */
6931 { 0x19, 0x99a3092f }, /* int-mic */
6932 { 0x1b, 0x0121401f }, /* HP out */
6936 .chain_id = ALC662_FIXUP_SKU_IGNORE
6938 [ALC662_FIXUP_ASUS_MODE3] = {
6939 .type = HDA_FIXUP_PINS,
6940 .v.pins = (const struct hda_pintbl[]) {
6941 { 0x14, 0x99130110 }, /* speaker */
6942 { 0x15, 0x0121441f }, /* HP */
6943 { 0x18, 0x01a19840 }, /* mic */
6944 { 0x19, 0x99a3094f }, /* int-mic */
6945 { 0x21, 0x01211420 }, /* HP2 */
6949 .chain_id = ALC662_FIXUP_SKU_IGNORE
6951 [ALC662_FIXUP_ASUS_MODE4] = {
6952 .type = HDA_FIXUP_PINS,
6953 .v.pins = (const struct hda_pintbl[]) {
6954 { 0x14, 0x99130110 }, /* speaker */
6955 { 0x16, 0x99130111 }, /* speaker */
6956 { 0x18, 0x01a19840 }, /* mic */
6957 { 0x19, 0x99a3094f }, /* int-mic */
6958 { 0x21, 0x0121441f }, /* HP */
6962 .chain_id = ALC662_FIXUP_SKU_IGNORE
6964 [ALC662_FIXUP_ASUS_MODE5] = {
6965 .type = HDA_FIXUP_PINS,
6966 .v.pins = (const struct hda_pintbl[]) {
6967 { 0x14, 0x99130110 }, /* speaker */
6968 { 0x15, 0x0121441f }, /* HP */
6969 { 0x16, 0x99130111 }, /* speaker */
6970 { 0x18, 0x01a19840 }, /* mic */
6971 { 0x19, 0x99a3094f }, /* int-mic */
6975 .chain_id = ALC662_FIXUP_SKU_IGNORE
6977 [ALC662_FIXUP_ASUS_MODE6] = {
6978 .type = HDA_FIXUP_PINS,
6979 .v.pins = (const struct hda_pintbl[]) {
6980 { 0x14, 0x99130110 }, /* speaker */
6981 { 0x15, 0x01211420 }, /* HP2 */
6982 { 0x18, 0x01a19840 }, /* mic */
6983 { 0x19, 0x99a3094f }, /* int-mic */
6984 { 0x1b, 0x0121441f }, /* HP */
6988 .chain_id = ALC662_FIXUP_SKU_IGNORE
6990 [ALC662_FIXUP_ASUS_MODE7] = {
6991 .type = HDA_FIXUP_PINS,
6992 .v.pins = (const struct hda_pintbl[]) {
6993 { 0x14, 0x99130110 }, /* speaker */
6994 { 0x17, 0x99130111 }, /* speaker */
6995 { 0x18, 0x01a19840 }, /* mic */
6996 { 0x19, 0x99a3094f }, /* int-mic */
6997 { 0x1b, 0x01214020 }, /* HP */
6998 { 0x21, 0x0121401f }, /* HP */
7002 .chain_id = ALC662_FIXUP_SKU_IGNORE
7004 [ALC662_FIXUP_ASUS_MODE8] = {
7005 .type = HDA_FIXUP_PINS,
7006 .v.pins = (const struct hda_pintbl[]) {
7007 { 0x14, 0x99130110 }, /* speaker */
7008 { 0x12, 0x99a30970 }, /* int-mic */
7009 { 0x15, 0x01214020 }, /* HP */
7010 { 0x17, 0x99130111 }, /* speaker */
7011 { 0x18, 0x01a19840 }, /* mic */
7012 { 0x21, 0x0121401f }, /* HP */
7016 .chain_id = ALC662_FIXUP_SKU_IGNORE
7018 [ALC662_FIXUP_NO_JACK_DETECT] = {
7019 .type = HDA_FIXUP_FUNC,
7020 .v.func = alc_fixup_no_jack_detect,
7022 [ALC662_FIXUP_ZOTAC_Z68] = {
7023 .type = HDA_FIXUP_PINS,
7024 .v.pins = (const struct hda_pintbl[]) {
7025 { 0x1b, 0x02214020 }, /* Front HP */
7029 [ALC662_FIXUP_INV_DMIC] = {
7030 .type = HDA_FIXUP_FUNC,
7031 .v.func = alc_fixup_inv_dmic,
7033 [ALC668_FIXUP_DELL_XPS13] = {
7034 .type = HDA_FIXUP_FUNC,
7035 .v.func = alc_fixup_dell_xps13,
7037 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
7039 [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
7040 .type = HDA_FIXUP_FUNC,
7041 .v.func = alc_fixup_disable_aamix,
7043 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
7045 [ALC668_FIXUP_AUTO_MUTE] = {
7046 .type = HDA_FIXUP_FUNC,
7047 .v.func = alc_fixup_auto_mute_via_amp,
7049 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
7051 [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
7052 .type = HDA_FIXUP_PINS,
7053 .v.pins = (const struct hda_pintbl[]) {
7054 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
7055 /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
7059 .chain_id = ALC662_FIXUP_HEADSET_MODE
7061 [ALC662_FIXUP_HEADSET_MODE] = {
7062 .type = HDA_FIXUP_FUNC,
7063 .v.func = alc_fixup_headset_mode_alc662,
7065 [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
7066 .type = HDA_FIXUP_PINS,
7067 .v.pins = (const struct hda_pintbl[]) {
7068 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
7069 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
7073 .chain_id = ALC668_FIXUP_HEADSET_MODE
7075 [ALC668_FIXUP_HEADSET_MODE] = {
7076 .type = HDA_FIXUP_FUNC,
7077 .v.func = alc_fixup_headset_mode_alc668,
7079 [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
7080 .type = HDA_FIXUP_FUNC,
7081 .v.func = alc_fixup_bass_chmap,
7083 .chain_id = ALC662_FIXUP_ASUS_MODE4
7085 [ALC662_FIXUP_BASS_16] = {
7086 .type = HDA_FIXUP_PINS,
7087 .v.pins = (const struct hda_pintbl[]) {
7088 {0x16, 0x80106111}, /* bass speaker */
7092 .chain_id = ALC662_FIXUP_BASS_CHMAP,
7094 [ALC662_FIXUP_BASS_1A] = {
7095 .type = HDA_FIXUP_PINS,
7096 .v.pins = (const struct hda_pintbl[]) {
7097 {0x1a, 0x80106111}, /* bass speaker */
7101 .chain_id = ALC662_FIXUP_BASS_CHMAP,
7103 [ALC662_FIXUP_BASS_CHMAP] = {
7104 .type = HDA_FIXUP_FUNC,
7105 .v.func = alc_fixup_bass_chmap,
7107 [ALC662_FIXUP_ASUS_Nx50] = {
7108 .type = HDA_FIXUP_FUNC,
7109 .v.func = alc_fixup_auto_mute_via_amp,
7111 .chain_id = ALC662_FIXUP_BASS_1A
7113 [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
7114 .type = HDA_FIXUP_FUNC,
7115 .v.func = alc_fixup_headset_mode_alc668,
7116 .chain_id = ALC662_FIXUP_BASS_CHMAP
7118 [ALC668_FIXUP_ASUS_Nx51] = {
7119 .type = HDA_FIXUP_PINS,
7120 .v.pins = (const struct hda_pintbl[]) {
7121 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
7122 { 0x1a, 0x90170151 }, /* bass speaker */
7123 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
7127 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
7129 [ALC668_FIXUP_MIC_COEF] = {
7130 .type = HDA_FIXUP_VERBS,
7131 .v.verbs = (const struct hda_verb[]) {
7132 { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
7133 { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
7137 [ALC668_FIXUP_ASUS_G751] = {
7138 .type = HDA_FIXUP_PINS,
7139 .v.pins = (const struct hda_pintbl[]) {
7140 { 0x16, 0x0421101f }, /* HP */
7144 .chain_id = ALC668_FIXUP_MIC_COEF
7146 [ALC891_FIXUP_HEADSET_MODE] = {
7147 .type = HDA_FIXUP_FUNC,
7148 .v.func = alc_fixup_headset_mode,
7150 [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
7151 .type = HDA_FIXUP_PINS,
7152 .v.pins = (const struct hda_pintbl[]) {
7153 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
7154 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
7158 .chain_id = ALC891_FIXUP_HEADSET_MODE
7160 [ALC662_FIXUP_ACER_VERITON] = {
7161 .type = HDA_FIXUP_PINS,
7162 .v.pins = (const struct hda_pintbl[]) {
7163 { 0x15, 0x50170120 }, /* no internal speaker */
7167 [ALC892_FIXUP_ASROCK_MOBO] = {
7168 .type = HDA_FIXUP_PINS,
7169 .v.pins = (const struct hda_pintbl[]) {
7170 { 0x15, 0x40f000f0 }, /* disabled */
7171 { 0x16, 0x40f000f0 }, /* disabled */
7177 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
7178 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
7179 SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
7180 SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
7181 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
7182 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
7183 SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
7184 SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
7185 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
7186 SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
7187 SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
7188 SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
7189 SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
7190 SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
7191 SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
7192 SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
7193 SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
7194 SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
7195 SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
7196 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
7197 SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
7198 SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
7199 SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
7200 SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
7201 SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
7202 SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
7203 SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
7204 SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
7205 SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
7206 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
7207 SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
7208 SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
7209 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
7210 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
7211 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
7212 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
7213 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
7214 SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
7215 SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
7216 SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
7217 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
7220 /* Below is a quirk table taken from the old code.
7221 * Basically the device should work as is without the fixup table.
7222 * If BIOS doesn't give a proper info, enable the corresponding
7225 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
7226 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
7227 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
7228 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
7229 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
7230 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
7231 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
7232 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
7233 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
7234 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
7235 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
7236 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
7237 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
7238 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
7239 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
7240 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
7241 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
7242 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
7243 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
7244 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
7245 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
7246 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
7247 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
7248 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
7249 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
7250 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
7251 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
7252 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
7253 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
7254 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
7255 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
7256 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
7257 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
7258 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
7259 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
7260 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
7261 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
7262 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
7263 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
7264 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
7265 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
7266 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
7267 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
7268 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
7269 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
7270 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
7271 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
7272 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
7273 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
7274 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
7279 static const struct hda_model_fixup alc662_fixup_models[] = {
7280 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
7281 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
7282 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
7283 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
7284 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
7285 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
7286 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
7287 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
7288 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
7289 {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
7290 {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
7294 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
7295 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
7299 {0x21, 0x01014020}),
7300 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
7304 {0x21, 0x01014020}),
7305 SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
7309 {0x1b, 0x0221401f}),
7310 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
7314 {0x16, 0x03011020}),
7315 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
7319 {0x16, 0x03011020}),
7320 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
7324 {0x16, 0x03011020}),
7325 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
7328 {0x16, 0x03011020}),
7329 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
7332 {0x15, 0x0321101f}),
7338 static int patch_alc662(struct hda_codec *codec)
7340 struct alc_spec *spec;
7343 err = alc_alloc_spec(codec, 0x0b);
7349 spec->shutup = alc_eapd_shutup;
7351 /* handle multiple HPs as is */
7352 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
7354 alc_fix_pll_init(codec, 0x20, 0x04, 15);
7356 switch (codec->core.vendor_id) {
7358 spec->init_hook = alc668_restore_default_value;
7362 snd_hda_pick_fixup(codec, alc662_fixup_models,
7363 alc662_fixup_tbl, alc662_fixups);
7364 snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups);
7365 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
7367 alc_auto_parse_customize_define(codec);
7369 if (has_cdefine_beep(codec))
7370 spec->gen.beep_nid = 0x01;
7372 if ((alc_get_coef0(codec) & (1 << 14)) &&
7373 codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
7374 spec->cdefine.platform_type == 1) {
7375 err = alc_codec_rename(codec, "ALC272X");
7380 /* automatic parse from the BIOS config */
7381 err = alc662_parse_auto_config(codec);
7385 if (!spec->gen.no_analog && spec->gen.beep_nid) {
7386 switch (codec->core.vendor_id) {
7388 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
7394 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
7397 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
7402 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
7415 static int alc680_parse_auto_config(struct hda_codec *codec)
7417 return alc_parse_auto_config(codec, NULL, NULL);
7422 static int patch_alc680(struct hda_codec *codec)
7426 /* ALC680 has no aa-loopback mixer */
7427 err = alc_alloc_spec(codec, 0);
7431 /* automatic parse from the BIOS config */
7432 err = alc680_parse_auto_config(codec);
7444 static const struct hda_device_id snd_hda_id_realtek[] = {
7445 HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
7446 HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
7447 HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
7448 HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
7449 HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
7450 HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
7451 HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
7452 HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
7453 HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
7454 HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
7455 HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
7456 HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
7457 HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
7458 HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
7459 HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
7460 HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
7461 HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
7462 HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
7463 HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
7464 HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
7465 HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
7466 HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
7467 HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
7468 HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
7469 HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
7470 HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
7471 HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
7472 HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
7473 HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
7474 HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
7475 HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
7476 HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
7477 HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
7478 HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
7479 HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
7480 HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
7481 HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
7482 HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
7483 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
7484 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
7485 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
7486 HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
7487 HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
7488 HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
7489 HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
7490 HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
7491 HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
7492 HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
7493 HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
7494 HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
7495 HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
7496 HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
7497 HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
7498 HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
7499 HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
7500 HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
7501 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
7502 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
7503 HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
7504 HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
7505 HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
7506 HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
7507 HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
7508 HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
7509 HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662),
7510 HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
7511 HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
7514 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
7516 MODULE_LICENSE("GPL");
7517 MODULE_DESCRIPTION("Realtek HD-audio codec");
7519 static struct hda_codec_driver realtek_driver = {
7520 .id = snd_hda_id_realtek,
7523 module_hda_codec_driver(realtek_driver);