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 */
416 alc_update_coef_idx(codec, 0x19, 1<<13, 0);
419 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
422 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
425 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
426 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
429 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
435 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
440 /* additional initialization for ALC888 variants */
441 static void alc888_coef_init(struct hda_codec *codec)
443 switch (alc_get_coef0(codec) & 0x00f0) {
448 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
453 /* turn on/off EAPD control (only if available) */
454 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
456 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
458 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
459 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
463 /* turn on/off EAPD controls of the codec */
464 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
466 /* We currently only handle front, HP */
467 static hda_nid_t pins[] = {
468 0x0f, 0x10, 0x14, 0x15, 0x17, 0
471 for (p = pins; *p; p++)
472 set_eapd(codec, *p, on);
475 static int find_ext_mic_pin(struct hda_codec *codec);
477 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
479 const struct hda_pincfg *pin;
480 int mic_pin = find_ext_mic_pin(codec);
483 /* don't shut up pins when unloading the driver; otherwise it breaks
484 * the default pin setup at the next load of the driver
486 if (codec->bus->shutdown)
489 snd_array_for_each(&codec->init_pins, i, pin) {
490 /* use read here for syncing after issuing each verb */
491 if (pin->nid != mic_pin)
492 snd_hda_codec_read(codec, pin->nid, 0,
493 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
496 codec->pins_shutup = 1;
499 static void alc_shutup_pins(struct hda_codec *codec)
501 struct alc_spec *spec = codec->spec;
503 switch (codec->core.vendor_id) {
507 alc_headset_mic_no_shutup(codec);
510 if (!spec->no_shutup_pins)
511 snd_hda_shutup_pins(codec);
516 /* generic shutup callback;
517 * just turning off EAPD and a little pause for avoiding pop-noise
519 static void alc_eapd_shutup(struct hda_codec *codec)
521 struct alc_spec *spec = codec->spec;
523 alc_auto_setup_eapd(codec, false);
524 if (!spec->no_depop_delay)
526 alc_shutup_pins(codec);
529 /* generic EAPD initialization */
530 static void alc_auto_init_amp(struct hda_codec *codec, int type)
532 alc_auto_setup_eapd(codec, true);
533 alc_write_gpio(codec);
535 case ALC_INIT_DEFAULT:
536 switch (codec->core.vendor_id) {
538 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
544 alc_update_coef_idx(codec, 7, 0, 0x2030);
547 alc888_coef_init(codec);
554 /* get a primary headphone pin if available */
555 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
557 if (spec->gen.autocfg.hp_pins[0])
558 return spec->gen.autocfg.hp_pins[0];
559 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
560 return spec->gen.autocfg.line_out_pins[0];
565 * Realtek SSID verification
568 /* Could be any non-zero and even value. When used as fixup, tells
569 * the driver to ignore any present sku defines.
571 #define ALC_FIXUP_SKU_IGNORE (2)
573 static void alc_fixup_sku_ignore(struct hda_codec *codec,
574 const struct hda_fixup *fix, int action)
576 struct alc_spec *spec = codec->spec;
577 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
578 spec->cdefine.fixup = 1;
579 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
583 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
584 const struct hda_fixup *fix, int action)
586 struct alc_spec *spec = codec->spec;
588 if (action == HDA_FIXUP_ACT_PROBE) {
589 spec->no_depop_delay = 1;
590 codec->depop_delay = 0;
594 static int alc_auto_parse_customize_define(struct hda_codec *codec)
596 unsigned int ass, tmp, i;
598 struct alc_spec *spec = codec->spec;
600 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
602 if (spec->cdefine.fixup) {
603 ass = spec->cdefine.sku_cfg;
604 if (ass == ALC_FIXUP_SKU_IGNORE)
609 if (!codec->bus->pci)
611 ass = codec->core.subsystem_id & 0xffff;
612 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
616 if (codec->core.vendor_id == 0x10ec0260)
618 ass = snd_hda_codec_get_pincfg(codec, nid);
621 codec_info(codec, "%s: SKU not ready 0x%08x\n",
622 codec->core.chip_name, ass);
628 for (i = 1; i < 16; i++) {
632 if (((ass >> 16) & 0xf) != tmp)
635 spec->cdefine.port_connectivity = ass >> 30;
636 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
637 spec->cdefine.check_sum = (ass >> 16) & 0xf;
638 spec->cdefine.customization = ass >> 8;
640 spec->cdefine.sku_cfg = ass;
641 spec->cdefine.external_amp = (ass & 0x38) >> 3;
642 spec->cdefine.platform_type = (ass & 0x4) >> 2;
643 spec->cdefine.swap = (ass & 0x2) >> 1;
644 spec->cdefine.override = ass & 0x1;
646 codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
647 nid, spec->cdefine.sku_cfg);
648 codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
649 spec->cdefine.port_connectivity);
650 codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
651 codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
652 codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
653 codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
654 codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
655 codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
656 codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
661 /* return the position of NID in the list, or -1 if not found */
662 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
665 for (i = 0; i < nums; i++)
670 /* return true if the given NID is found in the list */
671 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
673 return find_idx_in_nid_list(nid, list, nums) >= 0;
676 /* check subsystem ID and set up device-specific initialization;
677 * return 1 if initialized, 0 if invalid SSID
679 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
680 * 31 ~ 16 : Manufacture ID
682 * 7 ~ 0 : Assembly ID
683 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
685 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
687 unsigned int ass, tmp, i;
689 struct alc_spec *spec = codec->spec;
691 if (spec->cdefine.fixup) {
692 ass = spec->cdefine.sku_cfg;
693 if (ass == ALC_FIXUP_SKU_IGNORE)
698 ass = codec->core.subsystem_id & 0xffff;
699 if (codec->bus->pci &&
700 ass != codec->bus->pci->subsystem_device && (ass & 1))
703 /* invalid SSID, check the special NID pin defcfg instead */
705 * 31~30 : port connectivity
708 * 19~16 : Check sum (15:1)
713 if (codec->core.vendor_id == 0x10ec0260)
715 ass = snd_hda_codec_get_pincfg(codec, nid);
717 "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
721 if ((ass >> 30) != 1) /* no physical connection */
726 for (i = 1; i < 16; i++) {
730 if (((ass >> 16) & 0xf) != tmp)
733 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
734 ass & 0xffff, codec->core.vendor_id);
738 * 2 : 0 --> Desktop, 1 --> Laptop
739 * 3~5 : External Amplifier control
742 tmp = (ass & 0x38) >> 3; /* external Amp control */
743 if (spec->init_amp == ALC_INIT_UNDEFINED) {
746 alc_setup_gpio(codec, 0x01);
749 alc_setup_gpio(codec, 0x02);
752 alc_setup_gpio(codec, 0x03);
756 spec->init_amp = ALC_INIT_DEFAULT;
761 /* is laptop or Desktop and enable the function "Mute internal speaker
762 * when the external headphone out jack is plugged"
767 * 10~8 : Jack location
768 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
770 * 15 : 1 --> enable the function "Mute internal speaker
771 * when the external headphone out jack is plugged"
773 if (!alc_get_hp_pin(spec)) {
775 tmp = (ass >> 11) & 0x3; /* HP to chassis */
777 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
778 spec->gen.autocfg.line_outs))
780 spec->gen.autocfg.hp_pins[0] = nid;
785 /* Check the validity of ALC subsystem-id
786 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
787 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
789 if (!alc_subsystem_id(codec, ports)) {
790 struct alc_spec *spec = codec->spec;
792 "realtek: Enable default setup for auto mode as fallback\n");
793 spec->init_amp = ALC_INIT_DEFAULT;
800 static void alc_fixup_inv_dmic(struct hda_codec *codec,
801 const struct hda_fixup *fix, int action)
803 struct alc_spec *spec = codec->spec;
805 spec->gen.inv_dmic_split = 1;
809 static int alc_build_controls(struct hda_codec *codec)
813 err = snd_hda_gen_build_controls(codec);
817 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
826 static void alc_pre_init(struct hda_codec *codec)
828 alc_fill_eapd_coef(codec);
831 #define is_s3_resume(codec) \
832 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
833 #define is_s4_resume(codec) \
834 ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
836 static int alc_init(struct hda_codec *codec)
838 struct alc_spec *spec = codec->spec;
840 /* hibernation resume needs the full chip initialization */
841 if (is_s4_resume(codec))
845 spec->init_hook(codec);
847 spec->gen.skip_verbs = 1; /* applied in below */
848 snd_hda_gen_init(codec);
850 alc_auto_init_amp(codec, spec->init_amp);
851 snd_hda_apply_verbs(codec); /* apply verbs here after own init */
853 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
858 static inline void alc_shutup(struct hda_codec *codec)
860 struct alc_spec *spec = codec->spec;
862 if (!snd_hda_get_bool_hint(codec, "shutup"))
863 return; /* disabled explicitly by hints */
865 if (spec && spec->shutup)
868 alc_shutup_pins(codec);
871 static void alc_reboot_notify(struct hda_codec *codec)
873 struct alc_spec *spec = codec->spec;
875 if (spec && spec->reboot_notify)
876 spec->reboot_notify(codec);
881 #define alc_free snd_hda_gen_free
884 static void alc_power_eapd(struct hda_codec *codec)
886 alc_auto_setup_eapd(codec, false);
889 static int alc_suspend(struct hda_codec *codec)
891 struct alc_spec *spec = codec->spec;
893 if (spec && spec->power_hook)
894 spec->power_hook(codec);
900 static int alc_resume(struct hda_codec *codec)
902 struct alc_spec *spec = codec->spec;
904 if (!spec->no_depop_delay)
905 msleep(150); /* to avoid pop noise */
906 codec->patch_ops.init(codec);
907 regcache_sync(codec->core.regmap);
908 hda_call_check_power_status(codec, 0x01);
915 static const struct hda_codec_ops alc_patch_ops = {
916 .build_controls = alc_build_controls,
917 .build_pcms = snd_hda_gen_build_pcms,
920 .unsol_event = snd_hda_jack_unsol_event,
922 .resume = alc_resume,
923 .suspend = alc_suspend,
924 .check_power_status = snd_hda_gen_check_power_status,
926 .reboot_notify = alc_reboot_notify,
930 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
933 * Rename codecs appropriately from COEF value or subvendor id
935 struct alc_codec_rename_table {
936 unsigned int vendor_id;
937 unsigned short coef_mask;
938 unsigned short coef_bits;
942 struct alc_codec_rename_pci_table {
943 unsigned int codec_vendor_id;
944 unsigned short pci_subvendor;
945 unsigned short pci_subdevice;
949 static struct alc_codec_rename_table rename_tbl[] = {
950 { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
951 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
952 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
953 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
954 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
955 { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
956 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
957 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
958 { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
959 { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
960 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
961 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
962 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
963 { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
964 { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
965 { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
966 { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
970 static struct alc_codec_rename_pci_table rename_pci_tbl[] = {
971 { 0x10ec0280, 0x1028, 0, "ALC3220" },
972 { 0x10ec0282, 0x1028, 0, "ALC3221" },
973 { 0x10ec0283, 0x1028, 0, "ALC3223" },
974 { 0x10ec0288, 0x1028, 0, "ALC3263" },
975 { 0x10ec0292, 0x1028, 0, "ALC3226" },
976 { 0x10ec0293, 0x1028, 0, "ALC3235" },
977 { 0x10ec0255, 0x1028, 0, "ALC3234" },
978 { 0x10ec0668, 0x1028, 0, "ALC3661" },
979 { 0x10ec0275, 0x1028, 0, "ALC3260" },
980 { 0x10ec0899, 0x1028, 0, "ALC3861" },
981 { 0x10ec0298, 0x1028, 0, "ALC3266" },
982 { 0x10ec0236, 0x1028, 0, "ALC3204" },
983 { 0x10ec0256, 0x1028, 0, "ALC3246" },
984 { 0x10ec0225, 0x1028, 0, "ALC3253" },
985 { 0x10ec0295, 0x1028, 0, "ALC3254" },
986 { 0x10ec0299, 0x1028, 0, "ALC3271" },
987 { 0x10ec0670, 0x1025, 0, "ALC669X" },
988 { 0x10ec0676, 0x1025, 0, "ALC679X" },
989 { 0x10ec0282, 0x1043, 0, "ALC3229" },
990 { 0x10ec0233, 0x1043, 0, "ALC3236" },
991 { 0x10ec0280, 0x103c, 0, "ALC3228" },
992 { 0x10ec0282, 0x103c, 0, "ALC3227" },
993 { 0x10ec0286, 0x103c, 0, "ALC3242" },
994 { 0x10ec0290, 0x103c, 0, "ALC3241" },
995 { 0x10ec0668, 0x103c, 0, "ALC3662" },
996 { 0x10ec0283, 0x17aa, 0, "ALC3239" },
997 { 0x10ec0292, 0x17aa, 0, "ALC3232" },
1001 static int alc_codec_rename_from_preset(struct hda_codec *codec)
1003 const struct alc_codec_rename_table *p;
1004 const struct alc_codec_rename_pci_table *q;
1006 for (p = rename_tbl; p->vendor_id; p++) {
1007 if (p->vendor_id != codec->core.vendor_id)
1009 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1010 return alc_codec_rename(codec, p->name);
1013 if (!codec->bus->pci)
1015 for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1016 if (q->codec_vendor_id != codec->core.vendor_id)
1018 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1020 if (!q->pci_subdevice ||
1021 q->pci_subdevice == codec->bus->pci->subsystem_device)
1022 return alc_codec_rename(codec, q->name);
1030 * Digital-beep handlers
1032 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1034 /* additional beep mixers; private_value will be overwritten */
1035 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1036 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1037 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1040 /* set up and create beep controls */
1041 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1044 struct snd_kcontrol_new *knew;
1045 unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1048 for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1049 knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1050 &alc_beep_mixer[i]);
1053 knew->private_value = beep_amp;
1058 static const struct snd_pci_quirk beep_white_list[] = {
1059 SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1060 SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1061 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1062 SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1063 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1064 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1065 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1066 SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1067 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1068 /* blacklist -- no beep available */
1069 SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1070 SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1074 static inline int has_cdefine_beep(struct hda_codec *codec)
1076 struct alc_spec *spec = codec->spec;
1077 const struct snd_pci_quirk *q;
1078 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
1081 return spec->cdefine.enable_pcbeep;
1084 #define set_beep_amp(spec, nid, idx, dir) 0
1085 #define has_cdefine_beep(codec) 0
1088 /* parse the BIOS configuration and set up the alc_spec */
1089 /* return 1 if successful, 0 if the proper config is not found,
1090 * or a negative error code
1092 static int alc_parse_auto_config(struct hda_codec *codec,
1093 const hda_nid_t *ignore_nids,
1094 const hda_nid_t *ssid_nids)
1096 struct alc_spec *spec = codec->spec;
1097 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1100 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1106 alc_ssid_check(codec, ssid_nids);
1108 err = snd_hda_gen_parse_auto_config(codec, cfg);
1115 /* common preparation job for alc_spec */
1116 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1118 struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1124 snd_hda_gen_spec_init(&spec->gen);
1125 spec->gen.mixer_nid = mixer_nid;
1126 spec->gen.own_eapd_ctl = 1;
1127 codec->single_adc_amp = 1;
1128 /* FIXME: do we need this for all Realtek codec models? */
1129 codec->spdif_status_reset = 1;
1130 codec->patch_ops = alc_patch_ops;
1132 err = alc_codec_rename_from_preset(codec);
1140 static int alc880_parse_auto_config(struct hda_codec *codec)
1142 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1143 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1144 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1153 ALC880_FIXUP_MEDION_RIM,
1155 ALC880_FIXUP_LG_LW25,
1157 ALC880_FIXUP_EAPD_COEF,
1158 ALC880_FIXUP_TCL_S700,
1159 ALC880_FIXUP_VOL_KNOB,
1160 ALC880_FIXUP_FUJITSU,
1162 ALC880_FIXUP_UNIWILL,
1163 ALC880_FIXUP_UNIWILL_DIG,
1165 ALC880_FIXUP_ASUS_W5A,
1166 ALC880_FIXUP_3ST_BASE,
1168 ALC880_FIXUP_3ST_DIG,
1169 ALC880_FIXUP_5ST_BASE,
1171 ALC880_FIXUP_5ST_DIG,
1172 ALC880_FIXUP_6ST_BASE,
1174 ALC880_FIXUP_6ST_DIG,
1175 ALC880_FIXUP_6ST_AUTOMUTE,
1178 /* enable the volume-knob widget support on NID 0x21 */
1179 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1180 const struct hda_fixup *fix, int action)
1182 if (action == HDA_FIXUP_ACT_PROBE)
1183 snd_hda_jack_detect_enable_callback(codec, 0x21,
1184 alc_update_knob_master);
1187 static const struct hda_fixup alc880_fixups[] = {
1188 [ALC880_FIXUP_GPIO1] = {
1189 .type = HDA_FIXUP_FUNC,
1190 .v.func = alc_fixup_gpio1,
1192 [ALC880_FIXUP_GPIO2] = {
1193 .type = HDA_FIXUP_FUNC,
1194 .v.func = alc_fixup_gpio2,
1196 [ALC880_FIXUP_MEDION_RIM] = {
1197 .type = HDA_FIXUP_VERBS,
1198 .v.verbs = (const struct hda_verb[]) {
1199 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1200 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1204 .chain_id = ALC880_FIXUP_GPIO2,
1206 [ALC880_FIXUP_LG] = {
1207 .type = HDA_FIXUP_PINS,
1208 .v.pins = (const struct hda_pintbl[]) {
1209 /* disable bogus unused pins */
1210 { 0x16, 0x411111f0 },
1211 { 0x18, 0x411111f0 },
1212 { 0x1a, 0x411111f0 },
1216 [ALC880_FIXUP_LG_LW25] = {
1217 .type = HDA_FIXUP_PINS,
1218 .v.pins = (const struct hda_pintbl[]) {
1219 { 0x1a, 0x0181344f }, /* line-in */
1220 { 0x1b, 0x0321403f }, /* headphone */
1224 [ALC880_FIXUP_W810] = {
1225 .type = HDA_FIXUP_PINS,
1226 .v.pins = (const struct hda_pintbl[]) {
1227 /* disable bogus unused pins */
1228 { 0x17, 0x411111f0 },
1232 .chain_id = ALC880_FIXUP_GPIO2,
1234 [ALC880_FIXUP_EAPD_COEF] = {
1235 .type = HDA_FIXUP_VERBS,
1236 .v.verbs = (const struct hda_verb[]) {
1237 /* change to EAPD mode */
1238 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1239 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1243 [ALC880_FIXUP_TCL_S700] = {
1244 .type = HDA_FIXUP_VERBS,
1245 .v.verbs = (const struct hda_verb[]) {
1246 /* change to EAPD mode */
1247 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1248 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
1252 .chain_id = ALC880_FIXUP_GPIO2,
1254 [ALC880_FIXUP_VOL_KNOB] = {
1255 .type = HDA_FIXUP_FUNC,
1256 .v.func = alc880_fixup_vol_knob,
1258 [ALC880_FIXUP_FUJITSU] = {
1259 /* override all pins as BIOS on old Amilo is broken */
1260 .type = HDA_FIXUP_PINS,
1261 .v.pins = (const struct hda_pintbl[]) {
1262 { 0x14, 0x0121401f }, /* HP */
1263 { 0x15, 0x99030120 }, /* speaker */
1264 { 0x16, 0x99030130 }, /* bass speaker */
1265 { 0x17, 0x411111f0 }, /* N/A */
1266 { 0x18, 0x411111f0 }, /* N/A */
1267 { 0x19, 0x01a19950 }, /* mic-in */
1268 { 0x1a, 0x411111f0 }, /* N/A */
1269 { 0x1b, 0x411111f0 }, /* N/A */
1270 { 0x1c, 0x411111f0 }, /* N/A */
1271 { 0x1d, 0x411111f0 }, /* N/A */
1272 { 0x1e, 0x01454140 }, /* SPDIF out */
1276 .chain_id = ALC880_FIXUP_VOL_KNOB,
1278 [ALC880_FIXUP_F1734] = {
1279 /* almost compatible with FUJITSU, but no bass and SPDIF */
1280 .type = HDA_FIXUP_PINS,
1281 .v.pins = (const struct hda_pintbl[]) {
1282 { 0x14, 0x0121401f }, /* HP */
1283 { 0x15, 0x99030120 }, /* speaker */
1284 { 0x16, 0x411111f0 }, /* N/A */
1285 { 0x17, 0x411111f0 }, /* N/A */
1286 { 0x18, 0x411111f0 }, /* N/A */
1287 { 0x19, 0x01a19950 }, /* mic-in */
1288 { 0x1a, 0x411111f0 }, /* N/A */
1289 { 0x1b, 0x411111f0 }, /* N/A */
1290 { 0x1c, 0x411111f0 }, /* N/A */
1291 { 0x1d, 0x411111f0 }, /* N/A */
1292 { 0x1e, 0x411111f0 }, /* N/A */
1296 .chain_id = ALC880_FIXUP_VOL_KNOB,
1298 [ALC880_FIXUP_UNIWILL] = {
1299 /* need to fix HP and speaker pins to be parsed correctly */
1300 .type = HDA_FIXUP_PINS,
1301 .v.pins = (const struct hda_pintbl[]) {
1302 { 0x14, 0x0121411f }, /* HP */
1303 { 0x15, 0x99030120 }, /* speaker */
1304 { 0x16, 0x99030130 }, /* bass speaker */
1308 [ALC880_FIXUP_UNIWILL_DIG] = {
1309 .type = HDA_FIXUP_PINS,
1310 .v.pins = (const struct hda_pintbl[]) {
1311 /* disable bogus unused pins */
1312 { 0x17, 0x411111f0 },
1313 { 0x19, 0x411111f0 },
1314 { 0x1b, 0x411111f0 },
1315 { 0x1f, 0x411111f0 },
1319 [ALC880_FIXUP_Z71V] = {
1320 .type = HDA_FIXUP_PINS,
1321 .v.pins = (const struct hda_pintbl[]) {
1322 /* set up the whole pins as BIOS is utterly broken */
1323 { 0x14, 0x99030120 }, /* speaker */
1324 { 0x15, 0x0121411f }, /* HP */
1325 { 0x16, 0x411111f0 }, /* N/A */
1326 { 0x17, 0x411111f0 }, /* N/A */
1327 { 0x18, 0x01a19950 }, /* mic-in */
1328 { 0x19, 0x411111f0 }, /* N/A */
1329 { 0x1a, 0x01813031 }, /* line-in */
1330 { 0x1b, 0x411111f0 }, /* N/A */
1331 { 0x1c, 0x411111f0 }, /* N/A */
1332 { 0x1d, 0x411111f0 }, /* N/A */
1333 { 0x1e, 0x0144111e }, /* SPDIF */
1337 [ALC880_FIXUP_ASUS_W5A] = {
1338 .type = HDA_FIXUP_PINS,
1339 .v.pins = (const struct hda_pintbl[]) {
1340 /* set up the whole pins as BIOS is utterly broken */
1341 { 0x14, 0x0121411f }, /* HP */
1342 { 0x15, 0x411111f0 }, /* N/A */
1343 { 0x16, 0x411111f0 }, /* N/A */
1344 { 0x17, 0x411111f0 }, /* N/A */
1345 { 0x18, 0x90a60160 }, /* mic */
1346 { 0x19, 0x411111f0 }, /* N/A */
1347 { 0x1a, 0x411111f0 }, /* N/A */
1348 { 0x1b, 0x411111f0 }, /* N/A */
1349 { 0x1c, 0x411111f0 }, /* N/A */
1350 { 0x1d, 0x411111f0 }, /* N/A */
1351 { 0x1e, 0xb743111e }, /* SPDIF out */
1355 .chain_id = ALC880_FIXUP_GPIO1,
1357 [ALC880_FIXUP_3ST_BASE] = {
1358 .type = HDA_FIXUP_PINS,
1359 .v.pins = (const struct hda_pintbl[]) {
1360 { 0x14, 0x01014010 }, /* line-out */
1361 { 0x15, 0x411111f0 }, /* N/A */
1362 { 0x16, 0x411111f0 }, /* N/A */
1363 { 0x17, 0x411111f0 }, /* N/A */
1364 { 0x18, 0x01a19c30 }, /* mic-in */
1365 { 0x19, 0x0121411f }, /* HP */
1366 { 0x1a, 0x01813031 }, /* line-in */
1367 { 0x1b, 0x02a19c40 }, /* front-mic */
1368 { 0x1c, 0x411111f0 }, /* N/A */
1369 { 0x1d, 0x411111f0 }, /* N/A */
1370 /* 0x1e is filled in below */
1371 { 0x1f, 0x411111f0 }, /* N/A */
1375 [ALC880_FIXUP_3ST] = {
1376 .type = HDA_FIXUP_PINS,
1377 .v.pins = (const struct hda_pintbl[]) {
1378 { 0x1e, 0x411111f0 }, /* N/A */
1382 .chain_id = ALC880_FIXUP_3ST_BASE,
1384 [ALC880_FIXUP_3ST_DIG] = {
1385 .type = HDA_FIXUP_PINS,
1386 .v.pins = (const struct hda_pintbl[]) {
1387 { 0x1e, 0x0144111e }, /* SPDIF */
1391 .chain_id = ALC880_FIXUP_3ST_BASE,
1393 [ALC880_FIXUP_5ST_BASE] = {
1394 .type = HDA_FIXUP_PINS,
1395 .v.pins = (const struct hda_pintbl[]) {
1396 { 0x14, 0x01014010 }, /* front */
1397 { 0x15, 0x411111f0 }, /* N/A */
1398 { 0x16, 0x01011411 }, /* CLFE */
1399 { 0x17, 0x01016412 }, /* surr */
1400 { 0x18, 0x01a19c30 }, /* mic-in */
1401 { 0x19, 0x0121411f }, /* HP */
1402 { 0x1a, 0x01813031 }, /* line-in */
1403 { 0x1b, 0x02a19c40 }, /* front-mic */
1404 { 0x1c, 0x411111f0 }, /* N/A */
1405 { 0x1d, 0x411111f0 }, /* N/A */
1406 /* 0x1e is filled in below */
1407 { 0x1f, 0x411111f0 }, /* N/A */
1411 [ALC880_FIXUP_5ST] = {
1412 .type = HDA_FIXUP_PINS,
1413 .v.pins = (const struct hda_pintbl[]) {
1414 { 0x1e, 0x411111f0 }, /* N/A */
1418 .chain_id = ALC880_FIXUP_5ST_BASE,
1420 [ALC880_FIXUP_5ST_DIG] = {
1421 .type = HDA_FIXUP_PINS,
1422 .v.pins = (const struct hda_pintbl[]) {
1423 { 0x1e, 0x0144111e }, /* SPDIF */
1427 .chain_id = ALC880_FIXUP_5ST_BASE,
1429 [ALC880_FIXUP_6ST_BASE] = {
1430 .type = HDA_FIXUP_PINS,
1431 .v.pins = (const struct hda_pintbl[]) {
1432 { 0x14, 0x01014010 }, /* front */
1433 { 0x15, 0x01016412 }, /* surr */
1434 { 0x16, 0x01011411 }, /* CLFE */
1435 { 0x17, 0x01012414 }, /* side */
1436 { 0x18, 0x01a19c30 }, /* mic-in */
1437 { 0x19, 0x02a19c40 }, /* front-mic */
1438 { 0x1a, 0x01813031 }, /* line-in */
1439 { 0x1b, 0x0121411f }, /* HP */
1440 { 0x1c, 0x411111f0 }, /* N/A */
1441 { 0x1d, 0x411111f0 }, /* N/A */
1442 /* 0x1e is filled in below */
1443 { 0x1f, 0x411111f0 }, /* N/A */
1447 [ALC880_FIXUP_6ST] = {
1448 .type = HDA_FIXUP_PINS,
1449 .v.pins = (const struct hda_pintbl[]) {
1450 { 0x1e, 0x411111f0 }, /* N/A */
1454 .chain_id = ALC880_FIXUP_6ST_BASE,
1456 [ALC880_FIXUP_6ST_DIG] = {
1457 .type = HDA_FIXUP_PINS,
1458 .v.pins = (const struct hda_pintbl[]) {
1459 { 0x1e, 0x0144111e }, /* SPDIF */
1463 .chain_id = ALC880_FIXUP_6ST_BASE,
1465 [ALC880_FIXUP_6ST_AUTOMUTE] = {
1466 .type = HDA_FIXUP_PINS,
1467 .v.pins = (const struct hda_pintbl[]) {
1468 { 0x1b, 0x0121401f }, /* HP with jack detect */
1471 .chained_before = true,
1472 .chain_id = ALC880_FIXUP_6ST_BASE,
1476 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1477 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1478 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1479 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1480 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1481 SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1482 SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1483 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1484 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1485 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1486 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1487 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1488 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1489 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1490 SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1491 SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1492 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1493 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1494 SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1495 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1496 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1497 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1498 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1499 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1501 /* Below is the copied entries from alc880_quirks.c.
1502 * It's not quite sure whether BIOS sets the correct pin-config table
1503 * on these machines, thus they are kept to be compatible with
1504 * the old static quirks. Once when it's confirmed to work without
1505 * these overrides, it'd be better to remove.
1507 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1508 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1509 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1510 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1511 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1512 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1513 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1514 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1515 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1516 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1517 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1518 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1519 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1520 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1521 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1522 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1523 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1524 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1525 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1526 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1527 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1528 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1529 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1530 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1531 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1532 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1533 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1534 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1535 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1536 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1537 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1538 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1539 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1541 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1542 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1543 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1547 static const struct hda_model_fixup alc880_fixup_models[] = {
1548 {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1549 {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1550 {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1551 {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1552 {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1553 {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1554 {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1560 * OK, here we have finally the patch for ALC880
1562 static int patch_alc880(struct hda_codec *codec)
1564 struct alc_spec *spec;
1567 err = alc_alloc_spec(codec, 0x0b);
1572 spec->gen.need_dac_fix = 1;
1573 spec->gen.beep_nid = 0x01;
1575 codec->patch_ops.unsol_event = alc880_unsol_event;
1577 alc_pre_init(codec);
1579 snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1581 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1583 /* automatic parse from the BIOS config */
1584 err = alc880_parse_auto_config(codec);
1588 if (!spec->gen.no_analog) {
1589 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1594 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1607 static int alc260_parse_auto_config(struct hda_codec *codec)
1609 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1610 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1611 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1618 ALC260_FIXUP_HP_DC5750,
1619 ALC260_FIXUP_HP_PIN_0F,
1622 ALC260_FIXUP_GPIO1_TOGGLE,
1623 ALC260_FIXUP_REPLACER,
1624 ALC260_FIXUP_HP_B1900,
1626 ALC260_FIXUP_FSC_S7020,
1627 ALC260_FIXUP_FSC_S7020_JWSE,
1628 ALC260_FIXUP_VAIO_PINS,
1631 static void alc260_gpio1_automute(struct hda_codec *codec)
1633 struct alc_spec *spec = codec->spec;
1635 alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1638 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1639 const struct hda_fixup *fix, int action)
1641 struct alc_spec *spec = codec->spec;
1642 if (action == HDA_FIXUP_ACT_PROBE) {
1643 /* although the machine has only one output pin, we need to
1644 * toggle GPIO1 according to the jack state
1646 spec->gen.automute_hook = alc260_gpio1_automute;
1647 spec->gen.detect_hp = 1;
1648 spec->gen.automute_speaker = 1;
1649 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1650 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1651 snd_hda_gen_hp_automute);
1652 alc_setup_gpio(codec, 0x01);
1656 static void alc260_fixup_kn1(struct hda_codec *codec,
1657 const struct hda_fixup *fix, int action)
1659 struct alc_spec *spec = codec->spec;
1660 static const struct hda_pintbl pincfgs[] = {
1661 { 0x0f, 0x02214000 }, /* HP/speaker */
1662 { 0x12, 0x90a60160 }, /* int mic */
1663 { 0x13, 0x02a19000 }, /* ext mic */
1664 { 0x18, 0x01446000 }, /* SPDIF out */
1665 /* disable bogus I/O pins */
1666 { 0x10, 0x411111f0 },
1667 { 0x11, 0x411111f0 },
1668 { 0x14, 0x411111f0 },
1669 { 0x15, 0x411111f0 },
1670 { 0x16, 0x411111f0 },
1671 { 0x17, 0x411111f0 },
1672 { 0x19, 0x411111f0 },
1677 case HDA_FIXUP_ACT_PRE_PROBE:
1678 snd_hda_apply_pincfgs(codec, pincfgs);
1679 spec->init_amp = ALC_INIT_NONE;
1684 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1685 const struct hda_fixup *fix, int action)
1687 struct alc_spec *spec = codec->spec;
1688 if (action == HDA_FIXUP_ACT_PRE_PROBE)
1689 spec->init_amp = ALC_INIT_NONE;
1692 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1693 const struct hda_fixup *fix, int action)
1695 struct alc_spec *spec = codec->spec;
1696 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1697 spec->gen.add_jack_modes = 1;
1698 spec->gen.hp_mic = 1;
1702 static const struct hda_fixup alc260_fixups[] = {
1703 [ALC260_FIXUP_HP_DC5750] = {
1704 .type = HDA_FIXUP_PINS,
1705 .v.pins = (const struct hda_pintbl[]) {
1706 { 0x11, 0x90130110 }, /* speaker */
1710 [ALC260_FIXUP_HP_PIN_0F] = {
1711 .type = HDA_FIXUP_PINS,
1712 .v.pins = (const struct hda_pintbl[]) {
1713 { 0x0f, 0x01214000 }, /* HP */
1717 [ALC260_FIXUP_COEF] = {
1718 .type = HDA_FIXUP_VERBS,
1719 .v.verbs = (const struct hda_verb[]) {
1720 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1721 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 },
1725 [ALC260_FIXUP_GPIO1] = {
1726 .type = HDA_FIXUP_FUNC,
1727 .v.func = alc_fixup_gpio1,
1729 [ALC260_FIXUP_GPIO1_TOGGLE] = {
1730 .type = HDA_FIXUP_FUNC,
1731 .v.func = alc260_fixup_gpio1_toggle,
1733 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1735 [ALC260_FIXUP_REPLACER] = {
1736 .type = HDA_FIXUP_VERBS,
1737 .v.verbs = (const struct hda_verb[]) {
1738 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1739 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 },
1743 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1745 [ALC260_FIXUP_HP_B1900] = {
1746 .type = HDA_FIXUP_FUNC,
1747 .v.func = alc260_fixup_gpio1_toggle,
1749 .chain_id = ALC260_FIXUP_COEF,
1751 [ALC260_FIXUP_KN1] = {
1752 .type = HDA_FIXUP_FUNC,
1753 .v.func = alc260_fixup_kn1,
1755 [ALC260_FIXUP_FSC_S7020] = {
1756 .type = HDA_FIXUP_FUNC,
1757 .v.func = alc260_fixup_fsc_s7020,
1759 [ALC260_FIXUP_FSC_S7020_JWSE] = {
1760 .type = HDA_FIXUP_FUNC,
1761 .v.func = alc260_fixup_fsc_s7020_jwse,
1763 .chain_id = ALC260_FIXUP_FSC_S7020,
1765 [ALC260_FIXUP_VAIO_PINS] = {
1766 .type = HDA_FIXUP_PINS,
1767 .v.pins = (const struct hda_pintbl[]) {
1768 /* Pin configs are missing completely on some VAIOs */
1769 { 0x0f, 0x01211020 },
1770 { 0x10, 0x0001003f },
1771 { 0x11, 0x411111f0 },
1772 { 0x12, 0x01a15930 },
1773 { 0x13, 0x411111f0 },
1774 { 0x14, 0x411111f0 },
1775 { 0x15, 0x411111f0 },
1776 { 0x16, 0x411111f0 },
1777 { 0x17, 0x411111f0 },
1778 { 0x18, 0x411111f0 },
1779 { 0x19, 0x411111f0 },
1785 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1786 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1787 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1788 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1789 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1790 SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1791 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1792 SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1793 SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1794 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1795 SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1796 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1797 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1801 static const struct hda_model_fixup alc260_fixup_models[] = {
1802 {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1803 {.id = ALC260_FIXUP_COEF, .name = "coef"},
1804 {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1805 {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1811 static int patch_alc260(struct hda_codec *codec)
1813 struct alc_spec *spec;
1816 err = alc_alloc_spec(codec, 0x07);
1821 /* as quite a few machines require HP amp for speaker outputs,
1822 * it's easier to enable it unconditionally; even if it's unneeded,
1823 * it's almost harmless.
1825 spec->gen.prefer_hp_amp = 1;
1826 spec->gen.beep_nid = 0x01;
1828 spec->shutup = alc_eapd_shutup;
1830 alc_pre_init(codec);
1832 snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1834 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1836 /* automatic parse from the BIOS config */
1837 err = alc260_parse_auto_config(codec);
1841 if (!spec->gen.no_analog) {
1842 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1847 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1858 * ALC882/883/885/888/889 support
1860 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1861 * configuration. Each pin widget can choose any input DACs and a mixer.
1862 * Each ADC is connected from a mixer of all inputs. This makes possible
1863 * 6-channel independent captures.
1865 * In addition, an independent DAC for the multi-playback (not used in this
1873 ALC882_FIXUP_ABIT_AW9D_MAX,
1874 ALC882_FIXUP_LENOVO_Y530,
1875 ALC882_FIXUP_PB_M5210,
1876 ALC882_FIXUP_ACER_ASPIRE_7736,
1877 ALC882_FIXUP_ASUS_W90V,
1879 ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1880 ALC889_FIXUP_VAIO_TT,
1881 ALC888_FIXUP_EEE1601,
1884 ALC883_FIXUP_ACER_EAPD,
1889 ALC882_FIXUP_ASUS_W2JC,
1890 ALC882_FIXUP_ACER_ASPIRE_4930G,
1891 ALC882_FIXUP_ACER_ASPIRE_8930G,
1892 ALC882_FIXUP_ASPIRE_8930G_VERBS,
1893 ALC885_FIXUP_MACPRO_GPIO,
1894 ALC889_FIXUP_DAC_ROUTE,
1895 ALC889_FIXUP_MBP_VREF,
1896 ALC889_FIXUP_IMAC91_VREF,
1897 ALC889_FIXUP_MBA11_VREF,
1898 ALC889_FIXUP_MBA21_VREF,
1899 ALC889_FIXUP_MP11_VREF,
1900 ALC889_FIXUP_MP41_VREF,
1901 ALC882_FIXUP_INV_DMIC,
1902 ALC882_FIXUP_NO_PRIMARY_HP,
1903 ALC887_FIXUP_ASUS_BASS,
1904 ALC887_FIXUP_BASS_CHMAP,
1905 ALC1220_FIXUP_GB_DUAL_CODECS,
1906 ALC1220_FIXUP_CLEVO_P950,
1907 ALC1220_FIXUP_CLEVO_PB51ED,
1908 ALC1220_FIXUP_CLEVO_PB51ED_PINS,
1911 static void alc889_fixup_coef(struct hda_codec *codec,
1912 const struct hda_fixup *fix, int action)
1914 if (action != HDA_FIXUP_ACT_INIT)
1916 alc_update_coef_idx(codec, 7, 0, 0x2030);
1919 /* set up GPIO at initialization */
1920 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1921 const struct hda_fixup *fix, int action)
1923 struct alc_spec *spec = codec->spec;
1925 spec->gpio_write_delay = true;
1926 alc_fixup_gpio3(codec, fix, action);
1929 /* Fix the connection of some pins for ALC889:
1930 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
1931 * work correctly (bko#42740)
1933 static void alc889_fixup_dac_route(struct hda_codec *codec,
1934 const struct hda_fixup *fix, int action)
1936 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1937 /* fake the connections during parsing the tree */
1938 hda_nid_t conn1[2] = { 0x0c, 0x0d };
1939 hda_nid_t conn2[2] = { 0x0e, 0x0f };
1940 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
1941 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
1942 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
1943 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
1944 } else if (action == HDA_FIXUP_ACT_PROBE) {
1945 /* restore the connections */
1946 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
1947 snd_hda_override_conn_list(codec, 0x14, 5, conn);
1948 snd_hda_override_conn_list(codec, 0x15, 5, conn);
1949 snd_hda_override_conn_list(codec, 0x18, 5, conn);
1950 snd_hda_override_conn_list(codec, 0x1a, 5, conn);
1954 /* Set VREF on HP pin */
1955 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
1956 const struct hda_fixup *fix, int action)
1958 struct alc_spec *spec = codec->spec;
1959 static hda_nid_t nids[3] = { 0x14, 0x15, 0x19 };
1962 if (action != HDA_FIXUP_ACT_INIT)
1964 for (i = 0; i < ARRAY_SIZE(nids); i++) {
1965 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
1966 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
1968 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1969 val |= AC_PINCTL_VREF_80;
1970 snd_hda_set_pin_ctl(codec, nids[i], val);
1971 spec->gen.keep_vref_in_automute = 1;
1976 static void alc889_fixup_mac_pins(struct hda_codec *codec,
1977 const hda_nid_t *nids, int num_nids)
1979 struct alc_spec *spec = codec->spec;
1982 for (i = 0; i < num_nids; i++) {
1984 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1985 val |= AC_PINCTL_VREF_50;
1986 snd_hda_set_pin_ctl(codec, nids[i], val);
1988 spec->gen.keep_vref_in_automute = 1;
1991 /* Set VREF on speaker pins on imac91 */
1992 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
1993 const struct hda_fixup *fix, int action)
1995 static hda_nid_t nids[2] = { 0x18, 0x1a };
1997 if (action == HDA_FIXUP_ACT_INIT)
1998 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2001 /* Set VREF on speaker pins on mba11 */
2002 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2003 const struct hda_fixup *fix, int action)
2005 static hda_nid_t nids[1] = { 0x18 };
2007 if (action == HDA_FIXUP_ACT_INIT)
2008 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2011 /* Set VREF on speaker pins on mba21 */
2012 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2013 const struct hda_fixup *fix, int action)
2015 static hda_nid_t nids[2] = { 0x18, 0x19 };
2017 if (action == HDA_FIXUP_ACT_INIT)
2018 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2021 /* Don't take HP output as primary
2022 * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
2023 * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
2025 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2026 const struct hda_fixup *fix, int action)
2028 struct alc_spec *spec = codec->spec;
2029 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2030 spec->gen.no_primary_hp = 1;
2031 spec->gen.no_multi_io = 1;
2035 static void alc_fixup_bass_chmap(struct hda_codec *codec,
2036 const struct hda_fixup *fix, int action);
2038 /* For dual-codec configuration, we need to disable some features to avoid
2039 * conflicts of kctls and PCM streams
2041 static void alc_fixup_dual_codecs(struct hda_codec *codec,
2042 const struct hda_fixup *fix, int action)
2044 struct alc_spec *spec = codec->spec;
2046 if (action != HDA_FIXUP_ACT_PRE_PROBE)
2048 /* disable vmaster */
2049 spec->gen.suppress_vmaster = 1;
2050 /* auto-mute and auto-mic switch don't work with multiple codecs */
2051 spec->gen.suppress_auto_mute = 1;
2052 spec->gen.suppress_auto_mic = 1;
2053 /* disable aamix as well */
2054 spec->gen.mixer_nid = 0;
2055 /* add location prefix to avoid conflicts */
2056 codec->force_pin_prefix = 1;
2059 static void rename_ctl(struct hda_codec *codec, const char *oldname,
2060 const char *newname)
2062 struct snd_kcontrol *kctl;
2064 kctl = snd_hda_find_mixer_ctl(codec, oldname);
2066 strcpy(kctl->id.name, newname);
2069 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2070 const struct hda_fixup *fix,
2073 alc_fixup_dual_codecs(codec, fix, action);
2075 case HDA_FIXUP_ACT_PRE_PROBE:
2076 /* override card longname to provide a unique UCM profile */
2077 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2079 case HDA_FIXUP_ACT_BUILD:
2080 /* rename Capture controls depending on the codec */
2081 rename_ctl(codec, "Capture Volume",
2083 "Rear-Panel Capture Volume" :
2084 "Front-Panel Capture Volume");
2085 rename_ctl(codec, "Capture Switch",
2087 "Rear-Panel Capture Switch" :
2088 "Front-Panel Capture Switch");
2093 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2094 const struct hda_fixup *fix,
2097 hda_nid_t conn1[1] = { 0x0c };
2099 if (action != HDA_FIXUP_ACT_PRE_PROBE)
2102 alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2103 /* We therefore want to make sure 0x14 (front headphone) and
2104 * 0x1b (speakers) use the stereo DAC 0x02
2106 snd_hda_override_conn_list(codec, 0x14, 1, conn1);
2107 snd_hda_override_conn_list(codec, 0x1b, 1, conn1);
2110 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2111 const struct hda_fixup *fix, int action);
2113 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2114 const struct hda_fixup *fix,
2117 alc1220_fixup_clevo_p950(codec, fix, action);
2118 alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2121 static const struct hda_fixup alc882_fixups[] = {
2122 [ALC882_FIXUP_ABIT_AW9D_MAX] = {
2123 .type = HDA_FIXUP_PINS,
2124 .v.pins = (const struct hda_pintbl[]) {
2125 { 0x15, 0x01080104 }, /* side */
2126 { 0x16, 0x01011012 }, /* rear */
2127 { 0x17, 0x01016011 }, /* clfe */
2131 [ALC882_FIXUP_LENOVO_Y530] = {
2132 .type = HDA_FIXUP_PINS,
2133 .v.pins = (const struct hda_pintbl[]) {
2134 { 0x15, 0x99130112 }, /* rear int speakers */
2135 { 0x16, 0x99130111 }, /* subwoofer */
2139 [ALC882_FIXUP_PB_M5210] = {
2140 .type = HDA_FIXUP_PINCTLS,
2141 .v.pins = (const struct hda_pintbl[]) {
2142 { 0x19, PIN_VREF50 },
2146 [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2147 .type = HDA_FIXUP_FUNC,
2148 .v.func = alc_fixup_sku_ignore,
2150 [ALC882_FIXUP_ASUS_W90V] = {
2151 .type = HDA_FIXUP_PINS,
2152 .v.pins = (const struct hda_pintbl[]) {
2153 { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2157 [ALC889_FIXUP_CD] = {
2158 .type = HDA_FIXUP_PINS,
2159 .v.pins = (const struct hda_pintbl[]) {
2160 { 0x1c, 0x993301f0 }, /* CD */
2164 [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2165 .type = HDA_FIXUP_PINS,
2166 .v.pins = (const struct hda_pintbl[]) {
2167 { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2171 .chain_id = ALC889_FIXUP_CD,
2173 [ALC889_FIXUP_VAIO_TT] = {
2174 .type = HDA_FIXUP_PINS,
2175 .v.pins = (const struct hda_pintbl[]) {
2176 { 0x17, 0x90170111 }, /* hidden surround speaker */
2180 [ALC888_FIXUP_EEE1601] = {
2181 .type = HDA_FIXUP_VERBS,
2182 .v.verbs = (const struct hda_verb[]) {
2183 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2184 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },
2188 [ALC882_FIXUP_EAPD] = {
2189 .type = HDA_FIXUP_VERBS,
2190 .v.verbs = (const struct hda_verb[]) {
2191 /* change to EAPD mode */
2192 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2193 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2197 [ALC883_FIXUP_EAPD] = {
2198 .type = HDA_FIXUP_VERBS,
2199 .v.verbs = (const struct hda_verb[]) {
2200 /* change to EAPD mode */
2201 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2202 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2206 [ALC883_FIXUP_ACER_EAPD] = {
2207 .type = HDA_FIXUP_VERBS,
2208 .v.verbs = (const struct hda_verb[]) {
2209 /* eanable EAPD on Acer laptops */
2210 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2211 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2215 [ALC882_FIXUP_GPIO1] = {
2216 .type = HDA_FIXUP_FUNC,
2217 .v.func = alc_fixup_gpio1,
2219 [ALC882_FIXUP_GPIO2] = {
2220 .type = HDA_FIXUP_FUNC,
2221 .v.func = alc_fixup_gpio2,
2223 [ALC882_FIXUP_GPIO3] = {
2224 .type = HDA_FIXUP_FUNC,
2225 .v.func = alc_fixup_gpio3,
2227 [ALC882_FIXUP_ASUS_W2JC] = {
2228 .type = HDA_FIXUP_FUNC,
2229 .v.func = alc_fixup_gpio1,
2231 .chain_id = ALC882_FIXUP_EAPD,
2233 [ALC889_FIXUP_COEF] = {
2234 .type = HDA_FIXUP_FUNC,
2235 .v.func = alc889_fixup_coef,
2237 [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2238 .type = HDA_FIXUP_PINS,
2239 .v.pins = (const struct hda_pintbl[]) {
2240 { 0x16, 0x99130111 }, /* CLFE speaker */
2241 { 0x17, 0x99130112 }, /* surround speaker */
2245 .chain_id = ALC882_FIXUP_GPIO1,
2247 [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2248 .type = HDA_FIXUP_PINS,
2249 .v.pins = (const struct hda_pintbl[]) {
2250 { 0x16, 0x99130111 }, /* CLFE speaker */
2251 { 0x1b, 0x99130112 }, /* surround speaker */
2255 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2257 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2258 /* additional init verbs for Acer Aspire 8930G */
2259 .type = HDA_FIXUP_VERBS,
2260 .v.verbs = (const struct hda_verb[]) {
2261 /* Enable all DACs */
2262 /* DAC DISABLE/MUTE 1? */
2263 /* setting bits 1-5 disables DAC nids 0x02-0x06
2264 * apparently. Init=0x38 */
2265 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2266 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2267 /* DAC DISABLE/MUTE 2? */
2268 /* some bit here disables the other DACs.
2270 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2271 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2273 * This laptop has a stereo digital microphone.
2274 * The mics are only 1cm apart which makes the stereo
2275 * useless. However, either the mic or the ALC889
2276 * makes the signal become a difference/sum signal
2277 * instead of standard stereo, which is annoying.
2278 * So instead we flip this bit which makes the
2279 * codec replicate the sum signal to both channels,
2280 * turning it into a normal mono mic.
2282 /* DMIC_CONTROL? Init value = 0x0001 */
2283 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2284 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2285 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2286 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2290 .chain_id = ALC882_FIXUP_GPIO1,
2292 [ALC885_FIXUP_MACPRO_GPIO] = {
2293 .type = HDA_FIXUP_FUNC,
2294 .v.func = alc885_fixup_macpro_gpio,
2296 [ALC889_FIXUP_DAC_ROUTE] = {
2297 .type = HDA_FIXUP_FUNC,
2298 .v.func = alc889_fixup_dac_route,
2300 [ALC889_FIXUP_MBP_VREF] = {
2301 .type = HDA_FIXUP_FUNC,
2302 .v.func = alc889_fixup_mbp_vref,
2304 .chain_id = ALC882_FIXUP_GPIO1,
2306 [ALC889_FIXUP_IMAC91_VREF] = {
2307 .type = HDA_FIXUP_FUNC,
2308 .v.func = alc889_fixup_imac91_vref,
2310 .chain_id = ALC882_FIXUP_GPIO1,
2312 [ALC889_FIXUP_MBA11_VREF] = {
2313 .type = HDA_FIXUP_FUNC,
2314 .v.func = alc889_fixup_mba11_vref,
2316 .chain_id = ALC889_FIXUP_MBP_VREF,
2318 [ALC889_FIXUP_MBA21_VREF] = {
2319 .type = HDA_FIXUP_FUNC,
2320 .v.func = alc889_fixup_mba21_vref,
2322 .chain_id = ALC889_FIXUP_MBP_VREF,
2324 [ALC889_FIXUP_MP11_VREF] = {
2325 .type = HDA_FIXUP_FUNC,
2326 .v.func = alc889_fixup_mba11_vref,
2328 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2330 [ALC889_FIXUP_MP41_VREF] = {
2331 .type = HDA_FIXUP_FUNC,
2332 .v.func = alc889_fixup_mbp_vref,
2334 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2336 [ALC882_FIXUP_INV_DMIC] = {
2337 .type = HDA_FIXUP_FUNC,
2338 .v.func = alc_fixup_inv_dmic,
2340 [ALC882_FIXUP_NO_PRIMARY_HP] = {
2341 .type = HDA_FIXUP_FUNC,
2342 .v.func = alc882_fixup_no_primary_hp,
2344 [ALC887_FIXUP_ASUS_BASS] = {
2345 .type = HDA_FIXUP_PINS,
2346 .v.pins = (const struct hda_pintbl[]) {
2347 {0x16, 0x99130130}, /* bass speaker */
2351 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2353 [ALC887_FIXUP_BASS_CHMAP] = {
2354 .type = HDA_FIXUP_FUNC,
2355 .v.func = alc_fixup_bass_chmap,
2357 [ALC1220_FIXUP_GB_DUAL_CODECS] = {
2358 .type = HDA_FIXUP_FUNC,
2359 .v.func = alc1220_fixup_gb_dual_codecs,
2361 [ALC1220_FIXUP_CLEVO_P950] = {
2362 .type = HDA_FIXUP_FUNC,
2363 .v.func = alc1220_fixup_clevo_p950,
2365 [ALC1220_FIXUP_CLEVO_PB51ED] = {
2366 .type = HDA_FIXUP_FUNC,
2367 .v.func = alc1220_fixup_clevo_pb51ed,
2369 [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2370 .type = HDA_FIXUP_PINS,
2371 .v.pins = (const struct hda_pintbl[]) {
2372 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
2376 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2380 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2381 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2382 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2383 SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2384 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2385 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2386 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2387 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2388 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2389 ALC882_FIXUP_ACER_ASPIRE_4930G),
2390 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2391 ALC882_FIXUP_ACER_ASPIRE_4930G),
2392 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2393 ALC882_FIXUP_ACER_ASPIRE_8930G),
2394 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2395 ALC882_FIXUP_ACER_ASPIRE_8930G),
2396 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2397 ALC882_FIXUP_ACER_ASPIRE_4930G),
2398 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2399 ALC882_FIXUP_ACER_ASPIRE_4930G),
2400 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2401 ALC882_FIXUP_ACER_ASPIRE_4930G),
2402 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2403 SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2404 ALC882_FIXUP_ACER_ASPIRE_4930G),
2405 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2406 SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2407 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2408 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2409 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2410 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2411 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2412 SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2413 SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2414 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2415 SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2416 SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2417 SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2418 SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2420 /* All Apple entries are in codec SSIDs */
2421 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2422 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2423 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2424 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2425 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2426 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2427 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2428 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2429 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2430 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2431 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2432 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2433 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2434 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2435 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2436 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2437 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2438 SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2439 SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2440 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2441 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2442 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2444 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2445 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2446 SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2447 SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2448 SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2449 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2450 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2451 SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2452 SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2453 SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2454 SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2455 SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2456 SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2457 SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2458 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2459 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2460 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2461 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2465 static const struct hda_model_fixup alc882_fixup_models[] = {
2466 {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2467 {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2468 {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2469 {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2470 {.id = ALC889_FIXUP_CD, .name = "cd"},
2471 {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2472 {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2473 {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2474 {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2475 {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2476 {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2477 {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2478 {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2479 {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2480 {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2481 {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2482 {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2483 {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2484 {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2485 {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2486 {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2487 {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2488 {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2489 {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2490 {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2491 {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2492 {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2493 {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2494 {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2495 {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2496 {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2501 * BIOS auto configuration
2503 /* almost identical with ALC880 parser... */
2504 static int alc882_parse_auto_config(struct hda_codec *codec)
2506 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2507 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2508 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2513 static int patch_alc882(struct hda_codec *codec)
2515 struct alc_spec *spec;
2518 err = alc_alloc_spec(codec, 0x0b);
2524 switch (codec->core.vendor_id) {
2531 /* ALC883 and variants */
2532 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2536 alc_pre_init(codec);
2538 snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2540 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2542 alc_auto_parse_customize_define(codec);
2544 if (has_cdefine_beep(codec))
2545 spec->gen.beep_nid = 0x01;
2547 /* automatic parse from the BIOS config */
2548 err = alc882_parse_auto_config(codec);
2552 if (!spec->gen.no_analog && spec->gen.beep_nid) {
2553 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2558 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2571 static int alc262_parse_auto_config(struct hda_codec *codec)
2573 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2574 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2575 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2582 ALC262_FIXUP_FSC_H270,
2583 ALC262_FIXUP_FSC_S7110,
2584 ALC262_FIXUP_HP_Z200,
2586 ALC262_FIXUP_LENOVO_3000,
2588 ALC262_FIXUP_BENQ_T31,
2589 ALC262_FIXUP_INV_DMIC,
2590 ALC262_FIXUP_INTEL_BAYLEYBAY,
2593 static const struct hda_fixup alc262_fixups[] = {
2594 [ALC262_FIXUP_FSC_H270] = {
2595 .type = HDA_FIXUP_PINS,
2596 .v.pins = (const struct hda_pintbl[]) {
2597 { 0x14, 0x99130110 }, /* speaker */
2598 { 0x15, 0x0221142f }, /* front HP */
2599 { 0x1b, 0x0121141f }, /* rear HP */
2603 [ALC262_FIXUP_FSC_S7110] = {
2604 .type = HDA_FIXUP_PINS,
2605 .v.pins = (const struct hda_pintbl[]) {
2606 { 0x15, 0x90170110 }, /* speaker */
2610 .chain_id = ALC262_FIXUP_BENQ,
2612 [ALC262_FIXUP_HP_Z200] = {
2613 .type = HDA_FIXUP_PINS,
2614 .v.pins = (const struct hda_pintbl[]) {
2615 { 0x16, 0x99130120 }, /* internal speaker */
2619 [ALC262_FIXUP_TYAN] = {
2620 .type = HDA_FIXUP_PINS,
2621 .v.pins = (const struct hda_pintbl[]) {
2622 { 0x14, 0x1993e1f0 }, /* int AUX */
2626 [ALC262_FIXUP_LENOVO_3000] = {
2627 .type = HDA_FIXUP_PINCTLS,
2628 .v.pins = (const struct hda_pintbl[]) {
2629 { 0x19, PIN_VREF50 },
2633 .chain_id = ALC262_FIXUP_BENQ,
2635 [ALC262_FIXUP_BENQ] = {
2636 .type = HDA_FIXUP_VERBS,
2637 .v.verbs = (const struct hda_verb[]) {
2638 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2639 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2643 [ALC262_FIXUP_BENQ_T31] = {
2644 .type = HDA_FIXUP_VERBS,
2645 .v.verbs = (const struct hda_verb[]) {
2646 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2647 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2651 [ALC262_FIXUP_INV_DMIC] = {
2652 .type = HDA_FIXUP_FUNC,
2653 .v.func = alc_fixup_inv_dmic,
2655 [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2656 .type = HDA_FIXUP_FUNC,
2657 .v.func = alc_fixup_no_depop_delay,
2661 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2662 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2663 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2664 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2665 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2666 SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2667 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2668 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2669 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2670 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2671 SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2675 static const struct hda_model_fixup alc262_fixup_models[] = {
2676 {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2677 {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2678 {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2679 {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2680 {.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2681 {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2682 {.id = ALC262_FIXUP_BENQ, .name = "benq"},
2683 {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2684 {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2690 static int patch_alc262(struct hda_codec *codec)
2692 struct alc_spec *spec;
2695 err = alc_alloc_spec(codec, 0x0b);
2700 spec->gen.shared_mic_vref_pin = 0x18;
2702 spec->shutup = alc_eapd_shutup;
2705 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
2708 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2710 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2712 alc_pre_init(codec);
2714 snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2716 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2718 alc_auto_parse_customize_define(codec);
2720 if (has_cdefine_beep(codec))
2721 spec->gen.beep_nid = 0x01;
2723 /* automatic parse from the BIOS config */
2724 err = alc262_parse_auto_config(codec);
2728 if (!spec->gen.no_analog && spec->gen.beep_nid) {
2729 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2734 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2746 /* bind Beep switches of both NID 0x0f and 0x10 */
2747 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2748 struct snd_ctl_elem_value *ucontrol)
2750 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2754 mutex_lock(&codec->control_mutex);
2755 pval = kcontrol->private_value;
2756 kcontrol->private_value = (pval & ~0xff) | 0x0f;
2757 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2759 kcontrol->private_value = (pval & ~0xff) | 0x10;
2760 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2762 kcontrol->private_value = pval;
2763 mutex_unlock(&codec->control_mutex);
2767 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2768 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2770 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2771 .name = "Beep Playback Switch",
2772 .subdevice = HDA_SUBDEV_AMP_FLAG,
2773 .info = snd_hda_mixer_amp_switch_info,
2774 .get = snd_hda_mixer_amp_switch_get,
2775 .put = alc268_beep_switch_put,
2776 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
2780 /* set PCBEEP vol = 0, mute connections */
2781 static const struct hda_verb alc268_beep_init_verbs[] = {
2782 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2783 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2784 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2789 ALC268_FIXUP_INV_DMIC,
2790 ALC268_FIXUP_HP_EAPD,
2794 static const struct hda_fixup alc268_fixups[] = {
2795 [ALC268_FIXUP_INV_DMIC] = {
2796 .type = HDA_FIXUP_FUNC,
2797 .v.func = alc_fixup_inv_dmic,
2799 [ALC268_FIXUP_HP_EAPD] = {
2800 .type = HDA_FIXUP_VERBS,
2801 .v.verbs = (const struct hda_verb[]) {
2802 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
2806 [ALC268_FIXUP_SPDIF] = {
2807 .type = HDA_FIXUP_PINS,
2808 .v.pins = (const struct hda_pintbl[]) {
2809 { 0x1e, 0x014b1180 }, /* enable SPDIF out */
2815 static const struct hda_model_fixup alc268_fixup_models[] = {
2816 {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2817 {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
2818 {.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
2822 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2823 SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
2824 SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2825 /* below is codec SSID since multiple Toshiba laptops have the
2826 * same PCI SSID 1179:ff00
2828 SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
2833 * BIOS auto configuration
2835 static int alc268_parse_auto_config(struct hda_codec *codec)
2837 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2838 return alc_parse_auto_config(codec, NULL, alc268_ssids);
2843 static int patch_alc268(struct hda_codec *codec)
2845 struct alc_spec *spec;
2848 /* ALC268 has no aa-loopback mixer */
2849 err = alc_alloc_spec(codec, 0);
2854 if (has_cdefine_beep(codec))
2855 spec->gen.beep_nid = 0x01;
2857 spec->shutup = alc_eapd_shutup;
2859 alc_pre_init(codec);
2861 snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
2862 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2864 /* automatic parse from the BIOS config */
2865 err = alc268_parse_auto_config(codec);
2869 if (err > 0 && !spec->gen.no_analog &&
2870 spec->gen.autocfg.speaker_pins[0] != 0x1d) {
2871 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
2872 if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
2873 &alc268_beep_mixer[i])) {
2878 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
2879 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
2880 /* override the amp caps for beep generator */
2881 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
2882 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
2883 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
2884 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2885 (0 << AC_AMPCAP_MUTE_SHIFT));
2888 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2901 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
2902 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2905 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
2906 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2909 /* different alc269-variants */
2911 ALC269_TYPE_ALC269VA,
2912 ALC269_TYPE_ALC269VB,
2913 ALC269_TYPE_ALC269VC,
2914 ALC269_TYPE_ALC269VD,
2934 * BIOS auto configuration
2936 static int alc269_parse_auto_config(struct hda_codec *codec)
2938 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
2939 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
2940 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2941 struct alc_spec *spec = codec->spec;
2942 const hda_nid_t *ssids;
2944 switch (spec->codec_variant) {
2945 case ALC269_TYPE_ALC269VA:
2946 case ALC269_TYPE_ALC269VC:
2947 case ALC269_TYPE_ALC280:
2948 case ALC269_TYPE_ALC284:
2949 case ALC269_TYPE_ALC293:
2950 ssids = alc269va_ssids;
2952 case ALC269_TYPE_ALC269VB:
2953 case ALC269_TYPE_ALC269VD:
2954 case ALC269_TYPE_ALC282:
2955 case ALC269_TYPE_ALC283:
2956 case ALC269_TYPE_ALC286:
2957 case ALC269_TYPE_ALC298:
2958 case ALC269_TYPE_ALC255:
2959 case ALC269_TYPE_ALC256:
2960 case ALC269_TYPE_ALC257:
2961 case ALC269_TYPE_ALC215:
2962 case ALC269_TYPE_ALC225:
2963 case ALC269_TYPE_ALC294:
2964 case ALC269_TYPE_ALC300:
2965 case ALC269_TYPE_ALC623:
2966 case ALC269_TYPE_ALC700:
2967 ssids = alc269_ssids;
2970 ssids = alc269_ssids;
2974 return alc_parse_auto_config(codec, alc269_ignore, ssids);
2977 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
2979 alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
2982 static void alc269_shutup(struct hda_codec *codec)
2984 struct alc_spec *spec = codec->spec;
2986 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
2987 alc269vb_toggle_power_output(codec, 0);
2988 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
2989 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
2992 alc_shutup_pins(codec);
2995 static struct coef_fw alc282_coefs[] = {
2996 WRITE_COEF(0x03, 0x0002), /* Power Down Control */
2997 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
2998 WRITE_COEF(0x07, 0x0200), /* DMIC control */
2999 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3000 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3001 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3002 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3003 WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3004 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3005 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3006 WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3007 UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3008 WRITE_COEF(0x34, 0xa0c0), /* ANC */
3009 UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3010 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3011 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3012 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3013 WRITE_COEF(0x63, 0x2902), /* PLL */
3014 WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3015 WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3016 WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3017 WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3018 UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3019 WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3020 UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3021 WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3022 WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3023 UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3024 WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3028 static void alc282_restore_default_value(struct hda_codec *codec)
3030 alc_process_coef_fw(codec, alc282_coefs);
3033 static void alc282_init(struct hda_codec *codec)
3035 struct alc_spec *spec = codec->spec;
3036 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3040 alc282_restore_default_value(codec);
3044 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3045 coef78 = alc_read_coef_idx(codec, 0x78);
3047 /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3048 /* Headphone capless set to high power mode */
3049 alc_write_coef_idx(codec, 0x78, 0x9004);
3054 snd_hda_codec_write(codec, hp_pin, 0,
3055 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3060 snd_hda_codec_write(codec, hp_pin, 0,
3061 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3066 /* Headphone capless set to normal mode */
3067 alc_write_coef_idx(codec, 0x78, coef78);
3070 static void alc282_shutup(struct hda_codec *codec)
3072 struct alc_spec *spec = codec->spec;
3073 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3078 alc269_shutup(codec);
3082 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3083 coef78 = alc_read_coef_idx(codec, 0x78);
3084 alc_write_coef_idx(codec, 0x78, 0x9004);
3089 snd_hda_codec_write(codec, hp_pin, 0,
3090 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3095 if (!spec->no_shutup_pins)
3096 snd_hda_codec_write(codec, hp_pin, 0,
3097 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3102 alc_auto_setup_eapd(codec, false);
3103 alc_shutup_pins(codec);
3104 alc_write_coef_idx(codec, 0x78, coef78);
3107 static struct coef_fw alc283_coefs[] = {
3108 WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3109 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3110 WRITE_COEF(0x07, 0x0200), /* DMIC control */
3111 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3112 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3113 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3114 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3115 WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3116 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3117 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3118 WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3119 UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3120 WRITE_COEF(0x22, 0xa0c0), /* ANC */
3121 UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3122 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3123 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3124 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3125 WRITE_COEF(0x2e, 0x2902), /* PLL */
3126 WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3127 WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3128 WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3129 WRITE_COEF(0x36, 0x0), /* capless control 5 */
3130 UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3131 WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3132 UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3133 WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3134 WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3135 UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3136 WRITE_COEF(0x49, 0x0), /* test mode */
3137 UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3138 UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3139 WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3140 UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3144 static void alc283_restore_default_value(struct hda_codec *codec)
3146 alc_process_coef_fw(codec, alc283_coefs);
3149 static void alc283_init(struct hda_codec *codec)
3151 struct alc_spec *spec = codec->spec;
3152 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3155 alc283_restore_default_value(codec);
3161 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3163 /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3164 /* Headphone capless set to high power mode */
3165 alc_write_coef_idx(codec, 0x43, 0x9004);
3167 snd_hda_codec_write(codec, hp_pin, 0,
3168 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3173 snd_hda_codec_write(codec, hp_pin, 0,
3174 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3178 /* Index 0x46 Combo jack auto switch control 2 */
3179 /* 3k pull low control for Headset jack. */
3180 alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3181 /* Headphone capless set to normal mode */
3182 alc_write_coef_idx(codec, 0x43, 0x9614);
3185 static void alc283_shutup(struct hda_codec *codec)
3187 struct alc_spec *spec = codec->spec;
3188 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3192 alc269_shutup(codec);
3196 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3198 alc_write_coef_idx(codec, 0x43, 0x9004);
3200 /*depop hp during suspend*/
3201 alc_write_coef_idx(codec, 0x06, 0x2100);
3203 snd_hda_codec_write(codec, hp_pin, 0,
3204 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3209 if (!spec->no_shutup_pins)
3210 snd_hda_codec_write(codec, hp_pin, 0,
3211 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3213 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3217 alc_auto_setup_eapd(codec, false);
3218 alc_shutup_pins(codec);
3219 alc_write_coef_idx(codec, 0x43, 0x9614);
3222 static void alc256_init(struct hda_codec *codec)
3224 struct alc_spec *spec = codec->spec;
3225 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3233 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3238 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3239 if (spec->ultra_low_power) {
3240 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3241 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3242 alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3243 alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3244 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3248 snd_hda_codec_write(codec, hp_pin, 0,
3249 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3251 if (hp_pin_sense || spec->ultra_low_power)
3254 snd_hda_codec_write(codec, hp_pin, 0,
3255 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3257 if (hp_pin_sense || spec->ultra_low_power)
3260 alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3261 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3262 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3263 alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3264 alc_update_coef_idx(codec, 0x36, 1 << 13, 1 << 5); /* Switch pcbeep path to Line in path*/
3267 static void alc256_shutup(struct hda_codec *codec)
3269 struct alc_spec *spec = codec->spec;
3270 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3276 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3281 snd_hda_codec_write(codec, hp_pin, 0,
3282 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3284 if (hp_pin_sense || spec->ultra_low_power)
3287 /* 3k pull low control for Headset jack. */
3288 /* NOTE: call this before clearing the pin, otherwise codec stalls */
3289 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3291 if (!spec->no_shutup_pins)
3292 snd_hda_codec_write(codec, hp_pin, 0,
3293 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3295 if (hp_pin_sense || spec->ultra_low_power)
3298 alc_auto_setup_eapd(codec, false);
3299 alc_shutup_pins(codec);
3300 if (spec->ultra_low_power) {
3302 alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3303 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3304 alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3305 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3306 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3311 static void alc225_init(struct hda_codec *codec)
3313 struct alc_spec *spec = codec->spec;
3314 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3315 bool hp1_pin_sense, hp2_pin_sense;
3321 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3322 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3324 if (hp1_pin_sense || hp2_pin_sense)
3327 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3328 if (spec->ultra_low_power) {
3329 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3330 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3331 alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3335 if (hp1_pin_sense || spec->ultra_low_power)
3336 snd_hda_codec_write(codec, hp_pin, 0,
3337 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3339 snd_hda_codec_write(codec, 0x16, 0,
3340 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3342 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3345 if (hp1_pin_sense || spec->ultra_low_power)
3346 snd_hda_codec_write(codec, hp_pin, 0,
3347 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3349 snd_hda_codec_write(codec, 0x16, 0,
3350 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3352 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3355 alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3356 alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3359 static void alc225_shutup(struct hda_codec *codec)
3361 struct alc_spec *spec = codec->spec;
3362 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3363 bool hp1_pin_sense, hp2_pin_sense;
3367 /* 3k pull low control for Headset jack. */
3368 alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3370 hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3371 hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3373 if (hp1_pin_sense || hp2_pin_sense)
3376 if (hp1_pin_sense || spec->ultra_low_power)
3377 snd_hda_codec_write(codec, hp_pin, 0,
3378 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3380 snd_hda_codec_write(codec, 0x16, 0,
3381 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3383 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3386 if (hp1_pin_sense || spec->ultra_low_power)
3387 snd_hda_codec_write(codec, hp_pin, 0,
3388 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3390 snd_hda_codec_write(codec, 0x16, 0,
3391 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3393 if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3396 alc_auto_setup_eapd(codec, false);
3397 alc_shutup_pins(codec);
3398 if (spec->ultra_low_power) {
3400 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3401 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3402 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3403 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3408 static void alc_default_init(struct hda_codec *codec)
3410 struct alc_spec *spec = codec->spec;
3411 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3419 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3424 snd_hda_codec_write(codec, hp_pin, 0,
3425 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3430 snd_hda_codec_write(codec, hp_pin, 0,
3431 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3437 static void alc_default_shutup(struct hda_codec *codec)
3439 struct alc_spec *spec = codec->spec;
3440 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3444 alc269_shutup(codec);
3448 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3453 snd_hda_codec_write(codec, hp_pin, 0,
3454 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3459 if (!spec->no_shutup_pins)
3460 snd_hda_codec_write(codec, hp_pin, 0,
3461 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3466 alc_auto_setup_eapd(codec, false);
3467 alc_shutup_pins(codec);
3470 static void alc294_hp_init(struct hda_codec *codec)
3472 struct alc_spec *spec = codec->spec;
3473 hda_nid_t hp_pin = alc_get_hp_pin(spec);
3479 snd_hda_codec_write(codec, hp_pin, 0,
3480 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3484 if (!spec->no_shutup_pins)
3485 snd_hda_codec_write(codec, hp_pin, 0,
3486 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3488 alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3489 alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3491 /* Wait for depop procedure finish */
3492 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3493 for (i = 0; i < 20 && val & 0x0080; i++) {
3495 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3497 /* Set HP depop to auto mode */
3498 alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3502 static void alc294_init(struct hda_codec *codec)
3504 struct alc_spec *spec = codec->spec;
3506 /* required only at boot or S4 resume time */
3507 if (!spec->done_hp_init ||
3508 codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3509 alc294_hp_init(codec);
3510 spec->done_hp_init = true;
3512 alc_default_init(codec);
3515 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3518 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3519 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3520 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3523 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3527 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3528 val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3530 val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3535 static void alc5505_dsp_halt(struct hda_codec *codec)
3539 alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3540 alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3541 alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3542 alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3543 alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3544 alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3545 alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3546 val = alc5505_coef_get(codec, 0x6220);
3547 alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3550 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3552 alc5505_coef_set(codec, 0x61b8, 0x04133302);
3553 alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3554 alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3555 alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3556 alc5505_coef_set(codec, 0x6220, 0x2002010f);
3557 alc5505_coef_set(codec, 0x880c, 0x00000004);
3560 static void alc5505_dsp_init(struct hda_codec *codec)
3564 alc5505_dsp_halt(codec);
3565 alc5505_dsp_back_from_halt(codec);
3566 alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3567 alc5505_coef_set(codec, 0x61b0, 0x5b16);
3568 alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
3569 alc5505_coef_set(codec, 0x61b4, 0x04132b02);
3570 alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
3571 alc5505_coef_set(codec, 0x61b8, 0x041f3302);
3572 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
3573 alc5505_coef_set(codec, 0x61b8, 0x041b3302);
3574 alc5505_coef_set(codec, 0x61b8, 0x04173302);
3575 alc5505_coef_set(codec, 0x61b8, 0x04163302);
3576 alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
3577 alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
3578 alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
3580 val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
3582 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
3584 alc5505_coef_set(codec, 0x6220, 0x6002018f);
3586 alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
3587 alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
3588 alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
3589 alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
3590 alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
3591 alc5505_coef_set(codec, 0x880c, 0x00000003);
3592 alc5505_coef_set(codec, 0x880c, 0x00000010);
3594 #ifdef HALT_REALTEK_ALC5505
3595 alc5505_dsp_halt(codec);
3599 #ifdef HALT_REALTEK_ALC5505
3600 #define alc5505_dsp_suspend(codec) /* NOP */
3601 #define alc5505_dsp_resume(codec) /* NOP */
3603 #define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec)
3604 #define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec)
3608 static int alc269_suspend(struct hda_codec *codec)
3610 struct alc_spec *spec = codec->spec;
3612 if (spec->has_alc5505_dsp)
3613 alc5505_dsp_suspend(codec);
3614 return alc_suspend(codec);
3617 static int alc269_resume(struct hda_codec *codec)
3619 struct alc_spec *spec = codec->spec;
3621 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3622 alc269vb_toggle_power_output(codec, 0);
3623 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3624 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3628 codec->patch_ops.init(codec);
3630 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3631 alc269vb_toggle_power_output(codec, 1);
3632 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3633 (alc_get_coef0(codec) & 0x00ff) == 0x017) {
3637 regcache_sync(codec->core.regmap);
3638 hda_call_check_power_status(codec, 0x01);
3640 /* on some machine, the BIOS will clear the codec gpio data when enter
3641 * suspend, and won't restore the data after resume, so we restore it
3644 if (spec->gpio_data)
3645 alc_write_gpio_data(codec);
3647 if (spec->has_alc5505_dsp)
3648 alc5505_dsp_resume(codec);
3652 #endif /* CONFIG_PM */
3654 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
3655 const struct hda_fixup *fix, int action)
3657 struct alc_spec *spec = codec->spec;
3659 if (action == HDA_FIXUP_ACT_PRE_PROBE)
3660 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
3663 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
3664 const struct hda_fixup *fix,
3667 unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
3668 unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
3670 if (cfg_headphone && cfg_headset_mic == 0x411111f0)
3671 snd_hda_codec_set_pincfg(codec, 0x19,
3672 (cfg_headphone & ~AC_DEFCFG_DEVICE) |
3673 (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
3676 static void alc269_fixup_hweq(struct hda_codec *codec,
3677 const struct hda_fixup *fix, int action)
3679 if (action == HDA_FIXUP_ACT_INIT)
3680 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
3683 static void alc269_fixup_headset_mic(struct hda_codec *codec,
3684 const struct hda_fixup *fix, int action)
3686 struct alc_spec *spec = codec->spec;
3688 if (action == HDA_FIXUP_ACT_PRE_PROBE)
3689 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3692 static void alc271_fixup_dmic(struct hda_codec *codec,
3693 const struct hda_fixup *fix, int action)
3695 static const struct hda_verb verbs[] = {
3696 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
3697 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
3702 if (strcmp(codec->core.chip_name, "ALC271X") &&
3703 strcmp(codec->core.chip_name, "ALC269VB"))
3705 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
3706 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
3707 snd_hda_sequence_write(codec, verbs);
3710 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
3711 const struct hda_fixup *fix, int action)
3713 struct alc_spec *spec = codec->spec;
3715 if (action != HDA_FIXUP_ACT_PROBE)
3718 /* Due to a hardware problem on Lenovo Ideadpad, we need to
3719 * fix the sample rate of analog I/O to 44.1kHz
3721 spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
3722 spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
3725 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
3726 const struct hda_fixup *fix, int action)
3728 /* The digital-mic unit sends PDM (differential signal) instead of
3729 * the standard PCM, thus you can't record a valid mono stream as is.
3730 * Below is a workaround specific to ALC269 to control the dmic
3731 * signal source as mono.
3733 if (action == HDA_FIXUP_ACT_INIT)
3734 alc_update_coef_idx(codec, 0x07, 0, 0x80);
3737 static void alc269_quanta_automute(struct hda_codec *codec)
3739 snd_hda_gen_update_outputs(codec);
3741 alc_write_coef_idx(codec, 0x0c, 0x680);
3742 alc_write_coef_idx(codec, 0x0c, 0x480);
3745 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
3746 const struct hda_fixup *fix, int action)
3748 struct alc_spec *spec = codec->spec;
3749 if (action != HDA_FIXUP_ACT_PROBE)
3751 spec->gen.automute_hook = alc269_quanta_automute;
3754 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
3755 struct hda_jack_callback *jack)
3757 struct alc_spec *spec = codec->spec;
3760 snd_hda_gen_hp_automute(codec, jack);
3762 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
3764 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3767 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3772 * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
3774 struct hda_alc298_mbxinit {
3775 unsigned char value_0x23;
3776 unsigned char value_0x25;
3779 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
3780 const struct hda_alc298_mbxinit *initval,
3783 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
3784 alc_write_coef_idx(codec, 0x26, 0xb000);
3787 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
3789 snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
3790 alc_write_coef_idx(codec, 0x26, 0xf000);
3791 alc_write_coef_idx(codec, 0x23, initval->value_0x23);
3793 if (initval->value_0x23 != 0x1e)
3794 alc_write_coef_idx(codec, 0x25, initval->value_0x25);
3796 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
3797 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
3800 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
3801 const struct hda_fixup *fix,
3804 /* Initialization magic */
3805 static const struct hda_alc298_mbxinit dac_init[] = {
3806 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
3807 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
3808 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
3809 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
3810 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
3811 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
3813 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
3814 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
3815 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
3818 const struct hda_alc298_mbxinit *seq;
3820 if (action != HDA_FIXUP_ACT_INIT)
3824 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
3825 snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
3826 alc_write_coef_idx(codec, 0x26, 0xf000);
3827 alc_write_coef_idx(codec, 0x22, 0x31);
3828 alc_write_coef_idx(codec, 0x23, 0x0b);
3829 alc_write_coef_idx(codec, 0x25, 0x00);
3830 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
3831 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
3833 for (seq = dac_init; seq->value_0x23; seq++)
3834 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
3837 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
3838 const struct hda_fixup *fix, int action)
3840 struct alc_spec *spec = codec->spec;
3841 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3842 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3843 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
3848 /* update mute-LED according to the speaker mute state via mic VREF pin */
3849 static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)
3851 struct hda_codec *codec = private_data;
3852 struct alc_spec *spec = codec->spec;
3853 unsigned int pinval;
3855 if (spec->mute_led_polarity)
3857 pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);
3858 pinval &= ~AC_PINCTL_VREFEN;
3859 pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;
3860 if (spec->mute_led_nid) {
3861 /* temporarily power up/down for setting VREF */
3862 snd_hda_power_up_pm(codec);
3863 snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
3864 snd_hda_power_down_pm(codec);
3868 /* Make sure the led works even in runtime suspend */
3869 static unsigned int led_power_filter(struct hda_codec *codec,
3871 unsigned int power_state)
3873 struct alc_spec *spec = codec->spec;
3875 if (power_state != AC_PWRST_D3 || nid == 0 ||
3876 (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
3879 /* Set pin ctl again, it might have just been set to 0 */
3880 snd_hda_set_pin_ctl(codec, nid,
3881 snd_hda_codec_get_pin_target(codec, nid));
3883 return snd_hda_gen_path_power_filter(codec, nid, power_state);
3886 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
3887 const struct hda_fixup *fix, int action)
3889 struct alc_spec *spec = codec->spec;
3890 const struct dmi_device *dev = NULL;
3892 if (action != HDA_FIXUP_ACT_PRE_PROBE)
3895 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
3897 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
3899 if (pin < 0x0a || pin >= 0x10)
3901 spec->mute_led_polarity = pol;
3902 spec->mute_led_nid = pin - 0x0a + 0x18;
3903 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3904 spec->gen.vmaster_mute_enum = 1;
3905 codec->power_filter = led_power_filter;
3907 "Detected mute LED for %x:%d\n", spec->mute_led_nid,
3908 spec->mute_led_polarity);
3913 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
3914 const struct hda_fixup *fix,
3915 int action, hda_nid_t pin)
3917 struct alc_spec *spec = codec->spec;
3919 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3920 spec->mute_led_polarity = 0;
3921 spec->mute_led_nid = pin;
3922 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3923 spec->gen.vmaster_mute_enum = 1;
3924 codec->power_filter = led_power_filter;
3928 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
3929 const struct hda_fixup *fix, int action)
3931 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
3934 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
3935 const struct hda_fixup *fix, int action)
3937 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
3940 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
3941 const struct hda_fixup *fix, int action)
3943 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
3946 /* update LED status via GPIO */
3947 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
3950 struct alc_spec *spec = codec->spec;
3952 if (spec->mute_led_polarity)
3954 alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
3957 /* turn on/off mute LED via GPIO per vmaster hook */
3958 static void alc_fixup_gpio_mute_hook(void *private_data, int enabled)
3960 struct hda_codec *codec = private_data;
3961 struct alc_spec *spec = codec->spec;
3963 alc_update_gpio_led(codec, spec->gpio_mute_led_mask, enabled);
3966 /* turn on/off mic-mute LED via GPIO per capture hook */
3967 static void alc_gpio_micmute_update(struct hda_codec *codec)
3969 struct alc_spec *spec = codec->spec;
3971 alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
3972 spec->gen.micmute_led.led_value);
3975 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
3976 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
3978 unsigned int mute_mask,
3979 unsigned int micmute_mask)
3981 struct alc_spec *spec = codec->spec;
3983 alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
3985 if (action != HDA_FIXUP_ACT_PRE_PROBE)
3988 spec->gpio_mute_led_mask = mute_mask;
3989 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3992 spec->gpio_mic_led_mask = micmute_mask;
3993 snd_hda_gen_add_micmute_led(codec, alc_gpio_micmute_update);
3997 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
3998 const struct hda_fixup *fix, int action)
4000 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4003 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4004 const struct hda_fixup *fix, int action)
4006 alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4009 /* turn on/off mic-mute LED per capture hook */
4010 static void alc_cap_micmute_update(struct hda_codec *codec)
4012 struct alc_spec *spec = codec->spec;
4013 unsigned int pinval;
4015 if (!spec->cap_mute_led_nid)
4017 pinval = snd_hda_codec_get_pin_target(codec, spec->cap_mute_led_nid);
4018 pinval &= ~AC_PINCTL_VREFEN;
4019 if (spec->gen.micmute_led.led_value)
4020 pinval |= AC_PINCTL_VREF_80;
4022 pinval |= AC_PINCTL_VREF_HIZ;
4023 snd_hda_set_pin_ctl_cache(codec, spec->cap_mute_led_nid, pinval);
4026 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4027 const struct hda_fixup *fix, int action)
4029 struct alc_spec *spec = codec->spec;
4031 alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4032 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4033 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4034 * enable headphone amp
4036 spec->gpio_mask |= 0x10;
4037 spec->gpio_dir |= 0x10;
4038 spec->cap_mute_led_nid = 0x18;
4039 snd_hda_gen_add_micmute_led(codec, alc_cap_micmute_update);
4040 codec->power_filter = led_power_filter;
4044 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4045 const struct hda_fixup *fix, int action)
4047 struct alc_spec *spec = codec->spec;
4049 alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4050 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4051 spec->cap_mute_led_nid = 0x18;
4052 snd_hda_gen_add_micmute_led(codec, alc_cap_micmute_update);
4053 codec->power_filter = led_power_filter;
4057 #if IS_REACHABLE(CONFIG_INPUT)
4058 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4059 struct hda_jack_callback *event)
4061 struct alc_spec *spec = codec->spec;
4063 /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4064 send both key on and key off event for every interrupt. */
4065 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4066 input_sync(spec->kb_dev);
4067 input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4068 input_sync(spec->kb_dev);
4071 static int alc_register_micmute_input_device(struct hda_codec *codec)
4073 struct alc_spec *spec = codec->spec;
4076 spec->kb_dev = input_allocate_device();
4077 if (!spec->kb_dev) {
4078 codec_err(codec, "Out of memory (input_allocate_device)\n");
4082 spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4084 spec->kb_dev->name = "Microphone Mute Button";
4085 spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4086 spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4087 spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4088 spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4089 for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4090 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4092 if (input_register_device(spec->kb_dev)) {
4093 codec_err(codec, "input_register_device failed\n");
4094 input_free_device(spec->kb_dev);
4095 spec->kb_dev = NULL;
4102 /* GPIO1 = set according to SKU external amp
4103 * GPIO2 = mic mute hotkey
4105 * GPIO4 = mic mute LED
4107 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4108 const struct hda_fixup *fix, int action)
4110 struct alc_spec *spec = codec->spec;
4112 alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4113 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4114 spec->init_amp = ALC_INIT_DEFAULT;
4115 if (alc_register_micmute_input_device(codec) != 0)
4118 spec->gpio_mask |= 0x06;
4119 spec->gpio_dir |= 0x02;
4120 spec->gpio_data |= 0x02;
4121 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4122 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
4123 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4124 gpio2_mic_hotkey_event);
4132 case HDA_FIXUP_ACT_FREE:
4133 input_unregister_device(spec->kb_dev);
4134 spec->kb_dev = NULL;
4138 /* Line2 = mic mute hotkey
4139 * GPIO2 = mic mute LED
4141 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
4142 const struct hda_fixup *fix, int action)
4144 struct alc_spec *spec = codec->spec;
4146 alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4147 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4148 spec->init_amp = ALC_INIT_DEFAULT;
4149 if (alc_register_micmute_input_device(codec) != 0)
4152 snd_hda_jack_detect_enable_callback(codec, 0x1b,
4153 gpio2_mic_hotkey_event);
4161 case HDA_FIXUP_ACT_FREE:
4162 input_unregister_device(spec->kb_dev);
4163 spec->kb_dev = NULL;
4167 #define alc280_fixup_hp_gpio2_mic_hotkey NULL
4168 #define alc233_fixup_lenovo_line2_mic_hotkey NULL
4171 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
4172 const struct hda_fixup *fix, int action)
4174 struct alc_spec *spec = codec->spec;
4176 alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
4177 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4178 spec->cap_mute_led_nid = 0x18;
4179 snd_hda_gen_add_micmute_led(codec, alc_cap_micmute_update);
4183 static struct coef_fw alc225_pre_hsmode[] = {
4184 UPDATE_COEF(0x4a, 1<<8, 0),
4185 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4186 UPDATE_COEF(0x63, 3<<14, 3<<14),
4187 UPDATE_COEF(0x4a, 3<<4, 2<<4),
4188 UPDATE_COEF(0x4a, 3<<10, 3<<10),
4189 UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4190 UPDATE_COEF(0x4a, 3<<10, 0),
4194 static void alc_headset_mode_unplugged(struct hda_codec *codec)
4196 static struct coef_fw coef0255[] = {
4197 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
4198 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4199 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4200 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4201 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
4204 static struct coef_fw coef0256[] = {
4205 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
4206 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4207 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4208 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
4209 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4212 static struct coef_fw coef0233[] = {
4213 WRITE_COEF(0x1b, 0x0c0b),
4214 WRITE_COEF(0x45, 0xc429),
4215 UPDATE_COEF(0x35, 0x4000, 0),
4216 WRITE_COEF(0x06, 0x2104),
4217 WRITE_COEF(0x1a, 0x0001),
4218 WRITE_COEF(0x26, 0x0004),
4219 WRITE_COEF(0x32, 0x42a3),
4222 static struct coef_fw coef0288[] = {
4223 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4224 UPDATE_COEF(0x50, 0x2000, 0x2000),
4225 UPDATE_COEF(0x56, 0x0006, 0x0006),
4226 UPDATE_COEF(0x66, 0x0008, 0),
4227 UPDATE_COEF(0x67, 0x2000, 0),
4230 static struct coef_fw coef0298[] = {
4231 UPDATE_COEF(0x19, 0x1300, 0x0300),
4234 static struct coef_fw coef0292[] = {
4235 WRITE_COEF(0x76, 0x000e),
4236 WRITE_COEF(0x6c, 0x2400),
4237 WRITE_COEF(0x18, 0x7308),
4238 WRITE_COEF(0x6b, 0xc429),
4241 static struct coef_fw coef0293[] = {
4242 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
4243 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
4244 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
4245 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
4246 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
4247 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4250 static struct coef_fw coef0668[] = {
4251 WRITE_COEF(0x15, 0x0d40),
4252 WRITE_COEF(0xb7, 0x802b),
4255 static struct coef_fw coef0225[] = {
4256 UPDATE_COEF(0x63, 3<<14, 0),
4259 static struct coef_fw coef0274[] = {
4260 UPDATE_COEF(0x4a, 0x0100, 0),
4261 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
4262 UPDATE_COEF(0x6b, 0xf000, 0x5000),
4263 UPDATE_COEF(0x4a, 0x0010, 0),
4264 UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
4265 WRITE_COEF(0x45, 0x5289),
4266 UPDATE_COEF(0x4a, 0x0c00, 0),
4270 switch (codec->core.vendor_id) {
4272 alc_process_coef_fw(codec, coef0255);
4276 alc_process_coef_fw(codec, coef0256);
4281 alc_process_coef_fw(codec, coef0274);
4285 alc_process_coef_fw(codec, coef0233);
4289 alc_process_coef_fw(codec, coef0288);
4292 alc_process_coef_fw(codec, coef0298);
4293 alc_process_coef_fw(codec, coef0288);
4296 alc_process_coef_fw(codec, coef0292);
4299 alc_process_coef_fw(codec, coef0293);
4302 alc_process_coef_fw(codec, coef0668);
4310 alc_process_coef_fw(codec, alc225_pre_hsmode);
4311 alc_process_coef_fw(codec, coef0225);
4314 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4317 codec_dbg(codec, "Headset jack set to unplugged mode.\n");
4321 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
4324 static struct coef_fw coef0255[] = {
4325 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
4326 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
4329 static struct coef_fw coef0256[] = {
4330 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
4331 WRITE_COEFEX(0x57, 0x03, 0x09a3),
4332 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
4335 static struct coef_fw coef0233[] = {
4336 UPDATE_COEF(0x35, 0, 1<<14),
4337 WRITE_COEF(0x06, 0x2100),
4338 WRITE_COEF(0x1a, 0x0021),
4339 WRITE_COEF(0x26, 0x008c),
4342 static struct coef_fw coef0288[] = {
4343 UPDATE_COEF(0x4f, 0x00c0, 0),
4344 UPDATE_COEF(0x50, 0x2000, 0),
4345 UPDATE_COEF(0x56, 0x0006, 0),
4346 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4347 UPDATE_COEF(0x66, 0x0008, 0x0008),
4348 UPDATE_COEF(0x67, 0x2000, 0x2000),
4351 static struct coef_fw coef0292[] = {
4352 WRITE_COEF(0x19, 0xa208),
4353 WRITE_COEF(0x2e, 0xacf0),
4356 static struct coef_fw coef0293[] = {
4357 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
4358 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
4359 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
4362 static struct coef_fw coef0688[] = {
4363 WRITE_COEF(0xb7, 0x802b),
4364 WRITE_COEF(0xb5, 0x1040),
4365 UPDATE_COEF(0xc3, 0, 1<<12),
4368 static struct coef_fw coef0225[] = {
4369 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
4370 UPDATE_COEF(0x4a, 3<<4, 2<<4),
4371 UPDATE_COEF(0x63, 3<<14, 0),
4374 static struct coef_fw coef0274[] = {
4375 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
4376 UPDATE_COEF(0x4a, 0x0010, 0),
4377 UPDATE_COEF(0x6b, 0xf000, 0),
4381 switch (codec->core.vendor_id) {
4383 alc_write_coef_idx(codec, 0x45, 0xc489);
4384 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4385 alc_process_coef_fw(codec, coef0255);
4386 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4390 alc_write_coef_idx(codec, 0x45, 0xc489);
4391 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4392 alc_process_coef_fw(codec, coef0256);
4393 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4398 alc_write_coef_idx(codec, 0x45, 0x4689);
4399 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4400 alc_process_coef_fw(codec, coef0274);
4401 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4405 alc_write_coef_idx(codec, 0x45, 0xc429);
4406 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4407 alc_process_coef_fw(codec, coef0233);
4408 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4413 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4414 alc_process_coef_fw(codec, coef0288);
4415 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, coef0292);
4422 /* Set to TRS mode */
4423 alc_write_coef_idx(codec, 0x45, 0xc429);
4424 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4425 alc_process_coef_fw(codec, coef0293);
4426 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4429 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
4433 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4434 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4437 alc_write_coef_idx(codec, 0x11, 0x0001);
4438 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4439 alc_process_coef_fw(codec, coef0688);
4440 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4448 alc_process_coef_fw(codec, alc225_pre_hsmode);
4449 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
4450 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
4451 alc_process_coef_fw(codec, coef0225);
4452 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
4455 codec_dbg(codec, "Headset jack set to mic-in mode.\n");
4458 static void alc_headset_mode_default(struct hda_codec *codec)
4460 static struct coef_fw coef0225[] = {
4461 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
4462 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
4463 UPDATE_COEF(0x49, 3<<8, 0<<8),
4464 UPDATE_COEF(0x4a, 3<<4, 3<<4),
4465 UPDATE_COEF(0x63, 3<<14, 0),
4466 UPDATE_COEF(0x67, 0xf000, 0x3000),
4469 static struct coef_fw coef0255[] = {
4470 WRITE_COEF(0x45, 0xc089),
4471 WRITE_COEF(0x45, 0xc489),
4472 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4473 WRITE_COEF(0x49, 0x0049),
4476 static struct coef_fw coef0256[] = {
4477 WRITE_COEF(0x45, 0xc489),
4478 WRITE_COEFEX(0x57, 0x03, 0x0da3),
4479 WRITE_COEF(0x49, 0x0049),
4480 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4481 WRITE_COEF(0x06, 0x6100),
4484 static struct coef_fw coef0233[] = {
4485 WRITE_COEF(0x06, 0x2100),
4486 WRITE_COEF(0x32, 0x4ea3),
4489 static struct coef_fw coef0288[] = {
4490 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
4491 UPDATE_COEF(0x50, 0x2000, 0x2000),
4492 UPDATE_COEF(0x56, 0x0006, 0x0006),
4493 UPDATE_COEF(0x66, 0x0008, 0),
4494 UPDATE_COEF(0x67, 0x2000, 0),
4497 static struct coef_fw coef0292[] = {
4498 WRITE_COEF(0x76, 0x000e),
4499 WRITE_COEF(0x6c, 0x2400),
4500 WRITE_COEF(0x6b, 0xc429),
4501 WRITE_COEF(0x18, 0x7308),
4504 static struct coef_fw coef0293[] = {
4505 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4506 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
4507 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
4510 static struct coef_fw coef0688[] = {
4511 WRITE_COEF(0x11, 0x0041),
4512 WRITE_COEF(0x15, 0x0d40),
4513 WRITE_COEF(0xb7, 0x802b),
4516 static struct coef_fw coef0274[] = {
4517 WRITE_COEF(0x45, 0x4289),
4518 UPDATE_COEF(0x4a, 0x0010, 0x0010),
4519 UPDATE_COEF(0x6b, 0x0f00, 0),
4520 UPDATE_COEF(0x49, 0x0300, 0x0300),
4524 switch (codec->core.vendor_id) {
4531 alc_process_coef_fw(codec, alc225_pre_hsmode);
4532 alc_process_coef_fw(codec, coef0225);
4535 alc_process_coef_fw(codec, coef0255);
4539 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
4540 alc_write_coef_idx(codec, 0x45, 0xc089);
4542 alc_process_coef_fw(codec, coef0256);
4547 alc_process_coef_fw(codec, coef0274);
4551 alc_process_coef_fw(codec, coef0233);
4556 alc_process_coef_fw(codec, coef0288);
4559 alc_process_coef_fw(codec, coef0292);
4562 alc_process_coef_fw(codec, coef0293);
4565 alc_process_coef_fw(codec, coef0688);
4568 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4571 codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
4575 static void alc_headset_mode_ctia(struct hda_codec *codec)
4579 static struct coef_fw coef0255[] = {
4580 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
4581 WRITE_COEF(0x1b, 0x0c2b),
4582 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4585 static struct coef_fw coef0256[] = {
4586 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
4587 WRITE_COEF(0x1b, 0x0e6b),
4590 static struct coef_fw coef0233[] = {
4591 WRITE_COEF(0x45, 0xd429),
4592 WRITE_COEF(0x1b, 0x0c2b),
4593 WRITE_COEF(0x32, 0x4ea3),
4596 static struct coef_fw coef0288[] = {
4597 UPDATE_COEF(0x50, 0x2000, 0x2000),
4598 UPDATE_COEF(0x56, 0x0006, 0x0006),
4599 UPDATE_COEF(0x66, 0x0008, 0),
4600 UPDATE_COEF(0x67, 0x2000, 0),
4603 static struct coef_fw coef0292[] = {
4604 WRITE_COEF(0x6b, 0xd429),
4605 WRITE_COEF(0x76, 0x0008),
4606 WRITE_COEF(0x18, 0x7388),
4609 static struct coef_fw coef0293[] = {
4610 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
4611 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
4614 static struct coef_fw coef0688[] = {
4615 WRITE_COEF(0x11, 0x0001),
4616 WRITE_COEF(0x15, 0x0d60),
4617 WRITE_COEF(0xc3, 0x0000),
4620 static struct coef_fw coef0225_1[] = {
4621 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
4622 UPDATE_COEF(0x63, 3<<14, 2<<14),
4625 static struct coef_fw coef0225_2[] = {
4626 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
4627 UPDATE_COEF(0x63, 3<<14, 1<<14),
4631 switch (codec->core.vendor_id) {
4633 alc_process_coef_fw(codec, coef0255);
4637 alc_process_coef_fw(codec, coef0256);
4642 alc_write_coef_idx(codec, 0x45, 0xd689);
4646 alc_process_coef_fw(codec, coef0233);
4649 val = alc_read_coef_idx(codec, 0x50);
4650 if (val & (1 << 12)) {
4651 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
4652 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4655 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
4656 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4662 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
4664 alc_process_coef_fw(codec, coef0288);
4667 alc_process_coef_fw(codec, coef0292);
4670 alc_process_coef_fw(codec, coef0293);
4673 alc_process_coef_fw(codec, coef0688);
4681 val = alc_read_coef_idx(codec, 0x45);
4683 alc_process_coef_fw(codec, coef0225_2);
4685 alc_process_coef_fw(codec, coef0225_1);
4688 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4691 codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
4695 static void alc_headset_mode_omtp(struct hda_codec *codec)
4697 static struct coef_fw coef0255[] = {
4698 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
4699 WRITE_COEF(0x1b, 0x0c2b),
4700 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
4703 static struct coef_fw coef0256[] = {
4704 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
4705 WRITE_COEF(0x1b, 0x0e6b),
4708 static struct coef_fw coef0233[] = {
4709 WRITE_COEF(0x45, 0xe429),
4710 WRITE_COEF(0x1b, 0x0c2b),
4711 WRITE_COEF(0x32, 0x4ea3),
4714 static struct coef_fw coef0288[] = {
4715 UPDATE_COEF(0x50, 0x2000, 0x2000),
4716 UPDATE_COEF(0x56, 0x0006, 0x0006),
4717 UPDATE_COEF(0x66, 0x0008, 0),
4718 UPDATE_COEF(0x67, 0x2000, 0),
4721 static struct coef_fw coef0292[] = {
4722 WRITE_COEF(0x6b, 0xe429),
4723 WRITE_COEF(0x76, 0x0008),
4724 WRITE_COEF(0x18, 0x7388),
4727 static struct coef_fw coef0293[] = {
4728 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
4729 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
4732 static struct coef_fw coef0688[] = {
4733 WRITE_COEF(0x11, 0x0001),
4734 WRITE_COEF(0x15, 0x0d50),
4735 WRITE_COEF(0xc3, 0x0000),
4738 static struct coef_fw coef0225[] = {
4739 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
4740 UPDATE_COEF(0x63, 3<<14, 2<<14),
4744 switch (codec->core.vendor_id) {
4746 alc_process_coef_fw(codec, coef0255);
4750 alc_process_coef_fw(codec, coef0256);
4755 alc_write_coef_idx(codec, 0x45, 0xe689);
4759 alc_process_coef_fw(codec, coef0233);
4762 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
4763 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
4768 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
4770 alc_process_coef_fw(codec, coef0288);
4773 alc_process_coef_fw(codec, coef0292);
4776 alc_process_coef_fw(codec, coef0293);
4779 alc_process_coef_fw(codec, coef0688);
4787 alc_process_coef_fw(codec, coef0225);
4790 codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
4793 static void alc_determine_headset_type(struct hda_codec *codec)
4796 bool is_ctia = false;
4797 struct alc_spec *spec = codec->spec;
4798 static struct coef_fw coef0255[] = {
4799 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
4800 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
4804 static struct coef_fw coef0288[] = {
4805 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
4808 static struct coef_fw coef0298[] = {
4809 UPDATE_COEF(0x50, 0x2000, 0x2000),
4810 UPDATE_COEF(0x56, 0x0006, 0x0006),
4811 UPDATE_COEF(0x66, 0x0008, 0),
4812 UPDATE_COEF(0x67, 0x2000, 0),
4813 UPDATE_COEF(0x19, 0x1300, 0x1300),
4816 static struct coef_fw coef0293[] = {
4817 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
4818 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
4821 static struct coef_fw coef0688[] = {
4822 WRITE_COEF(0x11, 0x0001),
4823 WRITE_COEF(0xb7, 0x802b),
4824 WRITE_COEF(0x15, 0x0d60),
4825 WRITE_COEF(0xc3, 0x0c00),
4828 static struct coef_fw coef0274[] = {
4829 UPDATE_COEF(0x4a, 0x0010, 0),
4830 UPDATE_COEF(0x4a, 0x8000, 0),
4831 WRITE_COEF(0x45, 0xd289),
4832 UPDATE_COEF(0x49, 0x0300, 0x0300),
4836 switch (codec->core.vendor_id) {
4838 alc_process_coef_fw(codec, coef0255);
4840 val = alc_read_coef_idx(codec, 0x46);
4841 is_ctia = (val & 0x0070) == 0x0070;
4845 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
4846 alc_write_coef_idx(codec, 0x06, 0x6104);
4847 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
4849 snd_hda_codec_write(codec, 0x21, 0,
4850 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
4852 snd_hda_codec_write(codec, 0x21, 0,
4853 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
4855 alc_process_coef_fw(codec, coef0255);
4857 val = alc_read_coef_idx(codec, 0x46);
4858 is_ctia = (val & 0x0070) == 0x0070;
4860 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
4861 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
4863 snd_hda_codec_write(codec, 0x21, 0,
4864 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
4866 snd_hda_codec_write(codec, 0x21, 0,
4867 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
4872 alc_process_coef_fw(codec, coef0274);
4874 val = alc_read_coef_idx(codec, 0x46);
4875 is_ctia = (val & 0x00f0) == 0x00f0;
4879 alc_write_coef_idx(codec, 0x45, 0xd029);
4881 val = alc_read_coef_idx(codec, 0x46);
4882 is_ctia = (val & 0x0070) == 0x0070;
4885 snd_hda_codec_write(codec, 0x21, 0,
4886 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
4888 snd_hda_codec_write(codec, 0x21, 0,
4889 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
4892 val = alc_read_coef_idx(codec, 0x50);
4893 if (val & (1 << 12)) {
4894 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
4895 alc_process_coef_fw(codec, coef0288);
4897 val = alc_read_coef_idx(codec, 0x50);
4898 is_ctia = (val & 0x0070) == 0x0070;
4900 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
4901 alc_process_coef_fw(codec, coef0288);
4903 val = alc_read_coef_idx(codec, 0x50);
4904 is_ctia = (val & 0x0070) == 0x0070;
4906 alc_process_coef_fw(codec, coef0298);
4907 snd_hda_codec_write(codec, 0x21, 0,
4908 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
4910 snd_hda_codec_write(codec, 0x21, 0,
4911 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
4915 alc_process_coef_fw(codec, coef0288);
4917 val = alc_read_coef_idx(codec, 0x50);
4918 is_ctia = (val & 0x0070) == 0x0070;
4921 alc_write_coef_idx(codec, 0x6b, 0xd429);
4923 val = alc_read_coef_idx(codec, 0x6c);
4924 is_ctia = (val & 0x001c) == 0x001c;
4927 alc_process_coef_fw(codec, coef0293);
4929 val = alc_read_coef_idx(codec, 0x46);
4930 is_ctia = (val & 0x0070) == 0x0070;
4933 alc_process_coef_fw(codec, coef0688);
4935 val = alc_read_coef_idx(codec, 0xbe);
4936 is_ctia = (val & 0x1c02) == 0x1c02;
4944 snd_hda_codec_write(codec, 0x21, 0,
4945 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
4947 snd_hda_codec_write(codec, 0x21, 0,
4948 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
4950 alc_process_coef_fw(codec, alc225_pre_hsmode);
4951 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
4952 val = alc_read_coef_idx(codec, 0x45);
4953 if (val & (1 << 9)) {
4954 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
4955 alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
4957 val = alc_read_coef_idx(codec, 0x46);
4958 is_ctia = (val & 0x00f0) == 0x00f0;
4960 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
4961 alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
4963 val = alc_read_coef_idx(codec, 0x46);
4964 is_ctia = (val & 0x00f0) == 0x00f0;
4966 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
4967 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
4968 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
4970 snd_hda_codec_write(codec, 0x21, 0,
4971 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
4973 snd_hda_codec_write(codec, 0x21, 0,
4974 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
4981 codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
4982 is_ctia ? "yes" : "no");
4983 spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
4986 static void alc_update_headset_mode(struct hda_codec *codec)
4988 struct alc_spec *spec = codec->spec;
4990 hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
4991 hda_nid_t hp_pin = alc_get_hp_pin(spec);
4993 int new_headset_mode;
4995 if (!snd_hda_jack_detect(codec, hp_pin))
4996 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
4997 else if (mux_pin == spec->headset_mic_pin)
4998 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
4999 else if (mux_pin == spec->headphone_mic_pin)
5000 new_headset_mode = ALC_HEADSET_MODE_MIC;
5002 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5004 if (new_headset_mode == spec->current_headset_mode) {
5005 snd_hda_gen_update_outputs(codec);
5009 switch (new_headset_mode) {
5010 case ALC_HEADSET_MODE_UNPLUGGED:
5011 alc_headset_mode_unplugged(codec);
5012 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5013 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5014 spec->gen.hp_jack_present = false;
5016 case ALC_HEADSET_MODE_HEADSET:
5017 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5018 alc_determine_headset_type(codec);
5019 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5020 alc_headset_mode_ctia(codec);
5021 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5022 alc_headset_mode_omtp(codec);
5023 spec->gen.hp_jack_present = true;
5025 case ALC_HEADSET_MODE_MIC:
5026 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5027 spec->gen.hp_jack_present = false;
5029 case ALC_HEADSET_MODE_HEADPHONE:
5030 alc_headset_mode_default(codec);
5031 spec->gen.hp_jack_present = true;
5034 if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5035 snd_hda_set_pin_ctl_cache(codec, hp_pin,
5036 AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5037 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5038 snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5041 spec->current_headset_mode = new_headset_mode;
5043 snd_hda_gen_update_outputs(codec);
5046 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5047 struct snd_kcontrol *kcontrol,
5048 struct snd_ctl_elem_value *ucontrol)
5050 alc_update_headset_mode(codec);
5053 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5054 struct hda_jack_callback *jack)
5056 snd_hda_gen_hp_automute(codec, jack);
5059 static void alc_probe_headset_mode(struct hda_codec *codec)
5062 struct alc_spec *spec = codec->spec;
5063 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5066 for (i = 0; i < cfg->num_inputs; i++) {
5067 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
5068 spec->headset_mic_pin = cfg->inputs[i].pin;
5069 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
5070 spec->headphone_mic_pin = cfg->inputs[i].pin;
5073 WARN_ON(spec->gen.cap_sync_hook);
5074 spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
5075 spec->gen.automute_hook = alc_update_headset_mode;
5076 spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
5079 static void alc_fixup_headset_mode(struct hda_codec *codec,
5080 const struct hda_fixup *fix, int action)
5082 struct alc_spec *spec = codec->spec;
5085 case HDA_FIXUP_ACT_PRE_PROBE:
5086 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
5088 case HDA_FIXUP_ACT_PROBE:
5089 alc_probe_headset_mode(codec);
5091 case HDA_FIXUP_ACT_INIT:
5092 if (is_s3_resume(codec) || is_s4_resume(codec)) {
5093 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5094 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5096 alc_update_headset_mode(codec);
5101 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
5102 const struct hda_fixup *fix, int action)
5104 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5105 struct alc_spec *spec = codec->spec;
5106 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5109 alc_fixup_headset_mode(codec, fix, action);
5112 static void alc255_set_default_jack_type(struct hda_codec *codec)
5114 /* Set to iphone type */
5115 static struct coef_fw alc255fw[] = {
5116 WRITE_COEF(0x1b, 0x880b),
5117 WRITE_COEF(0x45, 0xd089),
5118 WRITE_COEF(0x1b, 0x080b),
5119 WRITE_COEF(0x46, 0x0004),
5120 WRITE_COEF(0x1b, 0x0c0b),
5123 static struct coef_fw alc256fw[] = {
5124 WRITE_COEF(0x1b, 0x884b),
5125 WRITE_COEF(0x45, 0xd089),
5126 WRITE_COEF(0x1b, 0x084b),
5127 WRITE_COEF(0x46, 0x0004),
5128 WRITE_COEF(0x1b, 0x0c4b),
5131 switch (codec->core.vendor_id) {
5133 alc_process_coef_fw(codec, alc255fw);
5137 alc_process_coef_fw(codec, alc256fw);
5143 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
5144 const struct hda_fixup *fix, int action)
5146 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5147 alc255_set_default_jack_type(codec);
5149 alc_fixup_headset_mode(codec, fix, action);
5152 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
5153 const struct hda_fixup *fix, int action)
5155 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5156 struct alc_spec *spec = codec->spec;
5157 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5158 alc255_set_default_jack_type(codec);
5161 alc_fixup_headset_mode(codec, fix, action);
5164 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
5165 struct hda_jack_callback *jack)
5167 struct alc_spec *spec = codec->spec;
5169 alc_update_headset_jack_cb(codec, jack);
5170 /* Headset Mic enable or disable, only for Dell Dino */
5171 alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
5174 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
5175 const struct hda_fixup *fix, int action)
5177 alc_fixup_headset_mode(codec, fix, action);
5178 if (action == HDA_FIXUP_ACT_PROBE) {
5179 struct alc_spec *spec = codec->spec;
5180 /* toggled via hp_automute_hook */
5181 spec->gpio_mask |= 0x40;
5182 spec->gpio_dir |= 0x40;
5183 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
5187 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
5188 const struct hda_fixup *fix, int action)
5190 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5191 struct alc_spec *spec = codec->spec;
5192 spec->gen.auto_mute_via_amp = 1;
5196 static void alc_fixup_no_shutup(struct hda_codec *codec,
5197 const struct hda_fixup *fix, int action)
5199 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5200 struct alc_spec *spec = codec->spec;
5201 spec->no_shutup_pins = 1;
5205 static void alc_fixup_disable_aamix(struct hda_codec *codec,
5206 const struct hda_fixup *fix, int action)
5208 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5209 struct alc_spec *spec = codec->spec;
5210 /* Disable AA-loopback as it causes white noise */
5211 spec->gen.mixer_nid = 0;
5215 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
5216 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
5217 const struct hda_fixup *fix, int action)
5219 static const struct hda_pintbl pincfgs[] = {
5220 { 0x16, 0x21211010 }, /* dock headphone */
5221 { 0x19, 0x21a11010 }, /* dock mic */
5224 struct alc_spec *spec = codec->spec;
5226 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5227 spec->reboot_notify = snd_hda_gen_reboot_notify; /* reduce noise */
5228 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5229 codec->power_save_node = 0; /* avoid click noises */
5230 snd_hda_apply_pincfgs(codec, pincfgs);
5234 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
5235 const struct hda_fixup *fix, int action)
5237 static const struct hda_pintbl pincfgs[] = {
5238 { 0x17, 0x21211010 }, /* dock headphone */
5239 { 0x19, 0x21a11010 }, /* dock mic */
5242 /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
5243 * the speaker output becomes too low by some reason on Thinkpads with
5246 static hda_nid_t preferred_pairs[] = {
5247 0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
5250 struct alc_spec *spec = codec->spec;
5252 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5253 spec->gen.preferred_dacs = preferred_pairs;
5254 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5255 snd_hda_apply_pincfgs(codec, pincfgs);
5256 } else if (action == HDA_FIXUP_ACT_INIT) {
5257 /* Enable DOCK device */
5258 snd_hda_codec_write(codec, 0x17, 0,
5259 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5260 /* Enable DOCK device */
5261 snd_hda_codec_write(codec, 0x19, 0,
5262 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5266 static void alc_shutup_dell_xps13(struct hda_codec *codec)
5268 struct alc_spec *spec = codec->spec;
5269 int hp_pin = alc_get_hp_pin(spec);
5271 /* Prevent pop noises when headphones are plugged in */
5272 snd_hda_codec_write(codec, hp_pin, 0,
5273 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5277 static void alc_fixup_dell_xps13(struct hda_codec *codec,
5278 const struct hda_fixup *fix, int action)
5280 struct alc_spec *spec = codec->spec;
5281 struct hda_input_mux *imux = &spec->gen.input_mux;
5285 case HDA_FIXUP_ACT_PRE_PROBE:
5286 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
5287 * it causes a click noise at start up
5289 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
5290 spec->shutup = alc_shutup_dell_xps13;
5292 case HDA_FIXUP_ACT_PROBE:
5293 /* Make the internal mic the default input source. */
5294 for (i = 0; i < imux->num_items; i++) {
5295 if (spec->gen.imux_pins[i] == 0x12) {
5296 spec->gen.cur_mux[0] = i;
5304 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
5305 const struct hda_fixup *fix, int action)
5307 struct alc_spec *spec = codec->spec;
5309 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5310 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5311 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
5313 /* Disable boost for mic-in permanently. (This code is only called
5314 from quirks that guarantee that the headphone is at NID 0x1b.) */
5315 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
5316 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
5318 alc_fixup_headset_mode(codec, fix, action);
5321 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
5322 const struct hda_fixup *fix, int action)
5324 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5325 alc_write_coef_idx(codec, 0xc4, 0x8000);
5326 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
5327 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
5329 alc_fixup_headset_mode(codec, fix, action);
5332 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
5333 static int find_ext_mic_pin(struct hda_codec *codec)
5335 struct alc_spec *spec = codec->spec;
5336 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5338 unsigned int defcfg;
5341 for (i = 0; i < cfg->num_inputs; i++) {
5342 if (cfg->inputs[i].type != AUTO_PIN_MIC)
5344 nid = cfg->inputs[i].pin;
5345 defcfg = snd_hda_codec_get_pincfg(codec, nid);
5346 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
5354 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
5355 const struct hda_fixup *fix,
5358 struct alc_spec *spec = codec->spec;
5360 if (action == HDA_FIXUP_ACT_PROBE) {
5361 int mic_pin = find_ext_mic_pin(codec);
5362 int hp_pin = alc_get_hp_pin(spec);
5364 if (snd_BUG_ON(!mic_pin || !hp_pin))
5366 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
5370 static void alc256_fixup_dell_xps_13_headphone_noise2(struct hda_codec *codec,
5371 const struct hda_fixup *fix,
5374 if (action != HDA_FIXUP_ACT_PRE_PROBE)
5377 snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 0, HDA_AMP_VOLMASK, 1);
5378 snd_hda_override_wcaps(codec, 0x1a, get_wcaps(codec, 0x1a) & ~AC_WCAP_IN_AMP);
5381 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
5382 const struct hda_fixup *fix,
5385 struct alc_spec *spec = codec->spec;
5386 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5389 /* The mic boosts on level 2 and 3 are too noisy
5390 on the internal mic input.
5391 Therefore limit the boost to 0 or 1. */
5393 if (action != HDA_FIXUP_ACT_PROBE)
5396 for (i = 0; i < cfg->num_inputs; i++) {
5397 hda_nid_t nid = cfg->inputs[i].pin;
5398 unsigned int defcfg;
5399 if (cfg->inputs[i].type != AUTO_PIN_MIC)
5401 defcfg = snd_hda_codec_get_pincfg(codec, nid);
5402 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
5405 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
5406 (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
5407 (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5408 (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
5409 (0 << AC_AMPCAP_MUTE_SHIFT));
5413 static void alc283_hp_automute_hook(struct hda_codec *codec,
5414 struct hda_jack_callback *jack)
5416 struct alc_spec *spec = codec->spec;
5420 snd_hda_gen_hp_automute(codec, jack);
5422 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
5425 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5429 static void alc283_fixup_chromebook(struct hda_codec *codec,
5430 const struct hda_fixup *fix, int action)
5432 struct alc_spec *spec = codec->spec;
5435 case HDA_FIXUP_ACT_PRE_PROBE:
5436 snd_hda_override_wcaps(codec, 0x03, 0);
5437 /* Disable AA-loopback as it causes white noise */
5438 spec->gen.mixer_nid = 0;
5440 case HDA_FIXUP_ACT_INIT:
5441 /* MIC2-VREF control */
5442 /* Set to manual mode */
5443 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
5444 /* Enable Line1 input control by verb */
5445 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
5450 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
5451 const struct hda_fixup *fix, int action)
5453 struct alc_spec *spec = codec->spec;
5456 case HDA_FIXUP_ACT_PRE_PROBE:
5457 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
5459 case HDA_FIXUP_ACT_INIT:
5460 /* MIC2-VREF control */
5461 /* Set to manual mode */
5462 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
5467 /* mute tablet speaker pin (0x14) via dock plugging in addition */
5468 static void asus_tx300_automute(struct hda_codec *codec)
5470 struct alc_spec *spec = codec->spec;
5471 snd_hda_gen_update_outputs(codec);
5472 if (snd_hda_jack_detect(codec, 0x1b))
5473 spec->gen.mute_bits |= (1ULL << 0x14);
5476 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
5477 const struct hda_fixup *fix, int action)
5479 struct alc_spec *spec = codec->spec;
5480 static const struct hda_pintbl dock_pins[] = {
5481 { 0x1b, 0x21114000 }, /* dock speaker pin */
5486 case HDA_FIXUP_ACT_PRE_PROBE:
5487 spec->init_amp = ALC_INIT_DEFAULT;
5488 /* TX300 needs to set up GPIO2 for the speaker amp */
5489 alc_setup_gpio(codec, 0x04);
5490 snd_hda_apply_pincfgs(codec, dock_pins);
5491 spec->gen.auto_mute_via_amp = 1;
5492 spec->gen.automute_hook = asus_tx300_automute;
5493 snd_hda_jack_detect_enable_callback(codec, 0x1b,
5494 snd_hda_gen_hp_automute);
5496 case HDA_FIXUP_ACT_PROBE:
5497 spec->init_amp = ALC_INIT_DEFAULT;
5499 case HDA_FIXUP_ACT_BUILD:
5500 /* this is a bit tricky; give more sane names for the main
5501 * (tablet) speaker and the dock speaker, respectively
5503 rename_ctl(codec, "Speaker Playback Switch",
5504 "Dock Speaker Playback Switch");
5505 rename_ctl(codec, "Bass Speaker Playback Switch",
5506 "Speaker Playback Switch");
5511 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
5512 const struct hda_fixup *fix, int action)
5514 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5515 /* DAC node 0x03 is giving mono output. We therefore want to
5516 make sure 0x14 (front speaker) and 0x15 (headphones) use the
5517 stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
5518 hda_nid_t conn1[2] = { 0x0c };
5519 snd_hda_override_conn_list(codec, 0x14, 1, conn1);
5520 snd_hda_override_conn_list(codec, 0x15, 1, conn1);
5524 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
5525 const struct hda_fixup *fix, int action)
5527 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5528 /* The speaker is routed to the Node 0x06 by a mistake, as a result
5529 we can't adjust the speaker's volume since this node does not has
5530 Amp-out capability. we change the speaker's route to:
5531 Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
5532 Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
5533 speaker's volume now. */
5535 hda_nid_t conn1[1] = { 0x0c };
5536 snd_hda_override_conn_list(codec, 0x17, 1, conn1);
5540 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
5541 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
5542 const struct hda_fixup *fix, int action)
5544 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5545 hda_nid_t conn[2] = { 0x02, 0x03 };
5546 snd_hda_override_conn_list(codec, 0x17, 2, conn);
5550 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
5551 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
5552 const struct hda_fixup *fix, int action)
5554 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5555 hda_nid_t conn[1] = { 0x02 };
5556 snd_hda_override_conn_list(codec, 0x17, 1, conn);
5560 /* Hook to update amp GPIO4 for automute */
5561 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
5562 struct hda_jack_callback *jack)
5564 struct alc_spec *spec = codec->spec;
5566 snd_hda_gen_hp_automute(codec, jack);
5567 /* mute_led_polarity is set to 0, so we pass inverted value here */
5568 alc_update_gpio_led(codec, 0x10, !spec->gen.hp_jack_present);
5571 /* Manage GPIOs for HP EliteBook Folio 9480m.
5573 * GPIO4 is the headphone amplifier power control
5574 * GPIO3 is the audio output mute indicator LED
5577 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
5578 const struct hda_fixup *fix,
5581 struct alc_spec *spec = codec->spec;
5583 alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
5584 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5585 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
5586 spec->gpio_mask |= 0x10;
5587 spec->gpio_dir |= 0x10;
5588 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
5592 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
5593 const struct hda_fixup *fix,
5596 struct alc_spec *spec = codec->spec;
5598 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5599 spec->gpio_mask |= 0x04;
5600 spec->gpio_dir |= 0x04;
5601 /* set data bit low */
5605 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
5606 const struct hda_fixup *fix,
5609 alc_fixup_dual_codecs(codec, fix, action);
5611 case HDA_FIXUP_ACT_PRE_PROBE:
5612 /* override card longname to provide a unique UCM profile */
5613 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
5615 case HDA_FIXUP_ACT_BUILD:
5616 /* rename Capture controls depending on the codec */
5617 rename_ctl(codec, "Capture Volume",
5619 "Rear-Panel Capture Volume" :
5620 "Front-Panel Capture Volume");
5621 rename_ctl(codec, "Capture Switch",
5623 "Rear-Panel Capture Switch" :
5624 "Front-Panel Capture Switch");
5629 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
5630 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
5631 const struct hda_fixup *fix, int action)
5633 struct alc_spec *spec = codec->spec;
5634 static hda_nid_t preferred_pairs[] = {
5635 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
5639 if (action != HDA_FIXUP_ACT_PRE_PROBE)
5642 spec->gen.preferred_dacs = preferred_pairs;
5643 spec->gen.auto_mute_via_amp = 1;
5644 codec->power_save_node = 0;
5647 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
5648 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
5649 const struct hda_fixup *fix, int action)
5651 if (action != HDA_FIXUP_ACT_PRE_PROBE)
5654 snd_hda_override_wcaps(codec, 0x03, 0);
5657 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
5658 { SND_JACK_BTN_0, KEY_PLAYPAUSE },
5659 { SND_JACK_BTN_1, KEY_VOICECOMMAND },
5660 { SND_JACK_BTN_2, KEY_VOLUMEUP },
5661 { SND_JACK_BTN_3, KEY_VOLUMEDOWN },
5665 static void alc_headset_btn_callback(struct hda_codec *codec,
5666 struct hda_jack_callback *jack)
5670 if (jack->unsol_res & (7 << 13))
5671 report |= SND_JACK_BTN_0;
5673 if (jack->unsol_res & (1 << 16 | 3 << 8))
5674 report |= SND_JACK_BTN_1;
5677 if (jack->unsol_res & (7 << 23))
5678 report |= SND_JACK_BTN_2;
5680 /* Volume down key */
5681 if (jack->unsol_res & (7 << 10))
5682 report |= SND_JACK_BTN_3;
5684 jack->jack->button_state = report;
5687 static void alc_fixup_headset_jack(struct hda_codec *codec,
5688 const struct hda_fixup *fix, int action)
5692 case HDA_FIXUP_ACT_PRE_PROBE:
5693 snd_hda_jack_detect_enable_callback(codec, 0x55,
5694 alc_headset_btn_callback);
5695 snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", false,
5696 SND_JACK_HEADSET, alc_headset_btn_keymap);
5698 case HDA_FIXUP_ACT_INIT:
5699 switch (codec->core.vendor_id) {
5703 alc_write_coef_idx(codec, 0x48, 0xd011);
5704 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
5705 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
5709 alc_write_coef_idx(codec, 0x48, 0xd011);
5710 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
5717 static void alc295_fixup_chromebook(struct hda_codec *codec,
5718 const struct hda_fixup *fix, int action)
5720 struct alc_spec *spec = codec->spec;
5723 case HDA_FIXUP_ACT_PRE_PROBE:
5724 spec->ultra_low_power = true;
5726 case HDA_FIXUP_ACT_INIT:
5727 switch (codec->core.vendor_id) {
5729 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
5730 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
5733 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
5734 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
5741 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
5742 const struct hda_fixup *fix, int action)
5744 if (action == HDA_FIXUP_ACT_PRE_PROBE)
5745 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
5748 /* for hda_fixup_thinkpad_acpi() */
5749 #include "thinkpad_helper.c"
5751 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
5752 const struct hda_fixup *fix, int action)
5754 alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
5755 hda_fixup_thinkpad_acpi(codec, fix, action);
5758 /* for alc295_fixup_hp_top_speakers */
5759 #include "hp_x360_helper.c"
5762 ALC269_FIXUP_SONY_VAIO,
5763 ALC275_FIXUP_SONY_VAIO_GPIO2,
5764 ALC269_FIXUP_DELL_M101Z,
5765 ALC269_FIXUP_SKU_IGNORE,
5766 ALC269_FIXUP_ASUS_G73JW,
5767 ALC269_FIXUP_LENOVO_EAPD,
5768 ALC275_FIXUP_SONY_HWEQ,
5769 ALC275_FIXUP_SONY_DISABLE_AAMIX,
5771 ALC269_FIXUP_PCM_44K,
5772 ALC269_FIXUP_STEREO_DMIC,
5773 ALC269_FIXUP_HEADSET_MIC,
5774 ALC269_FIXUP_QUANTA_MUTE,
5775 ALC269_FIXUP_LIFEBOOK,
5776 ALC269_FIXUP_LIFEBOOK_EXTMIC,
5777 ALC269_FIXUP_LIFEBOOK_HP_PIN,
5778 ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
5779 ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
5782 ALC269VB_FIXUP_AMIC,
5783 ALC269VB_FIXUP_DMIC,
5784 ALC269_FIXUP_HP_MUTE_LED,
5785 ALC269_FIXUP_HP_MUTE_LED_MIC1,
5786 ALC269_FIXUP_HP_MUTE_LED_MIC2,
5787 ALC269_FIXUP_HP_MUTE_LED_MIC3,
5788 ALC269_FIXUP_HP_GPIO_LED,
5789 ALC269_FIXUP_HP_GPIO_MIC1_LED,
5790 ALC269_FIXUP_HP_LINE1_MIC1_LED,
5791 ALC269_FIXUP_INV_DMIC,
5792 ALC269_FIXUP_LENOVO_DOCK,
5793 ALC269_FIXUP_NO_SHUTUP,
5794 ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
5795 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
5796 ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5797 ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
5798 ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
5799 ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
5800 ALC269_FIXUP_HEADSET_MODE,
5801 ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
5802 ALC269_FIXUP_ASPIRE_HEADSET_MIC,
5803 ALC269_FIXUP_ASUS_X101_FUNC,
5804 ALC269_FIXUP_ASUS_X101_VERB,
5805 ALC269_FIXUP_ASUS_X101,
5806 ALC271_FIXUP_AMIC_MIC2,
5807 ALC271_FIXUP_HP_GATE_MIC_JACK,
5808 ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
5809 ALC269_FIXUP_ACER_AC700,
5810 ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
5811 ALC269VB_FIXUP_ASUS_ZENBOOK,
5812 ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
5813 ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
5814 ALC269VB_FIXUP_ORDISSIMO_EVE2,
5815 ALC283_FIXUP_CHROME_BOOK,
5816 ALC283_FIXUP_SENSE_COMBO_JACK,
5817 ALC282_FIXUP_ASUS_TX300,
5818 ALC283_FIXUP_INT_MIC,
5819 ALC290_FIXUP_MONO_SPEAKERS,
5820 ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
5821 ALC290_FIXUP_SUBWOOFER,
5822 ALC290_FIXUP_SUBWOOFER_HSJACK,
5823 ALC269_FIXUP_THINKPAD_ACPI,
5824 ALC269_FIXUP_DMIC_THINKPAD_ACPI,
5825 ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
5826 ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
5827 ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5828 ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
5829 ALC255_FIXUP_HEADSET_MODE,
5830 ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
5831 ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
5832 ALC292_FIXUP_TPT440_DOCK,
5833 ALC292_FIXUP_TPT440,
5834 ALC283_FIXUP_HEADSET_MIC,
5835 ALC255_FIXUP_MIC_MUTE_LED,
5836 ALC282_FIXUP_ASPIRE_V5_PINS,
5837 ALC280_FIXUP_HP_GPIO4,
5838 ALC286_FIXUP_HP_GPIO_LED,
5839 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
5840 ALC280_FIXUP_HP_DOCK_PINS,
5841 ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
5842 ALC280_FIXUP_HP_9480M,
5843 ALC288_FIXUP_DELL_HEADSET_MODE,
5844 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
5845 ALC288_FIXUP_DELL_XPS_13,
5846 ALC288_FIXUP_DISABLE_AAMIX,
5847 ALC292_FIXUP_DELL_E7X,
5848 ALC292_FIXUP_DISABLE_AAMIX,
5849 ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
5850 ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
5851 ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
5852 ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
5853 ALC275_FIXUP_DELL_XPS,
5854 ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE,
5855 ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE2,
5856 ALC293_FIXUP_LENOVO_SPK_NOISE,
5857 ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
5858 ALC255_FIXUP_DELL_SPK_NOISE,
5859 ALC225_FIXUP_DISABLE_MIC_VREF,
5860 ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
5861 ALC295_FIXUP_DISABLE_DAC3,
5862 ALC285_FIXUP_SPEAKER2_TO_DAC1,
5863 ALC280_FIXUP_HP_HEADSET_MIC,
5864 ALC221_FIXUP_HP_FRONT_MIC,
5865 ALC292_FIXUP_TPT460,
5866 ALC298_FIXUP_SPK_VOLUME,
5867 ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
5868 ALC269_FIXUP_ATIV_BOOK_8,
5869 ALC221_FIXUP_HP_MIC_NO_PRESENCE,
5870 ALC256_FIXUP_ASUS_HEADSET_MODE,
5871 ALC256_FIXUP_ASUS_MIC,
5872 ALC256_FIXUP_ASUS_AIO_GPIO2,
5873 ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
5874 ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
5875 ALC233_FIXUP_LENOVO_MULTI_CODECS,
5876 ALC233_FIXUP_ACER_HEADSET_MIC,
5877 ALC294_FIXUP_LENOVO_MIC_LOCATION,
5878 ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
5879 ALC700_FIXUP_INTEL_REFERENCE,
5880 ALC274_FIXUP_DELL_BIND_DACS,
5881 ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
5882 ALC298_FIXUP_TPT470_DOCK,
5883 ALC255_FIXUP_DUMMY_LINEOUT_VERB,
5884 ALC255_FIXUP_DELL_HEADSET_MIC,
5885 ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
5886 ALC298_FIXUP_HUAWEI_MBX_STEREO,
5887 ALC295_FIXUP_HP_X360,
5888 ALC221_FIXUP_HP_HEADSET_MIC,
5889 ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
5890 ALC295_FIXUP_HP_AUTO_MUTE,
5891 ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
5892 ALC294_FIXUP_ASUS_MIC,
5893 ALC294_FIXUP_ASUS_HEADSET_MIC,
5894 ALC294_FIXUP_ASUS_SPK,
5895 ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
5896 ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
5897 ALC255_FIXUP_ACER_HEADSET_MIC,
5898 ALC295_FIXUP_CHROME_BOOK,
5899 ALC225_FIXUP_HEADSET_JACK,
5900 ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
5901 ALC225_FIXUP_WYSE_AUTO_MUTE,
5902 ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
5903 ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
5904 ALC256_FIXUP_ASUS_HEADSET_MIC,
5905 ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
5906 ALC299_FIXUP_PREDATOR_SPK,
5907 ALC294_FIXUP_ASUS_INTSPK_HEADSET_MIC,
5908 ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
5909 ALC294_FIXUP_ASUS_INTSPK_GPIO,
5912 static const struct hda_fixup alc269_fixups[] = {
5913 [ALC269_FIXUP_SONY_VAIO] = {
5914 .type = HDA_FIXUP_PINCTLS,
5915 .v.pins = (const struct hda_pintbl[]) {
5916 {0x19, PIN_VREFGRD},
5920 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
5921 .type = HDA_FIXUP_FUNC,
5922 .v.func = alc275_fixup_gpio4_off,
5924 .chain_id = ALC269_FIXUP_SONY_VAIO
5926 [ALC269_FIXUP_DELL_M101Z] = {
5927 .type = HDA_FIXUP_VERBS,
5928 .v.verbs = (const struct hda_verb[]) {
5929 /* Enables internal speaker */
5930 {0x20, AC_VERB_SET_COEF_INDEX, 13},
5931 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
5935 [ALC269_FIXUP_SKU_IGNORE] = {
5936 .type = HDA_FIXUP_FUNC,
5937 .v.func = alc_fixup_sku_ignore,
5939 [ALC269_FIXUP_ASUS_G73JW] = {
5940 .type = HDA_FIXUP_PINS,
5941 .v.pins = (const struct hda_pintbl[]) {
5942 { 0x17, 0x99130111 }, /* subwoofer */
5946 [ALC269_FIXUP_LENOVO_EAPD] = {
5947 .type = HDA_FIXUP_VERBS,
5948 .v.verbs = (const struct hda_verb[]) {
5949 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
5953 [ALC275_FIXUP_SONY_HWEQ] = {
5954 .type = HDA_FIXUP_FUNC,
5955 .v.func = alc269_fixup_hweq,
5957 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
5959 [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
5960 .type = HDA_FIXUP_FUNC,
5961 .v.func = alc_fixup_disable_aamix,
5963 .chain_id = ALC269_FIXUP_SONY_VAIO
5965 [ALC271_FIXUP_DMIC] = {
5966 .type = HDA_FIXUP_FUNC,
5967 .v.func = alc271_fixup_dmic,
5969 [ALC269_FIXUP_PCM_44K] = {
5970 .type = HDA_FIXUP_FUNC,
5971 .v.func = alc269_fixup_pcm_44k,
5973 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5975 [ALC269_FIXUP_STEREO_DMIC] = {
5976 .type = HDA_FIXUP_FUNC,
5977 .v.func = alc269_fixup_stereo_dmic,
5979 [ALC269_FIXUP_HEADSET_MIC] = {
5980 .type = HDA_FIXUP_FUNC,
5981 .v.func = alc269_fixup_headset_mic,
5983 [ALC269_FIXUP_QUANTA_MUTE] = {
5984 .type = HDA_FIXUP_FUNC,
5985 .v.func = alc269_fixup_quanta_mute,
5987 [ALC269_FIXUP_LIFEBOOK] = {
5988 .type = HDA_FIXUP_PINS,
5989 .v.pins = (const struct hda_pintbl[]) {
5990 { 0x1a, 0x2101103f }, /* dock line-out */
5991 { 0x1b, 0x23a11040 }, /* dock mic-in */
5995 .chain_id = ALC269_FIXUP_QUANTA_MUTE
5997 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
5998 .type = HDA_FIXUP_PINS,
5999 .v.pins = (const struct hda_pintbl[]) {
6000 { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
6004 [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
6005 .type = HDA_FIXUP_PINS,
6006 .v.pins = (const struct hda_pintbl[]) {
6007 { 0x21, 0x0221102f }, /* HP out */
6011 [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
6012 .type = HDA_FIXUP_FUNC,
6013 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
6015 [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
6016 .type = HDA_FIXUP_FUNC,
6017 .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
6019 [ALC269_FIXUP_AMIC] = {
6020 .type = HDA_FIXUP_PINS,
6021 .v.pins = (const struct hda_pintbl[]) {
6022 { 0x14, 0x99130110 }, /* speaker */
6023 { 0x15, 0x0121401f }, /* HP out */
6024 { 0x18, 0x01a19c20 }, /* mic */
6025 { 0x19, 0x99a3092f }, /* int-mic */
6029 [ALC269_FIXUP_DMIC] = {
6030 .type = HDA_FIXUP_PINS,
6031 .v.pins = (const struct hda_pintbl[]) {
6032 { 0x12, 0x99a3092f }, /* int-mic */
6033 { 0x14, 0x99130110 }, /* speaker */
6034 { 0x15, 0x0121401f }, /* HP out */
6035 { 0x18, 0x01a19c20 }, /* mic */
6039 [ALC269VB_FIXUP_AMIC] = {
6040 .type = HDA_FIXUP_PINS,
6041 .v.pins = (const struct hda_pintbl[]) {
6042 { 0x14, 0x99130110 }, /* speaker */
6043 { 0x18, 0x01a19c20 }, /* mic */
6044 { 0x19, 0x99a3092f }, /* int-mic */
6045 { 0x21, 0x0121401f }, /* HP out */
6049 [ALC269VB_FIXUP_DMIC] = {
6050 .type = HDA_FIXUP_PINS,
6051 .v.pins = (const struct hda_pintbl[]) {
6052 { 0x12, 0x99a3092f }, /* int-mic */
6053 { 0x14, 0x99130110 }, /* speaker */
6054 { 0x18, 0x01a19c20 }, /* mic */
6055 { 0x21, 0x0121401f }, /* HP out */
6059 [ALC269_FIXUP_HP_MUTE_LED] = {
6060 .type = HDA_FIXUP_FUNC,
6061 .v.func = alc269_fixup_hp_mute_led,
6063 [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
6064 .type = HDA_FIXUP_FUNC,
6065 .v.func = alc269_fixup_hp_mute_led_mic1,
6067 [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
6068 .type = HDA_FIXUP_FUNC,
6069 .v.func = alc269_fixup_hp_mute_led_mic2,
6071 [ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
6072 .type = HDA_FIXUP_FUNC,
6073 .v.func = alc269_fixup_hp_mute_led_mic3,
6075 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE
6077 [ALC269_FIXUP_HP_GPIO_LED] = {
6078 .type = HDA_FIXUP_FUNC,
6079 .v.func = alc269_fixup_hp_gpio_led,
6081 [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
6082 .type = HDA_FIXUP_FUNC,
6083 .v.func = alc269_fixup_hp_gpio_mic1_led,
6085 [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
6086 .type = HDA_FIXUP_FUNC,
6087 .v.func = alc269_fixup_hp_line1_mic1_led,
6089 [ALC269_FIXUP_INV_DMIC] = {
6090 .type = HDA_FIXUP_FUNC,
6091 .v.func = alc_fixup_inv_dmic,
6093 [ALC269_FIXUP_NO_SHUTUP] = {
6094 .type = HDA_FIXUP_FUNC,
6095 .v.func = alc_fixup_no_shutup,
6097 [ALC269_FIXUP_LENOVO_DOCK] = {
6098 .type = HDA_FIXUP_PINS,
6099 .v.pins = (const struct hda_pintbl[]) {
6100 { 0x19, 0x23a11040 }, /* dock mic */
6101 { 0x1b, 0x2121103f }, /* dock headphone */
6105 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
6107 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
6108 .type = HDA_FIXUP_FUNC,
6109 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
6111 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6113 [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6114 .type = HDA_FIXUP_PINS,
6115 .v.pins = (const struct hda_pintbl[]) {
6116 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6117 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6121 .chain_id = ALC269_FIXUP_HEADSET_MODE
6123 [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
6124 .type = HDA_FIXUP_PINS,
6125 .v.pins = (const struct hda_pintbl[]) {
6126 { 0x16, 0x21014020 }, /* dock line out */
6127 { 0x19, 0x21a19030 }, /* dock mic */
6128 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6132 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6134 [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
6135 .type = HDA_FIXUP_PINS,
6136 .v.pins = (const struct hda_pintbl[]) {
6137 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6141 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6143 [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
6144 .type = HDA_FIXUP_PINS,
6145 .v.pins = (const struct hda_pintbl[]) {
6146 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6147 { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6151 .chain_id = ALC269_FIXUP_HEADSET_MODE
6153 [ALC269_FIXUP_HEADSET_MODE] = {
6154 .type = HDA_FIXUP_FUNC,
6155 .v.func = alc_fixup_headset_mode,
6157 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6159 [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
6160 .type = HDA_FIXUP_FUNC,
6161 .v.func = alc_fixup_headset_mode_no_hp_mic,
6163 [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
6164 .type = HDA_FIXUP_PINS,
6165 .v.pins = (const struct hda_pintbl[]) {
6166 { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
6170 .chain_id = ALC269_FIXUP_HEADSET_MODE,
6172 [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
6173 .type = HDA_FIXUP_PINS,
6174 .v.pins = (const struct hda_pintbl[]) {
6175 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6179 .chain_id = ALC269_FIXUP_HEADSET_MIC
6181 [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
6182 .type = HDA_FIXUP_PINS,
6183 .v.pins = (const struct hda_pintbl[]) {
6197 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6199 [ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
6200 .type = HDA_FIXUP_FUNC,
6201 .v.func = alc298_fixup_huawei_mbx_stereo,
6203 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6205 [ALC269_FIXUP_ASUS_X101_FUNC] = {
6206 .type = HDA_FIXUP_FUNC,
6207 .v.func = alc269_fixup_x101_headset_mic,
6209 [ALC269_FIXUP_ASUS_X101_VERB] = {
6210 .type = HDA_FIXUP_VERBS,
6211 .v.verbs = (const struct hda_verb[]) {
6212 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6213 {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
6214 {0x20, AC_VERB_SET_PROC_COEF, 0x0310},
6218 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
6220 [ALC269_FIXUP_ASUS_X101] = {
6221 .type = HDA_FIXUP_PINS,
6222 .v.pins = (const struct hda_pintbl[]) {
6223 { 0x18, 0x04a1182c }, /* Headset mic */
6227 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
6229 [ALC271_FIXUP_AMIC_MIC2] = {
6230 .type = HDA_FIXUP_PINS,
6231 .v.pins = (const struct hda_pintbl[]) {
6232 { 0x14, 0x99130110 }, /* speaker */
6233 { 0x19, 0x01a19c20 }, /* mic */
6234 { 0x1b, 0x99a7012f }, /* int-mic */
6235 { 0x21, 0x0121401f }, /* HP out */
6239 [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
6240 .type = HDA_FIXUP_FUNC,
6241 .v.func = alc271_hp_gate_mic_jack,
6243 .chain_id = ALC271_FIXUP_AMIC_MIC2,
6245 [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
6246 .type = HDA_FIXUP_FUNC,
6247 .v.func = alc269_fixup_limit_int_mic_boost,
6249 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
6251 [ALC269_FIXUP_ACER_AC700] = {
6252 .type = HDA_FIXUP_PINS,
6253 .v.pins = (const struct hda_pintbl[]) {
6254 { 0x12, 0x99a3092f }, /* int-mic */
6255 { 0x14, 0x99130110 }, /* speaker */
6256 { 0x18, 0x03a11c20 }, /* mic */
6257 { 0x1e, 0x0346101e }, /* SPDIF1 */
6258 { 0x21, 0x0321101f }, /* HP out */
6262 .chain_id = ALC271_FIXUP_DMIC,
6264 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
6265 .type = HDA_FIXUP_FUNC,
6266 .v.func = alc269_fixup_limit_int_mic_boost,
6268 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6270 [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
6271 .type = HDA_FIXUP_FUNC,
6272 .v.func = alc269_fixup_limit_int_mic_boost,
6274 .chain_id = ALC269VB_FIXUP_DMIC,
6276 [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
6277 .type = HDA_FIXUP_VERBS,
6278 .v.verbs = (const struct hda_verb[]) {
6279 /* class-D output amp +5dB */
6280 { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
6281 { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
6285 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
6287 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
6288 .type = HDA_FIXUP_FUNC,
6289 .v.func = alc269_fixup_limit_int_mic_boost,
6291 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
6293 [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
6294 .type = HDA_FIXUP_PINS,
6295 .v.pins = (const struct hda_pintbl[]) {
6296 { 0x12, 0x99a3092f }, /* int-mic */
6297 { 0x18, 0x03a11d20 }, /* mic */
6298 { 0x19, 0x411111f0 }, /* Unused bogus pin */
6302 [ALC283_FIXUP_CHROME_BOOK] = {
6303 .type = HDA_FIXUP_FUNC,
6304 .v.func = alc283_fixup_chromebook,
6306 [ALC283_FIXUP_SENSE_COMBO_JACK] = {
6307 .type = HDA_FIXUP_FUNC,
6308 .v.func = alc283_fixup_sense_combo_jack,
6310 .chain_id = ALC283_FIXUP_CHROME_BOOK,
6312 [ALC282_FIXUP_ASUS_TX300] = {
6313 .type = HDA_FIXUP_FUNC,
6314 .v.func = alc282_fixup_asus_tx300,
6316 [ALC283_FIXUP_INT_MIC] = {
6317 .type = HDA_FIXUP_VERBS,
6318 .v.verbs = (const struct hda_verb[]) {
6319 {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
6320 {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
6324 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
6326 [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
6327 .type = HDA_FIXUP_PINS,
6328 .v.pins = (const struct hda_pintbl[]) {
6329 { 0x17, 0x90170112 }, /* subwoofer */
6333 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
6335 [ALC290_FIXUP_SUBWOOFER] = {
6336 .type = HDA_FIXUP_PINS,
6337 .v.pins = (const struct hda_pintbl[]) {
6338 { 0x17, 0x90170112 }, /* subwoofer */
6342 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
6344 [ALC290_FIXUP_MONO_SPEAKERS] = {
6345 .type = HDA_FIXUP_FUNC,
6346 .v.func = alc290_fixup_mono_speakers,
6348 [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
6349 .type = HDA_FIXUP_FUNC,
6350 .v.func = alc290_fixup_mono_speakers,
6352 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
6354 [ALC269_FIXUP_THINKPAD_ACPI] = {
6355 .type = HDA_FIXUP_FUNC,
6356 .v.func = alc_fixup_thinkpad_acpi,
6358 .chain_id = ALC269_FIXUP_SKU_IGNORE,
6360 [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
6361 .type = HDA_FIXUP_FUNC,
6362 .v.func = alc_fixup_inv_dmic,
6364 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
6366 [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
6367 .type = HDA_FIXUP_PINS,
6368 .v.pins = (const struct hda_pintbl[]) {
6369 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6373 .chain_id = ALC255_FIXUP_HEADSET_MODE
6375 [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
6376 .type = HDA_FIXUP_PINS,
6377 .v.pins = (const struct hda_pintbl[]) {
6378 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6382 .chain_id = ALC255_FIXUP_HEADSET_MODE
6384 [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6385 .type = HDA_FIXUP_PINS,
6386 .v.pins = (const struct hda_pintbl[]) {
6387 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6388 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6392 .chain_id = ALC255_FIXUP_HEADSET_MODE
6394 [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
6395 .type = HDA_FIXUP_PINS,
6396 .v.pins = (const struct hda_pintbl[]) {
6397 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6401 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
6403 [ALC255_FIXUP_HEADSET_MODE] = {
6404 .type = HDA_FIXUP_FUNC,
6405 .v.func = alc_fixup_headset_mode_alc255,
6407 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6409 [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
6410 .type = HDA_FIXUP_FUNC,
6411 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
6413 [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6414 .type = HDA_FIXUP_PINS,
6415 .v.pins = (const struct hda_pintbl[]) {
6416 { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6417 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6421 .chain_id = ALC269_FIXUP_HEADSET_MODE
6423 [ALC292_FIXUP_TPT440_DOCK] = {
6424 .type = HDA_FIXUP_FUNC,
6425 .v.func = alc_fixup_tpt440_dock,
6427 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
6429 [ALC292_FIXUP_TPT440] = {
6430 .type = HDA_FIXUP_FUNC,
6431 .v.func = alc_fixup_disable_aamix,
6433 .chain_id = ALC292_FIXUP_TPT440_DOCK,
6435 [ALC283_FIXUP_HEADSET_MIC] = {
6436 .type = HDA_FIXUP_PINS,
6437 .v.pins = (const struct hda_pintbl[]) {
6438 { 0x19, 0x04a110f0 },
6442 [ALC255_FIXUP_MIC_MUTE_LED] = {
6443 .type = HDA_FIXUP_FUNC,
6444 .v.func = snd_hda_gen_fixup_micmute_led,
6446 [ALC282_FIXUP_ASPIRE_V5_PINS] = {
6447 .type = HDA_FIXUP_PINS,
6448 .v.pins = (const struct hda_pintbl[]) {
6449 { 0x12, 0x90a60130 },
6450 { 0x14, 0x90170110 },
6451 { 0x17, 0x40000008 },
6452 { 0x18, 0x411111f0 },
6453 { 0x19, 0x01a1913c },
6454 { 0x1a, 0x411111f0 },
6455 { 0x1b, 0x411111f0 },
6456 { 0x1d, 0x40f89b2d },
6457 { 0x1e, 0x411111f0 },
6458 { 0x21, 0x0321101f },
6462 [ALC280_FIXUP_HP_GPIO4] = {
6463 .type = HDA_FIXUP_FUNC,
6464 .v.func = alc280_fixup_hp_gpio4,
6466 [ALC286_FIXUP_HP_GPIO_LED] = {
6467 .type = HDA_FIXUP_FUNC,
6468 .v.func = alc286_fixup_hp_gpio_led,
6470 [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
6471 .type = HDA_FIXUP_FUNC,
6472 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
6474 [ALC280_FIXUP_HP_DOCK_PINS] = {
6475 .type = HDA_FIXUP_PINS,
6476 .v.pins = (const struct hda_pintbl[]) {
6477 { 0x1b, 0x21011020 }, /* line-out */
6478 { 0x1a, 0x01a1903c }, /* headset mic */
6479 { 0x18, 0x2181103f }, /* line-in */
6483 .chain_id = ALC280_FIXUP_HP_GPIO4
6485 [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
6486 .type = HDA_FIXUP_PINS,
6487 .v.pins = (const struct hda_pintbl[]) {
6488 { 0x1b, 0x21011020 }, /* line-out */
6489 { 0x18, 0x2181103f }, /* line-in */
6493 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
6495 [ALC280_FIXUP_HP_9480M] = {
6496 .type = HDA_FIXUP_FUNC,
6497 .v.func = alc280_fixup_hp_9480m,
6499 [ALC288_FIXUP_DELL_HEADSET_MODE] = {
6500 .type = HDA_FIXUP_FUNC,
6501 .v.func = alc_fixup_headset_mode_dell_alc288,
6503 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
6505 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6506 .type = HDA_FIXUP_PINS,
6507 .v.pins = (const struct hda_pintbl[]) {
6508 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6509 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6513 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
6515 [ALC288_FIXUP_DISABLE_AAMIX] = {
6516 .type = HDA_FIXUP_FUNC,
6517 .v.func = alc_fixup_disable_aamix,
6519 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
6521 [ALC288_FIXUP_DELL_XPS_13] = {
6522 .type = HDA_FIXUP_FUNC,
6523 .v.func = alc_fixup_dell_xps13,
6525 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
6527 [ALC292_FIXUP_DISABLE_AAMIX] = {
6528 .type = HDA_FIXUP_FUNC,
6529 .v.func = alc_fixup_disable_aamix,
6531 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
6533 [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
6534 .type = HDA_FIXUP_FUNC,
6535 .v.func = alc_fixup_disable_aamix,
6537 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
6539 [ALC292_FIXUP_DELL_E7X] = {
6540 .type = HDA_FIXUP_FUNC,
6541 .v.func = alc_fixup_dell_xps13,
6543 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
6545 [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
6546 .type = HDA_FIXUP_PINS,
6547 .v.pins = (const struct hda_pintbl[]) {
6548 { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
6551 .chained_before = true,
6552 .chain_id = ALC269_FIXUP_HEADSET_MODE,
6554 [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6555 .type = HDA_FIXUP_PINS,
6556 .v.pins = (const struct hda_pintbl[]) {
6557 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6558 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6562 .chain_id = ALC269_FIXUP_HEADSET_MODE
6564 [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
6565 .type = HDA_FIXUP_PINS,
6566 .v.pins = (const struct hda_pintbl[]) {
6567 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6571 .chain_id = ALC269_FIXUP_HEADSET_MODE
6573 [ALC275_FIXUP_DELL_XPS] = {
6574 .type = HDA_FIXUP_VERBS,
6575 .v.verbs = (const struct hda_verb[]) {
6576 /* Enables internal speaker */
6577 {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
6578 {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
6579 {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
6580 {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
6584 [ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE] = {
6585 .type = HDA_FIXUP_VERBS,
6586 .v.verbs = (const struct hda_verb[]) {
6587 /* Disable pass-through path for FRONT 14h */
6588 {0x20, AC_VERB_SET_COEF_INDEX, 0x36},
6589 {0x20, AC_VERB_SET_PROC_COEF, 0x1737},
6593 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6595 [ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE2] = {
6596 .type = HDA_FIXUP_FUNC,
6597 .v.func = alc256_fixup_dell_xps_13_headphone_noise2,
6599 .chain_id = ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE
6601 [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
6602 .type = HDA_FIXUP_FUNC,
6603 .v.func = alc_fixup_disable_aamix,
6605 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
6607 [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
6608 .type = HDA_FIXUP_FUNC,
6609 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
6611 [ALC255_FIXUP_DELL_SPK_NOISE] = {
6612 .type = HDA_FIXUP_FUNC,
6613 .v.func = alc_fixup_disable_aamix,
6615 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6617 [ALC225_FIXUP_DISABLE_MIC_VREF] = {
6618 .type = HDA_FIXUP_FUNC,
6619 .v.func = alc_fixup_disable_mic_vref,
6621 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
6623 [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
6624 .type = HDA_FIXUP_VERBS,
6625 .v.verbs = (const struct hda_verb[]) {
6626 /* Disable pass-through path for FRONT 14h */
6627 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
6628 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
6632 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
6634 [ALC280_FIXUP_HP_HEADSET_MIC] = {
6635 .type = HDA_FIXUP_FUNC,
6636 .v.func = alc_fixup_disable_aamix,
6638 .chain_id = ALC269_FIXUP_HEADSET_MIC,
6640 [ALC221_FIXUP_HP_FRONT_MIC] = {
6641 .type = HDA_FIXUP_PINS,
6642 .v.pins = (const struct hda_pintbl[]) {
6643 { 0x19, 0x02a19020 }, /* Front Mic */
6647 [ALC292_FIXUP_TPT460] = {
6648 .type = HDA_FIXUP_FUNC,
6649 .v.func = alc_fixup_tpt440_dock,
6651 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
6653 [ALC298_FIXUP_SPK_VOLUME] = {
6654 .type = HDA_FIXUP_FUNC,
6655 .v.func = alc298_fixup_speaker_volume,
6657 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
6659 [ALC295_FIXUP_DISABLE_DAC3] = {
6660 .type = HDA_FIXUP_FUNC,
6661 .v.func = alc295_fixup_disable_dac3,
6663 [ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
6664 .type = HDA_FIXUP_FUNC,
6665 .v.func = alc285_fixup_speaker2_to_dac1,
6667 [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
6668 .type = HDA_FIXUP_PINS,
6669 .v.pins = (const struct hda_pintbl[]) {
6670 { 0x1b, 0x90170151 },
6674 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6676 [ALC269_FIXUP_ATIV_BOOK_8] = {
6677 .type = HDA_FIXUP_FUNC,
6678 .v.func = alc_fixup_auto_mute_via_amp,
6680 .chain_id = ALC269_FIXUP_NO_SHUTUP
6682 [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
6683 .type = HDA_FIXUP_PINS,
6684 .v.pins = (const struct hda_pintbl[]) {
6685 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6686 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
6690 .chain_id = ALC269_FIXUP_HEADSET_MODE
6692 [ALC256_FIXUP_ASUS_HEADSET_MODE] = {
6693 .type = HDA_FIXUP_FUNC,
6694 .v.func = alc_fixup_headset_mode,
6696 [ALC256_FIXUP_ASUS_MIC] = {
6697 .type = HDA_FIXUP_PINS,
6698 .v.pins = (const struct hda_pintbl[]) {
6699 { 0x13, 0x90a60160 }, /* use as internal mic */
6700 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
6704 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
6706 [ALC256_FIXUP_ASUS_AIO_GPIO2] = {
6707 .type = HDA_FIXUP_FUNC,
6708 /* Set up GPIO2 for the speaker amp */
6709 .v.func = alc_fixup_gpio4,
6711 [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
6712 .type = HDA_FIXUP_PINS,
6713 .v.pins = (const struct hda_pintbl[]) {
6714 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6718 .chain_id = ALC269_FIXUP_HEADSET_MIC
6720 [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
6721 .type = HDA_FIXUP_VERBS,
6722 .v.verbs = (const struct hda_verb[]) {
6723 /* Enables internal speaker */
6724 {0x20, AC_VERB_SET_COEF_INDEX, 0x40},
6725 {0x20, AC_VERB_SET_PROC_COEF, 0x8800},
6729 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
6731 [ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
6732 .type = HDA_FIXUP_FUNC,
6733 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
6735 [ALC233_FIXUP_ACER_HEADSET_MIC] = {
6736 .type = HDA_FIXUP_VERBS,
6737 .v.verbs = (const struct hda_verb[]) {
6738 { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
6739 { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
6743 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
6745 [ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
6746 .type = HDA_FIXUP_PINS,
6747 .v.pins = (const struct hda_pintbl[]) {
6748 /* Change the mic location from front to right, otherwise there are
6749 two front mics with the same name, pulseaudio can't handle them.
6750 This is just a temporary workaround, after applying this fixup,
6751 there will be one "Front Mic" and one "Mic" in this machine.
6753 { 0x1a, 0x04a19040 },
6757 [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
6758 .type = HDA_FIXUP_PINS,
6759 .v.pins = (const struct hda_pintbl[]) {
6760 { 0x16, 0x0101102f }, /* Rear Headset HP */
6761 { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
6762 { 0x1a, 0x01a19030 }, /* Rear Headset MIC */
6763 { 0x1b, 0x02011020 },
6767 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6769 [ALC700_FIXUP_INTEL_REFERENCE] = {
6770 .type = HDA_FIXUP_VERBS,
6771 .v.verbs = (const struct hda_verb[]) {
6772 /* Enables internal speaker */
6773 {0x20, AC_VERB_SET_COEF_INDEX, 0x45},
6774 {0x20, AC_VERB_SET_PROC_COEF, 0x5289},
6775 {0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
6776 {0x20, AC_VERB_SET_PROC_COEF, 0x001b},
6777 {0x58, AC_VERB_SET_COEF_INDEX, 0x00},
6778 {0x58, AC_VERB_SET_PROC_COEF, 0x3888},
6779 {0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
6780 {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
6784 [ALC274_FIXUP_DELL_BIND_DACS] = {
6785 .type = HDA_FIXUP_FUNC,
6786 .v.func = alc274_fixup_bind_dacs,
6788 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
6790 [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
6791 .type = HDA_FIXUP_PINS,
6792 .v.pins = (const struct hda_pintbl[]) {
6793 { 0x1b, 0x0401102f },
6797 .chain_id = ALC274_FIXUP_DELL_BIND_DACS
6799 [ALC298_FIXUP_TPT470_DOCK] = {
6800 .type = HDA_FIXUP_FUNC,
6801 .v.func = alc_fixup_tpt470_dock,
6803 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
6805 [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
6806 .type = HDA_FIXUP_PINS,
6807 .v.pins = (const struct hda_pintbl[]) {
6808 { 0x14, 0x0201101f },
6812 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
6814 [ALC255_FIXUP_DELL_HEADSET_MIC] = {
6815 .type = HDA_FIXUP_PINS,
6816 .v.pins = (const struct hda_pintbl[]) {
6817 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6821 .chain_id = ALC269_FIXUP_HEADSET_MIC
6823 [ALC295_FIXUP_HP_X360] = {
6824 .type = HDA_FIXUP_FUNC,
6825 .v.func = alc295_fixup_hp_top_speakers,
6827 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
6829 [ALC221_FIXUP_HP_HEADSET_MIC] = {
6830 .type = HDA_FIXUP_PINS,
6831 .v.pins = (const struct hda_pintbl[]) {
6832 { 0x19, 0x0181313f},
6836 .chain_id = ALC269_FIXUP_HEADSET_MIC
6838 [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
6839 .type = HDA_FIXUP_FUNC,
6840 .v.func = alc285_fixup_invalidate_dacs,
6842 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
6844 [ALC295_FIXUP_HP_AUTO_MUTE] = {
6845 .type = HDA_FIXUP_FUNC,
6846 .v.func = alc_fixup_auto_mute_via_amp,
6848 [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
6849 .type = HDA_FIXUP_PINS,
6850 .v.pins = (const struct hda_pintbl[]) {
6851 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6855 .chain_id = ALC269_FIXUP_HEADSET_MIC
6857 [ALC294_FIXUP_ASUS_MIC] = {
6858 .type = HDA_FIXUP_PINS,
6859 .v.pins = (const struct hda_pintbl[]) {
6860 { 0x13, 0x90a60160 }, /* use as internal mic */
6861 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
6865 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6867 [ALC294_FIXUP_ASUS_HEADSET_MIC] = {
6868 .type = HDA_FIXUP_PINS,
6869 .v.pins = (const struct hda_pintbl[]) {
6870 { 0x19, 0x01a1103c }, /* use as headset mic */
6874 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6876 [ALC294_FIXUP_ASUS_SPK] = {
6877 .type = HDA_FIXUP_VERBS,
6878 .v.verbs = (const struct hda_verb[]) {
6880 { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
6881 { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
6885 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
6887 [ALC295_FIXUP_CHROME_BOOK] = {
6888 .type = HDA_FIXUP_FUNC,
6889 .v.func = alc295_fixup_chromebook,
6891 .chain_id = ALC225_FIXUP_HEADSET_JACK
6893 [ALC225_FIXUP_HEADSET_JACK] = {
6894 .type = HDA_FIXUP_FUNC,
6895 .v.func = alc_fixup_headset_jack,
6897 [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
6898 .type = HDA_FIXUP_PINS,
6899 .v.pins = (const struct hda_pintbl[]) {
6900 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
6904 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6906 [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
6907 .type = HDA_FIXUP_VERBS,
6908 .v.verbs = (const struct hda_verb[]) {
6909 /* Disable PCBEEP-IN passthrough */
6910 { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
6911 { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
6915 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
6917 [ALC255_FIXUP_ACER_HEADSET_MIC] = {
6918 .type = HDA_FIXUP_PINS,
6919 .v.pins = (const struct hda_pintbl[]) {
6920 { 0x19, 0x03a11130 },
6921 { 0x1a, 0x90a60140 }, /* use as internal mic */
6925 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
6927 [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
6928 .type = HDA_FIXUP_PINS,
6929 .v.pins = (const struct hda_pintbl[]) {
6930 { 0x16, 0x01011020 }, /* Rear Line out */
6931 { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
6935 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
6937 [ALC225_FIXUP_WYSE_AUTO_MUTE] = {
6938 .type = HDA_FIXUP_FUNC,
6939 .v.func = alc_fixup_auto_mute_via_amp,
6941 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
6943 [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
6944 .type = HDA_FIXUP_FUNC,
6945 .v.func = alc_fixup_disable_mic_vref,
6947 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6949 [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
6950 .type = HDA_FIXUP_VERBS,
6951 .v.verbs = (const struct hda_verb[]) {
6952 { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
6953 { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
6957 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
6959 [ALC256_FIXUP_ASUS_HEADSET_MIC] = {
6960 .type = HDA_FIXUP_PINS,
6961 .v.pins = (const struct hda_pintbl[]) {
6962 { 0x19, 0x03a11020 }, /* headset mic with jack detect */
6966 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
6968 [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
6969 .type = HDA_FIXUP_PINS,
6970 .v.pins = (const struct hda_pintbl[]) {
6971 { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
6975 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
6977 [ALC299_FIXUP_PREDATOR_SPK] = {
6978 .type = HDA_FIXUP_PINS,
6979 .v.pins = (const struct hda_pintbl[]) {
6980 { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
6984 [ALC294_FIXUP_ASUS_INTSPK_HEADSET_MIC] = {
6985 .type = HDA_FIXUP_PINS,
6986 .v.pins = (const struct hda_pintbl[]) {
6987 { 0x14, 0x411111f0 }, /* disable confusing internal speaker */
6988 { 0x19, 0x04a11150 }, /* use as headset mic, without its own jack detect */
6992 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
6994 [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
6995 .type = HDA_FIXUP_PINS,
6996 .v.pins = (const struct hda_pintbl[]) {
6997 { 0x19, 0x04a11040 },
6998 { 0x21, 0x04211020 },
7002 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7004 [ALC294_FIXUP_ASUS_INTSPK_GPIO] = {
7005 .type = HDA_FIXUP_FUNC,
7006 /* The GPIO must be pulled to initialize the AMP */
7007 .v.func = alc_fixup_gpio4,
7009 .chain_id = ALC294_FIXUP_ASUS_INTSPK_HEADSET_MIC
7013 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
7014 SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
7015 SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
7016 SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
7017 SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
7018 SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
7019 SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
7020 SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
7021 SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
7022 SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
7023 SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
7024 SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
7025 SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
7026 SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
7027 SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
7028 SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
7029 SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
7030 SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7031 SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7032 SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7033 SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
7034 SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
7035 SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
7036 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
7037 SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
7038 SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
7039 SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
7040 SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
7041 SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
7042 SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
7043 SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
7044 SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
7045 SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
7046 SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
7047 SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
7048 SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
7049 SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
7050 SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
7051 SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7052 SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7053 SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
7054 SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
7055 SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
7056 SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
7057 SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7058 SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7059 SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7060 SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7061 SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7062 SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7063 SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
7064 SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13 9350", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE2),
7065 SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
7066 SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
7067 SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
7068 SND_PCI_QUIRK(0x1028, 0x075b, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE2),
7069 SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
7070 SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
7071 SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
7072 SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
7073 SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
7074 SND_PCI_QUIRK(0x1028, 0x082a, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE2),
7075 SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
7076 SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
7077 SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
7078 SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
7079 SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
7080 SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
7081 SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
7082 SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
7083 SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7084 SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
7085 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
7086 SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
7087 SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
7088 SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
7090 SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7091 SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7092 SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7093 SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7094 SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7095 SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7096 SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7097 SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
7098 SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7099 SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7100 SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7101 SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7102 SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
7103 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
7104 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
7105 SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7106 SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7107 SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7108 SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7109 SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7110 SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
7111 SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7112 SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7114 SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7115 SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7116 SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7117 SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7118 SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7119 SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7120 SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7121 SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7122 SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7123 SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
7124 SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7125 SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7126 SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7127 SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7128 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7129 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7130 SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
7131 SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7132 SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7133 SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7134 SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7135 SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7136 SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7137 SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7138 SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7139 SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7140 SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7141 SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7142 SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
7143 SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
7144 SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7145 SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7146 SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7147 SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
7148 SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
7149 SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7150 SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
7151 SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7152 SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7153 SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
7154 SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
7155 SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
7156 SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7157 SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
7158 SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
7159 SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
7160 SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7161 SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
7162 SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
7163 SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
7164 SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
7165 SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
7166 SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
7167 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
7168 SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
7169 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
7170 SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_INTSPK_GPIO),
7171 SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
7172 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
7173 SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
7174 SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
7175 SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
7176 SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7177 SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
7178 SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
7179 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
7180 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
7181 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
7182 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
7183 SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
7184 SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
7185 SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
7186 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
7187 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
7188 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
7189 SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
7190 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
7191 SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
7192 SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
7193 SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
7194 SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
7195 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
7196 SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
7197 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE),
7198 SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
7199 SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
7200 SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
7201 SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
7202 SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
7203 SND_PCI_QUIRK(0x1558, 0x1325, "System76 Darter Pro (darp5)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
7204 SND_PCI_QUIRK(0x1558, 0x8550, "System76 Gazelle (gaze14)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
7205 SND_PCI_QUIRK(0x1558, 0x8551, "System76 Gazelle (gaze14)", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
7206 SND_PCI_QUIRK(0x1558, 0x8560, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
7207 SND_PCI_QUIRK(0x1558, 0x8561, "System76 Gazelle (gaze14)", ALC269_FIXUP_HEADSET_MIC),
7208 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
7209 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
7210 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
7211 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
7212 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
7213 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
7214 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
7215 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
7216 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
7217 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
7218 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
7219 SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
7220 SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
7221 SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
7222 SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
7223 SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
7224 SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
7225 SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
7226 SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7227 SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
7228 SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
7229 SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
7230 SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7231 SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7232 SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
7233 SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
7234 SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
7235 SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7236 SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7237 SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
7238 SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7239 SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7240 SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7241 SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7242 SND_PCI_QUIRK(0x17aa, 0x2293, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_SPEAKER2_TO_DAC1),
7243 SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
7244 SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
7245 SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7246 SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7247 SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7248 SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7249 SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
7250 SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7251 SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7252 SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
7253 SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
7254 SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
7255 SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
7256 SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7257 SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
7258 SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
7259 SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7260 SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
7261 SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
7262 SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
7263 SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
7264 SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
7265 SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
7266 SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
7267 SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
7268 SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7269 SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7270 SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7271 SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
7272 SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7273 SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
7274 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
7275 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
7276 SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
7277 SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
7278 SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
7279 SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
7282 /* Below is a quirk table taken from the old code.
7283 * Basically the device should work as is without the fixup table.
7284 * If BIOS doesn't give a proper info, enable the corresponding
7287 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
7289 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
7290 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
7291 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
7292 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
7293 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
7294 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
7295 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
7296 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
7297 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
7298 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
7299 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
7300 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
7301 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
7302 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
7303 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
7304 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
7305 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
7306 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
7307 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
7308 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
7309 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
7310 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
7311 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
7312 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
7313 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
7314 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
7315 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
7316 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
7317 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
7318 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
7319 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
7320 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
7321 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
7322 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
7323 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
7324 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
7325 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
7326 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
7327 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
7332 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
7333 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
7334 SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
7335 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
7336 SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
7337 SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
7341 static const struct hda_model_fixup alc269_fixup_models[] = {
7342 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
7343 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
7344 {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
7345 {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
7346 {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
7347 {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
7348 {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
7349 {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
7350 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
7351 {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
7352 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
7353 {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
7354 {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
7355 {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
7356 {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
7357 {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
7358 {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
7359 {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
7360 {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
7361 {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
7362 {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
7363 {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
7364 {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
7365 {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
7366 {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
7367 {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
7368 {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
7369 {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
7370 {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
7371 {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
7372 {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
7373 {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
7374 {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
7375 {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
7376 {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
7377 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
7378 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
7379 {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
7380 {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
7381 {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
7382 {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
7383 {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
7384 {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
7385 {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
7386 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
7387 {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
7388 {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
7389 {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
7390 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
7391 {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
7392 {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
7393 {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
7394 {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
7395 {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
7396 {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
7397 {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
7398 {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
7399 {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
7400 {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
7401 {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
7402 {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
7403 {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
7404 {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
7405 {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
7406 {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
7407 {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
7408 {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
7409 {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
7410 {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
7411 {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
7412 {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
7413 {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
7414 {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
7415 {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
7416 {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
7417 {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
7418 {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
7419 {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
7420 {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
7421 {.id = ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE, .name = "alc256-dell-xps13"},
7422 {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
7423 {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
7424 {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
7425 {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
7426 {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
7427 {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
7428 {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
7429 {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
7430 {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
7431 {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
7432 {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
7433 {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
7434 {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
7435 {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
7436 {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
7437 {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
7438 {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
7439 {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
7440 {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
7441 {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
7442 {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
7443 {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
7444 {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
7445 {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
7446 {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
7447 {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
7448 {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
7449 {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
7452 #define ALC225_STANDARD_PINS \
7455 #define ALC256_STANDARD_PINS \
7456 {0x12, 0x90a60140}, \
7457 {0x14, 0x90170110}, \
7460 #define ALC282_STANDARD_PINS \
7463 #define ALC290_STANDARD_PINS \
7466 #define ALC292_STANDARD_PINS \
7467 {0x14, 0x90170110}, \
7470 #define ALC295_STANDARD_PINS \
7471 {0x12, 0xb7a60130}, \
7472 {0x14, 0x90170110}, \
7475 #define ALC298_STANDARD_PINS \
7476 {0x12, 0x90a60130}, \
7479 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
7480 SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
7485 {0x21, 0x0221102f}),
7486 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
7489 {0x21, 0x02211030}),
7490 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7493 {0x21, 0x03211020}),
7494 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7497 {0x21, 0x03211020}),
7498 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7499 ALC225_STANDARD_PINS,
7501 {0x14, 0x901701a0}),
7502 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7503 ALC225_STANDARD_PINS,
7505 {0x14, 0x901701b0}),
7506 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7507 ALC225_STANDARD_PINS,
7509 {0x14, 0x901701a0}),
7510 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7511 ALC225_STANDARD_PINS,
7513 {0x14, 0x901701b0}),
7514 SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7515 ALC225_STANDARD_PINS,
7517 {0x1b, 0x90170110}),
7518 SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7521 {0x21, 0x02211020}),
7522 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7526 {0x21, 0x02211020}),
7527 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
7532 {0x21, 0x0221101f}),
7533 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
7538 {0x21, 0x0221101f}),
7539 SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
7543 {0x21, 0x0221101f}),
7544 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7546 {0x21, 0x02211020}),
7547 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7549 {0x21, 0x02211040}),
7550 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7553 {0x21, 0x02211020}),
7554 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7557 {0x21, 0x02211030}),
7558 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7561 {0x21, 0x0221101f}),
7562 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7565 {0x21, 0x0221101f}),
7566 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7569 {0x21, 0x0221103f}),
7570 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7573 {0x21, 0x0221103f}),
7574 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7577 {0x21, 0x0221103f}),
7578 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7581 {0x21, 0x0221105f}),
7582 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7585 {0x21, 0x0221101f}),
7586 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7590 {0x21, 0x0321102f}),
7591 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7594 {0x21, 0x02211040}),
7595 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7598 {0x21, 0x02211050}),
7599 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7602 {0x21, 0x02211030}),
7603 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7606 {0x21, 0x02211040}),
7607 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7610 {0x21, 0x02211040}),
7611 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7614 {0x21, 0x02211050}),
7615 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7618 {0x21, 0x02211040}),
7619 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7622 {0x21, 0x02211030}),
7623 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7625 {0x21, 0x02211010}),
7626 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
7629 {0x21, 0x04211020}),
7630 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
7633 {0x21, 0x03211020}),
7634 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7637 {0x21, 0x03211020}),
7638 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7641 {0x21, 0x04211020}),
7642 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7645 {0x21, 0x03211020}),
7646 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
7650 {0x1a, 0x04a11020}),
7651 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
7657 {0x1b, 0x02011020}),
7658 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7659 ALC282_STANDARD_PINS,
7662 {0x21, 0x0321101f}),
7663 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7664 ALC282_STANDARD_PINS,
7667 {0x21, 0x03211040}),
7668 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7669 ALC282_STANDARD_PINS,
7672 {0x21, 0x03211020}),
7673 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7674 ALC282_STANDARD_PINS,
7677 {0x21, 0x0421101f}),
7678 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
7679 ALC282_STANDARD_PINS,
7682 {0x21, 0x04211020}),
7683 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7684 ALC282_STANDARD_PINS,
7686 {0x21, 0x0321101f}),
7687 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7690 {0x21, 0x02211030}),
7691 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7692 ALC282_STANDARD_PINS,
7695 {0x21, 0x0321101f}),
7696 SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
7700 {0x21, 0x04211020}),
7701 SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7704 {0x21, 0x02211020}),
7705 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
7708 {0x21, 0x0321101f}),
7709 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7710 ALC290_STANDARD_PINS,
7713 {0x1a, 0x04a11020}),
7714 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7715 ALC290_STANDARD_PINS,
7718 {0x1a, 0x04a11020}),
7719 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7720 ALC290_STANDARD_PINS,
7722 {0x1a, 0x04a11020}),
7723 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7724 ALC290_STANDARD_PINS,
7726 {0x1a, 0x04a11040}),
7727 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7728 ALC290_STANDARD_PINS,
7731 {0x1a, 0x04a11040}),
7732 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7733 ALC290_STANDARD_PINS,
7736 {0x1a, 0x04a11020}),
7737 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
7738 ALC290_STANDARD_PINS,
7741 {0x1a, 0x04a11020}),
7742 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7743 ALC292_STANDARD_PINS,
7746 {0x19, 0x01a19030}),
7747 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7748 ALC292_STANDARD_PINS,
7752 {0x19, 0x01a1903e}),
7753 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7754 ALC292_STANDARD_PINS,
7755 {0x12, 0x90a60140}),
7756 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7757 ALC292_STANDARD_PINS,
7760 {0x19, 0x21a19030}),
7761 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7762 ALC292_STANDARD_PINS,
7763 {0x13, 0x90a60140}),
7764 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
7767 {0x21, 0x04211020}),
7768 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
7771 {0x21, 0x03211020}),
7772 SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
7775 {0x21, 0x04211020}),
7776 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
7779 {0x21, 0x03211020}),
7780 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7782 {0x21, 0x04211020}),
7783 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7785 {0x21, 0x04211030}),
7786 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7787 ALC295_STANDARD_PINS,
7789 {0x18, 0x21a19030}),
7790 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7791 ALC295_STANDARD_PINS,
7793 {0x18, 0x21a19050}),
7794 SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7795 ALC295_STANDARD_PINS),
7796 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7797 ALC298_STANDARD_PINS,
7798 {0x17, 0x90170110}),
7799 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7800 ALC298_STANDARD_PINS,
7801 {0x17, 0x90170140}),
7802 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7803 ALC298_STANDARD_PINS,
7804 {0x17, 0x90170150}),
7805 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
7810 {0x21, 0x03211030}),
7811 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
7815 {0x21, 0x03211020}),
7816 SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7817 ALC225_STANDARD_PINS,
7819 {0x17, 0x90170110}),
7823 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
7824 * more machines, don't need to match all valid pins, just need to match
7825 * all the pins defined in the tbl. Just because of this reason, it is possible
7826 * that a single machine matches multiple tbls, so there is one limitation:
7827 * at most one tbl is allowed to define for the same vendor and same codec
7829 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
7830 SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7832 {0x1b, 0x40000000}),
7833 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7835 {0x1a, 0x40000000}),
7836 SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7838 {0x1a, 0x40000000}),
7839 SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7841 {0x1a, 0x40000000}),
7845 static void alc269_fill_coef(struct hda_codec *codec)
7847 struct alc_spec *spec = codec->spec;
7850 if (spec->codec_variant != ALC269_TYPE_ALC269VB)
7853 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
7854 alc_write_coef_idx(codec, 0xf, 0x960b);
7855 alc_write_coef_idx(codec, 0xe, 0x8817);
7858 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
7859 alc_write_coef_idx(codec, 0xf, 0x960b);
7860 alc_write_coef_idx(codec, 0xe, 0x8814);
7863 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
7864 /* Power up output pin */
7865 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
7868 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
7869 val = alc_read_coef_idx(codec, 0xd);
7870 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
7871 /* Capless ramp up clock control */
7872 alc_write_coef_idx(codec, 0xd, val | (1<<10));
7874 val = alc_read_coef_idx(codec, 0x17);
7875 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
7876 /* Class D power on reset */
7877 alc_write_coef_idx(codec, 0x17, val | (1<<7));
7882 alc_update_coef_idx(codec, 0x4, 0, 1<<11);
7887 static int patch_alc269(struct hda_codec *codec)
7889 struct alc_spec *spec;
7892 err = alc_alloc_spec(codec, 0x0b);
7897 spec->gen.shared_mic_vref_pin = 0x18;
7898 codec->power_save_node = 0;
7901 codec->patch_ops.suspend = alc269_suspend;
7902 codec->patch_ops.resume = alc269_resume;
7904 spec->shutup = alc_default_shutup;
7905 spec->init_hook = alc_default_init;
7907 switch (codec->core.vendor_id) {
7909 spec->codec_variant = ALC269_TYPE_ALC269VA;
7910 switch (alc_get_coef0(codec) & 0x00f0) {
7912 if (codec->bus->pci &&
7913 codec->bus->pci->subsystem_vendor == 0x1025 &&
7914 spec->cdefine.platform_type == 1)
7915 err = alc_codec_rename(codec, "ALC271X");
7916 spec->codec_variant = ALC269_TYPE_ALC269VB;
7919 if (codec->bus->pci &&
7920 codec->bus->pci->subsystem_vendor == 0x17aa &&
7921 codec->bus->pci->subsystem_device == 0x21f3)
7922 err = alc_codec_rename(codec, "ALC3202");
7923 spec->codec_variant = ALC269_TYPE_ALC269VC;
7926 spec->codec_variant = ALC269_TYPE_ALC269VD;
7929 alc_fix_pll_init(codec, 0x20, 0x04, 15);
7933 spec->shutup = alc269_shutup;
7934 spec->init_hook = alc269_fill_coef;
7935 alc269_fill_coef(codec);
7940 spec->codec_variant = ALC269_TYPE_ALC280;
7943 spec->codec_variant = ALC269_TYPE_ALC282;
7944 spec->shutup = alc282_shutup;
7945 spec->init_hook = alc282_init;
7949 spec->codec_variant = ALC269_TYPE_ALC283;
7950 spec->shutup = alc283_shutup;
7951 spec->init_hook = alc283_init;
7955 spec->codec_variant = ALC269_TYPE_ALC284;
7958 spec->codec_variant = ALC269_TYPE_ALC293;
7962 spec->codec_variant = ALC269_TYPE_ALC286;
7965 spec->codec_variant = ALC269_TYPE_ALC298;
7969 spec->codec_variant = ALC269_TYPE_ALC255;
7970 spec->shutup = alc256_shutup;
7971 spec->init_hook = alc256_init;
7975 spec->codec_variant = ALC269_TYPE_ALC256;
7976 spec->shutup = alc256_shutup;
7977 spec->init_hook = alc256_init;
7978 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
7981 spec->codec_variant = ALC269_TYPE_ALC257;
7982 spec->shutup = alc256_shutup;
7983 spec->init_hook = alc256_init;
7984 spec->gen.mixer_nid = 0;
7989 spec->codec_variant = ALC269_TYPE_ALC215;
7990 spec->shutup = alc225_shutup;
7991 spec->init_hook = alc225_init;
7992 spec->gen.mixer_nid = 0;
7997 spec->codec_variant = ALC269_TYPE_ALC225;
7998 spec->shutup = alc225_shutup;
7999 spec->init_hook = alc225_init;
8000 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
8005 spec->codec_variant = ALC269_TYPE_ALC294;
8006 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
8007 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
8008 spec->init_hook = alc294_init;
8011 spec->codec_variant = ALC269_TYPE_ALC300;
8012 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
8015 spec->codec_variant = ALC269_TYPE_ALC623;
8021 spec->codec_variant = ALC269_TYPE_ALC700;
8022 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
8023 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
8024 spec->init_hook = alc294_init;
8029 if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
8030 spec->has_alc5505_dsp = 1;
8031 spec->init_hook = alc5505_dsp_init;
8034 alc_pre_init(codec);
8036 snd_hda_pick_fixup(codec, alc269_fixup_models,
8037 alc269_fixup_tbl, alc269_fixups);
8038 snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
8039 snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
8040 snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
8042 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8044 alc_auto_parse_customize_define(codec);
8046 if (has_cdefine_beep(codec))
8047 spec->gen.beep_nid = 0x01;
8049 /* automatic parse from the BIOS config */
8050 err = alc269_parse_auto_config(codec);
8054 if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
8055 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
8060 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8073 static int alc861_parse_auto_config(struct hda_codec *codec)
8075 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
8076 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
8077 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
8080 /* Pin config fixes */
8082 ALC861_FIXUP_FSC_AMILO_PI1505,
8083 ALC861_FIXUP_AMP_VREF_0F,
8084 ALC861_FIXUP_NO_JACK_DETECT,
8085 ALC861_FIXUP_ASUS_A6RP,
8086 ALC660_FIXUP_ASUS_W7J,
8089 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
8090 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
8091 const struct hda_fixup *fix, int action)
8093 struct alc_spec *spec = codec->spec;
8096 if (action != HDA_FIXUP_ACT_INIT)
8098 val = snd_hda_codec_get_pin_target(codec, 0x0f);
8099 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
8100 val |= AC_PINCTL_IN_EN;
8101 val |= AC_PINCTL_VREF_50;
8102 snd_hda_set_pin_ctl(codec, 0x0f, val);
8103 spec->gen.keep_vref_in_automute = 1;
8106 /* suppress the jack-detection */
8107 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
8108 const struct hda_fixup *fix, int action)
8110 if (action == HDA_FIXUP_ACT_PRE_PROBE)
8111 codec->no_jack_detect = 1;
8114 static const struct hda_fixup alc861_fixups[] = {
8115 [ALC861_FIXUP_FSC_AMILO_PI1505] = {
8116 .type = HDA_FIXUP_PINS,
8117 .v.pins = (const struct hda_pintbl[]) {
8118 { 0x0b, 0x0221101f }, /* HP */
8119 { 0x0f, 0x90170310 }, /* speaker */
8123 [ALC861_FIXUP_AMP_VREF_0F] = {
8124 .type = HDA_FIXUP_FUNC,
8125 .v.func = alc861_fixup_asus_amp_vref_0f,
8127 [ALC861_FIXUP_NO_JACK_DETECT] = {
8128 .type = HDA_FIXUP_FUNC,
8129 .v.func = alc_fixup_no_jack_detect,
8131 [ALC861_FIXUP_ASUS_A6RP] = {
8132 .type = HDA_FIXUP_FUNC,
8133 .v.func = alc861_fixup_asus_amp_vref_0f,
8135 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
8137 [ALC660_FIXUP_ASUS_W7J] = {
8138 .type = HDA_FIXUP_VERBS,
8139 .v.verbs = (const struct hda_verb[]) {
8140 /* ASUS W7J needs a magic pin setup on unused NID 0x10
8141 * for enabling outputs
8143 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
8149 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
8150 SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
8151 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
8152 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
8153 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
8154 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
8155 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
8156 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
8157 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
8163 static int patch_alc861(struct hda_codec *codec)
8165 struct alc_spec *spec;
8168 err = alc_alloc_spec(codec, 0x15);
8173 if (has_cdefine_beep(codec))
8174 spec->gen.beep_nid = 0x23;
8177 spec->power_hook = alc_power_eapd;
8180 alc_pre_init(codec);
8182 snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
8183 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8185 /* automatic parse from the BIOS config */
8186 err = alc861_parse_auto_config(codec);
8190 if (!spec->gen.no_analog) {
8191 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
8196 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8210 * In addition, an independent DAC
8212 static int alc861vd_parse_auto_config(struct hda_codec *codec)
8214 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
8215 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
8216 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
8220 ALC660VD_FIX_ASUS_GPIO1,
8221 ALC861VD_FIX_DALLAS,
8224 /* exclude VREF80 */
8225 static void alc861vd_fixup_dallas(struct hda_codec *codec,
8226 const struct hda_fixup *fix, int action)
8228 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
8229 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
8230 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
8235 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
8236 const struct hda_fixup *fix, int action)
8238 struct alc_spec *spec = codec->spec;
8240 if (action == HDA_FIXUP_ACT_PRE_PROBE)
8241 spec->gpio_mask |= 0x02;
8242 alc_fixup_gpio(codec, action, 0x01);
8245 static const struct hda_fixup alc861vd_fixups[] = {
8246 [ALC660VD_FIX_ASUS_GPIO1] = {
8247 .type = HDA_FIXUP_FUNC,
8248 .v.func = alc660vd_fixup_asus_gpio1,
8250 [ALC861VD_FIX_DALLAS] = {
8251 .type = HDA_FIXUP_FUNC,
8252 .v.func = alc861vd_fixup_dallas,
8256 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
8257 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
8258 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
8259 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
8265 static int patch_alc861vd(struct hda_codec *codec)
8267 struct alc_spec *spec;
8270 err = alc_alloc_spec(codec, 0x0b);
8275 if (has_cdefine_beep(codec))
8276 spec->gen.beep_nid = 0x23;
8278 spec->shutup = alc_eapd_shutup;
8280 alc_pre_init(codec);
8282 snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
8283 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
8285 /* automatic parse from the BIOS config */
8286 err = alc861vd_parse_auto_config(codec);
8290 if (!spec->gen.no_analog) {
8291 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
8296 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
8308 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
8309 * configuration. Each pin widget can choose any input DACs and a mixer.
8310 * Each ADC is connected from a mixer of all inputs. This makes possible
8311 * 6-channel independent captures.
8313 * In addition, an independent DAC for the multi-playback (not used in this
8318 * BIOS auto configuration
8321 static int alc662_parse_auto_config(struct hda_codec *codec)
8323 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
8324 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
8325 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
8326 const hda_nid_t *ssids;
8328 if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
8329 codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
8330 codec->core.vendor_id == 0x10ec0671)
8331 ssids = alc663_ssids;
8333 ssids = alc662_ssids;
8334 return alc_parse_auto_config(codec, alc662_ignore, ssids);
8337 static void alc272_fixup_mario(struct hda_codec *codec,
8338 const struct hda_fixup *fix, int action)
8340 if (action != HDA_FIXUP_ACT_PRE_PROBE)
8342 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
8343 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
8344 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
8345 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
8346 (0 << AC_AMPCAP_MUTE_SHIFT)))
8347 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
8350 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
8352 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
8354 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
8355 SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
8359 /* override the 2.1 chmap */
8360 static void alc_fixup_bass_chmap(struct hda_codec *codec,
8361 const struct hda_fixup *fix, int action)
8363 if (action == HDA_FIXUP_ACT_BUILD) {
8364 struct alc_spec *spec = codec->spec;
8365 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
8369 /* avoid D3 for keeping GPIO up */
8370 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
8372 unsigned int power_state)
8374 struct alc_spec *spec = codec->spec;
8375 if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
8380 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
8381 const struct hda_fixup *fix, int action)
8383 struct alc_spec *spec = codec->spec;
8385 alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
8386 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
8387 spec->mute_led_polarity = 1;
8388 codec->power_filter = gpio_led_power_filter;
8392 static void alc662_usi_automute_hook(struct hda_codec *codec,
8393 struct hda_jack_callback *jack)
8395 struct alc_spec *spec = codec->spec;
8398 snd_hda_gen_hp_automute(codec, jack);
8400 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
8402 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8406 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
8407 const struct hda_fixup *fix, int action)
8409 struct alc_spec *spec = codec->spec;
8410 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
8411 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
8412 spec->gen.hp_automute_hook = alc662_usi_automute_hook;
8416 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
8417 struct hda_jack_callback *cb)
8419 /* surround speakers at 0x1b already get muted automatically when
8420 * headphones are plugged in, but we have to mute/unmute the remaining
8421 * channels manually:
8422 * 0x15 - front left/front right
8423 * 0x18 - front center/ LFE
8425 if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
8426 snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
8427 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
8429 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
8430 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
8434 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
8435 const struct hda_fixup *fix, int action)
8437 /* Pin 0x1b: shared headphones jack and surround speakers */
8438 if (!is_jack_detectable(codec, 0x1b))
8442 case HDA_FIXUP_ACT_PRE_PROBE:
8443 snd_hda_jack_detect_enable_callback(codec, 0x1b,
8444 alc662_aspire_ethos_mute_speakers);
8445 /* subwoofer needs an extra GPIO setting to become audible */
8446 alc_setup_gpio(codec, 0x02);
8448 case HDA_FIXUP_ACT_INIT:
8449 /* Make sure to start in a correct state, i.e. if
8450 * headphones have been plugged in before powering up the system
8452 alc662_aspire_ethos_mute_speakers(codec, NULL);
8457 static struct coef_fw alc668_coefs[] = {
8458 WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0),
8459 WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80),
8460 WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0),
8461 WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
8462 WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
8463 WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
8464 WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0),
8465 WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418),
8466 WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
8467 WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
8468 WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
8469 WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
8470 WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0),
8471 WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
8472 WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0),
8473 WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040),
8474 WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
8475 WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
8476 WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
8477 WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
8481 static void alc668_restore_default_value(struct hda_codec *codec)
8483 alc_process_coef_fw(codec, alc668_coefs);
8487 ALC662_FIXUP_ASPIRE,
8488 ALC662_FIXUP_LED_GPIO1,
8489 ALC662_FIXUP_IDEAPAD,
8491 ALC662_FIXUP_CZC_P10T,
8492 ALC662_FIXUP_SKU_IGNORE,
8493 ALC662_FIXUP_HP_RP5800,
8494 ALC662_FIXUP_ASUS_MODE1,
8495 ALC662_FIXUP_ASUS_MODE2,
8496 ALC662_FIXUP_ASUS_MODE3,
8497 ALC662_FIXUP_ASUS_MODE4,
8498 ALC662_FIXUP_ASUS_MODE5,
8499 ALC662_FIXUP_ASUS_MODE6,
8500 ALC662_FIXUP_ASUS_MODE7,
8501 ALC662_FIXUP_ASUS_MODE8,
8502 ALC662_FIXUP_NO_JACK_DETECT,
8503 ALC662_FIXUP_ZOTAC_Z68,
8504 ALC662_FIXUP_INV_DMIC,
8505 ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
8506 ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
8507 ALC662_FIXUP_HEADSET_MODE,
8508 ALC668_FIXUP_HEADSET_MODE,
8509 ALC662_FIXUP_BASS_MODE4_CHMAP,
8510 ALC662_FIXUP_BASS_16,
8511 ALC662_FIXUP_BASS_1A,
8512 ALC662_FIXUP_BASS_CHMAP,
8513 ALC668_FIXUP_AUTO_MUTE,
8514 ALC668_FIXUP_DELL_DISABLE_AAMIX,
8515 ALC668_FIXUP_DELL_XPS13,
8516 ALC662_FIXUP_ASUS_Nx50,
8517 ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
8518 ALC668_FIXUP_ASUS_Nx51,
8519 ALC668_FIXUP_MIC_COEF,
8520 ALC668_FIXUP_ASUS_G751,
8521 ALC891_FIXUP_HEADSET_MODE,
8522 ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
8523 ALC662_FIXUP_ACER_VERITON,
8524 ALC892_FIXUP_ASROCK_MOBO,
8525 ALC662_FIXUP_USI_FUNC,
8526 ALC662_FIXUP_USI_HEADSET_MODE,
8527 ALC662_FIXUP_LENOVO_MULTI_CODECS,
8528 ALC669_FIXUP_ACER_ASPIRE_ETHOS,
8529 ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
8532 static const struct hda_fixup alc662_fixups[] = {
8533 [ALC662_FIXUP_ASPIRE] = {
8534 .type = HDA_FIXUP_PINS,
8535 .v.pins = (const struct hda_pintbl[]) {
8536 { 0x15, 0x99130112 }, /* subwoofer */
8540 [ALC662_FIXUP_LED_GPIO1] = {
8541 .type = HDA_FIXUP_FUNC,
8542 .v.func = alc662_fixup_led_gpio1,
8544 [ALC662_FIXUP_IDEAPAD] = {
8545 .type = HDA_FIXUP_PINS,
8546 .v.pins = (const struct hda_pintbl[]) {
8547 { 0x17, 0x99130112 }, /* subwoofer */
8551 .chain_id = ALC662_FIXUP_LED_GPIO1,
8553 [ALC272_FIXUP_MARIO] = {
8554 .type = HDA_FIXUP_FUNC,
8555 .v.func = alc272_fixup_mario,
8557 [ALC662_FIXUP_CZC_P10T] = {
8558 .type = HDA_FIXUP_VERBS,
8559 .v.verbs = (const struct hda_verb[]) {
8560 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
8564 [ALC662_FIXUP_SKU_IGNORE] = {
8565 .type = HDA_FIXUP_FUNC,
8566 .v.func = alc_fixup_sku_ignore,
8568 [ALC662_FIXUP_HP_RP5800] = {
8569 .type = HDA_FIXUP_PINS,
8570 .v.pins = (const struct hda_pintbl[]) {
8571 { 0x14, 0x0221201f }, /* HP out */
8575 .chain_id = ALC662_FIXUP_SKU_IGNORE
8577 [ALC662_FIXUP_ASUS_MODE1] = {
8578 .type = HDA_FIXUP_PINS,
8579 .v.pins = (const struct hda_pintbl[]) {
8580 { 0x14, 0x99130110 }, /* speaker */
8581 { 0x18, 0x01a19c20 }, /* mic */
8582 { 0x19, 0x99a3092f }, /* int-mic */
8583 { 0x21, 0x0121401f }, /* HP out */
8587 .chain_id = ALC662_FIXUP_SKU_IGNORE
8589 [ALC662_FIXUP_ASUS_MODE2] = {
8590 .type = HDA_FIXUP_PINS,
8591 .v.pins = (const struct hda_pintbl[]) {
8592 { 0x14, 0x99130110 }, /* speaker */
8593 { 0x18, 0x01a19820 }, /* mic */
8594 { 0x19, 0x99a3092f }, /* int-mic */
8595 { 0x1b, 0x0121401f }, /* HP out */
8599 .chain_id = ALC662_FIXUP_SKU_IGNORE
8601 [ALC662_FIXUP_ASUS_MODE3] = {
8602 .type = HDA_FIXUP_PINS,
8603 .v.pins = (const struct hda_pintbl[]) {
8604 { 0x14, 0x99130110 }, /* speaker */
8605 { 0x15, 0x0121441f }, /* HP */
8606 { 0x18, 0x01a19840 }, /* mic */
8607 { 0x19, 0x99a3094f }, /* int-mic */
8608 { 0x21, 0x01211420 }, /* HP2 */
8612 .chain_id = ALC662_FIXUP_SKU_IGNORE
8614 [ALC662_FIXUP_ASUS_MODE4] = {
8615 .type = HDA_FIXUP_PINS,
8616 .v.pins = (const struct hda_pintbl[]) {
8617 { 0x14, 0x99130110 }, /* speaker */
8618 { 0x16, 0x99130111 }, /* speaker */
8619 { 0x18, 0x01a19840 }, /* mic */
8620 { 0x19, 0x99a3094f }, /* int-mic */
8621 { 0x21, 0x0121441f }, /* HP */
8625 .chain_id = ALC662_FIXUP_SKU_IGNORE
8627 [ALC662_FIXUP_ASUS_MODE5] = {
8628 .type = HDA_FIXUP_PINS,
8629 .v.pins = (const struct hda_pintbl[]) {
8630 { 0x14, 0x99130110 }, /* speaker */
8631 { 0x15, 0x0121441f }, /* HP */
8632 { 0x16, 0x99130111 }, /* speaker */
8633 { 0x18, 0x01a19840 }, /* mic */
8634 { 0x19, 0x99a3094f }, /* int-mic */
8638 .chain_id = ALC662_FIXUP_SKU_IGNORE
8640 [ALC662_FIXUP_ASUS_MODE6] = {
8641 .type = HDA_FIXUP_PINS,
8642 .v.pins = (const struct hda_pintbl[]) {
8643 { 0x14, 0x99130110 }, /* speaker */
8644 { 0x15, 0x01211420 }, /* HP2 */
8645 { 0x18, 0x01a19840 }, /* mic */
8646 { 0x19, 0x99a3094f }, /* int-mic */
8647 { 0x1b, 0x0121441f }, /* HP */
8651 .chain_id = ALC662_FIXUP_SKU_IGNORE
8653 [ALC662_FIXUP_ASUS_MODE7] = {
8654 .type = HDA_FIXUP_PINS,
8655 .v.pins = (const struct hda_pintbl[]) {
8656 { 0x14, 0x99130110 }, /* speaker */
8657 { 0x17, 0x99130111 }, /* speaker */
8658 { 0x18, 0x01a19840 }, /* mic */
8659 { 0x19, 0x99a3094f }, /* int-mic */
8660 { 0x1b, 0x01214020 }, /* HP */
8661 { 0x21, 0x0121401f }, /* HP */
8665 .chain_id = ALC662_FIXUP_SKU_IGNORE
8667 [ALC662_FIXUP_ASUS_MODE8] = {
8668 .type = HDA_FIXUP_PINS,
8669 .v.pins = (const struct hda_pintbl[]) {
8670 { 0x14, 0x99130110 }, /* speaker */
8671 { 0x12, 0x99a30970 }, /* int-mic */
8672 { 0x15, 0x01214020 }, /* HP */
8673 { 0x17, 0x99130111 }, /* speaker */
8674 { 0x18, 0x01a19840 }, /* mic */
8675 { 0x21, 0x0121401f }, /* HP */
8679 .chain_id = ALC662_FIXUP_SKU_IGNORE
8681 [ALC662_FIXUP_NO_JACK_DETECT] = {
8682 .type = HDA_FIXUP_FUNC,
8683 .v.func = alc_fixup_no_jack_detect,
8685 [ALC662_FIXUP_ZOTAC_Z68] = {
8686 .type = HDA_FIXUP_PINS,
8687 .v.pins = (const struct hda_pintbl[]) {
8688 { 0x1b, 0x02214020 }, /* Front HP */
8692 [ALC662_FIXUP_INV_DMIC] = {
8693 .type = HDA_FIXUP_FUNC,
8694 .v.func = alc_fixup_inv_dmic,
8696 [ALC668_FIXUP_DELL_XPS13] = {
8697 .type = HDA_FIXUP_FUNC,
8698 .v.func = alc_fixup_dell_xps13,
8700 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
8702 [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
8703 .type = HDA_FIXUP_FUNC,
8704 .v.func = alc_fixup_disable_aamix,
8706 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
8708 [ALC668_FIXUP_AUTO_MUTE] = {
8709 .type = HDA_FIXUP_FUNC,
8710 .v.func = alc_fixup_auto_mute_via_amp,
8712 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
8714 [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
8715 .type = HDA_FIXUP_PINS,
8716 .v.pins = (const struct hda_pintbl[]) {
8717 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
8718 /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
8722 .chain_id = ALC662_FIXUP_HEADSET_MODE
8724 [ALC662_FIXUP_HEADSET_MODE] = {
8725 .type = HDA_FIXUP_FUNC,
8726 .v.func = alc_fixup_headset_mode_alc662,
8728 [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
8729 .type = HDA_FIXUP_PINS,
8730 .v.pins = (const struct hda_pintbl[]) {
8731 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
8732 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
8736 .chain_id = ALC668_FIXUP_HEADSET_MODE
8738 [ALC668_FIXUP_HEADSET_MODE] = {
8739 .type = HDA_FIXUP_FUNC,
8740 .v.func = alc_fixup_headset_mode_alc668,
8742 [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
8743 .type = HDA_FIXUP_FUNC,
8744 .v.func = alc_fixup_bass_chmap,
8746 .chain_id = ALC662_FIXUP_ASUS_MODE4
8748 [ALC662_FIXUP_BASS_16] = {
8749 .type = HDA_FIXUP_PINS,
8750 .v.pins = (const struct hda_pintbl[]) {
8751 {0x16, 0x80106111}, /* bass speaker */
8755 .chain_id = ALC662_FIXUP_BASS_CHMAP,
8757 [ALC662_FIXUP_BASS_1A] = {
8758 .type = HDA_FIXUP_PINS,
8759 .v.pins = (const struct hda_pintbl[]) {
8760 {0x1a, 0x80106111}, /* bass speaker */
8764 .chain_id = ALC662_FIXUP_BASS_CHMAP,
8766 [ALC662_FIXUP_BASS_CHMAP] = {
8767 .type = HDA_FIXUP_FUNC,
8768 .v.func = alc_fixup_bass_chmap,
8770 [ALC662_FIXUP_ASUS_Nx50] = {
8771 .type = HDA_FIXUP_FUNC,
8772 .v.func = alc_fixup_auto_mute_via_amp,
8774 .chain_id = ALC662_FIXUP_BASS_1A
8776 [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
8777 .type = HDA_FIXUP_FUNC,
8778 .v.func = alc_fixup_headset_mode_alc668,
8779 .chain_id = ALC662_FIXUP_BASS_CHMAP
8781 [ALC668_FIXUP_ASUS_Nx51] = {
8782 .type = HDA_FIXUP_PINS,
8783 .v.pins = (const struct hda_pintbl[]) {
8784 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
8785 { 0x1a, 0x90170151 }, /* bass speaker */
8786 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
8790 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
8792 [ALC668_FIXUP_MIC_COEF] = {
8793 .type = HDA_FIXUP_VERBS,
8794 .v.verbs = (const struct hda_verb[]) {
8795 { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
8796 { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
8800 [ALC668_FIXUP_ASUS_G751] = {
8801 .type = HDA_FIXUP_PINS,
8802 .v.pins = (const struct hda_pintbl[]) {
8803 { 0x16, 0x0421101f }, /* HP */
8807 .chain_id = ALC668_FIXUP_MIC_COEF
8809 [ALC891_FIXUP_HEADSET_MODE] = {
8810 .type = HDA_FIXUP_FUNC,
8811 .v.func = alc_fixup_headset_mode,
8813 [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
8814 .type = HDA_FIXUP_PINS,
8815 .v.pins = (const struct hda_pintbl[]) {
8816 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
8817 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
8821 .chain_id = ALC891_FIXUP_HEADSET_MODE
8823 [ALC662_FIXUP_ACER_VERITON] = {
8824 .type = HDA_FIXUP_PINS,
8825 .v.pins = (const struct hda_pintbl[]) {
8826 { 0x15, 0x50170120 }, /* no internal speaker */
8830 [ALC892_FIXUP_ASROCK_MOBO] = {
8831 .type = HDA_FIXUP_PINS,
8832 .v.pins = (const struct hda_pintbl[]) {
8833 { 0x15, 0x40f000f0 }, /* disabled */
8834 { 0x16, 0x40f000f0 }, /* disabled */
8838 [ALC662_FIXUP_USI_FUNC] = {
8839 .type = HDA_FIXUP_FUNC,
8840 .v.func = alc662_fixup_usi_headset_mic,
8842 [ALC662_FIXUP_USI_HEADSET_MODE] = {
8843 .type = HDA_FIXUP_PINS,
8844 .v.pins = (const struct hda_pintbl[]) {
8845 { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
8846 { 0x18, 0x01a1903d },
8850 .chain_id = ALC662_FIXUP_USI_FUNC
8852 [ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
8853 .type = HDA_FIXUP_FUNC,
8854 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8856 [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
8857 .type = HDA_FIXUP_FUNC,
8858 .v.func = alc662_fixup_aspire_ethos_hp,
8860 [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
8861 .type = HDA_FIXUP_PINS,
8862 .v.pins = (const struct hda_pintbl[]) {
8863 { 0x15, 0x92130110 }, /* front speakers */
8864 { 0x18, 0x99130111 }, /* center/subwoofer */
8865 { 0x1b, 0x11130012 }, /* surround plus jack for HP */
8869 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
8873 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
8874 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
8875 SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
8876 SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
8877 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
8878 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
8879 SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
8880 SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
8881 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
8882 SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8883 SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8884 SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
8885 SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
8886 SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
8887 SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8888 SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8889 SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8890 SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8891 SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
8892 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
8893 SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
8894 SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
8895 SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
8896 SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
8897 SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
8898 SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
8899 SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
8900 SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
8901 SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
8902 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
8903 SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
8904 SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
8905 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
8906 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
8907 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
8908 SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
8909 SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
8910 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
8911 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
8912 SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
8913 SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
8914 SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
8915 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
8916 SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
8919 /* Below is a quirk table taken from the old code.
8920 * Basically the device should work as is without the fixup table.
8921 * If BIOS doesn't give a proper info, enable the corresponding
8924 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
8925 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
8926 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
8927 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
8928 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
8929 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8930 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
8931 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
8932 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
8933 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8934 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
8935 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
8936 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
8937 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
8938 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
8939 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8940 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
8941 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
8942 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8943 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
8944 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
8945 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8946 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
8947 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
8948 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
8949 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8950 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
8951 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
8952 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8953 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
8954 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8955 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8956 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
8957 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
8958 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
8959 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
8960 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
8961 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
8962 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
8963 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
8964 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
8965 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
8966 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
8967 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
8968 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
8969 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
8970 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
8971 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
8972 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
8973 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
8978 static const struct hda_model_fixup alc662_fixup_models[] = {
8979 {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
8980 {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
8981 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
8982 {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
8983 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
8984 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
8985 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
8986 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
8987 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
8988 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
8989 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
8990 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
8991 {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
8992 {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
8993 {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
8994 {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
8995 {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
8996 {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
8997 {.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
8998 {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
8999 {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
9000 {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
9001 {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
9002 {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
9003 {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
9004 {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
9005 {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
9006 {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
9007 {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
9008 {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
9009 {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
9010 {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
9014 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
9015 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
9019 {0x21, 0x01014020}),
9020 SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
9024 {0x21, 0x01014020}),
9025 SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
9029 {0x1b, 0x0221401f}),
9030 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9034 {0x16, 0x03011020}),
9035 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9039 {0x16, 0x03011020}),
9040 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9044 {0x16, 0x03011020}),
9045 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
9048 {0x16, 0x03011020}),
9049 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
9052 {0x15, 0x0321101f}),
9058 static int patch_alc662(struct hda_codec *codec)
9060 struct alc_spec *spec;
9063 err = alc_alloc_spec(codec, 0x0b);
9069 spec->shutup = alc_eapd_shutup;
9071 /* handle multiple HPs as is */
9072 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
9074 alc_fix_pll_init(codec, 0x20, 0x04, 15);
9076 switch (codec->core.vendor_id) {
9078 spec->init_hook = alc668_restore_default_value;
9082 alc_pre_init(codec);
9084 snd_hda_pick_fixup(codec, alc662_fixup_models,
9085 alc662_fixup_tbl, alc662_fixups);
9086 snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
9087 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
9089 alc_auto_parse_customize_define(codec);
9091 if (has_cdefine_beep(codec))
9092 spec->gen.beep_nid = 0x01;
9094 if ((alc_get_coef0(codec) & (1 << 14)) &&
9095 codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
9096 spec->cdefine.platform_type == 1) {
9097 err = alc_codec_rename(codec, "ALC272X");
9102 /* automatic parse from the BIOS config */
9103 err = alc662_parse_auto_config(codec);
9107 if (!spec->gen.no_analog && spec->gen.beep_nid) {
9108 switch (codec->core.vendor_id) {
9110 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9116 err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
9119 err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
9126 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
9139 static int alc680_parse_auto_config(struct hda_codec *codec)
9141 return alc_parse_auto_config(codec, NULL, NULL);
9146 static int patch_alc680(struct hda_codec *codec)
9150 /* ALC680 has no aa-loopback mixer */
9151 err = alc_alloc_spec(codec, 0);
9155 /* automatic parse from the BIOS config */
9156 err = alc680_parse_auto_config(codec);
9168 static const struct hda_device_id snd_hda_id_realtek[] = {
9169 HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
9170 HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
9171 HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
9172 HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
9173 HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
9174 HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
9175 HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
9176 HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
9177 HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
9178 HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
9179 HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
9180 HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
9181 HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
9182 HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
9183 HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
9184 HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
9185 HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
9186 HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
9187 HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
9188 HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
9189 HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
9190 HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
9191 HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
9192 HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
9193 HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
9194 HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
9195 HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
9196 HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
9197 HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
9198 HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
9199 HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
9200 HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
9201 HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
9202 HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
9203 HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
9204 HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
9205 HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
9206 HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
9207 HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
9208 HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
9209 HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
9210 HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
9211 HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
9212 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
9213 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
9214 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
9215 HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
9216 HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
9217 HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
9218 HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
9219 HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
9220 HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
9221 HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
9222 HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
9223 HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
9224 HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
9225 HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
9226 HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
9227 HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
9228 HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
9229 HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
9230 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
9231 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
9232 HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
9233 HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
9234 HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
9235 HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
9236 HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
9237 HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
9238 HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
9239 HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
9240 HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
9241 HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
9244 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
9246 MODULE_LICENSE("GPL");
9247 MODULE_DESCRIPTION("Realtek HD-audio codec");
9249 static struct hda_codec_driver realtek_driver = {
9250 .id = snd_hda_id_realtek,
9253 module_hda_codec_driver(realtek_driver);