1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Universal Interface for Intel High Definition Audio Codec
5 * HD audio interface patch for Realtek ALC codecs
7 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
8 * PeiSen Hou <pshou@realtek.com.tw>
9 * Takashi Iwai <tiwai@suse.de>
10 * Jonathan Woithe <jwoithe@just42.net>
13 #include <linux/init.h>
14 #include <linux/delay.h>
15 #include <linux/slab.h>
16 #include <linux/pci.h>
17 #include <linux/dmi.h>
18 #include <linux/module.h>
19 #include <linux/input.h>
20 #include <sound/core.h>
21 #include <sound/jack.h>
22 #include <sound/hda_codec.h>
23 #include "hda_local.h"
24 #include "hda_auto_parser.h"
26 #include "hda_generic.h"
28 /* keep halting ALC5505 DSP, for power saving */
29 #define HALT_REALTEK_ALC5505
31 /* extra amp-initialization sequence types */
39 ALC_HEADSET_MODE_UNKNOWN,
40 ALC_HEADSET_MODE_UNPLUGGED,
41 ALC_HEADSET_MODE_HEADSET,
43 ALC_HEADSET_MODE_HEADPHONE,
47 ALC_HEADSET_TYPE_UNKNOWN,
48 ALC_HEADSET_TYPE_CTIA,
49 ALC_HEADSET_TYPE_OMTP,
53 ALC_KEY_MICMUTE_INDEX,
56 struct alc_customize_define {
58 unsigned char port_connectivity;
59 unsigned char check_sum;
60 unsigned char customization;
61 unsigned char external_amp;
62 unsigned int enable_pcbeep:1;
63 unsigned int platform_type:1;
65 unsigned int override:1;
66 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */
70 struct hda_gen_spec gen; /* must be at head */
72 /* codec parameterization */
73 struct alc_customize_define cdefine;
74 unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
77 unsigned int gpio_mask;
78 unsigned int gpio_dir;
79 unsigned int gpio_data;
80 bool gpio_write_delay; /* add a delay before writing gpio_data */
82 /* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */
83 int mute_led_polarity;
84 hda_nid_t mute_led_nid;
85 hda_nid_t cap_mute_led_nid;
87 unsigned int gpio_mute_led_mask;
88 unsigned int gpio_mic_led_mask;
90 hda_nid_t headset_mic_pin;
91 hda_nid_t headphone_mic_pin;
92 int current_headset_mode;
93 int current_headset_type;
96 void (*init_hook)(struct hda_codec *codec);
98 void (*power_hook)(struct hda_codec *codec);
100 void (*shutup)(struct hda_codec *codec);
101 void (*reboot_notify)(struct hda_codec *codec);
104 int codec_variant; /* flag for other variants */
105 unsigned int has_alc5505_dsp:1;
106 unsigned int no_depop_delay:1;
107 unsigned int done_hp_init:1;
108 unsigned int no_shutup_pins:1;
109 unsigned int ultra_low_power:1;
113 unsigned int pll_coef_idx, pll_coef_bit;
115 struct input_dev *kb_dev;
116 u8 alc_mute_keycode_map[1];
120 * COEF access helper functions
123 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
124 unsigned int coef_idx)
128 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
129 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
133 #define alc_read_coef_idx(codec, coef_idx) \
134 alc_read_coefex_idx(codec, 0x20, coef_idx)
136 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
137 unsigned int coef_idx, unsigned int coef_val)
139 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
140 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
143 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
144 alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
146 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
147 unsigned int coef_idx, unsigned int mask,
148 unsigned int bits_set)
150 unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);
153 alc_write_coefex_idx(codec, nid, coef_idx,
154 (val & ~mask) | bits_set);
157 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \
158 alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
160 /* a special bypass for COEF 0; read the cached value at the second time */
161 static unsigned int alc_get_coef0(struct hda_codec *codec)
163 struct alc_spec *spec = codec->spec;
166 spec->coef0 = alc_read_coef_idx(codec, 0);
170 /* coef writes/updates batch */
178 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
179 { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
180 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
181 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
182 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
184 static void alc_process_coef_fw(struct hda_codec *codec,
185 const struct coef_fw *fw)
187 for (; fw->nid; fw++) {
188 if (fw->mask == (unsigned short)-1)
189 alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
191 alc_update_coefex_idx(codec, fw->nid, fw->idx,
197 * GPIO setup tables, used in initialization
200 /* Enable GPIO mask and set output */
201 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask)
203 struct alc_spec *spec = codec->spec;
205 spec->gpio_mask |= mask;
206 spec->gpio_dir |= mask;
207 spec->gpio_data |= mask;
210 static void alc_write_gpio_data(struct hda_codec *codec)
212 struct alc_spec *spec = codec->spec;
214 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
218 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask,
221 struct alc_spec *spec = codec->spec;
222 unsigned int oldval = spec->gpio_data;
225 spec->gpio_data |= mask;
227 spec->gpio_data &= ~mask;
228 if (oldval != spec->gpio_data)
229 alc_write_gpio_data(codec);
232 static void alc_write_gpio(struct hda_codec *codec)
234 struct alc_spec *spec = codec->spec;
236 if (!spec->gpio_mask)
239 snd_hda_codec_write(codec, codec->core.afg, 0,
240 AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
241 snd_hda_codec_write(codec, codec->core.afg, 0,
242 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir);
243 if (spec->gpio_write_delay)
245 alc_write_gpio_data(codec);
248 static void alc_fixup_gpio(struct hda_codec *codec, int action,
251 if (action == HDA_FIXUP_ACT_PRE_PROBE)
252 alc_setup_gpio(codec, mask);
255 static void alc_fixup_gpio1(struct hda_codec *codec,
256 const struct hda_fixup *fix, int action)
258 alc_fixup_gpio(codec, action, 0x01);
261 static void alc_fixup_gpio2(struct hda_codec *codec,
262 const struct hda_fixup *fix, int action)
264 alc_fixup_gpio(codec, action, 0x02);
267 static void alc_fixup_gpio3(struct hda_codec *codec,
268 const struct hda_fixup *fix, int action)
270 alc_fixup_gpio(codec, action, 0x03);
273 static void alc_fixup_gpio4(struct hda_codec *codec,
274 const struct hda_fixup *fix, int action)
276 alc_fixup_gpio(codec, action, 0x04);
280 * Fix hardware PLL issue
281 * On some codecs, the analog PLL gating control must be off while
282 * the default value is 1.
284 static void alc_fix_pll(struct hda_codec *codec)
286 struct alc_spec *spec = codec->spec;
289 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
290 1 << spec->pll_coef_bit, 0);
293 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
294 unsigned int coef_idx, unsigned int coef_bit)
296 struct alc_spec *spec = codec->spec;
298 spec->pll_coef_idx = coef_idx;
299 spec->pll_coef_bit = coef_bit;
303 /* update the master volume per volume-knob's unsol event */
304 static void alc_update_knob_master(struct hda_codec *codec,
305 struct hda_jack_callback *jack)
308 struct snd_kcontrol *kctl;
309 struct snd_ctl_elem_value *uctl;
311 kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
314 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
317 val = snd_hda_codec_read(codec, jack->nid, 0,
318 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
319 val &= HDA_AMP_VOLMASK;
320 uctl->value.integer.value[0] = val;
321 uctl->value.integer.value[1] = val;
322 kctl->put(kctl, uctl);
326 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
328 /* For some reason, the res given from ALC880 is broken.
329 Here we adjust it properly. */
330 snd_hda_jack_unsol_event(codec, res >> 2);
333 /* Change EAPD to verb control */
334 static void alc_fill_eapd_coef(struct hda_codec *codec)
338 coef = alc_get_coef0(codec);
340 switch (codec->core.vendor_id) {
342 alc_update_coef_idx(codec, 0x7, 0, 1<<5);
346 alc_update_coef_idx(codec, 0x7, 0, 1<<13);
349 if ((coef & 0x00f0) == 0x0010)
350 alc_update_coef_idx(codec, 0xd, 0, 1<<14);
351 if ((coef & 0x00f0) == 0x0020)
352 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
353 if ((coef & 0x00f0) == 0x0030)
354 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
360 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
365 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
380 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
384 alc_write_coef_idx(codec, 0x36, 0x5757);
385 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
388 alc_update_coef_idx(codec, 0xe, 0, 1<<0);
391 alc_update_coef_idx(codec, 0xa, 1<<13, 0);
400 alc_update_coef_idx(codec, 0x10, 1<<15, 0);
403 if ((coef & 0x00f0) == 0x0030)
404 alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
413 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
417 alc_update_coef_idx(codec, 0x19, 1<<13, 0);
420 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
423 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
426 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
427 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
430 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
437 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
442 /* additional initialization for ALC888 variants */
443 static void alc888_coef_init(struct hda_codec *codec)
445 switch (alc_get_coef0(codec) & 0x00f0) {
450 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
455 /* turn on/off EAPD control (only if available) */
456 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
458 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
460 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
461 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
465 /* turn on/off EAPD controls of the codec */
466 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
468 /* We currently only handle front, HP */
469 static const hda_nid_t pins[] = {
470 0x0f, 0x10, 0x14, 0x15, 0x17, 0
473 for (p = pins; *p; p++)
474 set_eapd(codec, *p, on);
477 static int find_ext_mic_pin(struct hda_codec *codec);
479 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
481 const struct hda_pincfg *pin;
482 int mic_pin = find_ext_mic_pin(codec);
485 /* don't shut up pins when unloading the driver; otherwise it breaks
486 * the default pin setup at the next load of the driver
488 if (codec->bus->shutdown)
491 snd_array_for_each(&codec->init_pins, i, pin) {
492 /* use read here for syncing after issuing each verb */
493 if (pin->nid != mic_pin)
494 snd_hda_codec_read(codec, pin->nid, 0,
495 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
498 codec->pins_shutup = 1;
501 static void alc_shutup_pins(struct hda_codec *codec)
503 struct alc_spec *spec = codec->spec;
505 switch (codec->core.vendor_id) {
510 alc_headset_mic_no_shutup(codec);
513 if (!spec->no_shutup_pins)
514 snd_hda_shutup_pins(codec);
519 /* generic shutup callback;
520 * just turning off EAPD and a little pause for avoiding pop-noise
522 static void alc_eapd_shutup(struct hda_codec *codec)
524 struct alc_spec *spec = codec->spec;
526 alc_auto_setup_eapd(codec, false);
527 if (!spec->no_depop_delay)
529 alc_shutup_pins(codec);
532 /* generic EAPD initialization */
533 static void alc_auto_init_amp(struct hda_codec *codec, int type)
535 alc_auto_setup_eapd(codec, true);
536 alc_write_gpio(codec);
538 case ALC_INIT_DEFAULT:
539 switch (codec->core.vendor_id) {
541 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
547 alc_update_coef_idx(codec, 7, 0, 0x2030);
550 alc888_coef_init(codec);
557 /* get a primary headphone pin if available */
558 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
560 if (spec->gen.autocfg.hp_pins[0])
561 return spec->gen.autocfg.hp_pins[0];
562 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
563 return spec->gen.autocfg.line_out_pins[0];
568 * Realtek SSID verification
571 /* Could be any non-zero and even value. When used as fixup, tells
572 * the driver to ignore any present sku defines.
574 #define ALC_FIXUP_SKU_IGNORE (2)
576 static void alc_fixup_sku_ignore(struct hda_codec *codec,
577 const struct hda_fixup *fix, int action)
579 struct alc_spec *spec = codec->spec;
580 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
581 spec->cdefine.fixup = 1;
582 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
586 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
587 const struct hda_fixup *fix, int action)
589 struct alc_spec *spec = codec->spec;
591 if (action == HDA_FIXUP_ACT_PROBE) {
592 spec->no_depop_delay = 1;
593 codec->depop_delay = 0;
597 static int alc_auto_parse_customize_define(struct hda_codec *codec)
599 unsigned int ass, tmp, i;
601 struct alc_spec *spec = codec->spec;
603 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
605 if (spec->cdefine.fixup) {
606 ass = spec->cdefine.sku_cfg;
607 if (ass == ALC_FIXUP_SKU_IGNORE)
612 if (!codec->bus->pci)
614 ass = codec->core.subsystem_id & 0xffff;
615 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
619 if (codec->core.vendor_id == 0x10ec0260)
621 ass = snd_hda_codec_get_pincfg(codec, nid);
624 codec_info(codec, "%s: SKU not ready 0x%08x\n",
625 codec->core.chip_name, ass);
631 for (i = 1; i < 16; i++) {
635 if (((ass >> 16) & 0xf) != tmp)
638 spec->cdefine.port_connectivity = ass >> 30;
639 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
640 spec->cdefine.check_sum = (ass >> 16) & 0xf;
641 spec->cdefine.customization = ass >> 8;
643 spec->cdefine.sku_cfg = ass;
644 spec->cdefine.external_amp = (ass & 0x38) >> 3;
645 spec->cdefine.platform_type = (ass & 0x4) >> 2;
646 spec->cdefine.swap = (ass & 0x2) >> 1;
647 spec->cdefine.override = ass & 0x1;
649 codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
650 nid, spec->cdefine.sku_cfg);
651 codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
652 spec->cdefine.port_connectivity);
653 codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
654 codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
655 codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
656 codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
657 codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
658 codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
659 codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
664 /* return the position of NID in the list, or -1 if not found */
665 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
668 for (i = 0; i < nums; i++)
673 /* return true if the given NID is found in the list */
674 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
676 return find_idx_in_nid_list(nid, list, nums) >= 0;
679 /* check subsystem ID and set up device-specific initialization;
680 * return 1 if initialized, 0 if invalid SSID
682 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
683 * 31 ~ 16 : Manufacture ID
685 * 7 ~ 0 : Assembly ID
686 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
688 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
690 unsigned int ass, tmp, i;
692 struct alc_spec *spec = codec->spec;
694 if (spec->cdefine.fixup) {
695 ass = spec->cdefine.sku_cfg;
696 if (ass == ALC_FIXUP_SKU_IGNORE)
701 ass = codec->core.subsystem_id & 0xffff;
702 if (codec->bus->pci &&
703 ass != codec->bus->pci->subsystem_device && (ass & 1))
706 /* invalid SSID, check the special NID pin defcfg instead */
708 * 31~30 : port connectivity
711 * 19~16 : Check sum (15:1)
716 if (codec->core.vendor_id == 0x10ec0260)
718 ass = snd_hda_codec_get_pincfg(codec, nid);
720 "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
724 if ((ass >> 30) != 1) /* no physical connection */
729 for (i = 1; i < 16; i++) {
733 if (((ass >> 16) & 0xf) != tmp)
736 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
737 ass & 0xffff, codec->core.vendor_id);
741 * 2 : 0 --> Desktop, 1 --> Laptop
742 * 3~5 : External Amplifier control
745 tmp = (ass & 0x38) >> 3; /* external Amp control */
746 if (spec->init_amp == ALC_INIT_UNDEFINED) {
749 alc_setup_gpio(codec, 0x01);
752 alc_setup_gpio(codec, 0x02);
755 alc_setup_gpio(codec, 0x03);
759 spec->init_amp = ALC_INIT_DEFAULT;
764 /* is laptop or Desktop and enable the function "Mute internal speaker
765 * when the external headphone out jack is plugged"
770 * 10~8 : Jack location
771 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
773 * 15 : 1 --> enable the function "Mute internal speaker
774 * when the external headphone out jack is plugged"
776 if (!alc_get_hp_pin(spec)) {
778 tmp = (ass >> 11) & 0x3; /* HP to chassis */
780 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
781 spec->gen.autocfg.line_outs))
783 spec->gen.autocfg.hp_pins[0] = nid;
788 /* Check the validity of ALC subsystem-id
789 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
790 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
792 if (!alc_subsystem_id(codec, ports)) {
793 struct alc_spec *spec = codec->spec;
795 "realtek: Enable default setup for auto mode as fallback\n");
796 spec->init_amp = ALC_INIT_DEFAULT;
803 static void alc_fixup_inv_dmic(struct hda_codec *codec,
804 const struct hda_fixup *fix, int action)
806 struct alc_spec *spec = codec->spec;
808 spec->gen.inv_dmic_split = 1;
812 static int alc_build_controls(struct hda_codec *codec)
816 err = snd_hda_gen_build_controls(codec);
820 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
829 static void alc_pre_init(struct hda_codec *codec)
831 alc_fill_eapd_coef(codec);
834 #define is_s3_resume(codec) \
835 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
836 #define is_s4_resume(codec) \
837 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
839 static int alc_init(struct hda_codec *codec)
841 struct alc_spec *spec = codec->spec;
843 /* hibernation resume needs the full chip initialization */
844 if (is_s4_resume(codec))
848 spec->init_hook(codec);
850 spec->gen.skip_verbs = 1; /* applied in below */
851 snd_hda_gen_init(codec);
853 alc_auto_init_amp(codec, spec->init_amp);
854 snd_hda_apply_verbs(codec); /* apply verbs here after own init */
856 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
861 static inline void alc_shutup(struct hda_codec *codec)
863 struct alc_spec *spec = codec->spec;
865 if (!snd_hda_get_bool_hint(codec, "shutup"))
866 return; /* disabled explicitly by hints */
868 if (spec && spec->shutup)
871 alc_shutup_pins(codec);
874 static void alc_reboot_notify(struct hda_codec *codec)
876 struct alc_spec *spec = codec->spec;
878 if (spec && spec->reboot_notify)
879 spec->reboot_notify(codec);
884 #define alc_free snd_hda_gen_free
887 static void alc_power_eapd(struct hda_codec *codec)
889 alc_auto_setup_eapd(codec, false);
892 static int alc_suspend(struct hda_codec *codec)
894 struct alc_spec *spec = codec->spec;
896 if (spec && spec->power_hook)
897 spec->power_hook(codec);
903 static int alc_resume(struct hda_codec *codec)
905 struct alc_spec *spec = codec->spec;
907 if (!spec->no_depop_delay)
908 msleep(150); /* to avoid pop noise */
909 codec->patch_ops.init(codec);
910 snd_hda_regmap_sync(codec);
911 hda_call_check_power_status(codec, 0x01);
918 static const struct hda_codec_ops alc_patch_ops = {
919 .build_controls = alc_build_controls,
920 .build_pcms = snd_hda_gen_build_pcms,
923 .unsol_event = snd_hda_jack_unsol_event,
925 .resume = alc_resume,
926 .suspend = alc_suspend,
927 .check_power_status = snd_hda_gen_check_power_status,
929 .reboot_notify = alc_reboot_notify,
933 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
936 * Rename codecs appropriately from COEF value or subvendor id
938 struct alc_codec_rename_table {
939 unsigned int vendor_id;
940 unsigned short coef_mask;
941 unsigned short coef_bits;
945 struct alc_codec_rename_pci_table {
946 unsigned int codec_vendor_id;
947 unsigned short pci_subvendor;
948 unsigned short pci_subdevice;
952 static const struct alc_codec_rename_table rename_tbl[] = {
953 { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
954 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
955 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
956 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
957 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
958 { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
959 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
960 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
961 { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
962 { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
963 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
964 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
965 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
966 { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
967 { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
968 { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
969 { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
973 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = {
974 { 0x10ec0280, 0x1028, 0, "ALC3220" },
975 { 0x10ec0282, 0x1028, 0, "ALC3221" },
976 { 0x10ec0283, 0x1028, 0, "ALC3223" },
977 { 0x10ec0288, 0x1028, 0, "ALC3263" },
978 { 0x10ec0292, 0x1028, 0, "ALC3226" },
979 { 0x10ec0293, 0x1028, 0, "ALC3235" },
980 { 0x10ec0255, 0x1028, 0, "ALC3234" },
981 { 0x10ec0668, 0x1028, 0, "ALC3661" },
982 { 0x10ec0275, 0x1028, 0, "ALC3260" },
983 { 0x10ec0899, 0x1028, 0, "ALC3861" },
984 { 0x10ec0298, 0x1028, 0, "ALC3266" },
985 { 0x10ec0236, 0x1028, 0, "ALC3204" },
986 { 0x10ec0256, 0x1028, 0, "ALC3246" },
987 { 0x10ec0225, 0x1028, 0, "ALC3253" },
988 { 0x10ec0295, 0x1028, 0, "ALC3254" },
989 { 0x10ec0299, 0x1028, 0, "ALC3271" },
990 { 0x10ec0670, 0x1025, 0, "ALC669X" },
991 { 0x10ec0676, 0x1025, 0, "ALC679X" },
992 { 0x10ec0282, 0x1043, 0, "ALC3229" },
993 { 0x10ec0233, 0x1043, 0, "ALC3236" },
994 { 0x10ec0280, 0x103c, 0, "ALC3228" },
995 { 0x10ec0282, 0x103c, 0, "ALC3227" },
996 { 0x10ec0286, 0x103c, 0, "ALC3242" },
997 { 0x10ec0290, 0x103c, 0, "ALC3241" },
998 { 0x10ec0668, 0x103c, 0, "ALC3662" },
999 { 0x10ec0283, 0x17aa, 0, "ALC3239" },
1000 { 0x10ec0292, 0x17aa, 0, "ALC3232" },
1001 { } /* terminator */
1004 static int alc_codec_rename_from_preset(struct hda_codec *codec)
1006 const struct alc_codec_rename_table *p;
1007 const struct alc_codec_rename_pci_table *q;
1009 for (p = rename_tbl; p->vendor_id; p++) {
1010 if (p->vendor_id != codec->core.vendor_id)
1012 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1013 return alc_codec_rename(codec, p->name);
1016 if (!codec->bus->pci)
1018 for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1019 if (q->codec_vendor_id != codec->core.vendor_id)
1021 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1023 if (!q->pci_subdevice ||
1024 q->pci_subdevice == codec->bus->pci->subsystem_device)
1025 return alc_codec_rename(codec, q->name);
1033 * Digital-beep handlers
1035 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1037 /* additional beep mixers; private_value will be overwritten */
1038 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1039 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1040 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1043 /* set up and create beep controls */
1044 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1047 struct snd_kcontrol_new *knew;
1048 unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1051 for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1052 knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1053 &alc_beep_mixer[i]);
1056 knew->private_value = beep_amp;
1061 static const struct snd_pci_quirk beep_white_list[] = {
1062 SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1063 SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1064 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1065 SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1066 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1067 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1068 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1069 SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1070 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1071 /* blacklist -- no beep available */
1072 SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1073 SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1077 static inline int has_cdefine_beep(struct hda_codec *codec)
1079 struct alc_spec *spec = codec->spec;
1080 const struct snd_pci_quirk *q;
1081 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
1084 return spec->cdefine.enable_pcbeep;
1087 #define set_beep_amp(spec, nid, idx, dir) 0
1088 #define has_cdefine_beep(codec) 0
1091 /* parse the BIOS configuration and set up the alc_spec */
1092 /* return 1 if successful, 0 if the proper config is not found,
1093 * or a negative error code
1095 static int alc_parse_auto_config(struct hda_codec *codec,
1096 const hda_nid_t *ignore_nids,
1097 const hda_nid_t *ssid_nids)
1099 struct alc_spec *spec = codec->spec;
1100 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1103 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1109 alc_ssid_check(codec, ssid_nids);
1111 err = snd_hda_gen_parse_auto_config(codec, cfg);
1118 /* common preparation job for alc_spec */
1119 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1121 struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1127 snd_hda_gen_spec_init(&spec->gen);
1128 spec->gen.mixer_nid = mixer_nid;
1129 spec->gen.own_eapd_ctl = 1;
1130 codec->single_adc_amp = 1;
1131 /* FIXME: do we need this for all Realtek codec models? */
1132 codec->spdif_status_reset = 1;
1133 codec->patch_ops = alc_patch_ops;
1135 err = alc_codec_rename_from_preset(codec);
1143 static int alc880_parse_auto_config(struct hda_codec *codec)
1145 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1146 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1147 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1156 ALC880_FIXUP_MEDION_RIM,
1158 ALC880_FIXUP_LG_LW25,
1160 ALC880_FIXUP_EAPD_COEF,
1161 ALC880_FIXUP_TCL_S700,
1162 ALC880_FIXUP_VOL_KNOB,
1163 ALC880_FIXUP_FUJITSU,
1165 ALC880_FIXUP_UNIWILL,
1166 ALC880_FIXUP_UNIWILL_DIG,
1168 ALC880_FIXUP_ASUS_W5A,
1169 ALC880_FIXUP_3ST_BASE,
1171 ALC880_FIXUP_3ST_DIG,
1172 ALC880_FIXUP_5ST_BASE,
1174 ALC880_FIXUP_5ST_DIG,
1175 ALC880_FIXUP_6ST_BASE,
1177 ALC880_FIXUP_6ST_DIG,
1178 ALC880_FIXUP_6ST_AUTOMUTE,
1181 /* enable the volume-knob widget support on NID 0x21 */
1182 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1183 const struct hda_fixup *fix, int action)
1185 if (action == HDA_FIXUP_ACT_PROBE)
1186 snd_hda_jack_detect_enable_callback(codec, 0x21,
1187 alc_update_knob_master);
1190 static const struct hda_fixup alc880_fixups[] = {
1191 [ALC880_FIXUP_GPIO1] = {
1192 .type = HDA_FIXUP_FUNC,
1193 .v.func = alc_fixup_gpio1,
1195 [ALC880_FIXUP_GPIO2] = {
1196 .type = HDA_FIXUP_FUNC,
1197 .v.func = alc_fixup_gpio2,
1199 [ALC880_FIXUP_MEDION_RIM] = {
1200 .type = HDA_FIXUP_VERBS,
1201 .v.verbs = (const struct hda_verb[]) {
1202 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1203 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1207 .chain_id = ALC880_FIXUP_GPIO2,
1209 [ALC880_FIXUP_LG] = {
1210 .type = HDA_FIXUP_PINS,
1211 .v.pins = (const struct hda_pintbl[]) {
1212 /* disable bogus unused pins */
1213 { 0x16, 0x411111f0 },
1214 { 0x18, 0x411111f0 },
1215 { 0x1a, 0x411111f0 },
1219 [ALC880_FIXUP_LG_LW25] = {
1220 .type = HDA_FIXUP_PINS,
1221 .v.pins = (const struct hda_pintbl[]) {
1222 { 0x1a, 0x0181344f }, /* line-in */
1223 { 0x1b, 0x0321403f }, /* headphone */
1227 [ALC880_FIXUP_W810] = {
1228 .type = HDA_FIXUP_PINS,
1229 .v.pins = (const struct hda_pintbl[]) {
1230 /* disable bogus unused pins */
1231 { 0x17, 0x411111f0 },
1235 .chain_id = ALC880_FIXUP_GPIO2,
1237 [ALC880_FIXUP_EAPD_COEF] = {
1238 .type = HDA_FIXUP_VERBS,
1239 .v.verbs = (const struct hda_verb[]) {
1240 /* change to EAPD mode */
1241 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1242 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1246 [ALC880_FIXUP_TCL_S700] = {
1247 .type = HDA_FIXUP_VERBS,
1248 .v.verbs = (const struct hda_verb[]) {
1249 /* change to EAPD mode */
1250 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1251 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
1255 .chain_id = ALC880_FIXUP_GPIO2,
1257 [ALC880_FIXUP_VOL_KNOB] = {
1258 .type = HDA_FIXUP_FUNC,
1259 .v.func = alc880_fixup_vol_knob,
1261 [ALC880_FIXUP_FUJITSU] = {
1262 /* override all pins as BIOS on old Amilo is broken */
1263 .type = HDA_FIXUP_PINS,
1264 .v.pins = (const struct hda_pintbl[]) {
1265 { 0x14, 0x0121401f }, /* HP */
1266 { 0x15, 0x99030120 }, /* speaker */
1267 { 0x16, 0x99030130 }, /* bass speaker */
1268 { 0x17, 0x411111f0 }, /* N/A */
1269 { 0x18, 0x411111f0 }, /* N/A */
1270 { 0x19, 0x01a19950 }, /* mic-in */
1271 { 0x1a, 0x411111f0 }, /* N/A */
1272 { 0x1b, 0x411111f0 }, /* N/A */
1273 { 0x1c, 0x411111f0 }, /* N/A */
1274 { 0x1d, 0x411111f0 }, /* N/A */
1275 { 0x1e, 0x01454140 }, /* SPDIF out */
1279 .chain_id = ALC880_FIXUP_VOL_KNOB,
1281 [ALC880_FIXUP_F1734] = {
1282 /* almost compatible with FUJITSU, but no bass and SPDIF */
1283 .type = HDA_FIXUP_PINS,
1284 .v.pins = (const struct hda_pintbl[]) {
1285 { 0x14, 0x0121401f }, /* HP */
1286 { 0x15, 0x99030120 }, /* speaker */
1287 { 0x16, 0x411111f0 }, /* N/A */
1288 { 0x17, 0x411111f0 }, /* N/A */
1289 { 0x18, 0x411111f0 }, /* N/A */
1290 { 0x19, 0x01a19950 }, /* mic-in */
1291 { 0x1a, 0x411111f0 }, /* N/A */
1292 { 0x1b, 0x411111f0 }, /* N/A */
1293 { 0x1c, 0x411111f0 }, /* N/A */
1294 { 0x1d, 0x411111f0 }, /* N/A */
1295 { 0x1e, 0x411111f0 }, /* N/A */
1299 .chain_id = ALC880_FIXUP_VOL_KNOB,
1301 [ALC880_FIXUP_UNIWILL] = {
1302 /* need to fix HP and speaker pins to be parsed correctly */
1303 .type = HDA_FIXUP_PINS,
1304 .v.pins = (const struct hda_pintbl[]) {
1305 { 0x14, 0x0121411f }, /* HP */
1306 { 0x15, 0x99030120 }, /* speaker */
1307 { 0x16, 0x99030130 }, /* bass speaker */
1311 [ALC880_FIXUP_UNIWILL_DIG] = {
1312 .type = HDA_FIXUP_PINS,
1313 .v.pins = (const struct hda_pintbl[]) {
1314 /* disable bogus unused pins */
1315 { 0x17, 0x411111f0 },
1316 { 0x19, 0x411111f0 },
1317 { 0x1b, 0x411111f0 },
1318 { 0x1f, 0x411111f0 },
1322 [ALC880_FIXUP_Z71V] = {
1323 .type = HDA_FIXUP_PINS,
1324 .v.pins = (const struct hda_pintbl[]) {
1325 /* set up the whole pins as BIOS is utterly broken */
1326 { 0x14, 0x99030120 }, /* speaker */
1327 { 0x15, 0x0121411f }, /* HP */
1328 { 0x16, 0x411111f0 }, /* N/A */
1329 { 0x17, 0x411111f0 }, /* N/A */
1330 { 0x18, 0x01a19950 }, /* mic-in */
1331 { 0x19, 0x411111f0 }, /* N/A */
1332 { 0x1a, 0x01813031 }, /* line-in */
1333 { 0x1b, 0x411111f0 }, /* N/A */
1334 { 0x1c, 0x411111f0 }, /* N/A */
1335 { 0x1d, 0x411111f0 }, /* N/A */
1336 { 0x1e, 0x0144111e }, /* SPDIF */
1340 [ALC880_FIXUP_ASUS_W5A] = {
1341 .type = HDA_FIXUP_PINS,
1342 .v.pins = (const struct hda_pintbl[]) {
1343 /* set up the whole pins as BIOS is utterly broken */
1344 { 0x14, 0x0121411f }, /* HP */
1345 { 0x15, 0x411111f0 }, /* N/A */
1346 { 0x16, 0x411111f0 }, /* N/A */
1347 { 0x17, 0x411111f0 }, /* N/A */
1348 { 0x18, 0x90a60160 }, /* mic */
1349 { 0x19, 0x411111f0 }, /* N/A */
1350 { 0x1a, 0x411111f0 }, /* N/A */
1351 { 0x1b, 0x411111f0 }, /* N/A */
1352 { 0x1c, 0x411111f0 }, /* N/A */
1353 { 0x1d, 0x411111f0 }, /* N/A */
1354 { 0x1e, 0xb743111e }, /* SPDIF out */
1358 .chain_id = ALC880_FIXUP_GPIO1,
1360 [ALC880_FIXUP_3ST_BASE] = {
1361 .type = HDA_FIXUP_PINS,
1362 .v.pins = (const struct hda_pintbl[]) {
1363 { 0x14, 0x01014010 }, /* line-out */
1364 { 0x15, 0x411111f0 }, /* N/A */
1365 { 0x16, 0x411111f0 }, /* N/A */
1366 { 0x17, 0x411111f0 }, /* N/A */
1367 { 0x18, 0x01a19c30 }, /* mic-in */
1368 { 0x19, 0x0121411f }, /* HP */
1369 { 0x1a, 0x01813031 }, /* line-in */
1370 { 0x1b, 0x02a19c40 }, /* front-mic */
1371 { 0x1c, 0x411111f0 }, /* N/A */
1372 { 0x1d, 0x411111f0 }, /* N/A */
1373 /* 0x1e is filled in below */
1374 { 0x1f, 0x411111f0 }, /* N/A */
1378 [ALC880_FIXUP_3ST] = {
1379 .type = HDA_FIXUP_PINS,
1380 .v.pins = (const struct hda_pintbl[]) {
1381 { 0x1e, 0x411111f0 }, /* N/A */
1385 .chain_id = ALC880_FIXUP_3ST_BASE,
1387 [ALC880_FIXUP_3ST_DIG] = {
1388 .type = HDA_FIXUP_PINS,
1389 .v.pins = (const struct hda_pintbl[]) {
1390 { 0x1e, 0x0144111e }, /* SPDIF */
1394 .chain_id = ALC880_FIXUP_3ST_BASE,
1396 [ALC880_FIXUP_5ST_BASE] = {
1397 .type = HDA_FIXUP_PINS,
1398 .v.pins = (const struct hda_pintbl[]) {
1399 { 0x14, 0x01014010 }, /* front */
1400 { 0x15, 0x411111f0 }, /* N/A */
1401 { 0x16, 0x01011411 }, /* CLFE */
1402 { 0x17, 0x01016412 }, /* surr */
1403 { 0x18, 0x01a19c30 }, /* mic-in */
1404 { 0x19, 0x0121411f }, /* HP */
1405 { 0x1a, 0x01813031 }, /* line-in */
1406 { 0x1b, 0x02a19c40 }, /* front-mic */
1407 { 0x1c, 0x411111f0 }, /* N/A */
1408 { 0x1d, 0x411111f0 }, /* N/A */
1409 /* 0x1e is filled in below */
1410 { 0x1f, 0x411111f0 }, /* N/A */
1414 [ALC880_FIXUP_5ST] = {
1415 .type = HDA_FIXUP_PINS,
1416 .v.pins = (const struct hda_pintbl[]) {
1417 { 0x1e, 0x411111f0 }, /* N/A */
1421 .chain_id = ALC880_FIXUP_5ST_BASE,
1423 [ALC880_FIXUP_5ST_DIG] = {
1424 .type = HDA_FIXUP_PINS,
1425 .v.pins = (const struct hda_pintbl[]) {
1426 { 0x1e, 0x0144111e }, /* SPDIF */
1430 .chain_id = ALC880_FIXUP_5ST_BASE,
1432 [ALC880_FIXUP_6ST_BASE] = {
1433 .type = HDA_FIXUP_PINS,
1434 .v.pins = (const struct hda_pintbl[]) {
1435 { 0x14, 0x01014010 }, /* front */
1436 { 0x15, 0x01016412 }, /* surr */
1437 { 0x16, 0x01011411 }, /* CLFE */
1438 { 0x17, 0x01012414 }, /* side */
1439 { 0x18, 0x01a19c30 }, /* mic-in */
1440 { 0x19, 0x02a19c40 }, /* front-mic */
1441 { 0x1a, 0x01813031 }, /* line-in */
1442 { 0x1b, 0x0121411f }, /* HP */
1443 { 0x1c, 0x411111f0 }, /* N/A */
1444 { 0x1d, 0x411111f0 }, /* N/A */
1445 /* 0x1e is filled in below */
1446 { 0x1f, 0x411111f0 }, /* N/A */
1450 [ALC880_FIXUP_6ST] = {
1451 .type = HDA_FIXUP_PINS,
1452 .v.pins = (const struct hda_pintbl[]) {
1453 { 0x1e, 0x411111f0 }, /* N/A */
1457 .chain_id = ALC880_FIXUP_6ST_BASE,
1459 [ALC880_FIXUP_6ST_DIG] = {
1460 .type = HDA_FIXUP_PINS,
1461 .v.pins = (const struct hda_pintbl[]) {
1462 { 0x1e, 0x0144111e }, /* SPDIF */
1466 .chain_id = ALC880_FIXUP_6ST_BASE,
1468 [ALC880_FIXUP_6ST_AUTOMUTE] = {
1469 .type = HDA_FIXUP_PINS,
1470 .v.pins = (const struct hda_pintbl[]) {
1471 { 0x1b, 0x0121401f }, /* HP with jack detect */
1474 .chained_before = true,
1475 .chain_id = ALC880_FIXUP_6ST_BASE,
1479 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1480 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1481 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1482 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1483 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1484 SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1485 SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1486 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1487 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1488 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1489 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1490 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1491 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1492 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1493 SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1494 SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1495 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1496 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1497 SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1498 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1499 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1500 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1501 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1502 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1504 /* Below is the copied entries from alc880_quirks.c.
1505 * It's not quite sure whether BIOS sets the correct pin-config table
1506 * on these machines, thus they are kept to be compatible with
1507 * the old static quirks. Once when it's confirmed to work without
1508 * these overrides, it'd be better to remove.
1510 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1511 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1512 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1513 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1514 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1515 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1516 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1517 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1518 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1519 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1520 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1521 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1522 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1523 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1524 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1525 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1526 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1527 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1528 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1529 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1530 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1531 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1532 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1533 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1534 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1535 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1536 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1537 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1538 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1539 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1540 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1541 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1542 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1544 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1545 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1546 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1550 static const struct hda_model_fixup alc880_fixup_models[] = {
1551 {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1552 {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1553 {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1554 {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1555 {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1556 {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1557 {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1563 * OK, here we have finally the patch for ALC880
1565 static int patch_alc880(struct hda_codec *codec)
1567 struct alc_spec *spec;
1570 err = alc_alloc_spec(codec, 0x0b);
1575 spec->gen.need_dac_fix = 1;
1576 spec->gen.beep_nid = 0x01;
1578 codec->patch_ops.unsol_event = alc880_unsol_event;
1580 alc_pre_init(codec);
1582 snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1584 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1586 /* automatic parse from the BIOS config */
1587 err = alc880_parse_auto_config(codec);
1591 if (!spec->gen.no_analog) {
1592 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1597 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1610 static int alc260_parse_auto_config(struct hda_codec *codec)
1612 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1613 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1614 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1621 ALC260_FIXUP_HP_DC5750,
1622 ALC260_FIXUP_HP_PIN_0F,
1625 ALC260_FIXUP_GPIO1_TOGGLE,
1626 ALC260_FIXUP_REPLACER,
1627 ALC260_FIXUP_HP_B1900,
1629 ALC260_FIXUP_FSC_S7020,
1630 ALC260_FIXUP_FSC_S7020_JWSE,
1631 ALC260_FIXUP_VAIO_PINS,
1634 static void alc260_gpio1_automute(struct hda_codec *codec)
1636 struct alc_spec *spec = codec->spec;
1638 alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1641 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1642 const struct hda_fixup *fix, int action)
1644 struct alc_spec *spec = codec->spec;
1645 if (action == HDA_FIXUP_ACT_PROBE) {
1646 /* although the machine has only one output pin, we need to
1647 * toggle GPIO1 according to the jack state
1649 spec->gen.automute_hook = alc260_gpio1_automute;
1650 spec->gen.detect_hp = 1;
1651 spec->gen.automute_speaker = 1;
1652 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1653 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1654 snd_hda_gen_hp_automute);
1655 alc_setup_gpio(codec, 0x01);
1659 static void alc260_fixup_kn1(struct hda_codec *codec,
1660 const struct hda_fixup *fix, int action)
1662 struct alc_spec *spec = codec->spec;
1663 static const struct hda_pintbl pincfgs[] = {
1664 { 0x0f, 0x02214000 }, /* HP/speaker */
1665 { 0x12, 0x90a60160 }, /* int mic */
1666 { 0x13, 0x02a19000 }, /* ext mic */
1667 { 0x18, 0x01446000 }, /* SPDIF out */
1668 /* disable bogus I/O pins */
1669 { 0x10, 0x411111f0 },
1670 { 0x11, 0x411111f0 },
1671 { 0x14, 0x411111f0 },
1672 { 0x15, 0x411111f0 },
1673 { 0x16, 0x411111f0 },
1674 { 0x17, 0x411111f0 },
1675 { 0x19, 0x411111f0 },
1680 case HDA_FIXUP_ACT_PRE_PROBE:
1681 snd_hda_apply_pincfgs(codec, pincfgs);
1682 spec->init_amp = ALC_INIT_NONE;
1687 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1688 const struct hda_fixup *fix, int action)
1690 struct alc_spec *spec = codec->spec;
1691 if (action == HDA_FIXUP_ACT_PRE_PROBE)
1692 spec->init_amp = ALC_INIT_NONE;
1695 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1696 const struct hda_fixup *fix, int action)
1698 struct alc_spec *spec = codec->spec;
1699 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1700 spec->gen.add_jack_modes = 1;
1701 spec->gen.hp_mic = 1;
1705 static const struct hda_fixup alc260_fixups[] = {
1706 [ALC260_FIXUP_HP_DC5750] = {
1707 .type = HDA_FIXUP_PINS,
1708 .v.pins = (const struct hda_pintbl[]) {
1709 { 0x11, 0x90130110 }, /* speaker */
1713 [ALC260_FIXUP_HP_PIN_0F] = {
1714 .type = HDA_FIXUP_PINS,
1715 .v.pins = (const struct hda_pintbl[]) {
1716 { 0x0f, 0x01214000 }, /* HP */
1720 [ALC260_FIXUP_COEF] = {
1721 .type = HDA_FIXUP_VERBS,
1722 .v.verbs = (const struct hda_verb[]) {
1723 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1724 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 },
1728 [ALC260_FIXUP_GPIO1] = {
1729 .type = HDA_FIXUP_FUNC,
1730 .v.func = alc_fixup_gpio1,
1732 [ALC260_FIXUP_GPIO1_TOGGLE] = {
1733 .type = HDA_FIXUP_FUNC,
1734 .v.func = alc260_fixup_gpio1_toggle,
1736 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1738 [ALC260_FIXUP_REPLACER] = {
1739 .type = HDA_FIXUP_VERBS,
1740 .v.verbs = (const struct hda_verb[]) {
1741 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1742 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 },
1746 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1748 [ALC260_FIXUP_HP_B1900] = {
1749 .type = HDA_FIXUP_FUNC,
1750 .v.func = alc260_fixup_gpio1_toggle,
1752 .chain_id = ALC260_FIXUP_COEF,
1754 [ALC260_FIXUP_KN1] = {
1755 .type = HDA_FIXUP_FUNC,
1756 .v.func = alc260_fixup_kn1,
1758 [ALC260_FIXUP_FSC_S7020] = {
1759 .type = HDA_FIXUP_FUNC,
1760 .v.func = alc260_fixup_fsc_s7020,
1762 [ALC260_FIXUP_FSC_S7020_JWSE] = {
1763 .type = HDA_FIXUP_FUNC,
1764 .v.func = alc260_fixup_fsc_s7020_jwse,
1766 .chain_id = ALC260_FIXUP_FSC_S7020,
1768 [ALC260_FIXUP_VAIO_PINS] = {
1769 .type = HDA_FIXUP_PINS,
1770 .v.pins = (const struct hda_pintbl[]) {
1771 /* Pin configs are missing completely on some VAIOs */
1772 { 0x0f, 0x01211020 },
1773 { 0x10, 0x0001003f },
1774 { 0x11, 0x411111f0 },
1775 { 0x12, 0x01a15930 },
1776 { 0x13, 0x411111f0 },
1777 { 0x14, 0x411111f0 },
1778 { 0x15, 0x411111f0 },
1779 { 0x16, 0x411111f0 },
1780 { 0x17, 0x411111f0 },
1781 { 0x18, 0x411111f0 },
1782 { 0x19, 0x411111f0 },
1788 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1789 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1790 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1791 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1792 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1793 SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1794 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1795 SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1796 SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1797 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1798 SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1799 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1800 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1804 static const struct hda_model_fixup alc260_fixup_models[] = {
1805 {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1806 {.id = ALC260_FIXUP_COEF, .name = "coef"},
1807 {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1808 {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1814 static int patch_alc260(struct hda_codec *codec)
1816 struct alc_spec *spec;
1819 err = alc_alloc_spec(codec, 0x07);
1824 /* as quite a few machines require HP amp for speaker outputs,
1825 * it's easier to enable it unconditionally; even if it's unneeded,
1826 * it's almost harmless.
1828 spec->gen.prefer_hp_amp = 1;
1829 spec->gen.beep_nid = 0x01;
1831 spec->shutup = alc_eapd_shutup;
1833 alc_pre_init(codec);
1835 snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1837 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1839 /* automatic parse from the BIOS config */
1840 err = alc260_parse_auto_config(codec);
1844 if (!spec->gen.no_analog) {
1845 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1850 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1861 * ALC882/883/885/888/889 support
1863 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1864 * configuration. Each pin widget can choose any input DACs and a mixer.
1865 * Each ADC is connected from a mixer of all inputs. This makes possible
1866 * 6-channel independent captures.
1868 * In addition, an independent DAC for the multi-playback (not used in this
1876 ALC882_FIXUP_ABIT_AW9D_MAX,
1877 ALC882_FIXUP_LENOVO_Y530,
1878 ALC882_FIXUP_PB_M5210,
1879 ALC882_FIXUP_ACER_ASPIRE_7736,
1880 ALC882_FIXUP_ASUS_W90V,
1882 ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1883 ALC889_FIXUP_VAIO_TT,
1884 ALC888_FIXUP_EEE1601,
1887 ALC883_FIXUP_ACER_EAPD,
1892 ALC882_FIXUP_ASUS_W2JC,
1893 ALC882_FIXUP_ACER_ASPIRE_4930G,
1894 ALC882_FIXUP_ACER_ASPIRE_8930G,
1895 ALC882_FIXUP_ASPIRE_8930G_VERBS,
1896 ALC885_FIXUP_MACPRO_GPIO,
1897 ALC889_FIXUP_DAC_ROUTE,
1898 ALC889_FIXUP_MBP_VREF,
1899 ALC889_FIXUP_IMAC91_VREF,
1900 ALC889_FIXUP_MBA11_VREF,
1901 ALC889_FIXUP_MBA21_VREF,
1902 ALC889_FIXUP_MP11_VREF,
1903 ALC889_FIXUP_MP41_VREF,
1904 ALC882_FIXUP_INV_DMIC,
1905 ALC882_FIXUP_NO_PRIMARY_HP,
1906 ALC887_FIXUP_ASUS_BASS,
1907 ALC887_FIXUP_BASS_CHMAP,
1908 ALC1220_FIXUP_GB_DUAL_CODECS,
1909 ALC1220_FIXUP_CLEVO_P950,
1910 ALC1220_FIXUP_CLEVO_PB51ED,
1911 ALC1220_FIXUP_CLEVO_PB51ED_PINS,
1914 static void alc889_fixup_coef(struct hda_codec *codec,
1915 const struct hda_fixup *fix, int action)
1917 if (action != HDA_FIXUP_ACT_INIT)
1919 alc_update_coef_idx(codec, 7, 0, 0x2030);
1922 /* set up GPIO at initialization */
1923 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1924 const struct hda_fixup *fix, int action)
1926 struct alc_spec *spec = codec->spec;
1928 spec->gpio_write_delay = true;
1929 alc_fixup_gpio3(codec, fix, action);
1932 /* Fix the connection of some pins for ALC889:
1933 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
1934 * work correctly (bko#42740)
1936 static void alc889_fixup_dac_route(struct hda_codec *codec,
1937 const struct hda_fixup *fix, int action)
1939 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1940 /* fake the connections during parsing the tree */
1941 static const hda_nid_t conn1[] = { 0x0c, 0x0d };
1942 static const hda_nid_t conn2[] = { 0x0e, 0x0f };
1943 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
1944 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
1945 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2);
1946 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2);
1947 } else if (action == HDA_FIXUP_ACT_PROBE) {
1948 /* restore the connections */
1949 static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
1950 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
1951 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
1952 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn);
1953 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn);
1957 /* Set VREF on HP pin */
1958 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
1959 const struct hda_fixup *fix, int action)
1961 static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 };
1962 struct alc_spec *spec = codec->spec;
1965 if (action != HDA_FIXUP_ACT_INIT)
1967 for (i = 0; i < ARRAY_SIZE(nids); i++) {
1968 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
1969 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
1971 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1972 val |= AC_PINCTL_VREF_80;
1973 snd_hda_set_pin_ctl(codec, nids[i], val);
1974 spec->gen.keep_vref_in_automute = 1;
1979 static void alc889_fixup_mac_pins(struct hda_codec *codec,
1980 const hda_nid_t *nids, int num_nids)
1982 struct alc_spec *spec = codec->spec;
1985 for (i = 0; i < num_nids; i++) {
1987 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1988 val |= AC_PINCTL_VREF_50;
1989 snd_hda_set_pin_ctl(codec, nids[i], val);
1991 spec->gen.keep_vref_in_automute = 1;
1994 /* Set VREF on speaker pins on imac91 */
1995 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
1996 const struct hda_fixup *fix, int action)
1998 static const hda_nid_t nids[] = { 0x18, 0x1a };
2000 if (action == HDA_FIXUP_ACT_INIT)
2001 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2004 /* Set VREF on speaker pins on mba11 */
2005 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2006 const struct hda_fixup *fix, int action)
2008 static const hda_nid_t nids[] = { 0x18 };
2010 if (action == HDA_FIXUP_ACT_INIT)
2011 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2014 /* Set VREF on speaker pins on mba21 */
2015 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2016 const struct hda_fixup *fix, int action)
2018 static const hda_nid_t nids[] = { 0x18, 0x19 };
2020 if (action == HDA_FIXUP_ACT_INIT)
2021 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2024 /* Don't take HP output as primary
2025 * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
2026 * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
2028 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2029 const struct hda_fixup *fix, int action)
2031 struct alc_spec *spec = codec->spec;
2032 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2033 spec->gen.no_primary_hp = 1;
2034 spec->gen.no_multi_io = 1;
2038 static void alc_fixup_bass_chmap(struct hda_codec *codec,
2039 const struct hda_fixup *fix, int action);
2041 /* For dual-codec configuration, we need to disable some features to avoid
2042 * conflicts of kctls and PCM streams
2044 static void alc_fixup_dual_codecs(struct hda_codec *codec,
2045 const struct hda_fixup *fix, int action)
2047 struct alc_spec *spec = codec->spec;
2049 if (action != HDA_FIXUP_ACT_PRE_PROBE)
2051 /* disable vmaster */
2052 spec->gen.suppress_vmaster = 1;
2053 /* auto-mute and auto-mic switch don't work with multiple codecs */
2054 spec->gen.suppress_auto_mute = 1;
2055 spec->gen.suppress_auto_mic = 1;
2056 /* disable aamix as well */
2057 spec->gen.mixer_nid = 0;
2058 /* add location prefix to avoid conflicts */
2059 codec->force_pin_prefix = 1;
2062 static void rename_ctl(struct hda_codec *codec, const char *oldname,
2063 const char *newname)
2065 struct snd_kcontrol *kctl;
2067 kctl = snd_hda_find_mixer_ctl(codec, oldname);
2069 strcpy(kctl->id.name, newname);
2072 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2073 const struct hda_fixup *fix,
2076 alc_fixup_dual_codecs(codec, fix, action);
2078 case HDA_FIXUP_ACT_PRE_PROBE:
2079 /* override card longname to provide a unique UCM profile */
2080 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2082 case HDA_FIXUP_ACT_BUILD:
2083 /* rename Capture controls depending on the codec */
2084 rename_ctl(codec, "Capture Volume",
2086 "Rear-Panel Capture Volume" :
2087 "Front-Panel Capture Volume");
2088 rename_ctl(codec, "Capture Switch",
2090 "Rear-Panel Capture Switch" :
2091 "Front-Panel Capture Switch");
2096 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2097 const struct hda_fixup *fix,
2100 static const hda_nid_t conn1[] = { 0x0c };
2102 if (action != HDA_FIXUP_ACT_PRE_PROBE)
2105 alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2106 /* We therefore want to make sure 0x14 (front headphone) and
2107 * 0x1b (speakers) use the stereo DAC 0x02
2109 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2110 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2113 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2114 const struct hda_fixup *fix, int action);
2116 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2117 const struct hda_fixup *fix,
2120 alc1220_fixup_clevo_p950(codec, fix, action);
2121 alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2124 static const struct hda_fixup alc882_fixups[] = {
2125 [ALC882_FIXUP_ABIT_AW9D_MAX] = {
2126 .type = HDA_FIXUP_PINS,
2127 .v.pins = (const struct hda_pintbl[]) {
2128 { 0x15, 0x01080104 }, /* side */
2129 { 0x16, 0x01011012 }, /* rear */
2130 { 0x17, 0x01016011 }, /* clfe */
2134 [ALC882_FIXUP_LENOVO_Y530] = {
2135 .type = HDA_FIXUP_PINS,
2136 .v.pins = (const struct hda_pintbl[]) {
2137 { 0x15, 0x99130112 }, /* rear int speakers */
2138 { 0x16, 0x99130111 }, /* subwoofer */
2142 [ALC882_FIXUP_PB_M5210] = {
2143 .type = HDA_FIXUP_PINCTLS,
2144 .v.pins = (const struct hda_pintbl[]) {
2145 { 0x19, PIN_VREF50 },
2149 [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2150 .type = HDA_FIXUP_FUNC,
2151 .v.func = alc_fixup_sku_ignore,
2153 [ALC882_FIXUP_ASUS_W90V] = {
2154 .type = HDA_FIXUP_PINS,
2155 .v.pins = (const struct hda_pintbl[]) {
2156 { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2160 [ALC889_FIXUP_CD] = {
2161 .type = HDA_FIXUP_PINS,
2162 .v.pins = (const struct hda_pintbl[]) {
2163 { 0x1c, 0x993301f0 }, /* CD */
2167 [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2168 .type = HDA_FIXUP_PINS,
2169 .v.pins = (const struct hda_pintbl[]) {
2170 { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2174 .chain_id = ALC889_FIXUP_CD,
2176 [ALC889_FIXUP_VAIO_TT] = {
2177 .type = HDA_FIXUP_PINS,
2178 .v.pins = (const struct hda_pintbl[]) {
2179 { 0x17, 0x90170111 }, /* hidden surround speaker */
2183 [ALC888_FIXUP_EEE1601] = {
2184 .type = HDA_FIXUP_VERBS,
2185 .v.verbs = (const struct hda_verb[]) {
2186 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2187 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },
2191 [ALC882_FIXUP_EAPD] = {
2192 .type = HDA_FIXUP_VERBS,
2193 .v.verbs = (const struct hda_verb[]) {
2194 /* change to EAPD mode */
2195 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2196 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2200 [ALC883_FIXUP_EAPD] = {
2201 .type = HDA_FIXUP_VERBS,
2202 .v.verbs = (const struct hda_verb[]) {
2203 /* change to EAPD mode */
2204 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2205 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2209 [ALC883_FIXUP_ACER_EAPD] = {
2210 .type = HDA_FIXUP_VERBS,
2211 .v.verbs = (const struct hda_verb[]) {
2212 /* eanable EAPD on Acer laptops */
2213 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2214 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2218 [ALC882_FIXUP_GPIO1] = {
2219 .type = HDA_FIXUP_FUNC,
2220 .v.func = alc_fixup_gpio1,
2222 [ALC882_FIXUP_GPIO2] = {
2223 .type = HDA_FIXUP_FUNC,
2224 .v.func = alc_fixup_gpio2,
2226 [ALC882_FIXUP_GPIO3] = {
2227 .type = HDA_FIXUP_FUNC,
2228 .v.func = alc_fixup_gpio3,
2230 [ALC882_FIXUP_ASUS_W2JC] = {
2231 .type = HDA_FIXUP_FUNC,
2232 .v.func = alc_fixup_gpio1,
2234 .chain_id = ALC882_FIXUP_EAPD,
2236 [ALC889_FIXUP_COEF] = {
2237 .type = HDA_FIXUP_FUNC,
2238 .v.func = alc889_fixup_coef,
2240 [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2241 .type = HDA_FIXUP_PINS,
2242 .v.pins = (const struct hda_pintbl[]) {
2243 { 0x16, 0x99130111 }, /* CLFE speaker */
2244 { 0x17, 0x99130112 }, /* surround speaker */
2248 .chain_id = ALC882_FIXUP_GPIO1,
2250 [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2251 .type = HDA_FIXUP_PINS,
2252 .v.pins = (const struct hda_pintbl[]) {
2253 { 0x16, 0x99130111 }, /* CLFE speaker */
2254 { 0x1b, 0x99130112 }, /* surround speaker */
2258 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2260 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2261 /* additional init verbs for Acer Aspire 8930G */
2262 .type = HDA_FIXUP_VERBS,
2263 .v.verbs = (const struct hda_verb[]) {
2264 /* Enable all DACs */
2265 /* DAC DISABLE/MUTE 1? */
2266 /* setting bits 1-5 disables DAC nids 0x02-0x06
2267 * apparently. Init=0x38 */
2268 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2269 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2270 /* DAC DISABLE/MUTE 2? */
2271 /* some bit here disables the other DACs.
2273 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2274 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2276 * This laptop has a stereo digital microphone.
2277 * The mics are only 1cm apart which makes the stereo
2278 * useless. However, either the mic or the ALC889
2279 * makes the signal become a difference/sum signal
2280 * instead of standard stereo, which is annoying.
2281 * So instead we flip this bit which makes the
2282 * codec replicate the sum signal to both channels,
2283 * turning it into a normal mono mic.
2285 /* DMIC_CONTROL? Init value = 0x0001 */
2286 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2287 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2288 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2289 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2293 .chain_id = ALC882_FIXUP_GPIO1,
2295 [ALC885_FIXUP_MACPRO_GPIO] = {
2296 .type = HDA_FIXUP_FUNC,
2297 .v.func = alc885_fixup_macpro_gpio,
2299 [ALC889_FIXUP_DAC_ROUTE] = {
2300 .type = HDA_FIXUP_FUNC,
2301 .v.func = alc889_fixup_dac_route,
2303 [ALC889_FIXUP_MBP_VREF] = {
2304 .type = HDA_FIXUP_FUNC,
2305 .v.func = alc889_fixup_mbp_vref,
2307 .chain_id = ALC882_FIXUP_GPIO1,
2309 [ALC889_FIXUP_IMAC91_VREF] = {
2310 .type = HDA_FIXUP_FUNC,
2311 .v.func = alc889_fixup_imac91_vref,
2313 .chain_id = ALC882_FIXUP_GPIO1,
2315 [ALC889_FIXUP_MBA11_VREF] = {
2316 .type = HDA_FIXUP_FUNC,
2317 .v.func = alc889_fixup_mba11_vref,
2319 .chain_id = ALC889_FIXUP_MBP_VREF,
2321 [ALC889_FIXUP_MBA21_VREF] = {
2322 .type = HDA_FIXUP_FUNC,
2323 .v.func = alc889_fixup_mba21_vref,
2325 .chain_id = ALC889_FIXUP_MBP_VREF,
2327 [ALC889_FIXUP_MP11_VREF] = {
2328 .type = HDA_FIXUP_FUNC,
2329 .v.func = alc889_fixup_mba11_vref,
2331 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2333 [ALC889_FIXUP_MP41_VREF] = {
2334 .type = HDA_FIXUP_FUNC,
2335 .v.func = alc889_fixup_mbp_vref,
2337 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2339 [ALC882_FIXUP_INV_DMIC] = {
2340 .type = HDA_FIXUP_FUNC,
2341 .v.func = alc_fixup_inv_dmic,
2343 [ALC882_FIXUP_NO_PRIMARY_HP] = {
2344 .type = HDA_FIXUP_FUNC,
2345 .v.func = alc882_fixup_no_primary_hp,
2347 [ALC887_FIXUP_ASUS_BASS] = {
2348 .type = HDA_FIXUP_PINS,
2349 .v.pins = (const struct hda_pintbl[]) {
2350 {0x16, 0x99130130}, /* bass speaker */
2354 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2356 [ALC887_FIXUP_BASS_CHMAP] = {
2357 .type = HDA_FIXUP_FUNC,
2358 .v.func = alc_fixup_bass_chmap,
2360 [ALC1220_FIXUP_GB_DUAL_CODECS] = {
2361 .type = HDA_FIXUP_FUNC,
2362 .v.func = alc1220_fixup_gb_dual_codecs,
2364 [ALC1220_FIXUP_CLEVO_P950] = {
2365 .type = HDA_FIXUP_FUNC,
2366 .v.func = alc1220_fixup_clevo_p950,
2368 [ALC1220_FIXUP_CLEVO_PB51ED] = {
2369 .type = HDA_FIXUP_FUNC,
2370 .v.func = alc1220_fixup_clevo_pb51ed,
2372 [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2373 .type = HDA_FIXUP_PINS,
2374 .v.pins = (const struct hda_pintbl[]) {
2375 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
2379 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2383 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2384 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2385 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2386 SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2387 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2388 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2389 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2390 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2391 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2392 ALC882_FIXUP_ACER_ASPIRE_4930G),
2393 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2394 ALC882_FIXUP_ACER_ASPIRE_4930G),
2395 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2396 ALC882_FIXUP_ACER_ASPIRE_8930G),
2397 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2398 ALC882_FIXUP_ACER_ASPIRE_8930G),
2399 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2400 ALC882_FIXUP_ACER_ASPIRE_4930G),
2401 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2402 ALC882_FIXUP_ACER_ASPIRE_4930G),
2403 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2404 ALC882_FIXUP_ACER_ASPIRE_4930G),
2405 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2406 SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2407 ALC882_FIXUP_ACER_ASPIRE_4930G),
2408 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2409 SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2410 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2411 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2412 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2413 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2414 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2415 SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2416 SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2417 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2418 SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2419 SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2420 SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2421 SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2423 /* All Apple entries are in codec SSIDs */
2424 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2425 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2426 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2427 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2428 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2429 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2430 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2431 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2432 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2433 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2434 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2435 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2436 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2437 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2438 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2439 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2440 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2441 SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2442 SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2443 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2444 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2445 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2447 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2448 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2449 SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2450 SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2451 SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2452 SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2453 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2454 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2455 SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2456 SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2457 SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2458 SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2459 SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2460 SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2461 SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2462 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2463 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2464 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2465 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2469 static const struct hda_model_fixup alc882_fixup_models[] = {
2470 {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2471 {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2472 {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2473 {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2474 {.id = ALC889_FIXUP_CD, .name = "cd"},
2475 {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2476 {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2477 {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2478 {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2479 {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2480 {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2481 {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2482 {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2483 {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2484 {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2485 {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2486 {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2487 {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2488 {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2489 {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2490 {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2491 {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2492 {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2493 {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2494 {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2495 {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2496 {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2497 {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2498 {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2499 {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2500 {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2505 * BIOS auto configuration
2507 /* almost identical with ALC880 parser... */
2508 static int alc882_parse_auto_config(struct hda_codec *codec)
2510 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2511 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2512 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2517 static int patch_alc882(struct hda_codec *codec)
2519 struct alc_spec *spec;
2522 err = alc_alloc_spec(codec, 0x0b);
2528 switch (codec->core.vendor_id) {
2536 /* ALC883 and variants */
2537 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2541 alc_pre_init(codec);
2543 snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2545 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2547 alc_auto_parse_customize_define(codec);
2549 if (has_cdefine_beep(codec))
2550 spec->gen.beep_nid = 0x01;
2552 /* automatic parse from the BIOS config */
2553 err = alc882_parse_auto_config(codec);
2557 if (!spec->gen.no_analog && spec->gen.beep_nid) {
2558 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2563 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2576 static int alc262_parse_auto_config(struct hda_codec *codec)
2578 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2579 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2580 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2587 ALC262_FIXUP_FSC_H270,
2588 ALC262_FIXUP_FSC_S7110,
2589 ALC262_FIXUP_HP_Z200,
2591 ALC262_FIXUP_LENOVO_3000,
2593 ALC262_FIXUP_BENQ_T31,
2594 ALC262_FIXUP_INV_DMIC,
2595 ALC262_FIXUP_INTEL_BAYLEYBAY,
2598 static const struct hda_fixup alc262_fixups[] = {
2599 [ALC262_FIXUP_FSC_H270] = {
2600 .type = HDA_FIXUP_PINS,
2601 .v.pins = (const struct hda_pintbl[]) {
2602 { 0x14, 0x99130110 }, /* speaker */
2603 { 0x15, 0x0221142f }, /* front HP */
2604 { 0x1b, 0x0121141f }, /* rear HP */
2608 [ALC262_FIXUP_FSC_S7110] = {
2609 .type = HDA_FIXUP_PINS,
2610 .v.pins = (const struct hda_pintbl[]) {
2611 { 0x15, 0x90170110 }, /* speaker */
2615 .chain_id = ALC262_FIXUP_BENQ,
2617 [ALC262_FIXUP_HP_Z200] = {
2618 .type = HDA_FIXUP_PINS,
2619 .v.pins = (const struct hda_pintbl[]) {
2620 { 0x16, 0x99130120 }, /* internal speaker */
2624 [ALC262_FIXUP_TYAN] = {
2625 .type = HDA_FIXUP_PINS,
2626 .v.pins = (const struct hda_pintbl[]) {
2627 { 0x14, 0x1993e1f0 }, /* int AUX */
2631 [ALC262_FIXUP_LENOVO_3000] = {
2632 .type = HDA_FIXUP_PINCTLS,
2633 .v.pins = (const struct hda_pintbl[]) {
2634 { 0x19, PIN_VREF50 },
2638 .chain_id = ALC262_FIXUP_BENQ,
2640 [ALC262_FIXUP_BENQ] = {
2641 .type = HDA_FIXUP_VERBS,
2642 .v.verbs = (const struct hda_verb[]) {
2643 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2644 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2648 [ALC262_FIXUP_BENQ_T31] = {
2649 .type = HDA_FIXUP_VERBS,
2650 .v.verbs = (const struct hda_verb[]) {
2651 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2652 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2656 [ALC262_FIXUP_INV_DMIC] = {
2657 .type = HDA_FIXUP_FUNC,
2658 .v.func = alc_fixup_inv_dmic,
2660 [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2661 .type = HDA_FIXUP_FUNC,
2662 .v.func = alc_fixup_no_depop_delay,
2666 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2667 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2668 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2669 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2670 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2671 SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2672 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2673 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2674 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2675 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2676 SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2680 static const struct hda_model_fixup alc262_fixup_models[] = {
2681 {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2682 {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2683 {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2684 {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2685 {.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2686 {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2687 {.id = ALC262_FIXUP_BENQ, .name = "benq"},
2688 {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2689 {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2695 static int patch_alc262(struct hda_codec *codec)
2697 struct alc_spec *spec;
2700 err = alc_alloc_spec(codec, 0x0b);
2705 spec->gen.shared_mic_vref_pin = 0x18;
2707 spec->shutup = alc_eapd_shutup;
2710 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
2713 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2715 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2717 alc_pre_init(codec);
2719 snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2721 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2723 alc_auto_parse_customize_define(codec);
2725 if (has_cdefine_beep(codec))
2726 spec->gen.beep_nid = 0x01;
2728 /* automatic parse from the BIOS config */
2729 err = alc262_parse_auto_config(codec);
2733 if (!spec->gen.no_analog && spec->gen.beep_nid) {
2734 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2739 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2751 /* bind Beep switches of both NID 0x0f and 0x10 */
2752 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2753 struct snd_ctl_elem_value *ucontrol)
2755 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2759 mutex_lock(&codec->control_mutex);
2760 pval = kcontrol->private_value;
2761 kcontrol->private_value = (pval & ~0xff) | 0x0f;
2762 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2764 kcontrol->private_value = (pval & ~0xff) | 0x10;
2765 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2767 kcontrol->private_value = pval;
2768 mutex_unlock(&codec->control_mutex);
2772 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2773 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2775 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2776 .name = "Beep Playback Switch",
2777 .subdevice = HDA_SUBDEV_AMP_FLAG,
2778 .info = snd_hda_mixer_amp_switch_info,
2779 .get = snd_hda_mixer_amp_switch_get,
2780 .put = alc268_beep_switch_put,
2781 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
2785 /* set PCBEEP vol = 0, mute connections */
2786 static const struct hda_verb alc268_beep_init_verbs[] = {
2787 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2788 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2789 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2794 ALC268_FIXUP_INV_DMIC,
2795 ALC268_FIXUP_HP_EAPD,
2799 static const struct hda_fixup alc268_fixups[] = {
2800 [ALC268_FIXUP_INV_DMIC] = {
2801 .type = HDA_FIXUP_FUNC,
2802 .v.func = alc_fixup_inv_dmic,
2804 [ALC268_FIXUP_HP_EAPD] = {
2805 .type = HDA_FIXUP_VERBS,
2806 .v.verbs = (const struct hda_verb[]) {
2807 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
2811 [ALC268_FIXUP_SPDIF] = {
2812 .type = HDA_FIXUP_PINS,
2813 .v.pins = (const struct hda_pintbl[]) {
2814 { 0x1e, 0x014b1180 }, /* enable SPDIF out */
2820 static const struct hda_model_fixup alc268_fixup_models[] = {
2821 {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2822 {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
2823 {.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
2827 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2828 SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
2829 SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2830 /* below is codec SSID since multiple Toshiba laptops have the
2831 * same PCI SSID 1179:ff00
2833 SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
2838 * BIOS auto configuration
2840 static int alc268_parse_auto_config(struct hda_codec *codec)
2842 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2843 return alc_parse_auto_config(codec, NULL, alc268_ssids);
2848 static int patch_alc268(struct hda_codec *codec)
2850 struct alc_spec *spec;
2853 /* ALC268 has no aa-loopback mixer */
2854 err = alc_alloc_spec(codec, 0);
2859 if (has_cdefine_beep(codec))
2860 spec->gen.beep_nid = 0x01;
2862 spec->shutup = alc_eapd_shutup;
2864 alc_pre_init(codec);
2866 snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
2867 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2869 /* automatic parse from the BIOS config */
2870 err = alc268_parse_auto_config(codec);
2874 if (err > 0 && !spec->gen.no_analog &&
2875 spec->gen.autocfg.speaker_pins[0] != 0x1d) {
2876 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
2877 if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
2878 &alc268_beep_mixer[i])) {
2883 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
2884 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
2885 /* override the amp caps for beep generator */
2886 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
2887 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
2888 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
2889 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2890 (0 << AC_AMPCAP_MUTE_SHIFT));
2893 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2906 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
2907 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2910 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
2911 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2914 /* different alc269-variants */
2916 ALC269_TYPE_ALC269VA,
2917 ALC269_TYPE_ALC269VB,
2918 ALC269_TYPE_ALC269VC,
2919 ALC269_TYPE_ALC269VD,
2939 * BIOS auto configuration
2941 static int alc269_parse_auto_config(struct hda_codec *codec)
2943 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
2944 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
2945 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2946 struct alc_spec *spec = codec->spec;
2947 const hda_nid_t *ssids;
2949 switch (spec->codec_variant) {
2950 case ALC269_TYPE_ALC269VA:
2951 case ALC269_TYPE_ALC269VC:
2952 case ALC269_TYPE_ALC280:
2953 case ALC269_TYPE_ALC284:
2954 case ALC269_TYPE_ALC293:
2955 ssids = alc269va_ssids;
2957 case ALC269_TYPE_ALC269VB:
2958 case ALC269_TYPE_ALC269VD:
2959 case ALC269_TYPE_ALC282:
2960 case ALC269_TYPE_ALC283:
2961 case ALC269_TYPE_ALC286:
2962 case ALC269_TYPE_ALC298:
2963 case ALC269_TYPE_ALC255:
2964 case ALC269_TYPE_ALC256:
2965 case ALC269_TYPE_ALC257:
2966 case ALC269_TYPE_ALC215:
2967 case ALC269_TYPE_ALC225:
2968 case ALC269_TYPE_ALC294:
2969 case ALC269_TYPE_ALC300:
2970 case ALC269_TYPE_ALC623:
2971 case ALC269_TYPE_ALC700:
2972 ssids = alc269_ssids;
2975 ssids = alc269_ssids;
2979 return alc_parse_auto_config(codec, alc269_ignore, ssids);
2982 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
2984 alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
2987 static void alc269_shutup(struct hda_codec *codec)
2989 struct alc_spec *spec = codec->spec;
2991 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
2992 alc269vb_toggle_power_output(codec, 0);
2993 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
2994 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
2997 alc_shutup_pins(codec);
3000 static const struct coef_fw alc282_coefs[] = {
3001 WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3002 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3003 WRITE_COEF(0x07, 0x0200), /* DMIC control */
3004 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3005 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3006 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3007 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3008 WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3009 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3010 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3011 WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3012 UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3013 WRITE_COEF(0x34, 0xa0c0), /* ANC */
3014 UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3015 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3016 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3017 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3018 WRITE_COEF(0x63, 0x2902), /* PLL */
3019 WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3020 WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3021 WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3022 WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3023 UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3024 WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3025 UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3026 WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3027 WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3028 UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3029 WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3033 static void alc282_restore_default_value(struct hda_codec *codec)
3035 alc_process_coef_fw(codec, alc282_coefs);
3038 static void alc282_init(struct hda_codec *codec)
3040 struct alc_spec *spec = codec->spec;
3041 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3045 alc282_restore_default_value(codec);
3049 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3050 coef78 = alc_read_coef_idx(codec, 0x78);
3052 /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3053 /* Headphone capless set to high power mode */
3054 alc_write_coef_idx(codec, 0x78, 0x9004);
3059 snd_hda_codec_write(codec, hp_pin, 0,
3060 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3065 snd_hda_codec_write(codec, hp_pin, 0,
3066 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3071 /* Headphone capless set to normal mode */
3072 alc_write_coef_idx(codec, 0x78, coef78);
3075 static void alc282_shutup(struct hda_codec *codec)
3077 struct alc_spec *spec = codec->spec;
3078 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3083 alc269_shutup(codec);
3087 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3088 coef78 = alc_read_coef_idx(codec, 0x78);
3089 alc_write_coef_idx(codec, 0x78, 0x9004);
3094 snd_hda_codec_write(codec, hp_pin, 0,
3095 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3100 if (!spec->no_shutup_pins)
3101 snd_hda_codec_write(codec, hp_pin, 0,
3102 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3107 alc_auto_setup_eapd(codec, false);
3108 alc_shutup_pins(codec);
3109 alc_write_coef_idx(codec, 0x78, coef78);
3112 static const struct coef_fw alc283_coefs[] = {
3113 WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3114 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3115 WRITE_COEF(0x07, 0x0200), /* DMIC control */
3116 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3117 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3118 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3119 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3120 WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3121 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3122 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3123 WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3124 UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3125 WRITE_COEF(0x22, 0xa0c0), /* ANC */
3126 UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3127 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3128 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3129 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3130 WRITE_COEF(0x2e, 0x2902), /* PLL */
3131 WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3132 WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3133 WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3134 WRITE_COEF(0x36, 0x0), /* capless control 5 */
3135 UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3136 WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3137 UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3138 WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3139 WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3140 UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3141 WRITE_COEF(0x49, 0x0), /* test mode */
3142 UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3143 UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3144 WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3145 UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3149 static void alc283_restore_default_value(struct hda_codec *codec)
3151 alc_process_coef_fw(codec, alc283_coefs);
3154 static void alc283_init(struct hda_codec *codec)
3156 struct alc_spec *spec = codec->spec;
3157 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3160 alc283_restore_default_value(codec);
3166 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3168 /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3169 /* Headphone capless set to high power mode */
3170 alc_write_coef_idx(codec, 0x43, 0x9004);
3172 snd_hda_codec_write(codec, hp_pin, 0,
3173 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3178 snd_hda_codec_write(codec, hp_pin, 0,
3179 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3183 /* Index 0x46 Combo jack auto switch control 2 */
3184 /* 3k pull low control for Headset jack. */
3185 alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3186 /* Headphone capless set to normal mode */
3187 alc_write_coef_idx(codec, 0x43, 0x9614);
3190 static void alc283_shutup(struct hda_codec *codec)
3192 struct alc_spec *spec = codec->spec;
3193 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3197 alc269_shutup(codec);
3201 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3203 alc_write_coef_idx(codec, 0x43, 0x9004);
3205 /*depop hp during suspend*/
3206 alc_write_coef_idx(codec, 0x06, 0x2100);
3208 snd_hda_codec_write(codec, hp_pin, 0,
3209 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3214 if (!spec->no_shutup_pins)
3215 snd_hda_codec_write(codec, hp_pin, 0,
3216 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3218 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3222 alc_auto_setup_eapd(codec, false);
3223 alc_shutup_pins(codec);
3224 alc_write_coef_idx(codec, 0x43, 0x9614);
3227 static void alc256_init(struct hda_codec *codec)
3229 struct alc_spec *spec = codec->spec;
3230 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3238 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3243 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3244 if (spec->ultra_low_power) {
3245 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3246 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3247 alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3248 alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3249 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3253 snd_hda_codec_write(codec, hp_pin, 0,
3254 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3256 if (hp_pin_sense || spec->ultra_low_power)
3259 snd_hda_codec_write(codec, hp_pin, 0,
3260 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3262 if (hp_pin_sense || spec->ultra_low_power)
3265 alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3266 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3267 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3268 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3269 alc_update_coef_idx(codec, 0x36, 1 << 13, 1 << 5); /* Switch pcbeep path to Line in path*/
3272 static void alc256_shutup(struct hda_codec *codec)
3274 struct alc_spec *spec = codec->spec;
3275 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3281 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3286 snd_hda_codec_write(codec, hp_pin, 0,
3287 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3289 if (hp_pin_sense || spec->ultra_low_power)
3292 /* 3k pull low control for Headset jack. */
3293 /* NOTE: call this before clearing the pin, otherwise codec stalls */
3294 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3296 if (!spec->no_shutup_pins)
3297 snd_hda_codec_write(codec, hp_pin, 0,
3298 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3300 if (hp_pin_sense || spec->ultra_low_power)
3303 alc_auto_setup_eapd(codec, false);
3304 alc_shutup_pins(codec);
3305 if (spec->ultra_low_power) {
3307 alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3308 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3309 alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3310 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3311 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3316 static void alc225_init(struct hda_codec *codec)
3318 struct alc_spec *spec = codec->spec;
3319 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3320 bool hp1_pin_sense, hp2_pin_sense;
3326 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3327 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3329 if (hp1_pin_sense || hp2_pin_sense)
3332 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3333 if (spec->ultra_low_power) {
3334 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3335 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3336 alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3340 if (hp1_pin_sense || spec->ultra_low_power)
3341 snd_hda_codec_write(codec, hp_pin, 0,
3342 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3344 snd_hda_codec_write(codec, 0x16, 0,
3345 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3347 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3350 if (hp1_pin_sense || spec->ultra_low_power)
3351 snd_hda_codec_write(codec, hp_pin, 0,
3352 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3354 snd_hda_codec_write(codec, 0x16, 0,
3355 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3357 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3360 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3361 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3364 static void alc225_shutup(struct hda_codec *codec)
3366 struct alc_spec *spec = codec->spec;
3367 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3368 bool hp1_pin_sense, hp2_pin_sense;
3372 /* 3k pull low control for Headset jack. */
3373 alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3375 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3376 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3378 if (hp1_pin_sense || hp2_pin_sense)
3381 if (hp1_pin_sense || spec->ultra_low_power)
3382 snd_hda_codec_write(codec, hp_pin, 0,
3383 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3385 snd_hda_codec_write(codec, 0x16, 0,
3386 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3388 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3391 if (hp1_pin_sense || spec->ultra_low_power)
3392 snd_hda_codec_write(codec, hp_pin, 0,
3393 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3395 snd_hda_codec_write(codec, 0x16, 0,
3396 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3398 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3401 alc_auto_setup_eapd(codec, false);
3402 alc_shutup_pins(codec);
3403 if (spec->ultra_low_power) {
3405 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3406 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3407 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3408 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3413 static void alc_default_init(struct hda_codec *codec)
3415 struct alc_spec *spec = codec->spec;
3416 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3424 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3429 snd_hda_codec_write(codec, hp_pin, 0,
3430 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3435 snd_hda_codec_write(codec, hp_pin, 0,
3436 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3442 static void alc_default_shutup(struct hda_codec *codec)
3444 struct alc_spec *spec = codec->spec;
3445 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3449 alc269_shutup(codec);
3453 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3458 snd_hda_codec_write(codec, hp_pin, 0,
3459 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3464 if (!spec->no_shutup_pins)
3465 snd_hda_codec_write(codec, hp_pin, 0,
3466 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3471 alc_auto_setup_eapd(codec, false);
3472 alc_shutup_pins(codec);
3475 static void alc294_hp_init(struct hda_codec *codec)
3477 struct alc_spec *spec = codec->spec;
3478 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3484 snd_hda_codec_write(codec, hp_pin, 0,
3485 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3489 if (!spec->no_shutup_pins)
3490 snd_hda_codec_write(codec, hp_pin, 0,
3491 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3493 alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3494 alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3496 /* Wait for depop procedure finish */
3497 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3498 for (i = 0; i < 20 && val & 0x0080; i++) {
3500 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3502 /* Set HP depop to auto mode */
3503 alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3507 static void alc294_init(struct hda_codec *codec)
3509 struct alc_spec *spec = codec->spec;
3511 /* required only at boot or S4 resume time */
3512 if (!spec->done_hp_init ||
3513 codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3514 alc294_hp_init(codec);
3515 spec->done_hp_init = true;
3517 alc_default_init(codec);
3520 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3523 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3524 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3525 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3528 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3532 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3533 val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3535 val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3540 static void alc5505_dsp_halt(struct hda_codec *codec)
3544 alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3545 alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3546 alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3547 alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3548 alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3549 alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3550 alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3551 val = alc5505_coef_get(codec, 0x6220);
3552 alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3555 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3557 alc5505_coef_set(codec, 0x61b8, 0x04133302);
3558 alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3559 alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3560 alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3561 alc5505_coef_set(codec, 0x6220, 0x2002010f);
3562 alc5505_coef_set(codec, 0x880c, 0x00000004);
3565 static void alc5505_dsp_init(struct hda_codec *codec)
3569 alc5505_dsp_halt(codec);
3570 alc5505_dsp_back_from_halt(codec);
3571 alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3572 alc5505_coef_set(codec, 0x61b0, 0x5b16);
3573 alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
3574 alc5505_coef_set(codec, 0x61b4, 0x04132b02);
3575 alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
3576 alc5505_coef_set(codec, 0x61b8, 0x041f3302);
3577 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
3578 alc5505_coef_set(codec, 0x61b8, 0x041b3302);
3579 alc5505_coef_set(codec, 0x61b8, 0x04173302);
3580 alc5505_coef_set(codec, 0x61b8, 0x04163302);
3581 alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
3582 alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
3583 alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
3585 val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
3587 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
3589 alc5505_coef_set(codec, 0x6220, 0x6002018f);
3591 alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
3592 alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
3593 alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
3594 alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
3595 alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
3596 alc5505_coef_set(codec, 0x880c, 0x00000003);
3597 alc5505_coef_set(codec, 0x880c, 0x00000010);
3599 #ifdef HALT_REALTEK_ALC5505
3600 alc5505_dsp_halt(codec);
3604 #ifdef HALT_REALTEK_ALC5505
3605 #define alc5505_dsp_suspend(codec) do { } while (0) /* NOP */
3606 #define alc5505_dsp_resume(codec) do { } while (0) /* NOP */
3608 #define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec)
3609 #define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec)
3613 static int alc269_suspend(struct hda_codec *codec)
3615 struct alc_spec *spec = codec->spec;
3617 if (spec->has_alc5505_dsp)
3618 alc5505_dsp_suspend(codec);
3619 return alc_suspend(codec);
3622 static int alc269_resume(struct hda_codec *codec)
3624 struct alc_spec *spec = codec->spec;
3626 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3627 alc269vb_toggle_power_output(codec, 0);
3628 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3629 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3633 codec->patch_ops.init(codec);
3635 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3636 alc269vb_toggle_power_output(codec, 1);
3637 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3638 (alc_get_coef0(codec) & 0x00ff) == 0x017) {
3642 snd_hda_regmap_sync(codec);
3643 hda_call_check_power_status(codec, 0x01);
3645 /* on some machine, the BIOS will clear the codec gpio data when enter
3646 * suspend, and won't restore the data after resume, so we restore it
3649 if (spec->gpio_data)
3650 alc_write_gpio_data(codec);
3652 if (spec->has_alc5505_dsp)
3653 alc5505_dsp_resume(codec);
3657 #endif /* CONFIG_PM */
3659 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
3660 const struct hda_fixup *fix, int action)
3662 struct alc_spec *spec = codec->spec;
3664 if (action == HDA_FIXUP_ACT_PRE_PROBE)
3665 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
3668 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
3669 const struct hda_fixup *fix,
3672 unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
3673 unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
3675 if (cfg_headphone && cfg_headset_mic == 0x411111f0)
3676 snd_hda_codec_set_pincfg(codec, 0x19,
3677 (cfg_headphone & ~AC_DEFCFG_DEVICE) |
3678 (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
3681 static void alc269_fixup_hweq(struct hda_codec *codec,
3682 const struct hda_fixup *fix, int action)
3684 if (action == HDA_FIXUP_ACT_INIT)
3685 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
3688 static void alc269_fixup_headset_mic(struct hda_codec *codec,
3689 const struct hda_fixup *fix, int action)
3691 struct alc_spec *spec = codec->spec;
3693 if (action == HDA_FIXUP_ACT_PRE_PROBE)
3694 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3697 static void alc271_fixup_dmic(struct hda_codec *codec,
3698 const struct hda_fixup *fix, int action)
3700 static const struct hda_verb verbs[] = {
3701 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
3702 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
3707 if (strcmp(codec->core.chip_name, "ALC271X") &&
3708 strcmp(codec->core.chip_name, "ALC269VB"))
3710 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
3711 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
3712 snd_hda_sequence_write(codec, verbs);
3715 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
3716 const struct hda_fixup *fix, int action)
3718 struct alc_spec *spec = codec->spec;
3720 if (action != HDA_FIXUP_ACT_PROBE)
3723 /* Due to a hardware problem on Lenovo Ideadpad, we need to
3724 * fix the sample rate of analog I/O to 44.1kHz
3726 spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
3727 spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
3730 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
3731 const struct hda_fixup *fix, int action)
3733 /* The digital-mic unit sends PDM (differential signal) instead of
3734 * the standard PCM, thus you can't record a valid mono stream as is.
3735 * Below is a workaround specific to ALC269 to control the dmic
3736 * signal source as mono.
3738 if (action == HDA_FIXUP_ACT_INIT)
3739 alc_update_coef_idx(codec, 0x07, 0, 0x80);
3742 static void alc269_quanta_automute(struct hda_codec *codec)
3744 snd_hda_gen_update_outputs(codec);
3746 alc_write_coef_idx(codec, 0x0c, 0x680);
3747 alc_write_coef_idx(codec, 0x0c, 0x480);
3750 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
3751 const struct hda_fixup *fix, int action)
3753 struct alc_spec *spec = codec->spec;
3754 if (action != HDA_FIXUP_ACT_PROBE)
3756 spec->gen.automute_hook = alc269_quanta_automute;
3759 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
3760 struct hda_jack_callback *jack)
3762 struct alc_spec *spec = codec->spec;
3765 snd_hda_gen_hp_automute(codec, jack);
3767 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
3769 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3772 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3777 * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
3779 struct hda_alc298_mbxinit {
3780 unsigned char value_0x23;
3781 unsigned char value_0x25;
3784 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
3785 const struct hda_alc298_mbxinit *initval,
3788 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
3789 alc_write_coef_idx(codec, 0x26, 0xb000);
3792 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
3794 snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
3795 alc_write_coef_idx(codec, 0x26, 0xf000);
3796 alc_write_coef_idx(codec, 0x23, initval->value_0x23);
3798 if (initval->value_0x23 != 0x1e)
3799 alc_write_coef_idx(codec, 0x25, initval->value_0x25);
3801 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
3802 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
3805 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
3806 const struct hda_fixup *fix,
3809 /* Initialization magic */
3810 static const struct hda_alc298_mbxinit dac_init[] = {
3811 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
3812 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
3813 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
3814 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
3815 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
3816 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
3818 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
3819 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
3820 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
3823 const struct hda_alc298_mbxinit *seq;
3825 if (action != HDA_FIXUP_ACT_INIT)
3829 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
3830 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
3831 alc_write_coef_idx(codec, 0x26, 0xf000);
3832 alc_write_coef_idx(codec, 0x22, 0x31);
3833 alc_write_coef_idx(codec, 0x23, 0x0b);
3834 alc_write_coef_idx(codec, 0x25, 0x00);
3835 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
3836 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
3838 for (seq = dac_init; seq->value_0x23; seq++)
3839 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
3842 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
3843 const struct hda_fixup *fix, int action)
3845 struct alc_spec *spec = codec->spec;
3846 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3847 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3848 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
3853 /* update mute-LED according to the speaker mute state via mic VREF pin */
3854 static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)
3856 struct hda_codec *codec = private_data;
3857 struct alc_spec *spec = codec->spec;
3858 unsigned int pinval;
3860 if (spec->mute_led_polarity)
3862 pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);
3863 pinval &= ~AC_PINCTL_VREFEN;
3864 pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;
3865 if (spec->mute_led_nid) {
3866 /* temporarily power up/down for setting VREF */
3867 snd_hda_power_up_pm(codec);
3868 snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
3869 snd_hda_power_down_pm(codec);
3873 /* Make sure the led works even in runtime suspend */
3874 static unsigned int led_power_filter(struct hda_codec *codec,
3876 unsigned int power_state)
3878 struct alc_spec *spec = codec->spec;
3880 if (power_state != AC_PWRST_D3 || nid == 0 ||
3881 (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
3884 /* Set pin ctl again, it might have just been set to 0 */
3885 snd_hda_set_pin_ctl(codec, nid,
3886 snd_hda_codec_get_pin_target(codec, nid));
3888 return snd_hda_gen_path_power_filter(codec, nid, power_state);
3891 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
3892 const struct hda_fixup *fix, int action)
3894 struct alc_spec *spec = codec->spec;
3895 const struct dmi_device *dev = NULL;
3897 if (action != HDA_FIXUP_ACT_PRE_PROBE)
3900 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
3902 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
3904 if (pin < 0x0a || pin >= 0x10)
3906 spec->mute_led_polarity = pol;
3907 spec->mute_led_nid = pin - 0x0a + 0x18;
3908 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3909 spec->gen.vmaster_mute_enum = 1;
3910 codec->power_filter = led_power_filter;
3912 "Detected mute LED for %x:%d\n", spec->mute_led_nid,
3913 spec->mute_led_polarity);
3918 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
3919 const struct hda_fixup *fix,
3920 int action, hda_nid_t pin)
3922 struct alc_spec *spec = codec->spec;
3924 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3925 spec->mute_led_polarity = 0;
3926 spec->mute_led_nid = pin;
3927 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3928 spec->gen.vmaster_mute_enum = 1;
3929 codec->power_filter = led_power_filter;
3933 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
3934 const struct hda_fixup *fix, int action)
3936 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
3939 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
3940 const struct hda_fixup *fix, int action)
3942 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
3945 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
3946 const struct hda_fixup *fix, int action)
3948 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
3951 /* update LED status via GPIO */
3952 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
3955 struct alc_spec *spec = codec->spec;
3957 if (spec->mute_led_polarity)
3959 alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
3962 /* turn on/off mute LED via GPIO per vmaster hook */
3963 static void alc_fixup_gpio_mute_hook(void *private_data, int enabled)
3965 struct hda_codec *codec = private_data;
3966 struct alc_spec *spec = codec->spec;
3968 alc_update_gpio_led(codec, spec->gpio_mute_led_mask, enabled);
3971 /* turn on/off mic-mute LED via GPIO per capture hook */
3972 static void alc_gpio_micmute_update(struct hda_codec *codec)
3974 struct alc_spec *spec = codec->spec;
3976 alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
3977 spec->gen.micmute_led.led_value);
3980 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
3981 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
3983 unsigned int mute_mask,
3984 unsigned int micmute_mask)
3986 struct alc_spec *spec = codec->spec;
3988 alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
3990 if (action != HDA_FIXUP_ACT_PRE_PROBE)
3993 spec->gpio_mute_led_mask = mute_mask;
3994 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3997 spec->gpio_mic_led_mask = micmute_mask;
3998 snd_hda_gen_add_micmute_led(codec, alc_gpio_micmute_update);
4002 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
4003 const struct hda_fixup *fix, int action)
4005 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4008 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4009 const struct hda_fixup *fix, int action)
4011 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4014 /* turn on/off mic-mute LED per capture hook */
4015 static void alc_cap_micmute_update(struct hda_codec *codec)
4017 struct alc_spec *spec = codec->spec;
4018 unsigned int pinval;
4020 if (!spec->cap_mute_led_nid)
4022 pinval = snd_hda_codec_get_pin_target(codec, spec->cap_mute_led_nid);
4023 pinval &= ~AC_PINCTL_VREFEN;
4024 if (spec->gen.micmute_led.led_value)
4025 pinval |= AC_PINCTL_VREF_80;
4027 pinval |= AC_PINCTL_VREF_HIZ;
4028 snd_hda_set_pin_ctl_cache(codec, spec->cap_mute_led_nid, pinval);
4031 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4032 const struct hda_fixup *fix, int action)
4034 struct alc_spec *spec = codec->spec;
4036 alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4037 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4038 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4039 * enable headphone amp
4041 spec->gpio_mask |= 0x10;
4042 spec->gpio_dir |= 0x10;
4043 spec->cap_mute_led_nid = 0x18;
4044 snd_hda_gen_add_micmute_led(codec, alc_cap_micmute_update);
4045 codec->power_filter = led_power_filter;
4049 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4050 const struct hda_fixup *fix, int action)
4052 struct alc_spec *spec = codec->spec;
4054 alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4055 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4056 spec->cap_mute_led_nid = 0x18;
4057 snd_hda_gen_add_micmute_led(codec, alc_cap_micmute_update);
4058 codec->power_filter = led_power_filter;
4062 #if IS_REACHABLE(CONFIG_INPUT)
4063 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4064 struct hda_jack_callback *event)
4066 struct alc_spec *spec = codec->spec;
4068 /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4069 send both key on and key off event for every interrupt. */
4070 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4071 input_sync(spec->kb_dev);
4072 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4073 input_sync(spec->kb_dev);
4076 static int alc_register_micmute_input_device(struct hda_codec *codec)
4078 struct alc_spec *spec = codec->spec;
4081 spec->kb_dev = input_allocate_device();
4082 if (!spec->kb_dev) {
4083 codec_err(codec, "Out of memory (input_allocate_device)\n");
4087 spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4089 spec->kb_dev->name = "Microphone Mute Button";
4090 spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4091 spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4092 spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4093 spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4094 for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4095 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4097 if (input_register_device(spec->kb_dev)) {
4098 codec_err(codec, "input_register_device failed\n");
4099 input_free_device(spec->kb_dev);
4100 spec->kb_dev = NULL;
4107 /* GPIO1 = set according to SKU external amp
4108 * GPIO2 = mic mute hotkey
4110 * GPIO4 = mic mute LED
4112 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4113 const struct hda_fixup *fix, int action)
4115 struct alc_spec *spec = codec->spec;
4117 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4118 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4119 spec->init_amp = ALC_INIT_DEFAULT;
4120 if (alc_register_micmute_input_device(codec) != 0)
4123 spec->gpio_mask |= 0x06;
4124 spec->gpio_dir |= 0x02;
4125 spec->gpio_data |= 0x02;
4126 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4127 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
4128 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4129 gpio2_mic_hotkey_event);
4137 case HDA_FIXUP_ACT_FREE:
4138 input_unregister_device(spec->kb_dev);
4139 spec->kb_dev = NULL;
4143 /* Line2 = mic mute hotkey
4144 * GPIO2 = mic mute LED
4146 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
4147 const struct hda_fixup *fix, int action)
4149 struct alc_spec *spec = codec->spec;
4151 alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4152 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4153 spec->init_amp = ALC_INIT_DEFAULT;
4154 if (alc_register_micmute_input_device(codec) != 0)
4157 snd_hda_jack_detect_enable_callback(codec, 0x1b,
4158 gpio2_mic_hotkey_event);
4166 case HDA_FIXUP_ACT_FREE:
4167 input_unregister_device(spec->kb_dev);
4168 spec->kb_dev = NULL;
4172 #define alc280_fixup_hp_gpio2_mic_hotkey NULL
4173 #define alc233_fixup_lenovo_line2_mic_hotkey NULL
4176 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
4177 const struct hda_fixup *fix, int action)
4179 struct alc_spec *spec = codec->spec;
4181 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
4182 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4183 spec->cap_mute_led_nid = 0x18;
4184 snd_hda_gen_add_micmute_led(codec, alc_cap_micmute_update);
4188 static const struct coef_fw alc225_pre_hsmode[] = {
4189 UPDATE_COEF(0x4a, 1<<8, 0),
4190 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4191 UPDATE_COEF(0x63, 3<<14, 3<<14),
4192 UPDATE_COEF(0x4a, 3<<4, 2<<4),
4193 UPDATE_COEF(0x4a, 3<<10, 3<<10),
4194 UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4195 UPDATE_COEF(0x4a, 3<<10, 0),
4199 static void alc_headset_mode_unplugged(struct hda_codec *codec)
4201 static const struct coef_fw coef0255[] = {
4202 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
4203 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4204 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4205 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4206 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
4209 static const struct coef_fw coef0256[] = {
4210 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
4211 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4212 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4213 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
4214 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4217 static const struct coef_fw coef0233[] = {
4218 WRITE_COEF(0x1b, 0x0c0b),
4219 WRITE_COEF(0x45, 0xc429),
4220 UPDATE_COEF(0x35, 0x4000, 0),
4221 WRITE_COEF(0x06, 0x2104),
4222 WRITE_COEF(0x1a, 0x0001),
4223 WRITE_COEF(0x26, 0x0004),
4224 WRITE_COEF(0x32, 0x42a3),
4227 static const struct coef_fw coef0288[] = {
4228 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4229 UPDATE_COEF(0x50, 0x2000, 0x2000),
4230 UPDATE_COEF(0x56, 0x0006, 0x0006),
4231 UPDATE_COEF(0x66, 0x0008, 0),
4232 UPDATE_COEF(0x67, 0x2000, 0),
4235 static const struct coef_fw coef0298[] = {
4236 UPDATE_COEF(0x19, 0x1300, 0x0300),
4239 static const struct coef_fw coef0292[] = {
4240 WRITE_COEF(0x76, 0x000e),
4241 WRITE_COEF(0x6c, 0x2400),
4242 WRITE_COEF(0x18, 0x7308),
4243 WRITE_COEF(0x6b, 0xc429),
4246 static const struct coef_fw coef0293[] = {
4247 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
4248 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
4249 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
4250 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
4251 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
4252 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4255 static const struct coef_fw coef0668[] = {
4256 WRITE_COEF(0x15, 0x0d40),
4257 WRITE_COEF(0xb7, 0x802b),
4260 static const struct coef_fw coef0225[] = {
4261 UPDATE_COEF(0x63, 3<<14, 0),
4264 static const struct coef_fw coef0274[] = {
4265 UPDATE_COEF(0x4a, 0x0100, 0),
4266 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
4267 UPDATE_COEF(0x6b, 0xf000, 0x5000),
4268 UPDATE_COEF(0x4a, 0x0010, 0),
4269 UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
4270 WRITE_COEF(0x45, 0x5289),
4271 UPDATE_COEF(0x4a, 0x0c00, 0),
4275 switch (codec->core.vendor_id) {
4277 alc_process_coef_fw(codec, coef0255);
4281 alc_process_coef_fw(codec, coef0256);
4286 alc_process_coef_fw(codec, coef0274);
4290 alc_process_coef_fw(codec, coef0233);
4294 alc_process_coef_fw(codec, coef0288);
4297 alc_process_coef_fw(codec, coef0298);
4298 alc_process_coef_fw(codec, coef0288);
4301 alc_process_coef_fw(codec, coef0292);
4304 alc_process_coef_fw(codec, coef0293);
4307 alc_process_coef_fw(codec, coef0668);
4315 alc_process_coef_fw(codec, alc225_pre_hsmode);
4316 alc_process_coef_fw(codec, coef0225);
4319 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4322 codec_dbg(codec, "Headset jack set to unplugged mode.\n");
4326 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
4329 static const struct coef_fw coef0255[] = {
4330 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
4331 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
4334 static const struct coef_fw coef0256[] = {
4335 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
4336 WRITE_COEFEX(0x57, 0x03, 0x09a3),
4337 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
4340 static const struct coef_fw coef0233[] = {
4341 UPDATE_COEF(0x35, 0, 1<<14),
4342 WRITE_COEF(0x06, 0x2100),
4343 WRITE_COEF(0x1a, 0x0021),
4344 WRITE_COEF(0x26, 0x008c),
4347 static const struct coef_fw coef0288[] = {
4348 UPDATE_COEF(0x4f, 0x00c0, 0),
4349 UPDATE_COEF(0x50, 0x2000, 0),
4350 UPDATE_COEF(0x56, 0x0006, 0),
4351 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4352 UPDATE_COEF(0x66, 0x0008, 0x0008),
4353 UPDATE_COEF(0x67, 0x2000, 0x2000),
4356 static const struct coef_fw coef0292[] = {
4357 WRITE_COEF(0x19, 0xa208),
4358 WRITE_COEF(0x2e, 0xacf0),
4361 static const struct coef_fw coef0293[] = {
4362 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
4363 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
4364 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
4367 static const struct coef_fw coef0688[] = {
4368 WRITE_COEF(0xb7, 0x802b),
4369 WRITE_COEF(0xb5, 0x1040),
4370 UPDATE_COEF(0xc3, 0, 1<<12),
4373 static const struct coef_fw coef0225[] = {
4374 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
4375 UPDATE_COEF(0x4a, 3<<4, 2<<4),
4376 UPDATE_COEF(0x63, 3<<14, 0),
4379 static const struct coef_fw coef0274[] = {
4380 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
4381 UPDATE_COEF(0x4a, 0x0010, 0),
4382 UPDATE_COEF(0x6b, 0xf000, 0),
4386 switch (codec->core.vendor_id) {
4388 alc_write_coef_idx(codec, 0x45, 0xc489);
4389 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4390 alc_process_coef_fw(codec, coef0255);
4391 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4395 alc_write_coef_idx(codec, 0x45, 0xc489);
4396 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4397 alc_process_coef_fw(codec, coef0256);
4398 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4403 alc_write_coef_idx(codec, 0x45, 0x4689);
4404 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4405 alc_process_coef_fw(codec, coef0274);
4406 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4410 alc_write_coef_idx(codec, 0x45, 0xc429);
4411 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4412 alc_process_coef_fw(codec, coef0233);
4413 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4418 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4419 alc_process_coef_fw(codec, coef0288);
4420 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4423 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4424 alc_process_coef_fw(codec, coef0292);
4427 /* Set to TRS mode */
4428 alc_write_coef_idx(codec, 0x45, 0xc429);
4429 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4430 alc_process_coef_fw(codec, coef0293);
4431 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4434 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
4438 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4439 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4442 alc_write_coef_idx(codec, 0x11, 0x0001);
4443 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4444 alc_process_coef_fw(codec, coef0688);
4445 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4453 alc_process_coef_fw(codec, alc225_pre_hsmode);
4454 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
4455 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4456 alc_process_coef_fw(codec, coef0225);
4457 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4460 codec_dbg(codec, "Headset jack set to mic-in mode.\n");
4463 static void alc_headset_mode_default(struct hda_codec *codec)
4465 static const struct coef_fw coef0225[] = {
4466 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
4467 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
4468 UPDATE_COEF(0x49, 3<<8, 0<<8),
4469 UPDATE_COEF(0x4a, 3<<4, 3<<4),
4470 UPDATE_COEF(0x63, 3<<14, 0),
4471 UPDATE_COEF(0x67, 0xf000, 0x3000),
4474 static const struct coef_fw coef0255[] = {
4475 WRITE_COEF(0x45, 0xc089),
4476 WRITE_COEF(0x45, 0xc489),
4477 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4478 WRITE_COEF(0x49, 0x0049),
4481 static const struct coef_fw coef0256[] = {
4482 WRITE_COEF(0x45, 0xc489),
4483 WRITE_COEFEX(0x57, 0x03, 0x0da3),
4484 WRITE_COEF(0x49, 0x0049),
4485 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4486 WRITE_COEF(0x06, 0x6100),
4489 static const struct coef_fw coef0233[] = {
4490 WRITE_COEF(0x06, 0x2100),
4491 WRITE_COEF(0x32, 0x4ea3),
4494 static const struct coef_fw coef0288[] = {
4495 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
4496 UPDATE_COEF(0x50, 0x2000, 0x2000),
4497 UPDATE_COEF(0x56, 0x0006, 0x0006),
4498 UPDATE_COEF(0x66, 0x0008, 0),
4499 UPDATE_COEF(0x67, 0x2000, 0),
4502 static const struct coef_fw coef0292[] = {
4503 WRITE_COEF(0x76, 0x000e),
4504 WRITE_COEF(0x6c, 0x2400),
4505 WRITE_COEF(0x6b, 0xc429),
4506 WRITE_COEF(0x18, 0x7308),
4509 static const struct coef_fw coef0293[] = {
4510 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4511 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
4512 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
4515 static const struct coef_fw coef0688[] = {
4516 WRITE_COEF(0x11, 0x0041),
4517 WRITE_COEF(0x15, 0x0d40),
4518 WRITE_COEF(0xb7, 0x802b),
4521 static const struct coef_fw coef0274[] = {
4522 WRITE_COEF(0x45, 0x4289),
4523 UPDATE_COEF(0x4a, 0x0010, 0x0010),
4524 UPDATE_COEF(0x6b, 0x0f00, 0),
4525 UPDATE_COEF(0x49, 0x0300, 0x0300),
4529 switch (codec->core.vendor_id) {
4536 alc_process_coef_fw(codec, alc225_pre_hsmode);
4537 alc_process_coef_fw(codec, coef0225);
4540 alc_process_coef_fw(codec, coef0255);
4544 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
4545 alc_write_coef_idx(codec, 0x45, 0xc089);
4547 alc_process_coef_fw(codec, coef0256);
4552 alc_process_coef_fw(codec, coef0274);
4556 alc_process_coef_fw(codec, coef0233);
4561 alc_process_coef_fw(codec, coef0288);
4564 alc_process_coef_fw(codec, coef0292);
4567 alc_process_coef_fw(codec, coef0293);
4570 alc_process_coef_fw(codec, coef0688);
4573 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4576 codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
4580 static void alc_headset_mode_ctia(struct hda_codec *codec)
4584 static const struct coef_fw coef0255[] = {
4585 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
4586 WRITE_COEF(0x1b, 0x0c2b),
4587 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4590 static const struct coef_fw coef0256[] = {
4591 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
4592 WRITE_COEF(0x1b, 0x0e6b),
4595 static const struct coef_fw coef0233[] = {
4596 WRITE_COEF(0x45, 0xd429),
4597 WRITE_COEF(0x1b, 0x0c2b),
4598 WRITE_COEF(0x32, 0x4ea3),
4601 static const struct coef_fw coef0288[] = {
4602 UPDATE_COEF(0x50, 0x2000, 0x2000),
4603 UPDATE_COEF(0x56, 0x0006, 0x0006),
4604 UPDATE_COEF(0x66, 0x0008, 0),
4605 UPDATE_COEF(0x67, 0x2000, 0),
4608 static const struct coef_fw coef0292[] = {
4609 WRITE_COEF(0x6b, 0xd429),
4610 WRITE_COEF(0x76, 0x0008),
4611 WRITE_COEF(0x18, 0x7388),
4614 static const struct coef_fw coef0293[] = {
4615 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
4616 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
4619 static const struct coef_fw coef0688[] = {
4620 WRITE_COEF(0x11, 0x0001),
4621 WRITE_COEF(0x15, 0x0d60),
4622 WRITE_COEF(0xc3, 0x0000),
4625 static const struct coef_fw coef0225_1[] = {
4626 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
4627 UPDATE_COEF(0x63, 3<<14, 2<<14),
4630 static const struct coef_fw coef0225_2[] = {
4631 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
4632 UPDATE_COEF(0x63, 3<<14, 1<<14),
4636 switch (codec->core.vendor_id) {
4638 alc_process_coef_fw(codec, coef0255);
4642 alc_process_coef_fw(codec, coef0256);
4647 alc_write_coef_idx(codec, 0x45, 0xd689);
4651 alc_process_coef_fw(codec, coef0233);
4654 val = alc_read_coef_idx(codec, 0x50);
4655 if (val & (1 << 12)) {
4656 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
4657 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4660 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
4661 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4667 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4669 alc_process_coef_fw(codec, coef0288);
4672 alc_process_coef_fw(codec, coef0292);
4675 alc_process_coef_fw(codec, coef0293);
4678 alc_process_coef_fw(codec, coef0688);
4686 val = alc_read_coef_idx(codec, 0x45);
4688 alc_process_coef_fw(codec, coef0225_2);
4690 alc_process_coef_fw(codec, coef0225_1);
4693 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4696 codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
4700 static void alc_headset_mode_omtp(struct hda_codec *codec)
4702 static const struct coef_fw coef0255[] = {
4703 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
4704 WRITE_COEF(0x1b, 0x0c2b),
4705 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4708 static const struct coef_fw coef0256[] = {
4709 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
4710 WRITE_COEF(0x1b, 0x0e6b),
4713 static const struct coef_fw coef0233[] = {
4714 WRITE_COEF(0x45, 0xe429),
4715 WRITE_COEF(0x1b, 0x0c2b),
4716 WRITE_COEF(0x32, 0x4ea3),
4719 static const struct coef_fw coef0288[] = {
4720 UPDATE_COEF(0x50, 0x2000, 0x2000),
4721 UPDATE_COEF(0x56, 0x0006, 0x0006),
4722 UPDATE_COEF(0x66, 0x0008, 0),
4723 UPDATE_COEF(0x67, 0x2000, 0),
4726 static const struct coef_fw coef0292[] = {
4727 WRITE_COEF(0x6b, 0xe429),
4728 WRITE_COEF(0x76, 0x0008),
4729 WRITE_COEF(0x18, 0x7388),
4732 static const struct coef_fw coef0293[] = {
4733 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
4734 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
4737 static const struct coef_fw coef0688[] = {
4738 WRITE_COEF(0x11, 0x0001),
4739 WRITE_COEF(0x15, 0x0d50),
4740 WRITE_COEF(0xc3, 0x0000),
4743 static const struct coef_fw coef0225[] = {
4744 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
4745 UPDATE_COEF(0x63, 3<<14, 2<<14),
4749 switch (codec->core.vendor_id) {
4751 alc_process_coef_fw(codec, coef0255);
4755 alc_process_coef_fw(codec, coef0256);
4760 alc_write_coef_idx(codec, 0x45, 0xe689);
4764 alc_process_coef_fw(codec, coef0233);
4767 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
4768 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
4773 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
4775 alc_process_coef_fw(codec, coef0288);
4778 alc_process_coef_fw(codec, coef0292);
4781 alc_process_coef_fw(codec, coef0293);
4784 alc_process_coef_fw(codec, coef0688);
4792 alc_process_coef_fw(codec, coef0225);
4795 codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
4798 static void alc_determine_headset_type(struct hda_codec *codec)
4801 bool is_ctia = false;
4802 struct alc_spec *spec = codec->spec;
4803 static const struct coef_fw coef0255[] = {
4804 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
4805 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
4809 static const struct coef_fw coef0288[] = {
4810 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
4813 static const struct coef_fw coef0298[] = {
4814 UPDATE_COEF(0x50, 0x2000, 0x2000),
4815 UPDATE_COEF(0x56, 0x0006, 0x0006),
4816 UPDATE_COEF(0x66, 0x0008, 0),
4817 UPDATE_COEF(0x67, 0x2000, 0),
4818 UPDATE_COEF(0x19, 0x1300, 0x1300),
4821 static const struct coef_fw coef0293[] = {
4822 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
4823 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
4826 static const struct coef_fw coef0688[] = {
4827 WRITE_COEF(0x11, 0x0001),
4828 WRITE_COEF(0xb7, 0x802b),
4829 WRITE_COEF(0x15, 0x0d60),
4830 WRITE_COEF(0xc3, 0x0c00),
4833 static const struct coef_fw coef0274[] = {
4834 UPDATE_COEF(0x4a, 0x0010, 0),
4835 UPDATE_COEF(0x4a, 0x8000, 0),
4836 WRITE_COEF(0x45, 0xd289),
4837 UPDATE_COEF(0x49, 0x0300, 0x0300),
4841 switch (codec->core.vendor_id) {
4843 alc_process_coef_fw(codec, coef0255);
4845 val = alc_read_coef_idx(codec, 0x46);
4846 is_ctia = (val & 0x0070) == 0x0070;
4850 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
4851 alc_write_coef_idx(codec, 0x06, 0x6104);
4852 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
4854 snd_hda_codec_write(codec, 0x21, 0,
4855 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
4857 snd_hda_codec_write(codec, 0x21, 0,
4858 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
4860 alc_process_coef_fw(codec, coef0255);
4862 val = alc_read_coef_idx(codec, 0x46);
4863 is_ctia = (val & 0x0070) == 0x0070;
4865 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
4866 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4868 snd_hda_codec_write(codec, 0x21, 0,
4869 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
4871 snd_hda_codec_write(codec, 0x21, 0,
4872 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
4877 alc_process_coef_fw(codec, coef0274);
4879 val = alc_read_coef_idx(codec, 0x46);
4880 is_ctia = (val & 0x00f0) == 0x00f0;
4884 alc_write_coef_idx(codec, 0x45, 0xd029);
4886 val = alc_read_coef_idx(codec, 0x46);
4887 is_ctia = (val & 0x0070) == 0x0070;
4890 snd_hda_codec_write(codec, 0x21, 0,
4891 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
4893 snd_hda_codec_write(codec, 0x21, 0,
4894 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
4897 val = alc_read_coef_idx(codec, 0x50);
4898 if (val & (1 << 12)) {
4899 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
4900 alc_process_coef_fw(codec, coef0288);
4902 val = alc_read_coef_idx(codec, 0x50);
4903 is_ctia = (val & 0x0070) == 0x0070;
4905 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
4906 alc_process_coef_fw(codec, coef0288);
4908 val = alc_read_coef_idx(codec, 0x50);
4909 is_ctia = (val & 0x0070) == 0x0070;
4911 alc_process_coef_fw(codec, coef0298);
4912 snd_hda_codec_write(codec, 0x21, 0,
4913 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
4915 snd_hda_codec_write(codec, 0x21, 0,
4916 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
4920 alc_process_coef_fw(codec, coef0288);
4922 val = alc_read_coef_idx(codec, 0x50);
4923 is_ctia = (val & 0x0070) == 0x0070;
4926 alc_write_coef_idx(codec, 0x6b, 0xd429);
4928 val = alc_read_coef_idx(codec, 0x6c);
4929 is_ctia = (val & 0x001c) == 0x001c;
4932 alc_process_coef_fw(codec, coef0293);
4934 val = alc_read_coef_idx(codec, 0x46);
4935 is_ctia = (val & 0x0070) == 0x0070;
4938 alc_process_coef_fw(codec, coef0688);
4940 val = alc_read_coef_idx(codec, 0xbe);
4941 is_ctia = (val & 0x1c02) == 0x1c02;
4949 snd_hda_codec_write(codec, 0x21, 0,
4950 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
4952 snd_hda_codec_write(codec, 0x21, 0,
4953 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
4955 alc_process_coef_fw(codec, alc225_pre_hsmode);
4956 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
4957 val = alc_read_coef_idx(codec, 0x45);
4958 if (val & (1 << 9)) {
4959 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
4960 alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
4962 val = alc_read_coef_idx(codec, 0x46);
4963 is_ctia = (val & 0x00f0) == 0x00f0;
4965 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
4966 alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
4968 val = alc_read_coef_idx(codec, 0x46);
4969 is_ctia = (val & 0x00f0) == 0x00f0;
4971 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
4972 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
4973 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
4975 snd_hda_codec_write(codec, 0x21, 0,
4976 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
4978 snd_hda_codec_write(codec, 0x21, 0,
4979 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
4986 codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
4987 is_ctia ? "yes" : "no");
4988 spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
4991 static void alc_update_headset_mode(struct hda_codec *codec)
4993 struct alc_spec *spec = codec->spec;
4995 hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
4996 hda_nid_t hp_pin = alc_get_hp_pin(spec);
4998 int new_headset_mode;
5000 if (!snd_hda_jack_detect(codec, hp_pin))
5001 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5002 else if (mux_pin == spec->headset_mic_pin)
5003 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5004 else if (mux_pin == spec->headphone_mic_pin)
5005 new_headset_mode = ALC_HEADSET_MODE_MIC;
5007 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5009 if (new_headset_mode == spec->current_headset_mode) {
5010 snd_hda_gen_update_outputs(codec);
5014 switch (new_headset_mode) {
5015 case ALC_HEADSET_MODE_UNPLUGGED:
5016 alc_headset_mode_unplugged(codec);
5017 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5018 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5019 spec->gen.hp_jack_present = false;
5021 case ALC_HEADSET_MODE_HEADSET:
5022 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5023 alc_determine_headset_type(codec);
5024 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5025 alc_headset_mode_ctia(codec);
5026 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5027 alc_headset_mode_omtp(codec);
5028 spec->gen.hp_jack_present = true;
5030 case ALC_HEADSET_MODE_MIC:
5031 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5032 spec->gen.hp_jack_present = false;
5034 case ALC_HEADSET_MODE_HEADPHONE:
5035 alc_headset_mode_default(codec);
5036 spec->gen.hp_jack_present = true;
5039 if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5040 snd_hda_set_pin_ctl_cache(codec, hp_pin,
5041 AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5042 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5043 snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5046 spec->current_headset_mode = new_headset_mode;
5048 snd_hda_gen_update_outputs(codec);
5051 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5052 struct snd_kcontrol *kcontrol,
5053 struct snd_ctl_elem_value *ucontrol)
5055 alc_update_headset_mode(codec);
5058 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5059 struct hda_jack_callback *jack)
5061 snd_hda_gen_hp_automute(codec, jack);
5064 static void alc_probe_headset_mode(struct hda_codec *codec)
5067 struct alc_spec *spec = codec->spec;
5068 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5071 for (i = 0; i < cfg->num_inputs; i++) {
5072 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
5073 spec->headset_mic_pin = cfg->inputs[i].pin;
5074 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
5075 spec->headphone_mic_pin = cfg->inputs[i].pin;
5078 WARN_ON(spec->gen.cap_sync_hook);
5079 spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
5080 spec->gen.automute_hook = alc_update_headset_mode;
5081 spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
5084 static void alc_fixup_headset_mode(struct hda_codec *codec,
5085 const struct hda_fixup *fix, int action)
5087 struct alc_spec *spec = codec->spec;
5090 case HDA_FIXUP_ACT_PRE_PROBE:
5091 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
5093 case HDA_FIXUP_ACT_PROBE:
5094 alc_probe_headset_mode(codec);
5096 case HDA_FIXUP_ACT_INIT:
5097 if (is_s3_resume(codec) || is_s4_resume(codec)) {
5098 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5099 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5101 alc_update_headset_mode(codec);
5106 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
5107 const struct hda_fixup *fix, int action)
5109 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5110 struct alc_spec *spec = codec->spec;
5111 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5114 alc_fixup_headset_mode(codec, fix, action);
5117 static void alc255_set_default_jack_type(struct hda_codec *codec)
5119 /* Set to iphone type */
5120 static const struct coef_fw alc255fw[] = {
5121 WRITE_COEF(0x1b, 0x880b),
5122 WRITE_COEF(0x45, 0xd089),
5123 WRITE_COEF(0x1b, 0x080b),
5124 WRITE_COEF(0x46, 0x0004),
5125 WRITE_COEF(0x1b, 0x0c0b),
5128 static const struct coef_fw alc256fw[] = {
5129 WRITE_COEF(0x1b, 0x884b),
5130 WRITE_COEF(0x45, 0xd089),
5131 WRITE_COEF(0x1b, 0x084b),
5132 WRITE_COEF(0x46, 0x0004),
5133 WRITE_COEF(0x1b, 0x0c4b),
5136 switch (codec->core.vendor_id) {
5138 alc_process_coef_fw(codec, alc255fw);
5142 alc_process_coef_fw(codec, alc256fw);
5148 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
5149 const struct hda_fixup *fix, int action)
5151 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5152 alc255_set_default_jack_type(codec);
5154 alc_fixup_headset_mode(codec, fix, action);
5157 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
5158 const struct hda_fixup *fix, int action)
5160 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5161 struct alc_spec *spec = codec->spec;
5162 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5163 alc255_set_default_jack_type(codec);
5166 alc_fixup_headset_mode(codec, fix, action);
5169 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
5170 struct hda_jack_callback *jack)
5172 struct alc_spec *spec = codec->spec;
5174 alc_update_headset_jack_cb(codec, jack);
5175 /* Headset Mic enable or disable, only for Dell Dino */
5176 alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
5179 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
5180 const struct hda_fixup *fix, int action)
5182 alc_fixup_headset_mode(codec, fix, action);
5183 if (action == HDA_FIXUP_ACT_PROBE) {
5184 struct alc_spec *spec = codec->spec;
5185 /* toggled via hp_automute_hook */
5186 spec->gpio_mask |= 0x40;
5187 spec->gpio_dir |= 0x40;
5188 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
5192 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
5193 const struct hda_fixup *fix, int action)
5195 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5196 struct alc_spec *spec = codec->spec;
5197 spec->gen.auto_mute_via_amp = 1;
5201 static void alc_fixup_no_shutup(struct hda_codec *codec,
5202 const struct hda_fixup *fix, int action)
5204 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5205 struct alc_spec *spec = codec->spec;
5206 spec->no_shutup_pins = 1;
5210 static void alc_fixup_disable_aamix(struct hda_codec *codec,
5211 const struct hda_fixup *fix, int action)
5213 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5214 struct alc_spec *spec = codec->spec;
5215 /* Disable AA-loopback as it causes white noise */
5216 spec->gen.mixer_nid = 0;
5220 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
5221 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
5222 const struct hda_fixup *fix, int action)
5224 static const struct hda_pintbl pincfgs[] = {
5225 { 0x16, 0x21211010 }, /* dock headphone */
5226 { 0x19, 0x21a11010 }, /* dock mic */
5229 struct alc_spec *spec = codec->spec;
5231 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5232 spec->reboot_notify = snd_hda_gen_reboot_notify; /* reduce noise */
5233 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5234 codec->power_save_node = 0; /* avoid click noises */
5235 snd_hda_apply_pincfgs(codec, pincfgs);
5239 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
5240 const struct hda_fixup *fix, int action)
5242 static const struct hda_pintbl pincfgs[] = {
5243 { 0x17, 0x21211010 }, /* dock headphone */
5244 { 0x19, 0x21a11010 }, /* dock mic */
5247 /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
5248 * the speaker output becomes too low by some reason on Thinkpads with
5251 static const hda_nid_t preferred_pairs[] = {
5252 0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
5255 struct alc_spec *spec = codec->spec;
5257 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5258 spec->gen.preferred_dacs = preferred_pairs;
5259 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5260 snd_hda_apply_pincfgs(codec, pincfgs);
5261 } else if (action == HDA_FIXUP_ACT_INIT) {
5262 /* Enable DOCK device */
5263 snd_hda_codec_write(codec, 0x17, 0,
5264 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5265 /* Enable DOCK device */
5266 snd_hda_codec_write(codec, 0x19, 0,
5267 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5271 static void alc_shutup_dell_xps13(struct hda_codec *codec)
5273 struct alc_spec *spec = codec->spec;
5274 int hp_pin = alc_get_hp_pin(spec);
5276 /* Prevent pop noises when headphones are plugged in */
5277 snd_hda_codec_write(codec, hp_pin, 0,
5278 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5282 static void alc_fixup_dell_xps13(struct hda_codec *codec,
5283 const struct hda_fixup *fix, int action)
5285 struct alc_spec *spec = codec->spec;
5286 struct hda_input_mux *imux = &spec->gen.input_mux;
5290 case HDA_FIXUP_ACT_PRE_PROBE:
5291 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
5292 * it causes a click noise at start up
5294 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
5295 spec->shutup = alc_shutup_dell_xps13;
5297 case HDA_FIXUP_ACT_PROBE:
5298 /* Make the internal mic the default input source. */
5299 for (i = 0; i < imux->num_items; i++) {
5300 if (spec->gen.imux_pins[i] == 0x12) {
5301 spec->gen.cur_mux[0] = i;
5309 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
5310 const struct hda_fixup *fix, int action)
5312 struct alc_spec *spec = codec->spec;
5314 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5315 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5316 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
5318 /* Disable boost for mic-in permanently. (This code is only called
5319 from quirks that guarantee that the headphone is at NID 0x1b.) */
5320 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
5321 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
5323 alc_fixup_headset_mode(codec, fix, action);
5326 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
5327 const struct hda_fixup *fix, int action)
5329 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5330 alc_write_coef_idx(codec, 0xc4, 0x8000);
5331 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
5332 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
5334 alc_fixup_headset_mode(codec, fix, action);
5337 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
5338 static int find_ext_mic_pin(struct hda_codec *codec)
5340 struct alc_spec *spec = codec->spec;
5341 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5343 unsigned int defcfg;
5346 for (i = 0; i < cfg->num_inputs; i++) {
5347 if (cfg->inputs[i].type != AUTO_PIN_MIC)
5349 nid = cfg->inputs[i].pin;
5350 defcfg = snd_hda_codec_get_pincfg(codec, nid);
5351 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
5359 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
5360 const struct hda_fixup *fix,
5363 struct alc_spec *spec = codec->spec;
5365 if (action == HDA_FIXUP_ACT_PROBE) {
5366 int mic_pin = find_ext_mic_pin(codec);
5367 int hp_pin = alc_get_hp_pin(spec);
5369 if (snd_BUG_ON(!mic_pin || !hp_pin))
5371 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
5375 static void alc256_fixup_dell_xps_13_headphone_noise2(struct hda_codec *codec,
5376 const struct hda_fixup *fix,
5379 if (action != HDA_FIXUP_ACT_PRE_PROBE)
5382 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 0, HDA_AMP_VOLMASK, 1);
5383 snd_hda_override_wcaps(codec, 0x1a, get_wcaps(codec, 0x1a) & ~AC_WCAP_IN_AMP);
5386 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
5387 const struct hda_fixup *fix,
5390 struct alc_spec *spec = codec->spec;
5391 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5394 /* The mic boosts on level 2 and 3 are too noisy
5395 on the internal mic input.
5396 Therefore limit the boost to 0 or 1. */
5398 if (action != HDA_FIXUP_ACT_PROBE)
5401 for (i = 0; i < cfg->num_inputs; i++) {
5402 hda_nid_t nid = cfg->inputs[i].pin;
5403 unsigned int defcfg;
5404 if (cfg->inputs[i].type != AUTO_PIN_MIC)
5406 defcfg = snd_hda_codec_get_pincfg(codec, nid);
5407 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
5410 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
5411 (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
5412 (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5413 (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
5414 (0 << AC_AMPCAP_MUTE_SHIFT));
5418 static void alc283_hp_automute_hook(struct hda_codec *codec,
5419 struct hda_jack_callback *jack)
5421 struct alc_spec *spec = codec->spec;
5425 snd_hda_gen_hp_automute(codec, jack);
5427 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
5430 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5434 static void alc283_fixup_chromebook(struct hda_codec *codec,
5435 const struct hda_fixup *fix, int action)
5437 struct alc_spec *spec = codec->spec;
5440 case HDA_FIXUP_ACT_PRE_PROBE:
5441 snd_hda_override_wcaps(codec, 0x03, 0);
5442 /* Disable AA-loopback as it causes white noise */
5443 spec->gen.mixer_nid = 0;
5445 case HDA_FIXUP_ACT_INIT:
5446 /* MIC2-VREF control */
5447 /* Set to manual mode */
5448 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
5449 /* Enable Line1 input control by verb */
5450 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
5455 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
5456 const struct hda_fixup *fix, int action)
5458 struct alc_spec *spec = codec->spec;
5461 case HDA_FIXUP_ACT_PRE_PROBE:
5462 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
5464 case HDA_FIXUP_ACT_INIT:
5465 /* MIC2-VREF control */
5466 /* Set to manual mode */
5467 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
5472 /* mute tablet speaker pin (0x14) via dock plugging in addition */
5473 static void asus_tx300_automute(struct hda_codec *codec)
5475 struct alc_spec *spec = codec->spec;
5476 snd_hda_gen_update_outputs(codec);
5477 if (snd_hda_jack_detect(codec, 0x1b))
5478 spec->gen.mute_bits |= (1ULL << 0x14);
5481 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
5482 const struct hda_fixup *fix, int action)
5484 struct alc_spec *spec = codec->spec;
5485 static const struct hda_pintbl dock_pins[] = {
5486 { 0x1b, 0x21114000 }, /* dock speaker pin */
5491 case HDA_FIXUP_ACT_PRE_PROBE:
5492 spec->init_amp = ALC_INIT_DEFAULT;
5493 /* TX300 needs to set up GPIO2 for the speaker amp */
5494 alc_setup_gpio(codec, 0x04);
5495 snd_hda_apply_pincfgs(codec, dock_pins);
5496 spec->gen.auto_mute_via_amp = 1;
5497 spec->gen.automute_hook = asus_tx300_automute;
5498 snd_hda_jack_detect_enable_callback(codec, 0x1b,
5499 snd_hda_gen_hp_automute);
5501 case HDA_FIXUP_ACT_PROBE:
5502 spec->init_amp = ALC_INIT_DEFAULT;
5504 case HDA_FIXUP_ACT_BUILD:
5505 /* this is a bit tricky; give more sane names for the main
5506 * (tablet) speaker and the dock speaker, respectively
5508 rename_ctl(codec, "Speaker Playback Switch",
5509 "Dock Speaker Playback Switch");
5510 rename_ctl(codec, "Bass Speaker Playback Switch",
5511 "Speaker Playback Switch");
5516 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
5517 const struct hda_fixup *fix, int action)
5519 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5520 /* DAC node 0x03 is giving mono output. We therefore want to
5521 make sure 0x14 (front speaker) and 0x15 (headphones) use the
5522 stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
5523 static const hda_nid_t conn1[] = { 0x0c };
5524 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
5525 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
5529 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
5530 const struct hda_fixup *fix, int action)
5532 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5533 /* The speaker is routed to the Node 0x06 by a mistake, as a result
5534 we can't adjust the speaker's volume since this node does not has
5535 Amp-out capability. we change the speaker's route to:
5536 Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
5537 Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
5538 speaker's volume now. */
5540 static const hda_nid_t conn1[] = { 0x0c };
5541 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
5545 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
5546 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
5547 const struct hda_fixup *fix, int action)
5549 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5550 static const hda_nid_t conn[] = { 0x02, 0x03 };
5551 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
5555 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
5556 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
5557 const struct hda_fixup *fix, int action)
5559 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5560 static const hda_nid_t conn[] = { 0x02 };
5561 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
5565 /* Hook to update amp GPIO4 for automute */
5566 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
5567 struct hda_jack_callback *jack)
5569 struct alc_spec *spec = codec->spec;
5571 snd_hda_gen_hp_automute(codec, jack);
5572 /* mute_led_polarity is set to 0, so we pass inverted value here */
5573 alc_update_gpio_led(codec, 0x10, !spec->gen.hp_jack_present);
5576 /* Manage GPIOs for HP EliteBook Folio 9480m.
5578 * GPIO4 is the headphone amplifier power control
5579 * GPIO3 is the audio output mute indicator LED
5582 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
5583 const struct hda_fixup *fix,
5586 struct alc_spec *spec = codec->spec;
5588 alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
5589 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5590 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
5591 spec->gpio_mask |= 0x10;
5592 spec->gpio_dir |= 0x10;
5593 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
5597 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
5598 const struct hda_fixup *fix,
5601 struct alc_spec *spec = codec->spec;
5603 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5604 spec->gpio_mask |= 0x04;
5605 spec->gpio_dir |= 0x04;
5606 /* set data bit low */
5610 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
5611 const struct hda_fixup *fix,
5614 alc_fixup_dual_codecs(codec, fix, action);
5616 case HDA_FIXUP_ACT_PRE_PROBE:
5617 /* override card longname to provide a unique UCM profile */
5618 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
5620 case HDA_FIXUP_ACT_BUILD:
5621 /* rename Capture controls depending on the codec */
5622 rename_ctl(codec, "Capture Volume",
5624 "Rear-Panel Capture Volume" :
5625 "Front-Panel Capture Volume");
5626 rename_ctl(codec, "Capture Switch",
5628 "Rear-Panel Capture Switch" :
5629 "Front-Panel Capture Switch");
5634 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
5635 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
5636 const struct hda_fixup *fix, int action)
5638 struct alc_spec *spec = codec->spec;
5639 static const hda_nid_t preferred_pairs[] = {
5640 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
5644 if (action != HDA_FIXUP_ACT_PRE_PROBE)
5647 spec->gen.preferred_dacs = preferred_pairs;
5648 spec->gen.auto_mute_via_amp = 1;
5649 codec->power_save_node = 0;
5652 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
5653 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
5654 const struct hda_fixup *fix, int action)
5656 if (action != HDA_FIXUP_ACT_PRE_PROBE)
5659 snd_hda_override_wcaps(codec, 0x03, 0);
5662 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
5663 { SND_JACK_BTN_0, KEY_PLAYPAUSE },
5664 { SND_JACK_BTN_1, KEY_VOICECOMMAND },
5665 { SND_JACK_BTN_2, KEY_VOLUMEUP },
5666 { SND_JACK_BTN_3, KEY_VOLUMEDOWN },
5670 static void alc_headset_btn_callback(struct hda_codec *codec,
5671 struct hda_jack_callback *jack)
5675 if (jack->unsol_res & (7 << 13))
5676 report |= SND_JACK_BTN_0;
5678 if (jack->unsol_res & (1 << 16 | 3 << 8))
5679 report |= SND_JACK_BTN_1;
5682 if (jack->unsol_res & (7 << 23))
5683 report |= SND_JACK_BTN_2;
5685 /* Volume down key */
5686 if (jack->unsol_res & (7 << 10))
5687 report |= SND_JACK_BTN_3;
5689 jack->jack->button_state = report;
5692 static void alc_fixup_headset_jack(struct hda_codec *codec,
5693 const struct hda_fixup *fix, int action)
5697 case HDA_FIXUP_ACT_PRE_PROBE:
5698 snd_hda_jack_detect_enable_callback(codec, 0x55,
5699 alc_headset_btn_callback);
5700 snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", false,
5701 SND_JACK_HEADSET, alc_headset_btn_keymap);
5703 case HDA_FIXUP_ACT_INIT:
5704 switch (codec->core.vendor_id) {
5711 alc_write_coef_idx(codec, 0x48, 0xd011);
5712 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
5713 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
5717 alc_write_coef_idx(codec, 0x48, 0xd011);
5718 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
5725 static void alc295_fixup_chromebook(struct hda_codec *codec,
5726 const struct hda_fixup *fix, int action)
5728 struct alc_spec *spec = codec->spec;
5731 case HDA_FIXUP_ACT_PRE_PROBE:
5732 spec->ultra_low_power = true;
5734 case HDA_FIXUP_ACT_INIT:
5735 switch (codec->core.vendor_id) {
5737 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
5738 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
5741 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
5742 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
5749 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
5750 const struct hda_fixup *fix, int action)
5752 if (action == HDA_FIXUP_ACT_PRE_PROBE)
5753 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
5756 /* for hda_fixup_thinkpad_acpi() */
5757 #include "thinkpad_helper.c"
5759 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
5760 const struct hda_fixup *fix, int action)
5762 alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
5763 hda_fixup_thinkpad_acpi(codec, fix, action);
5766 /* for alc295_fixup_hp_top_speakers */
5767 #include "hp_x360_helper.c"
5770 ALC269_FIXUP_SONY_VAIO,
5771 ALC275_FIXUP_SONY_VAIO_GPIO2,
5772 ALC269_FIXUP_DELL_M101Z,
5773 ALC269_FIXUP_SKU_IGNORE,
5774 ALC269_FIXUP_ASUS_G73JW,
5775 ALC269_FIXUP_LENOVO_EAPD,
5776 ALC275_FIXUP_SONY_HWEQ,
5777 ALC275_FIXUP_SONY_DISABLE_AAMIX,
5779 ALC269_FIXUP_PCM_44K,
5780 ALC269_FIXUP_STEREO_DMIC,
5781 ALC269_FIXUP_HEADSET_MIC,
5782 ALC269_FIXUP_QUANTA_MUTE,
5783 ALC269_FIXUP_LIFEBOOK,
5784 ALC269_FIXUP_LIFEBOOK_EXTMIC,
5785 ALC269_FIXUP_LIFEBOOK_HP_PIN,
5786 ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
5787 ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
5790 ALC269VB_FIXUP_AMIC,
5791 ALC269VB_FIXUP_DMIC,
5792 ALC269_FIXUP_HP_MUTE_LED,
5793 ALC269_FIXUP_HP_MUTE_LED_MIC1,
5794 ALC269_FIXUP_HP_MUTE_LED_MIC2,
5795 ALC269_FIXUP_HP_MUTE_LED_MIC3,
5796 ALC269_FIXUP_HP_GPIO_LED,
5797 ALC269_FIXUP_HP_GPIO_MIC1_LED,
5798 ALC269_FIXUP_HP_LINE1_MIC1_LED,
5799 ALC269_FIXUP_INV_DMIC,
5800 ALC269_FIXUP_LENOVO_DOCK,
5801 ALC269_FIXUP_NO_SHUTUP,
5802 ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
5803 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
5804 ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5805 ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
5806 ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
5807 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
5808 ALC269_FIXUP_HEADSET_MODE,
5809 ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
5810 ALC269_FIXUP_ASPIRE_HEADSET_MIC,
5811 ALC269_FIXUP_ASUS_X101_FUNC,
5812 ALC269_FIXUP_ASUS_X101_VERB,
5813 ALC269_FIXUP_ASUS_X101,
5814 ALC271_FIXUP_AMIC_MIC2,
5815 ALC271_FIXUP_HP_GATE_MIC_JACK,
5816 ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
5817 ALC269_FIXUP_ACER_AC700,
5818 ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
5819 ALC269VB_FIXUP_ASUS_ZENBOOK,
5820 ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
5821 ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
5822 ALC269VB_FIXUP_ORDISSIMO_EVE2,
5823 ALC283_FIXUP_CHROME_BOOK,
5824 ALC283_FIXUP_SENSE_COMBO_JACK,
5825 ALC282_FIXUP_ASUS_TX300,
5826 ALC283_FIXUP_INT_MIC,
5827 ALC290_FIXUP_MONO_SPEAKERS,
5828 ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
5829 ALC290_FIXUP_SUBWOOFER,
5830 ALC290_FIXUP_SUBWOOFER_HSJACK,
5831 ALC269_FIXUP_THINKPAD_ACPI,
5832 ALC269_FIXUP_DMIC_THINKPAD_ACPI,
5833 ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
5834 ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
5835 ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5836 ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
5837 ALC255_FIXUP_HEADSET_MODE,
5838 ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
5839 ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
5840 ALC292_FIXUP_TPT440_DOCK,
5841 ALC292_FIXUP_TPT440,
5842 ALC283_FIXUP_HEADSET_MIC,
5843 ALC255_FIXUP_MIC_MUTE_LED,
5844 ALC282_FIXUP_ASPIRE_V5_PINS,
5845 ALC280_FIXUP_HP_GPIO4,
5846 ALC286_FIXUP_HP_GPIO_LED,
5847 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
5848 ALC280_FIXUP_HP_DOCK_PINS,
5849 ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
5850 ALC280_FIXUP_HP_9480M,
5851 ALC288_FIXUP_DELL_HEADSET_MODE,
5852 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
5853 ALC288_FIXUP_DELL_XPS_13,
5854 ALC288_FIXUP_DISABLE_AAMIX,
5855 ALC292_FIXUP_DELL_E7X_AAMIX,
5856 ALC292_FIXUP_DELL_E7X,
5857 ALC292_FIXUP_DISABLE_AAMIX,
5858 ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
5859 ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
5860 ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
5861 ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
5862 ALC275_FIXUP_DELL_XPS,
5863 ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE,
5864 ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE2,
5865 ALC293_FIXUP_LENOVO_SPK_NOISE,
5866 ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
5867 ALC255_FIXUP_DELL_SPK_NOISE,
5868 ALC225_FIXUP_DISABLE_MIC_VREF,
5869 ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
5870 ALC295_FIXUP_DISABLE_DAC3,
5871 ALC285_FIXUP_SPEAKER2_TO_DAC1,
5872 ALC280_FIXUP_HP_HEADSET_MIC,
5873 ALC221_FIXUP_HP_FRONT_MIC,
5874 ALC292_FIXUP_TPT460,
5875 ALC298_FIXUP_SPK_VOLUME,
5876 ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
5877 ALC269_FIXUP_ATIV_BOOK_8,
5878 ALC221_FIXUP_HP_MIC_NO_PRESENCE,
5879 ALC256_FIXUP_ASUS_HEADSET_MODE,
5880 ALC256_FIXUP_ASUS_MIC,
5881 ALC256_FIXUP_ASUS_AIO_GPIO2,
5882 ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
5883 ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
5884 ALC233_FIXUP_LENOVO_MULTI_CODECS,
5885 ALC233_FIXUP_ACER_HEADSET_MIC,
5886 ALC294_FIXUP_LENOVO_MIC_LOCATION,
5887 ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
5888 ALC700_FIXUP_INTEL_REFERENCE,
5889 ALC274_FIXUP_DELL_BIND_DACS,
5890 ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
5891 ALC298_FIXUP_TPT470_DOCK,
5892 ALC255_FIXUP_DUMMY_LINEOUT_VERB,
5893 ALC255_FIXUP_DELL_HEADSET_MIC,
5894 ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
5895 ALC298_FIXUP_HUAWEI_MBX_STEREO,
5896 ALC295_FIXUP_HP_X360,
5897 ALC221_FIXUP_HP_HEADSET_MIC,
5898 ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
5899 ALC295_FIXUP_HP_AUTO_MUTE,
5900 ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
5901 ALC294_FIXUP_ASUS_MIC,
5902 ALC294_FIXUP_ASUS_HEADSET_MIC,
5903 ALC294_FIXUP_ASUS_SPK,
5904 ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
5905 ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
5906 ALC255_FIXUP_ACER_HEADSET_MIC,
5907 ALC295_FIXUP_CHROME_BOOK,
5908 ALC225_FIXUP_HEADSET_JACK,
5909 ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
5910 ALC225_FIXUP_WYSE_AUTO_MUTE,
5911 ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
5912 ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
5913 ALC256_FIXUP_ASUS_HEADSET_MIC,
5914 ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
5915 ALC299_FIXUP_PREDATOR_SPK,
5916 ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
5917 ALC289_FIXUP_DELL_SPK2,
5918 ALC289_FIXUP_DUAL_SPK,
5919 ALC294_FIXUP_SPK2_TO_DAC1,
5920 ALC294_FIXUP_ASUS_DUAL_SPK,
5924 static const struct hda_fixup alc269_fixups[] = {
5925 [ALC269_FIXUP_SONY_VAIO] = {
5926 .type = HDA_FIXUP_PINCTLS,
5927 .v.pins = (const struct hda_pintbl[]) {
5928 {0x19, PIN_VREFGRD},
5932 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
5933 .type = HDA_FIXUP_FUNC,
5934 .v.func = alc275_fixup_gpio4_off,
5936 .chain_id = ALC269_FIXUP_SONY_VAIO
5938 [ALC269_FIXUP_DELL_M101Z] = {
5939 .type = HDA_FIXUP_VERBS,
5940 .v.verbs = (const struct hda_verb[]) {
5941 /* Enables internal speaker */
5942 {0x20, AC_VERB_SET_COEF_INDEX, 13},
5943 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
5947 [ALC269_FIXUP_SKU_IGNORE] = {
5948 .type = HDA_FIXUP_FUNC,
5949 .v.func = alc_fixup_sku_ignore,
5951 [ALC269_FIXUP_ASUS_G73JW] = {
5952 .type = HDA_FIXUP_PINS,
5953 .v.pins = (const struct hda_pintbl[]) {
5954 { 0x17, 0x99130111 }, /* subwoofer */
5958 [ALC269_FIXUP_LENOVO_EAPD] = {
5959 .type = HDA_FIXUP_VERBS,
5960 .v.verbs = (const struct hda_verb[]) {
5961 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5965 [ALC275_FIXUP_SONY_HWEQ] = {
5966 .type = HDA_FIXUP_FUNC,
5967 .v.func = alc269_fixup_hweq,
5969 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
5971 [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
5972 .type = HDA_FIXUP_FUNC,
5973 .v.func = alc_fixup_disable_aamix,
5975 .chain_id = ALC269_FIXUP_SONY_VAIO
5977 [ALC271_FIXUP_DMIC] = {
5978 .type = HDA_FIXUP_FUNC,
5979 .v.func = alc271_fixup_dmic,
5981 [ALC269_FIXUP_PCM_44K] = {
5982 .type = HDA_FIXUP_FUNC,
5983 .v.func = alc269_fixup_pcm_44k,
5985 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5987 [ALC269_FIXUP_STEREO_DMIC] = {
5988 .type = HDA_FIXUP_FUNC,
5989 .v.func = alc269_fixup_stereo_dmic,
5991 [ALC269_FIXUP_HEADSET_MIC] = {
5992 .type = HDA_FIXUP_FUNC,
5993 .v.func = alc269_fixup_headset_mic,
5995 [ALC269_FIXUP_QUANTA_MUTE] = {
5996 .type = HDA_FIXUP_FUNC,
5997 .v.func = alc269_fixup_quanta_mute,
5999 [ALC269_FIXUP_LIFEBOOK] = {
6000 .type = HDA_FIXUP_PINS,
6001 .v.pins = (const struct hda_pintbl[]) {
6002 { 0x1a, 0x2101103f }, /* dock line-out */
6003 { 0x1b, 0x23a11040 }, /* dock mic-in */
6007 .chain_id = ALC269_FIXUP_QUANTA_MUTE
6009 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
6010 .type = HDA_FIXUP_PINS,
6011 .v.pins = (const struct hda_pintbl[]) {
6012 { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
6016 [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
6017 .type = HDA_FIXUP_PINS,
6018 .v.pins = (const struct hda_pintbl[]) {
6019 { 0x21, 0x0221102f }, /* HP out */
6023 [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
6024 .type = HDA_FIXUP_FUNC,
6025 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
6027 [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
6028 .type = HDA_FIXUP_FUNC,
6029 .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
6031 [ALC269_FIXUP_AMIC] = {
6032 .type = HDA_FIXUP_PINS,
6033 .v.pins = (const struct hda_pintbl[]) {
6034 { 0x14, 0x99130110 }, /* speaker */
6035 { 0x15, 0x0121401f }, /* HP out */
6036 { 0x18, 0x01a19c20 }, /* mic */
6037 { 0x19, 0x99a3092f }, /* int-mic */
6041 [ALC269_FIXUP_DMIC] = {
6042 .type = HDA_FIXUP_PINS,
6043 .v.pins = (const struct hda_pintbl[]) {
6044 { 0x12, 0x99a3092f }, /* int-mic */
6045 { 0x14, 0x99130110 }, /* speaker */
6046 { 0x15, 0x0121401f }, /* HP out */
6047 { 0x18, 0x01a19c20 }, /* mic */
6051 [ALC269VB_FIXUP_AMIC] = {
6052 .type = HDA_FIXUP_PINS,
6053 .v.pins = (const struct hda_pintbl[]) {
6054 { 0x14, 0x99130110 }, /* speaker */
6055 { 0x18, 0x01a19c20 }, /* mic */
6056 { 0x19, 0x99a3092f }, /* int-mic */
6057 { 0x21, 0x0121401f }, /* HP out */
6061 [ALC269VB_FIXUP_DMIC] = {
6062 .type = HDA_FIXUP_PINS,
6063 .v.pins = (const struct hda_pintbl[]) {
6064 { 0x12, 0x99a3092f }, /* int-mic */
6065 { 0x14, 0x99130110 }, /* speaker */
6066 { 0x18, 0x01a19c20 }, /* mic */
6067 { 0x21, 0x0121401f }, /* HP out */
6071 [ALC269_FIXUP_HP_MUTE_LED] = {
6072 .type = HDA_FIXUP_FUNC,
6073 .v.func = alc269_fixup_hp_mute_led,
6075 [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
6076 .type = HDA_FIXUP_FUNC,
6077 .v.func = alc269_fixup_hp_mute_led_mic1,
6079 [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
6080 .type = HDA_FIXUP_FUNC,
6081 .v.func = alc269_fixup_hp_mute_led_mic2,
6083 [ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
6084 .type = HDA_FIXUP_FUNC,
6085 .v.func = alc269_fixup_hp_mute_led_mic3,
6087 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE
6089 [ALC269_FIXUP_HP_GPIO_LED] = {
6090 .type = HDA_FIXUP_FUNC,
6091 .v.func = alc269_fixup_hp_gpio_led,
6093 [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
6094 .type = HDA_FIXUP_FUNC,
6095 .v.func = alc269_fixup_hp_gpio_mic1_led,
6097 [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
6098 .type = HDA_FIXUP_FUNC,
6099 .v.func = alc269_fixup_hp_line1_mic1_led,
6101 [ALC269_FIXUP_INV_DMIC] = {
6102 .type = HDA_FIXUP_FUNC,
6103 .v.func = alc_fixup_inv_dmic,
6105 [ALC269_FIXUP_NO_SHUTUP] = {
6106 .type = HDA_FIXUP_FUNC,
6107 .v.func = alc_fixup_no_shutup,
6109 [ALC269_FIXUP_LENOVO_DOCK] = {
6110 .type = HDA_FIXUP_PINS,
6111 .v.pins = (const struct hda_pintbl[]) {
6112 { 0x19, 0x23a11040 }, /* dock mic */
6113 { 0x1b, 0x2121103f }, /* dock headphone */
6117 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
6119 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
6120 .type = HDA_FIXUP_FUNC,
6121 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
6123 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6125 [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6126 .type = HDA_FIXUP_PINS,
6127 .v.pins = (const struct hda_pintbl[]) {
6128 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6129 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6133 .chain_id = ALC269_FIXUP_HEADSET_MODE
6135 [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
6136 .type = HDA_FIXUP_PINS,
6137 .v.pins = (const struct hda_pintbl[]) {
6138 { 0x16, 0x21014020 }, /* dock line out */
6139 { 0x19, 0x21a19030 }, /* dock mic */
6140 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6144 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6146 [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
6147 .type = HDA_FIXUP_PINS,
6148 .v.pins = (const struct hda_pintbl[]) {
6149 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6153 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6155 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
6156 .type = HDA_FIXUP_PINS,
6157 .v.pins = (const struct hda_pintbl[]) {
6158 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6159 { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6163 .chain_id = ALC269_FIXUP_HEADSET_MODE
6165 [ALC269_FIXUP_HEADSET_MODE] = {
6166 .type = HDA_FIXUP_FUNC,
6167 .v.func = alc_fixup_headset_mode,
6169 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6171 [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
6172 .type = HDA_FIXUP_FUNC,
6173 .v.func = alc_fixup_headset_mode_no_hp_mic,
6175 [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
6176 .type = HDA_FIXUP_PINS,
6177 .v.pins = (const struct hda_pintbl[]) {
6178 { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
6182 .chain_id = ALC269_FIXUP_HEADSET_MODE,
6184 [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
6185 .type = HDA_FIXUP_PINS,
6186 .v.pins = (const struct hda_pintbl[]) {
6187 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6191 .chain_id = ALC269_FIXUP_HEADSET_MIC
6193 [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
6194 .type = HDA_FIXUP_PINS,
6195 .v.pins = (const struct hda_pintbl[]) {
6209 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6211 [ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
6212 .type = HDA_FIXUP_FUNC,
6213 .v.func = alc298_fixup_huawei_mbx_stereo,
6215 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6217 [ALC269_FIXUP_ASUS_X101_FUNC] = {
6218 .type = HDA_FIXUP_FUNC,
6219 .v.func = alc269_fixup_x101_headset_mic,
6221 [ALC269_FIXUP_ASUS_X101_VERB] = {
6222 .type = HDA_FIXUP_VERBS,
6223 .v.verbs = (const struct hda_verb[]) {
6224 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6225 {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
6226 {0x20, AC_VERB_SET_PROC_COEF, 0x0310},
6230 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
6232 [ALC269_FIXUP_ASUS_X101] = {
6233 .type = HDA_FIXUP_PINS,
6234 .v.pins = (const struct hda_pintbl[]) {
6235 { 0x18, 0x04a1182c }, /* Headset mic */
6239 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
6241 [ALC271_FIXUP_AMIC_MIC2] = {
6242 .type = HDA_FIXUP_PINS,
6243 .v.pins = (const struct hda_pintbl[]) {
6244 { 0x14, 0x99130110 }, /* speaker */
6245 { 0x19, 0x01a19c20 }, /* mic */
6246 { 0x1b, 0x99a7012f }, /* int-mic */
6247 { 0x21, 0x0121401f }, /* HP out */
6251 [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
6252 .type = HDA_FIXUP_FUNC,
6253 .v.func = alc271_hp_gate_mic_jack,
6255 .chain_id = ALC271_FIXUP_AMIC_MIC2,
6257 [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
6258 .type = HDA_FIXUP_FUNC,
6259 .v.func = alc269_fixup_limit_int_mic_boost,
6261 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
6263 [ALC269_FIXUP_ACER_AC700] = {
6264 .type = HDA_FIXUP_PINS,
6265 .v.pins = (const struct hda_pintbl[]) {
6266 { 0x12, 0x99a3092f }, /* int-mic */
6267 { 0x14, 0x99130110 }, /* speaker */
6268 { 0x18, 0x03a11c20 }, /* mic */
6269 { 0x1e, 0x0346101e }, /* SPDIF1 */
6270 { 0x21, 0x0321101f }, /* HP out */
6274 .chain_id = ALC271_FIXUP_DMIC,
6276 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
6277 .type = HDA_FIXUP_FUNC,
6278 .v.func = alc269_fixup_limit_int_mic_boost,
6280 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6282 [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
6283 .type = HDA_FIXUP_FUNC,
6284 .v.func = alc269_fixup_limit_int_mic_boost,
6286 .chain_id = ALC269VB_FIXUP_DMIC,
6288 [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
6289 .type = HDA_FIXUP_VERBS,
6290 .v.verbs = (const struct hda_verb[]) {
6291 /* class-D output amp +5dB */
6292 { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
6293 { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
6297 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
6299 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
6300 .type = HDA_FIXUP_FUNC,
6301 .v.func = alc269_fixup_limit_int_mic_boost,
6303 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
6305 [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
6306 .type = HDA_FIXUP_PINS,
6307 .v.pins = (const struct hda_pintbl[]) {
6308 { 0x12, 0x99a3092f }, /* int-mic */
6309 { 0x18, 0x03a11d20 }, /* mic */
6310 { 0x19, 0x411111f0 }, /* Unused bogus pin */
6314 [ALC283_FIXUP_CHROME_BOOK] = {
6315 .type = HDA_FIXUP_FUNC,
6316 .v.func = alc283_fixup_chromebook,
6318 [ALC283_FIXUP_SENSE_COMBO_JACK] = {
6319 .type = HDA_FIXUP_FUNC,
6320 .v.func = alc283_fixup_sense_combo_jack,
6322 .chain_id = ALC283_FIXUP_CHROME_BOOK,
6324 [ALC282_FIXUP_ASUS_TX300] = {
6325 .type = HDA_FIXUP_FUNC,
6326 .v.func = alc282_fixup_asus_tx300,
6328 [ALC283_FIXUP_INT_MIC] = {
6329 .type = HDA_FIXUP_VERBS,
6330 .v.verbs = (const struct hda_verb[]) {
6331 {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
6332 {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
6336 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
6338 [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
6339 .type = HDA_FIXUP_PINS,
6340 .v.pins = (const struct hda_pintbl[]) {
6341 { 0x17, 0x90170112 }, /* subwoofer */
6345 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
6347 [ALC290_FIXUP_SUBWOOFER] = {
6348 .type = HDA_FIXUP_PINS,
6349 .v.pins = (const struct hda_pintbl[]) {
6350 { 0x17, 0x90170112 }, /* subwoofer */
6354 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
6356 [ALC290_FIXUP_MONO_SPEAKERS] = {
6357 .type = HDA_FIXUP_FUNC,
6358 .v.func = alc290_fixup_mono_speakers,
6360 [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
6361 .type = HDA_FIXUP_FUNC,
6362 .v.func = alc290_fixup_mono_speakers,
6364 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
6366 [ALC269_FIXUP_THINKPAD_ACPI] = {
6367 .type = HDA_FIXUP_FUNC,
6368 .v.func = alc_fixup_thinkpad_acpi,
6370 .chain_id = ALC269_FIXUP_SKU_IGNORE,
6372 [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
6373 .type = HDA_FIXUP_FUNC,
6374 .v.func = alc_fixup_inv_dmic,
6376 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6378 [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
6379 .type = HDA_FIXUP_PINS,
6380 .v.pins = (const struct hda_pintbl[]) {
6381 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6385 .chain_id = ALC255_FIXUP_HEADSET_MODE
6387 [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
6388 .type = HDA_FIXUP_PINS,
6389 .v.pins = (const struct hda_pintbl[]) {
6390 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6394 .chain_id = ALC255_FIXUP_HEADSET_MODE
6396 [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6397 .type = HDA_FIXUP_PINS,
6398 .v.pins = (const struct hda_pintbl[]) {
6399 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6400 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6404 .chain_id = ALC255_FIXUP_HEADSET_MODE
6406 [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
6407 .type = HDA_FIXUP_PINS,
6408 .v.pins = (const struct hda_pintbl[]) {
6409 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6413 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
6415 [ALC255_FIXUP_HEADSET_MODE] = {
6416 .type = HDA_FIXUP_FUNC,
6417 .v.func = alc_fixup_headset_mode_alc255,
6419 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6421 [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
6422 .type = HDA_FIXUP_FUNC,
6423 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
6425 [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6426 .type = HDA_FIXUP_PINS,
6427 .v.pins = (const struct hda_pintbl[]) {
6428 { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6429 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6433 .chain_id = ALC269_FIXUP_HEADSET_MODE
6435 [ALC292_FIXUP_TPT440_DOCK] = {
6436 .type = HDA_FIXUP_FUNC,
6437 .v.func = alc_fixup_tpt440_dock,
6439 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
6441 [ALC292_FIXUP_TPT440] = {
6442 .type = HDA_FIXUP_FUNC,
6443 .v.func = alc_fixup_disable_aamix,
6445 .chain_id = ALC292_FIXUP_TPT440_DOCK,
6447 [ALC283_FIXUP_HEADSET_MIC] = {
6448 .type = HDA_FIXUP_PINS,
6449 .v.pins = (const struct hda_pintbl[]) {
6450 { 0x19, 0x04a110f0 },
6454 [ALC255_FIXUP_MIC_MUTE_LED] = {
6455 .type = HDA_FIXUP_FUNC,
6456 .v.func = snd_hda_gen_fixup_micmute_led,
6458 [ALC282_FIXUP_ASPIRE_V5_PINS] = {
6459 .type = HDA_FIXUP_PINS,
6460 .v.pins = (const struct hda_pintbl[]) {
6461 { 0x12, 0x90a60130 },
6462 { 0x14, 0x90170110 },
6463 { 0x17, 0x40000008 },
6464 { 0x18, 0x411111f0 },
6465 { 0x19, 0x01a1913c },
6466 { 0x1a, 0x411111f0 },
6467 { 0x1b, 0x411111f0 },
6468 { 0x1d, 0x40f89b2d },
6469 { 0x1e, 0x411111f0 },
6470 { 0x21, 0x0321101f },
6474 [ALC280_FIXUP_HP_GPIO4] = {
6475 .type = HDA_FIXUP_FUNC,
6476 .v.func = alc280_fixup_hp_gpio4,
6478 [ALC286_FIXUP_HP_GPIO_LED] = {
6479 .type = HDA_FIXUP_FUNC,
6480 .v.func = alc286_fixup_hp_gpio_led,
6482 [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
6483 .type = HDA_FIXUP_FUNC,
6484 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
6486 [ALC280_FIXUP_HP_DOCK_PINS] = {
6487 .type = HDA_FIXUP_PINS,
6488 .v.pins = (const struct hda_pintbl[]) {
6489 { 0x1b, 0x21011020 }, /* line-out */
6490 { 0x1a, 0x01a1903c }, /* headset mic */
6491 { 0x18, 0x2181103f }, /* line-in */
6495 .chain_id = ALC280_FIXUP_HP_GPIO4
6497 [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
6498 .type = HDA_FIXUP_PINS,
6499 .v.pins = (const struct hda_pintbl[]) {
6500 { 0x1b, 0x21011020 }, /* line-out */
6501 { 0x18, 0x2181103f }, /* line-in */
6505 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
6507 [ALC280_FIXUP_HP_9480M] = {
6508 .type = HDA_FIXUP_FUNC,
6509 .v.func = alc280_fixup_hp_9480m,
6511 [ALC288_FIXUP_DELL_HEADSET_MODE] = {
6512 .type = HDA_FIXUP_FUNC,
6513 .v.func = alc_fixup_headset_mode_dell_alc288,
6515 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6517 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6518 .type = HDA_FIXUP_PINS,
6519 .v.pins = (const struct hda_pintbl[]) {
6520 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6521 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6525 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
6527 [ALC288_FIXUP_DISABLE_AAMIX] = {
6528 .type = HDA_FIXUP_FUNC,
6529 .v.func = alc_fixup_disable_aamix,
6531 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
6533 [ALC288_FIXUP_DELL_XPS_13] = {
6534 .type = HDA_FIXUP_FUNC,
6535 .v.func = alc_fixup_dell_xps13,
6537 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
6539 [ALC292_FIXUP_DISABLE_AAMIX] = {
6540 .type = HDA_FIXUP_FUNC,
6541 .v.func = alc_fixup_disable_aamix,
6543 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
6545 [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
6546 .type = HDA_FIXUP_FUNC,
6547 .v.func = alc_fixup_disable_aamix,
6549 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
6551 [ALC292_FIXUP_DELL_E7X_AAMIX] = {
6552 .type = HDA_FIXUP_FUNC,
6553 .v.func = alc_fixup_dell_xps13,
6555 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
6557 [ALC292_FIXUP_DELL_E7X] = {
6558 .type = HDA_FIXUP_FUNC,
6559 .v.func = snd_hda_gen_fixup_micmute_led,
6560 /* micmute fixup must be applied at last */
6561 .chained_before = true,
6562 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
6564 [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
6565 .type = HDA_FIXUP_PINS,
6566 .v.pins = (const struct hda_pintbl[]) {
6567 { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
6570 .chained_before = true,
6571 .chain_id = ALC269_FIXUP_HEADSET_MODE,
6573 [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6574 .type = HDA_FIXUP_PINS,
6575 .v.pins = (const struct hda_pintbl[]) {
6576 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6577 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6581 .chain_id = ALC269_FIXUP_HEADSET_MODE
6583 [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
6584 .type = HDA_FIXUP_PINS,
6585 .v.pins = (const struct hda_pintbl[]) {
6586 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6590 .chain_id = ALC269_FIXUP_HEADSET_MODE
6592 [ALC275_FIXUP_DELL_XPS] = {
6593 .type = HDA_FIXUP_VERBS,
6594 .v.verbs = (const struct hda_verb[]) {
6595 /* Enables internal speaker */
6596 {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
6597 {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
6598 {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
6599 {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
6603 [ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE] = {
6604 .type = HDA_FIXUP_VERBS,
6605 .v.verbs = (const struct hda_verb[]) {
6606 /* Disable pass-through path for FRONT 14h */
6607 {0x20, AC_VERB_SET_COEF_INDEX, 0x36},
6608 {0x20, AC_VERB_SET_PROC_COEF, 0x1737},
6612 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6614 [ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE2] = {
6615 .type = HDA_FIXUP_FUNC,
6616 .v.func = alc256_fixup_dell_xps_13_headphone_noise2,
6618 .chain_id = ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE
6620 [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
6621 .type = HDA_FIXUP_FUNC,
6622 .v.func = alc_fixup_disable_aamix,
6624 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
6626 [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
6627 .type = HDA_FIXUP_FUNC,
6628 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
6630 [ALC255_FIXUP_DELL_SPK_NOISE] = {
6631 .type = HDA_FIXUP_FUNC,
6632 .v.func = alc_fixup_disable_aamix,
6634 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6636 [ALC225_FIXUP_DISABLE_MIC_VREF] = {
6637 .type = HDA_FIXUP_FUNC,
6638 .v.func = alc_fixup_disable_mic_vref,
6640 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
6642 [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6643 .type = HDA_FIXUP_VERBS,
6644 .v.verbs = (const struct hda_verb[]) {
6645 /* Disable pass-through path for FRONT 14h */
6646 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
6647 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
6651 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
6653 [ALC280_FIXUP_HP_HEADSET_MIC] = {
6654 .type = HDA_FIXUP_FUNC,
6655 .v.func = alc_fixup_disable_aamix,
6657 .chain_id = ALC269_FIXUP_HEADSET_MIC,
6659 [ALC221_FIXUP_HP_FRONT_MIC] = {
6660 .type = HDA_FIXUP_PINS,
6661 .v.pins = (const struct hda_pintbl[]) {
6662 { 0x19, 0x02a19020 }, /* Front Mic */
6666 [ALC292_FIXUP_TPT460] = {
6667 .type = HDA_FIXUP_FUNC,
6668 .v.func = alc_fixup_tpt440_dock,
6670 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
6672 [ALC298_FIXUP_SPK_VOLUME] = {
6673 .type = HDA_FIXUP_FUNC,
6674 .v.func = alc298_fixup_speaker_volume,
6676 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
6678 [ALC295_FIXUP_DISABLE_DAC3] = {
6679 .type = HDA_FIXUP_FUNC,
6680 .v.func = alc295_fixup_disable_dac3,
6682 [ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
6683 .type = HDA_FIXUP_FUNC,
6684 .v.func = alc285_fixup_speaker2_to_dac1,
6686 [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
6687 .type = HDA_FIXUP_PINS,
6688 .v.pins = (const struct hda_pintbl[]) {
6689 { 0x1b, 0x90170151 },
6693 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6695 [ALC269_FIXUP_ATIV_BOOK_8] = {
6696 .type = HDA_FIXUP_FUNC,
6697 .v.func = alc_fixup_auto_mute_via_amp,
6699 .chain_id = ALC269_FIXUP_NO_SHUTUP
6701 [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
6702 .type = HDA_FIXUP_PINS,
6703 .v.pins = (const struct hda_pintbl[]) {
6704 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6705 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6709 .chain_id = ALC269_FIXUP_HEADSET_MODE
6711 [ALC256_FIXUP_ASUS_HEADSET_MODE] = {
6712 .type = HDA_FIXUP_FUNC,
6713 .v.func = alc_fixup_headset_mode,
6715 [ALC256_FIXUP_ASUS_MIC] = {
6716 .type = HDA_FIXUP_PINS,
6717 .v.pins = (const struct hda_pintbl[]) {
6718 { 0x13, 0x90a60160 }, /* use as internal mic */
6719 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
6723 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
6725 [ALC256_FIXUP_ASUS_AIO_GPIO2] = {
6726 .type = HDA_FIXUP_FUNC,
6727 /* Set up GPIO2 for the speaker amp */
6728 .v.func = alc_fixup_gpio4,
6730 [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
6731 .type = HDA_FIXUP_PINS,
6732 .v.pins = (const struct hda_pintbl[]) {
6733 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6737 .chain_id = ALC269_FIXUP_HEADSET_MIC
6739 [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
6740 .type = HDA_FIXUP_VERBS,
6741 .v.verbs = (const struct hda_verb[]) {
6742 /* Enables internal speaker */
6743 {0x20, AC_VERB_SET_COEF_INDEX, 0x40},
6744 {0x20, AC_VERB_SET_PROC_COEF, 0x8800},
6748 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
6750 [ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
6751 .type = HDA_FIXUP_FUNC,
6752 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
6754 [ALC233_FIXUP_ACER_HEADSET_MIC] = {
6755 .type = HDA_FIXUP_VERBS,
6756 .v.verbs = (const struct hda_verb[]) {
6757 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
6758 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
6762 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
6764 [ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
6765 .type = HDA_FIXUP_PINS,
6766 .v.pins = (const struct hda_pintbl[]) {
6767 /* Change the mic location from front to right, otherwise there are
6768 two front mics with the same name, pulseaudio can't handle them.
6769 This is just a temporary workaround, after applying this fixup,
6770 there will be one "Front Mic" and one "Mic" in this machine.
6772 { 0x1a, 0x04a19040 },
6776 [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
6777 .type = HDA_FIXUP_PINS,
6778 .v.pins = (const struct hda_pintbl[]) {
6779 { 0x16, 0x0101102f }, /* Rear Headset HP */
6780 { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
6781 { 0x1a, 0x01a19030 }, /* Rear Headset MIC */
6782 { 0x1b, 0x02011020 },
6786 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6788 [ALC700_FIXUP_INTEL_REFERENCE] = {
6789 .type = HDA_FIXUP_VERBS,
6790 .v.verbs = (const struct hda_verb[]) {
6791 /* Enables internal speaker */
6792 {0x20, AC_VERB_SET_COEF_INDEX, 0x45},
6793 {0x20, AC_VERB_SET_PROC_COEF, 0x5289},
6794 {0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
6795 {0x20, AC_VERB_SET_PROC_COEF, 0x001b},
6796 {0x58, AC_VERB_SET_COEF_INDEX, 0x00},
6797 {0x58, AC_VERB_SET_PROC_COEF, 0x3888},
6798 {0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
6799 {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
6803 [ALC274_FIXUP_DELL_BIND_DACS] = {
6804 .type = HDA_FIXUP_FUNC,
6805 .v.func = alc274_fixup_bind_dacs,
6807 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
6809 [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
6810 .type = HDA_FIXUP_PINS,
6811 .v.pins = (const struct hda_pintbl[]) {
6812 { 0x1b, 0x0401102f },
6816 .chain_id = ALC274_FIXUP_DELL_BIND_DACS
6818 [ALC298_FIXUP_TPT470_DOCK] = {
6819 .type = HDA_FIXUP_FUNC,
6820 .v.func = alc_fixup_tpt470_dock,
6822 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
6824 [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
6825 .type = HDA_FIXUP_PINS,
6826 .v.pins = (const struct hda_pintbl[]) {
6827 { 0x14, 0x0201101f },
6831 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6833 [ALC255_FIXUP_DELL_HEADSET_MIC] = {
6834 .type = HDA_FIXUP_PINS,
6835 .v.pins = (const struct hda_pintbl[]) {
6836 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6840 .chain_id = ALC269_FIXUP_HEADSET_MIC
6842 [ALC295_FIXUP_HP_X360] = {
6843 .type = HDA_FIXUP_FUNC,
6844 .v.func = alc295_fixup_hp_top_speakers,
6846 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
6848 [ALC221_FIXUP_HP_HEADSET_MIC] = {
6849 .type = HDA_FIXUP_PINS,
6850 .v.pins = (const struct hda_pintbl[]) {
6851 { 0x19, 0x0181313f},
6855 .chain_id = ALC269_FIXUP_HEADSET_MIC
6857 [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
6858 .type = HDA_FIXUP_FUNC,
6859 .v.func = alc285_fixup_invalidate_dacs,
6861 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
6863 [ALC295_FIXUP_HP_AUTO_MUTE] = {
6864 .type = HDA_FIXUP_FUNC,
6865 .v.func = alc_fixup_auto_mute_via_amp,
6867 [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
6868 .type = HDA_FIXUP_PINS,
6869 .v.pins = (const struct hda_pintbl[]) {
6870 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6874 .chain_id = ALC269_FIXUP_HEADSET_MIC
6876 [ALC294_FIXUP_ASUS_MIC] = {
6877 .type = HDA_FIXUP_PINS,
6878 .v.pins = (const struct hda_pintbl[]) {
6879 { 0x13, 0x90a60160 }, /* use as internal mic */
6880 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
6884 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6886 [ALC294_FIXUP_ASUS_HEADSET_MIC] = {
6887 .type = HDA_FIXUP_PINS,
6888 .v.pins = (const struct hda_pintbl[]) {
6889 { 0x19, 0x01a1103c }, /* use as headset mic */
6893 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6895 [ALC294_FIXUP_ASUS_SPK] = {
6896 .type = HDA_FIXUP_VERBS,
6897 .v.verbs = (const struct hda_verb[]) {
6899 { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
6900 { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
6904 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
6906 [ALC295_FIXUP_CHROME_BOOK] = {
6907 .type = HDA_FIXUP_FUNC,
6908 .v.func = alc295_fixup_chromebook,
6910 .chain_id = ALC225_FIXUP_HEADSET_JACK
6912 [ALC225_FIXUP_HEADSET_JACK] = {
6913 .type = HDA_FIXUP_FUNC,
6914 .v.func = alc_fixup_headset_jack,
6916 [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
6917 .type = HDA_FIXUP_PINS,
6918 .v.pins = (const struct hda_pintbl[]) {
6919 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6923 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6925 [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
6926 .type = HDA_FIXUP_VERBS,
6927 .v.verbs = (const struct hda_verb[]) {
6928 /* Disable PCBEEP-IN passthrough */
6929 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
6930 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
6934 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
6936 [ALC255_FIXUP_ACER_HEADSET_MIC] = {
6937 .type = HDA_FIXUP_PINS,
6938 .v.pins = (const struct hda_pintbl[]) {
6939 { 0x19, 0x03a11130 },
6940 { 0x1a, 0x90a60140 }, /* use as internal mic */
6944 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
6946 [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
6947 .type = HDA_FIXUP_PINS,
6948 .v.pins = (const struct hda_pintbl[]) {
6949 { 0x16, 0x01011020 }, /* Rear Line out */
6950 { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
6954 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
6956 [ALC225_FIXUP_WYSE_AUTO_MUTE] = {
6957 .type = HDA_FIXUP_FUNC,
6958 .v.func = alc_fixup_auto_mute_via_amp,
6960 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
6962 [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
6963 .type = HDA_FIXUP_FUNC,
6964 .v.func = alc_fixup_disable_mic_vref,
6966 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6968 [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
6969 .type = HDA_FIXUP_VERBS,
6970 .v.verbs = (const struct hda_verb[]) {
6971 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
6972 { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
6976 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
6978 [ALC256_FIXUP_ASUS_HEADSET_MIC] = {
6979 .type = HDA_FIXUP_PINS,
6980 .v.pins = (const struct hda_pintbl[]) {
6981 { 0x19, 0x03a11020 }, /* headset mic with jack detect */
6985 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
6987 [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
6988 .type = HDA_FIXUP_PINS,
6989 .v.pins = (const struct hda_pintbl[]) {
6990 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
6994 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
6996 [ALC299_FIXUP_PREDATOR_SPK] = {
6997 .type = HDA_FIXUP_PINS,
6998 .v.pins = (const struct hda_pintbl[]) {
6999 { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
7003 [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
7004 .type = HDA_FIXUP_PINS,
7005 .v.pins = (const struct hda_pintbl[]) {
7006 { 0x19, 0x04a11040 },
7007 { 0x21, 0x04211020 },
7011 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7013 [ALC289_FIXUP_DELL_SPK2] = {
7014 .type = HDA_FIXUP_PINS,
7015 .v.pins = (const struct hda_pintbl[]) {
7016 { 0x17, 0x90170130 }, /* bass spk */
7020 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
7022 [ALC289_FIXUP_DUAL_SPK] = {
7023 .type = HDA_FIXUP_FUNC,
7024 .v.func = alc285_fixup_speaker2_to_dac1,
7026 .chain_id = ALC289_FIXUP_DELL_SPK2
7028 [ALC294_FIXUP_SPK2_TO_DAC1] = {
7029 .type = HDA_FIXUP_FUNC,
7030 .v.func = alc285_fixup_speaker2_to_dac1,
7032 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
7034 [ALC294_FIXUP_ASUS_DUAL_SPK] = {
7035 .type = HDA_FIXUP_FUNC,
7036 /* The GPIO must be pulled to initialize the AMP */
7037 .v.func = alc_fixup_gpio4,
7039 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1
7044 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
7045 SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
7046 SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
7047 SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
7048 SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
7049 SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
7050 SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
7051 SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
7052 SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
7053 SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
7054 SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
7055 SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
7056 SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
7057 SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
7058 SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
7059 SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
7060 SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
7061 SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7062 SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7063 SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7064 SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7065 SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
7066 SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
7067 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
7068 SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
7069 SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
7070 SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
7071 SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
7072 SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
7073 SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
7074 SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
7075 SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
7076 SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
7077 SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
7078 SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
7079 SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
7080 SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
7081 SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
7082 SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7083 SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7084 SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
7085 SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
7086 SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
7087 SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
7088 SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7089 SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7090 SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7091 SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7092 SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7093 SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7094 SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7095 SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13 9350", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE2),
7096 SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
7097 SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
7098 SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
7099 SND_PCI_QUIRK(0x1028, 0x075b, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE2),
7100 SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
7101 SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
7102 SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
7103 SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
7104 SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
7105 SND_PCI_QUIRK(0x1028, 0x082a, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE2),
7106 SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
7107 SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
7108 SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
7109 SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
7110 SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
7111 SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
7112 SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
7113 SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
7114 SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
7115 SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
7116 SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7117 SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7118 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
7119 SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
7120 SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
7121 SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
7123 SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7124 SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7125 SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7126 SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7127 SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7128 SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7129 SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7130 SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7131 SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7132 SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7133 SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7134 SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7135 SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
7136 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
7137 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
7138 SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7139 SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7140 SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7141 SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7142 SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7143 SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
7144 SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7145 SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7147 SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7148 SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7149 SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7150 SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7151 SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7152 SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7153 SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7154 SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7155 SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7156 SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
7157 SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7158 SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7159 SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7160 SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7161 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7162 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7163 SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7164 SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7165 SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7166 SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7167 SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7168 SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7169 SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7170 SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7171 SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7172 SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7173 SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7174 SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7175 SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7176 SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
7177 SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7178 SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7179 SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7180 SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
7181 SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
7182 SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7183 SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7184 SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7185 SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7186 SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7187 SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
7188 SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
7189 SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7190 SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
7191 SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
7192 SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
7193 SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7194 SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
7195 SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
7196 SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
7197 SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
7198 SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
7199 SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
7200 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
7201 SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
7202 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
7203 SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
7204 SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
7205 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
7206 SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
7207 SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
7208 SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
7209 SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7210 SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
7211 SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
7212 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
7213 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
7214 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
7215 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
7216 SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
7217 SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
7218 SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
7219 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
7220 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
7221 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
7222 SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
7223 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
7224 SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
7225 SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
7226 SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
7227 SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
7228 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
7229 SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
7230 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE),
7231 SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
7232 SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
7233 SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
7234 SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
7235 SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
7236 SND_PCI_QUIRK(0x1558, 0x1325, "System76 Darter Pro (darp5)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
7237 SND_PCI_QUIRK(0x1558, 0x8550, "System76 Gazelle (gaze14)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
7238 SND_PCI_QUIRK(0x1558, 0x8551, "System76 Gazelle (gaze14)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
7239 SND_PCI_QUIRK(0x1558, 0x8560, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
7240 SND_PCI_QUIRK(0x1558, 0x8561, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
7241 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
7242 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
7243 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
7244 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
7245 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
7246 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
7247 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
7248 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
7249 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
7250 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
7251 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
7252 SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
7253 SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
7254 SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
7255 SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
7256 SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
7257 SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
7258 SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
7259 SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7260 SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
7261 SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
7262 SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
7263 SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7264 SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7265 SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
7266 SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
7267 SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
7268 SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7269 SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7270 SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
7271 SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7272 SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7273 SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7274 SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7275 SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Yoga 7th", ALC285_FIXUP_SPEAKER2_TO_DAC1),
7276 SND_PCI_QUIRK(0x17aa, 0x2293, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_SPEAKER2_TO_DAC1),
7277 SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
7278 SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
7279 SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7280 SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7281 SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7282 SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7283 SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7284 SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7285 SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7286 SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7287 SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
7288 SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
7289 SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
7290 SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7291 SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
7292 SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
7293 SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7294 SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
7295 SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
7296 SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
7297 SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
7298 SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
7299 SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
7300 SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
7301 SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
7302 SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7303 SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7304 SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7305 SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7306 SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7307 SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7308 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
7309 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
7310 SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
7311 SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
7312 SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
7313 SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
7316 /* Below is a quirk table taken from the old code.
7317 * Basically the device should work as is without the fixup table.
7318 * If BIOS doesn't give a proper info, enable the corresponding
7321 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
7323 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
7324 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
7325 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
7326 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
7327 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
7328 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
7329 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
7330 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
7331 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
7332 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
7333 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
7334 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
7335 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
7336 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
7337 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
7338 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
7339 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
7340 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
7341 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
7342 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
7343 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
7344 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
7345 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
7346 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
7347 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
7348 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
7349 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
7350 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
7351 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
7352 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
7353 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
7354 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
7355 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
7356 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
7357 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
7358 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
7359 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
7360 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
7361 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
7366 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
7367 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
7368 SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
7369 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
7370 SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
7371 SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
7375 static const struct hda_model_fixup alc269_fixup_models[] = {
7376 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
7377 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
7378 {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
7379 {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
7380 {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
7381 {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
7382 {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
7383 {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
7384 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
7385 {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
7386 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
7387 {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
7388 {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
7389 {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
7390 {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
7391 {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
7392 {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
7393 {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
7394 {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
7395 {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
7396 {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
7397 {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
7398 {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
7399 {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
7400 {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
7401 {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
7402 {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
7403 {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
7404 {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
7405 {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
7406 {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
7407 {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
7408 {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
7409 {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
7410 {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
7411 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
7412 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
7413 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
7414 {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
7415 {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
7416 {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
7417 {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
7418 {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
7419 {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
7420 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
7421 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
7422 {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
7423 {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
7424 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
7425 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
7426 {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
7427 {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
7428 {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
7429 {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
7430 {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
7431 {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
7432 {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
7433 {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
7434 {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
7435 {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
7436 {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
7437 {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
7438 {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
7439 {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
7440 {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
7441 {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
7442 {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
7443 {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
7444 {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
7445 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
7446 {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
7447 {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
7448 {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
7449 {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
7450 {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
7451 {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
7452 {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
7453 {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
7454 {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
7455 {.id = ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE, .name = "alc256-dell-xps13"},
7456 {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
7457 {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
7458 {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
7459 {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
7460 {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
7461 {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
7462 {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
7463 {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
7464 {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
7465 {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
7466 {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
7467 {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
7468 {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
7469 {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
7470 {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
7471 {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
7472 {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
7473 {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
7474 {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
7475 {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
7476 {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
7477 {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
7478 {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
7479 {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
7480 {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
7481 {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
7482 {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
7483 {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
7486 #define ALC225_STANDARD_PINS \
7489 #define ALC256_STANDARD_PINS \
7490 {0x12, 0x90a60140}, \
7491 {0x14, 0x90170110}, \
7494 #define ALC282_STANDARD_PINS \
7497 #define ALC290_STANDARD_PINS \
7500 #define ALC292_STANDARD_PINS \
7501 {0x14, 0x90170110}, \
7504 #define ALC295_STANDARD_PINS \
7505 {0x12, 0xb7a60130}, \
7506 {0x14, 0x90170110}, \
7509 #define ALC298_STANDARD_PINS \
7510 {0x12, 0x90a60130}, \
7513 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
7514 SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
7519 {0x21, 0x0221102f}),
7520 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
7523 {0x21, 0x02211030}),
7524 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7527 {0x21, 0x03211020}),
7528 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7531 {0x21, 0x03211020}),
7532 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7533 ALC225_STANDARD_PINS,
7535 {0x14, 0x901701a0}),
7536 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7537 ALC225_STANDARD_PINS,
7539 {0x14, 0x901701b0}),
7540 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7541 ALC225_STANDARD_PINS,
7543 {0x14, 0x901701a0}),
7544 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7545 ALC225_STANDARD_PINS,
7547 {0x14, 0x901701b0}),
7548 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7549 ALC225_STANDARD_PINS,
7551 {0x1b, 0x90170110}),
7552 SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7555 {0x21, 0x02211020}),
7556 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7560 {0x21, 0x02211020}),
7561 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
7566 {0x21, 0x0221101f}),
7567 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
7572 {0x21, 0x0221101f}),
7573 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
7577 {0x21, 0x0221101f}),
7578 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7580 {0x21, 0x02211020}),
7581 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7583 {0x21, 0x02211040}),
7584 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7587 {0x21, 0x02211020}),
7588 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7591 {0x21, 0x02211030}),
7592 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7595 {0x21, 0x0221101f}),
7596 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7599 {0x21, 0x0221101f}),
7600 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7603 {0x21, 0x0221103f}),
7604 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7607 {0x21, 0x0221103f}),
7608 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7611 {0x21, 0x0221103f}),
7612 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7615 {0x21, 0x0221105f}),
7616 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7619 {0x21, 0x0221101f}),
7620 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7624 {0x21, 0x0321102f}),
7625 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7628 {0x21, 0x02211040}),
7629 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7632 {0x21, 0x02211050}),
7633 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7636 {0x21, 0x02211030}),
7637 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7640 {0x21, 0x02211040}),
7641 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7644 {0x21, 0x02211040}),
7645 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7648 {0x21, 0x02211050}),
7649 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7652 {0x21, 0x02211040}),
7653 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7656 {0x21, 0x02211030}),
7657 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7659 {0x21, 0x02211010}),
7660 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
7663 {0x21, 0x04211020}),
7664 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
7667 {0x21, 0x03211020}),
7668 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7671 {0x21, 0x03211020}),
7672 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7675 {0x21, 0x04211020}),
7676 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7679 {0x21, 0x03211020}),
7680 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
7684 {0x1a, 0x04a11020}),
7685 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
7691 {0x1b, 0x02011020}),
7692 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7693 ALC282_STANDARD_PINS,
7696 {0x21, 0x0321101f}),
7697 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7698 ALC282_STANDARD_PINS,
7701 {0x21, 0x03211040}),
7702 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7703 ALC282_STANDARD_PINS,
7706 {0x21, 0x03211020}),
7707 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7708 ALC282_STANDARD_PINS,
7711 {0x21, 0x0421101f}),
7712 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
7713 ALC282_STANDARD_PINS,
7716 {0x21, 0x04211020}),
7717 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7718 ALC282_STANDARD_PINS,
7720 {0x21, 0x0321101f}),
7721 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7724 {0x21, 0x02211030}),
7725 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7726 ALC282_STANDARD_PINS,
7729 {0x21, 0x0321101f}),
7730 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
7734 {0x21, 0x04211020}),
7735 SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7738 {0x21, 0x02211020}),
7739 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
7742 {0x21, 0x0321101f}),
7743 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7744 ALC290_STANDARD_PINS,
7747 {0x1a, 0x04a11020}),
7748 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7749 ALC290_STANDARD_PINS,
7752 {0x1a, 0x04a11020}),
7753 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7754 ALC290_STANDARD_PINS,
7756 {0x1a, 0x04a11020}),
7757 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7758 ALC290_STANDARD_PINS,
7760 {0x1a, 0x04a11040}),
7761 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7762 ALC290_STANDARD_PINS,
7765 {0x1a, 0x04a11040}),
7766 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7767 ALC290_STANDARD_PINS,
7770 {0x1a, 0x04a11020}),
7771 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7772 ALC290_STANDARD_PINS,
7775 {0x1a, 0x04a11020}),
7776 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7777 ALC292_STANDARD_PINS,
7780 {0x19, 0x01a19030}),
7781 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7782 ALC292_STANDARD_PINS,
7786 {0x19, 0x01a1903e}),
7787 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7788 ALC292_STANDARD_PINS,
7789 {0x12, 0x90a60140}),
7790 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7791 ALC292_STANDARD_PINS,
7794 {0x19, 0x21a19030}),
7795 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7796 ALC292_STANDARD_PINS,
7797 {0x13, 0x90a60140}),
7798 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
7801 {0x21, 0x04211020}),
7802 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
7805 {0x21, 0x03211020}),
7806 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
7809 {0x21, 0x04211020}),
7810 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
7813 {0x21, 0x03211020}),
7814 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7816 {0x21, 0x04211020}),
7817 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7819 {0x21, 0x04211030}),
7820 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7821 ALC295_STANDARD_PINS,
7823 {0x18, 0x21a19030}),
7824 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7825 ALC295_STANDARD_PINS,
7827 {0x18, 0x21a19050}),
7828 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7829 ALC295_STANDARD_PINS),
7830 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7831 ALC298_STANDARD_PINS,
7832 {0x17, 0x90170110}),
7833 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7834 ALC298_STANDARD_PINS,
7835 {0x17, 0x90170140}),
7836 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7837 ALC298_STANDARD_PINS,
7838 {0x17, 0x90170150}),
7839 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
7844 {0x21, 0x03211030}),
7845 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
7849 {0x21, 0x03211020}),
7850 SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7851 ALC225_STANDARD_PINS,
7853 {0x17, 0x90170110}),
7857 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
7858 * more machines, don't need to match all valid pins, just need to match
7859 * all the pins defined in the tbl. Just because of this reason, it is possible
7860 * that a single machine matches multiple tbls, so there is one limitation:
7861 * at most one tbl is allowed to define for the same vendor and same codec
7863 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
7864 SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7866 {0x1b, 0x40000000}),
7867 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7869 {0x1a, 0x40000000}),
7870 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7872 {0x1a, 0x40000000}),
7873 SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7875 {0x1a, 0x40000000}),
7879 static void alc269_fill_coef(struct hda_codec *codec)
7881 struct alc_spec *spec = codec->spec;
7884 if (spec->codec_variant != ALC269_TYPE_ALC269VB)
7887 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
7888 alc_write_coef_idx(codec, 0xf, 0x960b);
7889 alc_write_coef_idx(codec, 0xe, 0x8817);
7892 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
7893 alc_write_coef_idx(codec, 0xf, 0x960b);
7894 alc_write_coef_idx(codec, 0xe, 0x8814);
7897 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
7898 /* Power up output pin */
7899 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
7902 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
7903 val = alc_read_coef_idx(codec, 0xd);
7904 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
7905 /* Capless ramp up clock control */
7906 alc_write_coef_idx(codec, 0xd, val | (1<<10));
7908 val = alc_read_coef_idx(codec, 0x17);
7909 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
7910 /* Class D power on reset */
7911 alc_write_coef_idx(codec, 0x17, val | (1<<7));
7916 alc_update_coef_idx(codec, 0x4, 0, 1<<11);
7921 static int patch_alc269(struct hda_codec *codec)
7923 struct alc_spec *spec;
7926 err = alc_alloc_spec(codec, 0x0b);
7931 spec->gen.shared_mic_vref_pin = 0x18;
7932 codec->power_save_node = 0;
7935 codec->patch_ops.suspend = alc269_suspend;
7936 codec->patch_ops.resume = alc269_resume;
7938 spec->shutup = alc_default_shutup;
7939 spec->init_hook = alc_default_init;
7941 switch (codec->core.vendor_id) {
7943 spec->codec_variant = ALC269_TYPE_ALC269VA;
7944 switch (alc_get_coef0(codec) & 0x00f0) {
7946 if (codec->bus->pci &&
7947 codec->bus->pci->subsystem_vendor == 0x1025 &&
7948 spec->cdefine.platform_type == 1)
7949 err = alc_codec_rename(codec, "ALC271X");
7950 spec->codec_variant = ALC269_TYPE_ALC269VB;
7953 if (codec->bus->pci &&
7954 codec->bus->pci->subsystem_vendor == 0x17aa &&
7955 codec->bus->pci->subsystem_device == 0x21f3)
7956 err = alc_codec_rename(codec, "ALC3202");
7957 spec->codec_variant = ALC269_TYPE_ALC269VC;
7960 spec->codec_variant = ALC269_TYPE_ALC269VD;
7963 alc_fix_pll_init(codec, 0x20, 0x04, 15);
7967 spec->shutup = alc269_shutup;
7968 spec->init_hook = alc269_fill_coef;
7969 alc269_fill_coef(codec);
7974 spec->codec_variant = ALC269_TYPE_ALC280;
7977 spec->codec_variant = ALC269_TYPE_ALC282;
7978 spec->shutup = alc282_shutup;
7979 spec->init_hook = alc282_init;
7983 spec->codec_variant = ALC269_TYPE_ALC283;
7984 spec->shutup = alc283_shutup;
7985 spec->init_hook = alc283_init;
7989 spec->codec_variant = ALC269_TYPE_ALC284;
7992 spec->codec_variant = ALC269_TYPE_ALC293;
7996 spec->codec_variant = ALC269_TYPE_ALC286;
7999 spec->codec_variant = ALC269_TYPE_ALC298;
8003 spec->codec_variant = ALC269_TYPE_ALC255;
8004 spec->shutup = alc256_shutup;
8005 spec->init_hook = alc256_init;
8009 spec->codec_variant = ALC269_TYPE_ALC256;
8010 spec->shutup = alc256_shutup;
8011 spec->init_hook = alc256_init;
8012 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
8015 spec->codec_variant = ALC269_TYPE_ALC257;
8016 spec->shutup = alc256_shutup;
8017 spec->init_hook = alc256_init;
8018 spec->gen.mixer_nid = 0;
8023 spec->codec_variant = ALC269_TYPE_ALC215;
8024 spec->shutup = alc225_shutup;
8025 spec->init_hook = alc225_init;
8026 spec->gen.mixer_nid = 0;
8031 spec->codec_variant = ALC269_TYPE_ALC225;
8032 spec->shutup = alc225_shutup;
8033 spec->init_hook = alc225_init;
8034 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
8039 spec->codec_variant = ALC269_TYPE_ALC294;
8040 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
8041 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
8042 spec->init_hook = alc294_init;
8045 spec->codec_variant = ALC269_TYPE_ALC300;
8046 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
8049 spec->codec_variant = ALC269_TYPE_ALC623;
8055 spec->codec_variant = ALC269_TYPE_ALC700;
8056 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
8057 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
8058 spec->init_hook = alc294_init;
8063 if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
8064 spec->has_alc5505_dsp = 1;
8065 spec->init_hook = alc5505_dsp_init;
8068 alc_pre_init(codec);
8070 snd_hda_pick_fixup(codec, alc269_fixup_models,
8071 alc269_fixup_tbl, alc269_fixups);
8072 snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
8073 snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
8074 snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
8076 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8078 alc_auto_parse_customize_define(codec);
8080 if (has_cdefine_beep(codec))
8081 spec->gen.beep_nid = 0x01;
8083 /* automatic parse from the BIOS config */
8084 err = alc269_parse_auto_config(codec);
8088 if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
8089 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
8094 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8107 static int alc861_parse_auto_config(struct hda_codec *codec)
8109 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
8110 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
8111 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
8114 /* Pin config fixes */
8116 ALC861_FIXUP_FSC_AMILO_PI1505,
8117 ALC861_FIXUP_AMP_VREF_0F,
8118 ALC861_FIXUP_NO_JACK_DETECT,
8119 ALC861_FIXUP_ASUS_A6RP,
8120 ALC660_FIXUP_ASUS_W7J,
8123 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
8124 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
8125 const struct hda_fixup *fix, int action)
8127 struct alc_spec *spec = codec->spec;
8130 if (action != HDA_FIXUP_ACT_INIT)
8132 val = snd_hda_codec_get_pin_target(codec, 0x0f);
8133 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
8134 val |= AC_PINCTL_IN_EN;
8135 val |= AC_PINCTL_VREF_50;
8136 snd_hda_set_pin_ctl(codec, 0x0f, val);
8137 spec->gen.keep_vref_in_automute = 1;
8140 /* suppress the jack-detection */
8141 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
8142 const struct hda_fixup *fix, int action)
8144 if (action == HDA_FIXUP_ACT_PRE_PROBE)
8145 codec->no_jack_detect = 1;
8148 static const struct hda_fixup alc861_fixups[] = {
8149 [ALC861_FIXUP_FSC_AMILO_PI1505] = {
8150 .type = HDA_FIXUP_PINS,
8151 .v.pins = (const struct hda_pintbl[]) {
8152 { 0x0b, 0x0221101f }, /* HP */
8153 { 0x0f, 0x90170310 }, /* speaker */
8157 [ALC861_FIXUP_AMP_VREF_0F] = {
8158 .type = HDA_FIXUP_FUNC,
8159 .v.func = alc861_fixup_asus_amp_vref_0f,
8161 [ALC861_FIXUP_NO_JACK_DETECT] = {
8162 .type = HDA_FIXUP_FUNC,
8163 .v.func = alc_fixup_no_jack_detect,
8165 [ALC861_FIXUP_ASUS_A6RP] = {
8166 .type = HDA_FIXUP_FUNC,
8167 .v.func = alc861_fixup_asus_amp_vref_0f,
8169 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
8171 [ALC660_FIXUP_ASUS_W7J] = {
8172 .type = HDA_FIXUP_VERBS,
8173 .v.verbs = (const struct hda_verb[]) {
8174 /* ASUS W7J needs a magic pin setup on unused NID 0x10
8175 * for enabling outputs
8177 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
8183 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
8184 SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
8185 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
8186 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
8187 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
8188 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
8189 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
8190 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
8191 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
8197 static int patch_alc861(struct hda_codec *codec)
8199 struct alc_spec *spec;
8202 err = alc_alloc_spec(codec, 0x15);
8207 if (has_cdefine_beep(codec))
8208 spec->gen.beep_nid = 0x23;
8211 spec->power_hook = alc_power_eapd;
8214 alc_pre_init(codec);
8216 snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
8217 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8219 /* automatic parse from the BIOS config */
8220 err = alc861_parse_auto_config(codec);
8224 if (!spec->gen.no_analog) {
8225 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
8230 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8244 * In addition, an independent DAC
8246 static int alc861vd_parse_auto_config(struct hda_codec *codec)
8248 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
8249 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
8250 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
8254 ALC660VD_FIX_ASUS_GPIO1,
8255 ALC861VD_FIX_DALLAS,
8258 /* exclude VREF80 */
8259 static void alc861vd_fixup_dallas(struct hda_codec *codec,
8260 const struct hda_fixup *fix, int action)
8262 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
8263 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
8264 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
8269 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
8270 const struct hda_fixup *fix, int action)
8272 struct alc_spec *spec = codec->spec;
8274 if (action == HDA_FIXUP_ACT_PRE_PROBE)
8275 spec->gpio_mask |= 0x02;
8276 alc_fixup_gpio(codec, action, 0x01);
8279 static const struct hda_fixup alc861vd_fixups[] = {
8280 [ALC660VD_FIX_ASUS_GPIO1] = {
8281 .type = HDA_FIXUP_FUNC,
8282 .v.func = alc660vd_fixup_asus_gpio1,
8284 [ALC861VD_FIX_DALLAS] = {
8285 .type = HDA_FIXUP_FUNC,
8286 .v.func = alc861vd_fixup_dallas,
8290 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
8291 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
8292 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
8293 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
8299 static int patch_alc861vd(struct hda_codec *codec)
8301 struct alc_spec *spec;
8304 err = alc_alloc_spec(codec, 0x0b);
8309 if (has_cdefine_beep(codec))
8310 spec->gen.beep_nid = 0x23;
8312 spec->shutup = alc_eapd_shutup;
8314 alc_pre_init(codec);
8316 snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
8317 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8319 /* automatic parse from the BIOS config */
8320 err = alc861vd_parse_auto_config(codec);
8324 if (!spec->gen.no_analog) {
8325 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
8330 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8342 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
8343 * configuration. Each pin widget can choose any input DACs and a mixer.
8344 * Each ADC is connected from a mixer of all inputs. This makes possible
8345 * 6-channel independent captures.
8347 * In addition, an independent DAC for the multi-playback (not used in this
8352 * BIOS auto configuration
8355 static int alc662_parse_auto_config(struct hda_codec *codec)
8357 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
8358 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
8359 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
8360 const hda_nid_t *ssids;
8362 if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
8363 codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
8364 codec->core.vendor_id == 0x10ec0671)
8365 ssids = alc663_ssids;
8367 ssids = alc662_ssids;
8368 return alc_parse_auto_config(codec, alc662_ignore, ssids);
8371 static void alc272_fixup_mario(struct hda_codec *codec,
8372 const struct hda_fixup *fix, int action)
8374 if (action != HDA_FIXUP_ACT_PRE_PROBE)
8376 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
8377 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
8378 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
8379 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
8380 (0 << AC_AMPCAP_MUTE_SHIFT)))
8381 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
8384 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
8386 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
8388 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
8389 SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
8393 /* override the 2.1 chmap */
8394 static void alc_fixup_bass_chmap(struct hda_codec *codec,
8395 const struct hda_fixup *fix, int action)
8397 if (action == HDA_FIXUP_ACT_BUILD) {
8398 struct alc_spec *spec = codec->spec;
8399 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
8403 /* avoid D3 for keeping GPIO up */
8404 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
8406 unsigned int power_state)
8408 struct alc_spec *spec = codec->spec;
8409 if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
8414 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
8415 const struct hda_fixup *fix, int action)
8417 struct alc_spec *spec = codec->spec;
8419 alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
8420 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
8421 spec->mute_led_polarity = 1;
8422 codec->power_filter = gpio_led_power_filter;
8426 static void alc662_usi_automute_hook(struct hda_codec *codec,
8427 struct hda_jack_callback *jack)
8429 struct alc_spec *spec = codec->spec;
8432 snd_hda_gen_hp_automute(codec, jack);
8434 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
8436 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8440 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
8441 const struct hda_fixup *fix, int action)
8443 struct alc_spec *spec = codec->spec;
8444 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
8445 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
8446 spec->gen.hp_automute_hook = alc662_usi_automute_hook;
8450 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
8451 struct hda_jack_callback *cb)
8453 /* surround speakers at 0x1b already get muted automatically when
8454 * headphones are plugged in, but we have to mute/unmute the remaining
8455 * channels manually:
8456 * 0x15 - front left/front right
8457 * 0x18 - front center/ LFE
8459 if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
8460 snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
8461 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
8463 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
8464 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
8468 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
8469 const struct hda_fixup *fix, int action)
8471 /* Pin 0x1b: shared headphones jack and surround speakers */
8472 if (!is_jack_detectable(codec, 0x1b))
8476 case HDA_FIXUP_ACT_PRE_PROBE:
8477 snd_hda_jack_detect_enable_callback(codec, 0x1b,
8478 alc662_aspire_ethos_mute_speakers);
8479 /* subwoofer needs an extra GPIO setting to become audible */
8480 alc_setup_gpio(codec, 0x02);
8482 case HDA_FIXUP_ACT_INIT:
8483 /* Make sure to start in a correct state, i.e. if
8484 * headphones have been plugged in before powering up the system
8486 alc662_aspire_ethos_mute_speakers(codec, NULL);
8491 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
8492 const struct hda_fixup *fix, int action)
8494 struct alc_spec *spec = codec->spec;
8496 static const struct hda_pintbl pincfgs[] = {
8497 { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
8498 { 0x1b, 0x0181304f },
8503 case HDA_FIXUP_ACT_PRE_PROBE:
8504 spec->gen.mixer_nid = 0;
8505 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
8506 snd_hda_apply_pincfgs(codec, pincfgs);
8508 case HDA_FIXUP_ACT_INIT:
8509 alc_write_coef_idx(codec, 0x19, 0xa054);
8514 static const struct coef_fw alc668_coefs[] = {
8515 WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0),
8516 WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80),
8517 WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0),
8518 WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
8519 WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
8520 WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
8521 WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0),
8522 WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418),
8523 WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
8524 WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
8525 WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
8526 WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
8527 WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0),
8528 WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
8529 WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0),
8530 WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040),
8531 WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
8532 WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
8533 WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
8534 WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
8538 static void alc668_restore_default_value(struct hda_codec *codec)
8540 alc_process_coef_fw(codec, alc668_coefs);
8544 ALC662_FIXUP_ASPIRE,
8545 ALC662_FIXUP_LED_GPIO1,
8546 ALC662_FIXUP_IDEAPAD,
8548 ALC662_FIXUP_CZC_P10T,
8549 ALC662_FIXUP_SKU_IGNORE,
8550 ALC662_FIXUP_HP_RP5800,
8551 ALC662_FIXUP_ASUS_MODE1,
8552 ALC662_FIXUP_ASUS_MODE2,
8553 ALC662_FIXUP_ASUS_MODE3,
8554 ALC662_FIXUP_ASUS_MODE4,
8555 ALC662_FIXUP_ASUS_MODE5,
8556 ALC662_FIXUP_ASUS_MODE6,
8557 ALC662_FIXUP_ASUS_MODE7,
8558 ALC662_FIXUP_ASUS_MODE8,
8559 ALC662_FIXUP_NO_JACK_DETECT,
8560 ALC662_FIXUP_ZOTAC_Z68,
8561 ALC662_FIXUP_INV_DMIC,
8562 ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
8563 ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
8564 ALC662_FIXUP_HEADSET_MODE,
8565 ALC668_FIXUP_HEADSET_MODE,
8566 ALC662_FIXUP_BASS_MODE4_CHMAP,
8567 ALC662_FIXUP_BASS_16,
8568 ALC662_FIXUP_BASS_1A,
8569 ALC662_FIXUP_BASS_CHMAP,
8570 ALC668_FIXUP_AUTO_MUTE,
8571 ALC668_FIXUP_DELL_DISABLE_AAMIX,
8572 ALC668_FIXUP_DELL_XPS13,
8573 ALC662_FIXUP_ASUS_Nx50,
8574 ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
8575 ALC668_FIXUP_ASUS_Nx51,
8576 ALC668_FIXUP_MIC_COEF,
8577 ALC668_FIXUP_ASUS_G751,
8578 ALC891_FIXUP_HEADSET_MODE,
8579 ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
8580 ALC662_FIXUP_ACER_VERITON,
8581 ALC892_FIXUP_ASROCK_MOBO,
8582 ALC662_FIXUP_USI_FUNC,
8583 ALC662_FIXUP_USI_HEADSET_MODE,
8584 ALC662_FIXUP_LENOVO_MULTI_CODECS,
8585 ALC669_FIXUP_ACER_ASPIRE_ETHOS,
8586 ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
8587 ALC671_FIXUP_HP_HEADSET_MIC2,
8590 static const struct hda_fixup alc662_fixups[] = {
8591 [ALC662_FIXUP_ASPIRE] = {
8592 .type = HDA_FIXUP_PINS,
8593 .v.pins = (const struct hda_pintbl[]) {
8594 { 0x15, 0x99130112 }, /* subwoofer */
8598 [ALC662_FIXUP_LED_GPIO1] = {
8599 .type = HDA_FIXUP_FUNC,
8600 .v.func = alc662_fixup_led_gpio1,
8602 [ALC662_FIXUP_IDEAPAD] = {
8603 .type = HDA_FIXUP_PINS,
8604 .v.pins = (const struct hda_pintbl[]) {
8605 { 0x17, 0x99130112 }, /* subwoofer */
8609 .chain_id = ALC662_FIXUP_LED_GPIO1,
8611 [ALC272_FIXUP_MARIO] = {
8612 .type = HDA_FIXUP_FUNC,
8613 .v.func = alc272_fixup_mario,
8615 [ALC662_FIXUP_CZC_P10T] = {
8616 .type = HDA_FIXUP_VERBS,
8617 .v.verbs = (const struct hda_verb[]) {
8618 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
8622 [ALC662_FIXUP_SKU_IGNORE] = {
8623 .type = HDA_FIXUP_FUNC,
8624 .v.func = alc_fixup_sku_ignore,
8626 [ALC662_FIXUP_HP_RP5800] = {
8627 .type = HDA_FIXUP_PINS,
8628 .v.pins = (const struct hda_pintbl[]) {
8629 { 0x14, 0x0221201f }, /* HP out */
8633 .chain_id = ALC662_FIXUP_SKU_IGNORE
8635 [ALC662_FIXUP_ASUS_MODE1] = {
8636 .type = HDA_FIXUP_PINS,
8637 .v.pins = (const struct hda_pintbl[]) {
8638 { 0x14, 0x99130110 }, /* speaker */
8639 { 0x18, 0x01a19c20 }, /* mic */
8640 { 0x19, 0x99a3092f }, /* int-mic */
8641 { 0x21, 0x0121401f }, /* HP out */
8645 .chain_id = ALC662_FIXUP_SKU_IGNORE
8647 [ALC662_FIXUP_ASUS_MODE2] = {
8648 .type = HDA_FIXUP_PINS,
8649 .v.pins = (const struct hda_pintbl[]) {
8650 { 0x14, 0x99130110 }, /* speaker */
8651 { 0x18, 0x01a19820 }, /* mic */
8652 { 0x19, 0x99a3092f }, /* int-mic */
8653 { 0x1b, 0x0121401f }, /* HP out */
8657 .chain_id = ALC662_FIXUP_SKU_IGNORE
8659 [ALC662_FIXUP_ASUS_MODE3] = {
8660 .type = HDA_FIXUP_PINS,
8661 .v.pins = (const struct hda_pintbl[]) {
8662 { 0x14, 0x99130110 }, /* speaker */
8663 { 0x15, 0x0121441f }, /* HP */
8664 { 0x18, 0x01a19840 }, /* mic */
8665 { 0x19, 0x99a3094f }, /* int-mic */
8666 { 0x21, 0x01211420 }, /* HP2 */
8670 .chain_id = ALC662_FIXUP_SKU_IGNORE
8672 [ALC662_FIXUP_ASUS_MODE4] = {
8673 .type = HDA_FIXUP_PINS,
8674 .v.pins = (const struct hda_pintbl[]) {
8675 { 0x14, 0x99130110 }, /* speaker */
8676 { 0x16, 0x99130111 }, /* speaker */
8677 { 0x18, 0x01a19840 }, /* mic */
8678 { 0x19, 0x99a3094f }, /* int-mic */
8679 { 0x21, 0x0121441f }, /* HP */
8683 .chain_id = ALC662_FIXUP_SKU_IGNORE
8685 [ALC662_FIXUP_ASUS_MODE5] = {
8686 .type = HDA_FIXUP_PINS,
8687 .v.pins = (const struct hda_pintbl[]) {
8688 { 0x14, 0x99130110 }, /* speaker */
8689 { 0x15, 0x0121441f }, /* HP */
8690 { 0x16, 0x99130111 }, /* speaker */
8691 { 0x18, 0x01a19840 }, /* mic */
8692 { 0x19, 0x99a3094f }, /* int-mic */
8696 .chain_id = ALC662_FIXUP_SKU_IGNORE
8698 [ALC662_FIXUP_ASUS_MODE6] = {
8699 .type = HDA_FIXUP_PINS,
8700 .v.pins = (const struct hda_pintbl[]) {
8701 { 0x14, 0x99130110 }, /* speaker */
8702 { 0x15, 0x01211420 }, /* HP2 */
8703 { 0x18, 0x01a19840 }, /* mic */
8704 { 0x19, 0x99a3094f }, /* int-mic */
8705 { 0x1b, 0x0121441f }, /* HP */
8709 .chain_id = ALC662_FIXUP_SKU_IGNORE
8711 [ALC662_FIXUP_ASUS_MODE7] = {
8712 .type = HDA_FIXUP_PINS,
8713 .v.pins = (const struct hda_pintbl[]) {
8714 { 0x14, 0x99130110 }, /* speaker */
8715 { 0x17, 0x99130111 }, /* speaker */
8716 { 0x18, 0x01a19840 }, /* mic */
8717 { 0x19, 0x99a3094f }, /* int-mic */
8718 { 0x1b, 0x01214020 }, /* HP */
8719 { 0x21, 0x0121401f }, /* HP */
8723 .chain_id = ALC662_FIXUP_SKU_IGNORE
8725 [ALC662_FIXUP_ASUS_MODE8] = {
8726 .type = HDA_FIXUP_PINS,
8727 .v.pins = (const struct hda_pintbl[]) {
8728 { 0x14, 0x99130110 }, /* speaker */
8729 { 0x12, 0x99a30970 }, /* int-mic */
8730 { 0x15, 0x01214020 }, /* HP */
8731 { 0x17, 0x99130111 }, /* speaker */
8732 { 0x18, 0x01a19840 }, /* mic */
8733 { 0x21, 0x0121401f }, /* HP */
8737 .chain_id = ALC662_FIXUP_SKU_IGNORE
8739 [ALC662_FIXUP_NO_JACK_DETECT] = {
8740 .type = HDA_FIXUP_FUNC,
8741 .v.func = alc_fixup_no_jack_detect,
8743 [ALC662_FIXUP_ZOTAC_Z68] = {
8744 .type = HDA_FIXUP_PINS,
8745 .v.pins = (const struct hda_pintbl[]) {
8746 { 0x1b, 0x02214020 }, /* Front HP */
8750 [ALC662_FIXUP_INV_DMIC] = {
8751 .type = HDA_FIXUP_FUNC,
8752 .v.func = alc_fixup_inv_dmic,
8754 [ALC668_FIXUP_DELL_XPS13] = {
8755 .type = HDA_FIXUP_FUNC,
8756 .v.func = alc_fixup_dell_xps13,
8758 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
8760 [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
8761 .type = HDA_FIXUP_FUNC,
8762 .v.func = alc_fixup_disable_aamix,
8764 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
8766 [ALC668_FIXUP_AUTO_MUTE] = {
8767 .type = HDA_FIXUP_FUNC,
8768 .v.func = alc_fixup_auto_mute_via_amp,
8770 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
8772 [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
8773 .type = HDA_FIXUP_PINS,
8774 .v.pins = (const struct hda_pintbl[]) {
8775 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
8776 /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
8780 .chain_id = ALC662_FIXUP_HEADSET_MODE
8782 [ALC662_FIXUP_HEADSET_MODE] = {
8783 .type = HDA_FIXUP_FUNC,
8784 .v.func = alc_fixup_headset_mode_alc662,
8786 [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
8787 .type = HDA_FIXUP_PINS,
8788 .v.pins = (const struct hda_pintbl[]) {
8789 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
8790 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
8794 .chain_id = ALC668_FIXUP_HEADSET_MODE
8796 [ALC668_FIXUP_HEADSET_MODE] = {
8797 .type = HDA_FIXUP_FUNC,
8798 .v.func = alc_fixup_headset_mode_alc668,
8800 [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
8801 .type = HDA_FIXUP_FUNC,
8802 .v.func = alc_fixup_bass_chmap,
8804 .chain_id = ALC662_FIXUP_ASUS_MODE4
8806 [ALC662_FIXUP_BASS_16] = {
8807 .type = HDA_FIXUP_PINS,
8808 .v.pins = (const struct hda_pintbl[]) {
8809 {0x16, 0x80106111}, /* bass speaker */
8813 .chain_id = ALC662_FIXUP_BASS_CHMAP,
8815 [ALC662_FIXUP_BASS_1A] = {
8816 .type = HDA_FIXUP_PINS,
8817 .v.pins = (const struct hda_pintbl[]) {
8818 {0x1a, 0x80106111}, /* bass speaker */
8822 .chain_id = ALC662_FIXUP_BASS_CHMAP,
8824 [ALC662_FIXUP_BASS_CHMAP] = {
8825 .type = HDA_FIXUP_FUNC,
8826 .v.func = alc_fixup_bass_chmap,
8828 [ALC662_FIXUP_ASUS_Nx50] = {
8829 .type = HDA_FIXUP_FUNC,
8830 .v.func = alc_fixup_auto_mute_via_amp,
8832 .chain_id = ALC662_FIXUP_BASS_1A
8834 [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
8835 .type = HDA_FIXUP_FUNC,
8836 .v.func = alc_fixup_headset_mode_alc668,
8837 .chain_id = ALC662_FIXUP_BASS_CHMAP
8839 [ALC668_FIXUP_ASUS_Nx51] = {
8840 .type = HDA_FIXUP_PINS,
8841 .v.pins = (const struct hda_pintbl[]) {
8842 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
8843 { 0x1a, 0x90170151 }, /* bass speaker */
8844 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
8848 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
8850 [ALC668_FIXUP_MIC_COEF] = {
8851 .type = HDA_FIXUP_VERBS,
8852 .v.verbs = (const struct hda_verb[]) {
8853 { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
8854 { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
8858 [ALC668_FIXUP_ASUS_G751] = {
8859 .type = HDA_FIXUP_PINS,
8860 .v.pins = (const struct hda_pintbl[]) {
8861 { 0x16, 0x0421101f }, /* HP */
8865 .chain_id = ALC668_FIXUP_MIC_COEF
8867 [ALC891_FIXUP_HEADSET_MODE] = {
8868 .type = HDA_FIXUP_FUNC,
8869 .v.func = alc_fixup_headset_mode,
8871 [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
8872 .type = HDA_FIXUP_PINS,
8873 .v.pins = (const struct hda_pintbl[]) {
8874 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
8875 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
8879 .chain_id = ALC891_FIXUP_HEADSET_MODE
8881 [ALC662_FIXUP_ACER_VERITON] = {
8882 .type = HDA_FIXUP_PINS,
8883 .v.pins = (const struct hda_pintbl[]) {
8884 { 0x15, 0x50170120 }, /* no internal speaker */
8888 [ALC892_FIXUP_ASROCK_MOBO] = {
8889 .type = HDA_FIXUP_PINS,
8890 .v.pins = (const struct hda_pintbl[]) {
8891 { 0x15, 0x40f000f0 }, /* disabled */
8892 { 0x16, 0x40f000f0 }, /* disabled */
8896 [ALC662_FIXUP_USI_FUNC] = {
8897 .type = HDA_FIXUP_FUNC,
8898 .v.func = alc662_fixup_usi_headset_mic,
8900 [ALC662_FIXUP_USI_HEADSET_MODE] = {
8901 .type = HDA_FIXUP_PINS,
8902 .v.pins = (const struct hda_pintbl[]) {
8903 { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
8904 { 0x18, 0x01a1903d },
8908 .chain_id = ALC662_FIXUP_USI_FUNC
8910 [ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
8911 .type = HDA_FIXUP_FUNC,
8912 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8914 [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
8915 .type = HDA_FIXUP_FUNC,
8916 .v.func = alc662_fixup_aspire_ethos_hp,
8918 [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
8919 .type = HDA_FIXUP_PINS,
8920 .v.pins = (const struct hda_pintbl[]) {
8921 { 0x15, 0x92130110 }, /* front speakers */
8922 { 0x18, 0x99130111 }, /* center/subwoofer */
8923 { 0x1b, 0x11130012 }, /* surround plus jack for HP */
8927 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
8929 [ALC671_FIXUP_HP_HEADSET_MIC2] = {
8930 .type = HDA_FIXUP_FUNC,
8931 .v.func = alc671_fixup_hp_headset_mic2,
8935 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
8936 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
8937 SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
8938 SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
8939 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
8940 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
8941 SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
8942 SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
8943 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
8944 SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8945 SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8946 SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
8947 SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
8948 SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
8949 SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8950 SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8951 SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8952 SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8953 SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8954 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
8955 SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
8956 SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
8957 SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
8958 SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
8959 SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
8960 SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
8961 SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
8962 SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
8963 SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
8964 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
8965 SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
8966 SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
8967 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
8968 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
8969 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
8970 SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
8971 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
8972 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
8973 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
8974 SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
8975 SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
8976 SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
8977 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
8978 SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
8981 /* Below is a quirk table taken from the old code.
8982 * Basically the device should work as is without the fixup table.
8983 * If BIOS doesn't give a proper info, enable the corresponding
8986 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
8987 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
8988 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
8989 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
8990 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
8991 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8992 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
8993 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
8994 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
8995 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8996 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
8997 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
8998 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
8999 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
9000 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
9001 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9002 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
9003 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
9004 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9005 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
9006 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
9007 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9008 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
9009 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
9010 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
9011 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9012 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
9013 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
9014 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9015 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
9016 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9017 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9018 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
9019 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
9020 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
9021 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
9022 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
9023 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
9024 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
9025 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
9026 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
9027 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
9028 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
9029 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
9030 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
9031 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
9032 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
9033 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
9034 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
9035 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
9040 static const struct hda_model_fixup alc662_fixup_models[] = {
9041 {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
9042 {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
9043 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
9044 {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
9045 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
9046 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
9047 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
9048 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
9049 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
9050 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
9051 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
9052 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
9053 {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
9054 {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
9055 {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
9056 {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
9057 {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
9058 {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
9059 {.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
9060 {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
9061 {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
9062 {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
9063 {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
9064 {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
9065 {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
9066 {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
9067 {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
9068 {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
9069 {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
9070 {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
9071 {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
9072 {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
9076 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
9077 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
9081 {0x21, 0x01014020}),
9082 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
9086 {0x21, 0x01014020}),
9087 SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
9091 {0x1b, 0x0221401f}),
9092 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9096 {0x16, 0x03011020}),
9097 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9101 {0x16, 0x03011020}),
9102 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9106 {0x16, 0x03011020}),
9107 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9110 {0x16, 0x03011020}),
9111 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
9114 {0x15, 0x0321101f}),
9115 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
9120 {0x21, 0x02211020}),
9121 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
9125 {0x21, 0x02211020}),
9126 SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
9131 {0x21, 0x02211030}),
9137 static int patch_alc662(struct hda_codec *codec)
9139 struct alc_spec *spec;
9142 err = alc_alloc_spec(codec, 0x0b);
9148 spec->shutup = alc_eapd_shutup;
9150 /* handle multiple HPs as is */
9151 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
9153 alc_fix_pll_init(codec, 0x20, 0x04, 15);
9155 switch (codec->core.vendor_id) {
9157 spec->init_hook = alc668_restore_default_value;
9161 alc_pre_init(codec);
9163 snd_hda_pick_fixup(codec, alc662_fixup_models,
9164 alc662_fixup_tbl, alc662_fixups);
9165 snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
9166 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
9168 alc_auto_parse_customize_define(codec);
9170 if (has_cdefine_beep(codec))
9171 spec->gen.beep_nid = 0x01;
9173 if ((alc_get_coef0(codec) & (1 << 14)) &&
9174 codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
9175 spec->cdefine.platform_type == 1) {
9176 err = alc_codec_rename(codec, "ALC272X");
9181 /* automatic parse from the BIOS config */
9182 err = alc662_parse_auto_config(codec);
9186 if (!spec->gen.no_analog && spec->gen.beep_nid) {
9187 switch (codec->core.vendor_id) {
9189 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9195 err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
9198 err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
9205 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
9218 static int alc680_parse_auto_config(struct hda_codec *codec)
9220 return alc_parse_auto_config(codec, NULL, NULL);
9225 static int patch_alc680(struct hda_codec *codec)
9229 /* ALC680 has no aa-loopback mixer */
9230 err = alc_alloc_spec(codec, 0);
9234 /* automatic parse from the BIOS config */
9235 err = alc680_parse_auto_config(codec);
9247 static const struct hda_device_id snd_hda_id_realtek[] = {
9248 HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
9249 HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
9250 HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
9251 HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
9252 HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
9253 HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
9254 HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
9255 HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
9256 HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
9257 HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
9258 HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
9259 HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
9260 HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
9261 HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
9262 HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
9263 HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
9264 HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
9265 HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
9266 HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
9267 HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
9268 HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
9269 HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
9270 HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
9271 HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
9272 HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
9273 HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
9274 HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
9275 HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
9276 HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
9277 HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
9278 HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
9279 HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
9280 HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
9281 HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
9282 HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
9283 HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
9284 HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
9285 HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
9286 HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
9287 HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
9288 HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
9289 HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
9290 HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
9291 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
9292 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
9293 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
9294 HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
9295 HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
9296 HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
9297 HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
9298 HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
9299 HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
9300 HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
9301 HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
9302 HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
9303 HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
9304 HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
9305 HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
9306 HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
9307 HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
9308 HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
9309 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
9310 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
9311 HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
9312 HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
9313 HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
9314 HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
9315 HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
9316 HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
9317 HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
9318 HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
9319 HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
9320 HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
9321 HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
9324 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
9326 MODULE_LICENSE("GPL");
9327 MODULE_DESCRIPTION("Realtek HD-audio codec");
9329 static struct hda_codec_driver realtek_driver = {
9330 .id = snd_hda_id_realtek,
9333 module_hda_codec_driver(realtek_driver);