2 * Universal Interface for Intel High Definition Audio Codec
4 * HD audio interface patch for Realtek ALC codecs
6 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
7 * PeiSen Hou <pshou@realtek.com.tw>
8 * Takashi Iwai <tiwai@suse.de>
9 * Jonathan Woithe <jwoithe@just42.net>
11 * This driver is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This driver is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/pci.h>
30 #include <linux/dmi.h>
31 #include <linux/module.h>
32 #include <linux/input.h>
33 #include <sound/core.h>
34 #include <sound/jack.h>
35 #include "hda_codec.h"
36 #include "hda_local.h"
37 #include "hda_auto_parser.h"
39 #include "hda_generic.h"
41 /* keep halting ALC5505 DSP, for power saving */
42 #define HALT_REALTEK_ALC5505
45 #define GPIO_MASK 0x03
47 /* extra amp-initialization sequence types */
57 ALC_HEADSET_MODE_UNKNOWN,
58 ALC_HEADSET_MODE_UNPLUGGED,
59 ALC_HEADSET_MODE_HEADSET,
61 ALC_HEADSET_MODE_HEADPHONE,
65 ALC_HEADSET_TYPE_UNKNOWN,
66 ALC_HEADSET_TYPE_CTIA,
67 ALC_HEADSET_TYPE_OMTP,
70 struct alc_customize_define {
72 unsigned char port_connectivity;
73 unsigned char check_sum;
74 unsigned char customization;
75 unsigned char external_amp;
76 unsigned int enable_pcbeep:1;
77 unsigned int platform_type:1;
79 unsigned int override:1;
80 unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */
84 struct hda_gen_spec gen; /* must be at head */
86 /* codec parameterization */
87 const struct snd_kcontrol_new *mixers[5]; /* mixer arrays */
88 unsigned int num_mixers;
89 unsigned int beep_amp; /* beep amp value, set via set_beep_amp() */
91 struct alc_customize_define cdefine;
92 unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
94 /* mute LED for HP laptops, see alc269_fixup_mic_mute_hook() */
95 int mute_led_polarity;
96 hda_nid_t mute_led_nid;
97 hda_nid_t cap_mute_led_nid;
99 unsigned int gpio_led; /* used for alc269_fixup_hp_gpio_led() */
100 unsigned int gpio_mute_led_mask;
101 unsigned int gpio_mic_led_mask;
103 hda_nid_t headset_mic_pin;
104 hda_nid_t headphone_mic_pin;
105 int current_headset_mode;
106 int current_headset_type;
109 void (*init_hook)(struct hda_codec *codec);
111 void (*power_hook)(struct hda_codec *codec);
113 void (*shutup)(struct hda_codec *codec);
116 int codec_variant; /* flag for other variants */
117 unsigned int has_alc5505_dsp:1;
118 unsigned int no_depop_delay:1;
122 unsigned int pll_coef_idx, pll_coef_bit;
124 struct input_dev *kb_dev;
128 * COEF access helper functions
131 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
132 unsigned int coef_idx)
136 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
137 val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
141 #define alc_read_coef_idx(codec, coef_idx) \
142 alc_read_coefex_idx(codec, 0x20, coef_idx)
144 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
145 unsigned int coef_idx, unsigned int coef_val)
147 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
148 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
151 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
152 alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
154 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
155 unsigned int coef_idx, unsigned int mask,
156 unsigned int bits_set)
158 unsigned int val = alc_read_coefex_idx(codec, nid, coef_idx);
161 alc_write_coefex_idx(codec, nid, coef_idx,
162 (val & ~mask) | bits_set);
165 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set) \
166 alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
168 /* a special bypass for COEF 0; read the cached value at the second time */
169 static unsigned int alc_get_coef0(struct hda_codec *codec)
171 struct alc_spec *spec = codec->spec;
174 spec->coef0 = alc_read_coef_idx(codec, 0);
178 /* coef writes/updates batch */
186 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
187 { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
188 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
189 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
190 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
192 static void alc_process_coef_fw(struct hda_codec *codec,
193 const struct coef_fw *fw)
195 for (; fw->nid; fw++) {
196 if (fw->mask == (unsigned short)-1)
197 alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
199 alc_update_coefex_idx(codec, fw->nid, fw->idx,
205 * Append the given mixer and verb elements for the later use
206 * The mixer array is referred in build_controls(), and init_verbs are
209 static void add_mixer(struct alc_spec *spec, const struct snd_kcontrol_new *mix)
211 if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
213 spec->mixers[spec->num_mixers++] = mix;
217 * GPIO setup tables, used in initialization
219 /* Enable GPIO mask and set output */
220 static const struct hda_verb alc_gpio1_init_verbs[] = {
221 {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
222 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
223 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
227 static const struct hda_verb alc_gpio2_init_verbs[] = {
228 {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
229 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
230 {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
234 static const struct hda_verb alc_gpio3_init_verbs[] = {
235 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
236 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
237 {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
242 * Fix hardware PLL issue
243 * On some codecs, the analog PLL gating control must be off while
244 * the default value is 1.
246 static void alc_fix_pll(struct hda_codec *codec)
248 struct alc_spec *spec = codec->spec;
251 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
252 1 << spec->pll_coef_bit, 0);
255 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
256 unsigned int coef_idx, unsigned int coef_bit)
258 struct alc_spec *spec = codec->spec;
260 spec->pll_coef_idx = coef_idx;
261 spec->pll_coef_bit = coef_bit;
265 /* update the master volume per volume-knob's unsol event */
266 static void alc_update_knob_master(struct hda_codec *codec,
267 struct hda_jack_callback *jack)
270 struct snd_kcontrol *kctl;
271 struct snd_ctl_elem_value *uctl;
273 kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
276 uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
279 val = snd_hda_codec_read(codec, jack->tbl->nid, 0,
280 AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
281 val &= HDA_AMP_VOLMASK;
282 uctl->value.integer.value[0] = val;
283 uctl->value.integer.value[1] = val;
284 kctl->put(kctl, uctl);
288 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
290 /* For some reason, the res given from ALC880 is broken.
291 Here we adjust it properly. */
292 snd_hda_jack_unsol_event(codec, res >> 2);
295 /* Change EAPD to verb control */
296 static void alc_fill_eapd_coef(struct hda_codec *codec)
300 coef = alc_get_coef0(codec);
302 switch (codec->core.vendor_id) {
304 alc_update_coef_idx(codec, 0x7, 0, 1<<5);
308 alc_update_coef_idx(codec, 0x7, 0, 1<<13);
311 if ((coef & 0x00f0) == 0x0010)
312 alc_update_coef_idx(codec, 0xd, 0, 1<<14);
313 if ((coef & 0x00f0) == 0x0020)
314 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
315 if ((coef & 0x00f0) == 0x0030)
316 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
322 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
332 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
336 alc_update_coef_idx(codec, 0xa, 1<<13, 0);
339 if ((coef & 0x00f0) == 0x0030)
340 alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
349 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
352 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
355 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
358 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
359 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
362 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
366 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
371 /* additional initialization for ALC888 variants */
372 static void alc888_coef_init(struct hda_codec *codec)
374 switch (alc_get_coef0(codec) & 0x00f0) {
379 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
384 /* turn on/off EAPD control (only if available) */
385 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
387 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
389 if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
390 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
394 /* turn on/off EAPD controls of the codec */
395 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
397 /* We currently only handle front, HP */
398 static hda_nid_t pins[] = {
399 0x0f, 0x10, 0x14, 0x15, 0x17, 0
402 for (p = pins; *p; p++)
403 set_eapd(codec, *p, on);
406 /* generic shutup callback;
407 * just turning off EPAD and a little pause for avoiding pop-noise
409 static void alc_eapd_shutup(struct hda_codec *codec)
411 struct alc_spec *spec = codec->spec;
413 alc_auto_setup_eapd(codec, false);
414 if (!spec->no_depop_delay)
416 snd_hda_shutup_pins(codec);
419 /* generic EAPD initialization */
420 static void alc_auto_init_amp(struct hda_codec *codec, int type)
422 alc_fill_eapd_coef(codec);
423 alc_auto_setup_eapd(codec, true);
426 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
429 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
432 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
434 case ALC_INIT_DEFAULT:
435 switch (codec->core.vendor_id) {
437 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
443 alc_update_coef_idx(codec, 7, 0, 0x2030);
446 alc888_coef_init(codec);
455 * Realtek SSID verification
458 /* Could be any non-zero and even value. When used as fixup, tells
459 * the driver to ignore any present sku defines.
461 #define ALC_FIXUP_SKU_IGNORE (2)
463 static void alc_fixup_sku_ignore(struct hda_codec *codec,
464 const struct hda_fixup *fix, int action)
466 struct alc_spec *spec = codec->spec;
467 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
468 spec->cdefine.fixup = 1;
469 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
473 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
474 const struct hda_fixup *fix, int action)
476 struct alc_spec *spec = codec->spec;
478 if (action == HDA_FIXUP_ACT_PROBE) {
479 spec->no_depop_delay = 1;
480 codec->depop_delay = 0;
484 static int alc_auto_parse_customize_define(struct hda_codec *codec)
486 unsigned int ass, tmp, i;
488 struct alc_spec *spec = codec->spec;
490 spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
492 if (spec->cdefine.fixup) {
493 ass = spec->cdefine.sku_cfg;
494 if (ass == ALC_FIXUP_SKU_IGNORE)
499 if (!codec->bus->pci)
501 ass = codec->core.subsystem_id & 0xffff;
502 if (ass != codec->bus->pci->subsystem_device && (ass & 1))
506 if (codec->core.vendor_id == 0x10ec0260)
508 ass = snd_hda_codec_get_pincfg(codec, nid);
511 codec_info(codec, "%s: SKU not ready 0x%08x\n",
512 codec->core.chip_name, ass);
518 for (i = 1; i < 16; i++) {
522 if (((ass >> 16) & 0xf) != tmp)
525 spec->cdefine.port_connectivity = ass >> 30;
526 spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
527 spec->cdefine.check_sum = (ass >> 16) & 0xf;
528 spec->cdefine.customization = ass >> 8;
530 spec->cdefine.sku_cfg = ass;
531 spec->cdefine.external_amp = (ass & 0x38) >> 3;
532 spec->cdefine.platform_type = (ass & 0x4) >> 2;
533 spec->cdefine.swap = (ass & 0x2) >> 1;
534 spec->cdefine.override = ass & 0x1;
536 codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
537 nid, spec->cdefine.sku_cfg);
538 codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
539 spec->cdefine.port_connectivity);
540 codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
541 codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
542 codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
543 codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
544 codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
545 codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
546 codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
551 /* return the position of NID in the list, or -1 if not found */
552 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
555 for (i = 0; i < nums; i++)
560 /* return true if the given NID is found in the list */
561 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
563 return find_idx_in_nid_list(nid, list, nums) >= 0;
566 /* check subsystem ID and set up device-specific initialization;
567 * return 1 if initialized, 0 if invalid SSID
569 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
570 * 31 ~ 16 : Manufacture ID
572 * 7 ~ 0 : Assembly ID
573 * port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
575 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
577 unsigned int ass, tmp, i;
579 struct alc_spec *spec = codec->spec;
581 if (spec->cdefine.fixup) {
582 ass = spec->cdefine.sku_cfg;
583 if (ass == ALC_FIXUP_SKU_IGNORE)
588 ass = codec->core.subsystem_id & 0xffff;
589 if (codec->bus->pci &&
590 ass != codec->bus->pci->subsystem_device && (ass & 1))
593 /* invalid SSID, check the special NID pin defcfg instead */
595 * 31~30 : port connectivity
598 * 19~16 : Check sum (15:1)
603 if (codec->core.vendor_id == 0x10ec0260)
605 ass = snd_hda_codec_get_pincfg(codec, nid);
607 "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
611 if ((ass >> 30) != 1) /* no physical connection */
616 for (i = 1; i < 16; i++) {
620 if (((ass >> 16) & 0xf) != tmp)
623 codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
624 ass & 0xffff, codec->core.vendor_id);
628 * 2 : 0 --> Desktop, 1 --> Laptop
629 * 3~5 : External Amplifier control
632 tmp = (ass & 0x38) >> 3; /* external Amp control */
635 spec->init_amp = ALC_INIT_GPIO1;
638 spec->init_amp = ALC_INIT_GPIO2;
641 spec->init_amp = ALC_INIT_GPIO3;
645 spec->init_amp = ALC_INIT_DEFAULT;
649 /* is laptop or Desktop and enable the function "Mute internal speaker
650 * when the external headphone out jack is plugged"
655 * 10~8 : Jack location
656 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
658 * 15 : 1 --> enable the function "Mute internal speaker
659 * when the external headphone out jack is plugged"
661 if (!spec->gen.autocfg.hp_pins[0] &&
662 !(spec->gen.autocfg.line_out_pins[0] &&
663 spec->gen.autocfg.line_out_type == AUTO_PIN_HP_OUT)) {
665 tmp = (ass >> 11) & 0x3; /* HP to chassis */
667 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
668 spec->gen.autocfg.line_outs))
670 spec->gen.autocfg.hp_pins[0] = nid;
675 /* Check the validity of ALC subsystem-id
676 * ports contains an array of 4 pin NIDs for port-A, E, D and I */
677 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
679 if (!alc_subsystem_id(codec, ports)) {
680 struct alc_spec *spec = codec->spec;
682 "realtek: Enable default setup for auto mode as fallback\n");
683 spec->init_amp = ALC_INIT_DEFAULT;
690 static void alc_fixup_inv_dmic(struct hda_codec *codec,
691 const struct hda_fixup *fix, int action)
693 struct alc_spec *spec = codec->spec;
695 spec->gen.inv_dmic_split = 1;
699 #ifdef CONFIG_SND_HDA_INPUT_BEEP
700 /* additional beep mixers; the actual parameters are overwritten at build */
701 static const struct snd_kcontrol_new alc_beep_mixer[] = {
702 HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
703 HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
708 static int alc_build_controls(struct hda_codec *codec)
710 struct alc_spec *spec = codec->spec;
713 err = snd_hda_gen_build_controls(codec);
717 for (i = 0; i < spec->num_mixers; i++) {
718 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
723 #ifdef CONFIG_SND_HDA_INPUT_BEEP
724 /* create beep controls if needed */
725 if (spec->beep_amp) {
726 const struct snd_kcontrol_new *knew;
727 for (knew = alc_beep_mixer; knew->name; knew++) {
728 struct snd_kcontrol *kctl;
729 kctl = snd_ctl_new1(knew, codec);
732 kctl->private_value = spec->beep_amp;
733 err = snd_hda_ctl_add(codec, 0, kctl);
740 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
749 static int alc_init(struct hda_codec *codec)
751 struct alc_spec *spec = codec->spec;
754 spec->init_hook(codec);
757 alc_auto_init_amp(codec, spec->init_amp);
759 snd_hda_gen_init(codec);
761 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
766 static inline void alc_shutup(struct hda_codec *codec)
768 struct alc_spec *spec = codec->spec;
770 if (spec && spec->shutup)
773 snd_hda_shutup_pins(codec);
776 #define alc_free snd_hda_gen_free
779 static void alc_power_eapd(struct hda_codec *codec)
781 alc_auto_setup_eapd(codec, false);
784 static int alc_suspend(struct hda_codec *codec)
786 struct alc_spec *spec = codec->spec;
788 if (spec && spec->power_hook)
789 spec->power_hook(codec);
795 static int alc_resume(struct hda_codec *codec)
797 struct alc_spec *spec = codec->spec;
799 if (!spec->no_depop_delay)
800 msleep(150); /* to avoid pop noise */
801 codec->patch_ops.init(codec);
802 regcache_sync(codec->core.regmap);
803 hda_call_check_power_status(codec, 0x01);
810 static const struct hda_codec_ops alc_patch_ops = {
811 .build_controls = alc_build_controls,
812 .build_pcms = snd_hda_gen_build_pcms,
815 .unsol_event = snd_hda_jack_unsol_event,
817 .resume = alc_resume,
818 .suspend = alc_suspend,
819 .check_power_status = snd_hda_gen_check_power_status,
821 .reboot_notify = alc_shutup,
825 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
828 * Rename codecs appropriately from COEF value or subvendor id
830 struct alc_codec_rename_table {
831 unsigned int vendor_id;
832 unsigned short coef_mask;
833 unsigned short coef_bits;
837 struct alc_codec_rename_pci_table {
838 unsigned int codec_vendor_id;
839 unsigned short pci_subvendor;
840 unsigned short pci_subdevice;
844 static struct alc_codec_rename_table rename_tbl[] = {
845 { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
846 { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
847 { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
848 { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
849 { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
850 { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
851 { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
852 { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
853 { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
854 { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
855 { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
856 { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
857 { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
858 { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
859 { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
860 { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
861 { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
865 static struct alc_codec_rename_pci_table rename_pci_tbl[] = {
866 { 0x10ec0280, 0x1028, 0, "ALC3220" },
867 { 0x10ec0282, 0x1028, 0, "ALC3221" },
868 { 0x10ec0283, 0x1028, 0, "ALC3223" },
869 { 0x10ec0288, 0x1028, 0, "ALC3263" },
870 { 0x10ec0292, 0x1028, 0, "ALC3226" },
871 { 0x10ec0293, 0x1028, 0, "ALC3235" },
872 { 0x10ec0255, 0x1028, 0, "ALC3234" },
873 { 0x10ec0668, 0x1028, 0, "ALC3661" },
874 { 0x10ec0275, 0x1028, 0, "ALC3260" },
875 { 0x10ec0899, 0x1028, 0, "ALC3861" },
876 { 0x10ec0298, 0x1028, 0, "ALC3266" },
877 { 0x10ec0256, 0x1028, 0, "ALC3246" },
878 { 0x10ec0670, 0x1025, 0, "ALC669X" },
879 { 0x10ec0676, 0x1025, 0, "ALC679X" },
880 { 0x10ec0282, 0x1043, 0, "ALC3229" },
881 { 0x10ec0233, 0x1043, 0, "ALC3236" },
882 { 0x10ec0280, 0x103c, 0, "ALC3228" },
883 { 0x10ec0282, 0x103c, 0, "ALC3227" },
884 { 0x10ec0286, 0x103c, 0, "ALC3242" },
885 { 0x10ec0290, 0x103c, 0, "ALC3241" },
886 { 0x10ec0668, 0x103c, 0, "ALC3662" },
887 { 0x10ec0283, 0x17aa, 0, "ALC3239" },
888 { 0x10ec0292, 0x17aa, 0, "ALC3232" },
892 static int alc_codec_rename_from_preset(struct hda_codec *codec)
894 const struct alc_codec_rename_table *p;
895 const struct alc_codec_rename_pci_table *q;
897 for (p = rename_tbl; p->vendor_id; p++) {
898 if (p->vendor_id != codec->core.vendor_id)
900 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
901 return alc_codec_rename(codec, p->name);
904 if (!codec->bus->pci)
906 for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
907 if (q->codec_vendor_id != codec->core.vendor_id)
909 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
911 if (!q->pci_subdevice ||
912 q->pci_subdevice == codec->bus->pci->subsystem_device)
913 return alc_codec_rename(codec, q->name);
921 * Digital-beep handlers
923 #ifdef CONFIG_SND_HDA_INPUT_BEEP
924 #define set_beep_amp(spec, nid, idx, dir) \
925 ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
927 static const struct snd_pci_quirk beep_white_list[] = {
928 SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
929 SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
930 SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
931 SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
932 SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
933 SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
934 SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
935 SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
936 SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
940 static inline int has_cdefine_beep(struct hda_codec *codec)
942 struct alc_spec *spec = codec->spec;
943 const struct snd_pci_quirk *q;
944 q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
947 return spec->cdefine.enable_pcbeep;
950 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
951 #define has_cdefine_beep(codec) 0
954 /* parse the BIOS configuration and set up the alc_spec */
955 /* return 1 if successful, 0 if the proper config is not found,
956 * or a negative error code
958 static int alc_parse_auto_config(struct hda_codec *codec,
959 const hda_nid_t *ignore_nids,
960 const hda_nid_t *ssid_nids)
962 struct alc_spec *spec = codec->spec;
963 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
966 err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
972 alc_ssid_check(codec, ssid_nids);
974 err = snd_hda_gen_parse_auto_config(codec, cfg);
981 /* common preparation job for alc_spec */
982 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
984 struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
990 snd_hda_gen_spec_init(&spec->gen);
991 spec->gen.mixer_nid = mixer_nid;
992 spec->gen.own_eapd_ctl = 1;
993 codec->single_adc_amp = 1;
994 /* FIXME: do we need this for all Realtek codec models? */
995 codec->spdif_status_reset = 1;
996 codec->patch_ops = alc_patch_ops;
998 err = alc_codec_rename_from_preset(codec);
1006 static int alc880_parse_auto_config(struct hda_codec *codec)
1008 static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1009 static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1010 return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1019 ALC880_FIXUP_MEDION_RIM,
1021 ALC880_FIXUP_LG_LW25,
1023 ALC880_FIXUP_EAPD_COEF,
1024 ALC880_FIXUP_TCL_S700,
1025 ALC880_FIXUP_VOL_KNOB,
1026 ALC880_FIXUP_FUJITSU,
1028 ALC880_FIXUP_UNIWILL,
1029 ALC880_FIXUP_UNIWILL_DIG,
1031 ALC880_FIXUP_ASUS_W5A,
1032 ALC880_FIXUP_3ST_BASE,
1034 ALC880_FIXUP_3ST_DIG,
1035 ALC880_FIXUP_5ST_BASE,
1037 ALC880_FIXUP_5ST_DIG,
1038 ALC880_FIXUP_6ST_BASE,
1040 ALC880_FIXUP_6ST_DIG,
1041 ALC880_FIXUP_6ST_AUTOMUTE,
1044 /* enable the volume-knob widget support on NID 0x21 */
1045 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1046 const struct hda_fixup *fix, int action)
1048 if (action == HDA_FIXUP_ACT_PROBE)
1049 snd_hda_jack_detect_enable_callback(codec, 0x21,
1050 alc_update_knob_master);
1053 static const struct hda_fixup alc880_fixups[] = {
1054 [ALC880_FIXUP_GPIO1] = {
1055 .type = HDA_FIXUP_VERBS,
1056 .v.verbs = alc_gpio1_init_verbs,
1058 [ALC880_FIXUP_GPIO2] = {
1059 .type = HDA_FIXUP_VERBS,
1060 .v.verbs = alc_gpio2_init_verbs,
1062 [ALC880_FIXUP_MEDION_RIM] = {
1063 .type = HDA_FIXUP_VERBS,
1064 .v.verbs = (const struct hda_verb[]) {
1065 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1066 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1070 .chain_id = ALC880_FIXUP_GPIO2,
1072 [ALC880_FIXUP_LG] = {
1073 .type = HDA_FIXUP_PINS,
1074 .v.pins = (const struct hda_pintbl[]) {
1075 /* disable bogus unused pins */
1076 { 0x16, 0x411111f0 },
1077 { 0x18, 0x411111f0 },
1078 { 0x1a, 0x411111f0 },
1082 [ALC880_FIXUP_LG_LW25] = {
1083 .type = HDA_FIXUP_PINS,
1084 .v.pins = (const struct hda_pintbl[]) {
1085 { 0x1a, 0x0181344f }, /* line-in */
1086 { 0x1b, 0x0321403f }, /* headphone */
1090 [ALC880_FIXUP_W810] = {
1091 .type = HDA_FIXUP_PINS,
1092 .v.pins = (const struct hda_pintbl[]) {
1093 /* disable bogus unused pins */
1094 { 0x17, 0x411111f0 },
1098 .chain_id = ALC880_FIXUP_GPIO2,
1100 [ALC880_FIXUP_EAPD_COEF] = {
1101 .type = HDA_FIXUP_VERBS,
1102 .v.verbs = (const struct hda_verb[]) {
1103 /* change to EAPD mode */
1104 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1105 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
1109 [ALC880_FIXUP_TCL_S700] = {
1110 .type = HDA_FIXUP_VERBS,
1111 .v.verbs = (const struct hda_verb[]) {
1112 /* change to EAPD mode */
1113 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1114 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
1118 .chain_id = ALC880_FIXUP_GPIO2,
1120 [ALC880_FIXUP_VOL_KNOB] = {
1121 .type = HDA_FIXUP_FUNC,
1122 .v.func = alc880_fixup_vol_knob,
1124 [ALC880_FIXUP_FUJITSU] = {
1125 /* override all pins as BIOS on old Amilo is broken */
1126 .type = HDA_FIXUP_PINS,
1127 .v.pins = (const struct hda_pintbl[]) {
1128 { 0x14, 0x0121401f }, /* HP */
1129 { 0x15, 0x99030120 }, /* speaker */
1130 { 0x16, 0x99030130 }, /* bass speaker */
1131 { 0x17, 0x411111f0 }, /* N/A */
1132 { 0x18, 0x411111f0 }, /* N/A */
1133 { 0x19, 0x01a19950 }, /* mic-in */
1134 { 0x1a, 0x411111f0 }, /* N/A */
1135 { 0x1b, 0x411111f0 }, /* N/A */
1136 { 0x1c, 0x411111f0 }, /* N/A */
1137 { 0x1d, 0x411111f0 }, /* N/A */
1138 { 0x1e, 0x01454140 }, /* SPDIF out */
1142 .chain_id = ALC880_FIXUP_VOL_KNOB,
1144 [ALC880_FIXUP_F1734] = {
1145 /* almost compatible with FUJITSU, but no bass and SPDIF */
1146 .type = HDA_FIXUP_PINS,
1147 .v.pins = (const struct hda_pintbl[]) {
1148 { 0x14, 0x0121401f }, /* HP */
1149 { 0x15, 0x99030120 }, /* speaker */
1150 { 0x16, 0x411111f0 }, /* N/A */
1151 { 0x17, 0x411111f0 }, /* N/A */
1152 { 0x18, 0x411111f0 }, /* N/A */
1153 { 0x19, 0x01a19950 }, /* mic-in */
1154 { 0x1a, 0x411111f0 }, /* N/A */
1155 { 0x1b, 0x411111f0 }, /* N/A */
1156 { 0x1c, 0x411111f0 }, /* N/A */
1157 { 0x1d, 0x411111f0 }, /* N/A */
1158 { 0x1e, 0x411111f0 }, /* N/A */
1162 .chain_id = ALC880_FIXUP_VOL_KNOB,
1164 [ALC880_FIXUP_UNIWILL] = {
1165 /* need to fix HP and speaker pins to be parsed correctly */
1166 .type = HDA_FIXUP_PINS,
1167 .v.pins = (const struct hda_pintbl[]) {
1168 { 0x14, 0x0121411f }, /* HP */
1169 { 0x15, 0x99030120 }, /* speaker */
1170 { 0x16, 0x99030130 }, /* bass speaker */
1174 [ALC880_FIXUP_UNIWILL_DIG] = {
1175 .type = HDA_FIXUP_PINS,
1176 .v.pins = (const struct hda_pintbl[]) {
1177 /* disable bogus unused pins */
1178 { 0x17, 0x411111f0 },
1179 { 0x19, 0x411111f0 },
1180 { 0x1b, 0x411111f0 },
1181 { 0x1f, 0x411111f0 },
1185 [ALC880_FIXUP_Z71V] = {
1186 .type = HDA_FIXUP_PINS,
1187 .v.pins = (const struct hda_pintbl[]) {
1188 /* set up the whole pins as BIOS is utterly broken */
1189 { 0x14, 0x99030120 }, /* speaker */
1190 { 0x15, 0x0121411f }, /* HP */
1191 { 0x16, 0x411111f0 }, /* N/A */
1192 { 0x17, 0x411111f0 }, /* N/A */
1193 { 0x18, 0x01a19950 }, /* mic-in */
1194 { 0x19, 0x411111f0 }, /* N/A */
1195 { 0x1a, 0x01813031 }, /* line-in */
1196 { 0x1b, 0x411111f0 }, /* N/A */
1197 { 0x1c, 0x411111f0 }, /* N/A */
1198 { 0x1d, 0x411111f0 }, /* N/A */
1199 { 0x1e, 0x0144111e }, /* SPDIF */
1203 [ALC880_FIXUP_ASUS_W5A] = {
1204 .type = HDA_FIXUP_PINS,
1205 .v.pins = (const struct hda_pintbl[]) {
1206 /* set up the whole pins as BIOS is utterly broken */
1207 { 0x14, 0x0121411f }, /* HP */
1208 { 0x15, 0x411111f0 }, /* N/A */
1209 { 0x16, 0x411111f0 }, /* N/A */
1210 { 0x17, 0x411111f0 }, /* N/A */
1211 { 0x18, 0x90a60160 }, /* mic */
1212 { 0x19, 0x411111f0 }, /* N/A */
1213 { 0x1a, 0x411111f0 }, /* N/A */
1214 { 0x1b, 0x411111f0 }, /* N/A */
1215 { 0x1c, 0x411111f0 }, /* N/A */
1216 { 0x1d, 0x411111f0 }, /* N/A */
1217 { 0x1e, 0xb743111e }, /* SPDIF out */
1221 .chain_id = ALC880_FIXUP_GPIO1,
1223 [ALC880_FIXUP_3ST_BASE] = {
1224 .type = HDA_FIXUP_PINS,
1225 .v.pins = (const struct hda_pintbl[]) {
1226 { 0x14, 0x01014010 }, /* line-out */
1227 { 0x15, 0x411111f0 }, /* N/A */
1228 { 0x16, 0x411111f0 }, /* N/A */
1229 { 0x17, 0x411111f0 }, /* N/A */
1230 { 0x18, 0x01a19c30 }, /* mic-in */
1231 { 0x19, 0x0121411f }, /* HP */
1232 { 0x1a, 0x01813031 }, /* line-in */
1233 { 0x1b, 0x02a19c40 }, /* front-mic */
1234 { 0x1c, 0x411111f0 }, /* N/A */
1235 { 0x1d, 0x411111f0 }, /* N/A */
1236 /* 0x1e is filled in below */
1237 { 0x1f, 0x411111f0 }, /* N/A */
1241 [ALC880_FIXUP_3ST] = {
1242 .type = HDA_FIXUP_PINS,
1243 .v.pins = (const struct hda_pintbl[]) {
1244 { 0x1e, 0x411111f0 }, /* N/A */
1248 .chain_id = ALC880_FIXUP_3ST_BASE,
1250 [ALC880_FIXUP_3ST_DIG] = {
1251 .type = HDA_FIXUP_PINS,
1252 .v.pins = (const struct hda_pintbl[]) {
1253 { 0x1e, 0x0144111e }, /* SPDIF */
1257 .chain_id = ALC880_FIXUP_3ST_BASE,
1259 [ALC880_FIXUP_5ST_BASE] = {
1260 .type = HDA_FIXUP_PINS,
1261 .v.pins = (const struct hda_pintbl[]) {
1262 { 0x14, 0x01014010 }, /* front */
1263 { 0x15, 0x411111f0 }, /* N/A */
1264 { 0x16, 0x01011411 }, /* CLFE */
1265 { 0x17, 0x01016412 }, /* surr */
1266 { 0x18, 0x01a19c30 }, /* mic-in */
1267 { 0x19, 0x0121411f }, /* HP */
1268 { 0x1a, 0x01813031 }, /* line-in */
1269 { 0x1b, 0x02a19c40 }, /* front-mic */
1270 { 0x1c, 0x411111f0 }, /* N/A */
1271 { 0x1d, 0x411111f0 }, /* N/A */
1272 /* 0x1e is filled in below */
1273 { 0x1f, 0x411111f0 }, /* N/A */
1277 [ALC880_FIXUP_5ST] = {
1278 .type = HDA_FIXUP_PINS,
1279 .v.pins = (const struct hda_pintbl[]) {
1280 { 0x1e, 0x411111f0 }, /* N/A */
1284 .chain_id = ALC880_FIXUP_5ST_BASE,
1286 [ALC880_FIXUP_5ST_DIG] = {
1287 .type = HDA_FIXUP_PINS,
1288 .v.pins = (const struct hda_pintbl[]) {
1289 { 0x1e, 0x0144111e }, /* SPDIF */
1293 .chain_id = ALC880_FIXUP_5ST_BASE,
1295 [ALC880_FIXUP_6ST_BASE] = {
1296 .type = HDA_FIXUP_PINS,
1297 .v.pins = (const struct hda_pintbl[]) {
1298 { 0x14, 0x01014010 }, /* front */
1299 { 0x15, 0x01016412 }, /* surr */
1300 { 0x16, 0x01011411 }, /* CLFE */
1301 { 0x17, 0x01012414 }, /* side */
1302 { 0x18, 0x01a19c30 }, /* mic-in */
1303 { 0x19, 0x02a19c40 }, /* front-mic */
1304 { 0x1a, 0x01813031 }, /* line-in */
1305 { 0x1b, 0x0121411f }, /* HP */
1306 { 0x1c, 0x411111f0 }, /* N/A */
1307 { 0x1d, 0x411111f0 }, /* N/A */
1308 /* 0x1e is filled in below */
1309 { 0x1f, 0x411111f0 }, /* N/A */
1313 [ALC880_FIXUP_6ST] = {
1314 .type = HDA_FIXUP_PINS,
1315 .v.pins = (const struct hda_pintbl[]) {
1316 { 0x1e, 0x411111f0 }, /* N/A */
1320 .chain_id = ALC880_FIXUP_6ST_BASE,
1322 [ALC880_FIXUP_6ST_DIG] = {
1323 .type = HDA_FIXUP_PINS,
1324 .v.pins = (const struct hda_pintbl[]) {
1325 { 0x1e, 0x0144111e }, /* SPDIF */
1329 .chain_id = ALC880_FIXUP_6ST_BASE,
1331 [ALC880_FIXUP_6ST_AUTOMUTE] = {
1332 .type = HDA_FIXUP_PINS,
1333 .v.pins = (const struct hda_pintbl[]) {
1334 { 0x1b, 0x0121401f }, /* HP with jack detect */
1337 .chained_before = true,
1338 .chain_id = ALC880_FIXUP_6ST_BASE,
1342 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1343 SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1344 SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1345 SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1346 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1347 SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1348 SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1349 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1350 SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1351 SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1352 SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1353 SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1354 SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1355 SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1356 SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1357 SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1358 SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1359 SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1360 SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1361 SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1362 SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1363 SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1364 SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1365 SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1367 /* Below is the copied entries from alc880_quirks.c.
1368 * It's not quite sure whether BIOS sets the correct pin-config table
1369 * on these machines, thus they are kept to be compatible with
1370 * the old static quirks. Once when it's confirmed to work without
1371 * these overrides, it'd be better to remove.
1373 SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1374 SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1375 SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1376 SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1377 SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1378 SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1379 SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1380 SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1381 SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1382 SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1383 SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1384 SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1385 SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1386 SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1387 SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1388 SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1389 SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1390 SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1391 SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1392 SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1393 SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1394 SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1395 SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1396 SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1397 SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1398 SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1399 SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1400 SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1401 SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1402 SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1403 SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1404 SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1405 SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1407 SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1408 SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1409 SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1413 static const struct hda_model_fixup alc880_fixup_models[] = {
1414 {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1415 {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1416 {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1417 {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1418 {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1419 {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1420 {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1426 * OK, here we have finally the patch for ALC880
1428 static int patch_alc880(struct hda_codec *codec)
1430 struct alc_spec *spec;
1433 err = alc_alloc_spec(codec, 0x0b);
1438 spec->gen.need_dac_fix = 1;
1439 spec->gen.beep_nid = 0x01;
1441 codec->patch_ops.unsol_event = alc880_unsol_event;
1443 snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1445 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1447 /* automatic parse from the BIOS config */
1448 err = alc880_parse_auto_config(codec);
1452 if (!spec->gen.no_analog)
1453 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1455 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1468 static int alc260_parse_auto_config(struct hda_codec *codec)
1470 static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1471 static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1472 return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1479 ALC260_FIXUP_HP_DC5750,
1480 ALC260_FIXUP_HP_PIN_0F,
1483 ALC260_FIXUP_GPIO1_TOGGLE,
1484 ALC260_FIXUP_REPLACER,
1485 ALC260_FIXUP_HP_B1900,
1487 ALC260_FIXUP_FSC_S7020,
1488 ALC260_FIXUP_FSC_S7020_JWSE,
1489 ALC260_FIXUP_VAIO_PINS,
1492 static void alc260_gpio1_automute(struct hda_codec *codec)
1494 struct alc_spec *spec = codec->spec;
1495 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1496 spec->gen.hp_jack_present);
1499 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1500 const struct hda_fixup *fix, int action)
1502 struct alc_spec *spec = codec->spec;
1503 if (action == HDA_FIXUP_ACT_PROBE) {
1504 /* although the machine has only one output pin, we need to
1505 * toggle GPIO1 according to the jack state
1507 spec->gen.automute_hook = alc260_gpio1_automute;
1508 spec->gen.detect_hp = 1;
1509 spec->gen.automute_speaker = 1;
1510 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1511 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1512 snd_hda_gen_hp_automute);
1513 snd_hda_add_verbs(codec, alc_gpio1_init_verbs);
1517 static void alc260_fixup_kn1(struct hda_codec *codec,
1518 const struct hda_fixup *fix, int action)
1520 struct alc_spec *spec = codec->spec;
1521 static const struct hda_pintbl pincfgs[] = {
1522 { 0x0f, 0x02214000 }, /* HP/speaker */
1523 { 0x12, 0x90a60160 }, /* int mic */
1524 { 0x13, 0x02a19000 }, /* ext mic */
1525 { 0x18, 0x01446000 }, /* SPDIF out */
1526 /* disable bogus I/O pins */
1527 { 0x10, 0x411111f0 },
1528 { 0x11, 0x411111f0 },
1529 { 0x14, 0x411111f0 },
1530 { 0x15, 0x411111f0 },
1531 { 0x16, 0x411111f0 },
1532 { 0x17, 0x411111f0 },
1533 { 0x19, 0x411111f0 },
1538 case HDA_FIXUP_ACT_PRE_PROBE:
1539 snd_hda_apply_pincfgs(codec, pincfgs);
1541 case HDA_FIXUP_ACT_PROBE:
1542 spec->init_amp = ALC_INIT_NONE;
1547 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1548 const struct hda_fixup *fix, int action)
1550 struct alc_spec *spec = codec->spec;
1551 if (action == HDA_FIXUP_ACT_PROBE)
1552 spec->init_amp = ALC_INIT_NONE;
1555 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1556 const struct hda_fixup *fix, int action)
1558 struct alc_spec *spec = codec->spec;
1559 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1560 spec->gen.add_jack_modes = 1;
1561 spec->gen.hp_mic = 1;
1565 static const struct hda_fixup alc260_fixups[] = {
1566 [ALC260_FIXUP_HP_DC5750] = {
1567 .type = HDA_FIXUP_PINS,
1568 .v.pins = (const struct hda_pintbl[]) {
1569 { 0x11, 0x90130110 }, /* speaker */
1573 [ALC260_FIXUP_HP_PIN_0F] = {
1574 .type = HDA_FIXUP_PINS,
1575 .v.pins = (const struct hda_pintbl[]) {
1576 { 0x0f, 0x01214000 }, /* HP */
1580 [ALC260_FIXUP_COEF] = {
1581 .type = HDA_FIXUP_VERBS,
1582 .v.verbs = (const struct hda_verb[]) {
1583 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1584 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3040 },
1588 [ALC260_FIXUP_GPIO1] = {
1589 .type = HDA_FIXUP_VERBS,
1590 .v.verbs = alc_gpio1_init_verbs,
1592 [ALC260_FIXUP_GPIO1_TOGGLE] = {
1593 .type = HDA_FIXUP_FUNC,
1594 .v.func = alc260_fixup_gpio1_toggle,
1596 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1598 [ALC260_FIXUP_REPLACER] = {
1599 .type = HDA_FIXUP_VERBS,
1600 .v.verbs = (const struct hda_verb[]) {
1601 { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1602 { 0x1a, AC_VERB_SET_PROC_COEF, 0x3050 },
1606 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1608 [ALC260_FIXUP_HP_B1900] = {
1609 .type = HDA_FIXUP_FUNC,
1610 .v.func = alc260_fixup_gpio1_toggle,
1612 .chain_id = ALC260_FIXUP_COEF,
1614 [ALC260_FIXUP_KN1] = {
1615 .type = HDA_FIXUP_FUNC,
1616 .v.func = alc260_fixup_kn1,
1618 [ALC260_FIXUP_FSC_S7020] = {
1619 .type = HDA_FIXUP_FUNC,
1620 .v.func = alc260_fixup_fsc_s7020,
1622 [ALC260_FIXUP_FSC_S7020_JWSE] = {
1623 .type = HDA_FIXUP_FUNC,
1624 .v.func = alc260_fixup_fsc_s7020_jwse,
1626 .chain_id = ALC260_FIXUP_FSC_S7020,
1628 [ALC260_FIXUP_VAIO_PINS] = {
1629 .type = HDA_FIXUP_PINS,
1630 .v.pins = (const struct hda_pintbl[]) {
1631 /* Pin configs are missing completely on some VAIOs */
1632 { 0x0f, 0x01211020 },
1633 { 0x10, 0x0001003f },
1634 { 0x11, 0x411111f0 },
1635 { 0x12, 0x01a15930 },
1636 { 0x13, 0x411111f0 },
1637 { 0x14, 0x411111f0 },
1638 { 0x15, 0x411111f0 },
1639 { 0x16, 0x411111f0 },
1640 { 0x17, 0x411111f0 },
1641 { 0x18, 0x411111f0 },
1642 { 0x19, 0x411111f0 },
1648 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1649 SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1650 SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1651 SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1652 SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1653 SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1654 SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1655 SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1656 SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1657 SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1658 SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1659 SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1660 SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1664 static const struct hda_model_fixup alc260_fixup_models[] = {
1665 {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1666 {.id = ALC260_FIXUP_COEF, .name = "coef"},
1667 {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1668 {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1674 static int patch_alc260(struct hda_codec *codec)
1676 struct alc_spec *spec;
1679 err = alc_alloc_spec(codec, 0x07);
1684 /* as quite a few machines require HP amp for speaker outputs,
1685 * it's easier to enable it unconditionally; even if it's unneeded,
1686 * it's almost harmless.
1688 spec->gen.prefer_hp_amp = 1;
1689 spec->gen.beep_nid = 0x01;
1691 spec->shutup = alc_eapd_shutup;
1693 snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1695 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1697 /* automatic parse from the BIOS config */
1698 err = alc260_parse_auto_config(codec);
1702 if (!spec->gen.no_analog)
1703 set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1705 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1716 * ALC882/883/885/888/889 support
1718 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1719 * configuration. Each pin widget can choose any input DACs and a mixer.
1720 * Each ADC is connected from a mixer of all inputs. This makes possible
1721 * 6-channel independent captures.
1723 * In addition, an independent DAC for the multi-playback (not used in this
1731 ALC882_FIXUP_ABIT_AW9D_MAX,
1732 ALC882_FIXUP_LENOVO_Y530,
1733 ALC882_FIXUP_PB_M5210,
1734 ALC882_FIXUP_ACER_ASPIRE_7736,
1735 ALC882_FIXUP_ASUS_W90V,
1737 ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1738 ALC889_FIXUP_VAIO_TT,
1739 ALC888_FIXUP_EEE1601,
1742 ALC883_FIXUP_ACER_EAPD,
1747 ALC882_FIXUP_ASUS_W2JC,
1748 ALC882_FIXUP_ACER_ASPIRE_4930G,
1749 ALC882_FIXUP_ACER_ASPIRE_8930G,
1750 ALC882_FIXUP_ASPIRE_8930G_VERBS,
1751 ALC885_FIXUP_MACPRO_GPIO,
1752 ALC889_FIXUP_DAC_ROUTE,
1753 ALC889_FIXUP_MBP_VREF,
1754 ALC889_FIXUP_IMAC91_VREF,
1755 ALC889_FIXUP_MBA11_VREF,
1756 ALC889_FIXUP_MBA21_VREF,
1757 ALC889_FIXUP_MP11_VREF,
1758 ALC882_FIXUP_INV_DMIC,
1759 ALC882_FIXUP_NO_PRIMARY_HP,
1760 ALC887_FIXUP_ASUS_BASS,
1761 ALC887_FIXUP_BASS_CHMAP,
1764 static void alc889_fixup_coef(struct hda_codec *codec,
1765 const struct hda_fixup *fix, int action)
1767 if (action != HDA_FIXUP_ACT_INIT)
1769 alc_update_coef_idx(codec, 7, 0, 0x2030);
1772 /* toggle speaker-output according to the hp-jack state */
1773 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
1775 unsigned int gpiostate, gpiomask, gpiodir;
1777 gpiostate = snd_hda_codec_read(codec, codec->core.afg, 0,
1778 AC_VERB_GET_GPIO_DATA, 0);
1781 gpiostate |= (1 << pin);
1783 gpiostate &= ~(1 << pin);
1785 gpiomask = snd_hda_codec_read(codec, codec->core.afg, 0,
1786 AC_VERB_GET_GPIO_MASK, 0);
1787 gpiomask |= (1 << pin);
1789 gpiodir = snd_hda_codec_read(codec, codec->core.afg, 0,
1790 AC_VERB_GET_GPIO_DIRECTION, 0);
1791 gpiodir |= (1 << pin);
1794 snd_hda_codec_write(codec, codec->core.afg, 0,
1795 AC_VERB_SET_GPIO_MASK, gpiomask);
1796 snd_hda_codec_write(codec, codec->core.afg, 0,
1797 AC_VERB_SET_GPIO_DIRECTION, gpiodir);
1801 snd_hda_codec_write(codec, codec->core.afg, 0,
1802 AC_VERB_SET_GPIO_DATA, gpiostate);
1805 /* set up GPIO at initialization */
1806 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1807 const struct hda_fixup *fix, int action)
1809 if (action != HDA_FIXUP_ACT_INIT)
1811 alc882_gpio_mute(codec, 0, 0);
1812 alc882_gpio_mute(codec, 1, 0);
1815 /* Fix the connection of some pins for ALC889:
1816 * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
1817 * work correctly (bko#42740)
1819 static void alc889_fixup_dac_route(struct hda_codec *codec,
1820 const struct hda_fixup *fix, int action)
1822 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1823 /* fake the connections during parsing the tree */
1824 hda_nid_t conn1[2] = { 0x0c, 0x0d };
1825 hda_nid_t conn2[2] = { 0x0e, 0x0f };
1826 snd_hda_override_conn_list(codec, 0x14, 2, conn1);
1827 snd_hda_override_conn_list(codec, 0x15, 2, conn1);
1828 snd_hda_override_conn_list(codec, 0x18, 2, conn2);
1829 snd_hda_override_conn_list(codec, 0x1a, 2, conn2);
1830 } else if (action == HDA_FIXUP_ACT_PROBE) {
1831 /* restore the connections */
1832 hda_nid_t conn[5] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
1833 snd_hda_override_conn_list(codec, 0x14, 5, conn);
1834 snd_hda_override_conn_list(codec, 0x15, 5, conn);
1835 snd_hda_override_conn_list(codec, 0x18, 5, conn);
1836 snd_hda_override_conn_list(codec, 0x1a, 5, conn);
1840 /* Set VREF on HP pin */
1841 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
1842 const struct hda_fixup *fix, int action)
1844 struct alc_spec *spec = codec->spec;
1845 static hda_nid_t nids[2] = { 0x14, 0x15 };
1848 if (action != HDA_FIXUP_ACT_INIT)
1850 for (i = 0; i < ARRAY_SIZE(nids); i++) {
1851 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
1852 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
1854 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1855 val |= AC_PINCTL_VREF_80;
1856 snd_hda_set_pin_ctl(codec, nids[i], val);
1857 spec->gen.keep_vref_in_automute = 1;
1862 static void alc889_fixup_mac_pins(struct hda_codec *codec,
1863 const hda_nid_t *nids, int num_nids)
1865 struct alc_spec *spec = codec->spec;
1868 for (i = 0; i < num_nids; i++) {
1870 val = snd_hda_codec_get_pin_target(codec, nids[i]);
1871 val |= AC_PINCTL_VREF_50;
1872 snd_hda_set_pin_ctl(codec, nids[i], val);
1874 spec->gen.keep_vref_in_automute = 1;
1877 /* Set VREF on speaker pins on imac91 */
1878 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
1879 const struct hda_fixup *fix, int action)
1881 static hda_nid_t nids[2] = { 0x18, 0x1a };
1883 if (action == HDA_FIXUP_ACT_INIT)
1884 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1887 /* Set VREF on speaker pins on mba11 */
1888 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
1889 const struct hda_fixup *fix, int action)
1891 static hda_nid_t nids[1] = { 0x18 };
1893 if (action == HDA_FIXUP_ACT_INIT)
1894 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1897 /* Set VREF on speaker pins on mba21 */
1898 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
1899 const struct hda_fixup *fix, int action)
1901 static hda_nid_t nids[2] = { 0x18, 0x19 };
1903 if (action == HDA_FIXUP_ACT_INIT)
1904 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
1907 /* Don't take HP output as primary
1908 * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
1909 * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
1911 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
1912 const struct hda_fixup *fix, int action)
1914 struct alc_spec *spec = codec->spec;
1915 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1916 spec->gen.no_primary_hp = 1;
1917 spec->gen.no_multi_io = 1;
1921 static void alc_fixup_bass_chmap(struct hda_codec *codec,
1922 const struct hda_fixup *fix, int action);
1924 static const struct hda_fixup alc882_fixups[] = {
1925 [ALC882_FIXUP_ABIT_AW9D_MAX] = {
1926 .type = HDA_FIXUP_PINS,
1927 .v.pins = (const struct hda_pintbl[]) {
1928 { 0x15, 0x01080104 }, /* side */
1929 { 0x16, 0x01011012 }, /* rear */
1930 { 0x17, 0x01016011 }, /* clfe */
1934 [ALC882_FIXUP_LENOVO_Y530] = {
1935 .type = HDA_FIXUP_PINS,
1936 .v.pins = (const struct hda_pintbl[]) {
1937 { 0x15, 0x99130112 }, /* rear int speakers */
1938 { 0x16, 0x99130111 }, /* subwoofer */
1942 [ALC882_FIXUP_PB_M5210] = {
1943 .type = HDA_FIXUP_PINCTLS,
1944 .v.pins = (const struct hda_pintbl[]) {
1945 { 0x19, PIN_VREF50 },
1949 [ALC882_FIXUP_ACER_ASPIRE_7736] = {
1950 .type = HDA_FIXUP_FUNC,
1951 .v.func = alc_fixup_sku_ignore,
1953 [ALC882_FIXUP_ASUS_W90V] = {
1954 .type = HDA_FIXUP_PINS,
1955 .v.pins = (const struct hda_pintbl[]) {
1956 { 0x16, 0x99130110 }, /* fix sequence for CLFE */
1960 [ALC889_FIXUP_CD] = {
1961 .type = HDA_FIXUP_PINS,
1962 .v.pins = (const struct hda_pintbl[]) {
1963 { 0x1c, 0x993301f0 }, /* CD */
1967 [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
1968 .type = HDA_FIXUP_PINS,
1969 .v.pins = (const struct hda_pintbl[]) {
1970 { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
1974 .chain_id = ALC889_FIXUP_CD,
1976 [ALC889_FIXUP_VAIO_TT] = {
1977 .type = HDA_FIXUP_PINS,
1978 .v.pins = (const struct hda_pintbl[]) {
1979 { 0x17, 0x90170111 }, /* hidden surround speaker */
1983 [ALC888_FIXUP_EEE1601] = {
1984 .type = HDA_FIXUP_VERBS,
1985 .v.verbs = (const struct hda_verb[]) {
1986 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
1987 { 0x20, AC_VERB_SET_PROC_COEF, 0x0838 },
1991 [ALC882_FIXUP_EAPD] = {
1992 .type = HDA_FIXUP_VERBS,
1993 .v.verbs = (const struct hda_verb[]) {
1994 /* change to EAPD mode */
1995 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1996 { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2000 [ALC883_FIXUP_EAPD] = {
2001 .type = HDA_FIXUP_VERBS,
2002 .v.verbs = (const struct hda_verb[]) {
2003 /* change to EAPD mode */
2004 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2005 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2009 [ALC883_FIXUP_ACER_EAPD] = {
2010 .type = HDA_FIXUP_VERBS,
2011 .v.verbs = (const struct hda_verb[]) {
2012 /* eanable EAPD on Acer laptops */
2013 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2014 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2018 [ALC882_FIXUP_GPIO1] = {
2019 .type = HDA_FIXUP_VERBS,
2020 .v.verbs = alc_gpio1_init_verbs,
2022 [ALC882_FIXUP_GPIO2] = {
2023 .type = HDA_FIXUP_VERBS,
2024 .v.verbs = alc_gpio2_init_verbs,
2026 [ALC882_FIXUP_GPIO3] = {
2027 .type = HDA_FIXUP_VERBS,
2028 .v.verbs = alc_gpio3_init_verbs,
2030 [ALC882_FIXUP_ASUS_W2JC] = {
2031 .type = HDA_FIXUP_VERBS,
2032 .v.verbs = alc_gpio1_init_verbs,
2034 .chain_id = ALC882_FIXUP_EAPD,
2036 [ALC889_FIXUP_COEF] = {
2037 .type = HDA_FIXUP_FUNC,
2038 .v.func = alc889_fixup_coef,
2040 [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2041 .type = HDA_FIXUP_PINS,
2042 .v.pins = (const struct hda_pintbl[]) {
2043 { 0x16, 0x99130111 }, /* CLFE speaker */
2044 { 0x17, 0x99130112 }, /* surround speaker */
2048 .chain_id = ALC882_FIXUP_GPIO1,
2050 [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2051 .type = HDA_FIXUP_PINS,
2052 .v.pins = (const struct hda_pintbl[]) {
2053 { 0x16, 0x99130111 }, /* CLFE speaker */
2054 { 0x1b, 0x99130112 }, /* surround speaker */
2058 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2060 [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2061 /* additional init verbs for Acer Aspire 8930G */
2062 .type = HDA_FIXUP_VERBS,
2063 .v.verbs = (const struct hda_verb[]) {
2064 /* Enable all DACs */
2065 /* DAC DISABLE/MUTE 1? */
2066 /* setting bits 1-5 disables DAC nids 0x02-0x06
2067 * apparently. Init=0x38 */
2068 { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2069 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2070 /* DAC DISABLE/MUTE 2? */
2071 /* some bit here disables the other DACs.
2073 { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2074 { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2076 * This laptop has a stereo digital microphone.
2077 * The mics are only 1cm apart which makes the stereo
2078 * useless. However, either the mic or the ALC889
2079 * makes the signal become a difference/sum signal
2080 * instead of standard stereo, which is annoying.
2081 * So instead we flip this bit which makes the
2082 * codec replicate the sum signal to both channels,
2083 * turning it into a normal mono mic.
2085 /* DMIC_CONTROL? Init value = 0x0001 */
2086 { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2087 { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2088 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2089 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2093 .chain_id = ALC882_FIXUP_GPIO1,
2095 [ALC885_FIXUP_MACPRO_GPIO] = {
2096 .type = HDA_FIXUP_FUNC,
2097 .v.func = alc885_fixup_macpro_gpio,
2099 [ALC889_FIXUP_DAC_ROUTE] = {
2100 .type = HDA_FIXUP_FUNC,
2101 .v.func = alc889_fixup_dac_route,
2103 [ALC889_FIXUP_MBP_VREF] = {
2104 .type = HDA_FIXUP_FUNC,
2105 .v.func = alc889_fixup_mbp_vref,
2107 .chain_id = ALC882_FIXUP_GPIO1,
2109 [ALC889_FIXUP_IMAC91_VREF] = {
2110 .type = HDA_FIXUP_FUNC,
2111 .v.func = alc889_fixup_imac91_vref,
2113 .chain_id = ALC882_FIXUP_GPIO1,
2115 [ALC889_FIXUP_MBA11_VREF] = {
2116 .type = HDA_FIXUP_FUNC,
2117 .v.func = alc889_fixup_mba11_vref,
2119 .chain_id = ALC889_FIXUP_MBP_VREF,
2121 [ALC889_FIXUP_MBA21_VREF] = {
2122 .type = HDA_FIXUP_FUNC,
2123 .v.func = alc889_fixup_mba21_vref,
2125 .chain_id = ALC889_FIXUP_MBP_VREF,
2127 [ALC889_FIXUP_MP11_VREF] = {
2128 .type = HDA_FIXUP_FUNC,
2129 .v.func = alc889_fixup_mba11_vref,
2131 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2133 [ALC882_FIXUP_INV_DMIC] = {
2134 .type = HDA_FIXUP_FUNC,
2135 .v.func = alc_fixup_inv_dmic,
2137 [ALC882_FIXUP_NO_PRIMARY_HP] = {
2138 .type = HDA_FIXUP_FUNC,
2139 .v.func = alc882_fixup_no_primary_hp,
2141 [ALC887_FIXUP_ASUS_BASS] = {
2142 .type = HDA_FIXUP_PINS,
2143 .v.pins = (const struct hda_pintbl[]) {
2144 {0x16, 0x99130130}, /* bass speaker */
2148 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2150 [ALC887_FIXUP_BASS_CHMAP] = {
2151 .type = HDA_FIXUP_FUNC,
2152 .v.func = alc_fixup_bass_chmap,
2156 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2157 SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2158 SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2159 SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2160 SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2161 SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2162 SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2163 SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2164 SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2165 ALC882_FIXUP_ACER_ASPIRE_4930G),
2166 SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2167 ALC882_FIXUP_ACER_ASPIRE_4930G),
2168 SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2169 ALC882_FIXUP_ACER_ASPIRE_8930G),
2170 SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2171 ALC882_FIXUP_ACER_ASPIRE_8930G),
2172 SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2173 ALC882_FIXUP_ACER_ASPIRE_4930G),
2174 SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2175 ALC882_FIXUP_ACER_ASPIRE_4930G),
2176 SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2177 ALC882_FIXUP_ACER_ASPIRE_4930G),
2178 SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2179 SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2180 ALC882_FIXUP_ACER_ASPIRE_4930G),
2181 SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2182 SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2183 SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2184 SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2185 SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2186 SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2187 SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2188 SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2189 SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2190 SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2191 SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2193 /* All Apple entries are in codec SSIDs */
2194 SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2195 SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2196 SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2197 SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2198 SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2199 SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2200 SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2201 SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2202 SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2203 SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2204 SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2205 SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2206 SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2207 SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2208 SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2209 SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2210 SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2211 SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 5,1", ALC885_FIXUP_MACPRO_GPIO),
2212 SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2213 SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2214 SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2215 SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2217 SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2218 SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2219 SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2220 SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2221 SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2222 SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2223 SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2224 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2225 SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2229 static const struct hda_model_fixup alc882_fixup_models[] = {
2230 {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2231 {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2232 {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2233 {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2234 {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2239 * BIOS auto configuration
2241 /* almost identical with ALC880 parser... */
2242 static int alc882_parse_auto_config(struct hda_codec *codec)
2244 static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2245 static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2246 return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2251 static int patch_alc882(struct hda_codec *codec)
2253 struct alc_spec *spec;
2256 err = alc_alloc_spec(codec, 0x0b);
2262 switch (codec->core.vendor_id) {
2268 /* ALC883 and variants */
2269 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2273 snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2275 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2277 alc_auto_parse_customize_define(codec);
2279 if (has_cdefine_beep(codec))
2280 spec->gen.beep_nid = 0x01;
2282 /* automatic parse from the BIOS config */
2283 err = alc882_parse_auto_config(codec);
2287 if (!spec->gen.no_analog && spec->gen.beep_nid)
2288 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2290 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2303 static int alc262_parse_auto_config(struct hda_codec *codec)
2305 static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2306 static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2307 return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2314 ALC262_FIXUP_FSC_H270,
2315 ALC262_FIXUP_FSC_S7110,
2316 ALC262_FIXUP_HP_Z200,
2318 ALC262_FIXUP_LENOVO_3000,
2320 ALC262_FIXUP_BENQ_T31,
2321 ALC262_FIXUP_INV_DMIC,
2322 ALC262_FIXUP_INTEL_BAYLEYBAY,
2325 static const struct hda_fixup alc262_fixups[] = {
2326 [ALC262_FIXUP_FSC_H270] = {
2327 .type = HDA_FIXUP_PINS,
2328 .v.pins = (const struct hda_pintbl[]) {
2329 { 0x14, 0x99130110 }, /* speaker */
2330 { 0x15, 0x0221142f }, /* front HP */
2331 { 0x1b, 0x0121141f }, /* rear HP */
2335 [ALC262_FIXUP_FSC_S7110] = {
2336 .type = HDA_FIXUP_PINS,
2337 .v.pins = (const struct hda_pintbl[]) {
2338 { 0x15, 0x90170110 }, /* speaker */
2342 .chain_id = ALC262_FIXUP_BENQ,
2344 [ALC262_FIXUP_HP_Z200] = {
2345 .type = HDA_FIXUP_PINS,
2346 .v.pins = (const struct hda_pintbl[]) {
2347 { 0x16, 0x99130120 }, /* internal speaker */
2351 [ALC262_FIXUP_TYAN] = {
2352 .type = HDA_FIXUP_PINS,
2353 .v.pins = (const struct hda_pintbl[]) {
2354 { 0x14, 0x1993e1f0 }, /* int AUX */
2358 [ALC262_FIXUP_LENOVO_3000] = {
2359 .type = HDA_FIXUP_PINCTLS,
2360 .v.pins = (const struct hda_pintbl[]) {
2361 { 0x19, PIN_VREF50 },
2365 .chain_id = ALC262_FIXUP_BENQ,
2367 [ALC262_FIXUP_BENQ] = {
2368 .type = HDA_FIXUP_VERBS,
2369 .v.verbs = (const struct hda_verb[]) {
2370 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2371 { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2375 [ALC262_FIXUP_BENQ_T31] = {
2376 .type = HDA_FIXUP_VERBS,
2377 .v.verbs = (const struct hda_verb[]) {
2378 { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2379 { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2383 [ALC262_FIXUP_INV_DMIC] = {
2384 .type = HDA_FIXUP_FUNC,
2385 .v.func = alc_fixup_inv_dmic,
2387 [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2388 .type = HDA_FIXUP_FUNC,
2389 .v.func = alc_fixup_no_depop_delay,
2393 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2394 SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2395 SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2396 SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2397 SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2398 SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2399 SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2400 SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2401 SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2402 SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2406 static const struct hda_model_fixup alc262_fixup_models[] = {
2407 {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2413 static int patch_alc262(struct hda_codec *codec)
2415 struct alc_spec *spec;
2418 err = alc_alloc_spec(codec, 0x0b);
2423 spec->gen.shared_mic_vref_pin = 0x18;
2425 spec->shutup = alc_eapd_shutup;
2428 /* pshou 07/11/05 set a zero PCM sample to DAC when FIFO is
2431 alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2433 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2435 snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2437 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2439 alc_auto_parse_customize_define(codec);
2441 if (has_cdefine_beep(codec))
2442 spec->gen.beep_nid = 0x01;
2444 /* automatic parse from the BIOS config */
2445 err = alc262_parse_auto_config(codec);
2449 if (!spec->gen.no_analog && spec->gen.beep_nid)
2450 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2452 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2464 /* bind Beep switches of both NID 0x0f and 0x10 */
2465 static const struct hda_bind_ctls alc268_bind_beep_sw = {
2466 .ops = &snd_hda_bind_sw,
2468 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
2469 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
2474 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2475 HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2476 HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
2480 /* set PCBEEP vol = 0, mute connections */
2481 static const struct hda_verb alc268_beep_init_verbs[] = {
2482 {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2483 {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2484 {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2489 ALC268_FIXUP_INV_DMIC,
2490 ALC268_FIXUP_HP_EAPD,
2494 static const struct hda_fixup alc268_fixups[] = {
2495 [ALC268_FIXUP_INV_DMIC] = {
2496 .type = HDA_FIXUP_FUNC,
2497 .v.func = alc_fixup_inv_dmic,
2499 [ALC268_FIXUP_HP_EAPD] = {
2500 .type = HDA_FIXUP_VERBS,
2501 .v.verbs = (const struct hda_verb[]) {
2502 {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
2506 [ALC268_FIXUP_SPDIF] = {
2507 .type = HDA_FIXUP_PINS,
2508 .v.pins = (const struct hda_pintbl[]) {
2509 { 0x1e, 0x014b1180 }, /* enable SPDIF out */
2515 static const struct hda_model_fixup alc268_fixup_models[] = {
2516 {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
2517 {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
2521 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
2522 SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
2523 SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
2524 /* below is codec SSID since multiple Toshiba laptops have the
2525 * same PCI SSID 1179:ff00
2527 SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
2532 * BIOS auto configuration
2534 static int alc268_parse_auto_config(struct hda_codec *codec)
2536 static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2537 return alc_parse_auto_config(codec, NULL, alc268_ssids);
2542 static int patch_alc268(struct hda_codec *codec)
2544 struct alc_spec *spec;
2547 /* ALC268 has no aa-loopback mixer */
2548 err = alc_alloc_spec(codec, 0);
2553 spec->gen.beep_nid = 0x01;
2555 spec->shutup = alc_eapd_shutup;
2557 snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
2558 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2560 /* automatic parse from the BIOS config */
2561 err = alc268_parse_auto_config(codec);
2565 if (err > 0 && !spec->gen.no_analog &&
2566 spec->gen.autocfg.speaker_pins[0] != 0x1d) {
2567 add_mixer(spec, alc268_beep_mixer);
2568 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
2569 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
2570 /* override the amp caps for beep generator */
2571 snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
2572 (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
2573 (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
2574 (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
2575 (0 << AC_AMPCAP_MUTE_SHIFT));
2578 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2591 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
2592 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2595 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
2596 .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
2599 /* different alc269-variants */
2601 ALC269_TYPE_ALC269VA,
2602 ALC269_TYPE_ALC269VB,
2603 ALC269_TYPE_ALC269VC,
2604 ALC269_TYPE_ALC269VD,
2617 * BIOS auto configuration
2619 static int alc269_parse_auto_config(struct hda_codec *codec)
2621 static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
2622 static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
2623 static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2624 struct alc_spec *spec = codec->spec;
2625 const hda_nid_t *ssids;
2627 switch (spec->codec_variant) {
2628 case ALC269_TYPE_ALC269VA:
2629 case ALC269_TYPE_ALC269VC:
2630 case ALC269_TYPE_ALC280:
2631 case ALC269_TYPE_ALC284:
2632 case ALC269_TYPE_ALC285:
2633 ssids = alc269va_ssids;
2635 case ALC269_TYPE_ALC269VB:
2636 case ALC269_TYPE_ALC269VD:
2637 case ALC269_TYPE_ALC282:
2638 case ALC269_TYPE_ALC283:
2639 case ALC269_TYPE_ALC286:
2640 case ALC269_TYPE_ALC298:
2641 case ALC269_TYPE_ALC255:
2642 case ALC269_TYPE_ALC256:
2643 ssids = alc269_ssids;
2646 ssids = alc269_ssids;
2650 return alc_parse_auto_config(codec, alc269_ignore, ssids);
2653 static int find_ext_mic_pin(struct hda_codec *codec);
2655 static void alc286_shutup(struct hda_codec *codec)
2658 int mic_pin = find_ext_mic_pin(codec);
2659 /* don't shut up pins when unloading the driver; otherwise it breaks
2660 * the default pin setup at the next load of the driver
2662 if (codec->bus->shutdown)
2664 for (i = 0; i < codec->init_pins.used; i++) {
2665 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
2666 /* use read here for syncing after issuing each verb */
2667 if (pin->nid != mic_pin)
2668 snd_hda_codec_read(codec, pin->nid, 0,
2669 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
2671 codec->pins_shutup = 1;
2674 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
2676 alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
2679 static void alc269_shutup(struct hda_codec *codec)
2681 struct alc_spec *spec = codec->spec;
2683 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
2684 alc269vb_toggle_power_output(codec, 0);
2685 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
2686 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
2689 snd_hda_shutup_pins(codec);
2692 static struct coef_fw alc282_coefs[] = {
2693 WRITE_COEF(0x03, 0x0002), /* Power Down Control */
2694 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
2695 WRITE_COEF(0x07, 0x0200), /* DMIC control */
2696 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
2697 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
2698 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
2699 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
2700 WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
2701 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
2702 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
2703 WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
2704 UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
2705 WRITE_COEF(0x34, 0xa0c0), /* ANC */
2706 UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
2707 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
2708 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
2709 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
2710 WRITE_COEF(0x63, 0x2902), /* PLL */
2711 WRITE_COEF(0x68, 0xa080), /* capless control 2 */
2712 WRITE_COEF(0x69, 0x3400), /* capless control 3 */
2713 WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
2714 WRITE_COEF(0x6b, 0x0), /* capless control 5 */
2715 UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
2716 WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
2717 UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
2718 WRITE_COEF(0x71, 0x0014), /* class D test 6 */
2719 WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
2720 UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
2721 WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
2725 static void alc282_restore_default_value(struct hda_codec *codec)
2727 alc_process_coef_fw(codec, alc282_coefs);
2730 static void alc282_init(struct hda_codec *codec)
2732 struct alc_spec *spec = codec->spec;
2733 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2737 alc282_restore_default_value(codec);
2741 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2742 coef78 = alc_read_coef_idx(codec, 0x78);
2744 /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
2745 /* Headphone capless set to high power mode */
2746 alc_write_coef_idx(codec, 0x78, 0x9004);
2751 snd_hda_codec_write(codec, hp_pin, 0,
2752 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2757 snd_hda_codec_write(codec, hp_pin, 0,
2758 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
2763 /* Headphone capless set to normal mode */
2764 alc_write_coef_idx(codec, 0x78, coef78);
2767 static void alc282_shutup(struct hda_codec *codec)
2769 struct alc_spec *spec = codec->spec;
2770 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2775 alc269_shutup(codec);
2779 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2780 coef78 = alc_read_coef_idx(codec, 0x78);
2781 alc_write_coef_idx(codec, 0x78, 0x9004);
2786 snd_hda_codec_write(codec, hp_pin, 0,
2787 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2792 snd_hda_codec_write(codec, hp_pin, 0,
2793 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
2798 alc_auto_setup_eapd(codec, false);
2799 snd_hda_shutup_pins(codec);
2800 alc_write_coef_idx(codec, 0x78, coef78);
2803 static struct coef_fw alc283_coefs[] = {
2804 WRITE_COEF(0x03, 0x0002), /* Power Down Control */
2805 UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
2806 WRITE_COEF(0x07, 0x0200), /* DMIC control */
2807 UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
2808 UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
2809 WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
2810 WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
2811 WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
2812 UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
2813 UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
2814 WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
2815 UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
2816 WRITE_COEF(0x22, 0xa0c0), /* ANC */
2817 UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
2818 UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
2819 UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
2820 WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
2821 WRITE_COEF(0x2e, 0x2902), /* PLL */
2822 WRITE_COEF(0x33, 0xa080), /* capless control 2 */
2823 WRITE_COEF(0x34, 0x3400), /* capless control 3 */
2824 WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
2825 WRITE_COEF(0x36, 0x0), /* capless control 5 */
2826 UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
2827 WRITE_COEF(0x39, 0x110a), /* class D test 3 */
2828 UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
2829 WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
2830 WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
2831 UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
2832 WRITE_COEF(0x49, 0x0), /* test mode */
2833 UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
2834 UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
2835 WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
2836 UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
2840 static void alc283_restore_default_value(struct hda_codec *codec)
2842 alc_process_coef_fw(codec, alc283_coefs);
2845 static void alc283_init(struct hda_codec *codec)
2847 struct alc_spec *spec = codec->spec;
2848 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2851 if (!spec->gen.autocfg.hp_outs) {
2852 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
2853 hp_pin = spec->gen.autocfg.line_out_pins[0];
2856 alc283_restore_default_value(codec);
2862 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2864 /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
2865 /* Headphone capless set to high power mode */
2866 alc_write_coef_idx(codec, 0x43, 0x9004);
2868 snd_hda_codec_write(codec, hp_pin, 0,
2869 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2874 snd_hda_codec_write(codec, hp_pin, 0,
2875 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
2879 /* Index 0x46 Combo jack auto switch control 2 */
2880 /* 3k pull low control for Headset jack. */
2881 alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
2882 /* Headphone capless set to normal mode */
2883 alc_write_coef_idx(codec, 0x43, 0x9614);
2886 static void alc283_shutup(struct hda_codec *codec)
2888 struct alc_spec *spec = codec->spec;
2889 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
2892 if (!spec->gen.autocfg.hp_outs) {
2893 if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
2894 hp_pin = spec->gen.autocfg.line_out_pins[0];
2898 alc269_shutup(codec);
2902 hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
2904 alc_write_coef_idx(codec, 0x43, 0x9004);
2906 /*depop hp during suspend*/
2907 alc_write_coef_idx(codec, 0x06, 0x2100);
2909 snd_hda_codec_write(codec, hp_pin, 0,
2910 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
2915 snd_hda_codec_write(codec, hp_pin, 0,
2916 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
2918 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
2922 alc_auto_setup_eapd(codec, false);
2923 snd_hda_shutup_pins(codec);
2924 alc_write_coef_idx(codec, 0x43, 0x9614);
2927 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
2930 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
2931 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
2932 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
2935 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
2939 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
2940 val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
2942 val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
2947 static void alc5505_dsp_halt(struct hda_codec *codec)
2951 alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
2952 alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
2953 alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
2954 alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
2955 alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
2956 alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
2957 alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
2958 val = alc5505_coef_get(codec, 0x6220);
2959 alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
2962 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
2964 alc5505_coef_set(codec, 0x61b8, 0x04133302);
2965 alc5505_coef_set(codec, 0x61b0, 0x00005b16);
2966 alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
2967 alc5505_coef_set(codec, 0x6230, 0xf80d4011);
2968 alc5505_coef_set(codec, 0x6220, 0x2002010f);
2969 alc5505_coef_set(codec, 0x880c, 0x00000004);
2972 static void alc5505_dsp_init(struct hda_codec *codec)
2976 alc5505_dsp_halt(codec);
2977 alc5505_dsp_back_from_halt(codec);
2978 alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
2979 alc5505_coef_set(codec, 0x61b0, 0x5b16);
2980 alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
2981 alc5505_coef_set(codec, 0x61b4, 0x04132b02);
2982 alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
2983 alc5505_coef_set(codec, 0x61b8, 0x041f3302);
2984 snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
2985 alc5505_coef_set(codec, 0x61b8, 0x041b3302);
2986 alc5505_coef_set(codec, 0x61b8, 0x04173302);
2987 alc5505_coef_set(codec, 0x61b8, 0x04163302);
2988 alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
2989 alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
2990 alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
2992 val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
2994 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
2996 alc5505_coef_set(codec, 0x6220, 0x6002018f);
2998 alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
2999 alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
3000 alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
3001 alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
3002 alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
3003 alc5505_coef_set(codec, 0x880c, 0x00000003);
3004 alc5505_coef_set(codec, 0x880c, 0x00000010);
3006 #ifdef HALT_REALTEK_ALC5505
3007 alc5505_dsp_halt(codec);
3011 #ifdef HALT_REALTEK_ALC5505
3012 #define alc5505_dsp_suspend(codec) /* NOP */
3013 #define alc5505_dsp_resume(codec) /* NOP */
3015 #define alc5505_dsp_suspend(codec) alc5505_dsp_halt(codec)
3016 #define alc5505_dsp_resume(codec) alc5505_dsp_back_from_halt(codec)
3020 static int alc269_suspend(struct hda_codec *codec)
3022 struct alc_spec *spec = codec->spec;
3024 if (spec->has_alc5505_dsp)
3025 alc5505_dsp_suspend(codec);
3026 return alc_suspend(codec);
3029 static int alc269_resume(struct hda_codec *codec)
3031 struct alc_spec *spec = codec->spec;
3033 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3034 alc269vb_toggle_power_output(codec, 0);
3035 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3036 (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3040 codec->patch_ops.init(codec);
3042 if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3043 alc269vb_toggle_power_output(codec, 1);
3044 if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3045 (alc_get_coef0(codec) & 0x00ff) == 0x017) {
3049 regcache_sync(codec->core.regmap);
3050 hda_call_check_power_status(codec, 0x01);
3052 /* on some machine, the BIOS will clear the codec gpio data when enter
3053 * suspend, and won't restore the data after resume, so we restore it
3057 snd_hda_codec_write(codec, codec->core.afg, 0, AC_VERB_SET_GPIO_DATA,
3060 if (spec->has_alc5505_dsp)
3061 alc5505_dsp_resume(codec);
3065 #endif /* CONFIG_PM */
3067 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
3068 const struct hda_fixup *fix, int action)
3070 struct alc_spec *spec = codec->spec;
3072 if (action == HDA_FIXUP_ACT_PRE_PROBE)
3073 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
3076 static void alc269_fixup_hweq(struct hda_codec *codec,
3077 const struct hda_fixup *fix, int action)
3079 if (action == HDA_FIXUP_ACT_INIT)
3080 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
3083 static void alc269_fixup_headset_mic(struct hda_codec *codec,
3084 const struct hda_fixup *fix, int action)
3086 struct alc_spec *spec = codec->spec;
3088 if (action == HDA_FIXUP_ACT_PRE_PROBE)
3089 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3092 static void alc271_fixup_dmic(struct hda_codec *codec,
3093 const struct hda_fixup *fix, int action)
3095 static const struct hda_verb verbs[] = {
3096 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
3097 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
3102 if (strcmp(codec->core.chip_name, "ALC271X") &&
3103 strcmp(codec->core.chip_name, "ALC269VB"))
3105 cfg = snd_hda_codec_get_pincfg(codec, 0x12);
3106 if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
3107 snd_hda_sequence_write(codec, verbs);
3110 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
3111 const struct hda_fixup *fix, int action)
3113 struct alc_spec *spec = codec->spec;
3115 if (action != HDA_FIXUP_ACT_PROBE)
3118 /* Due to a hardware problem on Lenovo Ideadpad, we need to
3119 * fix the sample rate of analog I/O to 44.1kHz
3121 spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
3122 spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
3125 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
3126 const struct hda_fixup *fix, int action)
3128 /* The digital-mic unit sends PDM (differential signal) instead of
3129 * the standard PCM, thus you can't record a valid mono stream as is.
3130 * Below is a workaround specific to ALC269 to control the dmic
3131 * signal source as mono.
3133 if (action == HDA_FIXUP_ACT_INIT)
3134 alc_update_coef_idx(codec, 0x07, 0, 0x80);
3137 static void alc269_quanta_automute(struct hda_codec *codec)
3139 snd_hda_gen_update_outputs(codec);
3141 alc_write_coef_idx(codec, 0x0c, 0x680);
3142 alc_write_coef_idx(codec, 0x0c, 0x480);
3145 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
3146 const struct hda_fixup *fix, int action)
3148 struct alc_spec *spec = codec->spec;
3149 if (action != HDA_FIXUP_ACT_PROBE)
3151 spec->gen.automute_hook = alc269_quanta_automute;
3154 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
3155 struct hda_jack_callback *jack)
3157 struct alc_spec *spec = codec->spec;
3160 snd_hda_gen_hp_automute(codec, jack);
3162 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
3164 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3167 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3171 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
3172 const struct hda_fixup *fix, int action)
3174 struct alc_spec *spec = codec->spec;
3175 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3176 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
3177 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
3182 /* update mute-LED according to the speaker mute state via mic VREF pin */
3183 static void alc269_fixup_mic_mute_hook(void *private_data, int enabled)
3185 struct hda_codec *codec = private_data;
3186 struct alc_spec *spec = codec->spec;
3187 unsigned int pinval;
3189 if (spec->mute_led_polarity)
3191 pinval = snd_hda_codec_get_pin_target(codec, spec->mute_led_nid);
3192 pinval &= ~AC_PINCTL_VREFEN;
3193 pinval |= enabled ? AC_PINCTL_VREF_HIZ : AC_PINCTL_VREF_80;
3194 if (spec->mute_led_nid)
3195 snd_hda_set_pin_ctl_cache(codec, spec->mute_led_nid, pinval);
3198 /* Make sure the led works even in runtime suspend */
3199 static unsigned int led_power_filter(struct hda_codec *codec,
3201 unsigned int power_state)
3203 struct alc_spec *spec = codec->spec;
3205 if (power_state != AC_PWRST_D3 || nid == 0 ||
3206 (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
3209 /* Set pin ctl again, it might have just been set to 0 */
3210 snd_hda_set_pin_ctl(codec, nid,
3211 snd_hda_codec_get_pin_target(codec, nid));
3213 return snd_hda_gen_path_power_filter(codec, nid, power_state);
3216 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
3217 const struct hda_fixup *fix, int action)
3219 struct alc_spec *spec = codec->spec;
3220 const struct dmi_device *dev = NULL;
3222 if (action != HDA_FIXUP_ACT_PRE_PROBE)
3225 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
3227 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
3229 if (pin < 0x0a || pin >= 0x10)
3231 spec->mute_led_polarity = pol;
3232 spec->mute_led_nid = pin - 0x0a + 0x18;
3233 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3234 spec->gen.vmaster_mute_enum = 1;
3235 codec->power_filter = led_power_filter;
3237 "Detected mute LED for %x:%d\n", spec->mute_led_nid,
3238 spec->mute_led_polarity);
3243 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
3244 const struct hda_fixup *fix, int action)
3246 struct alc_spec *spec = codec->spec;
3247 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3248 spec->mute_led_polarity = 0;
3249 spec->mute_led_nid = 0x18;
3250 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3251 spec->gen.vmaster_mute_enum = 1;
3252 codec->power_filter = led_power_filter;
3256 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
3257 const struct hda_fixup *fix, int action)
3259 struct alc_spec *spec = codec->spec;
3260 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3261 spec->mute_led_polarity = 0;
3262 spec->mute_led_nid = 0x19;
3263 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3264 spec->gen.vmaster_mute_enum = 1;
3265 codec->power_filter = led_power_filter;
3269 /* update LED status via GPIO */
3270 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
3273 struct alc_spec *spec = codec->spec;
3274 unsigned int oldval = spec->gpio_led;
3276 if (spec->mute_led_polarity)
3280 spec->gpio_led &= ~mask;
3282 spec->gpio_led |= mask;
3283 if (spec->gpio_led != oldval)
3284 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
3288 /* turn on/off mute LED via GPIO per vmaster hook */
3289 static void alc_fixup_gpio_mute_hook(void *private_data, int enabled)
3291 struct hda_codec *codec = private_data;
3292 struct alc_spec *spec = codec->spec;
3294 alc_update_gpio_led(codec, spec->gpio_mute_led_mask, enabled);
3297 /* turn on/off mic-mute LED via GPIO per capture hook */
3298 static void alc_fixup_gpio_mic_mute_hook(struct hda_codec *codec,
3299 struct snd_kcontrol *kcontrol,
3300 struct snd_ctl_elem_value *ucontrol)
3302 struct alc_spec *spec = codec->spec;
3305 alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
3306 ucontrol->value.integer.value[0] ||
3307 ucontrol->value.integer.value[1]);
3310 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
3311 const struct hda_fixup *fix, int action)
3313 struct alc_spec *spec = codec->spec;
3314 static const struct hda_verb gpio_init[] = {
3315 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
3316 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
3320 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3321 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3322 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3324 spec->mute_led_polarity = 0;
3325 spec->gpio_mute_led_mask = 0x08;
3326 spec->gpio_mic_led_mask = 0x10;
3327 snd_hda_add_verbs(codec, gpio_init);
3331 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
3332 const struct hda_fixup *fix, int action)
3334 struct alc_spec *spec = codec->spec;
3335 static const struct hda_verb gpio_init[] = {
3336 { 0x01, AC_VERB_SET_GPIO_MASK, 0x22 },
3337 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x22 },
3341 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3342 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3343 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3345 spec->mute_led_polarity = 0;
3346 spec->gpio_mute_led_mask = 0x02;
3347 spec->gpio_mic_led_mask = 0x20;
3348 snd_hda_add_verbs(codec, gpio_init);
3352 /* turn on/off mic-mute LED per capture hook */
3353 static void alc269_fixup_hp_cap_mic_mute_hook(struct hda_codec *codec,
3354 struct snd_kcontrol *kcontrol,
3355 struct snd_ctl_elem_value *ucontrol)
3357 struct alc_spec *spec = codec->spec;
3358 unsigned int pinval, enable, disable;
3360 pinval = snd_hda_codec_get_pin_target(codec, spec->cap_mute_led_nid);
3361 pinval &= ~AC_PINCTL_VREFEN;
3362 enable = pinval | AC_PINCTL_VREF_80;
3363 disable = pinval | AC_PINCTL_VREF_HIZ;
3368 if (ucontrol->value.integer.value[0] ||
3369 ucontrol->value.integer.value[1])
3374 if (spec->cap_mute_led_nid)
3375 snd_hda_set_pin_ctl_cache(codec, spec->cap_mute_led_nid, pinval);
3378 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
3379 const struct hda_fixup *fix, int action)
3381 struct alc_spec *spec = codec->spec;
3382 static const struct hda_verb gpio_init[] = {
3383 { 0x01, AC_VERB_SET_GPIO_MASK, 0x08 },
3384 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x08 },
3388 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3389 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3390 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
3392 spec->mute_led_polarity = 0;
3393 spec->gpio_mute_led_mask = 0x08;
3394 spec->cap_mute_led_nid = 0x18;
3395 snd_hda_add_verbs(codec, gpio_init);
3396 codec->power_filter = led_power_filter;
3400 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
3401 const struct hda_fixup *fix, int action)
3403 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to enable headphone amp */
3404 struct alc_spec *spec = codec->spec;
3405 static const struct hda_verb gpio_init[] = {
3406 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
3407 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
3411 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3412 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3413 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
3415 spec->mute_led_polarity = 0;
3416 spec->gpio_mute_led_mask = 0x08;
3417 spec->cap_mute_led_nid = 0x18;
3418 snd_hda_add_verbs(codec, gpio_init);
3419 codec->power_filter = led_power_filter;
3423 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
3424 struct hda_jack_callback *event)
3426 struct alc_spec *spec = codec->spec;
3428 /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
3429 send both key on and key off event for every interrupt. */
3430 input_report_key(spec->kb_dev, KEY_MICMUTE, 1);
3431 input_sync(spec->kb_dev);
3432 input_report_key(spec->kb_dev, KEY_MICMUTE, 0);
3433 input_sync(spec->kb_dev);
3436 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
3437 const struct hda_fixup *fix, int action)
3439 /* GPIO1 = set according to SKU external amp
3440 GPIO2 = mic mute hotkey
3442 GPIO4 = mic mute LED */
3443 static const struct hda_verb gpio_init[] = {
3444 { 0x01, AC_VERB_SET_GPIO_MASK, 0x1e },
3445 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x1a },
3446 { 0x01, AC_VERB_SET_GPIO_DATA, 0x02 },
3450 struct alc_spec *spec = codec->spec;
3452 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3453 spec->kb_dev = input_allocate_device();
3454 if (!spec->kb_dev) {
3455 codec_err(codec, "Out of memory (input_allocate_device)\n");
3458 spec->kb_dev->name = "Microphone Mute Button";
3459 spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
3460 spec->kb_dev->keybit[BIT_WORD(KEY_MICMUTE)] = BIT_MASK(KEY_MICMUTE);
3461 if (input_register_device(spec->kb_dev)) {
3462 codec_err(codec, "input_register_device failed\n");
3463 input_free_device(spec->kb_dev);
3464 spec->kb_dev = NULL;
3468 snd_hda_add_verbs(codec, gpio_init);
3469 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
3470 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
3471 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
3472 gpio2_mic_hotkey_event);
3474 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
3475 spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
3477 spec->mute_led_polarity = 0;
3478 spec->gpio_mute_led_mask = 0x08;
3479 spec->gpio_mic_led_mask = 0x10;
3487 case HDA_FIXUP_ACT_PROBE:
3488 spec->init_amp = ALC_INIT_DEFAULT;
3490 case HDA_FIXUP_ACT_FREE:
3491 input_unregister_device(spec->kb_dev);
3492 spec->kb_dev = NULL;
3496 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
3497 const struct hda_fixup *fix, int action)
3499 struct alc_spec *spec = codec->spec;
3501 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3502 spec->gen.vmaster_mute.hook = alc269_fixup_mic_mute_hook;
3503 spec->gen.cap_sync_hook = alc269_fixup_hp_cap_mic_mute_hook;
3504 spec->mute_led_polarity = 0;
3505 spec->mute_led_nid = 0x1a;
3506 spec->cap_mute_led_nid = 0x18;
3507 spec->gen.vmaster_mute_enum = 1;
3508 codec->power_filter = led_power_filter;
3512 static void alc_headset_mode_unplugged(struct hda_codec *codec)
3514 static struct coef_fw coef0255[] = {
3515 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
3516 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
3517 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
3518 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
3519 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
3522 static struct coef_fw coef0233[] = {
3523 WRITE_COEF(0x1b, 0x0c0b),
3524 WRITE_COEF(0x45, 0xc429),
3525 UPDATE_COEF(0x35, 0x4000, 0),
3526 WRITE_COEF(0x06, 0x2104),
3527 WRITE_COEF(0x1a, 0x0001),
3528 WRITE_COEF(0x26, 0x0004),
3529 WRITE_COEF(0x32, 0x42a3),
3532 static struct coef_fw coef0288[] = {
3533 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
3534 UPDATE_COEF(0x50, 0x2000, 0x2000),
3535 UPDATE_COEF(0x56, 0x0006, 0x0006),
3536 UPDATE_COEF(0x66, 0x0008, 0),
3537 UPDATE_COEF(0x67, 0x2000, 0),
3540 static struct coef_fw coef0292[] = {
3541 WRITE_COEF(0x76, 0x000e),
3542 WRITE_COEF(0x6c, 0x2400),
3543 WRITE_COEF(0x18, 0x7308),
3544 WRITE_COEF(0x6b, 0xc429),
3547 static struct coef_fw coef0293[] = {
3548 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
3549 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
3550 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
3551 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
3552 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
3553 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
3556 static struct coef_fw coef0668[] = {
3557 WRITE_COEF(0x15, 0x0d40),
3558 WRITE_COEF(0xb7, 0x802b),
3562 switch (codec->core.vendor_id) {
3565 alc_process_coef_fw(codec, coef0255);
3569 alc_process_coef_fw(codec, coef0233);
3574 alc_process_coef_fw(codec, coef0288);
3577 alc_process_coef_fw(codec, coef0292);
3580 alc_process_coef_fw(codec, coef0293);
3583 alc_process_coef_fw(codec, coef0668);
3586 codec_dbg(codec, "Headset jack set to unplugged mode.\n");
3590 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
3593 static struct coef_fw coef0255[] = {
3594 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
3595 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
3598 static struct coef_fw coef0233[] = {
3599 UPDATE_COEF(0x35, 0, 1<<14),
3600 WRITE_COEF(0x06, 0x2100),
3601 WRITE_COEF(0x1a, 0x0021),
3602 WRITE_COEF(0x26, 0x008c),
3605 static struct coef_fw coef0288[] = {
3606 UPDATE_COEF(0x50, 0x2000, 0),
3607 UPDATE_COEF(0x56, 0x0006, 0),
3608 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
3609 UPDATE_COEF(0x66, 0x0008, 0x0008),
3610 UPDATE_COEF(0x67, 0x2000, 0x2000),
3613 static struct coef_fw coef0292[] = {
3614 WRITE_COEF(0x19, 0xa208),
3615 WRITE_COEF(0x2e, 0xacf0),
3618 static struct coef_fw coef0293[] = {
3619 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
3620 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
3621 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
3624 static struct coef_fw coef0688[] = {
3625 WRITE_COEF(0xb7, 0x802b),
3626 WRITE_COEF(0xb5, 0x1040),
3627 UPDATE_COEF(0xc3, 0, 1<<12),
3631 switch (codec->core.vendor_id) {
3634 alc_write_coef_idx(codec, 0x45, 0xc489);
3635 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3636 alc_process_coef_fw(codec, coef0255);
3637 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3641 alc_write_coef_idx(codec, 0x45, 0xc429);
3642 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3643 alc_process_coef_fw(codec, coef0233);
3644 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3649 alc_update_coef_idx(codec, 0x4f, 0x000c, 0);
3650 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3651 alc_process_coef_fw(codec, coef0288);
3652 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3655 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3656 alc_process_coef_fw(codec, coef0292);
3659 /* Set to TRS mode */
3660 alc_write_coef_idx(codec, 0x45, 0xc429);
3661 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3662 alc_process_coef_fw(codec, coef0293);
3663 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3666 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3667 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3670 alc_write_coef_idx(codec, 0x11, 0x0001);
3671 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
3672 alc_process_coef_fw(codec, coef0688);
3673 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
3676 codec_dbg(codec, "Headset jack set to mic-in mode.\n");
3679 static void alc_headset_mode_default(struct hda_codec *codec)
3681 static struct coef_fw coef0255[] = {
3682 WRITE_COEF(0x45, 0xc089),
3683 WRITE_COEF(0x45, 0xc489),
3684 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
3685 WRITE_COEF(0x49, 0x0049),
3688 static struct coef_fw coef0233[] = {
3689 WRITE_COEF(0x06, 0x2100),
3690 WRITE_COEF(0x32, 0x4ea3),
3693 static struct coef_fw coef0288[] = {
3694 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
3695 UPDATE_COEF(0x50, 0x2000, 0x2000),
3696 UPDATE_COEF(0x56, 0x0006, 0x0006),
3697 UPDATE_COEF(0x66, 0x0008, 0),
3698 UPDATE_COEF(0x67, 0x2000, 0),
3701 static struct coef_fw coef0292[] = {
3702 WRITE_COEF(0x76, 0x000e),
3703 WRITE_COEF(0x6c, 0x2400),
3704 WRITE_COEF(0x6b, 0xc429),
3705 WRITE_COEF(0x18, 0x7308),
3708 static struct coef_fw coef0293[] = {
3709 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
3710 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
3711 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
3714 static struct coef_fw coef0688[] = {
3715 WRITE_COEF(0x11, 0x0041),
3716 WRITE_COEF(0x15, 0x0d40),
3717 WRITE_COEF(0xb7, 0x802b),
3721 switch (codec->core.vendor_id) {
3724 alc_process_coef_fw(codec, coef0255);
3728 alc_process_coef_fw(codec, coef0233);
3733 alc_process_coef_fw(codec, coef0288);
3736 alc_process_coef_fw(codec, coef0292);
3739 alc_process_coef_fw(codec, coef0293);
3742 alc_process_coef_fw(codec, coef0688);
3745 codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
3749 static void alc_headset_mode_ctia(struct hda_codec *codec)
3751 static struct coef_fw coef0255[] = {
3752 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
3753 WRITE_COEF(0x1b, 0x0c2b),
3754 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
3757 static struct coef_fw coef0233[] = {
3758 WRITE_COEF(0x45, 0xd429),
3759 WRITE_COEF(0x1b, 0x0c2b),
3760 WRITE_COEF(0x32, 0x4ea3),
3763 static struct coef_fw coef0288[] = {
3764 UPDATE_COEF(0x50, 0x2000, 0x2000),
3765 UPDATE_COEF(0x56, 0x0006, 0x0006),
3766 UPDATE_COEF(0x66, 0x0008, 0),
3767 UPDATE_COEF(0x67, 0x2000, 0),
3770 static struct coef_fw coef0292[] = {
3771 WRITE_COEF(0x6b, 0xd429),
3772 WRITE_COEF(0x76, 0x0008),
3773 WRITE_COEF(0x18, 0x7388),
3776 static struct coef_fw coef0293[] = {
3777 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
3778 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
3781 static struct coef_fw coef0688[] = {
3782 WRITE_COEF(0x11, 0x0001),
3783 WRITE_COEF(0x15, 0x0d60),
3784 WRITE_COEF(0xc3, 0x0000),
3788 switch (codec->core.vendor_id) {
3791 alc_process_coef_fw(codec, coef0255);
3795 alc_process_coef_fw(codec, coef0233);
3798 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);/* Headset output enable */
3799 /* ALC298 jack type setting is the same with ALC286/ALC288 */
3802 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
3804 alc_process_coef_fw(codec, coef0288);
3807 alc_process_coef_fw(codec, coef0292);
3810 alc_process_coef_fw(codec, coef0293);
3813 alc_process_coef_fw(codec, coef0688);
3816 codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
3820 static void alc_headset_mode_omtp(struct hda_codec *codec)
3822 static struct coef_fw coef0255[] = {
3823 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
3824 WRITE_COEF(0x1b, 0x0c2b),
3825 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
3828 static struct coef_fw coef0233[] = {
3829 WRITE_COEF(0x45, 0xe429),
3830 WRITE_COEF(0x1b, 0x0c2b),
3831 WRITE_COEF(0x32, 0x4ea3),
3834 static struct coef_fw coef0288[] = {
3835 UPDATE_COEF(0x50, 0x2000, 0x2000),
3836 UPDATE_COEF(0x56, 0x0006, 0x0006),
3837 UPDATE_COEF(0x66, 0x0008, 0),
3838 UPDATE_COEF(0x67, 0x2000, 0),
3841 static struct coef_fw coef0292[] = {
3842 WRITE_COEF(0x6b, 0xe429),
3843 WRITE_COEF(0x76, 0x0008),
3844 WRITE_COEF(0x18, 0x7388),
3847 static struct coef_fw coef0293[] = {
3848 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
3849 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
3852 static struct coef_fw coef0688[] = {
3853 WRITE_COEF(0x11, 0x0001),
3854 WRITE_COEF(0x15, 0x0d50),
3855 WRITE_COEF(0xc3, 0x0000),
3859 switch (codec->core.vendor_id) {
3862 alc_process_coef_fw(codec, coef0255);
3866 alc_process_coef_fw(codec, coef0233);
3869 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
3870 /* ALC298 jack type setting is the same with ALC286/ALC288 */
3873 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
3875 alc_process_coef_fw(codec, coef0288);
3878 alc_process_coef_fw(codec, coef0292);
3881 alc_process_coef_fw(codec, coef0293);
3884 alc_process_coef_fw(codec, coef0688);
3887 codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
3890 static void alc_determine_headset_type(struct hda_codec *codec)
3893 bool is_ctia = false;
3894 struct alc_spec *spec = codec->spec;
3895 static struct coef_fw coef0255[] = {
3896 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
3897 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
3901 static struct coef_fw coef0288[] = {
3902 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
3905 static struct coef_fw coef0293[] = {
3906 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
3907 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
3910 static struct coef_fw coef0688[] = {
3911 WRITE_COEF(0x11, 0x0001),
3912 WRITE_COEF(0xb7, 0x802b),
3913 WRITE_COEF(0x15, 0x0d60),
3914 WRITE_COEF(0xc3, 0x0c00),
3918 switch (codec->core.vendor_id) {
3921 alc_process_coef_fw(codec, coef0255);
3923 val = alc_read_coef_idx(codec, 0x46);
3924 is_ctia = (val & 0x0070) == 0x0070;
3928 alc_write_coef_idx(codec, 0x45, 0xd029);
3930 val = alc_read_coef_idx(codec, 0x46);
3931 is_ctia = (val & 0x0070) == 0x0070;
3934 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020); /* Headset output enable */
3935 /* ALC298 check jack type is the same with ALC286/ALC288 */
3938 alc_process_coef_fw(codec, coef0288);
3940 val = alc_read_coef_idx(codec, 0x50);
3941 is_ctia = (val & 0x0070) == 0x0070;
3944 alc_write_coef_idx(codec, 0x6b, 0xd429);
3946 val = alc_read_coef_idx(codec, 0x6c);
3947 is_ctia = (val & 0x001c) == 0x001c;
3950 alc_process_coef_fw(codec, coef0293);
3952 val = alc_read_coef_idx(codec, 0x46);
3953 is_ctia = (val & 0x0070) == 0x0070;
3956 alc_process_coef_fw(codec, coef0688);
3958 val = alc_read_coef_idx(codec, 0xbe);
3959 is_ctia = (val & 0x1c02) == 0x1c02;
3963 codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
3964 is_ctia ? "yes" : "no");
3965 spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
3968 static void alc_update_headset_mode(struct hda_codec *codec)
3970 struct alc_spec *spec = codec->spec;
3972 hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
3973 hda_nid_t hp_pin = spec->gen.autocfg.hp_pins[0];
3975 int new_headset_mode;
3977 if (!snd_hda_jack_detect(codec, hp_pin))
3978 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
3979 else if (mux_pin == spec->headset_mic_pin)
3980 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
3981 else if (mux_pin == spec->headphone_mic_pin)
3982 new_headset_mode = ALC_HEADSET_MODE_MIC;
3984 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
3986 if (new_headset_mode == spec->current_headset_mode) {
3987 snd_hda_gen_update_outputs(codec);
3991 switch (new_headset_mode) {
3992 case ALC_HEADSET_MODE_UNPLUGGED:
3993 alc_headset_mode_unplugged(codec);
3994 spec->gen.hp_jack_present = false;
3996 case ALC_HEADSET_MODE_HEADSET:
3997 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
3998 alc_determine_headset_type(codec);
3999 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
4000 alc_headset_mode_ctia(codec);
4001 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
4002 alc_headset_mode_omtp(codec);
4003 spec->gen.hp_jack_present = true;
4005 case ALC_HEADSET_MODE_MIC:
4006 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
4007 spec->gen.hp_jack_present = false;
4009 case ALC_HEADSET_MODE_HEADPHONE:
4010 alc_headset_mode_default(codec);
4011 spec->gen.hp_jack_present = true;
4014 if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
4015 snd_hda_set_pin_ctl_cache(codec, hp_pin,
4016 AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
4017 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
4018 snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
4021 spec->current_headset_mode = new_headset_mode;
4023 snd_hda_gen_update_outputs(codec);
4026 static void alc_update_headset_mode_hook(struct hda_codec *codec,
4027 struct snd_kcontrol *kcontrol,
4028 struct snd_ctl_elem_value *ucontrol)
4030 alc_update_headset_mode(codec);
4033 static void alc_update_headset_jack_cb(struct hda_codec *codec,
4034 struct hda_jack_callback *jack)
4036 struct alc_spec *spec = codec->spec;
4037 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
4038 snd_hda_gen_hp_automute(codec, jack);
4041 static void alc_probe_headset_mode(struct hda_codec *codec)
4044 struct alc_spec *spec = codec->spec;
4045 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
4048 for (i = 0; i < cfg->num_inputs; i++) {
4049 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
4050 spec->headset_mic_pin = cfg->inputs[i].pin;
4051 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
4052 spec->headphone_mic_pin = cfg->inputs[i].pin;
4055 spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
4056 spec->gen.automute_hook = alc_update_headset_mode;
4057 spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
4060 static void alc_fixup_headset_mode(struct hda_codec *codec,
4061 const struct hda_fixup *fix, int action)
4063 struct alc_spec *spec = codec->spec;
4066 case HDA_FIXUP_ACT_PRE_PROBE:
4067 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
4069 case HDA_FIXUP_ACT_PROBE:
4070 alc_probe_headset_mode(codec);
4072 case HDA_FIXUP_ACT_INIT:
4073 spec->current_headset_mode = 0;
4074 alc_update_headset_mode(codec);
4079 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
4080 const struct hda_fixup *fix, int action)
4082 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4083 struct alc_spec *spec = codec->spec;
4084 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4087 alc_fixup_headset_mode(codec, fix, action);
4090 static void alc255_set_default_jack_type(struct hda_codec *codec)
4092 /* Set to iphone type */
4093 static struct coef_fw fw[] = {
4094 WRITE_COEF(0x1b, 0x880b),
4095 WRITE_COEF(0x45, 0xd089),
4096 WRITE_COEF(0x1b, 0x080b),
4097 WRITE_COEF(0x46, 0x0004),
4098 WRITE_COEF(0x1b, 0x0c0b),
4101 alc_process_coef_fw(codec, fw);
4105 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
4106 const struct hda_fixup *fix, int action)
4108 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4109 alc255_set_default_jack_type(codec);
4111 alc_fixup_headset_mode(codec, fix, action);
4114 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
4115 const struct hda_fixup *fix, int action)
4117 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4118 struct alc_spec *spec = codec->spec;
4119 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4120 alc255_set_default_jack_type(codec);
4123 alc_fixup_headset_mode(codec, fix, action);
4126 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
4127 struct hda_jack_callback *jack)
4129 struct alc_spec *spec = codec->spec;
4132 alc_update_headset_jack_cb(codec, jack);
4133 /* Headset Mic enable or disable, only for Dell Dino */
4134 present = spec->gen.hp_jack_present ? 0x40 : 0;
4135 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
4139 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
4140 const struct hda_fixup *fix, int action)
4142 alc_fixup_headset_mode(codec, fix, action);
4143 if (action == HDA_FIXUP_ACT_PROBE) {
4144 struct alc_spec *spec = codec->spec;
4145 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
4149 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
4150 const struct hda_fixup *fix, int action)
4152 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4153 struct alc_spec *spec = codec->spec;
4154 spec->gen.auto_mute_via_amp = 1;
4158 static void alc_no_shutup(struct hda_codec *codec)
4162 static void alc_fixup_no_shutup(struct hda_codec *codec,
4163 const struct hda_fixup *fix, int action)
4165 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4166 struct alc_spec *spec = codec->spec;
4167 spec->shutup = alc_no_shutup;
4171 static void alc_fixup_disable_aamix(struct hda_codec *codec,
4172 const struct hda_fixup *fix, int action)
4174 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4175 struct alc_spec *spec = codec->spec;
4176 /* Disable AA-loopback as it causes white noise */
4177 spec->gen.mixer_nid = 0;
4181 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
4182 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
4183 const struct hda_fixup *fix, int action)
4185 static const struct hda_pintbl pincfgs[] = {
4186 { 0x16, 0x21211010 }, /* dock headphone */
4187 { 0x19, 0x21a11010 }, /* dock mic */
4190 struct alc_spec *spec = codec->spec;
4192 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4193 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4194 codec->power_save_node = 0; /* avoid click noises */
4195 snd_hda_apply_pincfgs(codec, pincfgs);
4199 static void alc_shutup_dell_xps13(struct hda_codec *codec)
4201 struct alc_spec *spec = codec->spec;
4202 int hp_pin = spec->gen.autocfg.hp_pins[0];
4204 /* Prevent pop noises when headphones are plugged in */
4205 snd_hda_codec_write(codec, hp_pin, 0,
4206 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
4210 static void alc_fixup_dell_xps13(struct hda_codec *codec,
4211 const struct hda_fixup *fix, int action)
4213 struct alc_spec *spec = codec->spec;
4214 struct hda_input_mux *imux = &spec->gen.input_mux;
4218 case HDA_FIXUP_ACT_PRE_PROBE:
4219 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
4220 * it causes a click noise at start up
4222 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
4224 case HDA_FIXUP_ACT_PROBE:
4225 spec->shutup = alc_shutup_dell_xps13;
4227 /* Make the internal mic the default input source. */
4228 for (i = 0; i < imux->num_items; i++) {
4229 if (spec->gen.imux_pins[i] == 0x12) {
4230 spec->gen.cur_mux[0] = i;
4238 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
4239 const struct hda_fixup *fix, int action)
4241 struct alc_spec *spec = codec->spec;
4243 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4244 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4245 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
4247 /* Disable boost for mic-in permanently. (This code is only called
4248 from quirks that guarantee that the headphone is at NID 0x1b.) */
4249 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
4250 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
4252 alc_fixup_headset_mode(codec, fix, action);
4255 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
4256 const struct hda_fixup *fix, int action)
4258 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4259 alc_write_coef_idx(codec, 0xc4, 0x8000);
4260 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
4261 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
4263 alc_fixup_headset_mode(codec, fix, action);
4266 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
4267 static int find_ext_mic_pin(struct hda_codec *codec)
4269 struct alc_spec *spec = codec->spec;
4270 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
4272 unsigned int defcfg;
4275 for (i = 0; i < cfg->num_inputs; i++) {
4276 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4278 nid = cfg->inputs[i].pin;
4279 defcfg = snd_hda_codec_get_pincfg(codec, nid);
4280 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
4288 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
4289 const struct hda_fixup *fix,
4292 struct alc_spec *spec = codec->spec;
4294 if (action == HDA_FIXUP_ACT_PROBE) {
4295 int mic_pin = find_ext_mic_pin(codec);
4296 int hp_pin = spec->gen.autocfg.hp_pins[0];
4298 if (snd_BUG_ON(!mic_pin || !hp_pin))
4300 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
4304 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
4305 const struct hda_fixup *fix,
4308 struct alc_spec *spec = codec->spec;
4309 struct auto_pin_cfg *cfg = &spec->gen.autocfg;
4312 /* The mic boosts on level 2 and 3 are too noisy
4313 on the internal mic input.
4314 Therefore limit the boost to 0 or 1. */
4316 if (action != HDA_FIXUP_ACT_PROBE)
4319 for (i = 0; i < cfg->num_inputs; i++) {
4320 hda_nid_t nid = cfg->inputs[i].pin;
4321 unsigned int defcfg;
4322 if (cfg->inputs[i].type != AUTO_PIN_MIC)
4324 defcfg = snd_hda_codec_get_pincfg(codec, nid);
4325 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
4328 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
4329 (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
4330 (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4331 (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
4332 (0 << AC_AMPCAP_MUTE_SHIFT));
4336 static void alc283_hp_automute_hook(struct hda_codec *codec,
4337 struct hda_jack_callback *jack)
4339 struct alc_spec *spec = codec->spec;
4343 snd_hda_gen_hp_automute(codec, jack);
4345 vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4348 snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4352 static void alc283_fixup_chromebook(struct hda_codec *codec,
4353 const struct hda_fixup *fix, int action)
4355 struct alc_spec *spec = codec->spec;
4358 case HDA_FIXUP_ACT_PRE_PROBE:
4359 snd_hda_override_wcaps(codec, 0x03, 0);
4360 /* Disable AA-loopback as it causes white noise */
4361 spec->gen.mixer_nid = 0;
4363 case HDA_FIXUP_ACT_INIT:
4364 /* MIC2-VREF control */
4365 /* Set to manual mode */
4366 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
4367 /* Enable Line1 input control by verb */
4368 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
4373 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
4374 const struct hda_fixup *fix, int action)
4376 struct alc_spec *spec = codec->spec;
4379 case HDA_FIXUP_ACT_PRE_PROBE:
4380 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
4382 case HDA_FIXUP_ACT_INIT:
4383 /* MIC2-VREF control */
4384 /* Set to manual mode */
4385 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
4390 /* mute tablet speaker pin (0x14) via dock plugging in addition */
4391 static void asus_tx300_automute(struct hda_codec *codec)
4393 struct alc_spec *spec = codec->spec;
4394 snd_hda_gen_update_outputs(codec);
4395 if (snd_hda_jack_detect(codec, 0x1b))
4396 spec->gen.mute_bits |= (1ULL << 0x14);
4399 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
4400 const struct hda_fixup *fix, int action)
4402 struct alc_spec *spec = codec->spec;
4403 /* TX300 needs to set up GPIO2 for the speaker amp */
4404 static const struct hda_verb gpio2_verbs[] = {
4405 { 0x01, AC_VERB_SET_GPIO_MASK, 0x04 },
4406 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04 },
4407 { 0x01, AC_VERB_SET_GPIO_DATA, 0x04 },
4410 static const struct hda_pintbl dock_pins[] = {
4411 { 0x1b, 0x21114000 }, /* dock speaker pin */
4414 struct snd_kcontrol *kctl;
4417 case HDA_FIXUP_ACT_PRE_PROBE:
4418 snd_hda_add_verbs(codec, gpio2_verbs);
4419 snd_hda_apply_pincfgs(codec, dock_pins);
4420 spec->gen.auto_mute_via_amp = 1;
4421 spec->gen.automute_hook = asus_tx300_automute;
4422 snd_hda_jack_detect_enable_callback(codec, 0x1b,
4423 snd_hda_gen_hp_automute);
4425 case HDA_FIXUP_ACT_BUILD:
4426 /* this is a bit tricky; give more sane names for the main
4427 * (tablet) speaker and the dock speaker, respectively
4429 kctl = snd_hda_find_mixer_ctl(codec, "Speaker Playback Switch");
4431 strcpy(kctl->id.name, "Dock Speaker Playback Switch");
4432 kctl = snd_hda_find_mixer_ctl(codec, "Bass Speaker Playback Switch");
4434 strcpy(kctl->id.name, "Speaker Playback Switch");
4439 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
4440 const struct hda_fixup *fix, int action)
4442 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4443 /* DAC node 0x03 is giving mono output. We therefore want to
4444 make sure 0x14 (front speaker) and 0x15 (headphones) use the
4445 stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
4446 hda_nid_t conn1[2] = { 0x0c };
4447 snd_hda_override_conn_list(codec, 0x14, 1, conn1);
4448 snd_hda_override_conn_list(codec, 0x15, 1, conn1);
4452 /* Hook to update amp GPIO4 for automute */
4453 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
4454 struct hda_jack_callback *jack)
4456 struct alc_spec *spec = codec->spec;
4458 snd_hda_gen_hp_automute(codec, jack);
4459 /* mute_led_polarity is set to 0, so we pass inverted value here */
4460 alc_update_gpio_led(codec, 0x10, !spec->gen.hp_jack_present);
4463 /* Manage GPIOs for HP EliteBook Folio 9480m.
4465 * GPIO4 is the headphone amplifier power control
4466 * GPIO3 is the audio output mute indicator LED
4469 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
4470 const struct hda_fixup *fix,
4473 struct alc_spec *spec = codec->spec;
4474 static const struct hda_verb gpio_init[] = {
4475 { 0x01, AC_VERB_SET_GPIO_MASK, 0x18 },
4476 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x18 },
4480 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4481 /* Set the hooks to turn the headphone amp on/off
4484 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
4485 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
4487 /* The GPIOs are currently off */
4490 /* GPIO3 is connected to the output mute LED,
4491 * high is on, low is off
4493 spec->mute_led_polarity = 0;
4494 spec->gpio_mute_led_mask = 0x08;
4496 /* Initialize GPIO configuration */
4497 snd_hda_add_verbs(codec, gpio_init);
4501 /* for hda_fixup_thinkpad_acpi() */
4502 #include "thinkpad_helper.c"
4504 /* for dell wmi mic mute led */
4505 #include "dell_wmi_helper.c"
4508 ALC269_FIXUP_SONY_VAIO,
4509 ALC275_FIXUP_SONY_VAIO_GPIO2,
4510 ALC269_FIXUP_DELL_M101Z,
4511 ALC269_FIXUP_SKU_IGNORE,
4512 ALC269_FIXUP_ASUS_G73JW,
4513 ALC269_FIXUP_LENOVO_EAPD,
4514 ALC275_FIXUP_SONY_HWEQ,
4515 ALC275_FIXUP_SONY_DISABLE_AAMIX,
4517 ALC269_FIXUP_PCM_44K,
4518 ALC269_FIXUP_STEREO_DMIC,
4519 ALC269_FIXUP_HEADSET_MIC,
4520 ALC269_FIXUP_QUANTA_MUTE,
4521 ALC269_FIXUP_LIFEBOOK,
4522 ALC269_FIXUP_LIFEBOOK_EXTMIC,
4523 ALC269_FIXUP_LIFEBOOK_HP_PIN,
4524 ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
4527 ALC269VB_FIXUP_AMIC,
4528 ALC269VB_FIXUP_DMIC,
4529 ALC269_FIXUP_HP_MUTE_LED,
4530 ALC269_FIXUP_HP_MUTE_LED_MIC1,
4531 ALC269_FIXUP_HP_MUTE_LED_MIC2,
4532 ALC269_FIXUP_HP_GPIO_LED,
4533 ALC269_FIXUP_HP_GPIO_MIC1_LED,
4534 ALC269_FIXUP_HP_LINE1_MIC1_LED,
4535 ALC269_FIXUP_INV_DMIC,
4536 ALC269_FIXUP_LENOVO_DOCK,
4537 ALC269_FIXUP_NO_SHUTUP,
4538 ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
4539 ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
4540 ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
4541 ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
4542 ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
4543 ALC269_FIXUP_HEADSET_MODE,
4544 ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
4545 ALC269_FIXUP_ASPIRE_HEADSET_MIC,
4546 ALC269_FIXUP_ASUS_X101_FUNC,
4547 ALC269_FIXUP_ASUS_X101_VERB,
4548 ALC269_FIXUP_ASUS_X101,
4549 ALC271_FIXUP_AMIC_MIC2,
4550 ALC271_FIXUP_HP_GATE_MIC_JACK,
4551 ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
4552 ALC269_FIXUP_ACER_AC700,
4553 ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
4554 ALC269VB_FIXUP_ASUS_ZENBOOK,
4555 ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
4556 ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
4557 ALC269VB_FIXUP_ORDISSIMO_EVE2,
4558 ALC283_FIXUP_CHROME_BOOK,
4559 ALC283_FIXUP_SENSE_COMBO_JACK,
4560 ALC282_FIXUP_ASUS_TX300,
4561 ALC283_FIXUP_INT_MIC,
4562 ALC290_FIXUP_MONO_SPEAKERS,
4563 ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
4564 ALC290_FIXUP_SUBWOOFER,
4565 ALC290_FIXUP_SUBWOOFER_HSJACK,
4566 ALC269_FIXUP_THINKPAD_ACPI,
4567 ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
4568 ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
4569 ALC255_FIXUP_HEADSET_MODE,
4570 ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
4571 ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
4572 ALC292_FIXUP_TPT440_DOCK,
4573 ALC283_FIXUP_BXBT2807_MIC,
4574 ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED,
4575 ALC282_FIXUP_ASPIRE_V5_PINS,
4576 ALC280_FIXUP_HP_GPIO4,
4577 ALC286_FIXUP_HP_GPIO_LED,
4578 ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
4579 ALC280_FIXUP_HP_DOCK_PINS,
4580 ALC280_FIXUP_HP_9480M,
4581 ALC288_FIXUP_DELL_HEADSET_MODE,
4582 ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
4583 ALC288_FIXUP_DELL_XPS_13_GPIO6,
4584 ALC288_FIXUP_DELL_XPS_13,
4585 ALC288_FIXUP_DISABLE_AAMIX,
4586 ALC292_FIXUP_DELL_E7X,
4587 ALC292_FIXUP_DISABLE_AAMIX,
4588 ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
4589 ALC275_FIXUP_DELL_XPS,
4592 static const struct hda_fixup alc269_fixups[] = {
4593 [ALC269_FIXUP_SONY_VAIO] = {
4594 .type = HDA_FIXUP_PINCTLS,
4595 .v.pins = (const struct hda_pintbl[]) {
4596 {0x19, PIN_VREFGRD},
4600 [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
4601 .type = HDA_FIXUP_VERBS,
4602 .v.verbs = (const struct hda_verb[]) {
4603 {0x01, AC_VERB_SET_GPIO_MASK, 0x04},
4604 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
4605 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
4609 .chain_id = ALC269_FIXUP_SONY_VAIO
4611 [ALC269_FIXUP_DELL_M101Z] = {
4612 .type = HDA_FIXUP_VERBS,
4613 .v.verbs = (const struct hda_verb[]) {
4614 /* Enables internal speaker */
4615 {0x20, AC_VERB_SET_COEF_INDEX, 13},
4616 {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
4620 [ALC269_FIXUP_SKU_IGNORE] = {
4621 .type = HDA_FIXUP_FUNC,
4622 .v.func = alc_fixup_sku_ignore,
4624 [ALC269_FIXUP_ASUS_G73JW] = {
4625 .type = HDA_FIXUP_PINS,
4626 .v.pins = (const struct hda_pintbl[]) {
4627 { 0x17, 0x99130111 }, /* subwoofer */
4631 [ALC269_FIXUP_LENOVO_EAPD] = {
4632 .type = HDA_FIXUP_VERBS,
4633 .v.verbs = (const struct hda_verb[]) {
4634 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
4638 [ALC275_FIXUP_SONY_HWEQ] = {
4639 .type = HDA_FIXUP_FUNC,
4640 .v.func = alc269_fixup_hweq,
4642 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
4644 [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
4645 .type = HDA_FIXUP_FUNC,
4646 .v.func = alc_fixup_disable_aamix,
4648 .chain_id = ALC269_FIXUP_SONY_VAIO
4650 [ALC271_FIXUP_DMIC] = {
4651 .type = HDA_FIXUP_FUNC,
4652 .v.func = alc271_fixup_dmic,
4654 [ALC269_FIXUP_PCM_44K] = {
4655 .type = HDA_FIXUP_FUNC,
4656 .v.func = alc269_fixup_pcm_44k,
4658 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4660 [ALC269_FIXUP_STEREO_DMIC] = {
4661 .type = HDA_FIXUP_FUNC,
4662 .v.func = alc269_fixup_stereo_dmic,
4664 [ALC269_FIXUP_HEADSET_MIC] = {
4665 .type = HDA_FIXUP_FUNC,
4666 .v.func = alc269_fixup_headset_mic,
4668 [ALC269_FIXUP_QUANTA_MUTE] = {
4669 .type = HDA_FIXUP_FUNC,
4670 .v.func = alc269_fixup_quanta_mute,
4672 [ALC269_FIXUP_LIFEBOOK] = {
4673 .type = HDA_FIXUP_PINS,
4674 .v.pins = (const struct hda_pintbl[]) {
4675 { 0x1a, 0x2101103f }, /* dock line-out */
4676 { 0x1b, 0x23a11040 }, /* dock mic-in */
4680 .chain_id = ALC269_FIXUP_QUANTA_MUTE
4682 [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
4683 .type = HDA_FIXUP_PINS,
4684 .v.pins = (const struct hda_pintbl[]) {
4685 { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
4689 [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
4690 .type = HDA_FIXUP_PINS,
4691 .v.pins = (const struct hda_pintbl[]) {
4692 { 0x21, 0x0221102f }, /* HP out */
4696 [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
4697 .type = HDA_FIXUP_FUNC,
4698 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
4700 [ALC269_FIXUP_AMIC] = {
4701 .type = HDA_FIXUP_PINS,
4702 .v.pins = (const struct hda_pintbl[]) {
4703 { 0x14, 0x99130110 }, /* speaker */
4704 { 0x15, 0x0121401f }, /* HP out */
4705 { 0x18, 0x01a19c20 }, /* mic */
4706 { 0x19, 0x99a3092f }, /* int-mic */
4710 [ALC269_FIXUP_DMIC] = {
4711 .type = HDA_FIXUP_PINS,
4712 .v.pins = (const struct hda_pintbl[]) {
4713 { 0x12, 0x99a3092f }, /* int-mic */
4714 { 0x14, 0x99130110 }, /* speaker */
4715 { 0x15, 0x0121401f }, /* HP out */
4716 { 0x18, 0x01a19c20 }, /* mic */
4720 [ALC269VB_FIXUP_AMIC] = {
4721 .type = HDA_FIXUP_PINS,
4722 .v.pins = (const struct hda_pintbl[]) {
4723 { 0x14, 0x99130110 }, /* speaker */
4724 { 0x18, 0x01a19c20 }, /* mic */
4725 { 0x19, 0x99a3092f }, /* int-mic */
4726 { 0x21, 0x0121401f }, /* HP out */
4730 [ALC269VB_FIXUP_DMIC] = {
4731 .type = HDA_FIXUP_PINS,
4732 .v.pins = (const struct hda_pintbl[]) {
4733 { 0x12, 0x99a3092f }, /* int-mic */
4734 { 0x14, 0x99130110 }, /* speaker */
4735 { 0x18, 0x01a19c20 }, /* mic */
4736 { 0x21, 0x0121401f }, /* HP out */
4740 [ALC269_FIXUP_HP_MUTE_LED] = {
4741 .type = HDA_FIXUP_FUNC,
4742 .v.func = alc269_fixup_hp_mute_led,
4744 [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
4745 .type = HDA_FIXUP_FUNC,
4746 .v.func = alc269_fixup_hp_mute_led_mic1,
4748 [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
4749 .type = HDA_FIXUP_FUNC,
4750 .v.func = alc269_fixup_hp_mute_led_mic2,
4752 [ALC269_FIXUP_HP_GPIO_LED] = {
4753 .type = HDA_FIXUP_FUNC,
4754 .v.func = alc269_fixup_hp_gpio_led,
4756 [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
4757 .type = HDA_FIXUP_FUNC,
4758 .v.func = alc269_fixup_hp_gpio_mic1_led,
4760 [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
4761 .type = HDA_FIXUP_FUNC,
4762 .v.func = alc269_fixup_hp_line1_mic1_led,
4764 [ALC269_FIXUP_INV_DMIC] = {
4765 .type = HDA_FIXUP_FUNC,
4766 .v.func = alc_fixup_inv_dmic,
4768 [ALC269_FIXUP_NO_SHUTUP] = {
4769 .type = HDA_FIXUP_FUNC,
4770 .v.func = alc_fixup_no_shutup,
4772 [ALC269_FIXUP_LENOVO_DOCK] = {
4773 .type = HDA_FIXUP_PINS,
4774 .v.pins = (const struct hda_pintbl[]) {
4775 { 0x19, 0x23a11040 }, /* dock mic */
4776 { 0x1b, 0x2121103f }, /* dock headphone */
4780 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
4782 [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
4783 .type = HDA_FIXUP_FUNC,
4784 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
4786 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
4788 [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
4789 .type = HDA_FIXUP_PINS,
4790 .v.pins = (const struct hda_pintbl[]) {
4791 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4792 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
4796 .chain_id = ALC269_FIXUP_HEADSET_MODE
4798 [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
4799 .type = HDA_FIXUP_PINS,
4800 .v.pins = (const struct hda_pintbl[]) {
4801 { 0x16, 0x21014020 }, /* dock line out */
4802 { 0x19, 0x21a19030 }, /* dock mic */
4803 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4807 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
4809 [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
4810 .type = HDA_FIXUP_PINS,
4811 .v.pins = (const struct hda_pintbl[]) {
4812 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4816 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
4818 [ALC269_FIXUP_HEADSET_MODE] = {
4819 .type = HDA_FIXUP_FUNC,
4820 .v.func = alc_fixup_headset_mode,
4822 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
4824 [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
4825 .type = HDA_FIXUP_FUNC,
4826 .v.func = alc_fixup_headset_mode_no_hp_mic,
4828 [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
4829 .type = HDA_FIXUP_PINS,
4830 .v.pins = (const struct hda_pintbl[]) {
4831 { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
4835 .chain_id = ALC269_FIXUP_HEADSET_MODE,
4837 [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
4838 .type = HDA_FIXUP_PINS,
4839 .v.pins = (const struct hda_pintbl[]) {
4840 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
4844 .chain_id = ALC269_FIXUP_HEADSET_MIC
4846 [ALC269_FIXUP_ASUS_X101_FUNC] = {
4847 .type = HDA_FIXUP_FUNC,
4848 .v.func = alc269_fixup_x101_headset_mic,
4850 [ALC269_FIXUP_ASUS_X101_VERB] = {
4851 .type = HDA_FIXUP_VERBS,
4852 .v.verbs = (const struct hda_verb[]) {
4853 {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4854 {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
4855 {0x20, AC_VERB_SET_PROC_COEF, 0x0310},
4859 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
4861 [ALC269_FIXUP_ASUS_X101] = {
4862 .type = HDA_FIXUP_PINS,
4863 .v.pins = (const struct hda_pintbl[]) {
4864 { 0x18, 0x04a1182c }, /* Headset mic */
4868 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
4870 [ALC271_FIXUP_AMIC_MIC2] = {
4871 .type = HDA_FIXUP_PINS,
4872 .v.pins = (const struct hda_pintbl[]) {
4873 { 0x14, 0x99130110 }, /* speaker */
4874 { 0x19, 0x01a19c20 }, /* mic */
4875 { 0x1b, 0x99a7012f }, /* int-mic */
4876 { 0x21, 0x0121401f }, /* HP out */
4880 [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
4881 .type = HDA_FIXUP_FUNC,
4882 .v.func = alc271_hp_gate_mic_jack,
4884 .chain_id = ALC271_FIXUP_AMIC_MIC2,
4886 [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
4887 .type = HDA_FIXUP_FUNC,
4888 .v.func = alc269_fixup_limit_int_mic_boost,
4890 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
4892 [ALC269_FIXUP_ACER_AC700] = {
4893 .type = HDA_FIXUP_PINS,
4894 .v.pins = (const struct hda_pintbl[]) {
4895 { 0x12, 0x99a3092f }, /* int-mic */
4896 { 0x14, 0x99130110 }, /* speaker */
4897 { 0x18, 0x03a11c20 }, /* mic */
4898 { 0x1e, 0x0346101e }, /* SPDIF1 */
4899 { 0x21, 0x0321101f }, /* HP out */
4903 .chain_id = ALC271_FIXUP_DMIC,
4905 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
4906 .type = HDA_FIXUP_FUNC,
4907 .v.func = alc269_fixup_limit_int_mic_boost,
4909 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
4911 [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
4912 .type = HDA_FIXUP_FUNC,
4913 .v.func = alc269_fixup_limit_int_mic_boost,
4915 .chain_id = ALC269VB_FIXUP_DMIC,
4917 [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
4918 .type = HDA_FIXUP_VERBS,
4919 .v.verbs = (const struct hda_verb[]) {
4920 /* class-D output amp +5dB */
4921 { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
4922 { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
4926 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
4928 [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
4929 .type = HDA_FIXUP_FUNC,
4930 .v.func = alc269_fixup_limit_int_mic_boost,
4932 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
4934 [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
4935 .type = HDA_FIXUP_PINS,
4936 .v.pins = (const struct hda_pintbl[]) {
4937 { 0x12, 0x99a3092f }, /* int-mic */
4938 { 0x18, 0x03a11d20 }, /* mic */
4939 { 0x19, 0x411111f0 }, /* Unused bogus pin */
4943 [ALC283_FIXUP_CHROME_BOOK] = {
4944 .type = HDA_FIXUP_FUNC,
4945 .v.func = alc283_fixup_chromebook,
4947 [ALC283_FIXUP_SENSE_COMBO_JACK] = {
4948 .type = HDA_FIXUP_FUNC,
4949 .v.func = alc283_fixup_sense_combo_jack,
4951 .chain_id = ALC283_FIXUP_CHROME_BOOK,
4953 [ALC282_FIXUP_ASUS_TX300] = {
4954 .type = HDA_FIXUP_FUNC,
4955 .v.func = alc282_fixup_asus_tx300,
4957 [ALC283_FIXUP_INT_MIC] = {
4958 .type = HDA_FIXUP_VERBS,
4959 .v.verbs = (const struct hda_verb[]) {
4960 {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
4961 {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
4965 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
4967 [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
4968 .type = HDA_FIXUP_PINS,
4969 .v.pins = (const struct hda_pintbl[]) {
4970 { 0x17, 0x90170112 }, /* subwoofer */
4974 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
4976 [ALC290_FIXUP_SUBWOOFER] = {
4977 .type = HDA_FIXUP_PINS,
4978 .v.pins = (const struct hda_pintbl[]) {
4979 { 0x17, 0x90170112 }, /* subwoofer */
4983 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
4985 [ALC290_FIXUP_MONO_SPEAKERS] = {
4986 .type = HDA_FIXUP_FUNC,
4987 .v.func = alc290_fixup_mono_speakers,
4989 [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
4990 .type = HDA_FIXUP_FUNC,
4991 .v.func = alc290_fixup_mono_speakers,
4993 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
4995 [ALC269_FIXUP_THINKPAD_ACPI] = {
4996 .type = HDA_FIXUP_FUNC,
4997 .v.func = hda_fixup_thinkpad_acpi,
4999 [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5000 .type = HDA_FIXUP_PINS,
5001 .v.pins = (const struct hda_pintbl[]) {
5002 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5003 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5007 .chain_id = ALC255_FIXUP_HEADSET_MODE
5009 [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
5010 .type = HDA_FIXUP_PINS,
5011 .v.pins = (const struct hda_pintbl[]) {
5012 { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5016 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
5018 [ALC255_FIXUP_HEADSET_MODE] = {
5019 .type = HDA_FIXUP_FUNC,
5020 .v.func = alc_fixup_headset_mode_alc255,
5022 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
5024 [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
5025 .type = HDA_FIXUP_FUNC,
5026 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
5028 [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5029 .type = HDA_FIXUP_PINS,
5030 .v.pins = (const struct hda_pintbl[]) {
5031 { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5032 { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5036 .chain_id = ALC269_FIXUP_HEADSET_MODE
5038 [ALC292_FIXUP_TPT440_DOCK] = {
5039 .type = HDA_FIXUP_FUNC,
5040 .v.func = alc_fixup_tpt440_dock,
5042 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
5044 [ALC283_FIXUP_BXBT2807_MIC] = {
5045 .type = HDA_FIXUP_PINS,
5046 .v.pins = (const struct hda_pintbl[]) {
5047 { 0x19, 0x04a110f0 },
5051 [ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED] = {
5052 .type = HDA_FIXUP_FUNC,
5053 .v.func = alc_fixup_dell_wmi,
5055 [ALC282_FIXUP_ASPIRE_V5_PINS] = {
5056 .type = HDA_FIXUP_PINS,
5057 .v.pins = (const struct hda_pintbl[]) {
5058 { 0x12, 0x90a60130 },
5059 { 0x14, 0x90170110 },
5060 { 0x17, 0x40000008 },
5061 { 0x18, 0x411111f0 },
5062 { 0x19, 0x01a1913c },
5063 { 0x1a, 0x411111f0 },
5064 { 0x1b, 0x411111f0 },
5065 { 0x1d, 0x40f89b2d },
5066 { 0x1e, 0x411111f0 },
5067 { 0x21, 0x0321101f },
5071 [ALC280_FIXUP_HP_GPIO4] = {
5072 .type = HDA_FIXUP_FUNC,
5073 .v.func = alc280_fixup_hp_gpio4,
5075 [ALC286_FIXUP_HP_GPIO_LED] = {
5076 .type = HDA_FIXUP_FUNC,
5077 .v.func = alc286_fixup_hp_gpio_led,
5079 [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
5080 .type = HDA_FIXUP_FUNC,
5081 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
5083 [ALC280_FIXUP_HP_DOCK_PINS] = {
5084 .type = HDA_FIXUP_PINS,
5085 .v.pins = (const struct hda_pintbl[]) {
5086 { 0x1b, 0x21011020 }, /* line-out */
5087 { 0x1a, 0x01a1903c }, /* headset mic */
5088 { 0x18, 0x2181103f }, /* line-in */
5092 .chain_id = ALC280_FIXUP_HP_GPIO4
5094 [ALC280_FIXUP_HP_9480M] = {
5095 .type = HDA_FIXUP_FUNC,
5096 .v.func = alc280_fixup_hp_9480m,
5098 [ALC288_FIXUP_DELL_HEADSET_MODE] = {
5099 .type = HDA_FIXUP_FUNC,
5100 .v.func = alc_fixup_headset_mode_dell_alc288,
5102 .chain_id = ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED
5104 [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5105 .type = HDA_FIXUP_PINS,
5106 .v.pins = (const struct hda_pintbl[]) {
5107 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5108 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5112 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
5114 [ALC288_FIXUP_DELL_XPS_13_GPIO6] = {
5115 .type = HDA_FIXUP_VERBS,
5116 .v.verbs = (const struct hda_verb[]) {
5117 {0x01, AC_VERB_SET_GPIO_MASK, 0x40},
5118 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x40},
5119 {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5123 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
5125 [ALC288_FIXUP_DISABLE_AAMIX] = {
5126 .type = HDA_FIXUP_FUNC,
5127 .v.func = alc_fixup_disable_aamix,
5129 .chain_id = ALC288_FIXUP_DELL_XPS_13_GPIO6
5131 [ALC288_FIXUP_DELL_XPS_13] = {
5132 .type = HDA_FIXUP_FUNC,
5133 .v.func = alc_fixup_dell_xps13,
5135 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
5137 [ALC292_FIXUP_DISABLE_AAMIX] = {
5138 .type = HDA_FIXUP_FUNC,
5139 .v.func = alc_fixup_disable_aamix,
5141 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
5143 [ALC292_FIXUP_DELL_E7X] = {
5144 .type = HDA_FIXUP_FUNC,
5145 .v.func = alc_fixup_dell_xps13,
5147 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
5149 [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
5150 .type = HDA_FIXUP_PINS,
5151 .v.pins = (const struct hda_pintbl[]) {
5152 { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
5153 { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
5157 .chain_id = ALC269_FIXUP_HEADSET_MODE
5159 [ALC275_FIXUP_DELL_XPS] = {
5160 .type = HDA_FIXUP_VERBS,
5161 .v.verbs = (const struct hda_verb[]) {
5162 /* Enables internal speaker */
5163 {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
5164 {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
5165 {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
5166 {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
5172 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
5173 SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
5174 SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
5175 SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
5176 SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
5177 SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
5178 SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
5179 SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
5180 SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
5181 SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
5182 SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
5183 SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
5184 SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
5185 SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
5186 SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
5187 SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
5188 SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
5189 SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
5190 SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
5191 SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
5192 SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
5193 SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
5194 SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
5195 SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5196 SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5197 SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
5198 SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
5199 SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
5200 SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5201 SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5202 SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC292_FIXUP_DISABLE_AAMIX),
5203 SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC292_FIXUP_DISABLE_AAMIX),
5204 SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC292_FIXUP_DISABLE_AAMIX),
5205 SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC292_FIXUP_DISABLE_AAMIX),
5206 SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC292_FIXUP_DISABLE_AAMIX),
5207 SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5208 SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
5209 SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
5210 SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
5211 SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
5212 SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
5214 SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5215 SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5216 SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5217 SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5218 SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5219 SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5220 SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5221 SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
5222 SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5223 SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5224 SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5225 SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5226 SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
5227 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
5228 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
5229 SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5230 SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5231 SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5232 SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5233 SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5234 SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
5235 SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5236 SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5238 SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5239 SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5240 SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5241 SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5242 SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5243 SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5244 SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5245 SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5246 SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5247 SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5248 SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5249 SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5250 SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5251 SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5252 SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5253 SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5254 SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
5255 SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5256 SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5257 SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5258 SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5259 SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5260 SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5261 SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5262 SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5263 SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5264 SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5265 SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5266 SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
5267 SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
5268 SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5269 SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5270 SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
5271 SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
5272 SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
5273 SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
5274 SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
5275 SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5276 SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
5277 SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
5278 SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5279 SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
5280 SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
5281 SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
5282 SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
5283 SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
5284 SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5285 SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
5286 SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
5287 SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
5288 SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
5289 SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
5290 SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
5291 SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
5292 SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
5293 SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_BXBT2807_MIC),
5294 SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
5295 SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
5296 SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
5297 SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
5298 SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
5299 SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK),
5300 SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
5301 SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
5302 SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
5303 SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
5304 SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
5305 SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440_DOCK),
5306 SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
5307 SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
5308 SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
5309 SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
5310 SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
5311 SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5312 SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
5313 SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
5314 SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
5315 SND_PCI_QUIRK(0x17aa, 0x3978, "IdeaPad Y410P", ALC269_FIXUP_NO_SHUTUP),
5316 SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5317 SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
5318 SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
5319 SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5320 SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
5321 SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
5322 SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
5323 SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
5324 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
5325 SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
5326 SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
5329 /* Below is a quirk table taken from the old code.
5330 * Basically the device should work as is without the fixup table.
5331 * If BIOS doesn't give a proper info, enable the corresponding
5334 SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
5336 SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
5337 SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
5338 SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
5339 SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
5340 SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
5341 SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
5342 SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
5343 SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
5344 SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
5345 SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
5346 SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
5347 SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
5348 SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
5349 SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
5350 SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
5351 SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
5352 SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
5353 SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
5354 SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
5355 SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
5356 SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
5357 SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
5358 SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
5359 SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
5360 SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
5361 SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
5362 SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
5363 SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
5364 SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
5365 SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
5366 SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
5367 SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
5368 SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
5369 SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
5370 SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
5371 SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
5372 SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
5373 SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
5374 SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
5379 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
5380 SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
5381 SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
5382 SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
5383 SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
5387 static const struct hda_model_fixup alc269_fixup_models[] = {
5388 {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
5389 {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
5390 {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
5391 {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
5392 {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
5393 {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
5394 {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
5395 {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
5396 {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
5397 {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
5398 {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
5399 {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
5400 {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
5401 {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
5402 {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
5406 #define ALC256_STANDARD_PINS \
5407 {0x12, 0x90a60140}, \
5408 {0x14, 0x90170110}, \
5411 #define ALC282_STANDARD_PINS \
5414 #define ALC290_STANDARD_PINS \
5417 #define ALC292_STANDARD_PINS \
5418 {0x14, 0x90170110}, \
5421 #define ALC298_STANDARD_PINS \
5422 {0x12, 0x90a60130}, \
5425 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
5426 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
5428 {0x21, 0x02211020}),
5429 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5432 {0x21, 0x02211020}),
5433 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5436 {0x21, 0x02211030}),
5437 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5440 {0x21, 0x0221103f}),
5441 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5444 {0x21, 0x0221105f}),
5445 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5448 {0x21, 0x0221101f}),
5449 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5453 {0x21, 0x0321102f}),
5454 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5457 {0x21, 0x02211040}),
5458 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5461 {0x21, 0x02211050}),
5462 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5465 {0x21, 0x02211030}),
5466 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5469 {0x21, 0x02211040}),
5470 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5473 {0x21, 0x02211050}),
5474 SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5477 {0x21, 0x02211040}),
5478 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5481 {0x21, 0x02211030}),
5482 SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
5483 ALC256_STANDARD_PINS),
5484 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
5488 {0x1a, 0x04a11020}),
5489 SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
5495 {0x1b, 0x02011020}),
5496 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5497 ALC282_STANDARD_PINS,
5500 {0x21, 0x0321101f}),
5501 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5502 ALC282_STANDARD_PINS,
5505 {0x21, 0x03211040}),
5506 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5507 ALC282_STANDARD_PINS,
5510 {0x21, 0x03211020}),
5511 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5512 ALC282_STANDARD_PINS,
5515 {0x21, 0x0421101f}),
5516 SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
5517 ALC282_STANDARD_PINS,
5520 {0x21, 0x04211020}),
5521 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5522 ALC282_STANDARD_PINS,
5524 {0x21, 0x0321101f}),
5525 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5528 {0x21, 0x02211030}),
5529 SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
5530 ALC282_STANDARD_PINS,
5533 {0x21, 0x0321101f}),
5534 SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL_XPS_13_GPIO6,
5537 {0x21, 0x0321101f}),
5538 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5539 ALC290_STANDARD_PINS,
5542 {0x1a, 0x04a11020}),
5543 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5544 ALC290_STANDARD_PINS,
5547 {0x1a, 0x04a11020}),
5548 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5549 ALC290_STANDARD_PINS,
5551 {0x1a, 0x04a11020}),
5552 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5553 ALC290_STANDARD_PINS,
5555 {0x1a, 0x04a11040}),
5556 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5557 ALC290_STANDARD_PINS,
5560 {0x1a, 0x04a11040}),
5561 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5562 ALC290_STANDARD_PINS,
5565 {0x1a, 0x04a11020}),
5566 SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
5567 ALC290_STANDARD_PINS,
5570 {0x1a, 0x04a11020}),
5571 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
5572 ALC292_STANDARD_PINS,
5575 {0x19, 0x01a19030}),
5576 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
5577 ALC292_STANDARD_PINS,
5581 {0x19, 0x01a1903e}),
5582 SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
5583 ALC292_STANDARD_PINS,
5584 {0x12, 0x90a60140}),
5585 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
5586 ALC292_STANDARD_PINS,
5589 {0x19, 0x21a19030}),
5590 SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
5591 ALC292_STANDARD_PINS,
5592 {0x13, 0x90a60140}),
5593 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
5594 ALC298_STANDARD_PINS,
5595 {0x17, 0x90170110}),
5596 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
5597 ALC298_STANDARD_PINS,
5598 {0x17, 0x90170140}),
5599 SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
5600 ALC298_STANDARD_PINS,
5601 {0x17, 0x90170150}),
5605 static void alc269_fill_coef(struct hda_codec *codec)
5607 struct alc_spec *spec = codec->spec;
5610 if (spec->codec_variant != ALC269_TYPE_ALC269VB)
5613 if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
5614 alc_write_coef_idx(codec, 0xf, 0x960b);
5615 alc_write_coef_idx(codec, 0xe, 0x8817);
5618 if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
5619 alc_write_coef_idx(codec, 0xf, 0x960b);
5620 alc_write_coef_idx(codec, 0xe, 0x8814);
5623 if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
5624 /* Power up output pin */
5625 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
5628 if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
5629 val = alc_read_coef_idx(codec, 0xd);
5630 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
5631 /* Capless ramp up clock control */
5632 alc_write_coef_idx(codec, 0xd, val | (1<<10));
5634 val = alc_read_coef_idx(codec, 0x17);
5635 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
5636 /* Class D power on reset */
5637 alc_write_coef_idx(codec, 0x17, val | (1<<7));
5642 alc_update_coef_idx(codec, 0x4, 0, 1<<11);
5647 static int patch_alc269(struct hda_codec *codec)
5649 struct alc_spec *spec;
5652 err = alc_alloc_spec(codec, 0x0b);
5657 spec->gen.shared_mic_vref_pin = 0x18;
5658 codec->power_save_node = 1;
5661 codec->patch_ops.suspend = alc269_suspend;
5662 codec->patch_ops.resume = alc269_resume;
5664 spec->shutup = alc269_shutup;
5666 snd_hda_pick_fixup(codec, alc269_fixup_models,
5667 alc269_fixup_tbl, alc269_fixups);
5668 snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups);
5669 snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
5671 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
5673 alc_auto_parse_customize_define(codec);
5675 if (has_cdefine_beep(codec))
5676 spec->gen.beep_nid = 0x01;
5678 switch (codec->core.vendor_id) {
5680 spec->codec_variant = ALC269_TYPE_ALC269VA;
5681 switch (alc_get_coef0(codec) & 0x00f0) {
5683 if (codec->bus->pci &&
5684 codec->bus->pci->subsystem_vendor == 0x1025 &&
5685 spec->cdefine.platform_type == 1)
5686 err = alc_codec_rename(codec, "ALC271X");
5687 spec->codec_variant = ALC269_TYPE_ALC269VB;
5690 if (codec->bus->pci &&
5691 codec->bus->pci->subsystem_vendor == 0x17aa &&
5692 codec->bus->pci->subsystem_device == 0x21f3)
5693 err = alc_codec_rename(codec, "ALC3202");
5694 spec->codec_variant = ALC269_TYPE_ALC269VC;
5697 spec->codec_variant = ALC269_TYPE_ALC269VD;
5700 alc_fix_pll_init(codec, 0x20, 0x04, 15);
5704 spec->init_hook = alc269_fill_coef;
5705 alc269_fill_coef(codec);
5710 spec->codec_variant = ALC269_TYPE_ALC280;
5713 spec->codec_variant = ALC269_TYPE_ALC282;
5714 spec->shutup = alc282_shutup;
5715 spec->init_hook = alc282_init;
5719 spec->codec_variant = ALC269_TYPE_ALC283;
5720 spec->shutup = alc283_shutup;
5721 spec->init_hook = alc283_init;
5725 spec->codec_variant = ALC269_TYPE_ALC284;
5729 spec->codec_variant = ALC269_TYPE_ALC285;
5733 spec->codec_variant = ALC269_TYPE_ALC286;
5734 spec->shutup = alc286_shutup;
5737 spec->codec_variant = ALC269_TYPE_ALC298;
5740 spec->codec_variant = ALC269_TYPE_ALC255;
5743 spec->codec_variant = ALC269_TYPE_ALC256;
5744 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
5745 alc_update_coef_idx(codec, 0x36, 1 << 13, 1 << 5); /* Switch pcbeep path to Line in path*/
5749 if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
5750 spec->has_alc5505_dsp = 1;
5751 spec->init_hook = alc5505_dsp_init;
5754 /* automatic parse from the BIOS config */
5755 err = alc269_parse_auto_config(codec);
5759 if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid)
5760 set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
5762 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
5775 static int alc861_parse_auto_config(struct hda_codec *codec)
5777 static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
5778 static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
5779 return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
5782 /* Pin config fixes */
5784 ALC861_FIXUP_FSC_AMILO_PI1505,
5785 ALC861_FIXUP_AMP_VREF_0F,
5786 ALC861_FIXUP_NO_JACK_DETECT,
5787 ALC861_FIXUP_ASUS_A6RP,
5788 ALC660_FIXUP_ASUS_W7J,
5791 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
5792 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
5793 const struct hda_fixup *fix, int action)
5795 struct alc_spec *spec = codec->spec;
5798 if (action != HDA_FIXUP_ACT_INIT)
5800 val = snd_hda_codec_get_pin_target(codec, 0x0f);
5801 if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
5802 val |= AC_PINCTL_IN_EN;
5803 val |= AC_PINCTL_VREF_50;
5804 snd_hda_set_pin_ctl(codec, 0x0f, val);
5805 spec->gen.keep_vref_in_automute = 1;
5808 /* suppress the jack-detection */
5809 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
5810 const struct hda_fixup *fix, int action)
5812 if (action == HDA_FIXUP_ACT_PRE_PROBE)
5813 codec->no_jack_detect = 1;
5816 static const struct hda_fixup alc861_fixups[] = {
5817 [ALC861_FIXUP_FSC_AMILO_PI1505] = {
5818 .type = HDA_FIXUP_PINS,
5819 .v.pins = (const struct hda_pintbl[]) {
5820 { 0x0b, 0x0221101f }, /* HP */
5821 { 0x0f, 0x90170310 }, /* speaker */
5825 [ALC861_FIXUP_AMP_VREF_0F] = {
5826 .type = HDA_FIXUP_FUNC,
5827 .v.func = alc861_fixup_asus_amp_vref_0f,
5829 [ALC861_FIXUP_NO_JACK_DETECT] = {
5830 .type = HDA_FIXUP_FUNC,
5831 .v.func = alc_fixup_no_jack_detect,
5833 [ALC861_FIXUP_ASUS_A6RP] = {
5834 .type = HDA_FIXUP_FUNC,
5835 .v.func = alc861_fixup_asus_amp_vref_0f,
5837 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
5839 [ALC660_FIXUP_ASUS_W7J] = {
5840 .type = HDA_FIXUP_VERBS,
5841 .v.verbs = (const struct hda_verb[]) {
5842 /* ASUS W7J needs a magic pin setup on unused NID 0x10
5843 * for enabling outputs
5845 {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5851 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
5852 SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
5853 SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
5854 SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
5855 SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
5856 SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
5857 SND_PCI_QUIRK(0x1584, 0x2b01, "Haier W18", ALC861_FIXUP_AMP_VREF_0F),
5858 SND_PCI_QUIRK(0x1584, 0x0000, "Uniwill ECS M31EI", ALC861_FIXUP_AMP_VREF_0F),
5859 SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
5865 static int patch_alc861(struct hda_codec *codec)
5867 struct alc_spec *spec;
5870 err = alc_alloc_spec(codec, 0x15);
5875 spec->gen.beep_nid = 0x23;
5878 spec->power_hook = alc_power_eapd;
5881 snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
5882 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
5884 /* automatic parse from the BIOS config */
5885 err = alc861_parse_auto_config(codec);
5889 if (!spec->gen.no_analog)
5890 set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
5892 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
5906 * In addition, an independent DAC
5908 static int alc861vd_parse_auto_config(struct hda_codec *codec)
5910 static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
5911 static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
5912 return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
5916 ALC660VD_FIX_ASUS_GPIO1,
5917 ALC861VD_FIX_DALLAS,
5920 /* exclude VREF80 */
5921 static void alc861vd_fixup_dallas(struct hda_codec *codec,
5922 const struct hda_fixup *fix, int action)
5924 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5925 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
5926 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
5930 static const struct hda_fixup alc861vd_fixups[] = {
5931 [ALC660VD_FIX_ASUS_GPIO1] = {
5932 .type = HDA_FIXUP_VERBS,
5933 .v.verbs = (const struct hda_verb[]) {
5935 {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
5936 {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5937 {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5941 [ALC861VD_FIX_DALLAS] = {
5942 .type = HDA_FIXUP_FUNC,
5943 .v.func = alc861vd_fixup_dallas,
5947 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
5948 SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
5949 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
5950 SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
5956 static int patch_alc861vd(struct hda_codec *codec)
5958 struct alc_spec *spec;
5961 err = alc_alloc_spec(codec, 0x0b);
5966 spec->gen.beep_nid = 0x23;
5968 spec->shutup = alc_eapd_shutup;
5970 snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
5971 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
5973 /* automatic parse from the BIOS config */
5974 err = alc861vd_parse_auto_config(codec);
5978 if (!spec->gen.no_analog)
5979 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5981 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
5993 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
5994 * configuration. Each pin widget can choose any input DACs and a mixer.
5995 * Each ADC is connected from a mixer of all inputs. This makes possible
5996 * 6-channel independent captures.
5998 * In addition, an independent DAC for the multi-playback (not used in this
6003 * BIOS auto configuration
6006 static int alc662_parse_auto_config(struct hda_codec *codec)
6008 static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
6009 static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
6010 static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
6011 const hda_nid_t *ssids;
6013 if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
6014 codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
6015 codec->core.vendor_id == 0x10ec0671)
6016 ssids = alc663_ssids;
6018 ssids = alc662_ssids;
6019 return alc_parse_auto_config(codec, alc662_ignore, ssids);
6022 static void alc272_fixup_mario(struct hda_codec *codec,
6023 const struct hda_fixup *fix, int action)
6025 if (action != HDA_FIXUP_ACT_PRE_PROBE)
6027 if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
6028 (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
6029 (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
6030 (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
6031 (0 << AC_AMPCAP_MUTE_SHIFT)))
6032 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
6035 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
6037 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
6039 .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
6040 SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
6044 /* override the 2.1 chmap */
6045 static void alc_fixup_bass_chmap(struct hda_codec *codec,
6046 const struct hda_fixup *fix, int action)
6048 if (action == HDA_FIXUP_ACT_BUILD) {
6049 struct alc_spec *spec = codec->spec;
6050 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
6054 /* avoid D3 for keeping GPIO up */
6055 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
6057 unsigned int power_state)
6059 struct alc_spec *spec = codec->spec;
6060 if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_led)
6065 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
6066 const struct hda_fixup *fix, int action)
6068 struct alc_spec *spec = codec->spec;
6069 static const struct hda_verb gpio_init[] = {
6070 { 0x01, AC_VERB_SET_GPIO_MASK, 0x01 },
6071 { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01 },
6075 if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6076 spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
6078 spec->mute_led_polarity = 1;
6079 spec->gpio_mute_led_mask = 0x01;
6080 snd_hda_add_verbs(codec, gpio_init);
6081 codec->power_filter = gpio_led_power_filter;
6085 static struct coef_fw alc668_coefs[] = {
6086 WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03, 0x0),
6087 WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06, 0x0), WRITE_COEF(0x07, 0x0f80),
6088 WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b, 0x0),
6089 WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
6090 WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
6091 WRITE_COEF(0x13, 0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
6092 WRITE_COEF(0x19, 0x0), WRITE_COEF(0x1a, 0x0), WRITE_COEF(0x1b, 0x0),
6093 WRITE_COEF(0x1c, 0x0), WRITE_COEF(0x1d, 0x0), WRITE_COEF(0x1e, 0x7418),
6094 WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
6095 WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
6096 WRITE_COEF(0x27, 0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
6097 WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
6098 WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac, 0x0),
6099 WRITE_COEF(0xad, 0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
6100 WRITE_COEF(0xb0, 0x0), WRITE_COEF(0xb1, 0x0), WRITE_COEF(0xb2, 0x0),
6101 WRITE_COEF(0xb3, 0x0), WRITE_COEF(0xb4, 0x0), WRITE_COEF(0xb5, 0x1040),
6102 WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
6103 WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
6104 WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
6105 WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
6109 static void alc668_restore_default_value(struct hda_codec *codec)
6111 alc_process_coef_fw(codec, alc668_coefs);
6115 ALC662_FIXUP_ASPIRE,
6116 ALC662_FIXUP_LED_GPIO1,
6117 ALC662_FIXUP_IDEAPAD,
6119 ALC662_FIXUP_CZC_P10T,
6120 ALC662_FIXUP_SKU_IGNORE,
6121 ALC662_FIXUP_HP_RP5800,
6122 ALC662_FIXUP_ASUS_MODE1,
6123 ALC662_FIXUP_ASUS_MODE2,
6124 ALC662_FIXUP_ASUS_MODE3,
6125 ALC662_FIXUP_ASUS_MODE4,
6126 ALC662_FIXUP_ASUS_MODE5,
6127 ALC662_FIXUP_ASUS_MODE6,
6128 ALC662_FIXUP_ASUS_MODE7,
6129 ALC662_FIXUP_ASUS_MODE8,
6130 ALC662_FIXUP_NO_JACK_DETECT,
6131 ALC662_FIXUP_ZOTAC_Z68,
6132 ALC662_FIXUP_INV_DMIC,
6133 ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
6134 ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
6135 ALC662_FIXUP_HEADSET_MODE,
6136 ALC668_FIXUP_HEADSET_MODE,
6137 ALC662_FIXUP_BASS_MODE4_CHMAP,
6138 ALC662_FIXUP_BASS_16,
6139 ALC662_FIXUP_BASS_1A,
6140 ALC662_FIXUP_BASS_CHMAP,
6141 ALC668_FIXUP_AUTO_MUTE,
6142 ALC668_FIXUP_DELL_DISABLE_AAMIX,
6143 ALC668_FIXUP_DELL_XPS13,
6146 static const struct hda_fixup alc662_fixups[] = {
6147 [ALC662_FIXUP_ASPIRE] = {
6148 .type = HDA_FIXUP_PINS,
6149 .v.pins = (const struct hda_pintbl[]) {
6150 { 0x15, 0x99130112 }, /* subwoofer */
6154 [ALC662_FIXUP_LED_GPIO1] = {
6155 .type = HDA_FIXUP_FUNC,
6156 .v.func = alc662_fixup_led_gpio1,
6158 [ALC662_FIXUP_IDEAPAD] = {
6159 .type = HDA_FIXUP_PINS,
6160 .v.pins = (const struct hda_pintbl[]) {
6161 { 0x17, 0x99130112 }, /* subwoofer */
6165 .chain_id = ALC662_FIXUP_LED_GPIO1,
6167 [ALC272_FIXUP_MARIO] = {
6168 .type = HDA_FIXUP_FUNC,
6169 .v.func = alc272_fixup_mario,
6171 [ALC662_FIXUP_CZC_P10T] = {
6172 .type = HDA_FIXUP_VERBS,
6173 .v.verbs = (const struct hda_verb[]) {
6174 {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
6178 [ALC662_FIXUP_SKU_IGNORE] = {
6179 .type = HDA_FIXUP_FUNC,
6180 .v.func = alc_fixup_sku_ignore,
6182 [ALC662_FIXUP_HP_RP5800] = {
6183 .type = HDA_FIXUP_PINS,
6184 .v.pins = (const struct hda_pintbl[]) {
6185 { 0x14, 0x0221201f }, /* HP out */
6189 .chain_id = ALC662_FIXUP_SKU_IGNORE
6191 [ALC662_FIXUP_ASUS_MODE1] = {
6192 .type = HDA_FIXUP_PINS,
6193 .v.pins = (const struct hda_pintbl[]) {
6194 { 0x14, 0x99130110 }, /* speaker */
6195 { 0x18, 0x01a19c20 }, /* mic */
6196 { 0x19, 0x99a3092f }, /* int-mic */
6197 { 0x21, 0x0121401f }, /* HP out */
6201 .chain_id = ALC662_FIXUP_SKU_IGNORE
6203 [ALC662_FIXUP_ASUS_MODE2] = {
6204 .type = HDA_FIXUP_PINS,
6205 .v.pins = (const struct hda_pintbl[]) {
6206 { 0x14, 0x99130110 }, /* speaker */
6207 { 0x18, 0x01a19820 }, /* mic */
6208 { 0x19, 0x99a3092f }, /* int-mic */
6209 { 0x1b, 0x0121401f }, /* HP out */
6213 .chain_id = ALC662_FIXUP_SKU_IGNORE
6215 [ALC662_FIXUP_ASUS_MODE3] = {
6216 .type = HDA_FIXUP_PINS,
6217 .v.pins = (const struct hda_pintbl[]) {
6218 { 0x14, 0x99130110 }, /* speaker */
6219 { 0x15, 0x0121441f }, /* HP */
6220 { 0x18, 0x01a19840 }, /* mic */
6221 { 0x19, 0x99a3094f }, /* int-mic */
6222 { 0x21, 0x01211420 }, /* HP2 */
6226 .chain_id = ALC662_FIXUP_SKU_IGNORE
6228 [ALC662_FIXUP_ASUS_MODE4] = {
6229 .type = HDA_FIXUP_PINS,
6230 .v.pins = (const struct hda_pintbl[]) {
6231 { 0x14, 0x99130110 }, /* speaker */
6232 { 0x16, 0x99130111 }, /* speaker */
6233 { 0x18, 0x01a19840 }, /* mic */
6234 { 0x19, 0x99a3094f }, /* int-mic */
6235 { 0x21, 0x0121441f }, /* HP */
6239 .chain_id = ALC662_FIXUP_SKU_IGNORE
6241 [ALC662_FIXUP_ASUS_MODE5] = {
6242 .type = HDA_FIXUP_PINS,
6243 .v.pins = (const struct hda_pintbl[]) {
6244 { 0x14, 0x99130110 }, /* speaker */
6245 { 0x15, 0x0121441f }, /* HP */
6246 { 0x16, 0x99130111 }, /* speaker */
6247 { 0x18, 0x01a19840 }, /* mic */
6248 { 0x19, 0x99a3094f }, /* int-mic */
6252 .chain_id = ALC662_FIXUP_SKU_IGNORE
6254 [ALC662_FIXUP_ASUS_MODE6] = {
6255 .type = HDA_FIXUP_PINS,
6256 .v.pins = (const struct hda_pintbl[]) {
6257 { 0x14, 0x99130110 }, /* speaker */
6258 { 0x15, 0x01211420 }, /* HP2 */
6259 { 0x18, 0x01a19840 }, /* mic */
6260 { 0x19, 0x99a3094f }, /* int-mic */
6261 { 0x1b, 0x0121441f }, /* HP */
6265 .chain_id = ALC662_FIXUP_SKU_IGNORE
6267 [ALC662_FIXUP_ASUS_MODE7] = {
6268 .type = HDA_FIXUP_PINS,
6269 .v.pins = (const struct hda_pintbl[]) {
6270 { 0x14, 0x99130110 }, /* speaker */
6271 { 0x17, 0x99130111 }, /* speaker */
6272 { 0x18, 0x01a19840 }, /* mic */
6273 { 0x19, 0x99a3094f }, /* int-mic */
6274 { 0x1b, 0x01214020 }, /* HP */
6275 { 0x21, 0x0121401f }, /* HP */
6279 .chain_id = ALC662_FIXUP_SKU_IGNORE
6281 [ALC662_FIXUP_ASUS_MODE8] = {
6282 .type = HDA_FIXUP_PINS,
6283 .v.pins = (const struct hda_pintbl[]) {
6284 { 0x14, 0x99130110 }, /* speaker */
6285 { 0x12, 0x99a30970 }, /* int-mic */
6286 { 0x15, 0x01214020 }, /* HP */
6287 { 0x17, 0x99130111 }, /* speaker */
6288 { 0x18, 0x01a19840 }, /* mic */
6289 { 0x21, 0x0121401f }, /* HP */
6293 .chain_id = ALC662_FIXUP_SKU_IGNORE
6295 [ALC662_FIXUP_NO_JACK_DETECT] = {
6296 .type = HDA_FIXUP_FUNC,
6297 .v.func = alc_fixup_no_jack_detect,
6299 [ALC662_FIXUP_ZOTAC_Z68] = {
6300 .type = HDA_FIXUP_PINS,
6301 .v.pins = (const struct hda_pintbl[]) {
6302 { 0x1b, 0x02214020 }, /* Front HP */
6306 [ALC662_FIXUP_INV_DMIC] = {
6307 .type = HDA_FIXUP_FUNC,
6308 .v.func = alc_fixup_inv_dmic,
6310 [ALC668_FIXUP_DELL_XPS13] = {
6311 .type = HDA_FIXUP_FUNC,
6312 .v.func = alc_fixup_dell_xps13,
6314 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
6316 [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
6317 .type = HDA_FIXUP_FUNC,
6318 .v.func = alc_fixup_disable_aamix,
6320 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
6322 [ALC668_FIXUP_AUTO_MUTE] = {
6323 .type = HDA_FIXUP_FUNC,
6324 .v.func = alc_fixup_auto_mute_via_amp,
6326 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
6328 [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
6329 .type = HDA_FIXUP_PINS,
6330 .v.pins = (const struct hda_pintbl[]) {
6331 { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
6332 /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
6336 .chain_id = ALC662_FIXUP_HEADSET_MODE
6338 [ALC662_FIXUP_HEADSET_MODE] = {
6339 .type = HDA_FIXUP_FUNC,
6340 .v.func = alc_fixup_headset_mode_alc662,
6342 [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
6343 .type = HDA_FIXUP_PINS,
6344 .v.pins = (const struct hda_pintbl[]) {
6345 { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
6346 { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
6350 .chain_id = ALC668_FIXUP_HEADSET_MODE
6352 [ALC668_FIXUP_HEADSET_MODE] = {
6353 .type = HDA_FIXUP_FUNC,
6354 .v.func = alc_fixup_headset_mode_alc668,
6356 [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
6357 .type = HDA_FIXUP_FUNC,
6358 .v.func = alc_fixup_bass_chmap,
6360 .chain_id = ALC662_FIXUP_ASUS_MODE4
6362 [ALC662_FIXUP_BASS_16] = {
6363 .type = HDA_FIXUP_PINS,
6364 .v.pins = (const struct hda_pintbl[]) {
6365 {0x16, 0x80106111}, /* bass speaker */
6369 .chain_id = ALC662_FIXUP_BASS_CHMAP,
6371 [ALC662_FIXUP_BASS_1A] = {
6372 .type = HDA_FIXUP_PINS,
6373 .v.pins = (const struct hda_pintbl[]) {
6374 {0x1a, 0x80106111}, /* bass speaker */
6378 .chain_id = ALC662_FIXUP_BASS_CHMAP,
6380 [ALC662_FIXUP_BASS_CHMAP] = {
6381 .type = HDA_FIXUP_FUNC,
6382 .v.func = alc_fixup_bass_chmap,
6386 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
6387 SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
6388 SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
6389 SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
6390 SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
6391 SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
6392 SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
6393 SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
6394 SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6395 SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6396 SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
6397 SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
6398 SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
6399 SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6400 SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6401 SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6402 SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6403 SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
6404 SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
6405 SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_BASS_1A),
6406 SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
6407 SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
6408 SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
6409 SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
6410 SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
6411 SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
6412 SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
6413 SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
6414 SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
6415 SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
6416 SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
6419 /* Below is a quirk table taken from the old code.
6420 * Basically the device should work as is without the fixup table.
6421 * If BIOS doesn't give a proper info, enable the corresponding
6424 SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
6425 SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
6426 SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
6427 SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
6428 SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6429 SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6430 SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6431 SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
6432 SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
6433 SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6434 SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
6435 SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
6436 SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
6437 SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
6438 SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
6439 SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6440 SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
6441 SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
6442 SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6443 SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6444 SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6445 SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6446 SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
6447 SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
6448 SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
6449 SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6450 SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
6451 SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
6452 SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6453 SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
6454 SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6455 SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6456 SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
6457 SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
6458 SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
6459 SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
6460 SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
6461 SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
6462 SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
6463 SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
6464 SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
6465 SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
6466 SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6467 SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
6468 SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
6469 SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
6470 SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
6471 SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
6472 SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
6473 SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
6478 static const struct hda_model_fixup alc662_fixup_models[] = {
6479 {.id = ALC272_FIXUP_MARIO, .name = "mario"},
6480 {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
6481 {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
6482 {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
6483 {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
6484 {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
6485 {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
6486 {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
6487 {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
6488 {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
6489 {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
6493 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
6494 SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
6498 {0x1b, 0x0221401f}),
6499 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
6503 {0x16, 0x03011020}),
6504 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
6508 {0x16, 0x03011020}),
6509 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
6513 {0x16, 0x03011020}),
6514 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
6517 {0x16, 0x03011020}),
6518 SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
6521 {0x15, 0x0321101f}),
6527 static int patch_alc662(struct hda_codec *codec)
6529 struct alc_spec *spec;
6532 err = alc_alloc_spec(codec, 0x0b);
6538 spec->shutup = alc_eapd_shutup;
6540 /* handle multiple HPs as is */
6541 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6543 alc_fix_pll_init(codec, 0x20, 0x04, 15);
6545 switch (codec->core.vendor_id) {
6547 spec->init_hook = alc668_restore_default_value;
6551 snd_hda_pick_fixup(codec, alc662_fixup_models,
6552 alc662_fixup_tbl, alc662_fixups);
6553 snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups);
6554 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
6556 alc_auto_parse_customize_define(codec);
6558 if (has_cdefine_beep(codec))
6559 spec->gen.beep_nid = 0x01;
6561 if ((alc_get_coef0(codec) & (1 << 14)) &&
6562 codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
6563 spec->cdefine.platform_type == 1) {
6564 err = alc_codec_rename(codec, "ALC272X");
6569 /* automatic parse from the BIOS config */
6570 err = alc662_parse_auto_config(codec);
6574 if (!spec->gen.no_analog && spec->gen.beep_nid) {
6575 switch (codec->core.vendor_id) {
6577 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
6583 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
6586 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
6591 snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
6604 static int alc680_parse_auto_config(struct hda_codec *codec)
6606 return alc_parse_auto_config(codec, NULL, NULL);
6611 static int patch_alc680(struct hda_codec *codec)
6615 /* ALC680 has no aa-loopback mixer */
6616 err = alc_alloc_spec(codec, 0);
6620 /* automatic parse from the BIOS config */
6621 err = alc680_parse_auto_config(codec);
6633 static const struct hda_device_id snd_hda_id_realtek[] = {
6634 HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
6635 HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
6636 HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
6637 HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
6638 HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
6639 HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
6640 HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
6641 HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
6642 HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
6643 HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
6644 HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
6645 HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
6646 HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
6647 HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
6648 HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
6649 HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
6650 HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
6651 HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
6652 HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
6653 HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
6654 HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
6655 HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
6656 HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
6657 HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
6658 HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
6659 HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
6660 HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
6661 HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
6662 HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
6663 HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
6664 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
6665 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
6666 HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
6667 HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
6668 HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
6669 HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
6670 HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
6671 HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
6672 HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
6673 HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
6674 HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc882),
6675 HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
6676 HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
6677 HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
6678 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
6679 HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
6680 HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
6681 HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
6682 HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
6683 HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
6684 HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
6685 HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
6686 HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
6687 HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
6690 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
6692 MODULE_LICENSE("GPL");
6693 MODULE_DESCRIPTION("Realtek HD-audio codec");
6695 static struct hda_codec_driver realtek_driver = {
6696 .id = snd_hda_id_realtek,
6699 module_hda_codec_driver(realtek_driver);