pci/hda/patch_realtek.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Universal Interface for Intel High Definition Audio Codec
0004  *
0005  * HD audio interface patch for Realtek ALC codecs
0006  *
0007  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
0008  *                    PeiSen Hou <pshou@realtek.com.tw>
0009  *                    Takashi Iwai <tiwai@suse.de>
0010  *                    Jonathan Woithe <jwoithe@just42.net>
0011  */
0012
0013 #include <linux/init.h>
0014 #include <linux/delay.h>
0015 #include <linux/slab.h>
0016 #include <linux/pci.h>
0017 #include <linux/dmi.h>
0018 #include <linux/module.h>
0019 #include <linux/input.h>
0020 #include <linux/leds.h>
0021 #include <sound/core.h>
0022 #include <sound/jack.h>
0023 #include <sound/hda_codec.h>
0024 #include "hda_local.h"
0025 #include "hda_auto_parser.h"
0026 #include "hda_jack.h"
0027 #include "hda_generic.h"
0028 #include "hda_component.h"
0029
0030 /* keep halting ALC5505 DSP, for power saving */
0031 #define HALT_REALTEK_ALC5505
0032
0033 /* extra amp-initialization sequence types */
0034 enum {
0035     ALC_INIT_UNDEFINED,
0036     ALC_INIT_NONE,
0037     ALC_INIT_DEFAULT,
0038 };
0039
0040 enum {
0041     ALC_HEADSET_MODE_UNKNOWN,
0042     ALC_HEADSET_MODE_UNPLUGGED,
0043     ALC_HEADSET_MODE_HEADSET,
0044     ALC_HEADSET_MODE_MIC,
0045     ALC_HEADSET_MODE_HEADPHONE,
0046 };
0047
0048 enum {
0049     ALC_HEADSET_TYPE_UNKNOWN,
0050     ALC_HEADSET_TYPE_CTIA,
0051     ALC_HEADSET_TYPE_OMTP,
0052 };
0053
0054 enum {
0055     ALC_KEY_MICMUTE_INDEX,
0056 };
0057
0058 struct alc_customize_define {
0059     unsigned int  sku_cfg;
0060     unsigned char port_connectivity;
0061     unsigned char check_sum;
0062     unsigned char customization;
0063     unsigned char external_amp;
0064     unsigned int  enable_pcbeep:1;
0065     unsigned int  platform_type:1;
0066     unsigned int  swap:1;
0067     unsigned int  override:1;
0068     unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
0069 };
0070
0071 struct alc_coef_led {
0072     unsigned int idx;
0073     unsigned int mask;
0074     unsigned int on;
0075     unsigned int off;
0076 };
0077
0078 struct alc_spec {
0079     struct hda_gen_spec gen; /* must be at head */
0080
0081     /* codec parameterization */
0082     struct alc_customize_define cdefine;
0083     unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
0084
0085     /* GPIO bits */
0086     unsigned int gpio_mask;
0087     unsigned int gpio_dir;
0088     unsigned int gpio_data;
0089     bool gpio_write_delay;  /* add a delay before writing gpio_data */
0090
0091     /* mute LED for HP laptops, see vref_mute_led_set() */
0092     int mute_led_polarity;
0093     int micmute_led_polarity;
0094     hda_nid_t mute_led_nid;
0095     hda_nid_t cap_mute_led_nid;
0096
0097     unsigned int gpio_mute_led_mask;
0098     unsigned int gpio_mic_led_mask;
0099     struct alc_coef_led mute_led_coef;
0100     struct alc_coef_led mic_led_coef;
0101     struct mutex coef_mutex;
0102
0103     hda_nid_t headset_mic_pin;
0104     hda_nid_t headphone_mic_pin;
0105     int current_headset_mode;
0106     int current_headset_type;
0107
0108     /* hooks */
0109     void (*init_hook)(struct hda_codec *codec);
0110 #ifdef CONFIG_PM
0111     void (*power_hook)(struct hda_codec *codec);
0112 #endif
0113     void (*shutup)(struct hda_codec *codec);
0114
0115     int init_amp;
0116     int codec_variant;  /* flag for other variants */
0117     unsigned int has_alc5505_dsp:1;
0118     unsigned int no_depop_delay:1;
0119     unsigned int done_hp_init:1;
0120     unsigned int no_shutup_pins:1;
0121     unsigned int ultra_low_power:1;
0122     unsigned int has_hs_key:1;
0123     unsigned int no_internal_mic_pin:1;
0124
0125     /* for PLL fix */
0126     hda_nid_t pll_nid;
0127     unsigned int pll_coef_idx, pll_coef_bit;
0128     unsigned int coef0;
0129     struct input_dev *kb_dev;
0130     u8 alc_mute_keycode_map[1];
0131
0132     /* component binding */
0133     struct component_match *match;
0134     struct hda_component comps[HDA_MAX_COMPONENTS];
0135 };
0136
0137 /*
0138  * COEF access helper functions
0139  */
0140
0141 static void coef_mutex_lock(struct hda_codec *codec)
0142 {
0143     struct alc_spec *spec = codec->spec;
0144
0145     snd_hda_power_up_pm(codec);
0146     mutex_lock(&spec->coef_mutex);
0147 }
0148
0149 static void coef_mutex_unlock(struct hda_codec *codec)
0150 {
0151     struct alc_spec *spec = codec->spec;
0152
0153     mutex_unlock(&spec->coef_mutex);
0154     snd_hda_power_down_pm(codec);
0155 }
0156
0157 static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
0158                  unsigned int coef_idx)
0159 {
0160     unsigned int val;
0161
0162     snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
0163     val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
0164     return val;
0165 }
0166
0167 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
0168                    unsigned int coef_idx)
0169 {
0170     unsigned int val;
0171
0172     coef_mutex_lock(codec);
0173     val = __alc_read_coefex_idx(codec, nid, coef_idx);
0174     coef_mutex_unlock(codec);
0175     return val;
0176 }
0177
0178 #define alc_read_coef_idx(codec, coef_idx) \
0179     alc_read_coefex_idx(codec, 0x20, coef_idx)
0180
0181 static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
0182                    unsigned int coef_idx, unsigned int coef_val)
0183 {
0184     snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
0185     snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
0186 }
0187
0188 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
0189                  unsigned int coef_idx, unsigned int coef_val)
0190 {
0191     coef_mutex_lock(codec);
0192     __alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
0193     coef_mutex_unlock(codec);
0194 }
0195
0196 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
0197     alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
0198
0199 static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
0200                     unsigned int coef_idx, unsigned int mask,
0201                     unsigned int bits_set)
0202 {
0203     unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx);
0204
0205     if (val != -1)
0206         __alc_write_coefex_idx(codec, nid, coef_idx,
0207                        (val & ~mask) | bits_set);
0208 }
0209
0210 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
0211                   unsigned int coef_idx, unsigned int mask,
0212                   unsigned int bits_set)
0213 {
0214     coef_mutex_lock(codec);
0215     __alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
0216     coef_mutex_unlock(codec);
0217 }
0218
0219 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set)    \
0220     alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
0221
0222 /* a special bypass for COEF 0; read the cached value at the second time */
0223 static unsigned int alc_get_coef0(struct hda_codec *codec)
0224 {
0225     struct alc_spec *spec = codec->spec;
0226
0227     if (!spec->coef0)
0228         spec->coef0 = alc_read_coef_idx(codec, 0);
0229     return spec->coef0;
0230 }
0231
0232 /* coef writes/updates batch */
0233 struct coef_fw {
0234     unsigned char nid;
0235     unsigned char idx;
0236     unsigned short mask;
0237     unsigned short val;
0238 };
0239
0240 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
0241     { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
0242 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
0243 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
0244 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
0245
0246 static void alc_process_coef_fw(struct hda_codec *codec,
0247                 const struct coef_fw *fw)
0248 {
0249     coef_mutex_lock(codec);
0250     for (; fw->nid; fw++) {
0251         if (fw->mask == (unsigned short)-1)
0252             __alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
0253         else
0254             __alc_update_coefex_idx(codec, fw->nid, fw->idx,
0255                         fw->mask, fw->val);
0256     }
0257     coef_mutex_unlock(codec);
0258 }
0259
0260 /*
0261  * GPIO setup tables, used in initialization
0262  */
0263
0264 /* Enable GPIO mask and set output */
0265 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask)
0266 {
0267     struct alc_spec *spec = codec->spec;
0268
0269     spec->gpio_mask |= mask;
0270     spec->gpio_dir |= mask;
0271     spec->gpio_data |= mask;
0272 }
0273
0274 static void alc_write_gpio_data(struct hda_codec *codec)
0275 {
0276     struct alc_spec *spec = codec->spec;
0277
0278     snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
0279                 spec->gpio_data);
0280 }
0281
0282 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask,
0283                  bool on)
0284 {
0285     struct alc_spec *spec = codec->spec;
0286     unsigned int oldval = spec->gpio_data;
0287
0288     if (on)
0289         spec->gpio_data |= mask;
0290     else
0291         spec->gpio_data &= ~mask;
0292     if (oldval != spec->gpio_data)
0293         alc_write_gpio_data(codec);
0294 }
0295
0296 static void alc_write_gpio(struct hda_codec *codec)
0297 {
0298     struct alc_spec *spec = codec->spec;
0299
0300     if (!spec->gpio_mask)
0301         return;
0302
0303     snd_hda_codec_write(codec, codec->core.afg, 0,
0304                 AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
0305     snd_hda_codec_write(codec, codec->core.afg, 0,
0306                 AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir);
0307     if (spec->gpio_write_delay)
0308         msleep(1);
0309     alc_write_gpio_data(codec);
0310 }
0311
0312 static void alc_fixup_gpio(struct hda_codec *codec, int action,
0313                unsigned int mask)
0314 {
0315     if (action == HDA_FIXUP_ACT_PRE_PROBE)
0316         alc_setup_gpio(codec, mask);
0317 }
0318
0319 static void alc_fixup_gpio1(struct hda_codec *codec,
0320                 const struct hda_fixup *fix, int action)
0321 {
0322     alc_fixup_gpio(codec, action, 0x01);
0323 }
0324
0325 static void alc_fixup_gpio2(struct hda_codec *codec,
0326                 const struct hda_fixup *fix, int action)
0327 {
0328     alc_fixup_gpio(codec, action, 0x02);
0329 }
0330
0331 static void alc_fixup_gpio3(struct hda_codec *codec,
0332                 const struct hda_fixup *fix, int action)
0333 {
0334     alc_fixup_gpio(codec, action, 0x03);
0335 }
0336
0337 static void alc_fixup_gpio4(struct hda_codec *codec,
0338                 const struct hda_fixup *fix, int action)
0339 {
0340     alc_fixup_gpio(codec, action, 0x04);
0341 }
0342
0343 static void alc_fixup_micmute_led(struct hda_codec *codec,
0344                   const struct hda_fixup *fix, int action)
0345 {
0346     if (action == HDA_FIXUP_ACT_PRE_PROBE)
0347         snd_hda_gen_add_micmute_led_cdev(codec, NULL);
0348 }
0349
0350 /*
0351  * Fix hardware PLL issue
0352  * On some codecs, the analog PLL gating control must be off while
0353  * the default value is 1.
0354  */
0355 static void alc_fix_pll(struct hda_codec *codec)
0356 {
0357     struct alc_spec *spec = codec->spec;
0358
0359     if (spec->pll_nid)
0360         alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
0361                       1 << spec->pll_coef_bit, 0);
0362 }
0363
0364 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
0365                  unsigned int coef_idx, unsigned int coef_bit)
0366 {
0367     struct alc_spec *spec = codec->spec;
0368     spec->pll_nid = nid;
0369     spec->pll_coef_idx = coef_idx;
0370     spec->pll_coef_bit = coef_bit;
0371     alc_fix_pll(codec);
0372 }
0373
0374 /* update the master volume per volume-knob's unsol event */
0375 static void alc_update_knob_master(struct hda_codec *codec,
0376                    struct hda_jack_callback *jack)
0377 {
0378     unsigned int val;
0379     struct snd_kcontrol *kctl;
0380     struct snd_ctl_elem_value *uctl;
0381
0382     kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
0383     if (!kctl)
0384         return;
0385     uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
0386     if (!uctl)
0387         return;
0388     val = snd_hda_codec_read(codec, jack->nid, 0,
0389                  AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
0390     val &= HDA_AMP_VOLMASK;
0391     uctl->value.integer.value[0] = val;
0392     uctl->value.integer.value[1] = val;
0393     kctl->put(kctl, uctl);
0394     kfree(uctl);
0395 }
0396
0397 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
0398 {
0399     /* For some reason, the res given from ALC880 is broken.
0400        Here we adjust it properly. */
0401     snd_hda_jack_unsol_event(codec, res >> 2);
0402 }
0403
0404 /* Change EAPD to verb control */
0405 static void alc_fill_eapd_coef(struct hda_codec *codec)
0406 {
0407     int coef;
0408
0409     coef = alc_get_coef0(codec);
0410
0411     switch (codec->core.vendor_id) {
0412     case 0x10ec0262:
0413         alc_update_coef_idx(codec, 0x7, 0, 1<<5);
0414         break;
0415     case 0x10ec0267:
0416     case 0x10ec0268:
0417         alc_update_coef_idx(codec, 0x7, 0, 1<<13);
0418         break;
0419     case 0x10ec0269:
0420         if ((coef & 0x00f0) == 0x0010)
0421             alc_update_coef_idx(codec, 0xd, 0, 1<<14);
0422         if ((coef & 0x00f0) == 0x0020)
0423             alc_update_coef_idx(codec, 0x4, 1<<15, 0);
0424         if ((coef & 0x00f0) == 0x0030)
0425             alc_update_coef_idx(codec, 0x10, 1<<9, 0);
0426         break;
0427     case 0x10ec0280:
0428     case 0x10ec0284:
0429     case 0x10ec0290:
0430     case 0x10ec0292:
0431         alc_update_coef_idx(codec, 0x4, 1<<15, 0);
0432         break;
0433     case 0x10ec0225:
0434     case 0x10ec0295:
0435     case 0x10ec0299:
0436         alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
0437         fallthrough;
0438     case 0x10ec0215:
0439     case 0x10ec0230:
0440     case 0x10ec0233:
0441     case 0x10ec0235:
0442     case 0x10ec0236:
0443     case 0x10ec0245:
0444     case 0x10ec0255:
0445     case 0x10ec0256:
0446     case 0x19e58326:
0447     case 0x10ec0257:
0448     case 0x10ec0282:
0449     case 0x10ec0283:
0450     case 0x10ec0286:
0451     case 0x10ec0288:
0452     case 0x10ec0285:
0453     case 0x10ec0298:
0454     case 0x10ec0289:
0455     case 0x10ec0300:
0456         alc_update_coef_idx(codec, 0x10, 1<<9, 0);
0457         break;
0458     case 0x10ec0275:
0459         alc_update_coef_idx(codec, 0xe, 0, 1<<0);
0460         break;
0461     case 0x10ec0287:
0462         alc_update_coef_idx(codec, 0x10, 1<<9, 0);
0463         alc_write_coef_idx(codec, 0x8, 0x4ab7);
0464         break;
0465     case 0x10ec0293:
0466         alc_update_coef_idx(codec, 0xa, 1<<13, 0);
0467         break;
0468     case 0x10ec0234:
0469     case 0x10ec0274:
0470     case 0x10ec0294:
0471     case 0x10ec0700:
0472     case 0x10ec0701:
0473     case 0x10ec0703:
0474     case 0x10ec0711:
0475         alc_update_coef_idx(codec, 0x10, 1<<15, 0);
0476         break;
0477     case 0x10ec0662:
0478         if ((coef & 0x00f0) == 0x0030)
0479             alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
0480         break;
0481     case 0x10ec0272:
0482     case 0x10ec0273:
0483     case 0x10ec0663:
0484     case 0x10ec0665:
0485     case 0x10ec0670:
0486     case 0x10ec0671:
0487     case 0x10ec0672:
0488         alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
0489         break;
0490     case 0x10ec0222:
0491     case 0x10ec0623:
0492         alc_update_coef_idx(codec, 0x19, 1<<13, 0);
0493         break;
0494     case 0x10ec0668:
0495         alc_update_coef_idx(codec, 0x7, 3<<13, 0);
0496         break;
0497     case 0x10ec0867:
0498         alc_update_coef_idx(codec, 0x4, 1<<10, 0);
0499         break;
0500     case 0x10ec0888:
0501         if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
0502             alc_update_coef_idx(codec, 0x7, 1<<5, 0);
0503         break;
0504     case 0x10ec0892:
0505     case 0x10ec0897:
0506         alc_update_coef_idx(codec, 0x7, 1<<5, 0);
0507         break;
0508     case 0x10ec0899:
0509     case 0x10ec0900:
0510     case 0x10ec0b00:
0511     case 0x10ec1168:
0512     case 0x10ec1220:
0513         alc_update_coef_idx(codec, 0x7, 1<<1, 0);
0514         break;
0515     }
0516 }
0517
0518 /* additional initialization for ALC888 variants */
0519 static void alc888_coef_init(struct hda_codec *codec)
0520 {
0521     switch (alc_get_coef0(codec) & 0x00f0) {
0522     /* alc888-VA */
0523     case 0x00:
0524     /* alc888-VB */
0525     case 0x10:
0526         alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
0527         break;
0528     }
0529 }
0530
0531 /* turn on/off EAPD control (only if available) */
0532 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
0533 {
0534     if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
0535         return;
0536     if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
0537         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
0538                     on ? 2 : 0);
0539 }
0540
0541 /* turn on/off EAPD controls of the codec */
0542 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
0543 {
0544     /* We currently only handle front, HP */
0545     static const hda_nid_t pins[] = {
0546         0x0f, 0x10, 0x14, 0x15, 0x17, 0
0547     };
0548     const hda_nid_t *p;
0549     for (p = pins; *p; p++)
0550         set_eapd(codec, *p, on);
0551 }
0552
0553 static int find_ext_mic_pin(struct hda_codec *codec);
0554
0555 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
0556 {
0557     const struct hda_pincfg *pin;
0558     int mic_pin = find_ext_mic_pin(codec);
0559     int i;
0560
0561     /* don't shut up pins when unloading the driver; otherwise it breaks
0562      * the default pin setup at the next load of the driver
0563      */
0564     if (codec->bus->shutdown)
0565         return;
0566
0567     snd_array_for_each(&codec->init_pins, i, pin) {
0568         /* use read here for syncing after issuing each verb */
0569         if (pin->nid != mic_pin)
0570             snd_hda_codec_read(codec, pin->nid, 0,
0571                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
0572     }
0573
0574     codec->pins_shutup = 1;
0575 }
0576
0577 static void alc_shutup_pins(struct hda_codec *codec)
0578 {
0579     struct alc_spec *spec = codec->spec;
0580
0581     switch (codec->core.vendor_id) {
0582     case 0x10ec0236:
0583     case 0x10ec0256:
0584     case 0x19e58326:
0585     case 0x10ec0283:
0586     case 0x10ec0286:
0587     case 0x10ec0288:
0588     case 0x10ec0298:
0589         alc_headset_mic_no_shutup(codec);
0590         break;
0591     default:
0592         if (!spec->no_shutup_pins)
0593             snd_hda_shutup_pins(codec);
0594         break;
0595     }
0596 }
0597
0598 /* generic shutup callback;
0599  * just turning off EAPD and a little pause for avoiding pop-noise
0600  */
0601 static void alc_eapd_shutup(struct hda_codec *codec)
0602 {
0603     struct alc_spec *spec = codec->spec;
0604
0605     alc_auto_setup_eapd(codec, false);
0606     if (!spec->no_depop_delay)
0607         msleep(200);
0608     alc_shutup_pins(codec);
0609 }
0610
0611 /* generic EAPD initialization */
0612 static void alc_auto_init_amp(struct hda_codec *codec, int type)
0613 {
0614     alc_auto_setup_eapd(codec, true);
0615     alc_write_gpio(codec);
0616     switch (type) {
0617     case ALC_INIT_DEFAULT:
0618         switch (codec->core.vendor_id) {
0619         case 0x10ec0260:
0620             alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
0621             break;
0622         case 0x10ec0880:
0623         case 0x10ec0882:
0624         case 0x10ec0883:
0625         case 0x10ec0885:
0626             alc_update_coef_idx(codec, 7, 0, 0x2030);
0627             break;
0628         case 0x10ec0888:
0629             alc888_coef_init(codec);
0630             break;
0631         }
0632         break;
0633     }
0634 }
0635
0636 /* get a primary headphone pin if available */
0637 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
0638 {
0639     if (spec->gen.autocfg.hp_pins[0])
0640         return spec->gen.autocfg.hp_pins[0];
0641     if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
0642         return spec->gen.autocfg.line_out_pins[0];
0643     return 0;
0644 }
0645
0646 /*
0647  * Realtek SSID verification
0648  */
0649
0650 /* Could be any non-zero and even value. When used as fixup, tells
0651  * the driver to ignore any present sku defines.
0652  */
0653 #define ALC_FIXUP_SKU_IGNORE (2)
0654
0655 static void alc_fixup_sku_ignore(struct hda_codec *codec,
0656                  const struct hda_fixup *fix, int action)
0657 {
0658     struct alc_spec *spec = codec->spec;
0659     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
0660         spec->cdefine.fixup = 1;
0661         spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
0662     }
0663 }
0664
0665 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
0666                     const struct hda_fixup *fix, int action)
0667 {
0668     struct alc_spec *spec = codec->spec;
0669
0670     if (action == HDA_FIXUP_ACT_PROBE) {
0671         spec->no_depop_delay = 1;
0672         codec->depop_delay = 0;
0673     }
0674 }
0675
0676 static int alc_auto_parse_customize_define(struct hda_codec *codec)
0677 {
0678     unsigned int ass, tmp, i;
0679     unsigned nid = 0;
0680     struct alc_spec *spec = codec->spec;
0681
0682     spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
0683
0684     if (spec->cdefine.fixup) {
0685         ass = spec->cdefine.sku_cfg;
0686         if (ass == ALC_FIXUP_SKU_IGNORE)
0687             return -1;
0688         goto do_sku;
0689     }
0690
0691     if (!codec->bus->pci)
0692         return -1;
0693     ass = codec->core.subsystem_id & 0xffff;
0694     if (ass != codec->bus->pci->subsystem_device && (ass & 1))
0695         goto do_sku;
0696
0697     nid = 0x1d;
0698     if (codec->core.vendor_id == 0x10ec0260)
0699         nid = 0x17;
0700     ass = snd_hda_codec_get_pincfg(codec, nid);
0701
0702     if (!(ass & 1)) {
0703         codec_info(codec, "%s: SKU not ready 0x%08x\n",
0704                codec->core.chip_name, ass);
0705         return -1;
0706     }
0707
0708     /* check sum */
0709     tmp = 0;
0710     for (i = 1; i < 16; i++) {
0711         if ((ass >> i) & 1)
0712             tmp++;
0713     }
0714     if (((ass >> 16) & 0xf) != tmp)
0715         return -1;
0716
0717     spec->cdefine.port_connectivity = ass >> 30;
0718     spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
0719     spec->cdefine.check_sum = (ass >> 16) & 0xf;
0720     spec->cdefine.customization = ass >> 8;
0721 do_sku:
0722     spec->cdefine.sku_cfg = ass;
0723     spec->cdefine.external_amp = (ass & 0x38) >> 3;
0724     spec->cdefine.platform_type = (ass & 0x4) >> 2;
0725     spec->cdefine.swap = (ass & 0x2) >> 1;
0726     spec->cdefine.override = ass & 0x1;
0727
0728     codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
0729            nid, spec->cdefine.sku_cfg);
0730     codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
0731            spec->cdefine.port_connectivity);
0732     codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
0733     codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
0734     codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
0735     codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
0736     codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
0737     codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
0738     codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
0739
0740     return 0;
0741 }
0742
0743 /* return the position of NID in the list, or -1 if not found */
0744 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
0745 {
0746     int i;
0747     for (i = 0; i < nums; i++)
0748         if (list[i] == nid)
0749             return i;
0750     return -1;
0751 }
0752 /* return true if the given NID is found in the list */
0753 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
0754 {
0755     return find_idx_in_nid_list(nid, list, nums) >= 0;
0756 }
0757
0758 /* check subsystem ID and set up device-specific initialization;
0759  * return 1 if initialized, 0 if invalid SSID
0760  */
0761 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
0762  *  31 ~ 16 :   Manufacture ID
0763  *  15 ~ 8  :   SKU ID
0764  *  7  ~ 0  :   Assembly ID
0765  *  port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
0766  */
0767 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
0768 {
0769     unsigned int ass, tmp, i;
0770     unsigned nid;
0771     struct alc_spec *spec = codec->spec;
0772
0773     if (spec->cdefine.fixup) {
0774         ass = spec->cdefine.sku_cfg;
0775         if (ass == ALC_FIXUP_SKU_IGNORE)
0776             return 0;
0777         goto do_sku;
0778     }
0779
0780     ass = codec->core.subsystem_id & 0xffff;
0781     if (codec->bus->pci &&
0782         ass != codec->bus->pci->subsystem_device && (ass & 1))
0783         goto do_sku;
0784
0785     /* invalid SSID, check the special NID pin defcfg instead */
0786     /*
0787      * 31~30    : port connectivity
0788      * 29~21    : reserve
0789      * 20       : PCBEEP input
0790      * 19~16    : Check sum (15:1)
0791      * 15~1     : Custom
0792      * 0        : override
0793     */
0794     nid = 0x1d;
0795     if (codec->core.vendor_id == 0x10ec0260)
0796         nid = 0x17;
0797     ass = snd_hda_codec_get_pincfg(codec, nid);
0798     codec_dbg(codec,
0799           "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
0800            ass, nid);
0801     if (!(ass & 1))
0802         return 0;
0803     if ((ass >> 30) != 1)   /* no physical connection */
0804         return 0;
0805
0806     /* check sum */
0807     tmp = 0;
0808     for (i = 1; i < 16; i++) {
0809         if ((ass >> i) & 1)
0810             tmp++;
0811     }
0812     if (((ass >> 16) & 0xf) != tmp)
0813         return 0;
0814 do_sku:
0815     codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
0816            ass & 0xffff, codec->core.vendor_id);
0817     /*
0818      * 0 : override
0819      * 1 :  Swap Jack
0820      * 2 : 0 --> Desktop, 1 --> Laptop
0821      * 3~5 : External Amplifier control
0822      * 7~6 : Reserved
0823     */
0824     tmp = (ass & 0x38) >> 3;    /* external Amp control */
0825     if (spec->init_amp == ALC_INIT_UNDEFINED) {
0826         switch (tmp) {
0827         case 1:
0828             alc_setup_gpio(codec, 0x01);
0829             break;
0830         case 3:
0831             alc_setup_gpio(codec, 0x02);
0832             break;
0833         case 7:
0834             alc_setup_gpio(codec, 0x03);
0835             break;
0836         case 5:
0837         default:
0838             spec->init_amp = ALC_INIT_DEFAULT;
0839             break;
0840         }
0841     }
0842
0843     /* is laptop or Desktop and enable the function "Mute internal speaker
0844      * when the external headphone out jack is plugged"
0845      */
0846     if (!(ass & 0x8000))
0847         return 1;
0848     /*
0849      * 10~8 : Jack location
0850      * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
0851      * 14~13: Resvered
0852      * 15   : 1 --> enable the function "Mute internal speaker
0853      *          when the external headphone out jack is plugged"
0854      */
0855     if (!alc_get_hp_pin(spec)) {
0856         hda_nid_t nid;
0857         tmp = (ass >> 11) & 0x3;    /* HP to chassis */
0858         nid = ports[tmp];
0859         if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
0860                       spec->gen.autocfg.line_outs))
0861             return 1;
0862         spec->gen.autocfg.hp_pins[0] = nid;
0863     }
0864     return 1;
0865 }
0866
0867 /* Check the validity of ALC subsystem-id
0868  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
0869 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
0870 {
0871     if (!alc_subsystem_id(codec, ports)) {
0872         struct alc_spec *spec = codec->spec;
0873         if (spec->init_amp == ALC_INIT_UNDEFINED) {
0874             codec_dbg(codec,
0875                   "realtek: Enable default setup for auto mode as fallback\n");
0876             spec->init_amp = ALC_INIT_DEFAULT;
0877         }
0878     }
0879 }
0880
0881 /*
0882  */
0883
0884 static void alc_fixup_inv_dmic(struct hda_codec *codec,
0885                    const struct hda_fixup *fix, int action)
0886 {
0887     struct alc_spec *spec = codec->spec;
0888
0889     spec->gen.inv_dmic_split = 1;
0890 }
0891
0892
0893 static int alc_build_controls(struct hda_codec *codec)
0894 {
0895     int err;
0896
0897     err = snd_hda_gen_build_controls(codec);
0898     if (err < 0)
0899         return err;
0900
0901     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
0902     return 0;
0903 }
0904
0905
0906 /*
0907  * Common callbacks
0908  */
0909
0910 static void alc_pre_init(struct hda_codec *codec)
0911 {
0912     alc_fill_eapd_coef(codec);
0913 }
0914
0915 #define is_s3_resume(codec) \
0916     ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
0917 #define is_s4_resume(codec) \
0918     ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
0919
0920 static int alc_init(struct hda_codec *codec)
0921 {
0922     struct alc_spec *spec = codec->spec;
0923
0924     /* hibernation resume needs the full chip initialization */
0925     if (is_s4_resume(codec))
0926         alc_pre_init(codec);
0927
0928     if (spec->init_hook)
0929         spec->init_hook(codec);
0930
0931     spec->gen.skip_verbs = 1; /* applied in below */
0932     snd_hda_gen_init(codec);
0933     alc_fix_pll(codec);
0934     alc_auto_init_amp(codec, spec->init_amp);
0935     snd_hda_apply_verbs(codec); /* apply verbs here after own init */
0936
0937     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
0938
0939     return 0;
0940 }
0941
0942 #define alc_free    snd_hda_gen_free
0943
0944 #ifdef CONFIG_PM
0945 static inline void alc_shutup(struct hda_codec *codec)
0946 {
0947     struct alc_spec *spec = codec->spec;
0948
0949     if (!snd_hda_get_bool_hint(codec, "shutup"))
0950         return; /* disabled explicitly by hints */
0951
0952     if (spec && spec->shutup)
0953         spec->shutup(codec);
0954     else
0955         alc_shutup_pins(codec);
0956 }
0957
0958 static void alc_power_eapd(struct hda_codec *codec)
0959 {
0960     alc_auto_setup_eapd(codec, false);
0961 }
0962
0963 static int alc_suspend(struct hda_codec *codec)
0964 {
0965     struct alc_spec *spec = codec->spec;
0966     alc_shutup(codec);
0967     if (spec && spec->power_hook)
0968         spec->power_hook(codec);
0969     return 0;
0970 }
0971
0972 static int alc_resume(struct hda_codec *codec)
0973 {
0974     struct alc_spec *spec = codec->spec;
0975
0976     if (!spec->no_depop_delay)
0977         msleep(150); /* to avoid pop noise */
0978     codec->patch_ops.init(codec);
0979     snd_hda_regmap_sync(codec);
0980     hda_call_check_power_status(codec, 0x01);
0981     return 0;
0982 }
0983 #endif
0984
0985 /*
0986  */
0987 static const struct hda_codec_ops alc_patch_ops = {
0988     .build_controls = alc_build_controls,
0989     .build_pcms = snd_hda_gen_build_pcms,
0990     .init = alc_init,
0991     .free = alc_free,
0992     .unsol_event = snd_hda_jack_unsol_event,
0993 #ifdef CONFIG_PM
0994     .resume = alc_resume,
0995     .suspend = alc_suspend,
0996     .check_power_status = snd_hda_gen_check_power_status,
0997 #endif
0998 };
0999
1000
1001 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
1002
1003 /*
1004  * Rename codecs appropriately from COEF value or subvendor id
1005  */
1006 struct alc_codec_rename_table {
1007     unsigned int vendor_id;
1008     unsigned short coef_mask;
1009     unsigned short coef_bits;
1010     const char *name;
1011 };
1012
1013 struct alc_codec_rename_pci_table {
1014     unsigned int codec_vendor_id;
1015     unsigned short pci_subvendor;
1016     unsigned short pci_subdevice;
1017     const char *name;
1018 };
1019
1020 static const struct alc_codec_rename_table rename_tbl[] = {
1021     { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
1022     { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
1023     { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
1024     { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
1025     { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
1026     { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
1027     { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
1028     { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
1029     { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
1030     { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
1031     { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
1032     { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
1033     { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
1034     { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
1035     { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
1036     { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
1037     { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
1038     { } /* terminator */
1039 };
1040
1041 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = {
1042     { 0x10ec0280, 0x1028, 0, "ALC3220" },
1043     { 0x10ec0282, 0x1028, 0, "ALC3221" },
1044     { 0x10ec0283, 0x1028, 0, "ALC3223" },
1045     { 0x10ec0288, 0x1028, 0, "ALC3263" },
1046     { 0x10ec0292, 0x1028, 0, "ALC3226" },
1047     { 0x10ec0293, 0x1028, 0, "ALC3235" },
1048     { 0x10ec0255, 0x1028, 0, "ALC3234" },
1049     { 0x10ec0668, 0x1028, 0, "ALC3661" },
1050     { 0x10ec0275, 0x1028, 0, "ALC3260" },
1051     { 0x10ec0899, 0x1028, 0, "ALC3861" },
1052     { 0x10ec0298, 0x1028, 0, "ALC3266" },
1053     { 0x10ec0236, 0x1028, 0, "ALC3204" },
1054     { 0x10ec0256, 0x1028, 0, "ALC3246" },
1055     { 0x10ec0225, 0x1028, 0, "ALC3253" },
1056     { 0x10ec0295, 0x1028, 0, "ALC3254" },
1057     { 0x10ec0299, 0x1028, 0, "ALC3271" },
1058     { 0x10ec0670, 0x1025, 0, "ALC669X" },
1059     { 0x10ec0676, 0x1025, 0, "ALC679X" },
1060     { 0x10ec0282, 0x1043, 0, "ALC3229" },
1061     { 0x10ec0233, 0x1043, 0, "ALC3236" },
1062     { 0x10ec0280, 0x103c, 0, "ALC3228" },
1063     { 0x10ec0282, 0x103c, 0, "ALC3227" },
1064     { 0x10ec0286, 0x103c, 0, "ALC3242" },
1065     { 0x10ec0290, 0x103c, 0, "ALC3241" },
1066     { 0x10ec0668, 0x103c, 0, "ALC3662" },
1067     { 0x10ec0283, 0x17aa, 0, "ALC3239" },
1068     { 0x10ec0292, 0x17aa, 0, "ALC3232" },
1069     { } /* terminator */
1070 };
1071
1072 static int alc_codec_rename_from_preset(struct hda_codec *codec)
1073 {
1074     const struct alc_codec_rename_table *p;
1075     const struct alc_codec_rename_pci_table *q;
1076
1077     for (p = rename_tbl; p->vendor_id; p++) {
1078         if (p->vendor_id != codec->core.vendor_id)
1079             continue;
1080         if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1081             return alc_codec_rename(codec, p->name);
1082     }
1083
1084     if (!codec->bus->pci)
1085         return 0;
1086     for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1087         if (q->codec_vendor_id != codec->core.vendor_id)
1088             continue;
1089         if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1090             continue;
1091         if (!q->pci_subdevice ||
1092             q->pci_subdevice == codec->bus->pci->subsystem_device)
1093             return alc_codec_rename(codec, q->name);
1094     }
1095
1096     return 0;
1097 }
1098
1099
1100 /*
1101  * Digital-beep handlers
1102  */
1103 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1104
1105 /* additional beep mixers; private_value will be overwritten */
1106 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1107     HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1108     HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1109 };
1110
1111 /* set up and create beep controls */
1112 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1113             int idx, int dir)
1114 {
1115     struct snd_kcontrol_new *knew;
1116     unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1117     int i;
1118
1119     for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1120         knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1121                         &alc_beep_mixer[i]);
1122         if (!knew)
1123             return -ENOMEM;
1124         knew->private_value = beep_amp;
1125     }
1126     return 0;
1127 }
1128
1129 static const struct snd_pci_quirk beep_allow_list[] = {
1130     SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1131     SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1132     SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1133     SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1134     SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1135     SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1136     SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1137     SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1138     SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1139     /* denylist -- no beep available */
1140     SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1141     SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1142     {}
1143 };
1144
1145 static inline int has_cdefine_beep(struct hda_codec *codec)
1146 {
1147     struct alc_spec *spec = codec->spec;
1148     const struct snd_pci_quirk *q;
1149     q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list);
1150     if (q)
1151         return q->value;
1152     return spec->cdefine.enable_pcbeep;
1153 }
1154 #else
1155 #define set_beep_amp(spec, nid, idx, dir)   0
1156 #define has_cdefine_beep(codec)     0
1157 #endif
1158
1159 /* parse the BIOS configuration and set up the alc_spec */
1160 /* return 1 if successful, 0 if the proper config is not found,
1161  * or a negative error code
1162  */
1163 static int alc_parse_auto_config(struct hda_codec *codec,
1164                  const hda_nid_t *ignore_nids,
1165                  const hda_nid_t *ssid_nids)
1166 {
1167     struct alc_spec *spec = codec->spec;
1168     struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1169     int err;
1170
1171     err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1172                        spec->parse_flags);
1173     if (err < 0)
1174         return err;
1175
1176     if (ssid_nids)
1177         alc_ssid_check(codec, ssid_nids);
1178
1179     err = snd_hda_gen_parse_auto_config(codec, cfg);
1180     if (err < 0)
1181         return err;
1182
1183     return 1;
1184 }
1185
1186 /* common preparation job for alc_spec */
1187 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1188 {
1189     struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1190     int err;
1191
1192     if (!spec)
1193         return -ENOMEM;
1194     codec->spec = spec;
1195     snd_hda_gen_spec_init(&spec->gen);
1196     spec->gen.mixer_nid = mixer_nid;
1197     spec->gen.own_eapd_ctl = 1;
1198     codec->single_adc_amp = 1;
1199     /* FIXME: do we need this for all Realtek codec models? */
1200     codec->spdif_status_reset = 1;
1201     codec->forced_resume = 1;
1202     codec->patch_ops = alc_patch_ops;
1203     mutex_init(&spec->coef_mutex);
1204
1205     err = alc_codec_rename_from_preset(codec);
1206     if (err < 0) {
1207         kfree(spec);
1208         return err;
1209     }
1210     return 0;
1211 }
1212
1213 static int alc880_parse_auto_config(struct hda_codec *codec)
1214 {
1215     static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1216     static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1217     return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1218 }
1219
1220 /*
1221  * ALC880 fix-ups
1222  */
1223 enum {
1224     ALC880_FIXUP_GPIO1,
1225     ALC880_FIXUP_GPIO2,
1226     ALC880_FIXUP_MEDION_RIM,
1227     ALC880_FIXUP_LG,
1228     ALC880_FIXUP_LG_LW25,
1229     ALC880_FIXUP_W810,
1230     ALC880_FIXUP_EAPD_COEF,
1231     ALC880_FIXUP_TCL_S700,
1232     ALC880_FIXUP_VOL_KNOB,
1233     ALC880_FIXUP_FUJITSU,
1234     ALC880_FIXUP_F1734,
1235     ALC880_FIXUP_UNIWILL,
1236     ALC880_FIXUP_UNIWILL_DIG,
1237     ALC880_FIXUP_Z71V,
1238     ALC880_FIXUP_ASUS_W5A,
1239     ALC880_FIXUP_3ST_BASE,
1240     ALC880_FIXUP_3ST,
1241     ALC880_FIXUP_3ST_DIG,
1242     ALC880_FIXUP_5ST_BASE,
1243     ALC880_FIXUP_5ST,
1244     ALC880_FIXUP_5ST_DIG,
1245     ALC880_FIXUP_6ST_BASE,
1246     ALC880_FIXUP_6ST,
1247     ALC880_FIXUP_6ST_DIG,
1248     ALC880_FIXUP_6ST_AUTOMUTE,
1249 };
1250
1251 /* enable the volume-knob widget support on NID 0x21 */
1252 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1253                   const struct hda_fixup *fix, int action)
1254 {
1255     if (action == HDA_FIXUP_ACT_PROBE)
1256         snd_hda_jack_detect_enable_callback(codec, 0x21,
1257                             alc_update_knob_master);
1258 }
1259
1260 static const struct hda_fixup alc880_fixups[] = {
1261     [ALC880_FIXUP_GPIO1] = {
1262         .type = HDA_FIXUP_FUNC,
1263         .v.func = alc_fixup_gpio1,
1264     },
1265     [ALC880_FIXUP_GPIO2] = {
1266         .type = HDA_FIXUP_FUNC,
1267         .v.func = alc_fixup_gpio2,
1268     },
1269     [ALC880_FIXUP_MEDION_RIM] = {
1270         .type = HDA_FIXUP_VERBS,
1271         .v.verbs = (const struct hda_verb[]) {
1272             { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1273             { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1274             { }
1275         },
1276         .chained = true,
1277         .chain_id = ALC880_FIXUP_GPIO2,
1278     },
1279     [ALC880_FIXUP_LG] = {
1280         .type = HDA_FIXUP_PINS,
1281         .v.pins = (const struct hda_pintbl[]) {
1282             /* disable bogus unused pins */
1283             { 0x16, 0x411111f0 },
1284             { 0x18, 0x411111f0 },
1285             { 0x1a, 0x411111f0 },
1286             { }
1287         }
1288     },
1289     [ALC880_FIXUP_LG_LW25] = {
1290         .type = HDA_FIXUP_PINS,
1291         .v.pins = (const struct hda_pintbl[]) {
1292             { 0x1a, 0x0181344f }, /* line-in */
1293             { 0x1b, 0x0321403f }, /* headphone */
1294             { }
1295         }
1296     },
1297     [ALC880_FIXUP_W810] = {
1298         .type = HDA_FIXUP_PINS,
1299         .v.pins = (const struct hda_pintbl[]) {
1300             /* disable bogus unused pins */
1301             { 0x17, 0x411111f0 },
1302             { }
1303         },
1304         .chained = true,
1305         .chain_id = ALC880_FIXUP_GPIO2,
1306     },
1307     [ALC880_FIXUP_EAPD_COEF] = {
1308         .type = HDA_FIXUP_VERBS,
1309         .v.verbs = (const struct hda_verb[]) {
1310             /* change to EAPD mode */
1311             { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1312             { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1313             {}
1314         },
1315     },
1316     [ALC880_FIXUP_TCL_S700] = {
1317         .type = HDA_FIXUP_VERBS,
1318         .v.verbs = (const struct hda_verb[]) {
1319             /* change to EAPD mode */
1320             { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1321             { 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
1322             {}
1323         },
1324         .chained = true,
1325         .chain_id = ALC880_FIXUP_GPIO2,
1326     },
1327     [ALC880_FIXUP_VOL_KNOB] = {
1328         .type = HDA_FIXUP_FUNC,
1329         .v.func = alc880_fixup_vol_knob,
1330     },
1331     [ALC880_FIXUP_FUJITSU] = {
1332         /* override all pins as BIOS on old Amilo is broken */
1333         .type = HDA_FIXUP_PINS,
1334         .v.pins = (const struct hda_pintbl[]) {
1335             { 0x14, 0x0121401f }, /* HP */
1336             { 0x15, 0x99030120 }, /* speaker */
1337             { 0x16, 0x99030130 }, /* bass speaker */
1338             { 0x17, 0x411111f0 }, /* N/A */
1339             { 0x18, 0x411111f0 }, /* N/A */
1340             { 0x19, 0x01a19950 }, /* mic-in */
1341             { 0x1a, 0x411111f0 }, /* N/A */
1342             { 0x1b, 0x411111f0 }, /* N/A */
1343             { 0x1c, 0x411111f0 }, /* N/A */
1344             { 0x1d, 0x411111f0 }, /* N/A */
1345             { 0x1e, 0x01454140 }, /* SPDIF out */
1346             { }
1347         },
1348         .chained = true,
1349         .chain_id = ALC880_FIXUP_VOL_KNOB,
1350     },
1351     [ALC880_FIXUP_F1734] = {
1352         /* almost compatible with FUJITSU, but no bass and SPDIF */
1353         .type = HDA_FIXUP_PINS,
1354         .v.pins = (const struct hda_pintbl[]) {
1355             { 0x14, 0x0121401f }, /* HP */
1356             { 0x15, 0x99030120 }, /* speaker */
1357             { 0x16, 0x411111f0 }, /* N/A */
1358             { 0x17, 0x411111f0 }, /* N/A */
1359             { 0x18, 0x411111f0 }, /* N/A */
1360             { 0x19, 0x01a19950 }, /* mic-in */
1361             { 0x1a, 0x411111f0 }, /* N/A */
1362             { 0x1b, 0x411111f0 }, /* N/A */
1363             { 0x1c, 0x411111f0 }, /* N/A */
1364             { 0x1d, 0x411111f0 }, /* N/A */
1365             { 0x1e, 0x411111f0 }, /* N/A */
1366             { }
1367         },
1368         .chained = true,
1369         .chain_id = ALC880_FIXUP_VOL_KNOB,
1370     },
1371     [ALC880_FIXUP_UNIWILL] = {
1372         /* need to fix HP and speaker pins to be parsed correctly */
1373         .type = HDA_FIXUP_PINS,
1374         .v.pins = (const struct hda_pintbl[]) {
1375             { 0x14, 0x0121411f }, /* HP */
1376             { 0x15, 0x99030120 }, /* speaker */
1377             { 0x16, 0x99030130 }, /* bass speaker */
1378             { }
1379         },
1380     },
1381     [ALC880_FIXUP_UNIWILL_DIG] = {
1382         .type = HDA_FIXUP_PINS,
1383         .v.pins = (const struct hda_pintbl[]) {
1384             /* disable bogus unused pins */
1385             { 0x17, 0x411111f0 },
1386             { 0x19, 0x411111f0 },
1387             { 0x1b, 0x411111f0 },
1388             { 0x1f, 0x411111f0 },
1389             { }
1390         }
1391     },
1392     [ALC880_FIXUP_Z71V] = {
1393         .type = HDA_FIXUP_PINS,
1394         .v.pins = (const struct hda_pintbl[]) {
1395             /* set up the whole pins as BIOS is utterly broken */
1396             { 0x14, 0x99030120 }, /* speaker */
1397             { 0x15, 0x0121411f }, /* HP */
1398             { 0x16, 0x411111f0 }, /* N/A */
1399             { 0x17, 0x411111f0 }, /* N/A */
1400             { 0x18, 0x01a19950 }, /* mic-in */
1401             { 0x19, 0x411111f0 }, /* N/A */
1402             { 0x1a, 0x01813031 }, /* line-in */
1403             { 0x1b, 0x411111f0 }, /* N/A */
1404             { 0x1c, 0x411111f0 }, /* N/A */
1405             { 0x1d, 0x411111f0 }, /* N/A */
1406             { 0x1e, 0x0144111e }, /* SPDIF */
1407             { }
1408         }
1409     },
1410     [ALC880_FIXUP_ASUS_W5A] = {
1411         .type = HDA_FIXUP_PINS,
1412         .v.pins = (const struct hda_pintbl[]) {
1413             /* set up the whole pins as BIOS is utterly broken */
1414             { 0x14, 0x0121411f }, /* HP */
1415             { 0x15, 0x411111f0 }, /* N/A */
1416             { 0x16, 0x411111f0 }, /* N/A */
1417             { 0x17, 0x411111f0 }, /* N/A */
1418             { 0x18, 0x90a60160 }, /* mic */
1419             { 0x19, 0x411111f0 }, /* N/A */
1420             { 0x1a, 0x411111f0 }, /* N/A */
1421             { 0x1b, 0x411111f0 }, /* N/A */
1422             { 0x1c, 0x411111f0 }, /* N/A */
1423             { 0x1d, 0x411111f0 }, /* N/A */
1424             { 0x1e, 0xb743111e }, /* SPDIF out */
1425             { }
1426         },
1427         .chained = true,
1428         .chain_id = ALC880_FIXUP_GPIO1,
1429     },
1430     [ALC880_FIXUP_3ST_BASE] = {
1431         .type = HDA_FIXUP_PINS,
1432         .v.pins = (const struct hda_pintbl[]) {
1433             { 0x14, 0x01014010 }, /* line-out */
1434             { 0x15, 0x411111f0 }, /* N/A */
1435             { 0x16, 0x411111f0 }, /* N/A */
1436             { 0x17, 0x411111f0 }, /* N/A */
1437             { 0x18, 0x01a19c30 }, /* mic-in */
1438             { 0x19, 0x0121411f }, /* HP */
1439             { 0x1a, 0x01813031 }, /* line-in */
1440             { 0x1b, 0x02a19c40 }, /* front-mic */
1441             { 0x1c, 0x411111f0 }, /* N/A */
1442             { 0x1d, 0x411111f0 }, /* N/A */
1443             /* 0x1e is filled in below */
1444             { 0x1f, 0x411111f0 }, /* N/A */
1445             { }
1446         }
1447     },
1448     [ALC880_FIXUP_3ST] = {
1449         .type = HDA_FIXUP_PINS,
1450         .v.pins = (const struct hda_pintbl[]) {
1451             { 0x1e, 0x411111f0 }, /* N/A */
1452             { }
1453         },
1454         .chained = true,
1455         .chain_id = ALC880_FIXUP_3ST_BASE,
1456     },
1457     [ALC880_FIXUP_3ST_DIG] = {
1458         .type = HDA_FIXUP_PINS,
1459         .v.pins = (const struct hda_pintbl[]) {
1460             { 0x1e, 0x0144111e }, /* SPDIF */
1461             { }
1462         },
1463         .chained = true,
1464         .chain_id = ALC880_FIXUP_3ST_BASE,
1465     },
1466     [ALC880_FIXUP_5ST_BASE] = {
1467         .type = HDA_FIXUP_PINS,
1468         .v.pins = (const struct hda_pintbl[]) {
1469             { 0x14, 0x01014010 }, /* front */
1470             { 0x15, 0x411111f0 }, /* N/A */
1471             { 0x16, 0x01011411 }, /* CLFE */
1472             { 0x17, 0x01016412 }, /* surr */
1473             { 0x18, 0x01a19c30 }, /* mic-in */
1474             { 0x19, 0x0121411f }, /* HP */
1475             { 0x1a, 0x01813031 }, /* line-in */
1476             { 0x1b, 0x02a19c40 }, /* front-mic */
1477             { 0x1c, 0x411111f0 }, /* N/A */
1478             { 0x1d, 0x411111f0 }, /* N/A */
1479             /* 0x1e is filled in below */
1480             { 0x1f, 0x411111f0 }, /* N/A */
1481             { }
1482         }
1483     },
1484     [ALC880_FIXUP_5ST] = {
1485         .type = HDA_FIXUP_PINS,
1486         .v.pins = (const struct hda_pintbl[]) {
1487             { 0x1e, 0x411111f0 }, /* N/A */
1488             { }
1489         },
1490         .chained = true,
1491         .chain_id = ALC880_FIXUP_5ST_BASE,
1492     },
1493     [ALC880_FIXUP_5ST_DIG] = {
1494         .type = HDA_FIXUP_PINS,
1495         .v.pins = (const struct hda_pintbl[]) {
1496             { 0x1e, 0x0144111e }, /* SPDIF */
1497             { }
1498         },
1499         .chained = true,
1500         .chain_id = ALC880_FIXUP_5ST_BASE,
1501     },
1502     [ALC880_FIXUP_6ST_BASE] = {
1503         .type = HDA_FIXUP_PINS,
1504         .v.pins = (const struct hda_pintbl[]) {
1505             { 0x14, 0x01014010 }, /* front */
1506             { 0x15, 0x01016412 }, /* surr */
1507             { 0x16, 0x01011411 }, /* CLFE */
1508             { 0x17, 0x01012414 }, /* side */
1509             { 0x18, 0x01a19c30 }, /* mic-in */
1510             { 0x19, 0x02a19c40 }, /* front-mic */
1511             { 0x1a, 0x01813031 }, /* line-in */
1512             { 0x1b, 0x0121411f }, /* HP */
1513             { 0x1c, 0x411111f0 }, /* N/A */
1514             { 0x1d, 0x411111f0 }, /* N/A */
1515             /* 0x1e is filled in below */
1516             { 0x1f, 0x411111f0 }, /* N/A */
1517             { }
1518         }
1519     },
1520     [ALC880_FIXUP_6ST] = {
1521         .type = HDA_FIXUP_PINS,
1522         .v.pins = (const struct hda_pintbl[]) {
1523             { 0x1e, 0x411111f0 }, /* N/A */
1524             { }
1525         },
1526         .chained = true,
1527         .chain_id = ALC880_FIXUP_6ST_BASE,
1528     },
1529     [ALC880_FIXUP_6ST_DIG] = {
1530         .type = HDA_FIXUP_PINS,
1531         .v.pins = (const struct hda_pintbl[]) {
1532             { 0x1e, 0x0144111e }, /* SPDIF */
1533             { }
1534         },
1535         .chained = true,
1536         .chain_id = ALC880_FIXUP_6ST_BASE,
1537     },
1538     [ALC880_FIXUP_6ST_AUTOMUTE] = {
1539         .type = HDA_FIXUP_PINS,
1540         .v.pins = (const struct hda_pintbl[]) {
1541             { 0x1b, 0x0121401f }, /* HP with jack detect */
1542             { }
1543         },
1544         .chained_before = true,
1545         .chain_id = ALC880_FIXUP_6ST_BASE,
1546     },
1547 };
1548
1549 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1550     SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1551     SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1552     SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1553     SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1554     SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1555     SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1556     SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1557     SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1558     SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1559     SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1560     SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1561     SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1562     SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1563     SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1564     SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1565     SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1566     SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1567     SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1568     SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1569     SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1570     SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1571     SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1572     SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1573
1574     /* Below is the copied entries from alc880_quirks.c.
1575      * It's not quite sure whether BIOS sets the correct pin-config table
1576      * on these machines, thus they are kept to be compatible with
1577      * the old static quirks.  Once when it's confirmed to work without
1578      * these overrides, it'd be better to remove.
1579      */
1580     SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1581     SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1582     SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1583     SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1584     SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1585     SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1586     SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1587     SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1588     SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1589     SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1590     SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1591     SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1592     SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1593     SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1594     SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1595     SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1596     SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1597     SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1598     SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1599     SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1600     SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1601     SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1602     SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1603     SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1604     SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1605     SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1606     SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1607     SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1608     SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1609     SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1610     SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1611     SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1612     SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1613     /* default Intel */
1614     SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1615     SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1616     SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1617     {}
1618 };
1619
1620 static const struct hda_model_fixup alc880_fixup_models[] = {
1621     {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1622     {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1623     {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1624     {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1625     {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1626     {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1627     {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1628     {}
1629 };
1630
1631
1632 /*
1633  * OK, here we have finally the patch for ALC880
1634  */
1635 static int patch_alc880(struct hda_codec *codec)
1636 {
1637     struct alc_spec *spec;
1638     int err;
1639
1640     err = alc_alloc_spec(codec, 0x0b);
1641     if (err < 0)
1642         return err;
1643
1644     spec = codec->spec;
1645     spec->gen.need_dac_fix = 1;
1646     spec->gen.beep_nid = 0x01;
1647
1648     codec->patch_ops.unsol_event = alc880_unsol_event;
1649
1650     alc_pre_init(codec);
1651
1652     snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1653                alc880_fixups);
1654     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1655
1656     /* automatic parse from the BIOS config */
1657     err = alc880_parse_auto_config(codec);
1658     if (err < 0)
1659         goto error;
1660
1661     if (!spec->gen.no_analog) {
1662         err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1663         if (err < 0)
1664             goto error;
1665     }
1666
1667     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1668
1669     return 0;
1670
1671  error:
1672     alc_free(codec);
1673     return err;
1674 }
1675
1676
1677 /*
1678  * ALC260 support
1679  */
1680 static int alc260_parse_auto_config(struct hda_codec *codec)
1681 {
1682     static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1683     static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1684     return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1685 }
1686
1687 /*
1688  * Pin config fixes
1689  */
1690 enum {
1691     ALC260_FIXUP_HP_DC5750,
1692     ALC260_FIXUP_HP_PIN_0F,
1693     ALC260_FIXUP_COEF,
1694     ALC260_FIXUP_GPIO1,
1695     ALC260_FIXUP_GPIO1_TOGGLE,
1696     ALC260_FIXUP_REPLACER,
1697     ALC260_FIXUP_HP_B1900,
1698     ALC260_FIXUP_KN1,
1699     ALC260_FIXUP_FSC_S7020,
1700     ALC260_FIXUP_FSC_S7020_JWSE,
1701     ALC260_FIXUP_VAIO_PINS,
1702 };
1703
1704 static void alc260_gpio1_automute(struct hda_codec *codec)
1705 {
1706     struct alc_spec *spec = codec->spec;
1707
1708     alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1709 }
1710
1711 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1712                       const struct hda_fixup *fix, int action)
1713 {
1714     struct alc_spec *spec = codec->spec;
1715     if (action == HDA_FIXUP_ACT_PROBE) {
1716         /* although the machine has only one output pin, we need to
1717          * toggle GPIO1 according to the jack state
1718          */
1719         spec->gen.automute_hook = alc260_gpio1_automute;
1720         spec->gen.detect_hp = 1;
1721         spec->gen.automute_speaker = 1;
1722         spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1723         snd_hda_jack_detect_enable_callback(codec, 0x0f,
1724                             snd_hda_gen_hp_automute);
1725         alc_setup_gpio(codec, 0x01);
1726     }
1727 }
1728
1729 static void alc260_fixup_kn1(struct hda_codec *codec,
1730                  const struct hda_fixup *fix, int action)
1731 {
1732     struct alc_spec *spec = codec->spec;
1733     static const struct hda_pintbl pincfgs[] = {
1734         { 0x0f, 0x02214000 }, /* HP/speaker */
1735         { 0x12, 0x90a60160 }, /* int mic */
1736         { 0x13, 0x02a19000 }, /* ext mic */
1737         { 0x18, 0x01446000 }, /* SPDIF out */
1738         /* disable bogus I/O pins */
1739         { 0x10, 0x411111f0 },
1740         { 0x11, 0x411111f0 },
1741         { 0x14, 0x411111f0 },
1742         { 0x15, 0x411111f0 },
1743         { 0x16, 0x411111f0 },
1744         { 0x17, 0x411111f0 },
1745         { 0x19, 0x411111f0 },
1746         { }
1747     };
1748
1749     switch (action) {
1750     case HDA_FIXUP_ACT_PRE_PROBE:
1751         snd_hda_apply_pincfgs(codec, pincfgs);
1752         spec->init_amp = ALC_INIT_NONE;
1753         break;
1754     }
1755 }
1756
1757 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1758                    const struct hda_fixup *fix, int action)
1759 {
1760     struct alc_spec *spec = codec->spec;
1761     if (action == HDA_FIXUP_ACT_PRE_PROBE)
1762         spec->init_amp = ALC_INIT_NONE;
1763 }
1764
1765 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1766                    const struct hda_fixup *fix, int action)
1767 {
1768     struct alc_spec *spec = codec->spec;
1769     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1770         spec->gen.add_jack_modes = 1;
1771         spec->gen.hp_mic = 1;
1772     }
1773 }
1774
1775 static const struct hda_fixup alc260_fixups[] = {
1776     [ALC260_FIXUP_HP_DC5750] = {
1777         .type = HDA_FIXUP_PINS,
1778         .v.pins = (const struct hda_pintbl[]) {
1779             { 0x11, 0x90130110 }, /* speaker */
1780             { }
1781         }
1782     },
1783     [ALC260_FIXUP_HP_PIN_0F] = {
1784         .type = HDA_FIXUP_PINS,
1785         .v.pins = (const struct hda_pintbl[]) {
1786             { 0x0f, 0x01214000 }, /* HP */
1787             { }
1788         }
1789     },
1790     [ALC260_FIXUP_COEF] = {
1791         .type = HDA_FIXUP_VERBS,
1792         .v.verbs = (const struct hda_verb[]) {
1793             { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1794             { 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
1795             { }
1796         },
1797     },
1798     [ALC260_FIXUP_GPIO1] = {
1799         .type = HDA_FIXUP_FUNC,
1800         .v.func = alc_fixup_gpio1,
1801     },
1802     [ALC260_FIXUP_GPIO1_TOGGLE] = {
1803         .type = HDA_FIXUP_FUNC,
1804         .v.func = alc260_fixup_gpio1_toggle,
1805         .chained = true,
1806         .chain_id = ALC260_FIXUP_HP_PIN_0F,
1807     },
1808     [ALC260_FIXUP_REPLACER] = {
1809         .type = HDA_FIXUP_VERBS,
1810         .v.verbs = (const struct hda_verb[]) {
1811             { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1812             { 0x1a, AC_VERB_SET_PROC_COEF,  0x3050 },
1813             { }
1814         },
1815         .chained = true,
1816         .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1817     },
1818     [ALC260_FIXUP_HP_B1900] = {
1819         .type = HDA_FIXUP_FUNC,
1820         .v.func = alc260_fixup_gpio1_toggle,
1821         .chained = true,
1822         .chain_id = ALC260_FIXUP_COEF,
1823     },
1824     [ALC260_FIXUP_KN1] = {
1825         .type = HDA_FIXUP_FUNC,
1826         .v.func = alc260_fixup_kn1,
1827     },
1828     [ALC260_FIXUP_FSC_S7020] = {
1829         .type = HDA_FIXUP_FUNC,
1830         .v.func = alc260_fixup_fsc_s7020,
1831     },
1832     [ALC260_FIXUP_FSC_S7020_JWSE] = {
1833         .type = HDA_FIXUP_FUNC,
1834         .v.func = alc260_fixup_fsc_s7020_jwse,
1835         .chained = true,
1836         .chain_id = ALC260_FIXUP_FSC_S7020,
1837     },
1838     [ALC260_FIXUP_VAIO_PINS] = {
1839         .type = HDA_FIXUP_PINS,
1840         .v.pins = (const struct hda_pintbl[]) {
1841             /* Pin configs are missing completely on some VAIOs */
1842             { 0x0f, 0x01211020 },
1843             { 0x10, 0x0001003f },
1844             { 0x11, 0x411111f0 },
1845             { 0x12, 0x01a15930 },
1846             { 0x13, 0x411111f0 },
1847             { 0x14, 0x411111f0 },
1848             { 0x15, 0x411111f0 },
1849             { 0x16, 0x411111f0 },
1850             { 0x17, 0x411111f0 },
1851             { 0x18, 0x411111f0 },
1852             { 0x19, 0x411111f0 },
1853             { }
1854         }
1855     },
1856 };
1857
1858 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1859     SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1860     SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1861     SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1862     SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1863     SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1864     SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1865     SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1866     SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1867     SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1868     SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1869     SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1870     SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1871     {}
1872 };
1873
1874 static const struct hda_model_fixup alc260_fixup_models[] = {
1875     {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1876     {.id = ALC260_FIXUP_COEF, .name = "coef"},
1877     {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1878     {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1879     {}
1880 };
1881
1882 /*
1883  */
1884 static int patch_alc260(struct hda_codec *codec)
1885 {
1886     struct alc_spec *spec;
1887     int err;
1888
1889     err = alc_alloc_spec(codec, 0x07);
1890     if (err < 0)
1891         return err;
1892
1893     spec = codec->spec;
1894     /* as quite a few machines require HP amp for speaker outputs,
1895      * it's easier to enable it unconditionally; even if it's unneeded,
1896      * it's almost harmless.
1897      */
1898     spec->gen.prefer_hp_amp = 1;
1899     spec->gen.beep_nid = 0x01;
1900
1901     spec->shutup = alc_eapd_shutup;
1902
1903     alc_pre_init(codec);
1904
1905     snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1906                alc260_fixups);
1907     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1908
1909     /* automatic parse from the BIOS config */
1910     err = alc260_parse_auto_config(codec);
1911     if (err < 0)
1912         goto error;
1913
1914     if (!spec->gen.no_analog) {
1915         err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1916         if (err < 0)
1917             goto error;
1918     }
1919
1920     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1921
1922     return 0;
1923
1924  error:
1925     alc_free(codec);
1926     return err;
1927 }
1928
1929
1930 /*
1931  * ALC882/883/885/888/889 support
1932  *
1933  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1934  * configuration.  Each pin widget can choose any input DACs and a mixer.
1935  * Each ADC is connected from a mixer of all inputs.  This makes possible
1936  * 6-channel independent captures.
1937  *
1938  * In addition, an independent DAC for the multi-playback (not used in this
1939  * driver yet).
1940  */
1941
1942 /*
1943  * Pin config fixes
1944  */
1945 enum {
1946     ALC882_FIXUP_ABIT_AW9D_MAX,
1947     ALC882_FIXUP_LENOVO_Y530,
1948     ALC882_FIXUP_PB_M5210,
1949     ALC882_FIXUP_ACER_ASPIRE_7736,
1950     ALC882_FIXUP_ASUS_W90V,
1951     ALC889_FIXUP_CD,
1952     ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1953     ALC889_FIXUP_VAIO_TT,
1954     ALC888_FIXUP_EEE1601,
1955     ALC886_FIXUP_EAPD,
1956     ALC882_FIXUP_EAPD,
1957     ALC883_FIXUP_EAPD,
1958     ALC883_FIXUP_ACER_EAPD,
1959     ALC882_FIXUP_GPIO1,
1960     ALC882_FIXUP_GPIO2,
1961     ALC882_FIXUP_GPIO3,
1962     ALC889_FIXUP_COEF,
1963     ALC882_FIXUP_ASUS_W2JC,
1964     ALC882_FIXUP_ACER_ASPIRE_4930G,
1965     ALC882_FIXUP_ACER_ASPIRE_8930G,
1966     ALC882_FIXUP_ASPIRE_8930G_VERBS,
1967     ALC885_FIXUP_MACPRO_GPIO,
1968     ALC889_FIXUP_DAC_ROUTE,
1969     ALC889_FIXUP_MBP_VREF,
1970     ALC889_FIXUP_IMAC91_VREF,
1971     ALC889_FIXUP_MBA11_VREF,
1972     ALC889_FIXUP_MBA21_VREF,
1973     ALC889_FIXUP_MP11_VREF,
1974     ALC889_FIXUP_MP41_VREF,
1975     ALC882_FIXUP_INV_DMIC,
1976     ALC882_FIXUP_NO_PRIMARY_HP,
1977     ALC887_FIXUP_ASUS_BASS,
1978     ALC887_FIXUP_BASS_CHMAP,
1979     ALC1220_FIXUP_GB_DUAL_CODECS,
1980     ALC1220_FIXUP_GB_X570,
1981     ALC1220_FIXUP_CLEVO_P950,
1982     ALC1220_FIXUP_CLEVO_PB51ED,
1983     ALC1220_FIXUP_CLEVO_PB51ED_PINS,
1984     ALC887_FIXUP_ASUS_AUDIO,
1985     ALC887_FIXUP_ASUS_HMIC,
1986     ALCS1200A_FIXUP_MIC_VREF,
1987 };
1988
1989 static void alc889_fixup_coef(struct hda_codec *codec,
1990                   const struct hda_fixup *fix, int action)
1991 {
1992     if (action != HDA_FIXUP_ACT_INIT)
1993         return;
1994     alc_update_coef_idx(codec, 7, 0, 0x2030);
1995 }
1996
1997 /* set up GPIO at initialization */
1998 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
1999                      const struct hda_fixup *fix, int action)
2000 {
2001     struct alc_spec *spec = codec->spec;
2002
2003     spec->gpio_write_delay = true;
2004     alc_fixup_gpio3(codec, fix, action);
2005 }
2006
2007 /* Fix the connection of some pins for ALC889:
2008  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
2009  * work correctly (bko#42740)
2010  */
2011 static void alc889_fixup_dac_route(struct hda_codec *codec,
2012                    const struct hda_fixup *fix, int action)
2013 {
2014     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2015         /* fake the connections during parsing the tree */
2016         static const hda_nid_t conn1[] = { 0x0c, 0x0d };
2017         static const hda_nid_t conn2[] = { 0x0e, 0x0f };
2018         snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2019         snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
2020         snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2);
2021         snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2);
2022     } else if (action == HDA_FIXUP_ACT_PROBE) {
2023         /* restore the connections */
2024         static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
2025         snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
2026         snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
2027         snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn);
2028         snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn);
2029     }
2030 }
2031
2032 /* Set VREF on HP pin */
2033 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
2034                   const struct hda_fixup *fix, int action)
2035 {
2036     static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 };
2037     struct alc_spec *spec = codec->spec;
2038     int i;
2039
2040     if (action != HDA_FIXUP_ACT_INIT)
2041         return;
2042     for (i = 0; i < ARRAY_SIZE(nids); i++) {
2043         unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
2044         if (get_defcfg_device(val) != AC_JACK_HP_OUT)
2045             continue;
2046         val = snd_hda_codec_get_pin_target(codec, nids[i]);
2047         val |= AC_PINCTL_VREF_80;
2048         snd_hda_set_pin_ctl(codec, nids[i], val);
2049         spec->gen.keep_vref_in_automute = 1;
2050         break;
2051     }
2052 }
2053
2054 static void alc889_fixup_mac_pins(struct hda_codec *codec,
2055                   const hda_nid_t *nids, int num_nids)
2056 {
2057     struct alc_spec *spec = codec->spec;
2058     int i;
2059
2060     for (i = 0; i < num_nids; i++) {
2061         unsigned int val;
2062         val = snd_hda_codec_get_pin_target(codec, nids[i]);
2063         val |= AC_PINCTL_VREF_50;
2064         snd_hda_set_pin_ctl(codec, nids[i], val);
2065     }
2066     spec->gen.keep_vref_in_automute = 1;
2067 }
2068
2069 /* Set VREF on speaker pins on imac91 */
2070 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
2071                      const struct hda_fixup *fix, int action)
2072 {
2073     static const hda_nid_t nids[] = { 0x18, 0x1a };
2074
2075     if (action == HDA_FIXUP_ACT_INIT)
2076         alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2077 }
2078
2079 /* Set VREF on speaker pins on mba11 */
2080 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2081                     const struct hda_fixup *fix, int action)
2082 {
2083     static const hda_nid_t nids[] = { 0x18 };
2084
2085     if (action == HDA_FIXUP_ACT_INIT)
2086         alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2087 }
2088
2089 /* Set VREF on speaker pins on mba21 */
2090 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2091                     const struct hda_fixup *fix, int action)
2092 {
2093     static const hda_nid_t nids[] = { 0x18, 0x19 };
2094
2095     if (action == HDA_FIXUP_ACT_INIT)
2096         alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2097 }
2098
2099 /* Don't take HP output as primary
2100  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
2101  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
2102  */
2103 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2104                        const struct hda_fixup *fix, int action)
2105 {
2106     struct alc_spec *spec = codec->spec;
2107     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2108         spec->gen.no_primary_hp = 1;
2109         spec->gen.no_multi_io = 1;
2110     }
2111 }
2112
2113 static void alc_fixup_bass_chmap(struct hda_codec *codec,
2114                  const struct hda_fixup *fix, int action);
2115
2116 /* For dual-codec configuration, we need to disable some features to avoid
2117  * conflicts of kctls and PCM streams
2118  */
2119 static void alc_fixup_dual_codecs(struct hda_codec *codec,
2120                   const struct hda_fixup *fix, int action)
2121 {
2122     struct alc_spec *spec = codec->spec;
2123
2124     if (action != HDA_FIXUP_ACT_PRE_PROBE)
2125         return;
2126     /* disable vmaster */
2127     spec->gen.suppress_vmaster = 1;
2128     /* auto-mute and auto-mic switch don't work with multiple codecs */
2129     spec->gen.suppress_auto_mute = 1;
2130     spec->gen.suppress_auto_mic = 1;
2131     /* disable aamix as well */
2132     spec->gen.mixer_nid = 0;
2133     /* add location prefix to avoid conflicts */
2134     codec->force_pin_prefix = 1;
2135 }
2136
2137 static void rename_ctl(struct hda_codec *codec, const char *oldname,
2138                const char *newname)
2139 {
2140     struct snd_kcontrol *kctl;
2141
2142     kctl = snd_hda_find_mixer_ctl(codec, oldname);
2143     if (kctl)
2144         strcpy(kctl->id.name, newname);
2145 }
2146
2147 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2148                      const struct hda_fixup *fix,
2149                      int action)
2150 {
2151     alc_fixup_dual_codecs(codec, fix, action);
2152     switch (action) {
2153     case HDA_FIXUP_ACT_PRE_PROBE:
2154         /* override card longname to provide a unique UCM profile */
2155         strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2156         break;
2157     case HDA_FIXUP_ACT_BUILD:
2158         /* rename Capture controls depending on the codec */
2159         rename_ctl(codec, "Capture Volume",
2160                codec->addr == 0 ?
2161                "Rear-Panel Capture Volume" :
2162                "Front-Panel Capture Volume");
2163         rename_ctl(codec, "Capture Switch",
2164                codec->addr == 0 ?
2165                "Rear-Panel Capture Switch" :
2166                "Front-Panel Capture Switch");
2167         break;
2168     }
2169 }
2170
2171 static void alc1220_fixup_gb_x570(struct hda_codec *codec,
2172                      const struct hda_fixup *fix,
2173                      int action)
2174 {
2175     static const hda_nid_t conn1[] = { 0x0c };
2176     static const struct coef_fw gb_x570_coefs[] = {
2177         WRITE_COEF(0x07, 0x03c0),
2178         WRITE_COEF(0x1a, 0x01c1),
2179         WRITE_COEF(0x1b, 0x0202),
2180         WRITE_COEF(0x43, 0x3005),
2181         {}
2182     };
2183
2184     switch (action) {
2185     case HDA_FIXUP_ACT_PRE_PROBE:
2186         snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2187         snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2188         break;
2189     case HDA_FIXUP_ACT_INIT:
2190         alc_process_coef_fw(codec, gb_x570_coefs);
2191         break;
2192     }
2193 }
2194
2195 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2196                      const struct hda_fixup *fix,
2197                      int action)
2198 {
2199     static const hda_nid_t conn1[] = { 0x0c };
2200
2201     if (action != HDA_FIXUP_ACT_PRE_PROBE)
2202         return;
2203
2204     alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2205     /* We therefore want to make sure 0x14 (front headphone) and
2206      * 0x1b (speakers) use the stereo DAC 0x02
2207      */
2208     snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2209     snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2210 }
2211
2212 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2213                 const struct hda_fixup *fix, int action);
2214
2215 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2216                      const struct hda_fixup *fix,
2217                      int action)
2218 {
2219     alc1220_fixup_clevo_p950(codec, fix, action);
2220     alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2221 }
2222
2223 static void alc887_asus_hp_automute_hook(struct hda_codec *codec,
2224                      struct hda_jack_callback *jack)
2225 {
2226     struct alc_spec *spec = codec->spec;
2227     unsigned int vref;
2228
2229     snd_hda_gen_hp_automute(codec, jack);
2230
2231     if (spec->gen.hp_jack_present)
2232         vref = AC_PINCTL_VREF_80;
2233     else
2234         vref = AC_PINCTL_VREF_HIZ;
2235     snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref);
2236 }
2237
2238 static void alc887_fixup_asus_jack(struct hda_codec *codec,
2239                      const struct hda_fixup *fix, int action)
2240 {
2241     struct alc_spec *spec = codec->spec;
2242     if (action != HDA_FIXUP_ACT_PROBE)
2243         return;
2244     snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP);
2245     spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook;
2246 }
2247
2248 static const struct hda_fixup alc882_fixups[] = {
2249     [ALC882_FIXUP_ABIT_AW9D_MAX] = {
2250         .type = HDA_FIXUP_PINS,
2251         .v.pins = (const struct hda_pintbl[]) {
2252             { 0x15, 0x01080104 }, /* side */
2253             { 0x16, 0x01011012 }, /* rear */
2254             { 0x17, 0x01016011 }, /* clfe */
2255             { }
2256         }
2257     },
2258     [ALC882_FIXUP_LENOVO_Y530] = {
2259         .type = HDA_FIXUP_PINS,
2260         .v.pins = (const struct hda_pintbl[]) {
2261             { 0x15, 0x99130112 }, /* rear int speakers */
2262             { 0x16, 0x99130111 }, /* subwoofer */
2263             { }
2264         }
2265     },
2266     [ALC882_FIXUP_PB_M5210] = {
2267         .type = HDA_FIXUP_PINCTLS,
2268         .v.pins = (const struct hda_pintbl[]) {
2269             { 0x19, PIN_VREF50 },
2270             {}
2271         }
2272     },
2273     [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2274         .type = HDA_FIXUP_FUNC,
2275         .v.func = alc_fixup_sku_ignore,
2276     },
2277     [ALC882_FIXUP_ASUS_W90V] = {
2278         .type = HDA_FIXUP_PINS,
2279         .v.pins = (const struct hda_pintbl[]) {
2280             { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2281             { }
2282         }
2283     },
2284     [ALC889_FIXUP_CD] = {
2285         .type = HDA_FIXUP_PINS,
2286         .v.pins = (const struct hda_pintbl[]) {
2287             { 0x1c, 0x993301f0 }, /* CD */
2288             { }
2289         }
2290     },
2291     [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2292         .type = HDA_FIXUP_PINS,
2293         .v.pins = (const struct hda_pintbl[]) {
2294             { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2295             { }
2296         },
2297         .chained = true,
2298         .chain_id = ALC889_FIXUP_CD,
2299     },
2300     [ALC889_FIXUP_VAIO_TT] = {
2301         .type = HDA_FIXUP_PINS,
2302         .v.pins = (const struct hda_pintbl[]) {
2303             { 0x17, 0x90170111 }, /* hidden surround speaker */
2304             { }
2305         }
2306     },
2307     [ALC888_FIXUP_EEE1601] = {
2308         .type = HDA_FIXUP_VERBS,
2309         .v.verbs = (const struct hda_verb[]) {
2310             { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2311             { 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2312             { }
2313         }
2314     },
2315     [ALC886_FIXUP_EAPD] = {
2316         .type = HDA_FIXUP_VERBS,
2317         .v.verbs = (const struct hda_verb[]) {
2318             /* change to EAPD mode */
2319             { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2320             { 0x20, AC_VERB_SET_PROC_COEF, 0x0068 },
2321             { }
2322         }
2323     },
2324     [ALC882_FIXUP_EAPD] = {
2325         .type = HDA_FIXUP_VERBS,
2326         .v.verbs = (const struct hda_verb[]) {
2327             /* change to EAPD mode */
2328             { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2329             { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2330             { }
2331         }
2332     },
2333     [ALC883_FIXUP_EAPD] = {
2334         .type = HDA_FIXUP_VERBS,
2335         .v.verbs = (const struct hda_verb[]) {
2336             /* change to EAPD mode */
2337             { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2338             { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2339             { }
2340         }
2341     },
2342     [ALC883_FIXUP_ACER_EAPD] = {
2343         .type = HDA_FIXUP_VERBS,
2344         .v.verbs = (const struct hda_verb[]) {
2345             /* eanable EAPD on Acer laptops */
2346             { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2347             { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2348             { }
2349         }
2350     },
2351     [ALC882_FIXUP_GPIO1] = {
2352         .type = HDA_FIXUP_FUNC,
2353         .v.func = alc_fixup_gpio1,
2354     },
2355     [ALC882_FIXUP_GPIO2] = {
2356         .type = HDA_FIXUP_FUNC,
2357         .v.func = alc_fixup_gpio2,
2358     },
2359     [ALC882_FIXUP_GPIO3] = {
2360         .type = HDA_FIXUP_FUNC,
2361         .v.func = alc_fixup_gpio3,
2362     },
2363     [ALC882_FIXUP_ASUS_W2JC] = {
2364         .type = HDA_FIXUP_FUNC,
2365         .v.func = alc_fixup_gpio1,
2366         .chained = true,
2367         .chain_id = ALC882_FIXUP_EAPD,
2368     },
2369     [ALC889_FIXUP_COEF] = {
2370         .type = HDA_FIXUP_FUNC,
2371         .v.func = alc889_fixup_coef,
2372     },
2373     [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2374         .type = HDA_FIXUP_PINS,
2375         .v.pins = (const struct hda_pintbl[]) {
2376             { 0x16, 0x99130111 }, /* CLFE speaker */
2377             { 0x17, 0x99130112 }, /* surround speaker */
2378             { }
2379         },
2380         .chained = true,
2381         .chain_id = ALC882_FIXUP_GPIO1,
2382     },
2383     [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2384         .type = HDA_FIXUP_PINS,
2385         .v.pins = (const struct hda_pintbl[]) {
2386             { 0x16, 0x99130111 }, /* CLFE speaker */
2387             { 0x1b, 0x99130112 }, /* surround speaker */
2388             { }
2389         },
2390         .chained = true,
2391         .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2392     },
2393     [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2394         /* additional init verbs for Acer Aspire 8930G */
2395         .type = HDA_FIXUP_VERBS,
2396         .v.verbs = (const struct hda_verb[]) {
2397             /* Enable all DACs */
2398             /* DAC DISABLE/MUTE 1? */
2399             /*  setting bits 1-5 disables DAC nids 0x02-0x06
2400              *  apparently. Init=0x38 */
2401             { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2402             { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2403             /* DAC DISABLE/MUTE 2? */
2404             /*  some bit here disables the other DACs.
2405              *  Init=0x4900 */
2406             { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2407             { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2408             /* DMIC fix
2409              * This laptop has a stereo digital microphone.
2410              * The mics are only 1cm apart which makes the stereo
2411              * useless. However, either the mic or the ALC889
2412              * makes the signal become a difference/sum signal
2413              * instead of standard stereo, which is annoying.
2414              * So instead we flip this bit which makes the
2415              * codec replicate the sum signal to both channels,
2416              * turning it into a normal mono mic.
2417              */
2418             /* DMIC_CONTROL? Init value = 0x0001 */
2419             { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2420             { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2421             { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2422             { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2423             { }
2424         },
2425         .chained = true,
2426         .chain_id = ALC882_FIXUP_GPIO1,
2427     },
2428     [ALC885_FIXUP_MACPRO_GPIO] = {
2429         .type = HDA_FIXUP_FUNC,
2430         .v.func = alc885_fixup_macpro_gpio,
2431     },
2432     [ALC889_FIXUP_DAC_ROUTE] = {
2433         .type = HDA_FIXUP_FUNC,
2434         .v.func = alc889_fixup_dac_route,
2435     },
2436     [ALC889_FIXUP_MBP_VREF] = {
2437         .type = HDA_FIXUP_FUNC,
2438         .v.func = alc889_fixup_mbp_vref,
2439         .chained = true,
2440         .chain_id = ALC882_FIXUP_GPIO1,
2441     },
2442     [ALC889_FIXUP_IMAC91_VREF] = {
2443         .type = HDA_FIXUP_FUNC,
2444         .v.func = alc889_fixup_imac91_vref,
2445         .chained = true,
2446         .chain_id = ALC882_FIXUP_GPIO1,
2447     },
2448     [ALC889_FIXUP_MBA11_VREF] = {
2449         .type = HDA_FIXUP_FUNC,
2450         .v.func = alc889_fixup_mba11_vref,
2451         .chained = true,
2452         .chain_id = ALC889_FIXUP_MBP_VREF,
2453     },
2454     [ALC889_FIXUP_MBA21_VREF] = {
2455         .type = HDA_FIXUP_FUNC,
2456         .v.func = alc889_fixup_mba21_vref,
2457         .chained = true,
2458         .chain_id = ALC889_FIXUP_MBP_VREF,
2459     },
2460     [ALC889_FIXUP_MP11_VREF] = {
2461         .type = HDA_FIXUP_FUNC,
2462         .v.func = alc889_fixup_mba11_vref,
2463         .chained = true,
2464         .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2465     },
2466     [ALC889_FIXUP_MP41_VREF] = {
2467         .type = HDA_FIXUP_FUNC,
2468         .v.func = alc889_fixup_mbp_vref,
2469         .chained = true,
2470         .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2471     },
2472     [ALC882_FIXUP_INV_DMIC] = {
2473         .type = HDA_FIXUP_FUNC,
2474         .v.func = alc_fixup_inv_dmic,
2475     },
2476     [ALC882_FIXUP_NO_PRIMARY_HP] = {
2477         .type = HDA_FIXUP_FUNC,
2478         .v.func = alc882_fixup_no_primary_hp,
2479     },
2480     [ALC887_FIXUP_ASUS_BASS] = {
2481         .type = HDA_FIXUP_PINS,
2482         .v.pins = (const struct hda_pintbl[]) {
2483             {0x16, 0x99130130}, /* bass speaker */
2484             {}
2485         },
2486         .chained = true,
2487         .chain_id = ALC887_FIXUP_BASS_CHMAP,
2488     },
2489     [ALC887_FIXUP_BASS_CHMAP] = {
2490         .type = HDA_FIXUP_FUNC,
2491         .v.func = alc_fixup_bass_chmap,
2492     },
2493     [ALC1220_FIXUP_GB_DUAL_CODECS] = {
2494         .type = HDA_FIXUP_FUNC,
2495         .v.func = alc1220_fixup_gb_dual_codecs,
2496     },
2497     [ALC1220_FIXUP_GB_X570] = {
2498         .type = HDA_FIXUP_FUNC,
2499         .v.func = alc1220_fixup_gb_x570,
2500     },
2501     [ALC1220_FIXUP_CLEVO_P950] = {
2502         .type = HDA_FIXUP_FUNC,
2503         .v.func = alc1220_fixup_clevo_p950,
2504     },
2505     [ALC1220_FIXUP_CLEVO_PB51ED] = {
2506         .type = HDA_FIXUP_FUNC,
2507         .v.func = alc1220_fixup_clevo_pb51ed,
2508     },
2509     [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2510         .type = HDA_FIXUP_PINS,
2511         .v.pins = (const struct hda_pintbl[]) {
2512             { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
2513             {}
2514         },
2515         .chained = true,
2516         .chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2517     },
2518     [ALC887_FIXUP_ASUS_AUDIO] = {
2519         .type = HDA_FIXUP_PINS,
2520         .v.pins = (const struct hda_pintbl[]) {
2521             { 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */
2522             { 0x19, 0x22219420 },
2523             {}
2524         },
2525     },
2526     [ALC887_FIXUP_ASUS_HMIC] = {
2527         .type = HDA_FIXUP_FUNC,
2528         .v.func = alc887_fixup_asus_jack,
2529         .chained = true,
2530         .chain_id = ALC887_FIXUP_ASUS_AUDIO,
2531     },
2532     [ALCS1200A_FIXUP_MIC_VREF] = {
2533         .type = HDA_FIXUP_PINCTLS,
2534         .v.pins = (const struct hda_pintbl[]) {
2535             { 0x18, PIN_VREF50 }, /* rear mic */
2536             { 0x19, PIN_VREF50 }, /* front mic */
2537             {}
2538         }
2539     },
2540 };
2541
2542 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2543     SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2544     SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2545     SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2546     SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2547     SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2548     SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2549     SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2550     SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2551               ALC882_FIXUP_ACER_ASPIRE_4930G),
2552     SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2553               ALC882_FIXUP_ACER_ASPIRE_4930G),
2554     SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2555               ALC882_FIXUP_ACER_ASPIRE_8930G),
2556     SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2557               ALC882_FIXUP_ACER_ASPIRE_8930G),
2558     SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2559               ALC882_FIXUP_ACER_ASPIRE_4930G),
2560     SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2561     SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2562               ALC882_FIXUP_ACER_ASPIRE_4930G),
2563     SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2564               ALC882_FIXUP_ACER_ASPIRE_4930G),
2565     SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2566               ALC882_FIXUP_ACER_ASPIRE_4930G),
2567     SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2568     SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2569     SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2570     SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2571     SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2572     SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2573     SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC),
2574     SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2575     SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2576     SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2577     SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF),
2578     SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2579     SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2580     SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2581     SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2582     SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2583
2584     /* All Apple entries are in codec SSIDs */
2585     SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2586     SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2587     SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2588     SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2589     SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2590     SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2591     SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2592     SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2593     SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2594     SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2595     SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2596     SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2597     SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2598     SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2599     SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2600     SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2601     SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2602     SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2603     SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2604     SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2605     SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2606     SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2607
2608     SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2609     SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD),
2610     SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2611     SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2612     SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570),
2613     SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570),
2614     SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570),
2615     SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
2616     SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
2617     SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950),
2618     SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950),
2619     SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2620     SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2621     SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2622     SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS),
2623     SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2624     SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2625     SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2626     SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2627     SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2628     SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2629     SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2630     SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2631     SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2632     SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2633     SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2634     SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2635     SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2636     SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2637     SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2638     SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2639     SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2640     SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
2641     SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2642     SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
2643     SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950),
2644     SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2645     SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2646     SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950),
2647     SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950),
2648     SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950),
2649     SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950),
2650     SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2651     SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2652     SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950),
2653     SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2654     SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2655     SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2656     SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2657     {}
2658 };
2659
2660 static const struct hda_model_fixup alc882_fixup_models[] = {
2661     {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2662     {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2663     {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2664     {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2665     {.id = ALC889_FIXUP_CD, .name = "cd"},
2666     {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2667     {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2668     {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2669     {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2670     {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2671     {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2672     {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2673     {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2674     {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2675     {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2676     {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2677     {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2678     {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2679     {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2680     {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2681     {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2682     {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2683     {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2684     {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2685     {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2686     {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2687     {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2688     {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2689     {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2690     {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2691     {.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"},
2692     {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2693     {}
2694 };
2695
2696 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = {
2697     SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950,
2698         {0x14, 0x01014010},
2699         {0x15, 0x01011012},
2700         {0x16, 0x01016011},
2701         {0x18, 0x01a19040},
2702         {0x19, 0x02a19050},
2703         {0x1a, 0x0181304f},
2704         {0x1b, 0x0221401f},
2705         {0x1e, 0x01456130}),
2706     SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950,
2707         {0x14, 0x01015010},
2708         {0x15, 0x01011012},
2709         {0x16, 0x01011011},
2710         {0x18, 0x01a11040},
2711         {0x19, 0x02a19050},
2712         {0x1a, 0x0181104f},
2713         {0x1b, 0x0221401f},
2714         {0x1e, 0x01451130}),
2715     {}
2716 };
2717
2718 /*
2719  * BIOS auto configuration
2720  */
2721 /* almost identical with ALC880 parser... */
2722 static int alc882_parse_auto_config(struct hda_codec *codec)
2723 {
2724     static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2725     static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2726     return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2727 }
2728
2729 /*
2730  */
2731 static int patch_alc882(struct hda_codec *codec)
2732 {
2733     struct alc_spec *spec;
2734     int err;
2735
2736     err = alc_alloc_spec(codec, 0x0b);
2737     if (err < 0)
2738         return err;
2739
2740     spec = codec->spec;
2741
2742     switch (codec->core.vendor_id) {
2743     case 0x10ec0882:
2744     case 0x10ec0885:
2745     case 0x10ec0900:
2746     case 0x10ec0b00:
2747     case 0x10ec1220:
2748         break;
2749     default:
2750         /* ALC883 and variants */
2751         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2752         break;
2753     }
2754
2755     alc_pre_init(codec);
2756
2757     snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2758                alc882_fixups);
2759     snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true);
2760     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2761
2762     alc_auto_parse_customize_define(codec);
2763
2764     if (has_cdefine_beep(codec))
2765         spec->gen.beep_nid = 0x01;
2766
2767     /* automatic parse from the BIOS config */
2768     err = alc882_parse_auto_config(codec);
2769     if (err < 0)
2770         goto error;
2771
2772     if (!spec->gen.no_analog && spec->gen.beep_nid) {
2773         err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2774         if (err < 0)
2775             goto error;
2776     }
2777
2778     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2779
2780     return 0;
2781
2782  error:
2783     alc_free(codec);
2784     return err;
2785 }
2786
2787
2788 /*
2789  * ALC262 support
2790  */
2791 static int alc262_parse_auto_config(struct hda_codec *codec)
2792 {
2793     static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2794     static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2795     return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2796 }
2797
2798 /*
2799  * Pin config fixes
2800  */
2801 enum {
2802     ALC262_FIXUP_FSC_H270,
2803     ALC262_FIXUP_FSC_S7110,
2804     ALC262_FIXUP_HP_Z200,
2805     ALC262_FIXUP_TYAN,
2806     ALC262_FIXUP_LENOVO_3000,
2807     ALC262_FIXUP_BENQ,
2808     ALC262_FIXUP_BENQ_T31,
2809     ALC262_FIXUP_INV_DMIC,
2810     ALC262_FIXUP_INTEL_BAYLEYBAY,
2811 };
2812
2813 static const struct hda_fixup alc262_fixups[] = {
2814     [ALC262_FIXUP_FSC_H270] = {
2815         .type = HDA_FIXUP_PINS,
2816         .v.pins = (const struct hda_pintbl[]) {
2817             { 0x14, 0x99130110 }, /* speaker */
2818             { 0x15, 0x0221142f }, /* front HP */
2819             { 0x1b, 0x0121141f }, /* rear HP */
2820             { }
2821         }
2822     },
2823     [ALC262_FIXUP_FSC_S7110] = {
2824         .type = HDA_FIXUP_PINS,
2825         .v.pins = (const struct hda_pintbl[]) {
2826             { 0x15, 0x90170110 }, /* speaker */
2827             { }
2828         },
2829         .chained = true,
2830         .chain_id = ALC262_FIXUP_BENQ,
2831     },
2832     [ALC262_FIXUP_HP_Z200] = {
2833         .type = HDA_FIXUP_PINS,
2834         .v.pins = (const struct hda_pintbl[]) {
2835             { 0x16, 0x99130120 }, /* internal speaker */
2836             { }
2837         }
2838     },
2839     [ALC262_FIXUP_TYAN] = {
2840         .type = HDA_FIXUP_PINS,
2841         .v.pins = (const struct hda_pintbl[]) {
2842             { 0x14, 0x1993e1f0 }, /* int AUX */
2843             { }
2844         }
2845     },
2846     [ALC262_FIXUP_LENOVO_3000] = {
2847         .type = HDA_FIXUP_PINCTLS,
2848         .v.pins = (const struct hda_pintbl[]) {
2849             { 0x19, PIN_VREF50 },
2850             {}
2851         },
2852         .chained = true,
2853         .chain_id = ALC262_FIXUP_BENQ,
2854     },
2855     [ALC262_FIXUP_BENQ] = {
2856         .type = HDA_FIXUP_VERBS,
2857         .v.verbs = (const struct hda_verb[]) {
2858             { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2859             { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2860             {}
2861         }
2862     },
2863     [ALC262_FIXUP_BENQ_T31] = {
2864         .type = HDA_FIXUP_VERBS,
2865         .v.verbs = (const struct hda_verb[]) {
2866             { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2867             { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2868             {}
2869         }
2870     },
2871     [ALC262_FIXUP_INV_DMIC] = {
2872         .type = HDA_FIXUP_FUNC,
2873         .v.func = alc_fixup_inv_dmic,
2874     },
2875     [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2876         .type = HDA_FIXUP_FUNC,
2877         .v.func = alc_fixup_no_depop_delay,
2878     },
2879 };
2880
2881 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2882     SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2883     SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2884     SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2885     SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2886     SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2887     SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2888     SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2889     SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2890     SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2891     SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2892     {}
2893 };
2894
2895 static const struct hda_model_fixup alc262_fixup_models[] = {
2896     {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2897     {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2898     {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2899     {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2900     {.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2901     {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2902     {.id = ALC262_FIXUP_BENQ, .name = "benq"},
2903     {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2904     {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2905     {}
2906 };
2907
2908 /*
2909  */
2910 static int patch_alc262(struct hda_codec *codec)
2911 {
2912     struct alc_spec *spec;
2913     int err;
2914
2915     err = alc_alloc_spec(codec, 0x0b);
2916     if (err < 0)
2917         return err;
2918
2919     spec = codec->spec;
2920     spec->gen.shared_mic_vref_pin = 0x18;
2921
2922     spec->shutup = alc_eapd_shutup;
2923
2924 #if 0
2925     /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2926      * under-run
2927      */
2928     alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2929 #endif
2930     alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2931
2932     alc_pre_init(codec);
2933
2934     snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2935                alc262_fixups);
2936     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2937
2938     alc_auto_parse_customize_define(codec);
2939
2940     if (has_cdefine_beep(codec))
2941         spec->gen.beep_nid = 0x01;
2942
2943     /* automatic parse from the BIOS config */
2944     err = alc262_parse_auto_config(codec);
2945     if (err < 0)
2946         goto error;
2947
2948     if (!spec->gen.no_analog && spec->gen.beep_nid) {
2949         err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2950         if (err < 0)
2951             goto error;
2952     }
2953
2954     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2955
2956     return 0;
2957
2958  error:
2959     alc_free(codec);
2960     return err;
2961 }
2962
2963 /*
2964  *  ALC268
2965  */
2966 /* bind Beep switches of both NID 0x0f and 0x10 */
2967 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2968                   struct snd_ctl_elem_value *ucontrol)
2969 {
2970     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2971     unsigned long pval;
2972     int err;
2973
2974     mutex_lock(&codec->control_mutex);
2975     pval = kcontrol->private_value;
2976     kcontrol->private_value = (pval & ~0xff) | 0x0f;
2977     err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2978     if (err >= 0) {
2979         kcontrol->private_value = (pval & ~0xff) | 0x10;
2980         err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2981     }
2982     kcontrol->private_value = pval;
2983     mutex_unlock(&codec->control_mutex);
2984     return err;
2985 }
2986
2987 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
2988     HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
2989     {
2990         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2991         .name = "Beep Playback Switch",
2992         .subdevice = HDA_SUBDEV_AMP_FLAG,
2993         .info = snd_hda_mixer_amp_switch_info,
2994         .get = snd_hda_mixer_amp_switch_get,
2995         .put = alc268_beep_switch_put,
2996         .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
2997     },
2998 };
2999
3000 /* set PCBEEP vol = 0, mute connections */
3001 static const struct hda_verb alc268_beep_init_verbs[] = {
3002     {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3003     {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3004     {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3005     { }
3006 };
3007
3008 enum {
3009     ALC268_FIXUP_INV_DMIC,
3010     ALC268_FIXUP_HP_EAPD,
3011     ALC268_FIXUP_SPDIF,
3012 };
3013
3014 static const struct hda_fixup alc268_fixups[] = {
3015     [ALC268_FIXUP_INV_DMIC] = {
3016         .type = HDA_FIXUP_FUNC,
3017         .v.func = alc_fixup_inv_dmic,
3018     },
3019     [ALC268_FIXUP_HP_EAPD] = {
3020         .type = HDA_FIXUP_VERBS,
3021         .v.verbs = (const struct hda_verb[]) {
3022             {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
3023             {}
3024         }
3025     },
3026     [ALC268_FIXUP_SPDIF] = {
3027         .type = HDA_FIXUP_PINS,
3028         .v.pins = (const struct hda_pintbl[]) {
3029             { 0x1e, 0x014b1180 }, /* enable SPDIF out */
3030             {}
3031         }
3032     },
3033 };
3034
3035 static const struct hda_model_fixup alc268_fixup_models[] = {
3036     {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
3037     {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
3038     {.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
3039     {}
3040 };
3041
3042 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
3043     SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
3044     SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
3045     /* below is codec SSID since multiple Toshiba laptops have the
3046      * same PCI SSID 1179:ff00
3047      */
3048     SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
3049     {}
3050 };
3051
3052 /*
3053  * BIOS auto configuration
3054  */
3055 static int alc268_parse_auto_config(struct hda_codec *codec)
3056 {
3057     static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3058     return alc_parse_auto_config(codec, NULL, alc268_ssids);
3059 }
3060
3061 /*
3062  */
3063 static int patch_alc268(struct hda_codec *codec)
3064 {
3065     struct alc_spec *spec;
3066     int i, err;
3067
3068     /* ALC268 has no aa-loopback mixer */
3069     err = alc_alloc_spec(codec, 0);
3070     if (err < 0)
3071         return err;
3072
3073     spec = codec->spec;
3074     if (has_cdefine_beep(codec))
3075         spec->gen.beep_nid = 0x01;
3076
3077     spec->shutup = alc_eapd_shutup;
3078
3079     alc_pre_init(codec);
3080
3081     snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
3082     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
3083
3084     /* automatic parse from the BIOS config */
3085     err = alc268_parse_auto_config(codec);
3086     if (err < 0)
3087         goto error;
3088
3089     if (err > 0 && !spec->gen.no_analog &&
3090         spec->gen.autocfg.speaker_pins[0] != 0x1d) {
3091         for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
3092             if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
3093                           &alc268_beep_mixer[i])) {
3094                 err = -ENOMEM;
3095                 goto error;
3096             }
3097         }
3098         snd_hda_add_verbs(codec, alc268_beep_init_verbs);
3099         if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
3100             /* override the amp caps for beep generator */
3101             snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
3102                       (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
3103                       (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
3104                       (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3105                       (0 << AC_AMPCAP_MUTE_SHIFT));
3106     }
3107
3108     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
3109
3110     return 0;
3111
3112  error:
3113     alc_free(codec);
3114     return err;
3115 }
3116
3117 /*
3118  * ALC269
3119  */
3120
3121 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
3122     .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3123 };
3124
3125 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
3126     .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3127 };
3128
3129 /* different alc269-variants */
3130 enum {
3131     ALC269_TYPE_ALC269VA,
3132     ALC269_TYPE_ALC269VB,
3133     ALC269_TYPE_ALC269VC,
3134     ALC269_TYPE_ALC269VD,
3135     ALC269_TYPE_ALC280,
3136     ALC269_TYPE_ALC282,
3137     ALC269_TYPE_ALC283,
3138     ALC269_TYPE_ALC284,
3139     ALC269_TYPE_ALC293,
3140     ALC269_TYPE_ALC286,
3141     ALC269_TYPE_ALC298,
3142     ALC269_TYPE_ALC255,
3143     ALC269_TYPE_ALC256,
3144     ALC269_TYPE_ALC257,
3145     ALC269_TYPE_ALC215,
3146     ALC269_TYPE_ALC225,
3147     ALC269_TYPE_ALC245,
3148     ALC269_TYPE_ALC287,
3149     ALC269_TYPE_ALC294,
3150     ALC269_TYPE_ALC300,
3151     ALC269_TYPE_ALC623,
3152     ALC269_TYPE_ALC700,
3153 };
3154
3155 /*
3156  * BIOS auto configuration
3157  */
3158 static int alc269_parse_auto_config(struct hda_codec *codec)
3159 {
3160     static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
3161     static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
3162     static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3163     struct alc_spec *spec = codec->spec;
3164     const hda_nid_t *ssids;
3165
3166     switch (spec->codec_variant) {
3167     case ALC269_TYPE_ALC269VA:
3168     case ALC269_TYPE_ALC269VC:
3169     case ALC269_TYPE_ALC280:
3170     case ALC269_TYPE_ALC284:
3171     case ALC269_TYPE_ALC293:
3172         ssids = alc269va_ssids;
3173         break;
3174     case ALC269_TYPE_ALC269VB:
3175     case ALC269_TYPE_ALC269VD:
3176     case ALC269_TYPE_ALC282:
3177     case ALC269_TYPE_ALC283:
3178     case ALC269_TYPE_ALC286:
3179     case ALC269_TYPE_ALC298:
3180     case ALC269_TYPE_ALC255:
3181     case ALC269_TYPE_ALC256:
3182     case ALC269_TYPE_ALC257:
3183     case ALC269_TYPE_ALC215:
3184     case ALC269_TYPE_ALC225:
3185     case ALC269_TYPE_ALC245:
3186     case ALC269_TYPE_ALC287:
3187     case ALC269_TYPE_ALC294:
3188     case ALC269_TYPE_ALC300:
3189     case ALC269_TYPE_ALC623:
3190     case ALC269_TYPE_ALC700:
3191         ssids = alc269_ssids;
3192         break;
3193     default:
3194         ssids = alc269_ssids;
3195         break;
3196     }
3197
3198     return alc_parse_auto_config(codec, alc269_ignore, ssids);
3199 }
3200
3201 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
3202     { SND_JACK_BTN_0, KEY_PLAYPAUSE },
3203     { SND_JACK_BTN_1, KEY_VOICECOMMAND },
3204     { SND_JACK_BTN_2, KEY_VOLUMEUP },
3205     { SND_JACK_BTN_3, KEY_VOLUMEDOWN },
3206     {}
3207 };
3208
3209 static void alc_headset_btn_callback(struct hda_codec *codec,
3210                      struct hda_jack_callback *jack)
3211 {
3212     int report = 0;
3213
3214     if (jack->unsol_res & (7 << 13))
3215         report |= SND_JACK_BTN_0;
3216
3217     if (jack->unsol_res  & (1 << 16 | 3 << 8))
3218         report |= SND_JACK_BTN_1;
3219
3220     /* Volume up key */
3221     if (jack->unsol_res & (7 << 23))
3222         report |= SND_JACK_BTN_2;
3223
3224     /* Volume down key */
3225     if (jack->unsol_res & (7 << 10))
3226         report |= SND_JACK_BTN_3;
3227
3228     snd_hda_jack_set_button_state(codec, jack->nid, report);
3229 }
3230
3231 static void alc_disable_headset_jack_key(struct hda_codec *codec)
3232 {
3233     struct alc_spec *spec = codec->spec;
3234
3235     if (!spec->has_hs_key)
3236         return;
3237
3238     switch (codec->core.vendor_id) {
3239     case 0x10ec0215:
3240     case 0x10ec0225:
3241     case 0x10ec0285:
3242     case 0x10ec0287:
3243     case 0x10ec0295:
3244     case 0x10ec0289:
3245     case 0x10ec0299:
3246         alc_write_coef_idx(codec, 0x48, 0x0);
3247         alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3248         alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0);
3249         break;
3250     case 0x10ec0230:
3251     case 0x10ec0236:
3252     case 0x10ec0256:
3253     case 0x19e58326:
3254         alc_write_coef_idx(codec, 0x48, 0x0);
3255         alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3256         break;
3257     }
3258 }
3259
3260 static void alc_enable_headset_jack_key(struct hda_codec *codec)
3261 {
3262     struct alc_spec *spec = codec->spec;
3263
3264     if (!spec->has_hs_key)
3265         return;
3266
3267     switch (codec->core.vendor_id) {
3268     case 0x10ec0215:
3269     case 0x10ec0225:
3270     case 0x10ec0285:
3271     case 0x10ec0287:
3272     case 0x10ec0295:
3273     case 0x10ec0289:
3274     case 0x10ec0299:
3275         alc_write_coef_idx(codec, 0x48, 0xd011);
3276         alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3277         alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
3278         break;
3279     case 0x10ec0230:
3280     case 0x10ec0236:
3281     case 0x10ec0256:
3282     case 0x19e58326:
3283         alc_write_coef_idx(codec, 0x48, 0xd011);
3284         alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3285         break;
3286     }
3287 }
3288
3289 static void alc_fixup_headset_jack(struct hda_codec *codec,
3290                     const struct hda_fixup *fix, int action)
3291 {
3292     struct alc_spec *spec = codec->spec;
3293     hda_nid_t hp_pin;
3294
3295     switch (action) {
3296     case HDA_FIXUP_ACT_PRE_PROBE:
3297         spec->has_hs_key = 1;
3298         snd_hda_jack_detect_enable_callback(codec, 0x55,
3299                             alc_headset_btn_callback);
3300         break;
3301     case HDA_FIXUP_ACT_BUILD:
3302         hp_pin = alc_get_hp_pin(spec);
3303         if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55,
3304                             alc_headset_btn_keymap,
3305                             hp_pin))
3306             snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack",
3307                           false, SND_JACK_HEADSET,
3308                           alc_headset_btn_keymap);
3309
3310         alc_enable_headset_jack_key(codec);
3311         break;
3312     }
3313 }
3314
3315 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
3316 {
3317     alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
3318 }
3319
3320 static void alc269_shutup(struct hda_codec *codec)
3321 {
3322     struct alc_spec *spec = codec->spec;
3323
3324     if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3325         alc269vb_toggle_power_output(codec, 0);
3326     if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3327             (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3328         msleep(150);
3329     }
3330     alc_shutup_pins(codec);
3331 }
3332
3333 static const struct coef_fw alc282_coefs[] = {
3334     WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3335     UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3336     WRITE_COEF(0x07, 0x0200), /* DMIC control */
3337     UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3338     UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3339     WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3340     WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3341     WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3342     UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3343     UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3344     WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3345     UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3346     WRITE_COEF(0x34, 0xa0c0), /* ANC */
3347     UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3348     UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3349     UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3350     WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3351     WRITE_COEF(0x63, 0x2902), /* PLL */
3352     WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3353     WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3354     WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3355     WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3356     UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3357     WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3358     UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3359     WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3360     WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3361     UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3362     WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3363     {}
3364 };
3365
3366 static void alc282_restore_default_value(struct hda_codec *codec)
3367 {
3368     alc_process_coef_fw(codec, alc282_coefs);
3369 }
3370
3371 static void alc282_init(struct hda_codec *codec)
3372 {
3373     struct alc_spec *spec = codec->spec;
3374     hda_nid_t hp_pin = alc_get_hp_pin(spec);
3375     bool hp_pin_sense;
3376     int coef78;
3377
3378     alc282_restore_default_value(codec);
3379
3380     if (!hp_pin)
3381         return;
3382     hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3383     coef78 = alc_read_coef_idx(codec, 0x78);
3384
3385     /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3386     /* Headphone capless set to high power mode */
3387     alc_write_coef_idx(codec, 0x78, 0x9004);
3388
3389     if (hp_pin_sense)
3390         msleep(2);
3391
3392     snd_hda_codec_write(codec, hp_pin, 0,
3393                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3394
3395     if (hp_pin_sense)
3396         msleep(85);
3397
3398     snd_hda_codec_write(codec, hp_pin, 0,
3399                 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3400
3401     if (hp_pin_sense)
3402         msleep(100);
3403
3404     /* Headphone capless set to normal mode */
3405     alc_write_coef_idx(codec, 0x78, coef78);
3406 }
3407
3408 static void alc282_shutup(struct hda_codec *codec)
3409 {
3410     struct alc_spec *spec = codec->spec;
3411     hda_nid_t hp_pin = alc_get_hp_pin(spec);
3412     bool hp_pin_sense;
3413     int coef78;
3414
3415     if (!hp_pin) {
3416         alc269_shutup(codec);
3417         return;
3418     }
3419
3420     hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3421     coef78 = alc_read_coef_idx(codec, 0x78);
3422     alc_write_coef_idx(codec, 0x78, 0x9004);
3423
3424     if (hp_pin_sense)
3425         msleep(2);
3426
3427     snd_hda_codec_write(codec, hp_pin, 0,
3428                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3429
3430     if (hp_pin_sense)
3431         msleep(85);
3432
3433     if (!spec->no_shutup_pins)
3434         snd_hda_codec_write(codec, hp_pin, 0,
3435                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3436
3437     if (hp_pin_sense)
3438         msleep(100);
3439
3440     alc_auto_setup_eapd(codec, false);
3441     alc_shutup_pins(codec);
3442     alc_write_coef_idx(codec, 0x78, coef78);
3443 }
3444
3445 static const struct coef_fw alc283_coefs[] = {
3446     WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3447     UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3448     WRITE_COEF(0x07, 0x0200), /* DMIC control */
3449     UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3450     UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3451     WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3452     WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3453     WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3454     UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3455     UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3456     WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3457     UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3458     WRITE_COEF(0x22, 0xa0c0), /* ANC */
3459     UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3460     UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3461     UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3462     WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3463     WRITE_COEF(0x2e, 0x2902), /* PLL */
3464     WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3465     WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3466     WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3467     WRITE_COEF(0x36, 0x0), /* capless control 5 */
3468     UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3469     WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3470     UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3471     WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3472     WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3473     UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3474     WRITE_COEF(0x49, 0x0), /* test mode */
3475     UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3476     UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3477     WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3478     UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3479     {}
3480 };
3481
3482 static void alc283_restore_default_value(struct hda_codec *codec)
3483 {
3484     alc_process_coef_fw(codec, alc283_coefs);
3485 }
3486
3487 static void alc283_init(struct hda_codec *codec)
3488 {
3489     struct alc_spec *spec = codec->spec;
3490     hda_nid_t hp_pin = alc_get_hp_pin(spec);
3491     bool hp_pin_sense;
3492
3493     alc283_restore_default_value(codec);
3494
3495     if (!hp_pin)
3496         return;
3497
3498     msleep(30);
3499     hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3500
3501     /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3502     /* Headphone capless set to high power mode */
3503     alc_write_coef_idx(codec, 0x43, 0x9004);
3504
3505     snd_hda_codec_write(codec, hp_pin, 0,
3506                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3507
3508     if (hp_pin_sense)
3509         msleep(85);
3510
3511     snd_hda_codec_write(codec, hp_pin, 0,
3512                 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3513
3514     if (hp_pin_sense)
3515         msleep(85);
3516     /* Index 0x46 Combo jack auto switch control 2 */
3517     /* 3k pull low control for Headset jack. */
3518     alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3519     /* Headphone capless set to normal mode */
3520     alc_write_coef_idx(codec, 0x43, 0x9614);
3521 }
3522
3523 static void alc283_shutup(struct hda_codec *codec)
3524 {
3525     struct alc_spec *spec = codec->spec;
3526     hda_nid_t hp_pin = alc_get_hp_pin(spec);
3527     bool hp_pin_sense;
3528
3529     if (!hp_pin) {
3530         alc269_shutup(codec);
3531         return;
3532     }
3533
3534     hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3535
3536     alc_write_coef_idx(codec, 0x43, 0x9004);
3537
3538     /*depop hp during suspend*/
3539     alc_write_coef_idx(codec, 0x06, 0x2100);
3540
3541     snd_hda_codec_write(codec, hp_pin, 0,
3542                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3543
3544     if (hp_pin_sense)
3545         msleep(100);
3546
3547     if (!spec->no_shutup_pins)
3548         snd_hda_codec_write(codec, hp_pin, 0,
3549                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3550
3551     alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3552
3553     if (hp_pin_sense)
3554         msleep(100);
3555     alc_auto_setup_eapd(codec, false);
3556     alc_shutup_pins(codec);
3557     alc_write_coef_idx(codec, 0x43, 0x9614);
3558 }
3559
3560 static void alc256_init(struct hda_codec *codec)
3561 {
3562     struct alc_spec *spec = codec->spec;
3563     hda_nid_t hp_pin = alc_get_hp_pin(spec);
3564     bool hp_pin_sense;
3565
3566     if (!hp_pin)
3567         hp_pin = 0x21;
3568
3569     msleep(30);
3570
3571     hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3572
3573     if (hp_pin_sense)
3574         msleep(2);
3575
3576     alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3577     if (spec->ultra_low_power) {
3578         alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3579         alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3580         alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3581         alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3582         alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3583         msleep(30);
3584     }
3585
3586     snd_hda_codec_write(codec, hp_pin, 0,
3587                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3588
3589     if (hp_pin_sense || spec->ultra_low_power)
3590         msleep(85);
3591
3592     snd_hda_codec_write(codec, hp_pin, 0,
3593                 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3594
3595     if (hp_pin_sense || spec->ultra_low_power)
3596         msleep(100);
3597
3598     alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3599     alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3600     alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3601     alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3602     /*
3603      * Expose headphone mic (or possibly Line In on some machines) instead
3604      * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See
3605      * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of
3606      * this register.
3607      */
3608     alc_write_coef_idx(codec, 0x36, 0x5757);
3609 }
3610
3611 static void alc256_shutup(struct hda_codec *codec)
3612 {
3613     struct alc_spec *spec = codec->spec;
3614     hda_nid_t hp_pin = alc_get_hp_pin(spec);
3615     bool hp_pin_sense;
3616
3617     if (!hp_pin)
3618         hp_pin = 0x21;
3619
3620     hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3621
3622     if (hp_pin_sense)
3623         msleep(2);
3624
3625     snd_hda_codec_write(codec, hp_pin, 0,
3626                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3627
3628     if (hp_pin_sense || spec->ultra_low_power)
3629         msleep(85);
3630
3631     /* 3k pull low control for Headset jack. */
3632     /* NOTE: call this before clearing the pin, otherwise codec stalls */
3633     /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly
3634      * when booting with headset plugged. So skip setting it for the codec alc257
3635      */
3636     if (codec->core.vendor_id != 0x10ec0236 &&
3637         codec->core.vendor_id != 0x10ec0257)
3638         alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3639
3640     if (!spec->no_shutup_pins)
3641         snd_hda_codec_write(codec, hp_pin, 0,
3642                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3643
3644     if (hp_pin_sense || spec->ultra_low_power)
3645         msleep(100);
3646
3647     alc_auto_setup_eapd(codec, false);
3648     alc_shutup_pins(codec);
3649     if (spec->ultra_low_power) {
3650         msleep(50);
3651         alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3652         alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3653         alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3654         alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3655         alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3656         msleep(30);
3657     }
3658 }
3659
3660 static void alc285_hp_init(struct hda_codec *codec)
3661 {
3662     struct alc_spec *spec = codec->spec;
3663     hda_nid_t hp_pin = alc_get_hp_pin(spec);
3664     int i, val;
3665     int coef38, coef0d, coef36;
3666
3667     alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */
3668     coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */
3669     coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */
3670     coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */
3671     alc_update_coef_idx(codec, 0x38, 1<<4, 0x0);
3672     alc_update_coef_idx(codec, 0x0d, 0x110, 0x0);
3673
3674     alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
3675
3676     if (hp_pin)
3677         snd_hda_codec_write(codec, hp_pin, 0,
3678                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3679
3680     msleep(130);
3681     alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14);
3682     alc_update_coef_idx(codec, 0x36, 1<<13, 0x0);
3683
3684     if (hp_pin)
3685         snd_hda_codec_write(codec, hp_pin, 0,
3686                 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3687     msleep(10);
3688     alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */
3689     alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880);
3690     alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049);
3691     alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0);
3692
3693     alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */
3694     val = alc_read_coefex_idx(codec, 0x58, 0x00);
3695     for (i = 0; i < 20 && val & 0x8000; i++) {
3696         msleep(50);
3697         val = alc_read_coefex_idx(codec, 0x58, 0x00);
3698     } /* Wait for depop procedure finish  */
3699
3700     alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */
3701     alc_update_coef_idx(codec, 0x38, 1<<4, coef38);
3702     alc_update_coef_idx(codec, 0x0d, 0x110, coef0d);
3703     alc_update_coef_idx(codec, 0x36, 3<<13, coef36);
3704
3705     msleep(50);
3706     alc_update_coef_idx(codec, 0x4a, 1<<15, 0);
3707 }
3708
3709 static void alc225_init(struct hda_codec *codec)
3710 {
3711     struct alc_spec *spec = codec->spec;
3712     hda_nid_t hp_pin = alc_get_hp_pin(spec);
3713     bool hp1_pin_sense, hp2_pin_sense;
3714
3715     if (spec->codec_variant != ALC269_TYPE_ALC287 &&
3716         spec->codec_variant != ALC269_TYPE_ALC245)
3717         /* required only at boot or S3 and S4 resume time */
3718         if (!spec->done_hp_init ||
3719             is_s3_resume(codec) ||
3720             is_s4_resume(codec)) {
3721             alc285_hp_init(codec);
3722             spec->done_hp_init = true;
3723         }
3724
3725     if (!hp_pin)
3726         hp_pin = 0x21;
3727     msleep(30);
3728
3729     hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3730     hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3731
3732     if (hp1_pin_sense || hp2_pin_sense)
3733         msleep(2);
3734
3735     alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3736     if (spec->ultra_low_power) {
3737         alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3738         alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3739         alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3740         msleep(30);
3741     }
3742
3743     if (hp1_pin_sense || spec->ultra_low_power)
3744         snd_hda_codec_write(codec, hp_pin, 0,
3745                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3746     if (hp2_pin_sense)
3747         snd_hda_codec_write(codec, 0x16, 0,
3748                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3749
3750     if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3751         msleep(85);
3752
3753     if (hp1_pin_sense || spec->ultra_low_power)
3754         snd_hda_codec_write(codec, hp_pin, 0,
3755                 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3756     if (hp2_pin_sense)
3757         snd_hda_codec_write(codec, 0x16, 0,
3758                 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3759
3760     if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3761         msleep(100);
3762
3763     alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3764     alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3765 }
3766
3767 static void alc225_shutup(struct hda_codec *codec)
3768 {
3769     struct alc_spec *spec = codec->spec;
3770     hda_nid_t hp_pin = alc_get_hp_pin(spec);
3771     bool hp1_pin_sense, hp2_pin_sense;
3772
3773     if (!hp_pin)
3774         hp_pin = 0x21;
3775
3776     alc_disable_headset_jack_key(codec);
3777     /* 3k pull low control for Headset jack. */
3778     alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3779
3780     hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3781     hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3782
3783     if (hp1_pin_sense || hp2_pin_sense)
3784         msleep(2);
3785
3786     if (hp1_pin_sense || spec->ultra_low_power)
3787         snd_hda_codec_write(codec, hp_pin, 0,
3788                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3789     if (hp2_pin_sense)
3790         snd_hda_codec_write(codec, 0x16, 0,
3791                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3792
3793     if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3794         msleep(85);
3795
3796     if (hp1_pin_sense || spec->ultra_low_power)
3797         snd_hda_codec_write(codec, hp_pin, 0,
3798                 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3799     if (hp2_pin_sense)
3800         snd_hda_codec_write(codec, 0x16, 0,
3801                 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3802
3803     if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3804         msleep(100);
3805
3806     alc_auto_setup_eapd(codec, false);
3807     alc_shutup_pins(codec);
3808     if (spec->ultra_low_power) {
3809         msleep(50);
3810         alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3811         alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3812         alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3813         alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3814         msleep(30);
3815     }
3816
3817     alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3818     alc_enable_headset_jack_key(codec);
3819 }
3820
3821 static void alc_default_init(struct hda_codec *codec)
3822 {
3823     struct alc_spec *spec = codec->spec;
3824     hda_nid_t hp_pin = alc_get_hp_pin(spec);
3825     bool hp_pin_sense;
3826
3827     if (!hp_pin)
3828         return;
3829
3830     msleep(30);
3831
3832     hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3833
3834     if (hp_pin_sense)
3835         msleep(2);
3836
3837     snd_hda_codec_write(codec, hp_pin, 0,
3838                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3839
3840     if (hp_pin_sense)
3841         msleep(85);
3842
3843     snd_hda_codec_write(codec, hp_pin, 0,
3844                 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3845
3846     if (hp_pin_sense)
3847         msleep(100);
3848 }
3849
3850 static void alc_default_shutup(struct hda_codec *codec)
3851 {
3852     struct alc_spec *spec = codec->spec;
3853     hda_nid_t hp_pin = alc_get_hp_pin(spec);
3854     bool hp_pin_sense;
3855
3856     if (!hp_pin) {
3857         alc269_shutup(codec);
3858         return;
3859     }
3860
3861     hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3862
3863     if (hp_pin_sense)
3864         msleep(2);
3865
3866     snd_hda_codec_write(codec, hp_pin, 0,
3867                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3868
3869     if (hp_pin_sense)
3870         msleep(85);
3871
3872     if (!spec->no_shutup_pins)
3873         snd_hda_codec_write(codec, hp_pin, 0,
3874                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3875
3876     if (hp_pin_sense)
3877         msleep(100);
3878
3879     alc_auto_setup_eapd(codec, false);
3880     alc_shutup_pins(codec);
3881 }
3882
3883 static void alc294_hp_init(struct hda_codec *codec)
3884 {
3885     struct alc_spec *spec = codec->spec;
3886     hda_nid_t hp_pin = alc_get_hp_pin(spec);
3887     int i, val;
3888
3889     if (!hp_pin)
3890         return;
3891
3892     snd_hda_codec_write(codec, hp_pin, 0,
3893                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3894
3895     msleep(100);
3896
3897     if (!spec->no_shutup_pins)
3898         snd_hda_codec_write(codec, hp_pin, 0,
3899                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3900
3901     alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3902     alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3903
3904     /* Wait for depop procedure finish  */
3905     val = alc_read_coefex_idx(codec, 0x58, 0x01);
3906     for (i = 0; i < 20 && val & 0x0080; i++) {
3907         msleep(50);
3908         val = alc_read_coefex_idx(codec, 0x58, 0x01);
3909     }
3910     /* Set HP depop to auto mode */
3911     alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3912     msleep(50);
3913 }
3914
3915 static void alc294_init(struct hda_codec *codec)
3916 {
3917     struct alc_spec *spec = codec->spec;
3918
3919     /* required only at boot or S4 resume time */
3920     if (!spec->done_hp_init ||
3921         codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3922         alc294_hp_init(codec);
3923         spec->done_hp_init = true;
3924     }
3925     alc_default_init(codec);
3926 }
3927
3928 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3929                  unsigned int val)
3930 {
3931     snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3932     snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3933     snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3934 }
3935
3936 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3937 {
3938     unsigned int val;
3939
3940     snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3941     val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3942         & 0xffff;
3943     val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3944         << 16;
3945     return val;
3946 }
3947
3948 static void alc5505_dsp_halt(struct hda_codec *codec)
3949 {
3950     unsigned int val;
3951
3952     alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3953     alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3954     alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3955     alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3956     alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3957     alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3958     alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3959     val = alc5505_coef_get(codec, 0x6220);
3960     alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3961 }
3962
3963 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3964 {
3965     alc5505_coef_set(codec, 0x61b8, 0x04133302);
3966     alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3967     alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3968     alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3969     alc5505_coef_set(codec, 0x6220, 0x2002010f);
3970     alc5505_coef_set(codec, 0x880c, 0x00000004);
3971 }
3972
3973 static void alc5505_dsp_init(struct hda_codec *codec)
3974 {
3975     unsigned int val;
3976
3977     alc5505_dsp_halt(codec);
3978     alc5505_dsp_back_from_halt(codec);
3979     alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3980     alc5505_coef_set(codec, 0x61b0, 0x5b16);
3981     alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
3982     alc5505_coef_set(codec, 0x61b4, 0x04132b02);
3983     alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
3984     alc5505_coef_set(codec, 0x61b8, 0x041f3302);
3985     snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
3986     alc5505_coef_set(codec, 0x61b8, 0x041b3302);
3987     alc5505_coef_set(codec, 0x61b8, 0x04173302);
3988     alc5505_coef_set(codec, 0x61b8, 0x04163302);
3989     alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
3990     alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
3991     alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
3992
3993     val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
3994     if (val <= 3)
3995         alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
3996     else
3997         alc5505_coef_set(codec, 0x6220, 0x6002018f);
3998
3999     alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
4000     alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
4001     alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
4002     alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
4003     alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
4004     alc5505_coef_set(codec, 0x880c, 0x00000003);
4005     alc5505_coef_set(codec, 0x880c, 0x00000010);
4006
4007 #ifdef HALT_REALTEK_ALC5505
4008     alc5505_dsp_halt(codec);
4009 #endif
4010 }
4011
4012 #ifdef HALT_REALTEK_ALC5505
4013 #define alc5505_dsp_suspend(codec)  do { } while (0) /* NOP */
4014 #define alc5505_dsp_resume(codec)   do { } while (0) /* NOP */
4015 #else
4016 #define alc5505_dsp_suspend(codec)  alc5505_dsp_halt(codec)
4017 #define alc5505_dsp_resume(codec)   alc5505_dsp_back_from_halt(codec)
4018 #endif
4019
4020 #ifdef CONFIG_PM
4021 static int alc269_suspend(struct hda_codec *codec)
4022 {
4023     struct alc_spec *spec = codec->spec;
4024     int i;
4025
4026     if (spec->has_alc5505_dsp)
4027         alc5505_dsp_suspend(codec);
4028
4029     for (i = 0; i < HDA_MAX_COMPONENTS; i++)
4030         if (spec->comps[i].suspend_hook)
4031             spec->comps[i].suspend_hook(spec->comps[i].dev);
4032
4033     return alc_suspend(codec);
4034 }
4035
4036 static int alc269_resume(struct hda_codec *codec)
4037 {
4038     struct alc_spec *spec = codec->spec;
4039     int i;
4040
4041     if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4042         alc269vb_toggle_power_output(codec, 0);
4043     if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4044             (alc_get_coef0(codec) & 0x00ff) == 0x018) {
4045         msleep(150);
4046     }
4047
4048     codec->patch_ops.init(codec);
4049
4050     if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4051         alc269vb_toggle_power_output(codec, 1);
4052     if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4053             (alc_get_coef0(codec) & 0x00ff) == 0x017) {
4054         msleep(200);
4055     }
4056
4057     snd_hda_regmap_sync(codec);
4058     hda_call_check_power_status(codec, 0x01);
4059
4060     /* on some machine, the BIOS will clear the codec gpio data when enter
4061      * suspend, and won't restore the data after resume, so we restore it
4062      * in the driver.
4063      */
4064     if (spec->gpio_data)
4065         alc_write_gpio_data(codec);
4066
4067     if (spec->has_alc5505_dsp)
4068         alc5505_dsp_resume(codec);
4069
4070     for (i = 0; i < HDA_MAX_COMPONENTS; i++)
4071         if (spec->comps[i].resume_hook)
4072             spec->comps[i].resume_hook(spec->comps[i].dev);
4073
4074     return 0;
4075 }
4076 #endif /* CONFIG_PM */
4077
4078 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
4079                          const struct hda_fixup *fix, int action)
4080 {
4081     struct alc_spec *spec = codec->spec;
4082
4083     if (action == HDA_FIXUP_ACT_PRE_PROBE)
4084         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4085 }
4086
4087 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
4088                          const struct hda_fixup *fix,
4089                          int action)
4090 {
4091     unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
4092     unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
4093
4094     if (cfg_headphone && cfg_headset_mic == 0x411111f0)
4095         snd_hda_codec_set_pincfg(codec, 0x19,
4096             (cfg_headphone & ~AC_DEFCFG_DEVICE) |
4097             (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
4098 }
4099
4100 static void alc269_fixup_hweq(struct hda_codec *codec,
4101                    const struct hda_fixup *fix, int action)
4102 {
4103     if (action == HDA_FIXUP_ACT_INIT)
4104         alc_update_coef_idx(codec, 0x1e, 0, 0x80);
4105 }
4106
4107 static void alc269_fixup_headset_mic(struct hda_codec *codec,
4108                        const struct hda_fixup *fix, int action)
4109 {
4110     struct alc_spec *spec = codec->spec;
4111
4112     if (action == HDA_FIXUP_ACT_PRE_PROBE)
4113         spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4114 }
4115
4116 static void alc271_fixup_dmic(struct hda_codec *codec,
4117                   const struct hda_fixup *fix, int action)
4118 {
4119     static const struct hda_verb verbs[] = {
4120         {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4121         {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4122         {}
4123     };
4124     unsigned int cfg;
4125
4126     if (strcmp(codec->core.chip_name, "ALC271X") &&
4127         strcmp(codec->core.chip_name, "ALC269VB"))
4128         return;
4129     cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4130     if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4131         snd_hda_sequence_write(codec, verbs);
4132 }
4133
4134 /* Fix the speaker amp after resume, etc */
4135 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec,
4136                       const struct hda_fixup *fix,
4137                       int action)
4138 {
4139     if (action == HDA_FIXUP_ACT_INIT)
4140         alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000);
4141 }
4142
4143 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4144                  const struct hda_fixup *fix, int action)
4145 {
4146     struct alc_spec *spec = codec->spec;
4147
4148     if (action != HDA_FIXUP_ACT_PROBE)
4149         return;
4150
4151     /* Due to a hardware problem on Lenovo Ideadpad, we need to
4152      * fix the sample rate of analog I/O to 44.1kHz
4153      */
4154     spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
4155     spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
4156 }
4157
4158 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4159                      const struct hda_fixup *fix, int action)
4160 {
4161     /* The digital-mic unit sends PDM (differential signal) instead of
4162      * the standard PCM, thus you can't record a valid mono stream as is.
4163      * Below is a workaround specific to ALC269 to control the dmic
4164      * signal source as mono.
4165      */
4166     if (action == HDA_FIXUP_ACT_INIT)
4167         alc_update_coef_idx(codec, 0x07, 0, 0x80);
4168 }
4169
4170 static void alc269_quanta_automute(struct hda_codec *codec)
4171 {
4172     snd_hda_gen_update_outputs(codec);
4173
4174     alc_write_coef_idx(codec, 0x0c, 0x680);
4175     alc_write_coef_idx(codec, 0x0c, 0x480);
4176 }
4177
4178 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4179                      const struct hda_fixup *fix, int action)
4180 {
4181     struct alc_spec *spec = codec->spec;
4182     if (action != HDA_FIXUP_ACT_PROBE)
4183         return;
4184     spec->gen.automute_hook = alc269_quanta_automute;
4185 }
4186
4187 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
4188                      struct hda_jack_callback *jack)
4189 {
4190     struct alc_spec *spec = codec->spec;
4191     int vref;
4192     msleep(200);
4193     snd_hda_gen_hp_automute(codec, jack);
4194
4195     vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4196     msleep(100);
4197     snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4198                 vref);
4199     msleep(500);
4200     snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4201                 vref);
4202 }
4203
4204 /*
4205  * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
4206  */
4207 struct hda_alc298_mbxinit {
4208     unsigned char value_0x23;
4209     unsigned char value_0x25;
4210 };
4211
4212 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
4213                      const struct hda_alc298_mbxinit *initval,
4214                      bool first)
4215 {
4216     snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
4217     alc_write_coef_idx(codec, 0x26, 0xb000);
4218
4219     if (first)
4220         snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
4221
4222     snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4223     alc_write_coef_idx(codec, 0x26, 0xf000);
4224     alc_write_coef_idx(codec, 0x23, initval->value_0x23);
4225
4226     if (initval->value_0x23 != 0x1e)
4227         alc_write_coef_idx(codec, 0x25, initval->value_0x25);
4228
4229     snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4230     snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4231 }
4232
4233 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
4234                        const struct hda_fixup *fix,
4235                        int action)
4236 {
4237     /* Initialization magic */
4238     static const struct hda_alc298_mbxinit dac_init[] = {
4239         {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
4240         {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
4241         {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
4242         {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
4243         {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
4244         {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
4245         {0x2f, 0x00},
4246         {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
4247         {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
4248         {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
4249         {}
4250     };
4251     const struct hda_alc298_mbxinit *seq;
4252
4253     if (action != HDA_FIXUP_ACT_INIT)
4254         return;
4255
4256     /* Start */
4257     snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
4258     snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4259     alc_write_coef_idx(codec, 0x26, 0xf000);
4260     alc_write_coef_idx(codec, 0x22, 0x31);
4261     alc_write_coef_idx(codec, 0x23, 0x0b);
4262     alc_write_coef_idx(codec, 0x25, 0x00);
4263     snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4264     snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4265
4266     for (seq = dac_init; seq->value_0x23; seq++)
4267         alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
4268 }
4269
4270 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
4271                      const struct hda_fixup *fix, int action)
4272 {
4273     struct alc_spec *spec = codec->spec;
4274     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4275         spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4276         spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
4277     }
4278 }
4279
4280 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin,
4281                 bool polarity, bool on)
4282 {
4283     unsigned int pinval;
4284
4285     if (!pin)
4286         return;
4287     if (polarity)
4288         on = !on;
4289     pinval = snd_hda_codec_get_pin_target(codec, pin);
4290     pinval &= ~AC_PINCTL_VREFEN;
4291     pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ;
4292     /* temporarily power up/down for setting VREF */
4293     snd_hda_power_up_pm(codec);
4294     snd_hda_set_pin_ctl_cache(codec, pin, pinval);
4295     snd_hda_power_down_pm(codec);
4296 }
4297
4298 /* update mute-LED according to the speaker mute state via mic VREF pin */
4299 static int vref_mute_led_set(struct led_classdev *led_cdev,
4300                  enum led_brightness brightness)
4301 {
4302     struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4303     struct alc_spec *spec = codec->spec;
4304
4305     alc_update_vref_led(codec, spec->mute_led_nid,
4306                 spec->mute_led_polarity, brightness);
4307     return 0;
4308 }
4309
4310 /* Make sure the led works even in runtime suspend */
4311 static unsigned int led_power_filter(struct hda_codec *codec,
4312                           hda_nid_t nid,
4313                           unsigned int power_state)
4314 {
4315     struct alc_spec *spec = codec->spec;
4316
4317     if (power_state != AC_PWRST_D3 || nid == 0 ||
4318         (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4319         return power_state;
4320
4321     /* Set pin ctl again, it might have just been set to 0 */
4322     snd_hda_set_pin_ctl(codec, nid,
4323                 snd_hda_codec_get_pin_target(codec, nid));
4324
4325     return snd_hda_gen_path_power_filter(codec, nid, power_state);
4326 }
4327
4328 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4329                      const struct hda_fixup *fix, int action)
4330 {
4331     struct alc_spec *spec = codec->spec;
4332     const struct dmi_device *dev = NULL;
4333
4334     if (action != HDA_FIXUP_ACT_PRE_PROBE)
4335         return;
4336
4337     while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4338         int pol, pin;
4339         if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4340             continue;
4341         if (pin < 0x0a || pin >= 0x10)
4342             break;
4343         spec->mute_led_polarity = pol;
4344         spec->mute_led_nid = pin - 0x0a + 0x18;
4345         snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4346         codec->power_filter = led_power_filter;
4347         codec_dbg(codec,
4348               "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4349                spec->mute_led_polarity);
4350         break;
4351     }
4352 }
4353
4354 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4355                       const struct hda_fixup *fix,
4356                       int action, hda_nid_t pin)
4357 {
4358     struct alc_spec *spec = codec->spec;
4359
4360     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4361         spec->mute_led_polarity = 0;
4362         spec->mute_led_nid = pin;
4363         snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4364         codec->power_filter = led_power_filter;
4365     }
4366 }
4367
4368 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4369                 const struct hda_fixup *fix, int action)
4370 {
4371     alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4372 }
4373
4374 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4375                 const struct hda_fixup *fix, int action)
4376 {
4377     alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4378 }
4379
4380 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4381                 const struct hda_fixup *fix, int action)
4382 {
4383     alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4384 }
4385
4386 /* update LED status via GPIO */
4387 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4388                 int polarity, bool enabled)
4389 {
4390     if (polarity)
4391         enabled = !enabled;
4392     alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
4393 }
4394
4395 /* turn on/off mute LED via GPIO per vmaster hook */
4396 static int gpio_mute_led_set(struct led_classdev *led_cdev,
4397                  enum led_brightness brightness)
4398 {
4399     struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4400     struct alc_spec *spec = codec->spec;
4401
4402     alc_update_gpio_led(codec, spec->gpio_mute_led_mask,
4403                 spec->mute_led_polarity, !brightness);
4404     return 0;
4405 }
4406
4407 /* turn on/off mic-mute LED via GPIO per capture hook */
4408 static int micmute_led_set(struct led_classdev *led_cdev,
4409                enum led_brightness brightness)
4410 {
4411     struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4412     struct alc_spec *spec = codec->spec;
4413
4414     alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4415                 spec->micmute_led_polarity, !brightness);
4416     return 0;
4417 }
4418
4419 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
4420 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4421                   int action,
4422                   unsigned int mute_mask,
4423                   unsigned int micmute_mask)
4424 {
4425     struct alc_spec *spec = codec->spec;
4426
4427     alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4428
4429     if (action != HDA_FIXUP_ACT_PRE_PROBE)
4430         return;
4431     if (mute_mask) {
4432         spec->gpio_mute_led_mask = mute_mask;
4433         snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set);
4434     }
4435     if (micmute_mask) {
4436         spec->gpio_mic_led_mask = micmute_mask;
4437         snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4438     }
4439 }
4440
4441 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec,
4442                 const struct hda_fixup *fix, int action)
4443 {
4444     alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01);
4445 }
4446
4447 static void alc269_fixup_hp_gpio_led(struct hda_codec *codec,
4448                 const struct hda_fixup *fix, int action)
4449 {
4450     alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4451 }
4452
4453 static void alc285_fixup_hp_gpio_led(struct hda_codec *codec,
4454                 const struct hda_fixup *fix, int action)
4455 {
4456     alc_fixup_hp_gpio_led(codec, action, 0x04, 0x01);
4457 }
4458
4459 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4460                 const struct hda_fixup *fix, int action)
4461 {
4462     alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4463 }
4464
4465 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec,
4466                 const struct hda_fixup *fix, int action)
4467 {
4468     alc_fixup_hp_gpio_led(codec, action, 0x10, 0);
4469 }
4470
4471 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
4472                 const struct hda_fixup *fix, int action)
4473 {
4474     struct alc_spec *spec = codec->spec;
4475
4476     if (action == HDA_FIXUP_ACT_PRE_PROBE)
4477         spec->micmute_led_polarity = 1;
4478     alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4479 }
4480
4481 /* turn on/off mic-mute LED per capture hook via VREF change */
4482 static int vref_micmute_led_set(struct led_classdev *led_cdev,
4483                 enum led_brightness brightness)
4484 {
4485     struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4486     struct alc_spec *spec = codec->spec;
4487
4488     alc_update_vref_led(codec, spec->cap_mute_led_nid,
4489                 spec->micmute_led_polarity, brightness);
4490     return 0;
4491 }
4492
4493 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4494                 const struct hda_fixup *fix, int action)
4495 {
4496     struct alc_spec *spec = codec->spec;
4497
4498     alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4499     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4500         /* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4501          * enable headphone amp
4502          */
4503         spec->gpio_mask |= 0x10;
4504         spec->gpio_dir |= 0x10;
4505         spec->cap_mute_led_nid = 0x18;
4506         snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4507         codec->power_filter = led_power_filter;
4508     }
4509 }
4510
4511 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4512                    const struct hda_fixup *fix, int action)
4513 {
4514     struct alc_spec *spec = codec->spec;
4515
4516     alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4517     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4518         spec->cap_mute_led_nid = 0x18;
4519         snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4520         codec->power_filter = led_power_filter;
4521     }
4522 }
4523
4524 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp;
4525  * it needs to toggle the GPIO0 once on and off at each time (bko#210633)
4526  */
4527 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec,
4528                      const struct hda_fixup *fix, int action)
4529 {
4530     struct alc_spec *spec = codec->spec;
4531
4532     switch (action) {
4533     case HDA_FIXUP_ACT_PRE_PROBE:
4534         spec->gpio_mask |= 0x01;
4535         spec->gpio_dir |= 0x01;
4536         break;
4537     case HDA_FIXUP_ACT_INIT:
4538         /* need to toggle GPIO to enable the amp */
4539         alc_update_gpio_data(codec, 0x01, true);
4540         msleep(100);
4541         alc_update_gpio_data(codec, 0x01, false);
4542         break;
4543     }
4544 }
4545
4546 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */
4547 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo,
4548                     struct hda_codec *codec,
4549                     struct snd_pcm_substream *substream,
4550                     int action)
4551 {
4552     switch (action) {
4553     case HDA_GEN_PCM_ACT_PREPARE:
4554         alc_update_gpio_data(codec, 0x04, true);
4555         break;
4556     case HDA_GEN_PCM_ACT_CLEANUP:
4557         alc_update_gpio_data(codec, 0x04, false);
4558         break;
4559     }
4560 }
4561
4562 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec,
4563                       const struct hda_fixup *fix,
4564                       int action)
4565 {
4566     struct alc_spec *spec = codec->spec;
4567
4568     if (action == HDA_FIXUP_ACT_PROBE) {
4569         spec->gpio_mask |= 0x04;
4570         spec->gpio_dir |= 0x04;
4571         spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook;
4572     }
4573 }
4574
4575 static void alc_update_coef_led(struct hda_codec *codec,
4576                 struct alc_coef_led *led,
4577                 bool polarity, bool on)
4578 {
4579     if (polarity)
4580         on = !on;
4581     /* temporarily power up/down for setting COEF bit */
4582     alc_update_coef_idx(codec, led->idx, led->mask,
4583                 on ? led->on : led->off);
4584 }
4585
4586 /* update mute-LED according to the speaker mute state via COEF bit */
4587 static int coef_mute_led_set(struct led_classdev *led_cdev,
4588                  enum led_brightness brightness)
4589 {
4590     struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4591     struct alc_spec *spec = codec->spec;
4592
4593     alc_update_coef_led(codec, &spec->mute_led_coef,
4594                 spec->mute_led_polarity, brightness);
4595     return 0;
4596 }
4597
4598 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4599                       const struct hda_fixup *fix,
4600                       int action)
4601 {
4602     struct alc_spec *spec = codec->spec;
4603
4604     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4605         spec->mute_led_polarity = 0;
4606         spec->mute_led_coef.idx = 0x0b;
4607         spec->mute_led_coef.mask = 1 << 3;
4608         spec->mute_led_coef.on = 1 << 3;
4609         spec->mute_led_coef.off = 0;
4610         snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4611     }
4612 }
4613
4614 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4615                       const struct hda_fixup *fix,
4616                       int action)
4617 {
4618     struct alc_spec *spec = codec->spec;
4619
4620     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4621         spec->mute_led_polarity = 0;
4622         spec->mute_led_coef.idx = 0x34;
4623         spec->mute_led_coef.mask = 1 << 5;
4624         spec->mute_led_coef.on = 0;
4625         spec->mute_led_coef.off = 1 << 5;
4626         snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4627     }
4628 }
4629
4630 /* turn on/off mic-mute LED per capture hook by coef bit */
4631 static int coef_micmute_led_set(struct led_classdev *led_cdev,
4632                 enum led_brightness brightness)
4633 {
4634     struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4635     struct alc_spec *spec = codec->spec;
4636
4637     alc_update_coef_led(codec, &spec->mic_led_coef,
4638                 spec->micmute_led_polarity, brightness);
4639     return 0;
4640 }
4641
4642 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4643                 const struct hda_fixup *fix, int action)
4644 {
4645     struct alc_spec *spec = codec->spec;
4646
4647     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4648         spec->mic_led_coef.idx = 0x19;
4649         spec->mic_led_coef.mask = 1 << 13;
4650         spec->mic_led_coef.on = 1 << 13;
4651         spec->mic_led_coef.off = 0;
4652         snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4653     }
4654 }
4655
4656 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4657                 const struct hda_fixup *fix, int action)
4658 {
4659     struct alc_spec *spec = codec->spec;
4660
4661     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4662         spec->mic_led_coef.idx = 0x35;
4663         spec->mic_led_coef.mask = 3 << 2;
4664         spec->mic_led_coef.on = 2 << 2;
4665         spec->mic_led_coef.off = 1 << 2;
4666         snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4667     }
4668 }
4669
4670 static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4671                 const struct hda_fixup *fix, int action)
4672 {
4673     alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4674     alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4675 }
4676
4677 static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4678                 const struct hda_fixup *fix, int action)
4679 {
4680     alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4681     alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4682 }
4683
4684 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec,
4685                 const struct hda_fixup *fix, int action)
4686 {
4687     struct alc_spec *spec = codec->spec;
4688
4689     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4690         spec->cap_mute_led_nid = 0x1a;
4691         snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4692         codec->power_filter = led_power_filter;
4693     }
4694 }
4695
4696 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec,
4697                 const struct hda_fixup *fix, int action)
4698 {
4699     alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4700     alc236_fixup_hp_micmute_led_vref(codec, fix, action);
4701 }
4702
4703 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec,
4704                           const unsigned short coefs[2])
4705 {
4706     alc_write_coef_idx(codec, 0x23, coefs[0]);
4707     alc_write_coef_idx(codec, 0x25, coefs[1]);
4708     alc_write_coef_idx(codec, 0x26, 0xb011);
4709 }
4710
4711 struct alc298_samsung_amp_desc {
4712     unsigned char nid;
4713     unsigned short init_seq[2][2];
4714 };
4715
4716 static void alc298_fixup_samsung_amp(struct hda_codec *codec,
4717                      const struct hda_fixup *fix, int action)
4718 {
4719     int i, j;
4720     static const unsigned short init_seq[][2] = {
4721         { 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 },
4722         { 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 },
4723         { 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e },
4724         { 0x41, 0x07 }, { 0x400, 0x1 }
4725     };
4726     static const struct alc298_samsung_amp_desc amps[] = {
4727         { 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } },
4728         { 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } }
4729     };
4730
4731     if (action != HDA_FIXUP_ACT_INIT)
4732         return;
4733
4734     for (i = 0; i < ARRAY_SIZE(amps); i++) {
4735         alc_write_coef_idx(codec, 0x22, amps[i].nid);
4736
4737         for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++)
4738             alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]);
4739
4740         for (j = 0; j < ARRAY_SIZE(init_seq); j++)
4741             alc298_samsung_write_coef_pack(codec, init_seq[j]);
4742     }
4743 }
4744
4745 #if IS_REACHABLE(CONFIG_INPUT)
4746 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4747                    struct hda_jack_callback *event)
4748 {
4749     struct alc_spec *spec = codec->spec;
4750
4751     /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4752        send both key on and key off event for every interrupt. */
4753     input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4754     input_sync(spec->kb_dev);
4755     input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4756     input_sync(spec->kb_dev);
4757 }
4758
4759 static int alc_register_micmute_input_device(struct hda_codec *codec)
4760 {
4761     struct alc_spec *spec = codec->spec;
4762     int i;
4763
4764     spec->kb_dev = input_allocate_device();
4765     if (!spec->kb_dev) {
4766         codec_err(codec, "Out of memory (input_allocate_device)\n");
4767         return -ENOMEM;
4768     }
4769
4770     spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4771
4772     spec->kb_dev->name = "Microphone Mute Button";
4773     spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4774     spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4775     spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4776     spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4777     for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4778         set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4779
4780     if (input_register_device(spec->kb_dev)) {
4781         codec_err(codec, "input_register_device failed\n");
4782         input_free_device(spec->kb_dev);
4783         spec->kb_dev = NULL;
4784         return -ENOMEM;
4785     }
4786
4787     return 0;
4788 }
4789
4790 /* GPIO1 = set according to SKU external amp
4791  * GPIO2 = mic mute hotkey
4792  * GPIO3 = mute LED
4793  * GPIO4 = mic mute LED
4794  */
4795 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4796                          const struct hda_fixup *fix, int action)
4797 {
4798     struct alc_spec *spec = codec->spec;
4799
4800     alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4801     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4802         spec->init_amp = ALC_INIT_DEFAULT;
4803         if (alc_register_micmute_input_device(codec) != 0)
4804             return;
4805
4806         spec->gpio_mask |= 0x06;
4807         spec->gpio_dir |= 0x02;
4808         spec->gpio_data |= 0x02;
4809         snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4810                       AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
4811         snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4812                             gpio2_mic_hotkey_event);
4813         return;
4814     }
4815
4816     if (!spec->kb_dev)
4817         return;
4818
4819     switch (action) {
4820     case HDA_FIXUP_ACT_FREE:
4821         input_unregister_device(spec->kb_dev);
4822         spec->kb_dev = NULL;
4823     }
4824 }
4825
4826 /* Line2 = mic mute hotkey
4827  * GPIO2 = mic mute LED
4828  */
4829 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
4830                          const struct hda_fixup *fix, int action)
4831 {
4832     struct alc_spec *spec = codec->spec;
4833
4834     alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4835     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4836         spec->init_amp = ALC_INIT_DEFAULT;
4837         if (alc_register_micmute_input_device(codec) != 0)
4838             return;
4839
4840         snd_hda_jack_detect_enable_callback(codec, 0x1b,
4841                             gpio2_mic_hotkey_event);
4842         return;
4843     }
4844
4845     if (!spec->kb_dev)
4846         return;
4847
4848     switch (action) {
4849     case HDA_FIXUP_ACT_FREE:
4850         input_unregister_device(spec->kb_dev);
4851         spec->kb_dev = NULL;
4852     }
4853 }
4854 #else /* INPUT */
4855 #define alc280_fixup_hp_gpio2_mic_hotkey    NULL
4856 #define alc233_fixup_lenovo_line2_mic_hotkey    NULL
4857 #endif /* INPUT */
4858
4859 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
4860                 const struct hda_fixup *fix, int action)
4861 {
4862     struct alc_spec *spec = codec->spec;
4863
4864     alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
4865     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4866         spec->cap_mute_led_nid = 0x18;
4867         snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4868     }
4869 }
4870
4871 static const struct coef_fw alc225_pre_hsmode[] = {
4872     UPDATE_COEF(0x4a, 1<<8, 0),
4873     UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4874     UPDATE_COEF(0x63, 3<<14, 3<<14),
4875     UPDATE_COEF(0x4a, 3<<4, 2<<4),
4876     UPDATE_COEF(0x4a, 3<<10, 3<<10),
4877     UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4878     UPDATE_COEF(0x4a, 3<<10, 0),
4879     {}
4880 };
4881
4882 static void alc_headset_mode_unplugged(struct hda_codec *codec)
4883 {
4884     struct alc_spec *spec = codec->spec;
4885     static const struct coef_fw coef0255[] = {
4886         WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
4887         WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4888         UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4889         WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4890         WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
4891         {}
4892     };
4893     static const struct coef_fw coef0256[] = {
4894         WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
4895         WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4896         WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4897         WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
4898         UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4899         {}
4900     };
4901     static const struct coef_fw coef0233[] = {
4902         WRITE_COEF(0x1b, 0x0c0b),
4903         WRITE_COEF(0x45, 0xc429),
4904         UPDATE_COEF(0x35, 0x4000, 0),
4905         WRITE_COEF(0x06, 0x2104),
4906         WRITE_COEF(0x1a, 0x0001),
4907         WRITE_COEF(0x26, 0x0004),
4908         WRITE_COEF(0x32, 0x42a3),
4909         {}
4910     };
4911     static const struct coef_fw coef0288[] = {
4912         UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4913         UPDATE_COEF(0x50, 0x2000, 0x2000),
4914         UPDATE_COEF(0x56, 0x0006, 0x0006),
4915         UPDATE_COEF(0x66, 0x0008, 0),
4916         UPDATE_COEF(0x67, 0x2000, 0),
4917         {}
4918     };
4919     static const struct coef_fw coef0298[] = {
4920         UPDATE_COEF(0x19, 0x1300, 0x0300),
4921         {}
4922     };
4923     static const struct coef_fw coef0292[] = {
4924         WRITE_COEF(0x76, 0x000e),
4925         WRITE_COEF(0x6c, 0x2400),
4926         WRITE_COEF(0x18, 0x7308),
4927         WRITE_COEF(0x6b, 0xc429),
4928         {}
4929     };
4930     static const struct coef_fw coef0293[] = {
4931         UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
4932         UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
4933         UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
4934         UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
4935         WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
4936         UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4937         {}
4938     };
4939     static const struct coef_fw coef0668[] = {
4940         WRITE_COEF(0x15, 0x0d40),
4941         WRITE_COEF(0xb7, 0x802b),
4942         {}
4943     };
4944     static const struct coef_fw coef0225[] = {
4945         UPDATE_COEF(0x63, 3<<14, 0),
4946         {}
4947     };
4948     static const struct coef_fw coef0274[] = {
4949         UPDATE_COEF(0x4a, 0x0100, 0),
4950         UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
4951         UPDATE_COEF(0x6b, 0xf000, 0x5000),
4952         UPDATE_COEF(0x4a, 0x0010, 0),
4953         UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
4954         WRITE_COEF(0x45, 0x5289),
4955         UPDATE_COEF(0x4a, 0x0c00, 0),
4956         {}
4957     };
4958
4959     if (spec->no_internal_mic_pin) {
4960         alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
4961         return;
4962     }
4963
4964     switch (codec->core.vendor_id) {
4965     case 0x10ec0255:
4966         alc_process_coef_fw(codec, coef0255);
4967         break;
4968     case 0x10ec0230:
4969     case 0x10ec0236:
4970     case 0x10ec0256:
4971     case 0x19e58326:
4972         alc_process_coef_fw(codec, coef0256);
4973         break;
4974     case 0x10ec0234:
4975     case 0x10ec0274:
4976     case 0x10ec0294:
4977         alc_process_coef_fw(codec, coef0274);
4978         break;
4979     case 0x10ec0233:
4980     case 0x10ec0283:
4981         alc_process_coef_fw(codec, coef0233);
4982         break;
4983     case 0x10ec0286:
4984     case 0x10ec0288:
4985         alc_process_coef_fw(codec, coef0288);
4986         break;
4987     case 0x10ec0298:
4988         alc_process_coef_fw(codec, coef0298);
4989         alc_process_coef_fw(codec, coef0288);
4990         break;
4991     case 0x10ec0292:
4992         alc_process_coef_fw(codec, coef0292);
4993         break;
4994     case 0x10ec0293:
4995         alc_process_coef_fw(codec, coef0293);
4996         break;
4997     case 0x10ec0668:
4998         alc_process_coef_fw(codec, coef0668);
4999         break;
5000     case 0x10ec0215:
5001     case 0x10ec0225:
5002     case 0x10ec0285:
5003     case 0x10ec0295:
5004     case 0x10ec0289:
5005     case 0x10ec0299:
5006         alc_process_coef_fw(codec, alc225_pre_hsmode);
5007         alc_process_coef_fw(codec, coef0225);
5008         break;
5009     case 0x10ec0867:
5010         alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5011         break;
5012     }
5013     codec_dbg(codec, "Headset jack set to unplugged mode.\n");
5014 }
5015
5016
5017 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
5018                     hda_nid_t mic_pin)
5019 {
5020     static const struct coef_fw coef0255[] = {
5021         WRITE_COEFEX(0x57, 0x03, 0x8aa6),
5022         WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5023         {}
5024     };
5025     static const struct coef_fw coef0256[] = {
5026         UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
5027         WRITE_COEFEX(0x57, 0x03, 0x09a3),
5028         WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5029         {}
5030     };
5031     static const struct coef_fw coef0233[] = {
5032         UPDATE_COEF(0x35, 0, 1<<14),
5033         WRITE_COEF(0x06, 0x2100),
5034         WRITE_COEF(0x1a, 0x0021),
5035         WRITE_COEF(0x26, 0x008c),
5036         {}
5037     };
5038     static const struct coef_fw coef0288[] = {
5039         UPDATE_COEF(0x4f, 0x00c0, 0),
5040         UPDATE_COEF(0x50, 0x2000, 0),
5041         UPDATE_COEF(0x56, 0x0006, 0),
5042         UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5043         UPDATE_COEF(0x66, 0x0008, 0x0008),
5044         UPDATE_COEF(0x67, 0x2000, 0x2000),
5045         {}
5046     };
5047     static const struct coef_fw coef0292[] = {
5048         WRITE_COEF(0x19, 0xa208),
5049         WRITE_COEF(0x2e, 0xacf0),
5050         {}
5051     };
5052     static const struct coef_fw coef0293[] = {
5053         UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
5054         UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
5055         UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5056         {}
5057     };
5058     static const struct coef_fw coef0688[] = {
5059         WRITE_COEF(0xb7, 0x802b),
5060         WRITE_COEF(0xb5, 0x1040),
5061         UPDATE_COEF(0xc3, 0, 1<<12),
5062         {}
5063     };
5064     static const struct coef_fw coef0225[] = {
5065         UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
5066         UPDATE_COEF(0x4a, 3<<4, 2<<4),
5067         UPDATE_COEF(0x63, 3<<14, 0),
5068         {}
5069     };
5070     static const struct coef_fw coef0274[] = {
5071         UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
5072         UPDATE_COEF(0x4a, 0x0010, 0),
5073         UPDATE_COEF(0x6b, 0xf000, 0),
5074         {}
5075     };
5076
5077     switch (codec->core.vendor_id) {
5078     case 0x10ec0255:
5079         alc_write_coef_idx(codec, 0x45, 0xc489);
5080         snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5081         alc_process_coef_fw(codec, coef0255);
5082         snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5083         break;
5084     case 0x10ec0230:
5085     case 0x10ec0236:
5086     case 0x10ec0256:
5087     case 0x19e58326:
5088         alc_write_coef_idx(codec, 0x45, 0xc489);
5089         snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5090         alc_process_coef_fw(codec, coef0256);
5091         snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5092         break;
5093     case 0x10ec0234:
5094     case 0x10ec0274:
5095     case 0x10ec0294:
5096         alc_write_coef_idx(codec, 0x45, 0x4689);
5097         snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5098         alc_process_coef_fw(codec, coef0274);
5099         snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5100         break;
5101     case 0x10ec0233:
5102     case 0x10ec0283:
5103         alc_write_coef_idx(codec, 0x45, 0xc429);
5104         snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5105         alc_process_coef_fw(codec, coef0233);
5106         snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5107         break;
5108     case 0x10ec0286:
5109     case 0x10ec0288:
5110     case 0x10ec0298:
5111         snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5112         alc_process_coef_fw(codec, coef0288);
5113         snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5114         break;
5115     case 0x10ec0292:
5116         snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5117         alc_process_coef_fw(codec, coef0292);
5118         break;
5119     case 0x10ec0293:
5120         /* Set to TRS mode */
5121         alc_write_coef_idx(codec, 0x45, 0xc429);
5122         snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5123         alc_process_coef_fw(codec, coef0293);
5124         snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5125         break;
5126     case 0x10ec0867:
5127         alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
5128         fallthrough;
5129     case 0x10ec0221:
5130     case 0x10ec0662:
5131         snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5132         snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5133         break;
5134     case 0x10ec0668:
5135         alc_write_coef_idx(codec, 0x11, 0x0001);
5136         snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5137         alc_process_coef_fw(codec, coef0688);
5138         snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5139         break;
5140     case 0x10ec0215:
5141     case 0x10ec0225:
5142     case 0x10ec0285:
5143     case 0x10ec0295:
5144     case 0x10ec0289:
5145     case 0x10ec0299:
5146         alc_process_coef_fw(codec, alc225_pre_hsmode);
5147         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
5148         snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5149         alc_process_coef_fw(codec, coef0225);
5150         snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5151         break;
5152     }
5153     codec_dbg(codec, "Headset jack set to mic-in mode.\n");
5154 }
5155
5156 static void alc_headset_mode_default(struct hda_codec *codec)
5157 {
5158     static const struct coef_fw coef0225[] = {
5159         UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
5160         UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
5161         UPDATE_COEF(0x49, 3<<8, 0<<8),
5162         UPDATE_COEF(0x4a, 3<<4, 3<<4),
5163         UPDATE_COEF(0x63, 3<<14, 0),
5164         UPDATE_COEF(0x67, 0xf000, 0x3000),
5165         {}
5166     };
5167     static const struct coef_fw coef0255[] = {
5168         WRITE_COEF(0x45, 0xc089),
5169         WRITE_COEF(0x45, 0xc489),
5170         WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5171         WRITE_COEF(0x49, 0x0049),
5172         {}
5173     };
5174     static const struct coef_fw coef0256[] = {
5175         WRITE_COEF(0x45, 0xc489),
5176         WRITE_COEFEX(0x57, 0x03, 0x0da3),
5177         WRITE_COEF(0x49, 0x0049),
5178         UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5179         WRITE_COEF(0x06, 0x6100),
5180         {}
5181     };
5182     static const struct coef_fw coef0233[] = {
5183         WRITE_COEF(0x06, 0x2100),
5184         WRITE_COEF(0x32, 0x4ea3),
5185         {}
5186     };
5187     static const struct coef_fw coef0288[] = {
5188         UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
5189         UPDATE_COEF(0x50, 0x2000, 0x2000),
5190         UPDATE_COEF(0x56, 0x0006, 0x0006),
5191         UPDATE_COEF(0x66, 0x0008, 0),
5192         UPDATE_COEF(0x67, 0x2000, 0),
5193         {}
5194     };
5195     static const struct coef_fw coef0292[] = {
5196         WRITE_COEF(0x76, 0x000e),
5197         WRITE_COEF(0x6c, 0x2400),
5198         WRITE_COEF(0x6b, 0xc429),
5199         WRITE_COEF(0x18, 0x7308),
5200         {}
5201     };
5202     static const struct coef_fw coef0293[] = {
5203         UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5204         WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
5205         UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5206         {}
5207     };
5208     static const struct coef_fw coef0688[] = {
5209         WRITE_COEF(0x11, 0x0041),
5210         WRITE_COEF(0x15, 0x0d40),
5211         WRITE_COEF(0xb7, 0x802b),
5212         {}
5213     };
5214     static const struct coef_fw coef0274[] = {
5215         WRITE_COEF(0x45, 0x4289),
5216         UPDATE_COEF(0x4a, 0x0010, 0x0010),
5217         UPDATE_COEF(0x6b, 0x0f00, 0),
5218         UPDATE_COEF(0x49, 0x0300, 0x0300),
5219         {}
5220     };
5221
5222     switch (codec->core.vendor_id) {
5223     case 0x10ec0215:
5224     case 0x10ec0225:
5225     case 0x10ec0285:
5226     case 0x10ec0295:
5227     case 0x10ec0289:
5228     case 0x10ec0299:
5229         alc_process_coef_fw(codec, alc225_pre_hsmode);
5230         alc_process_coef_fw(codec, coef0225);
5231         break;
5232     case 0x10ec0255:
5233         alc_process_coef_fw(codec, coef0255);
5234         break;
5235     case 0x10ec0230:
5236     case 0x10ec0236:
5237     case 0x10ec0256:
5238     case 0x19e58326:
5239         alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5240         alc_write_coef_idx(codec, 0x45, 0xc089);
5241         msleep(50);
5242         alc_process_coef_fw(codec, coef0256);
5243         break;
5244     case 0x10ec0234:
5245     case 0x10ec0274:
5246     case 0x10ec0294:
5247         alc_process_coef_fw(codec, coef0274);
5248         break;
5249     case 0x10ec0233:
5250     case 0x10ec0283:
5251         alc_process_coef_fw(codec, coef0233);
5252         break;
5253     case 0x10ec0286:
5254     case 0x10ec0288:
5255     case 0x10ec0298:
5256         alc_process_coef_fw(codec, coef0288);
5257         break;
5258     case 0x10ec0292:
5259         alc_process_coef_fw(codec, coef0292);
5260         break;
5261     case 0x10ec0293:
5262         alc_process_coef_fw(codec, coef0293);
5263         break;
5264     case 0x10ec0668:
5265         alc_process_coef_fw(codec, coef0688);
5266         break;
5267     case 0x10ec0867:
5268         alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5269         break;
5270     }
5271     codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
5272 }
5273
5274 /* Iphone type */
5275 static void alc_headset_mode_ctia(struct hda_codec *codec)
5276 {
5277     int val;
5278
5279     static const struct coef_fw coef0255[] = {
5280         WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5281         WRITE_COEF(0x1b, 0x0c2b),
5282         WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5283         {}
5284     };
5285     static const struct coef_fw coef0256[] = {
5286         WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5287         WRITE_COEF(0x1b, 0x0e6b),
5288         {}
5289     };
5290     static const struct coef_fw coef0233[] = {
5291         WRITE_COEF(0x45, 0xd429),
5292         WRITE_COEF(0x1b, 0x0c2b),
5293         WRITE_COEF(0x32, 0x4ea3),
5294         {}
5295     };
5296     static const struct coef_fw coef0288[] = {
5297         UPDATE_COEF(0x50, 0x2000, 0x2000),
5298         UPDATE_COEF(0x56, 0x0006, 0x0006),
5299         UPDATE_COEF(0x66, 0x0008, 0),
5300         UPDATE_COEF(0x67, 0x2000, 0),
5301         {}
5302     };
5303     static const struct coef_fw coef0292[] = {
5304         WRITE_COEF(0x6b, 0xd429),
5305         WRITE_COEF(0x76, 0x0008),
5306         WRITE_COEF(0x18, 0x7388),
5307         {}
5308     };
5309     static const struct coef_fw coef0293[] = {
5310         WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
5311         UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5312         {}
5313     };
5314     static const struct coef_fw coef0688[] = {
5315         WRITE_COEF(0x11, 0x0001),
5316         WRITE_COEF(0x15, 0x0d60),
5317         WRITE_COEF(0xc3, 0x0000),
5318         {}
5319     };
5320     static const struct coef_fw coef0225_1[] = {
5321         UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5322         UPDATE_COEF(0x63, 3<<14, 2<<14),
5323         {}
5324     };
5325     static const struct coef_fw coef0225_2[] = {
5326         UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5327         UPDATE_COEF(0x63, 3<<14, 1<<14),
5328         {}
5329     };
5330
5331     switch (codec->core.vendor_id) {
5332     case 0x10ec0255:
5333         alc_process_coef_fw(codec, coef0255);
5334         break;
5335     case 0x10ec0230:
5336     case 0x10ec0236:
5337     case 0x10ec0256:
5338     case 0x19e58326:
5339         alc_process_coef_fw(codec, coef0256);
5340         break;
5341     case 0x10ec0234:
5342     case 0x10ec0274:
5343     case 0x10ec0294:
5344         alc_write_coef_idx(codec, 0x45, 0xd689);
5345         break;
5346     case 0x10ec0233:
5347     case 0x10ec0283:
5348         alc_process_coef_fw(codec, coef0233);
5349         break;
5350     case 0x10ec0298:
5351         val = alc_read_coef_idx(codec, 0x50);
5352         if (val & (1 << 12)) {
5353             alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5354             alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5355             msleep(300);
5356         } else {
5357             alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5358             alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5359             msleep(300);
5360         }
5361         break;
5362     case 0x10ec0286:
5363     case 0x10ec0288:
5364         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5365         msleep(300);
5366         alc_process_coef_fw(codec, coef0288);
5367         break;
5368     case 0x10ec0292:
5369         alc_process_coef_fw(codec, coef0292);
5370         break;
5371     case 0x10ec0293:
5372         alc_process_coef_fw(codec, coef0293);
5373         break;
5374     case 0x10ec0668:
5375         alc_process_coef_fw(codec, coef0688);
5376         break;
5377     case 0x10ec0215:
5378     case 0x10ec0225:
5379     case 0x10ec0285:
5380     case 0x10ec0295:
5381     case 0x10ec0289:
5382     case 0x10ec0299:
5383         val = alc_read_coef_idx(codec, 0x45);
5384         if (val & (1 << 9))
5385             alc_process_coef_fw(codec, coef0225_2);
5386         else
5387             alc_process_coef_fw(codec, coef0225_1);
5388         break;
5389     case 0x10ec0867:
5390         alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5391         break;
5392     }
5393     codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
5394 }
5395
5396 /* Nokia type */
5397 static void alc_headset_mode_omtp(struct hda_codec *codec)
5398 {
5399     static const struct coef_fw coef0255[] = {
5400         WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5401         WRITE_COEF(0x1b, 0x0c2b),
5402         WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5403         {}
5404     };
5405     static const struct coef_fw coef0256[] = {
5406         WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5407         WRITE_COEF(0x1b, 0x0e6b),
5408         {}
5409     };
5410     static const struct coef_fw coef0233[] = {
5411         WRITE_COEF(0x45, 0xe429),
5412         WRITE_COEF(0x1b, 0x0c2b),
5413         WRITE_COEF(0x32, 0x4ea3),
5414         {}
5415     };
5416     static const struct coef_fw coef0288[] = {
5417         UPDATE_COEF(0x50, 0x2000, 0x2000),
5418         UPDATE_COEF(0x56, 0x0006, 0x0006),
5419         UPDATE_COEF(0x66, 0x0008, 0),
5420         UPDATE_COEF(0x67, 0x2000, 0),
5421         {}
5422     };
5423     static const struct coef_fw coef0292[] = {
5424         WRITE_COEF(0x6b, 0xe429),
5425         WRITE_COEF(0x76, 0x0008),
5426         WRITE_COEF(0x18, 0x7388),
5427         {}
5428     };
5429     static const struct coef_fw coef0293[] = {
5430         WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
5431         UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5432         {}
5433     };
5434     static const struct coef_fw coef0688[] = {
5435         WRITE_COEF(0x11, 0x0001),
5436         WRITE_COEF(0x15, 0x0d50),
5437         WRITE_COEF(0xc3, 0x0000),
5438         {}
5439     };
5440     static const struct coef_fw coef0225[] = {
5441         UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
5442         UPDATE_COEF(0x63, 3<<14, 2<<14),
5443         {}
5444     };
5445
5446     switch (codec->core.vendor_id) {
5447     case 0x10ec0255:
5448         alc_process_coef_fw(codec, coef0255);
5449         break;
5450     case 0x10ec0230:
5451     case 0x10ec0236:
5452     case 0x10ec0256:
5453     case 0x19e58326:
5454         alc_process_coef_fw(codec, coef0256);
5455         break;
5456     case 0x10ec0234:
5457     case 0x10ec0274:
5458     case 0x10ec0294:
5459         alc_write_coef_idx(codec, 0x45, 0xe689);
5460         break;
5461     case 0x10ec0233:
5462     case 0x10ec0283:
5463         alc_process_coef_fw(codec, coef0233);
5464         break;
5465     case 0x10ec0298:
5466         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
5467         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5468         msleep(300);
5469         break;
5470     case 0x10ec0286:
5471     case 0x10ec0288:
5472         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5473         msleep(300);
5474         alc_process_coef_fw(codec, coef0288);
5475         break;
5476     case 0x10ec0292:
5477         alc_process_coef_fw(codec, coef0292);
5478         break;
5479     case 0x10ec0293:
5480         alc_process_coef_fw(codec, coef0293);
5481         break;
5482     case 0x10ec0668:
5483         alc_process_coef_fw(codec, coef0688);
5484         break;
5485     case 0x10ec0215:
5486     case 0x10ec0225:
5487     case 0x10ec0285:
5488     case 0x10ec0295:
5489     case 0x10ec0289:
5490     case 0x10ec0299:
5491         alc_process_coef_fw(codec, coef0225);
5492         break;
5493     }
5494     codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5495 }
5496
5497 static void alc_determine_headset_type(struct hda_codec *codec)
5498 {
5499     int val;
5500     bool is_ctia = false;
5501     struct alc_spec *spec = codec->spec;
5502     static const struct coef_fw coef0255[] = {
5503         WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
5504         WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
5505  conteol) */
5506         {}
5507     };
5508     static const struct coef_fw coef0288[] = {
5509         UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
5510         {}
5511     };
5512     static const struct coef_fw coef0298[] = {
5513         UPDATE_COEF(0x50, 0x2000, 0x2000),
5514         UPDATE_COEF(0x56, 0x0006, 0x0006),
5515         UPDATE_COEF(0x66, 0x0008, 0),
5516         UPDATE_COEF(0x67, 0x2000, 0),
5517         UPDATE_COEF(0x19, 0x1300, 0x1300),
5518         {}
5519     };
5520     static const struct coef_fw coef0293[] = {
5521         UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
5522         WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
5523         {}
5524     };
5525     static const struct coef_fw coef0688[] = {
5526         WRITE_COEF(0x11, 0x0001),
5527         WRITE_COEF(0xb7, 0x802b),
5528         WRITE_COEF(0x15, 0x0d60),
5529         WRITE_COEF(0xc3, 0x0c00),
5530         {}
5531     };
5532     static const struct coef_fw coef0274[] = {
5533         UPDATE_COEF(0x4a, 0x0010, 0),
5534         UPDATE_COEF(0x4a, 0x8000, 0),
5535         WRITE_COEF(0x45, 0xd289),
5536         UPDATE_COEF(0x49, 0x0300, 0x0300),
5537         {}
5538     };
5539
5540     if (spec->no_internal_mic_pin) {
5541         alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5542         return;
5543     }
5544
5545     switch (codec->core.vendor_id) {
5546     case 0x10ec0255:
5547         alc_process_coef_fw(codec, coef0255);
5548         msleep(300);
5549         val = alc_read_coef_idx(codec, 0x46);
5550         is_ctia = (val & 0x0070) == 0x0070;
5551         break;
5552     case 0x10ec0230:
5553     case 0x10ec0236:
5554     case 0x10ec0256:
5555     case 0x19e58326:
5556         alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5557         alc_write_coef_idx(codec, 0x06, 0x6104);
5558         alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5559
5560         snd_hda_codec_write(codec, 0x21, 0,
5561                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5562         msleep(80);
5563         snd_hda_codec_write(codec, 0x21, 0,
5564                 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5565
5566         alc_process_coef_fw(codec, coef0255);
5567         msleep(300);
5568         val = alc_read_coef_idx(codec, 0x46);
5569         is_ctia = (val & 0x0070) == 0x0070;
5570
5571         alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5572         alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5573
5574         snd_hda_codec_write(codec, 0x21, 0,
5575                 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5576         msleep(80);
5577         snd_hda_codec_write(codec, 0x21, 0,
5578                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5579         break;
5580     case 0x10ec0234:
5581     case 0x10ec0274:
5582     case 0x10ec0294:
5583         alc_process_coef_fw(codec, coef0274);
5584         msleep(850);
5585         val = alc_read_coef_idx(codec, 0x46);
5586         is_ctia = (val & 0x00f0) == 0x00f0;
5587         break;
5588     case 0x10ec0233:
5589     case 0x10ec0283:
5590         alc_write_coef_idx(codec, 0x45, 0xd029);
5591         msleep(300);
5592         val = alc_read_coef_idx(codec, 0x46);
5593         is_ctia = (val & 0x0070) == 0x0070;
5594         break;
5595     case 0x10ec0298:
5596         snd_hda_codec_write(codec, 0x21, 0,
5597                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5598         msleep(100);
5599         snd_hda_codec_write(codec, 0x21, 0,
5600                 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5601         msleep(200);
5602
5603         val = alc_read_coef_idx(codec, 0x50);
5604         if (val & (1 << 12)) {
5605             alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5606             alc_process_coef_fw(codec, coef0288);
5607             msleep(350);
5608             val = alc_read_coef_idx(codec, 0x50);
5609             is_ctia = (val & 0x0070) == 0x0070;
5610         } else {
5611             alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5612             alc_process_coef_fw(codec, coef0288);
5613             msleep(350);
5614             val = alc_read_coef_idx(codec, 0x50);
5615             is_ctia = (val & 0x0070) == 0x0070;
5616         }
5617         alc_process_coef_fw(codec, coef0298);
5618         snd_hda_codec_write(codec, 0x21, 0,
5619                 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5620         msleep(75);
5621         snd_hda_codec_write(codec, 0x21, 0,
5622                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5623         break;
5624     case 0x10ec0286:
5625     case 0x10ec0288:
5626         alc_process_coef_fw(codec, coef0288);
5627         msleep(350);
5628         val = alc_read_coef_idx(codec, 0x50);
5629         is_ctia = (val & 0x0070) == 0x0070;
5630         break;
5631     case 0x10ec0292:
5632         alc_write_coef_idx(codec, 0x6b, 0xd429);
5633         msleep(300);
5634         val = alc_read_coef_idx(codec, 0x6c);
5635         is_ctia = (val & 0x001c) == 0x001c;
5636         break;
5637     case 0x10ec0293:
5638         alc_process_coef_fw(codec, coef0293);
5639         msleep(300);
5640         val = alc_read_coef_idx(codec, 0x46);
5641         is_ctia = (val & 0x0070) == 0x0070;
5642         break;
5643     case 0x10ec0668:
5644         alc_process_coef_fw(codec, coef0688);
5645         msleep(300);
5646         val = alc_read_coef_idx(codec, 0xbe);
5647         is_ctia = (val & 0x1c02) == 0x1c02;
5648         break;
5649     case 0x10ec0215:
5650     case 0x10ec0225:
5651     case 0x10ec0285:
5652     case 0x10ec0295:
5653     case 0x10ec0289:
5654     case 0x10ec0299:
5655         snd_hda_codec_write(codec, 0x21, 0,
5656                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5657         msleep(80);
5658         snd_hda_codec_write(codec, 0x21, 0,
5659                 AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5660
5661         alc_process_coef_fw(codec, alc225_pre_hsmode);
5662         alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5663         val = alc_read_coef_idx(codec, 0x45);
5664         if (val & (1 << 9)) {
5665             alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5666             alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5667             msleep(800);
5668             val = alc_read_coef_idx(codec, 0x46);
5669             is_ctia = (val & 0x00f0) == 0x00f0;
5670         } else {
5671             alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5672             alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5673             msleep(800);
5674             val = alc_read_coef_idx(codec, 0x46);
5675             is_ctia = (val & 0x00f0) == 0x00f0;
5676         }
5677         alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5678         alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5679         alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5680
5681         snd_hda_codec_write(codec, 0x21, 0,
5682                 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5683         msleep(80);
5684         snd_hda_codec_write(codec, 0x21, 0,
5685                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5686         break;
5687     case 0x10ec0867:
5688         is_ctia = true;
5689         break;
5690     }
5691
5692     codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5693             is_ctia ? "yes" : "no");
5694     spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5695 }
5696
5697 static void alc_update_headset_mode(struct hda_codec *codec)
5698 {
5699     struct alc_spec *spec = codec->spec;
5700
5701     hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5702     hda_nid_t hp_pin = alc_get_hp_pin(spec);
5703
5704     int new_headset_mode;
5705
5706     if (!snd_hda_jack_detect(codec, hp_pin))
5707         new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5708     else if (mux_pin == spec->headset_mic_pin)
5709         new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5710     else if (mux_pin == spec->headphone_mic_pin)
5711         new_headset_mode = ALC_HEADSET_MODE_MIC;
5712     else
5713         new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5714
5715     if (new_headset_mode == spec->current_headset_mode) {
5716         snd_hda_gen_update_outputs(codec);
5717         return;
5718     }
5719
5720     switch (new_headset_mode) {
5721     case ALC_HEADSET_MODE_UNPLUGGED:
5722         alc_headset_mode_unplugged(codec);
5723         spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5724         spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5725         spec->gen.hp_jack_present = false;
5726         break;
5727     case ALC_HEADSET_MODE_HEADSET:
5728         if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5729             alc_determine_headset_type(codec);
5730         if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5731             alc_headset_mode_ctia(codec);
5732         else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5733             alc_headset_mode_omtp(codec);
5734         spec->gen.hp_jack_present = true;
5735         break;
5736     case ALC_HEADSET_MODE_MIC:
5737         alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5738         spec->gen.hp_jack_present = false;
5739         break;
5740     case ALC_HEADSET_MODE_HEADPHONE:
5741         alc_headset_mode_default(codec);
5742         spec->gen.hp_jack_present = true;
5743         break;
5744     }
5745     if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5746         snd_hda_set_pin_ctl_cache(codec, hp_pin,
5747                       AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5748         if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5749             snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5750                           PIN_VREFHIZ);
5751     }
5752     spec->current_headset_mode = new_headset_mode;
5753
5754     snd_hda_gen_update_outputs(codec);
5755 }
5756
5757 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5758                      struct snd_kcontrol *kcontrol,
5759                      struct snd_ctl_elem_value *ucontrol)
5760 {
5761     alc_update_headset_mode(codec);
5762 }
5763
5764 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5765                        struct hda_jack_callback *jack)
5766 {
5767     snd_hda_gen_hp_automute(codec, jack);
5768     alc_update_headset_mode(codec);
5769 }
5770
5771 static void alc_probe_headset_mode(struct hda_codec *codec)
5772 {
5773     int i;
5774     struct alc_spec *spec = codec->spec;
5775     struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5776
5777     /* Find mic pins */
5778     for (i = 0; i < cfg->num_inputs; i++) {
5779         if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
5780             spec->headset_mic_pin = cfg->inputs[i].pin;
5781         if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
5782             spec->headphone_mic_pin = cfg->inputs[i].pin;
5783     }
5784
5785     WARN_ON(spec->gen.cap_sync_hook);
5786     spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
5787     spec->gen.automute_hook = alc_update_headset_mode;
5788     spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
5789 }
5790
5791 static void alc_fixup_headset_mode(struct hda_codec *codec,
5792                 const struct hda_fixup *fix, int action)
5793 {
5794     struct alc_spec *spec = codec->spec;
5795
5796     switch (action) {
5797     case HDA_FIXUP_ACT_PRE_PROBE:
5798         spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
5799         break;
5800     case HDA_FIXUP_ACT_PROBE:
5801         alc_probe_headset_mode(codec);
5802         break;
5803     case HDA_FIXUP_ACT_INIT:
5804         if (is_s3_resume(codec) || is_s4_resume(codec)) {
5805             spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5806             spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5807         }
5808         alc_update_headset_mode(codec);
5809         break;
5810     }
5811 }
5812
5813 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
5814                 const struct hda_fixup *fix, int action)
5815 {
5816     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5817         struct alc_spec *spec = codec->spec;
5818         spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5819     }
5820     else
5821         alc_fixup_headset_mode(codec, fix, action);
5822 }
5823
5824 static void alc255_set_default_jack_type(struct hda_codec *codec)
5825 {
5826     /* Set to iphone type */
5827     static const struct coef_fw alc255fw[] = {
5828         WRITE_COEF(0x1b, 0x880b),
5829         WRITE_COEF(0x45, 0xd089),
5830         WRITE_COEF(0x1b, 0x080b),
5831         WRITE_COEF(0x46, 0x0004),
5832         WRITE_COEF(0x1b, 0x0c0b),
5833         {}
5834     };
5835     static const struct coef_fw alc256fw[] = {
5836         WRITE_COEF(0x1b, 0x884b),
5837         WRITE_COEF(0x45, 0xd089),
5838         WRITE_COEF(0x1b, 0x084b),
5839         WRITE_COEF(0x46, 0x0004),
5840         WRITE_COEF(0x1b, 0x0c4b),
5841         {}
5842     };
5843     switch (codec->core.vendor_id) {
5844     case 0x10ec0255:
5845         alc_process_coef_fw(codec, alc255fw);
5846         break;
5847     case 0x10ec0230:
5848     case 0x10ec0236:
5849     case 0x10ec0256:
5850     case 0x19e58326:
5851         alc_process_coef_fw(codec, alc256fw);
5852         break;
5853     }
5854     msleep(30);
5855 }
5856
5857 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
5858                 const struct hda_fixup *fix, int action)
5859 {
5860     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5861         alc255_set_default_jack_type(codec);
5862     }
5863     alc_fixup_headset_mode(codec, fix, action);
5864 }
5865
5866 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
5867                 const struct hda_fixup *fix, int action)
5868 {
5869     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5870         struct alc_spec *spec = codec->spec;
5871         spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5872         alc255_set_default_jack_type(codec);
5873     }
5874     else
5875         alc_fixup_headset_mode(codec, fix, action);
5876 }
5877
5878 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
5879                        struct hda_jack_callback *jack)
5880 {
5881     struct alc_spec *spec = codec->spec;
5882
5883     alc_update_headset_jack_cb(codec, jack);
5884     /* Headset Mic enable or disable, only for Dell Dino */
5885     alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
5886 }
5887
5888 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
5889                 const struct hda_fixup *fix, int action)
5890 {
5891     alc_fixup_headset_mode(codec, fix, action);
5892     if (action == HDA_FIXUP_ACT_PROBE) {
5893         struct alc_spec *spec = codec->spec;
5894         /* toggled via hp_automute_hook */
5895         spec->gpio_mask |= 0x40;
5896         spec->gpio_dir |= 0x40;
5897         spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
5898     }
5899 }
5900
5901 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
5902                     const struct hda_fixup *fix, int action)
5903 {
5904     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5905         struct alc_spec *spec = codec->spec;
5906         spec->gen.auto_mute_via_amp = 1;
5907     }
5908 }
5909
5910 static void alc_fixup_no_shutup(struct hda_codec *codec,
5911                 const struct hda_fixup *fix, int action)
5912 {
5913     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5914         struct alc_spec *spec = codec->spec;
5915         spec->no_shutup_pins = 1;
5916     }
5917 }
5918
5919 static void alc_fixup_disable_aamix(struct hda_codec *codec,
5920                     const struct hda_fixup *fix, int action)
5921 {
5922     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5923         struct alc_spec *spec = codec->spec;
5924         /* Disable AA-loopback as it causes white noise */
5925         spec->gen.mixer_nid = 0;
5926     }
5927 }
5928
5929 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
5930 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
5931                   const struct hda_fixup *fix, int action)
5932 {
5933     static const struct hda_pintbl pincfgs[] = {
5934         { 0x16, 0x21211010 }, /* dock headphone */
5935         { 0x19, 0x21a11010 }, /* dock mic */
5936         { }
5937     };
5938     struct alc_spec *spec = codec->spec;
5939
5940     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5941         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5942         codec->power_save_node = 0; /* avoid click noises */
5943         snd_hda_apply_pincfgs(codec, pincfgs);
5944     }
5945 }
5946
5947 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
5948                   const struct hda_fixup *fix, int action)
5949 {
5950     static const struct hda_pintbl pincfgs[] = {
5951         { 0x17, 0x21211010 }, /* dock headphone */
5952         { 0x19, 0x21a11010 }, /* dock mic */
5953         { }
5954     };
5955     struct alc_spec *spec = codec->spec;
5956
5957     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5958         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5959         snd_hda_apply_pincfgs(codec, pincfgs);
5960     } else if (action == HDA_FIXUP_ACT_INIT) {
5961         /* Enable DOCK device */
5962         snd_hda_codec_write(codec, 0x17, 0,
5963                 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5964         /* Enable DOCK device */
5965         snd_hda_codec_write(codec, 0x19, 0,
5966                 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
5967     }
5968 }
5969
5970 static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
5971                   const struct hda_fixup *fix, int action)
5972 {
5973     /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
5974      * the speaker output becomes too low by some reason on Thinkpads with
5975      * ALC298 codec
5976      */
5977     static const hda_nid_t preferred_pairs[] = {
5978         0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
5979         0
5980     };
5981     struct alc_spec *spec = codec->spec;
5982
5983     if (action == HDA_FIXUP_ACT_PRE_PROBE)
5984         spec->gen.preferred_dacs = preferred_pairs;
5985 }
5986
5987 static void alc295_fixup_asus_dacs(struct hda_codec *codec,
5988                    const struct hda_fixup *fix, int action)
5989 {
5990     static const hda_nid_t preferred_pairs[] = {
5991         0x17, 0x02, 0x21, 0x03, 0
5992     };
5993     struct alc_spec *spec = codec->spec;
5994
5995     if (action == HDA_FIXUP_ACT_PRE_PROBE)
5996         spec->gen.preferred_dacs = preferred_pairs;
5997 }
5998
5999 static void alc_shutup_dell_xps13(struct hda_codec *codec)
6000 {
6001     struct alc_spec *spec = codec->spec;
6002     int hp_pin = alc_get_hp_pin(spec);
6003
6004     /* Prevent pop noises when headphones are plugged in */
6005     snd_hda_codec_write(codec, hp_pin, 0,
6006                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
6007     msleep(20);
6008 }
6009
6010 static void alc_fixup_dell_xps13(struct hda_codec *codec,
6011                 const struct hda_fixup *fix, int action)
6012 {
6013     struct alc_spec *spec = codec->spec;
6014     struct hda_input_mux *imux = &spec->gen.input_mux;
6015     int i;
6016
6017     switch (action) {
6018     case HDA_FIXUP_ACT_PRE_PROBE:
6019         /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
6020          * it causes a click noise at start up
6021          */
6022         snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6023         spec->shutup = alc_shutup_dell_xps13;
6024         break;
6025     case HDA_FIXUP_ACT_PROBE:
6026         /* Make the internal mic the default input source. */
6027         for (i = 0; i < imux->num_items; i++) {
6028             if (spec->gen.imux_pins[i] == 0x12) {
6029                 spec->gen.cur_mux[0] = i;
6030                 break;
6031             }
6032         }
6033         break;
6034     }
6035 }
6036
6037 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
6038                 const struct hda_fixup *fix, int action)
6039 {
6040     struct alc_spec *spec = codec->spec;
6041
6042     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6043         spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6044         spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
6045
6046         /* Disable boost for mic-in permanently. (This code is only called
6047            from quirks that guarantee that the headphone is at NID 0x1b.) */
6048         snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
6049         snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
6050     } else
6051         alc_fixup_headset_mode(codec, fix, action);
6052 }
6053
6054 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
6055                 const struct hda_fixup *fix, int action)
6056 {
6057     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6058         alc_write_coef_idx(codec, 0xc4, 0x8000);
6059         alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
6060         snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
6061     }
6062     alc_fixup_headset_mode(codec, fix, action);
6063 }
6064
6065 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
6066 static int find_ext_mic_pin(struct hda_codec *codec)
6067 {
6068     struct alc_spec *spec = codec->spec;
6069     struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6070     hda_nid_t nid;
6071     unsigned int defcfg;
6072     int i;
6073
6074     for (i = 0; i < cfg->num_inputs; i++) {
6075         if (cfg->inputs[i].type != AUTO_PIN_MIC)
6076             continue;
6077         nid = cfg->inputs[i].pin;
6078         defcfg = snd_hda_codec_get_pincfg(codec, nid);
6079         if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
6080             continue;
6081         return nid;
6082     }
6083
6084     return 0;
6085 }
6086
6087 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
6088                     const struct hda_fixup *fix,
6089                     int action)
6090 {
6091     struct alc_spec *spec = codec->spec;
6092
6093     if (action == HDA_FIXUP_ACT_PROBE) {
6094         int mic_pin = find_ext_mic_pin(codec);
6095         int hp_pin = alc_get_hp_pin(spec);
6096
6097         if (snd_BUG_ON(!mic_pin || !hp_pin))
6098             return;
6099         snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
6100     }
6101 }
6102
6103 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
6104                          const struct hda_fixup *fix,
6105                          int action)
6106 {
6107     struct alc_spec *spec = codec->spec;
6108     struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6109     int i;
6110
6111     /* The mic boosts on level 2 and 3 are too noisy
6112        on the internal mic input.
6113        Therefore limit the boost to 0 or 1. */
6114
6115     if (action != HDA_FIXUP_ACT_PROBE)
6116         return;
6117
6118     for (i = 0; i < cfg->num_inputs; i++) {
6119         hda_nid_t nid = cfg->inputs[i].pin;
6120         unsigned int defcfg;
6121         if (cfg->inputs[i].type != AUTO_PIN_MIC)
6122             continue;
6123         defcfg = snd_hda_codec_get_pincfg(codec, nid);
6124         if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
6125             continue;
6126
6127         snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
6128                       (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
6129                       (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6130                       (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
6131                       (0 << AC_AMPCAP_MUTE_SHIFT));
6132     }
6133 }
6134
6135 static void alc283_hp_automute_hook(struct hda_codec *codec,
6136                     struct hda_jack_callback *jack)
6137 {
6138     struct alc_spec *spec = codec->spec;
6139     int vref;
6140
6141     msleep(200);
6142     snd_hda_gen_hp_automute(codec, jack);
6143
6144     vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
6145
6146     msleep(600);
6147     snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6148                 vref);
6149 }
6150
6151 static void alc283_fixup_chromebook(struct hda_codec *codec,
6152                     const struct hda_fixup *fix, int action)
6153 {
6154     struct alc_spec *spec = codec->spec;
6155
6156     switch (action) {
6157     case HDA_FIXUP_ACT_PRE_PROBE:
6158         snd_hda_override_wcaps(codec, 0x03, 0);
6159         /* Disable AA-loopback as it causes white noise */
6160         spec->gen.mixer_nid = 0;
6161         break;
6162     case HDA_FIXUP_ACT_INIT:
6163         /* MIC2-VREF control */
6164         /* Set to manual mode */
6165         alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6166         /* Enable Line1 input control by verb */
6167         alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
6168         break;
6169     }
6170 }
6171
6172 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
6173                     const struct hda_fixup *fix, int action)
6174 {
6175     struct alc_spec *spec = codec->spec;
6176
6177     switch (action) {
6178     case HDA_FIXUP_ACT_PRE_PROBE:
6179         spec->gen.hp_automute_hook = alc283_hp_automute_hook;
6180         break;
6181     case HDA_FIXUP_ACT_INIT:
6182         /* MIC2-VREF control */
6183         /* Set to manual mode */
6184         alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6185         break;
6186     }
6187 }
6188
6189 /* mute tablet speaker pin (0x14) via dock plugging in addition */
6190 static void asus_tx300_automute(struct hda_codec *codec)
6191 {
6192     struct alc_spec *spec = codec->spec;
6193     snd_hda_gen_update_outputs(codec);
6194     if (snd_hda_jack_detect(codec, 0x1b))
6195         spec->gen.mute_bits |= (1ULL << 0x14);
6196 }
6197
6198 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
6199                     const struct hda_fixup *fix, int action)
6200 {
6201     struct alc_spec *spec = codec->spec;
6202     static const struct hda_pintbl dock_pins[] = {
6203         { 0x1b, 0x21114000 }, /* dock speaker pin */
6204         {}
6205     };
6206
6207     switch (action) {
6208     case HDA_FIXUP_ACT_PRE_PROBE:
6209         spec->init_amp = ALC_INIT_DEFAULT;
6210         /* TX300 needs to set up GPIO2 for the speaker amp */
6211         alc_setup_gpio(codec, 0x04);
6212         snd_hda_apply_pincfgs(codec, dock_pins);
6213         spec->gen.auto_mute_via_amp = 1;
6214         spec->gen.automute_hook = asus_tx300_automute;
6215         snd_hda_jack_detect_enable_callback(codec, 0x1b,
6216                             snd_hda_gen_hp_automute);
6217         break;
6218     case HDA_FIXUP_ACT_PROBE:
6219         spec->init_amp = ALC_INIT_DEFAULT;
6220         break;
6221     case HDA_FIXUP_ACT_BUILD:
6222         /* this is a bit tricky; give more sane names for the main
6223          * (tablet) speaker and the dock speaker, respectively
6224          */
6225         rename_ctl(codec, "Speaker Playback Switch",
6226                "Dock Speaker Playback Switch");
6227         rename_ctl(codec, "Bass Speaker Playback Switch",
6228                "Speaker Playback Switch");
6229         break;
6230     }
6231 }
6232
6233 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
6234                        const struct hda_fixup *fix, int action)
6235 {
6236     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6237         /* DAC node 0x03 is giving mono output. We therefore want to
6238            make sure 0x14 (front speaker) and 0x15 (headphones) use the
6239            stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
6240         static const hda_nid_t conn1[] = { 0x0c };
6241         snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
6242         snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
6243     }
6244 }
6245
6246 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
6247                     const struct hda_fixup *fix, int action)
6248 {
6249     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6250         /* The speaker is routed to the Node 0x06 by a mistake, as a result
6251            we can't adjust the speaker's volume since this node does not has
6252            Amp-out capability. we change the speaker's route to:
6253            Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
6254            Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
6255            speaker's volume now. */
6256
6257         static const hda_nid_t conn1[] = { 0x0c };
6258         snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
6259     }
6260 }
6261
6262 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
6263 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
6264                       const struct hda_fixup *fix, int action)
6265 {
6266     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6267         static const hda_nid_t conn[] = { 0x02, 0x03 };
6268         snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6269     }
6270 }
6271
6272 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
6273 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
6274                       const struct hda_fixup *fix, int action)
6275 {
6276     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6277         static const hda_nid_t conn[] = { 0x02 };
6278         snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6279     }
6280 }
6281
6282 /* Hook to update amp GPIO4 for automute */
6283 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
6284                       struct hda_jack_callback *jack)
6285 {
6286     struct alc_spec *spec = codec->spec;
6287
6288     snd_hda_gen_hp_automute(codec, jack);
6289     /* mute_led_polarity is set to 0, so we pass inverted value here */
6290     alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
6291                 !spec->gen.hp_jack_present);
6292 }
6293
6294 /* Manage GPIOs for HP EliteBook Folio 9480m.
6295  *
6296  * GPIO4 is the headphone amplifier power control
6297  * GPIO3 is the audio output mute indicator LED
6298  */
6299
6300 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
6301                   const struct hda_fixup *fix,
6302                   int action)
6303 {
6304     struct alc_spec *spec = codec->spec;
6305
6306     alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
6307     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6308         /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
6309         spec->gpio_mask |= 0x10;
6310         spec->gpio_dir |= 0x10;
6311         spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
6312     }
6313 }
6314
6315 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
6316                    const struct hda_fixup *fix,
6317                    int action)
6318 {
6319     struct alc_spec *spec = codec->spec;
6320
6321     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6322         spec->gpio_mask |= 0x04;
6323         spec->gpio_dir |= 0x04;
6324         /* set data bit low */
6325     }
6326 }
6327
6328 /* Quirk for Thinkpad X1 7th and 8th Gen
6329  * The following fixed routing needed
6330  * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly
6331  * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC
6332  * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp
6333  */
6334 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
6335                       const struct hda_fixup *fix, int action)
6336 {
6337     static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
6338     static const hda_nid_t preferred_pairs[] = {
6339         0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
6340     };
6341     struct alc_spec *spec = codec->spec;
6342
6343     switch (action) {
6344     case HDA_FIXUP_ACT_PRE_PROBE:
6345         snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6346         spec->gen.preferred_dacs = preferred_pairs;
6347         break;
6348     case HDA_FIXUP_ACT_BUILD:
6349         /* The generic parser creates somewhat unintuitive volume ctls
6350          * with the fixed routing above, and the shared DAC2 may be
6351          * confusing for PA.
6352          * Rename those to unique names so that PA doesn't touch them
6353          * and use only Master volume.
6354          */
6355         rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
6356         rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
6357         break;
6358     }
6359 }
6360
6361 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
6362                      const struct hda_fixup *fix,
6363                      int action)
6364 {
6365     alc_fixup_dual_codecs(codec, fix, action);
6366     switch (action) {
6367     case HDA_FIXUP_ACT_PRE_PROBE:
6368         /* override card longname to provide a unique UCM profile */
6369         strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
6370         break;
6371     case HDA_FIXUP_ACT_BUILD:
6372         /* rename Capture controls depending on the codec */
6373         rename_ctl(codec, "Capture Volume",
6374                codec->addr == 0 ?
6375                "Rear-Panel Capture Volume" :
6376                "Front-Panel Capture Volume");
6377         rename_ctl(codec, "Capture Switch",
6378                codec->addr == 0 ?
6379                "Rear-Panel Capture Switch" :
6380                "Front-Panel Capture Switch");
6381         break;
6382     }
6383 }
6384
6385 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
6386                       const struct hda_fixup *fix, int action)
6387 {
6388     if (action != HDA_FIXUP_ACT_PRE_PROBE)
6389         return;
6390
6391     codec->power_save_node = 1;
6392 }
6393
6394 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
6395 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
6396                     const struct hda_fixup *fix, int action)
6397 {
6398     struct alc_spec *spec = codec->spec;
6399     static const hda_nid_t preferred_pairs[] = {
6400         0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
6401         0
6402     };
6403
6404     if (action != HDA_FIXUP_ACT_PRE_PROBE)
6405         return;
6406
6407     spec->gen.preferred_dacs = preferred_pairs;
6408     spec->gen.auto_mute_via_amp = 1;
6409     codec->power_save_node = 0;
6410 }
6411
6412 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */
6413 static void alc289_fixup_asus_ga401(struct hda_codec *codec,
6414                     const struct hda_fixup *fix, int action)
6415 {
6416     static const hda_nid_t preferred_pairs[] = {
6417         0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0
6418     };
6419     struct alc_spec *spec = codec->spec;
6420
6421     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6422         spec->gen.preferred_dacs = preferred_pairs;
6423         spec->gen.obey_preferred_dacs = 1;
6424     }
6425 }
6426
6427 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
6428 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
6429                   const struct hda_fixup *fix, int action)
6430 {
6431     if (action != HDA_FIXUP_ACT_PRE_PROBE)
6432         return;
6433
6434     snd_hda_override_wcaps(codec, 0x03, 0);
6435 }
6436
6437 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec)
6438 {
6439     switch (codec->core.vendor_id) {
6440     case 0x10ec0274:
6441     case 0x10ec0294:
6442     case 0x10ec0225:
6443     case 0x10ec0295:
6444     case 0x10ec0299:
6445         alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
6446         alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
6447         break;
6448     case 0x10ec0230:
6449     case 0x10ec0235:
6450     case 0x10ec0236:
6451     case 0x10ec0255:
6452     case 0x10ec0256:
6453     case 0x19e58326:
6454         alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
6455         alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
6456         break;
6457     }
6458 }
6459
6460 static void alc295_fixup_chromebook(struct hda_codec *codec,
6461                     const struct hda_fixup *fix, int action)
6462 {
6463     struct alc_spec *spec = codec->spec;
6464
6465     switch (action) {
6466     case HDA_FIXUP_ACT_PRE_PROBE:
6467         spec->ultra_low_power = true;
6468         break;
6469     case HDA_FIXUP_ACT_INIT:
6470         alc_combo_jack_hp_jd_restart(codec);
6471         break;
6472     }
6473 }
6474
6475 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
6476                   const struct hda_fixup *fix, int action)
6477 {
6478     if (action == HDA_FIXUP_ACT_PRE_PROBE)
6479         snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6480 }
6481
6482
6483 static void alc294_gx502_toggle_output(struct hda_codec *codec,
6484                     struct hda_jack_callback *cb)
6485 {
6486     /* The Windows driver sets the codec up in a very different way where
6487      * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it
6488      */
6489     if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6490         alc_write_coef_idx(codec, 0x10, 0x8a20);
6491     else
6492         alc_write_coef_idx(codec, 0x10, 0x0a20);
6493 }
6494
6495 static void alc294_fixup_gx502_hp(struct hda_codec *codec,
6496                     const struct hda_fixup *fix, int action)
6497 {
6498     /* Pin 0x21: headphones/headset mic */
6499     if (!is_jack_detectable(codec, 0x21))
6500         return;
6501
6502     switch (action) {
6503     case HDA_FIXUP_ACT_PRE_PROBE:
6504         snd_hda_jack_detect_enable_callback(codec, 0x21,
6505                 alc294_gx502_toggle_output);
6506         break;
6507     case HDA_FIXUP_ACT_INIT:
6508         /* Make sure to start in a correct state, i.e. if
6509          * headphones have been plugged in before powering up the system
6510          */
6511         alc294_gx502_toggle_output(codec, NULL);
6512         break;
6513     }
6514 }
6515
6516 static void alc294_gu502_toggle_output(struct hda_codec *codec,
6517                        struct hda_jack_callback *cb)
6518 {
6519     /* Windows sets 0x10 to 0x8420 for Node 0x20 which is
6520      * responsible from changes between speakers and headphones
6521      */
6522     if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6523         alc_write_coef_idx(codec, 0x10, 0x8420);
6524     else
6525         alc_write_coef_idx(codec, 0x10, 0x0a20);
6526 }
6527
6528 static void alc294_fixup_gu502_hp(struct hda_codec *codec,
6529                   const struct hda_fixup *fix, int action)
6530 {
6531     if (!is_jack_detectable(codec, 0x21))
6532         return;
6533
6534     switch (action) {
6535     case HDA_FIXUP_ACT_PRE_PROBE:
6536         snd_hda_jack_detect_enable_callback(codec, 0x21,
6537                 alc294_gu502_toggle_output);
6538         break;
6539     case HDA_FIXUP_ACT_INIT:
6540         alc294_gu502_toggle_output(codec, NULL);
6541         break;
6542     }
6543 }
6544
6545 static void  alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec,
6546                   const struct hda_fixup *fix, int action)
6547 {
6548     if (action != HDA_FIXUP_ACT_INIT)
6549         return;
6550
6551     msleep(100);
6552     alc_write_coef_idx(codec, 0x65, 0x0);
6553 }
6554
6555 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec,
6556                     const struct hda_fixup *fix, int action)
6557 {
6558     switch (action) {
6559     case HDA_FIXUP_ACT_INIT:
6560         alc_combo_jack_hp_jd_restart(codec);
6561         break;
6562     }
6563 }
6564
6565 static void alc_fixup_no_int_mic(struct hda_codec *codec,
6566                     const struct hda_fixup *fix, int action)
6567 {
6568     struct alc_spec *spec = codec->spec;
6569
6570     switch (action) {
6571     case HDA_FIXUP_ACT_PRE_PROBE:
6572         /* Mic RING SLEEVE swap for combo jack */
6573         alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
6574         spec->no_internal_mic_pin = true;
6575         break;
6576     case HDA_FIXUP_ACT_INIT:
6577         alc_combo_jack_hp_jd_restart(codec);
6578         break;
6579     }
6580 }
6581
6582 /* GPIO1 = amplifier on/off
6583  * GPIO3 = mic mute LED
6584  */
6585 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
6586                       const struct hda_fixup *fix, int action)
6587 {
6588     static const hda_nid_t conn[] = { 0x02 };
6589
6590     struct alc_spec *spec = codec->spec;
6591     static const struct hda_pintbl pincfgs[] = {
6592         { 0x14, 0x90170110 },  /* front/high speakers */
6593         { 0x17, 0x90170130 },  /* back/bass speakers */
6594         { }
6595     };
6596
6597     //enable micmute led
6598     alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
6599
6600     switch (action) {
6601     case HDA_FIXUP_ACT_PRE_PROBE:
6602         spec->micmute_led_polarity = 1;
6603         /* needed for amp of back speakers */
6604         spec->gpio_mask |= 0x01;
6605         spec->gpio_dir |= 0x01;
6606         snd_hda_apply_pincfgs(codec, pincfgs);
6607         /* share DAC to have unified volume control */
6608         snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
6609         snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6610         break;
6611     case HDA_FIXUP_ACT_INIT:
6612         /* need to toggle GPIO to enable the amp of back speakers */
6613         alc_update_gpio_data(codec, 0x01, true);
6614         msleep(100);
6615         alc_update_gpio_data(codec, 0x01, false);
6616         break;
6617     }
6618 }
6619
6620 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
6621                       const struct hda_fixup *fix, int action)
6622 {
6623     static const hda_nid_t conn[] = { 0x02 };
6624     static const struct hda_pintbl pincfgs[] = {
6625         { 0x14, 0x90170110 },  /* rear speaker */
6626         { }
6627     };
6628
6629     switch (action) {
6630     case HDA_FIXUP_ACT_PRE_PROBE:
6631         snd_hda_apply_pincfgs(codec, pincfgs);
6632         /* force front speaker to DAC1 */
6633         snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6634         break;
6635     }
6636 }
6637
6638 /* for hda_fixup_thinkpad_acpi() */
6639 #include "thinkpad_helper.c"
6640
6641 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
6642                     const struct hda_fixup *fix, int action)
6643 {
6644     alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
6645     hda_fixup_thinkpad_acpi(codec, fix, action);
6646 }
6647
6648 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
6649 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
6650                           const struct hda_fixup *fix,
6651                           int action)
6652 {
6653     struct alc_spec *spec = codec->spec;
6654
6655     switch (action) {
6656     case HDA_FIXUP_ACT_PRE_PROBE:
6657         spec->gen.suppress_auto_mute = 1;
6658         break;
6659     }
6660 }
6661
6662 static int comp_bind(struct device *dev)
6663 {
6664     struct hda_codec *cdc = dev_to_hda_codec(dev);
6665     struct alc_spec *spec = cdc->spec;
6666     int ret, i;
6667
6668     ret = component_bind_all(dev, spec->comps);
6669     if (ret)
6670         return ret;
6671
6672     if (snd_hdac_is_power_on(&cdc->core)) {
6673         codec_dbg(cdc, "Resuming after bind.\n");
6674         for (i = 0; i < HDA_MAX_COMPONENTS; i++)
6675             if (spec->comps[i].resume_hook)
6676                 spec->comps[i].resume_hook(spec->comps[i].dev);
6677     }
6678
6679     return 0;
6680 }
6681
6682 static void comp_unbind(struct device *dev)
6683 {
6684     struct hda_codec *cdc = dev_to_hda_codec(dev);
6685     struct alc_spec *spec = cdc->spec;
6686
6687     component_unbind_all(dev, spec->comps);
6688 }
6689
6690 static const struct component_master_ops comp_master_ops = {
6691     .bind = comp_bind,
6692     .unbind = comp_unbind,
6693 };
6694
6695 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc,
6696                        struct snd_pcm_substream *sub, int action)
6697 {
6698     struct alc_spec *spec = cdc->spec;
6699     int i;
6700
6701     for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
6702         if (spec->comps[i].dev)
6703             spec->comps[i].playback_hook(spec->comps[i].dev, action);
6704     }
6705 }
6706
6707 static void cs35l41_generic_fixup(struct hda_codec *cdc, int action, const char *bus,
6708                   const char *hid, int count)
6709 {
6710     struct device *dev = hda_codec_dev(cdc);
6711     struct alc_spec *spec = cdc->spec;
6712     char *name;
6713     int ret, i;
6714
6715     switch (action) {
6716     case HDA_FIXUP_ACT_PRE_PROBE:
6717         for (i = 0; i < count; i++) {
6718             name = devm_kasprintf(dev, GFP_KERNEL,
6719                           "%s-%s:00-cs35l41-hda.%d", bus, hid, i);
6720             if (!name)
6721                 return;
6722             spec->comps[i].codec = cdc;
6723             component_match_add(dev, &spec->match, component_compare_dev_name, name);
6724         }
6725         ret = component_master_add_with_match(dev, &comp_master_ops, spec->match);
6726         if (ret)
6727             codec_err(cdc, "Fail to register component aggregator %d\n", ret);
6728         else
6729             spec->gen.pcm_playback_hook = comp_generic_playback_hook;
6730         break;
6731     }
6732 }
6733
6734 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6735 {
6736     cs35l41_generic_fixup(cdc, action, "i2c", "CSC3551", 2);
6737 }
6738
6739 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6740 {
6741     cs35l41_generic_fixup(codec, action, "spi0", "CSC3551", 2);
6742 }
6743
6744 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6745 {
6746     cs35l41_generic_fixup(codec, action, "spi0", "CSC3551", 4);
6747 }
6748
6749 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6750                          int action)
6751 {
6752     cs35l41_generic_fixup(cdc, action, "i2c", "CLSA0100", 2);
6753 }
6754
6755 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6756                          int action)
6757 {
6758     cs35l41_generic_fixup(cdc, action, "i2c", "CLSA0101", 2);
6759 }
6760
6761 /* for alc295_fixup_hp_top_speakers */
6762 #include "hp_x360_helper.c"
6763
6764 /* for alc285_fixup_ideapad_s740_coef() */
6765 #include "ideapad_s740_helper.c"
6766
6767 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
6768     WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
6769     WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
6770     WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
6771     {}
6772 };
6773
6774 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
6775                        const struct hda_fixup *fix,
6776                        int action)
6777 {
6778     /*
6779      * A certain other OS sets these coeffs to different values. On at least
6780      * one TongFang barebone these settings might survive even a cold
6781      * reboot. So to restore a clean slate the values are explicitly reset
6782      * to default here. Without this, the external microphone is always in a
6783      * plugged-in state, while the internal microphone is always in an
6784      * unplugged state, breaking the ability to use the internal microphone.
6785      */
6786     alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
6787 }
6788
6789 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
6790     WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06),
6791     WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074),
6792     WRITE_COEF(0x49, 0x0149),
6793     {}
6794 };
6795
6796 static void alc233_fixup_no_audio_jack(struct hda_codec *codec,
6797                        const struct hda_fixup *fix,
6798                        int action)
6799 {
6800     /*
6801      * The audio jack input and output is not detected on the ASRock NUC Box
6802      * 1100 series when cold booting without this fix. Warm rebooting from a
6803      * certain other OS makes the audio functional, as COEF settings are
6804      * preserved in this case. This fix sets these altered COEF values as
6805      * the default.
6806      */
6807     alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs);
6808 }
6809
6810 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec,
6811                             const struct hda_fixup *fix,
6812                             int action)
6813 {
6814     /*
6815      * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec,
6816      * but uses the 0x8686 subproduct id in both cases. The ALC256 codec
6817      * needs an additional quirk for sound working after suspend and resume.
6818      */
6819     if (codec->core.vendor_id == 0x10ec0256) {
6820         alc_update_coef_idx(codec, 0x10, 1<<9, 0);
6821         snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120);
6822     } else {
6823         snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c);
6824     }
6825 }
6826
6827 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec,
6828                           const struct hda_fixup *fix,
6829                           int action)
6830 {
6831     struct alc_spec *spec = codec->spec;
6832     struct hda_input_mux *imux = &spec->gen.input_mux;
6833     int i;
6834
6835     alc269_fixup_limit_int_mic_boost(codec, fix, action);
6836
6837     switch (action) {
6838     case HDA_FIXUP_ACT_PRE_PROBE:
6839         /**
6840          * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic)
6841          * to Hi-Z to avoid pop noises at startup and when plugging and
6842          * unplugging headphones.
6843          */
6844         snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6845         snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ);
6846         break;
6847     case HDA_FIXUP_ACT_PROBE:
6848         /**
6849          * Make the internal mic (0x12) the default input source to
6850          * prevent pop noises on cold boot.
6851          */
6852         for (i = 0; i < imux->num_items; i++) {
6853             if (spec->gen.imux_pins[i] == 0x12) {
6854                 spec->gen.cur_mux[0] = i;
6855                 break;
6856             }
6857         }
6858         break;
6859     }
6860 }
6861
6862 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec,
6863                       const struct hda_fixup *fix, int action)
6864 {
6865     /*
6866      * The Pin Complex 0x17 for the bass speakers is wrongly reported as
6867      * unconnected.
6868      */
6869     static const struct hda_pintbl pincfgs[] = {
6870         { 0x17, 0x90170121 },
6871         { }
6872     };
6873     /*
6874      * Avoid DAC 0x06 and 0x08, as they have no volume controls.
6875      * DAC 0x02 and 0x03 would be fine.
6876      */
6877     static const hda_nid_t conn[] = { 0x02, 0x03 };
6878     /*
6879      * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02.
6880      * Headphones (0x21) are connected to DAC 0x03.
6881      */
6882     static const hda_nid_t preferred_pairs[] = {
6883         0x14, 0x02,
6884         0x17, 0x02,
6885         0x21, 0x03,
6886         0
6887     };
6888     struct alc_spec *spec = codec->spec;
6889
6890     switch (action) {
6891     case HDA_FIXUP_ACT_PRE_PROBE:
6892         snd_hda_apply_pincfgs(codec, pincfgs);
6893         snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6894         spec->gen.preferred_dacs = preferred_pairs;
6895         break;
6896     }
6897 }
6898
6899 enum {
6900     ALC269_FIXUP_GPIO2,
6901     ALC269_FIXUP_SONY_VAIO,
6902     ALC275_FIXUP_SONY_VAIO_GPIO2,
6903     ALC269_FIXUP_DELL_M101Z,
6904     ALC269_FIXUP_SKU_IGNORE,
6905     ALC269_FIXUP_ASUS_G73JW,
6906     ALC269_FIXUP_LENOVO_EAPD,
6907     ALC275_FIXUP_SONY_HWEQ,
6908     ALC275_FIXUP_SONY_DISABLE_AAMIX,
6909     ALC271_FIXUP_DMIC,
6910     ALC269_FIXUP_PCM_44K,
6911     ALC269_FIXUP_STEREO_DMIC,
6912     ALC269_FIXUP_HEADSET_MIC,
6913     ALC269_FIXUP_QUANTA_MUTE,
6914     ALC269_FIXUP_LIFEBOOK,
6915     ALC269_FIXUP_LIFEBOOK_EXTMIC,
6916     ALC269_FIXUP_LIFEBOOK_HP_PIN,
6917     ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
6918     ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
6919     ALC269_FIXUP_AMIC,
6920     ALC269_FIXUP_DMIC,
6921     ALC269VB_FIXUP_AMIC,
6922     ALC269VB_FIXUP_DMIC,
6923     ALC269_FIXUP_HP_MUTE_LED,
6924     ALC269_FIXUP_HP_MUTE_LED_MIC1,
6925     ALC269_FIXUP_HP_MUTE_LED_MIC2,
6926     ALC269_FIXUP_HP_MUTE_LED_MIC3,
6927     ALC269_FIXUP_HP_GPIO_LED,
6928     ALC269_FIXUP_HP_GPIO_MIC1_LED,
6929     ALC269_FIXUP_HP_LINE1_MIC1_LED,
6930     ALC269_FIXUP_INV_DMIC,
6931     ALC269_FIXUP_LENOVO_DOCK,
6932     ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
6933     ALC269_FIXUP_NO_SHUTUP,
6934     ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
6935     ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
6936     ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
6937     ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
6938     ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
6939     ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
6940     ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
6941     ALC269_FIXUP_HEADSET_MODE,
6942     ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
6943     ALC269_FIXUP_ASPIRE_HEADSET_MIC,
6944     ALC269_FIXUP_ASUS_X101_FUNC,
6945     ALC269_FIXUP_ASUS_X101_VERB,
6946     ALC269_FIXUP_ASUS_X101,
6947     ALC271_FIXUP_AMIC_MIC2,
6948     ALC271_FIXUP_HP_GATE_MIC_JACK,
6949     ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
6950     ALC269_FIXUP_ACER_AC700,
6951     ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
6952     ALC269VB_FIXUP_ASUS_ZENBOOK,
6953     ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
6954     ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE,
6955     ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
6956     ALC269VB_FIXUP_ORDISSIMO_EVE2,
6957     ALC283_FIXUP_CHROME_BOOK,
6958     ALC283_FIXUP_SENSE_COMBO_JACK,
6959     ALC282_FIXUP_ASUS_TX300,
6960     ALC283_FIXUP_INT_MIC,
6961     ALC290_FIXUP_MONO_SPEAKERS,
6962     ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
6963     ALC290_FIXUP_SUBWOOFER,
6964     ALC290_FIXUP_SUBWOOFER_HSJACK,
6965     ALC269_FIXUP_THINKPAD_ACPI,
6966     ALC269_FIXUP_DMIC_THINKPAD_ACPI,
6967     ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
6968     ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
6969     ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
6970     ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
6971     ALC255_FIXUP_HEADSET_MODE,
6972     ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
6973     ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
6974     ALC292_FIXUP_TPT440_DOCK,
6975     ALC292_FIXUP_TPT440,
6976     ALC283_FIXUP_HEADSET_MIC,
6977     ALC255_FIXUP_MIC_MUTE_LED,
6978     ALC282_FIXUP_ASPIRE_V5_PINS,
6979     ALC269VB_FIXUP_ASPIRE_E1_COEF,
6980     ALC280_FIXUP_HP_GPIO4,
6981     ALC286_FIXUP_HP_GPIO_LED,
6982     ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
6983     ALC280_FIXUP_HP_DOCK_PINS,
6984     ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
6985     ALC280_FIXUP_HP_9480M,
6986     ALC245_FIXUP_HP_X360_AMP,
6987     ALC285_FIXUP_HP_SPECTRE_X360_EB1,
6988     ALC288_FIXUP_DELL_HEADSET_MODE,
6989     ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
6990     ALC288_FIXUP_DELL_XPS_13,
6991     ALC288_FIXUP_DISABLE_AAMIX,
6992     ALC292_FIXUP_DELL_E7X_AAMIX,
6993     ALC292_FIXUP_DELL_E7X,
6994     ALC292_FIXUP_DISABLE_AAMIX,
6995     ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
6996     ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
6997     ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
6998     ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
6999     ALC275_FIXUP_DELL_XPS,
7000     ALC293_FIXUP_LENOVO_SPK_NOISE,
7001     ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7002     ALC255_FIXUP_DELL_SPK_NOISE,
7003     ALC225_FIXUP_DISABLE_MIC_VREF,
7004     ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7005     ALC295_FIXUP_DISABLE_DAC3,
7006     ALC285_FIXUP_SPEAKER2_TO_DAC1,
7007     ALC280_FIXUP_HP_HEADSET_MIC,
7008     ALC221_FIXUP_HP_FRONT_MIC,
7009     ALC292_FIXUP_TPT460,
7010     ALC298_FIXUP_SPK_VOLUME,
7011     ALC298_FIXUP_LENOVO_SPK_VOLUME,
7012     ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
7013     ALC269_FIXUP_ATIV_BOOK_8,
7014     ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
7015     ALC221_FIXUP_HP_MIC_NO_PRESENCE,
7016     ALC256_FIXUP_ASUS_HEADSET_MODE,
7017     ALC256_FIXUP_ASUS_MIC,
7018     ALC256_FIXUP_ASUS_AIO_GPIO2,
7019     ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
7020     ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
7021     ALC233_FIXUP_LENOVO_MULTI_CODECS,
7022     ALC233_FIXUP_ACER_HEADSET_MIC,
7023     ALC294_FIXUP_LENOVO_MIC_LOCATION,
7024     ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
7025     ALC225_FIXUP_S3_POP_NOISE,
7026     ALC700_FIXUP_INTEL_REFERENCE,
7027     ALC274_FIXUP_DELL_BIND_DACS,
7028     ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7029     ALC298_FIXUP_TPT470_DOCK_FIX,
7030     ALC298_FIXUP_TPT470_DOCK,
7031     ALC255_FIXUP_DUMMY_LINEOUT_VERB,
7032     ALC255_FIXUP_DELL_HEADSET_MIC,
7033     ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
7034     ALC298_FIXUP_HUAWEI_MBX_STEREO,
7035     ALC295_FIXUP_HP_X360,
7036     ALC221_FIXUP_HP_HEADSET_MIC,
7037     ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
7038     ALC295_FIXUP_HP_AUTO_MUTE,
7039     ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7040     ALC294_FIXUP_ASUS_MIC,
7041     ALC294_FIXUP_ASUS_HEADSET_MIC,
7042     ALC294_FIXUP_ASUS_SPK,
7043     ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7044     ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
7045     ALC255_FIXUP_ACER_HEADSET_MIC,
7046     ALC295_FIXUP_CHROME_BOOK,
7047     ALC225_FIXUP_HEADSET_JACK,
7048     ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
7049     ALC225_FIXUP_WYSE_AUTO_MUTE,
7050     ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
7051     ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
7052     ALC256_FIXUP_ASUS_HEADSET_MIC,
7053     ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7054     ALC299_FIXUP_PREDATOR_SPK,
7055     ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
7056     ALC289_FIXUP_DELL_SPK2,
7057     ALC289_FIXUP_DUAL_SPK,
7058     ALC294_FIXUP_SPK2_TO_DAC1,
7059     ALC294_FIXUP_ASUS_DUAL_SPK,
7060     ALC285_FIXUP_THINKPAD_X1_GEN7,
7061     ALC285_FIXUP_THINKPAD_HEADSET_JACK,
7062     ALC294_FIXUP_ASUS_HPE,
7063     ALC294_FIXUP_ASUS_COEF_1B,
7064     ALC294_FIXUP_ASUS_GX502_HP,
7065     ALC294_FIXUP_ASUS_GX502_PINS,
7066     ALC294_FIXUP_ASUS_GX502_VERBS,
7067     ALC294_FIXUP_ASUS_GU502_HP,
7068     ALC294_FIXUP_ASUS_GU502_PINS,
7069     ALC294_FIXUP_ASUS_GU502_VERBS,
7070     ALC294_FIXUP_ASUS_G513_PINS,
7071     ALC285_FIXUP_ASUS_G533Z_PINS,
7072     ALC285_FIXUP_HP_GPIO_LED,
7073     ALC285_FIXUP_HP_MUTE_LED,
7074     ALC236_FIXUP_HP_GPIO_LED,
7075     ALC236_FIXUP_HP_MUTE_LED,
7076     ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
7077     ALC298_FIXUP_SAMSUNG_AMP,
7078     ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7079     ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7080     ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
7081     ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
7082     ALC269VC_FIXUP_ACER_HEADSET_MIC,
7083     ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE,
7084     ALC289_FIXUP_ASUS_GA401,
7085     ALC289_FIXUP_ASUS_GA502,
7086     ALC256_FIXUP_ACER_MIC_NO_PRESENCE,
7087     ALC285_FIXUP_HP_GPIO_AMP_INIT,
7088     ALC269_FIXUP_CZC_B20,
7089     ALC269_FIXUP_CZC_TMI,
7090     ALC269_FIXUP_CZC_L101,
7091     ALC269_FIXUP_LEMOTE_A1802,
7092     ALC269_FIXUP_LEMOTE_A190X,
7093     ALC256_FIXUP_INTEL_NUC8_RUGGED,
7094     ALC233_FIXUP_INTEL_NUC8_DMIC,
7095     ALC233_FIXUP_INTEL_NUC8_BOOST,
7096     ALC256_FIXUP_INTEL_NUC10,
7097     ALC255_FIXUP_XIAOMI_HEADSET_MIC,
7098     ALC274_FIXUP_HP_MIC,
7099     ALC274_FIXUP_HP_HEADSET_MIC,
7100     ALC274_FIXUP_HP_ENVY_GPIO,
7101     ALC256_FIXUP_ASUS_HPE,
7102     ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
7103     ALC287_FIXUP_HP_GPIO_LED,
7104     ALC256_FIXUP_HP_HEADSET_MIC,
7105     ALC245_FIXUP_HP_GPIO_LED,
7106     ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
7107     ALC282_FIXUP_ACER_DISABLE_LINEOUT,
7108     ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST,
7109     ALC256_FIXUP_ACER_HEADSET_MIC,
7110     ALC285_FIXUP_IDEAPAD_S740_COEF,
7111     ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7112     ALC295_FIXUP_ASUS_DACS,
7113     ALC295_FIXUP_HP_OMEN,
7114     ALC285_FIXUP_HP_SPECTRE_X360,
7115     ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP,
7116     ALC623_FIXUP_LENOVO_THINKSTATION_P340,
7117     ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
7118     ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7119     ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
7120     ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
7121     ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
7122     ALC298_FIXUP_LENOVO_C940_DUET7,
7123     ALC287_FIXUP_13S_GEN2_SPEAKERS,
7124     ALC256_FIXUP_SET_COEF_DEFAULTS,
7125     ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7126     ALC233_FIXUP_NO_AUDIO_JACK,
7127     ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME,
7128     ALC285_FIXUP_LEGION_Y9000X_SPEAKERS,
7129     ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
7130     ALC287_FIXUP_LEGION_16ACHG6,
7131     ALC287_FIXUP_CS35L41_I2C_2,
7132     ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED,
7133     ALC245_FIXUP_CS35L41_SPI_2,
7134     ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED,
7135     ALC245_FIXUP_CS35L41_SPI_4,
7136     ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED,
7137     ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED,
7138     ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE,
7139     ALC287_FIXUP_LEGION_16ITHG6,
7140     ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
7141     ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN,
7142 };
7143
7144 /* A special fixup for Lenovo C940 and Yoga Duet 7;
7145  * both have the very same PCI SSID, and we need to apply different fixups
7146  * depending on the codec ID
7147  */
7148 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
7149                        const struct hda_fixup *fix,
7150                        int action)
7151 {
7152     int id;
7153
7154     if (codec->core.vendor_id == 0x10ec0298)
7155         id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
7156     else
7157         id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
7158     __snd_hda_apply_fixup(codec, id, action, 0);
7159 }
7160
7161 static const struct hda_fixup alc269_fixups[] = {
7162     [ALC269_FIXUP_GPIO2] = {
7163         .type = HDA_FIXUP_FUNC,
7164         .v.func = alc_fixup_gpio2,
7165     },
7166     [ALC269_FIXUP_SONY_VAIO] = {
7167         .type = HDA_FIXUP_PINCTLS,
7168         .v.pins = (const struct hda_pintbl[]) {
7169             {0x19, PIN_VREFGRD},
7170             {}
7171         }
7172     },
7173     [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
7174         .type = HDA_FIXUP_FUNC,
7175         .v.func = alc275_fixup_gpio4_off,
7176         .chained = true,
7177         .chain_id = ALC269_FIXUP_SONY_VAIO
7178     },
7179     [ALC269_FIXUP_DELL_M101Z] = {
7180         .type = HDA_FIXUP_VERBS,
7181         .v.verbs = (const struct hda_verb[]) {
7182             /* Enables internal speaker */
7183             {0x20, AC_VERB_SET_COEF_INDEX, 13},
7184             {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
7185             {}
7186         }
7187     },
7188     [ALC269_FIXUP_SKU_IGNORE] = {
7189         .type = HDA_FIXUP_FUNC,
7190         .v.func = alc_fixup_sku_ignore,
7191     },
7192     [ALC269_FIXUP_ASUS_G73JW] = {
7193         .type = HDA_FIXUP_PINS,
7194         .v.pins = (const struct hda_pintbl[]) {
7195             { 0x17, 0x99130111 }, /* subwoofer */
7196             { }
7197         }
7198     },
7199     [ALC269_FIXUP_LENOVO_EAPD] = {
7200         .type = HDA_FIXUP_VERBS,
7201         .v.verbs = (const struct hda_verb[]) {
7202             {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
7203             {}
7204         }
7205     },
7206     [ALC275_FIXUP_SONY_HWEQ] = {
7207         .type = HDA_FIXUP_FUNC,
7208         .v.func = alc269_fixup_hweq,
7209         .chained = true,
7210         .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
7211     },
7212     [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
7213         .type = HDA_FIXUP_FUNC,
7214         .v.func = alc_fixup_disable_aamix,
7215         .chained = true,
7216         .chain_id = ALC269_FIXUP_SONY_VAIO
7217     },
7218     [ALC271_FIXUP_DMIC] = {
7219         .type = HDA_FIXUP_FUNC,
7220         .v.func = alc271_fixup_dmic,
7221     },
7222     [ALC269_FIXUP_PCM_44K] = {
7223         .type = HDA_FIXUP_FUNC,
7224         .v.func = alc269_fixup_pcm_44k,
7225         .chained = true,
7226         .chain_id = ALC269_FIXUP_QUANTA_MUTE
7227     },
7228     [ALC269_FIXUP_STEREO_DMIC] = {
7229         .type = HDA_FIXUP_FUNC,
7230         .v.func = alc269_fixup_stereo_dmic,
7231     },
7232     [ALC269_FIXUP_HEADSET_MIC] = {
7233         .type = HDA_FIXUP_FUNC,
7234         .v.func = alc269_fixup_headset_mic,
7235     },
7236     [ALC269_FIXUP_QUANTA_MUTE] = {
7237         .type = HDA_FIXUP_FUNC,
7238         .v.func = alc269_fixup_quanta_mute,
7239     },
7240     [ALC269_FIXUP_LIFEBOOK] = {
7241         .type = HDA_FIXUP_PINS,
7242         .v.pins = (const struct hda_pintbl[]) {
7243             { 0x1a, 0x2101103f }, /* dock line-out */
7244             { 0x1b, 0x23a11040 }, /* dock mic-in */
7245             { }
7246         },
7247         .chained = true,
7248         .chain_id = ALC269_FIXUP_QUANTA_MUTE
7249     },
7250     [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
7251         .type = HDA_FIXUP_PINS,
7252         .v.pins = (const struct hda_pintbl[]) {
7253             { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
7254             { }
7255         },
7256     },
7257     [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
7258         .type = HDA_FIXUP_PINS,
7259         .v.pins = (const struct hda_pintbl[]) {
7260             { 0x21, 0x0221102f }, /* HP out */
7261             { }
7262         },
7263     },
7264     [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
7265         .type = HDA_FIXUP_FUNC,
7266         .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7267     },
7268     [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
7269         .type = HDA_FIXUP_FUNC,
7270         .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
7271     },
7272     [ALC269_FIXUP_AMIC] = {
7273         .type = HDA_FIXUP_PINS,
7274         .v.pins = (const struct hda_pintbl[]) {
7275             { 0x14, 0x99130110 }, /* speaker */
7276             { 0x15, 0x0121401f }, /* HP out */
7277             { 0x18, 0x01a19c20 }, /* mic */
7278             { 0x19, 0x99a3092f }, /* int-mic */
7279             { }
7280         },
7281     },
7282     [ALC269_FIXUP_DMIC] = {
7283         .type = HDA_FIXUP_PINS,
7284         .v.pins = (const struct hda_pintbl[]) {
7285             { 0x12, 0x99a3092f }, /* int-mic */
7286             { 0x14, 0x99130110 }, /* speaker */
7287             { 0x15, 0x0121401f }, /* HP out */
7288             { 0x18, 0x01a19c20 }, /* mic */
7289             { }
7290         },
7291     },
7292     [ALC269VB_FIXUP_AMIC] = {
7293         .type = HDA_FIXUP_PINS,
7294         .v.pins = (const struct hda_pintbl[]) {
7295             { 0x14, 0x99130110 }, /* speaker */
7296             { 0x18, 0x01a19c20 }, /* mic */
7297             { 0x19, 0x99a3092f }, /* int-mic */
7298             { 0x21, 0x0121401f }, /* HP out */
7299             { }
7300         },
7301     },
7302     [ALC269VB_FIXUP_DMIC] = {
7303         .type = HDA_FIXUP_PINS,
7304         .v.pins = (const struct hda_pintbl[]) {
7305             { 0x12, 0x99a3092f }, /* int-mic */
7306             { 0x14, 0x99130110 }, /* speaker */
7307             { 0x18, 0x01a19c20 }, /* mic */
7308             { 0x21, 0x0121401f }, /* HP out */
7309             { }
7310         },
7311     },
7312     [ALC269_FIXUP_HP_MUTE_LED] = {
7313         .type = HDA_FIXUP_FUNC,
7314         .v.func = alc269_fixup_hp_mute_led,
7315     },
7316     [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
7317         .type = HDA_FIXUP_FUNC,
7318         .v.func = alc269_fixup_hp_mute_led_mic1,
7319     },
7320     [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
7321         .type = HDA_FIXUP_FUNC,
7322         .v.func = alc269_fixup_hp_mute_led_mic2,
7323     },
7324     [ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
7325         .type = HDA_FIXUP_FUNC,
7326         .v.func = alc269_fixup_hp_mute_led_mic3,
7327         .chained = true,
7328         .chain_id = ALC295_FIXUP_HP_AUTO_MUTE
7329     },
7330     [ALC269_FIXUP_HP_GPIO_LED] = {
7331         .type = HDA_FIXUP_FUNC,
7332         .v.func = alc269_fixup_hp_gpio_led,
7333     },
7334     [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
7335         .type = HDA_FIXUP_FUNC,
7336         .v.func = alc269_fixup_hp_gpio_mic1_led,
7337     },
7338     [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
7339         .type = HDA_FIXUP_FUNC,
7340         .v.func = alc269_fixup_hp_line1_mic1_led,
7341     },
7342     [ALC269_FIXUP_INV_DMIC] = {
7343         .type = HDA_FIXUP_FUNC,
7344         .v.func = alc_fixup_inv_dmic,
7345     },
7346     [ALC269_FIXUP_NO_SHUTUP] = {
7347         .type = HDA_FIXUP_FUNC,
7348         .v.func = alc_fixup_no_shutup,
7349     },
7350     [ALC269_FIXUP_LENOVO_DOCK] = {
7351         .type = HDA_FIXUP_PINS,
7352         .v.pins = (const struct hda_pintbl[]) {
7353             { 0x19, 0x23a11040 }, /* dock mic */
7354             { 0x1b, 0x2121103f }, /* dock headphone */
7355             { }
7356         },
7357         .chained = true,
7358         .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
7359     },
7360     [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
7361         .type = HDA_FIXUP_FUNC,
7362         .v.func = alc269_fixup_limit_int_mic_boost,
7363         .chained = true,
7364         .chain_id = ALC269_FIXUP_LENOVO_DOCK,
7365     },
7366     [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
7367         .type = HDA_FIXUP_FUNC,
7368         .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7369         .chained = true,
7370         .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7371     },
7372     [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7373         .type = HDA_FIXUP_PINS,
7374         .v.pins = (const struct hda_pintbl[]) {
7375             { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7376             { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7377             { }
7378         },
7379         .chained = true,
7380         .chain_id = ALC269_FIXUP_HEADSET_MODE
7381     },
7382     [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
7383         .type = HDA_FIXUP_PINS,
7384         .v.pins = (const struct hda_pintbl[]) {
7385             { 0x16, 0x21014020 }, /* dock line out */
7386             { 0x19, 0x21a19030 }, /* dock mic */
7387             { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7388             { }
7389         },
7390         .chained = true,
7391         .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7392     },
7393     [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
7394         .type = HDA_FIXUP_PINS,
7395         .v.pins = (const struct hda_pintbl[]) {
7396             { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7397             { }
7398         },
7399         .chained = true,
7400         .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7401     },
7402     [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
7403         .type = HDA_FIXUP_PINS,
7404         .v.pins = (const struct hda_pintbl[]) {
7405             { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7406             { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7407             { }
7408         },
7409         .chained = true,
7410         .chain_id = ALC269_FIXUP_HEADSET_MODE
7411     },
7412     [ALC269_FIXUP_HEADSET_MODE] = {
7413         .type = HDA_FIXUP_FUNC,
7414         .v.func = alc_fixup_headset_mode,
7415         .chained = true,
7416         .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7417     },
7418     [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7419         .type = HDA_FIXUP_FUNC,
7420         .v.func = alc_fixup_headset_mode_no_hp_mic,
7421     },
7422     [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
7423         .type = HDA_FIXUP_PINS,
7424         .v.pins = (const struct hda_pintbl[]) {
7425             { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
7426             { }
7427         },
7428         .chained = true,
7429         .chain_id = ALC269_FIXUP_HEADSET_MODE,
7430     },
7431     [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
7432         .type = HDA_FIXUP_PINS,
7433         .v.pins = (const struct hda_pintbl[]) {
7434             { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7435             { }
7436         },
7437         .chained = true,
7438         .chain_id = ALC269_FIXUP_HEADSET_MIC
7439     },
7440     [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
7441         .type = HDA_FIXUP_PINS,
7442         .v.pins = (const struct hda_pintbl[]) {
7443             {0x12, 0x90a60130},
7444             {0x13, 0x40000000},
7445             {0x14, 0x90170110},
7446             {0x18, 0x411111f0},
7447             {0x19, 0x04a11040},
7448             {0x1a, 0x411111f0},
7449             {0x1b, 0x90170112},
7450             {0x1d, 0x40759a05},
7451             {0x1e, 0x411111f0},
7452             {0x21, 0x04211020},
7453             { }
7454         },
7455         .chained = true,
7456         .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7457     },
7458     [ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
7459         .type = HDA_FIXUP_FUNC,
7460         .v.func = alc298_fixup_huawei_mbx_stereo,
7461         .chained = true,
7462         .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7463     },
7464     [ALC269_FIXUP_ASUS_X101_FUNC] = {
7465         .type = HDA_FIXUP_FUNC,
7466         .v.func = alc269_fixup_x101_headset_mic,
7467     },
7468     [ALC269_FIXUP_ASUS_X101_VERB] = {
7469         .type = HDA_FIXUP_VERBS,
7470         .v.verbs = (const struct hda_verb[]) {
7471             {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
7472             {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
7473             {0x20, AC_VERB_SET_PROC_COEF,  0x0310},
7474             { }
7475         },
7476         .chained = true,
7477         .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
7478     },
7479     [ALC269_FIXUP_ASUS_X101] = {
7480         .type = HDA_FIXUP_PINS,
7481         .v.pins = (const struct hda_pintbl[]) {
7482             { 0x18, 0x04a1182c }, /* Headset mic */
7483             { }
7484         },
7485         .chained = true,
7486         .chain_id = ALC269_FIXUP_ASUS_X101_VERB
7487     },
7488     [ALC271_FIXUP_AMIC_MIC2] = {
7489         .type = HDA_FIXUP_PINS,
7490         .v.pins = (const struct hda_pintbl[]) {
7491             { 0x14, 0x99130110 }, /* speaker */
7492             { 0x19, 0x01a19c20 }, /* mic */
7493             { 0x1b, 0x99a7012f }, /* int-mic */
7494             { 0x21, 0x0121401f }, /* HP out */
7495             { }
7496         },
7497     },
7498     [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
7499         .type = HDA_FIXUP_FUNC,
7500         .v.func = alc271_hp_gate_mic_jack,
7501         .chained = true,
7502         .chain_id = ALC271_FIXUP_AMIC_MIC2,
7503     },
7504     [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
7505         .type = HDA_FIXUP_FUNC,
7506         .v.func = alc269_fixup_limit_int_mic_boost,
7507         .chained = true,
7508         .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
7509     },
7510     [ALC269_FIXUP_ACER_AC700] = {
7511         .type = HDA_FIXUP_PINS,
7512         .v.pins = (const struct hda_pintbl[]) {
7513             { 0x12, 0x99a3092f }, /* int-mic */
7514             { 0x14, 0x99130110 }, /* speaker */
7515             { 0x18, 0x03a11c20 }, /* mic */
7516             { 0x1e, 0x0346101e }, /* SPDIF1 */
7517             { 0x21, 0x0321101f }, /* HP out */
7518             { }
7519         },
7520         .chained = true,
7521         .chain_id = ALC271_FIXUP_DMIC,
7522     },
7523     [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
7524         .type = HDA_FIXUP_FUNC,
7525         .v.func = alc269_fixup_limit_int_mic_boost,
7526         .chained = true,
7527         .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7528     },
7529     [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
7530         .type = HDA_FIXUP_FUNC,
7531         .v.func = alc269_fixup_limit_int_mic_boost,
7532         .chained = true,
7533         .chain_id = ALC269VB_FIXUP_DMIC,
7534     },
7535     [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
7536         .type = HDA_FIXUP_VERBS,
7537         .v.verbs = (const struct hda_verb[]) {
7538             /* class-D output amp +5dB */
7539             { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
7540             { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
7541             {}
7542         },
7543         .chained = true,
7544         .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
7545     },
7546     [ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7547         .type = HDA_FIXUP_PINS,
7548         .v.pins = (const struct hda_pintbl[]) {
7549             { 0x18, 0x01a110f0 },  /* use as headset mic */
7550             { }
7551         },
7552         .chained = true,
7553         .chain_id = ALC269_FIXUP_HEADSET_MIC
7554     },
7555     [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
7556         .type = HDA_FIXUP_FUNC,
7557         .v.func = alc269_fixup_limit_int_mic_boost,
7558         .chained = true,
7559         .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
7560     },
7561     [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
7562         .type = HDA_FIXUP_PINS,
7563         .v.pins = (const struct hda_pintbl[]) {
7564             { 0x12, 0x99a3092f }, /* int-mic */
7565             { 0x18, 0x03a11d20 }, /* mic */
7566             { 0x19, 0x411111f0 }, /* Unused bogus pin */
7567             { }
7568         },
7569     },
7570     [ALC283_FIXUP_CHROME_BOOK] = {
7571         .type = HDA_FIXUP_FUNC,
7572         .v.func = alc283_fixup_chromebook,
7573     },
7574     [ALC283_FIXUP_SENSE_COMBO_JACK] = {
7575         .type = HDA_FIXUP_FUNC,
7576         .v.func = alc283_fixup_sense_combo_jack,
7577         .chained = true,
7578         .chain_id = ALC283_FIXUP_CHROME_BOOK,
7579     },
7580     [ALC282_FIXUP_ASUS_TX300] = {
7581         .type = HDA_FIXUP_FUNC,
7582         .v.func = alc282_fixup_asus_tx300,
7583     },
7584     [ALC283_FIXUP_INT_MIC] = {
7585         .type = HDA_FIXUP_VERBS,
7586         .v.verbs = (const struct hda_verb[]) {
7587             {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
7588             {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
7589             { }
7590         },
7591         .chained = true,
7592         .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
7593     },
7594     [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
7595         .type = HDA_FIXUP_PINS,
7596         .v.pins = (const struct hda_pintbl[]) {
7597             { 0x17, 0x90170112 }, /* subwoofer */
7598             { }
7599         },
7600         .chained = true,
7601         .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7602     },
7603     [ALC290_FIXUP_SUBWOOFER] = {
7604         .type = HDA_FIXUP_PINS,
7605         .v.pins = (const struct hda_pintbl[]) {
7606             { 0x17, 0x90170112 }, /* subwoofer */
7607             { }
7608         },
7609         .chained = true,
7610         .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
7611     },
7612     [ALC290_FIXUP_MONO_SPEAKERS] = {
7613         .type = HDA_FIXUP_FUNC,
7614         .v.func = alc290_fixup_mono_speakers,
7615     },
7616     [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
7617         .type = HDA_FIXUP_FUNC,
7618         .v.func = alc290_fixup_mono_speakers,
7619         .chained = true,
7620         .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7621     },
7622     [ALC269_FIXUP_THINKPAD_ACPI] = {
7623         .type = HDA_FIXUP_FUNC,
7624         .v.func = alc_fixup_thinkpad_acpi,
7625         .chained = true,
7626         .chain_id = ALC269_FIXUP_SKU_IGNORE,
7627     },
7628     [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
7629         .type = HDA_FIXUP_FUNC,
7630         .v.func = alc_fixup_inv_dmic,
7631         .chained = true,
7632         .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7633     },
7634     [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
7635         .type = HDA_FIXUP_PINS,
7636         .v.pins = (const struct hda_pintbl[]) {
7637             { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7638             { }
7639         },
7640         .chained = true,
7641         .chain_id = ALC255_FIXUP_HEADSET_MODE
7642     },
7643     [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7644         .type = HDA_FIXUP_PINS,
7645         .v.pins = (const struct hda_pintbl[]) {
7646             { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7647             { }
7648         },
7649         .chained = true,
7650         .chain_id = ALC255_FIXUP_HEADSET_MODE
7651     },
7652     [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7653         .type = HDA_FIXUP_PINS,
7654         .v.pins = (const struct hda_pintbl[]) {
7655             { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7656             { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7657             { }
7658         },
7659         .chained = true,
7660         .chain_id = ALC255_FIXUP_HEADSET_MODE
7661     },
7662     [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
7663         .type = HDA_FIXUP_PINS,
7664         .v.pins = (const struct hda_pintbl[]) {
7665             { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7666             { }
7667         },
7668         .chained = true,
7669         .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
7670     },
7671     [ALC255_FIXUP_HEADSET_MODE] = {
7672         .type = HDA_FIXUP_FUNC,
7673         .v.func = alc_fixup_headset_mode_alc255,
7674         .chained = true,
7675         .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7676     },
7677     [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7678         .type = HDA_FIXUP_FUNC,
7679         .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
7680     },
7681     [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7682         .type = HDA_FIXUP_PINS,
7683         .v.pins = (const struct hda_pintbl[]) {
7684             { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7685             { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7686             { }
7687         },
7688         .chained = true,
7689         .chain_id = ALC269_FIXUP_HEADSET_MODE
7690     },
7691     [ALC292_FIXUP_TPT440_DOCK] = {
7692         .type = HDA_FIXUP_FUNC,
7693         .v.func = alc_fixup_tpt440_dock,
7694         .chained = true,
7695         .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
7696     },
7697     [ALC292_FIXUP_TPT440] = {
7698         .type = HDA_FIXUP_FUNC,
7699         .v.func = alc_fixup_disable_aamix,
7700         .chained = true,
7701         .chain_id = ALC292_FIXUP_TPT440_DOCK,
7702     },
7703     [ALC283_FIXUP_HEADSET_MIC] = {
7704         .type = HDA_FIXUP_PINS,
7705         .v.pins = (const struct hda_pintbl[]) {
7706             { 0x19, 0x04a110f0 },
7707             { },
7708         },
7709     },
7710     [ALC255_FIXUP_MIC_MUTE_LED] = {
7711         .type = HDA_FIXUP_FUNC,
7712         .v.func = alc_fixup_micmute_led,
7713     },
7714     [ALC282_FIXUP_ASPIRE_V5_PINS] = {
7715         .type = HDA_FIXUP_PINS,
7716         .v.pins = (const struct hda_pintbl[]) {
7717             { 0x12, 0x90a60130 },
7718             { 0x14, 0x90170110 },
7719             { 0x17, 0x40000008 },
7720             { 0x18, 0x411111f0 },
7721             { 0x19, 0x01a1913c },
7722             { 0x1a, 0x411111f0 },
7723             { 0x1b, 0x411111f0 },
7724             { 0x1d, 0x40f89b2d },
7725             { 0x1e, 0x411111f0 },
7726             { 0x21, 0x0321101f },
7727             { },
7728         },
7729     },
7730     [ALC269VB_FIXUP_ASPIRE_E1_COEF] = {
7731         .type = HDA_FIXUP_FUNC,
7732         .v.func = alc269vb_fixup_aspire_e1_coef,
7733     },
7734     [ALC280_FIXUP_HP_GPIO4] = {
7735         .type = HDA_FIXUP_FUNC,
7736         .v.func = alc280_fixup_hp_gpio4,
7737     },
7738     [ALC286_FIXUP_HP_GPIO_LED] = {
7739         .type = HDA_FIXUP_FUNC,
7740         .v.func = alc286_fixup_hp_gpio_led,
7741     },
7742     [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
7743         .type = HDA_FIXUP_FUNC,
7744         .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
7745     },
7746     [ALC280_FIXUP_HP_DOCK_PINS] = {
7747         .type = HDA_FIXUP_PINS,
7748         .v.pins = (const struct hda_pintbl[]) {
7749             { 0x1b, 0x21011020 }, /* line-out */
7750             { 0x1a, 0x01a1903c }, /* headset mic */
7751             { 0x18, 0x2181103f }, /* line-in */
7752             { },
7753         },
7754         .chained = true,
7755         .chain_id = ALC280_FIXUP_HP_GPIO4
7756     },
7757     [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
7758         .type = HDA_FIXUP_PINS,
7759         .v.pins = (const struct hda_pintbl[]) {
7760             { 0x1b, 0x21011020 }, /* line-out */
7761             { 0x18, 0x2181103f }, /* line-in */
7762             { },
7763         },
7764         .chained = true,
7765         .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
7766     },
7767     [ALC280_FIXUP_HP_9480M] = {
7768         .type = HDA_FIXUP_FUNC,
7769         .v.func = alc280_fixup_hp_9480m,
7770     },
7771     [ALC245_FIXUP_HP_X360_AMP] = {
7772         .type = HDA_FIXUP_FUNC,
7773         .v.func = alc245_fixup_hp_x360_amp,
7774         .chained = true,
7775         .chain_id = ALC245_FIXUP_HP_GPIO_LED
7776     },
7777     [ALC288_FIXUP_DELL_HEADSET_MODE] = {
7778         .type = HDA_FIXUP_FUNC,
7779         .v.func = alc_fixup_headset_mode_dell_alc288,
7780         .chained = true,
7781         .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7782     },
7783     [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7784         .type = HDA_FIXUP_PINS,
7785         .v.pins = (const struct hda_pintbl[]) {
7786             { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7787             { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7788             { }
7789         },
7790         .chained = true,
7791         .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
7792     },
7793     [ALC288_FIXUP_DISABLE_AAMIX] = {
7794         .type = HDA_FIXUP_FUNC,
7795         .v.func = alc_fixup_disable_aamix,
7796         .chained = true,
7797         .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
7798     },
7799     [ALC288_FIXUP_DELL_XPS_13] = {
7800         .type = HDA_FIXUP_FUNC,
7801         .v.func = alc_fixup_dell_xps13,
7802         .chained = true,
7803         .chain_id = ALC288_FIXUP_DISABLE_AAMIX
7804     },
7805     [ALC292_FIXUP_DISABLE_AAMIX] = {
7806         .type = HDA_FIXUP_FUNC,
7807         .v.func = alc_fixup_disable_aamix,
7808         .chained = true,
7809         .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
7810     },
7811     [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
7812         .type = HDA_FIXUP_FUNC,
7813         .v.func = alc_fixup_disable_aamix,
7814         .chained = true,
7815         .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
7816     },
7817     [ALC292_FIXUP_DELL_E7X_AAMIX] = {
7818         .type = HDA_FIXUP_FUNC,
7819         .v.func = alc_fixup_dell_xps13,
7820         .chained = true,
7821         .chain_id = ALC292_FIXUP_DISABLE_AAMIX
7822     },
7823     [ALC292_FIXUP_DELL_E7X] = {
7824         .type = HDA_FIXUP_FUNC,
7825         .v.func = alc_fixup_micmute_led,
7826         /* micmute fixup must be applied at last */
7827         .chained_before = true,
7828         .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
7829     },
7830     [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
7831         .type = HDA_FIXUP_PINS,
7832         .v.pins = (const struct hda_pintbl[]) {
7833             { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
7834             { }
7835         },
7836         .chained_before = true,
7837         .chain_id = ALC269_FIXUP_HEADSET_MODE,
7838     },
7839     [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7840         .type = HDA_FIXUP_PINS,
7841         .v.pins = (const struct hda_pintbl[]) {
7842             { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7843             { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7844             { }
7845         },
7846         .chained = true,
7847         .chain_id = ALC269_FIXUP_HEADSET_MODE
7848     },
7849     [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
7850         .type = HDA_FIXUP_PINS,
7851         .v.pins = (const struct hda_pintbl[]) {
7852             { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7853             { }
7854         },
7855         .chained = true,
7856         .chain_id = ALC269_FIXUP_HEADSET_MODE
7857     },
7858     [ALC275_FIXUP_DELL_XPS] = {
7859         .type = HDA_FIXUP_VERBS,
7860         .v.verbs = (const struct hda_verb[]) {
7861             /* Enables internal speaker */
7862             {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
7863             {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
7864             {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
7865             {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
7866             {}
7867         }
7868     },
7869     [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
7870         .type = HDA_FIXUP_FUNC,
7871         .v.func = alc_fixup_disable_aamix,
7872         .chained = true,
7873         .chain_id = ALC269_FIXUP_THINKPAD_ACPI
7874     },
7875     [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
7876         .type = HDA_FIXUP_FUNC,
7877         .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
7878     },
7879     [ALC233_FIXUP_INTEL_NUC8_DMIC] = {
7880         .type = HDA_FIXUP_FUNC,
7881         .v.func = alc_fixup_inv_dmic,
7882         .chained = true,
7883         .chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST,
7884     },
7885     [ALC233_FIXUP_INTEL_NUC8_BOOST] = {
7886         .type = HDA_FIXUP_FUNC,
7887         .v.func = alc269_fixup_limit_int_mic_boost
7888     },
7889     [ALC255_FIXUP_DELL_SPK_NOISE] = {
7890         .type = HDA_FIXUP_FUNC,
7891         .v.func = alc_fixup_disable_aamix,
7892         .chained = true,
7893         .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
7894     },
7895     [ALC225_FIXUP_DISABLE_MIC_VREF] = {
7896         .type = HDA_FIXUP_FUNC,
7897         .v.func = alc_fixup_disable_mic_vref,
7898         .chained = true,
7899         .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
7900     },
7901     [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7902         .type = HDA_FIXUP_VERBS,
7903         .v.verbs = (const struct hda_verb[]) {
7904             /* Disable pass-through path for FRONT 14h */
7905             { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
7906             { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
7907             {}
7908         },
7909         .chained = true,
7910         .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
7911     },
7912     [ALC280_FIXUP_HP_HEADSET_MIC] = {
7913         .type = HDA_FIXUP_FUNC,
7914         .v.func = alc_fixup_disable_aamix,
7915         .chained = true,
7916         .chain_id = ALC269_FIXUP_HEADSET_MIC,
7917     },
7918     [ALC221_FIXUP_HP_FRONT_MIC] = {
7919         .type = HDA_FIXUP_PINS,
7920         .v.pins = (const struct hda_pintbl[]) {
7921             { 0x19, 0x02a19020 }, /* Front Mic */
7922             { }
7923         },
7924     },
7925     [ALC292_FIXUP_TPT460] = {
7926         .type = HDA_FIXUP_FUNC,
7927         .v.func = alc_fixup_tpt440_dock,
7928         .chained = true,
7929         .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
7930     },
7931     [ALC298_FIXUP_SPK_VOLUME] = {
7932         .type = HDA_FIXUP_FUNC,
7933         .v.func = alc298_fixup_speaker_volume,
7934         .chained = true,
7935         .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
7936     },
7937     [ALC298_FIXUP_LENOVO_SPK_VOLUME] = {
7938         .type = HDA_FIXUP_FUNC,
7939         .v.func = alc298_fixup_speaker_volume,
7940     },
7941     [ALC295_FIXUP_DISABLE_DAC3] = {
7942         .type = HDA_FIXUP_FUNC,
7943         .v.func = alc295_fixup_disable_dac3,
7944     },
7945     [ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
7946         .type = HDA_FIXUP_FUNC,
7947         .v.func = alc285_fixup_speaker2_to_dac1,
7948         .chained = true,
7949         .chain_id = ALC269_FIXUP_THINKPAD_ACPI
7950     },
7951     [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
7952         .type = HDA_FIXUP_PINS,
7953         .v.pins = (const struct hda_pintbl[]) {
7954             { 0x1b, 0x90170151 },
7955             { }
7956         },
7957         .chained = true,
7958         .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
7959     },
7960     [ALC269_FIXUP_ATIV_BOOK_8] = {
7961         .type = HDA_FIXUP_FUNC,
7962         .v.func = alc_fixup_auto_mute_via_amp,
7963         .chained = true,
7964         .chain_id = ALC269_FIXUP_NO_SHUTUP
7965     },
7966     [ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
7967         .type = HDA_FIXUP_PINS,
7968         .v.pins = (const struct hda_pintbl[]) {
7969             { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7970             { 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
7971             { }
7972         },
7973         .chained = true,
7974         .chain_id = ALC269_FIXUP_HEADSET_MODE
7975     },
7976     [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
7977         .type = HDA_FIXUP_PINS,
7978         .v.pins = (const struct hda_pintbl[]) {
7979             { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7980             { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7981             { }
7982         },
7983         .chained = true,
7984         .chain_id = ALC269_FIXUP_HEADSET_MODE
7985     },
7986     [ALC256_FIXUP_ASUS_HEADSET_MODE] = {
7987         .type = HDA_FIXUP_FUNC,
7988         .v.func = alc_fixup_headset_mode,
7989     },
7990     [ALC256_FIXUP_ASUS_MIC] = {
7991         .type = HDA_FIXUP_PINS,
7992         .v.pins = (const struct hda_pintbl[]) {
7993             { 0x13, 0x90a60160 }, /* use as internal mic */
7994             { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
7995             { }
7996         },
7997         .chained = true,
7998         .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
7999     },
8000     [ALC256_FIXUP_ASUS_AIO_GPIO2] = {
8001         .type = HDA_FIXUP_FUNC,
8002         /* Set up GPIO2 for the speaker amp */
8003         .v.func = alc_fixup_gpio4,
8004     },
8005     [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8006         .type = HDA_FIXUP_PINS,
8007         .v.pins = (const struct hda_pintbl[]) {
8008             { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8009             { }
8010         },
8011         .chained = true,
8012         .chain_id = ALC269_FIXUP_HEADSET_MIC
8013     },
8014     [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
8015         .type = HDA_FIXUP_VERBS,
8016         .v.verbs = (const struct hda_verb[]) {
8017             /* Enables internal speaker */
8018             {0x20, AC_VERB_SET_COEF_INDEX, 0x40},
8019             {0x20, AC_VERB_SET_PROC_COEF, 0x8800},
8020             {}
8021         },
8022         .chained = true,
8023         .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8024     },
8025     [ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
8026         .type = HDA_FIXUP_FUNC,
8027         .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8028         .chained = true,
8029         .chain_id = ALC269_FIXUP_GPIO2
8030     },
8031     [ALC233_FIXUP_ACER_HEADSET_MIC] = {
8032         .type = HDA_FIXUP_VERBS,
8033         .v.verbs = (const struct hda_verb[]) {
8034             { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8035             { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8036             { }
8037         },
8038         .chained = true,
8039         .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8040     },
8041     [ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
8042         .type = HDA_FIXUP_PINS,
8043         .v.pins = (const struct hda_pintbl[]) {
8044             /* Change the mic location from front to right, otherwise there are
8045                two front mics with the same name, pulseaudio can't handle them.
8046                This is just a temporary workaround, after applying this fixup,
8047                there will be one "Front Mic" and one "Mic" in this machine.
8048              */
8049             { 0x1a, 0x04a19040 },
8050             { }
8051         },
8052     },
8053     [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
8054         .type = HDA_FIXUP_PINS,
8055         .v.pins = (const struct hda_pintbl[]) {
8056             { 0x16, 0x0101102f }, /* Rear Headset HP */
8057             { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
8058             { 0x1a, 0x01a19030 }, /* Rear Headset MIC */
8059             { 0x1b, 0x02011020 },
8060             { }
8061         },
8062         .chained = true,
8063         .chain_id = ALC225_FIXUP_S3_POP_NOISE
8064     },
8065     [ALC225_FIXUP_S3_POP_NOISE] = {
8066         .type = HDA_FIXUP_FUNC,
8067         .v.func = alc225_fixup_s3_pop_noise,
8068         .chained = true,
8069         .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8070     },
8071     [ALC700_FIXUP_INTEL_REFERENCE] = {
8072         .type = HDA_FIXUP_VERBS,
8073         .v.verbs = (const struct hda_verb[]) {
8074             /* Enables internal speaker */
8075             {0x20, AC_VERB_SET_COEF_INDEX, 0x45},
8076             {0x20, AC_VERB_SET_PROC_COEF, 0x5289},
8077             {0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
8078             {0x20, AC_VERB_SET_PROC_COEF, 0x001b},
8079             {0x58, AC_VERB_SET_COEF_INDEX, 0x00},
8080             {0x58, AC_VERB_SET_PROC_COEF, 0x3888},
8081             {0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
8082             {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
8083             {}
8084         }
8085     },
8086     [ALC274_FIXUP_DELL_BIND_DACS] = {
8087         .type = HDA_FIXUP_FUNC,
8088         .v.func = alc274_fixup_bind_dacs,
8089         .chained = true,
8090         .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8091     },
8092     [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
8093         .type = HDA_FIXUP_PINS,
8094         .v.pins = (const struct hda_pintbl[]) {
8095             { 0x1b, 0x0401102f },
8096             { }
8097         },
8098         .chained = true,
8099         .chain_id = ALC274_FIXUP_DELL_BIND_DACS
8100     },
8101     [ALC298_FIXUP_TPT470_DOCK_FIX] = {
8102         .type = HDA_FIXUP_FUNC,
8103         .v.func = alc_fixup_tpt470_dock,
8104         .chained = true,
8105         .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
8106     },
8107     [ALC298_FIXUP_TPT470_DOCK] = {
8108         .type = HDA_FIXUP_FUNC,
8109         .v.func = alc_fixup_tpt470_dacs,
8110         .chained = true,
8111         .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
8112     },
8113     [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
8114         .type = HDA_FIXUP_PINS,
8115         .v.pins = (const struct hda_pintbl[]) {
8116             { 0x14, 0x0201101f },
8117             { }
8118         },
8119         .chained = true,
8120         .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8121     },
8122     [ALC255_FIXUP_DELL_HEADSET_MIC] = {
8123         .type = HDA_FIXUP_PINS,
8124         .v.pins = (const struct hda_pintbl[]) {
8125             { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8126             { }
8127         },
8128         .chained = true,
8129         .chain_id = ALC269_FIXUP_HEADSET_MIC
8130     },
8131     [ALC295_FIXUP_HP_X360] = {
8132         .type = HDA_FIXUP_FUNC,
8133         .v.func = alc295_fixup_hp_top_speakers,
8134         .chained = true,
8135         .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
8136     },
8137     [ALC221_FIXUP_HP_HEADSET_MIC] = {
8138         .type = HDA_FIXUP_PINS,
8139         .v.pins = (const struct hda_pintbl[]) {
8140             { 0x19, 0x0181313f},
8141             { }
8142         },
8143         .chained = true,
8144         .chain_id = ALC269_FIXUP_HEADSET_MIC
8145     },
8146     [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
8147         .type = HDA_FIXUP_FUNC,
8148         .v.func = alc285_fixup_invalidate_dacs,
8149         .chained = true,
8150         .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8151     },
8152     [ALC295_FIXUP_HP_AUTO_MUTE] = {
8153         .type = HDA_FIXUP_FUNC,
8154         .v.func = alc_fixup_auto_mute_via_amp,
8155     },
8156     [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
8157         .type = HDA_FIXUP_PINS,
8158         .v.pins = (const struct hda_pintbl[]) {
8159             { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8160             { }
8161         },
8162         .chained = true,
8163         .chain_id = ALC269_FIXUP_HEADSET_MIC
8164     },
8165     [ALC294_FIXUP_ASUS_MIC] = {
8166         .type = HDA_FIXUP_PINS,
8167         .v.pins = (const struct hda_pintbl[]) {
8168             { 0x13, 0x90a60160 }, /* use as internal mic */
8169             { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8170             { }
8171         },
8172         .chained = true,
8173         .chain_id = ALC269_FIXUP_HEADSET_MIC
8174     },
8175     [ALC294_FIXUP_ASUS_HEADSET_MIC] = {
8176         .type = HDA_FIXUP_PINS,
8177         .v.pins = (const struct hda_pintbl[]) {
8178             { 0x19, 0x01a1103c }, /* use as headset mic */
8179             { }
8180         },
8181         .chained = true,
8182         .chain_id = ALC269_FIXUP_HEADSET_MIC
8183     },
8184     [ALC294_FIXUP_ASUS_SPK] = {
8185         .type = HDA_FIXUP_VERBS,
8186         .v.verbs = (const struct hda_verb[]) {
8187             /* Set EAPD high */
8188             { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
8189             { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
8190             { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8191             { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8192             { }
8193         },
8194         .chained = true,
8195         .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8196     },
8197     [ALC295_FIXUP_CHROME_BOOK] = {
8198         .type = HDA_FIXUP_FUNC,
8199         .v.func = alc295_fixup_chromebook,
8200         .chained = true,
8201         .chain_id = ALC225_FIXUP_HEADSET_JACK
8202     },
8203     [ALC225_FIXUP_HEADSET_JACK] = {
8204         .type = HDA_FIXUP_FUNC,
8205         .v.func = alc_fixup_headset_jack,
8206     },
8207     [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
8208         .type = HDA_FIXUP_PINS,
8209         .v.pins = (const struct hda_pintbl[]) {
8210             { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8211             { }
8212         },
8213         .chained = true,
8214         .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8215     },
8216     [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
8217         .type = HDA_FIXUP_VERBS,
8218         .v.verbs = (const struct hda_verb[]) {
8219             /* Disable PCBEEP-IN passthrough */
8220             { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8221             { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8222             { }
8223         },
8224         .chained = true,
8225         .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
8226     },
8227     [ALC255_FIXUP_ACER_HEADSET_MIC] = {
8228         .type = HDA_FIXUP_PINS,
8229         .v.pins = (const struct hda_pintbl[]) {
8230             { 0x19, 0x03a11130 },
8231             { 0x1a, 0x90a60140 }, /* use as internal mic */
8232             { }
8233         },
8234         .chained = true,
8235         .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8236     },
8237     [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
8238         .type = HDA_FIXUP_PINS,
8239         .v.pins = (const struct hda_pintbl[]) {
8240             { 0x16, 0x01011020 }, /* Rear Line out */
8241             { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
8242             { }
8243         },
8244         .chained = true,
8245         .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
8246     },
8247     [ALC225_FIXUP_WYSE_AUTO_MUTE] = {
8248         .type = HDA_FIXUP_FUNC,
8249         .v.func = alc_fixup_auto_mute_via_amp,
8250         .chained = true,
8251         .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
8252     },
8253     [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
8254         .type = HDA_FIXUP_FUNC,
8255         .v.func = alc_fixup_disable_mic_vref,
8256         .chained = true,
8257         .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8258     },
8259     [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
8260         .type = HDA_FIXUP_VERBS,
8261         .v.verbs = (const struct hda_verb[]) {
8262             { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
8263             { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
8264             { }
8265         },
8266         .chained = true,
8267         .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
8268     },
8269     [ALC256_FIXUP_ASUS_HEADSET_MIC] = {
8270         .type = HDA_FIXUP_PINS,
8271         .v.pins = (const struct hda_pintbl[]) {
8272             { 0x19, 0x03a11020 }, /* headset mic with jack detect */
8273             { }
8274         },
8275         .chained = true,
8276         .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8277     },
8278     [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8279         .type = HDA_FIXUP_PINS,
8280         .v.pins = (const struct hda_pintbl[]) {
8281             { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8282             { }
8283         },
8284         .chained = true,
8285         .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8286     },
8287     [ALC299_FIXUP_PREDATOR_SPK] = {
8288         .type = HDA_FIXUP_PINS,
8289         .v.pins = (const struct hda_pintbl[]) {
8290             { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
8291             { }
8292         }
8293     },
8294     [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
8295         .type = HDA_FIXUP_PINS,
8296         .v.pins = (const struct hda_pintbl[]) {
8297             { 0x19, 0x04a11040 },
8298             { 0x21, 0x04211020 },
8299             { }
8300         },
8301         .chained = true,
8302         .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8303     },
8304     [ALC289_FIXUP_DELL_SPK2] = {
8305         .type = HDA_FIXUP_PINS,
8306         .v.pins = (const struct hda_pintbl[]) {
8307             { 0x17, 0x90170130 }, /* bass spk */
8308             { }
8309         },
8310         .chained = true,
8311         .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8312     },
8313     [ALC289_FIXUP_DUAL_SPK] = {
8314         .type = HDA_FIXUP_FUNC,
8315         .v.func = alc285_fixup_speaker2_to_dac1,
8316         .chained = true,
8317         .chain_id = ALC289_FIXUP_DELL_SPK2
8318     },
8319     [ALC294_FIXUP_SPK2_TO_DAC1] = {
8320         .type = HDA_FIXUP_FUNC,
8321         .v.func = alc285_fixup_speaker2_to_dac1,
8322         .chained = true,
8323         .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8324     },
8325     [ALC294_FIXUP_ASUS_DUAL_SPK] = {
8326         .type = HDA_FIXUP_FUNC,
8327         /* The GPIO must be pulled to initialize the AMP */
8328         .v.func = alc_fixup_gpio4,
8329         .chained = true,
8330         .chain_id = ALC294_FIXUP_SPK2_TO_DAC1
8331     },
8332     [ALC285_FIXUP_THINKPAD_X1_GEN7] = {
8333         .type = HDA_FIXUP_FUNC,
8334         .v.func = alc285_fixup_thinkpad_x1_gen7,
8335         .chained = true,
8336         .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8337     },
8338     [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
8339         .type = HDA_FIXUP_FUNC,
8340         .v.func = alc_fixup_headset_jack,
8341         .chained = true,
8342         .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
8343     },
8344     [ALC294_FIXUP_ASUS_HPE] = {
8345         .type = HDA_FIXUP_VERBS,
8346         .v.verbs = (const struct hda_verb[]) {
8347             /* Set EAPD high */
8348             { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8349             { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8350             { }
8351         },
8352         .chained = true,
8353         .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8354     },
8355     [ALC294_FIXUP_ASUS_GX502_PINS] = {
8356         .type = HDA_FIXUP_PINS,
8357         .v.pins = (const struct hda_pintbl[]) {
8358             { 0x19, 0x03a11050 }, /* front HP mic */
8359             { 0x1a, 0x01a11830 }, /* rear external mic */
8360             { 0x21, 0x03211020 }, /* front HP out */
8361             { }
8362         },
8363         .chained = true,
8364         .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS
8365     },
8366     [ALC294_FIXUP_ASUS_GX502_VERBS] = {
8367         .type = HDA_FIXUP_VERBS,
8368         .v.verbs = (const struct hda_verb[]) {
8369             /* set 0x15 to HP-OUT ctrl */
8370             { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8371             /* unmute the 0x15 amp */
8372             { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8373             { }
8374         },
8375         .chained = true,
8376         .chain_id = ALC294_FIXUP_ASUS_GX502_HP
8377     },
8378     [ALC294_FIXUP_ASUS_GX502_HP] = {
8379         .type = HDA_FIXUP_FUNC,
8380         .v.func = alc294_fixup_gx502_hp,
8381     },
8382     [ALC294_FIXUP_ASUS_GU502_PINS] = {
8383         .type = HDA_FIXUP_PINS,
8384         .v.pins = (const struct hda_pintbl[]) {
8385             { 0x19, 0x01a11050 }, /* rear HP mic */
8386             { 0x1a, 0x01a11830 }, /* rear external mic */
8387             { 0x21, 0x012110f0 }, /* rear HP out */
8388             { }
8389         },
8390         .chained = true,
8391         .chain_id = ALC294_FIXUP_ASUS_GU502_VERBS
8392     },
8393     [ALC294_FIXUP_ASUS_GU502_VERBS] = {
8394         .type = HDA_FIXUP_VERBS,
8395         .v.verbs = (const struct hda_verb[]) {
8396             /* set 0x15 to HP-OUT ctrl */
8397             { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8398             /* unmute the 0x15 amp */
8399             { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8400             /* set 0x1b to HP-OUT */
8401             { 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
8402             { }
8403         },
8404         .chained = true,
8405         .chain_id = ALC294_FIXUP_ASUS_GU502_HP
8406     },
8407     [ALC294_FIXUP_ASUS_GU502_HP] = {
8408         .type = HDA_FIXUP_FUNC,
8409         .v.func = alc294_fixup_gu502_hp,
8410     },
8411      [ALC294_FIXUP_ASUS_G513_PINS] = {
8412         .type = HDA_FIXUP_PINS,
8413         .v.pins = (const struct hda_pintbl[]) {
8414                 { 0x19, 0x03a11050 }, /* front HP mic */
8415                 { 0x1a, 0x03a11c30 }, /* rear external mic */
8416                 { 0x21, 0x03211420 }, /* front HP out */
8417                 { }
8418         },
8419     },
8420     [ALC285_FIXUP_ASUS_G533Z_PINS] = {
8421         .type = HDA_FIXUP_PINS,
8422         .v.pins = (const struct hda_pintbl[]) {
8423             { 0x14, 0x90170120 },
8424             { }
8425         },
8426         .chained = true,
8427         .chain_id = ALC294_FIXUP_ASUS_G513_PINS,
8428     },
8429     [ALC294_FIXUP_ASUS_COEF_1B] = {
8430         .type = HDA_FIXUP_VERBS,
8431         .v.verbs = (const struct hda_verb[]) {
8432             /* Set bit 10 to correct noisy output after reboot from
8433              * Windows 10 (due to pop noise reduction?)
8434              */
8435             { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
8436             { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
8437             { }
8438         },
8439         .chained = true,
8440         .chain_id = ALC289_FIXUP_ASUS_GA401,
8441     },
8442     [ALC285_FIXUP_HP_GPIO_LED] = {
8443         .type = HDA_FIXUP_FUNC,
8444         .v.func = alc285_fixup_hp_gpio_led,
8445     },
8446     [ALC285_FIXUP_HP_MUTE_LED] = {
8447         .type = HDA_FIXUP_FUNC,
8448         .v.func = alc285_fixup_hp_mute_led,
8449     },
8450     [ALC236_FIXUP_HP_GPIO_LED] = {
8451         .type = HDA_FIXUP_FUNC,
8452         .v.func = alc236_fixup_hp_gpio_led,
8453     },
8454     [ALC236_FIXUP_HP_MUTE_LED] = {
8455         .type = HDA_FIXUP_FUNC,
8456         .v.func = alc236_fixup_hp_mute_led,
8457     },
8458     [ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = {
8459         .type = HDA_FIXUP_FUNC,
8460         .v.func = alc236_fixup_hp_mute_led_micmute_vref,
8461     },
8462     [ALC298_FIXUP_SAMSUNG_AMP] = {
8463         .type = HDA_FIXUP_FUNC,
8464         .v.func = alc298_fixup_samsung_amp,
8465         .chained = true,
8466         .chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET
8467     },
8468     [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8469         .type = HDA_FIXUP_VERBS,
8470         .v.verbs = (const struct hda_verb[]) {
8471             { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
8472             { }
8473         },
8474     },
8475     [ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8476         .type = HDA_FIXUP_VERBS,
8477         .v.verbs = (const struct hda_verb[]) {
8478             { 0x20, AC_VERB_SET_COEF_INDEX, 0x08},
8479             { 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf},
8480             { }
8481         },
8482     },
8483     [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8484         .type = HDA_FIXUP_PINS,
8485         .v.pins = (const struct hda_pintbl[]) {
8486             { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8487             { }
8488         },
8489         .chained = true,
8490         .chain_id = ALC269_FIXUP_HEADSET_MODE
8491     },
8492     [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = {
8493         .type = HDA_FIXUP_PINS,
8494         .v.pins = (const struct hda_pintbl[]) {
8495             { 0x14, 0x90100120 }, /* use as internal speaker */
8496             { 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */
8497             { 0x1a, 0x01011020 }, /* use as line out */
8498             { },
8499         },
8500         .chained = true,
8501         .chain_id = ALC269_FIXUP_HEADSET_MIC
8502     },
8503     [ALC269VC_FIXUP_ACER_HEADSET_MIC] = {
8504         .type = HDA_FIXUP_PINS,
8505         .v.pins = (const struct hda_pintbl[]) {
8506             { 0x18, 0x02a11030 }, /* use as headset mic */
8507             { }
8508         },
8509         .chained = true,
8510         .chain_id = ALC269_FIXUP_HEADSET_MIC
8511     },
8512     [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = {
8513         .type = HDA_FIXUP_PINS,
8514         .v.pins = (const struct hda_pintbl[]) {
8515             { 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */
8516             { }
8517         },
8518         .chained = true,
8519         .chain_id = ALC269_FIXUP_HEADSET_MIC
8520     },
8521     [ALC289_FIXUP_ASUS_GA401] = {
8522         .type = HDA_FIXUP_FUNC,
8523         .v.func = alc289_fixup_asus_ga401,
8524         .chained = true,
8525         .chain_id = ALC289_FIXUP_ASUS_GA502,
8526     },
8527     [ALC289_FIXUP_ASUS_GA502] = {
8528         .type = HDA_FIXUP_PINS,
8529         .v.pins = (const struct hda_pintbl[]) {
8530             { 0x19, 0x03a11020 }, /* headset mic with jack detect */
8531             { }
8532         },
8533     },
8534     [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = {
8535         .type = HDA_FIXUP_PINS,
8536         .v.pins = (const struct hda_pintbl[]) {
8537             { 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */
8538             { }
8539         },
8540         .chained = true,
8541         .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8542     },
8543     [ALC285_FIXUP_HP_GPIO_AMP_INIT] = {
8544         .type = HDA_FIXUP_FUNC,
8545         .v.func = alc285_fixup_hp_gpio_amp_init,
8546         .chained = true,
8547         .chain_id = ALC285_FIXUP_HP_GPIO_LED
8548     },
8549     [ALC269_FIXUP_CZC_B20] = {
8550         .type = HDA_FIXUP_PINS,
8551         .v.pins = (const struct hda_pintbl[]) {
8552             { 0x12, 0x411111f0 },
8553             { 0x14, 0x90170110 }, /* speaker */
8554             { 0x15, 0x032f1020 }, /* HP out */
8555             { 0x17, 0x411111f0 },
8556             { 0x18, 0x03ab1040 }, /* mic */
8557             { 0x19, 0xb7a7013f },
8558             { 0x1a, 0x0181305f },
8559             { 0x1b, 0x411111f0 },
8560             { 0x1d, 0x411111f0 },
8561             { 0x1e, 0x411111f0 },
8562             { }
8563         },
8564         .chain_id = ALC269_FIXUP_DMIC,
8565     },
8566     [ALC269_FIXUP_CZC_TMI] = {
8567         .type = HDA_FIXUP_PINS,
8568         .v.pins = (const struct hda_pintbl[]) {
8569             { 0x12, 0x4000c000 },
8570             { 0x14, 0x90170110 }, /* speaker */
8571             { 0x15, 0x0421401f }, /* HP out */
8572             { 0x17, 0x411111f0 },
8573             { 0x18, 0x04a19020 }, /* mic */
8574             { 0x19, 0x411111f0 },
8575             { 0x1a, 0x411111f0 },
8576             { 0x1b, 0x411111f0 },
8577             { 0x1d, 0x40448505 },
8578             { 0x1e, 0x411111f0 },
8579             { 0x20, 0x8000ffff },
8580             { }
8581         },
8582         .chain_id = ALC269_FIXUP_DMIC,
8583     },
8584     [ALC269_FIXUP_CZC_L101] = {
8585         .type = HDA_FIXUP_PINS,
8586         .v.pins = (const struct hda_pintbl[]) {
8587             { 0x12, 0x40000000 },
8588             { 0x14, 0x01014010 }, /* speaker */
8589             { 0x15, 0x411111f0 }, /* HP out */
8590             { 0x16, 0x411111f0 },
8591             { 0x18, 0x01a19020 }, /* mic */
8592             { 0x19, 0x02a19021 },
8593             { 0x1a, 0x0181302f },
8594             { 0x1b, 0x0221401f },
8595             { 0x1c, 0x411111f0 },
8596             { 0x1d, 0x4044c601 },
8597             { 0x1e, 0x411111f0 },
8598             { }
8599         },
8600         .chain_id = ALC269_FIXUP_DMIC,
8601     },
8602     [ALC269_FIXUP_LEMOTE_A1802] = {
8603         .type = HDA_FIXUP_PINS,
8604         .v.pins = (const struct hda_pintbl[]) {
8605             { 0x12, 0x40000000 },
8606             { 0x14, 0x90170110 }, /* speaker */
8607             { 0x17, 0x411111f0 },
8608             { 0x18, 0x03a19040 }, /* mic1 */
8609             { 0x19, 0x90a70130 }, /* mic2 */
8610             { 0x1a, 0x411111f0 },
8611             { 0x1b, 0x411111f0 },
8612             { 0x1d, 0x40489d2d },
8613             { 0x1e, 0x411111f0 },
8614             { 0x20, 0x0003ffff },
8615             { 0x21, 0x03214020 },
8616             { }
8617         },
8618         .chain_id = ALC269_FIXUP_DMIC,
8619     },
8620     [ALC269_FIXUP_LEMOTE_A190X] = {
8621         .type = HDA_FIXUP_PINS,
8622         .v.pins = (const struct hda_pintbl[]) {
8623             { 0x14, 0x99130110 }, /* speaker */
8624             { 0x15, 0x0121401f }, /* HP out */
8625             { 0x18, 0x01a19c20 }, /* rear  mic */
8626             { 0x19, 0x99a3092f }, /* front mic */
8627             { 0x1b, 0x0201401f }, /* front lineout */
8628             { }
8629         },
8630         .chain_id = ALC269_FIXUP_DMIC,
8631     },
8632     [ALC256_FIXUP_INTEL_NUC8_RUGGED] = {
8633         .type = HDA_FIXUP_PINS,
8634         .v.pins = (const struct hda_pintbl[]) {
8635             { 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8636             { }
8637         },
8638         .chained = true,
8639         .chain_id = ALC269_FIXUP_HEADSET_MODE
8640     },
8641     [ALC256_FIXUP_INTEL_NUC10] = {
8642         .type = HDA_FIXUP_PINS,
8643         .v.pins = (const struct hda_pintbl[]) {
8644             { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8645             { }
8646         },
8647         .chained = true,
8648         .chain_id = ALC269_FIXUP_HEADSET_MODE
8649     },
8650     [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = {
8651         .type = HDA_FIXUP_VERBS,
8652         .v.verbs = (const struct hda_verb[]) {
8653             { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8654             { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8655             { }
8656         },
8657         .chained = true,
8658         .chain_id = ALC289_FIXUP_ASUS_GA502
8659     },
8660     [ALC274_FIXUP_HP_MIC] = {
8661         .type = HDA_FIXUP_VERBS,
8662         .v.verbs = (const struct hda_verb[]) {
8663             { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8664             { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8665             { }
8666         },
8667     },
8668     [ALC274_FIXUP_HP_HEADSET_MIC] = {
8669         .type = HDA_FIXUP_FUNC,
8670         .v.func = alc274_fixup_hp_headset_mic,
8671         .chained = true,
8672         .chain_id = ALC274_FIXUP_HP_MIC
8673     },
8674     [ALC274_FIXUP_HP_ENVY_GPIO] = {
8675         .type = HDA_FIXUP_FUNC,
8676         .v.func = alc274_fixup_hp_envy_gpio,
8677     },
8678     [ALC256_FIXUP_ASUS_HPE] = {
8679         .type = HDA_FIXUP_VERBS,
8680         .v.verbs = (const struct hda_verb[]) {
8681             /* Set EAPD high */
8682             { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8683             { 0x20, AC_VERB_SET_PROC_COEF, 0x7778 },
8684             { }
8685         },
8686         .chained = true,
8687         .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8688     },
8689     [ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = {
8690         .type = HDA_FIXUP_FUNC,
8691         .v.func = alc_fixup_headset_jack,
8692         .chained = true,
8693         .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8694     },
8695     [ALC287_FIXUP_HP_GPIO_LED] = {
8696         .type = HDA_FIXUP_FUNC,
8697         .v.func = alc287_fixup_hp_gpio_led,
8698     },
8699     [ALC256_FIXUP_HP_HEADSET_MIC] = {
8700         .type = HDA_FIXUP_FUNC,
8701         .v.func = alc274_fixup_hp_headset_mic,
8702     },
8703     [ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = {
8704         .type = HDA_FIXUP_FUNC,
8705         .v.func = alc_fixup_no_int_mic,
8706         .chained = true,
8707         .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8708     },
8709     [ALC282_FIXUP_ACER_DISABLE_LINEOUT] = {
8710         .type = HDA_FIXUP_PINS,
8711         .v.pins = (const struct hda_pintbl[]) {
8712             { 0x1b, 0x411111f0 },
8713             { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8714             { },
8715         },
8716         .chained = true,
8717         .chain_id = ALC269_FIXUP_HEADSET_MODE
8718     },
8719     [ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = {
8720         .type = HDA_FIXUP_FUNC,
8721         .v.func = alc269_fixup_limit_int_mic_boost,
8722         .chained = true,
8723         .chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
8724     },
8725     [ALC256_FIXUP_ACER_HEADSET_MIC] = {
8726         .type = HDA_FIXUP_PINS,
8727         .v.pins = (const struct hda_pintbl[]) {
8728             { 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */
8729             { 0x1a, 0x90a1092f }, /* use as internal mic */
8730             { }
8731         },
8732         .chained = true,
8733         .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8734     },
8735     [ALC285_FIXUP_IDEAPAD_S740_COEF] = {
8736         .type = HDA_FIXUP_FUNC,
8737         .v.func = alc285_fixup_ideapad_s740_coef,
8738         .chained = true,
8739         .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8740     },
8741     [ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
8742         .type = HDA_FIXUP_FUNC,
8743         .v.func = alc269_fixup_limit_int_mic_boost,
8744         .chained = true,
8745         .chain_id = ALC285_FIXUP_HP_MUTE_LED,
8746     },
8747     [ALC295_FIXUP_ASUS_DACS] = {
8748         .type = HDA_FIXUP_FUNC,
8749         .v.func = alc295_fixup_asus_dacs,
8750     },
8751     [ALC295_FIXUP_HP_OMEN] = {
8752         .type = HDA_FIXUP_PINS,
8753         .v.pins = (const struct hda_pintbl[]) {
8754             { 0x12, 0xb7a60130 },
8755             { 0x13, 0x40000000 },
8756             { 0x14, 0x411111f0 },
8757             { 0x16, 0x411111f0 },
8758             { 0x17, 0x90170110 },
8759             { 0x18, 0x411111f0 },
8760             { 0x19, 0x02a11030 },
8761             { 0x1a, 0x411111f0 },
8762             { 0x1b, 0x04a19030 },
8763             { 0x1d, 0x40600001 },
8764             { 0x1e, 0x411111f0 },
8765             { 0x21, 0x03211020 },
8766             {}
8767         },
8768         .chained = true,
8769         .chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED,
8770     },
8771     [ALC285_FIXUP_HP_SPECTRE_X360] = {
8772         .type = HDA_FIXUP_FUNC,
8773         .v.func = alc285_fixup_hp_spectre_x360,
8774     },
8775     [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
8776         .type = HDA_FIXUP_FUNC,
8777         .v.func = alc285_fixup_hp_spectre_x360_eb1
8778     },
8779     [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
8780         .type = HDA_FIXUP_FUNC,
8781         .v.func = alc285_fixup_ideapad_s740_coef,
8782         .chained = true,
8783         .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
8784     },
8785     [ALC623_FIXUP_LENOVO_THINKSTATION_P340] = {
8786         .type = HDA_FIXUP_FUNC,
8787         .v.func = alc_fixup_no_shutup,
8788         .chained = true,
8789         .chain_id = ALC283_FIXUP_HEADSET_MIC,
8790     },
8791     [ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = {
8792         .type = HDA_FIXUP_PINS,
8793         .v.pins = (const struct hda_pintbl[]) {
8794             { 0x21, 0x03211030 }, /* Change the Headphone location to Left */
8795             { }
8796         },
8797         .chained = true,
8798         .chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC
8799     },
8800     [ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
8801         .type = HDA_FIXUP_FUNC,
8802         .v.func = alc269_fixup_limit_int_mic_boost,
8803         .chained = true,
8804         .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
8805     },
8806     [ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = {
8807         .type = HDA_FIXUP_FUNC,
8808         .v.func = alc285_fixup_ideapad_s740_coef,
8809         .chained = true,
8810         .chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
8811     },
8812     [ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = {
8813         .type = HDA_FIXUP_FUNC,
8814         .v.func = alc287_fixup_legion_15imhg05_speakers,
8815         .chained = true,
8816         .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8817     },
8818     [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
8819         .type = HDA_FIXUP_VERBS,
8820         //.v.verbs = legion_15imhg05_coefs,
8821         .v.verbs = (const struct hda_verb[]) {
8822              // set left speaker Legion 7i.
8823              { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
8824              { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
8825
8826              { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8827              { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
8828              { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8829              { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
8830              { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8831
8832              { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8833              { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
8834              { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8835              { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8836              { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8837
8838              // set right speaker Legion 7i.
8839              { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
8840              { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
8841
8842              { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8843              { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
8844              { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8845              { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
8846              { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8847
8848              { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8849              { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
8850              { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8851              { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8852              { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8853              {}
8854         },
8855         .chained = true,
8856         .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
8857     },
8858     [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
8859         .type = HDA_FIXUP_FUNC,
8860         .v.func = alc287_fixup_legion_15imhg05_speakers,
8861         .chained = true,
8862         .chain_id = ALC269_FIXUP_HEADSET_MODE,
8863     },
8864     [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
8865         .type = HDA_FIXUP_VERBS,
8866         .v.verbs = (const struct hda_verb[]) {
8867              // set left speaker Yoga 7i.
8868              { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
8869              { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
8870
8871              { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8872              { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
8873              { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8874              { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
8875              { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8876
8877              { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8878              { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
8879              { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8880              { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8881              { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8882
8883              // set right speaker Yoga 7i.
8884              { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
8885              { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
8886
8887              { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8888              { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
8889              { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8890              { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
8891              { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8892
8893              { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8894              { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
8895              { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8896              { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8897              { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8898              {}
8899         },
8900         .chained = true,
8901         .chain_id = ALC269_FIXUP_HEADSET_MODE,
8902     },
8903     [ALC298_FIXUP_LENOVO_C940_DUET7] = {
8904         .type = HDA_FIXUP_FUNC,
8905         .v.func = alc298_fixup_lenovo_c940_duet7,
8906     },
8907     [ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
8908         .type = HDA_FIXUP_VERBS,
8909         .v.verbs = (const struct hda_verb[]) {
8910             { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
8911             { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
8912             { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8913             { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
8914             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8915             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8916             { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8917             { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
8918             { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
8919             { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
8920             { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
8921             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8922             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
8923             { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
8924             {}
8925         },
8926         .chained = true,
8927         .chain_id = ALC269_FIXUP_HEADSET_MODE,
8928     },
8929     [ALC256_FIXUP_SET_COEF_DEFAULTS] = {
8930         .type = HDA_FIXUP_FUNC,
8931         .v.func = alc256_fixup_set_coef_defaults,
8932     },
8933     [ALC245_FIXUP_HP_GPIO_LED] = {
8934         .type = HDA_FIXUP_FUNC,
8935         .v.func = alc245_fixup_hp_gpio_led,
8936     },
8937     [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
8938         .type = HDA_FIXUP_PINS,
8939         .v.pins = (const struct hda_pintbl[]) {
8940             { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
8941             { }
8942         },
8943         .chained = true,
8944         .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
8945     },
8946     [ALC233_FIXUP_NO_AUDIO_JACK] = {
8947         .type = HDA_FIXUP_FUNC,
8948         .v.func = alc233_fixup_no_audio_jack,
8949     },
8950     [ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = {
8951         .type = HDA_FIXUP_FUNC,
8952         .v.func = alc256_fixup_mic_no_presence_and_resume,
8953         .chained = true,
8954         .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8955     },
8956     [ALC287_FIXUP_LEGION_16ACHG6] = {
8957         .type = HDA_FIXUP_FUNC,
8958         .v.func = alc287_fixup_legion_16achg6_speakers,
8959     },
8960     [ALC287_FIXUP_CS35L41_I2C_2] = {
8961         .type = HDA_FIXUP_FUNC,
8962         .v.func = cs35l41_fixup_i2c_two,
8963         .chained = true,
8964         .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8965     },
8966     [ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = {
8967         .type = HDA_FIXUP_FUNC,
8968         .v.func = cs35l41_fixup_i2c_two,
8969         .chained = true,
8970         .chain_id = ALC285_FIXUP_HP_MUTE_LED,
8971     },
8972     [ALC245_FIXUP_CS35L41_SPI_2] = {
8973         .type = HDA_FIXUP_FUNC,
8974         .v.func = cs35l41_fixup_spi_two,
8975     },
8976     [ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = {
8977         .type = HDA_FIXUP_FUNC,
8978         .v.func = cs35l41_fixup_spi_two,
8979         .chained = true,
8980         .chain_id = ALC285_FIXUP_HP_GPIO_LED,
8981     },
8982     [ALC245_FIXUP_CS35L41_SPI_4] = {
8983         .type = HDA_FIXUP_FUNC,
8984         .v.func = cs35l41_fixup_spi_four,
8985     },
8986     [ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = {
8987         .type = HDA_FIXUP_FUNC,
8988         .v.func = cs35l41_fixup_spi_four,
8989         .chained = true,
8990         .chain_id = ALC285_FIXUP_HP_GPIO_LED,
8991     },
8992     [ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = {
8993         .type = HDA_FIXUP_VERBS,
8994         .v.verbs = (const struct hda_verb[]) {
8995              { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 },
8996              { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 },
8997              { }
8998         },
8999         .chained = true,
9000         .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9001     },
9002     [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = {
9003         .type = HDA_FIXUP_FUNC,
9004         .v.func = alc_fixup_dell4_mic_no_presence_quiet,
9005         .chained = true,
9006         .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9007     },
9008     [ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = {
9009         .type = HDA_FIXUP_PINS,
9010         .v.pins = (const struct hda_pintbl[]) {
9011             { 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */
9012             { }
9013         },
9014         .chained = true,
9015         .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9016     },
9017     [ALC287_FIXUP_LEGION_16ITHG6] = {
9018         .type = HDA_FIXUP_FUNC,
9019         .v.func = alc287_fixup_legion_16ithg6_speakers,
9020     },
9021     [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = {
9022         .type = HDA_FIXUP_VERBS,
9023         .v.verbs = (const struct hda_verb[]) {
9024             // enable left speaker
9025             { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9026             { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9027
9028             { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9029             { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9030             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9031             { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9032             { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9033
9034             { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9035             { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9036             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9037             { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9038             { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9039
9040             { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9041             { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9042             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9043             { 0x20, AC_VERB_SET_PROC_COEF, 0x40 },
9044             { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9045
9046             { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9047             { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9048             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9049             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9050             { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9051
9052             // enable right speaker
9053             { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9054             { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9055
9056             { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9057             { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9058             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9059             { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9060             { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9061
9062             { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9063             { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9064             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9065             { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9066             { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9067
9068             { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9069             { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9070             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9071             { 0x20, AC_VERB_SET_PROC_COEF, 0x44 },
9072             { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9073
9074             { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9075             { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9076             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9077             { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9078             { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9079
9080             { },
9081         },
9082     },
9083     [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = {
9084         .type = HDA_FIXUP_FUNC,
9085         .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
9086         .chained = true,
9087         .chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
9088     },
9089 };
9090
9091 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
9092     SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
9093     SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
9094     SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
9095     SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
9096     SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9097     SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
9098     SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
9099     SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9100     SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9101     SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
9102     SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9103     SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF),
9104     SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK),
9105     SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
9106     SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC),
9107     SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
9108     SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
9109     SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9110     SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9111     SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK),
9112     SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK),
9113     SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
9114     SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
9115     SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE),
9116     SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC),
9117     SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9118     SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9119     SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9120     SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
9121     SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9122     SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9123     SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9124     SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
9125     SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
9126     SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9127     SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9128     SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9129     SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
9130     SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
9131     SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
9132     SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
9133     SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
9134     SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
9135     SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
9136     SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
9137     SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
9138     SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9139     SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9140     SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9141     SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9142     SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9143     SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
9144     SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
9145     SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
9146     SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9147     SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9148     SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
9149     SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9150     SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
9151     SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9152     SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9153     SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9154     SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9155     SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9156     SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9157     SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9158     SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9159     SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9160     SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
9161     SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
9162     SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
9163     SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
9164     SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9165     SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
9166     SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
9167     SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9168     SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9169     SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9170     SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9171     SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
9172     SND_PCI_QUIRK(0x1028, 0x087d, "Dell Precision 5530", ALC289_FIXUP_DUAL_SPK),
9173     SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
9174     SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
9175     SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9176     SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9177     SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9178     SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9179     SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9180     SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9181     SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9182     SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET),
9183     SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
9184     SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
9185     SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
9186     SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9187     SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9188     SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
9189     SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK),
9190     SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9191     SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9192     SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
9193     SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
9194     SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
9195     SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9196     SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9197     SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9198     SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9199     SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
9200     SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9201     SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9202     SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9203     SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9204     SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9205     SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9206     SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9207     SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9208     SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9209     SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9210     SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9211     SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9212     SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9213     SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
9214     SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
9215     SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9216     SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9217     SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9218     SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9219     SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9220     SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9221     SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9222     SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9223     SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
9224     SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9225     SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9226     SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9227     SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9228     SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9229     SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9230     SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9231     SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9232     SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9233     SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9234     SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9235     SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9236     SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9237     SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9238     SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9239     SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9240     SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9241     SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9242     SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
9243     SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9244     SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9245     SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9246     SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9247     SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9248     SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9249     SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
9250     SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9251     SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9252     SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9253     SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9254     SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9255     SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
9256     SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
9257     SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9258     SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9259     SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9260     SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9261     SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9262     SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9263     SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN),
9264     SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9265     SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
9266     SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9267     SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9268     SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9269     SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
9270     SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9271     SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9272     SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9273     SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9274     SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
9275     SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
9276     SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
9277     SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9278     SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9279     SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9280     SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
9281     SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
9282     SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9283     SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation",
9284               ALC285_FIXUP_HP_GPIO_AMP_INIT),
9285     SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
9286               ALC285_FIXUP_HP_GPIO_AMP_INIT),
9287     SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9288     SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9289     SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9290     SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
9291     SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9292     SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9293     SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9294     SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9295     SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED),
9296     SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
9297     SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9298     SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9299     SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9300     SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9301     SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9302     SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9303     SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9304     SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9305     SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9306     SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9307     SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9308     SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9309     SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9310     SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9311     SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9312     SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
9313     SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED),
9314     SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
9315     SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9316     SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
9317     SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED),
9318     SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9319     SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9320     SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9321     SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9322     SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9323     SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9324     SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4),
9325     SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
9326     SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
9327     SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9328     SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2),
9329     SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9330     SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2),
9331     SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED),
9332     SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED),
9333     SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
9334     SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED),
9335     SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED),
9336     SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9337     SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9338     SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9339     SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9340     SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
9341     SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
9342     SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
9343     SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED),
9344     SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9345     SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9346     SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
9347     SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
9348     SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9349     SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
9350     SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
9351     SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9352     SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9353     SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9354     SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9355     SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
9356     SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
9357     SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
9358     SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
9359     SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
9360     SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
9361     SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE),
9362     SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
9363     SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
9364     SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
9365     SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK),
9366     SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
9367     SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
9368     SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS),
9369     SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
9370     SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS),
9371     SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
9372     SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
9373     SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
9374     SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
9375     SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
9376     SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
9377     SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
9378     SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
9379     SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
9380     SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
9381     SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
9382     SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
9383     SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9384     SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9385     SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS),
9386     SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
9387     SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401),
9388     SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE),
9389     SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
9390     SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
9391     SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS),
9392     SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
9393     SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401),
9394     SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
9395     SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
9396     SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
9397     SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
9398     SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
9399     SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
9400     SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
9401     SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
9402     SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
9403     SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
9404     SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
9405     SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
9406     SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
9407     SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
9408     SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
9409     SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
9410     SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
9411     SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
9412     SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
9413     SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
9414     SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
9415     SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
9416     SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
9417     SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
9418     SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE),
9419     SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
9420     SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
9421     SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP),
9422     SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP),
9423     SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
9424     SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
9425     SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
9426     SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP),
9427     SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
9428     SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
9429     SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
9430     SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
9431     SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK),
9432     SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9433     SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9434     SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9435     SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9436     SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9437     SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9438     SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9439     SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9440     SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9441     SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9442     SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9443     SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9444     SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9445     SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9446     SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9447     SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9448     SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9449     SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9450     SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9451     SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9452     SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9453     SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9454     SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9455     SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9456     SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9457     SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9458     SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9459     SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9460     SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9461     SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9462     SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9463     SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9464     SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9465     SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9466     SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9467     SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9468     SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9469     SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9470     SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9471     SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9472     SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9473     SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9474     SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9475     SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9476     SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9477     SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9478     SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
9479     SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
9480     SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
9481     SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9482     SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9483     SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9484     SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9485     SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9486     SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME),
9487     SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9488     SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9489     SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9490     SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9491     SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9492     SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9493     SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9494     SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9495     SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9496     SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9497     SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9498     SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9499     SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9500     SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9501     SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9502     SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
9503     SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
9504     SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
9505     SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
9506     SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
9507     SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
9508     SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
9509     SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
9510     SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
9511     SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
9512     SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
9513     SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
9514     SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
9515     SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
9516     SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
9517     SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
9518     SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
9519     SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
9520     SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
9521     SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9522     SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
9523     SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
9524     SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
9525     SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
9526     SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
9527     SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
9528     SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
9529     SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
9530     SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
9531     SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
9532     SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
9533     SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
9534     SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
9535     SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
9536     SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9537     SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
9538     SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
9539     SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
9540     SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
9541     SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2),
9542     SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2),
9543     SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_CS35L41_I2C_2),
9544     SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
9545     SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
9546     SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
9547     SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
9548     SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
9549     SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
9550     SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
9551     SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
9552     SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
9553     SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
9554     SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
9555     SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
9556     SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga DuetITL 2021", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
9557     SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
9558     SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
9559     SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
9560     SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
9561     SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
9562     SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
9563     SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
9564     SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
9565     SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
9566     SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6),
9567     SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
9568     SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
9569     SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
9570     SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6),
9571     SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
9572     SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
9573     SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
9574     SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
9575     SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
9576     SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9577     SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
9578     SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
9579     SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9580     SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
9581     SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
9582     SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
9583     SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
9584     SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
9585     SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
9586     SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
9587     SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
9588     SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
9589     SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
9590     SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
9591     SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
9592     SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9593     SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
9594     SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
9595     SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
9596     SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK),
9597     SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
9598     SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
9599     SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
9600     SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI),
9601     SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101),
9602     SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
9603     SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
9604     SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
9605     SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
9606     SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
9607     SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
9608     SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
9609     SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
9610     SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
9611     SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
9612     SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
9613     SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
9614     SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
9615     SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
9616     SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
9617     SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
9618     SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
9619     SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
9620     SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
9621     SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
9622     SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
9623
9624 #if 0
9625     /* Below is a quirk table taken from the old code.
9626      * Basically the device should work as is without the fixup table.
9627      * If BIOS doesn't give a proper info, enable the corresponding
9628      * fixup entry.
9629      */
9630     SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
9631               ALC269_FIXUP_AMIC),
9632     SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
9633     SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
9634     SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
9635     SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
9636     SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
9637     SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
9638     SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
9639     SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
9640     SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
9641     SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
9642     SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
9643     SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
9644     SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
9645     SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
9646     SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
9647     SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
9648     SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
9649     SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
9650     SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
9651     SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
9652     SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
9653     SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
9654     SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
9655     SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
9656     SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
9657     SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
9658     SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
9659     SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
9660     SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
9661     SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
9662     SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
9663     SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
9664     SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
9665     SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
9666     SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
9667     SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
9668     SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
9669     SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
9670     SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
9671 #endif
9672     {}
9673 };
9674
9675 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
9676     SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
9677     SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
9678     SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
9679     SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
9680     SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
9681     {}
9682 };
9683
9684 static const struct hda_model_fixup alc269_fixup_models[] = {
9685     {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
9686     {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
9687     {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
9688     {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
9689     {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
9690     {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
9691     {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
9692     {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
9693     {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
9694     {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
9695     {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
9696     {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
9697     {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
9698     {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
9699     {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
9700     {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
9701     {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
9702     {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
9703     {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
9704     {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
9705     {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
9706     {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
9707     {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
9708     {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
9709     {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
9710     {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
9711     {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
9712     {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
9713     {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
9714     {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
9715     {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
9716     {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
9717     {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
9718     {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
9719     {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
9720     {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
9721     {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
9722     {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
9723     {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
9724     {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
9725     {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
9726     {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
9727     {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
9728     {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
9729     {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
9730     {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
9731     {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
9732     {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
9733     {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
9734     {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
9735     {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
9736     {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
9737     {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
9738     {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
9739     {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
9740     {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
9741     {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
9742     {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
9743     {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
9744     {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
9745     {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
9746     {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
9747     {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
9748     {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
9749     {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
9750     {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
9751     {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
9752     {.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"},
9753     {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
9754     {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
9755     {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
9756     {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
9757     {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
9758     {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
9759     {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
9760     {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
9761     {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
9762     {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
9763     {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
9764     {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
9765     {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
9766     {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
9767     {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
9768     {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
9769     {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
9770     {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
9771     {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
9772     {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
9773     {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
9774     {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
9775     {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
9776     {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
9777     {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
9778     {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
9779     {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
9780     {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
9781     {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
9782     {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
9783     {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
9784     {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
9785     {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
9786     {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
9787     {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
9788     {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
9789     {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
9790     {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
9791     {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
9792     {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
9793     {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
9794     {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
9795     {.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"},
9796     {.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"},
9797     {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
9798     {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
9799     {.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"},
9800     {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
9801     {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
9802     {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
9803     {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
9804     {.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"},
9805     {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
9806     {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
9807     {.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"},
9808     {}
9809 };
9810 #define ALC225_STANDARD_PINS \
9811     {0x21, 0x04211020}
9812
9813 #define ALC256_STANDARD_PINS \
9814     {0x12, 0x90a60140}, \
9815     {0x14, 0x90170110}, \
9816     {0x21, 0x02211020}
9817
9818 #define ALC282_STANDARD_PINS \
9819     {0x14, 0x90170110}
9820
9821 #define ALC290_STANDARD_PINS \
9822     {0x12, 0x99a30130}
9823
9824 #define ALC292_STANDARD_PINS \
9825     {0x14, 0x90170110}, \
9826     {0x15, 0x0221401f}
9827
9828 #define ALC295_STANDARD_PINS \
9829     {0x12, 0xb7a60130}, \
9830     {0x14, 0x90170110}, \
9831     {0x21, 0x04211020}
9832
9833 #define ALC298_STANDARD_PINS \
9834     {0x12, 0x90a60130}, \
9835     {0x21, 0x03211020}
9836
9837 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
9838     SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
9839         {0x14, 0x01014020},
9840         {0x17, 0x90170110},
9841         {0x18, 0x02a11030},
9842         {0x19, 0x0181303F},
9843         {0x21, 0x0221102f}),
9844     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
9845         {0x12, 0x90a601c0},
9846         {0x14, 0x90171120},
9847         {0x21, 0x02211030}),
9848     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
9849         {0x14, 0x90170110},
9850         {0x1b, 0x90a70130},
9851         {0x21, 0x03211020}),
9852     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
9853         {0x1a, 0x90a70130},
9854         {0x1b, 0x90170110},
9855         {0x21, 0x03211020}),
9856     SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
9857         ALC225_STANDARD_PINS,
9858         {0x12, 0xb7a60130},
9859         {0x14, 0x901701a0}),
9860     SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
9861         ALC225_STANDARD_PINS,
9862         {0x12, 0xb7a60130},
9863         {0x14, 0x901701b0}),
9864     SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
9865         ALC225_STANDARD_PINS,
9866         {0x12, 0xb7a60150},
9867         {0x14, 0x901701a0}),
9868     SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
9869         ALC225_STANDARD_PINS,
9870         {0x12, 0xb7a60150},
9871         {0x14, 0x901701b0}),
9872     SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
9873         ALC225_STANDARD_PINS,
9874         {0x12, 0xb7a60130},
9875         {0x1b, 0x90170110}),
9876     SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
9877         {0x1b, 0x01111010},
9878         {0x1e, 0x01451130},
9879         {0x21, 0x02211020}),
9880     SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
9881         {0x12, 0x90a60140},
9882         {0x14, 0x90170110},
9883         {0x19, 0x02a11030},
9884         {0x21, 0x02211020}),
9885     SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
9886         {0x14, 0x90170110},
9887         {0x19, 0x02a11030},
9888         {0x1a, 0x02a11040},
9889         {0x1b, 0x01014020},
9890         {0x21, 0x0221101f}),
9891     SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
9892         {0x14, 0x90170110},
9893         {0x19, 0x02a11030},
9894         {0x1a, 0x02a11040},
9895         {0x1b, 0x01011020},
9896         {0x21, 0x0221101f}),
9897     SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
9898         {0x14, 0x90170110},
9899         {0x19, 0x02a11020},
9900         {0x1a, 0x02a11030},
9901         {0x21, 0x0221101f}),
9902     SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
9903         {0x21, 0x02211010}),
9904     SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
9905         {0x14, 0x90170110},
9906         {0x19, 0x02a11020},
9907         {0x21, 0x02211030}),
9908     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
9909         {0x14, 0x90170110},
9910         {0x21, 0x02211020}),
9911     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9912         {0x14, 0x90170130},
9913         {0x21, 0x02211040}),
9914     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9915         {0x12, 0x90a60140},
9916         {0x14, 0x90170110},
9917         {0x21, 0x02211020}),
9918     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9919         {0x12, 0x90a60160},
9920         {0x14, 0x90170120},
9921         {0x21, 0x02211030}),
9922     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9923         {0x14, 0x90170110},
9924         {0x1b, 0x02011020},
9925         {0x21, 0x0221101f}),
9926     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9927         {0x14, 0x90170110},
9928         {0x1b, 0x01011020},
9929         {0x21, 0x0221101f}),
9930     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9931         {0x14, 0x90170130},
9932         {0x1b, 0x01014020},
9933         {0x21, 0x0221103f}),
9934     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9935         {0x14, 0x90170130},
9936         {0x1b, 0x01011020},
9937         {0x21, 0x0221103f}),
9938     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9939         {0x14, 0x90170130},
9940         {0x1b, 0x02011020},
9941         {0x21, 0x0221103f}),
9942     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9943         {0x14, 0x90170150},
9944         {0x1b, 0x02011020},
9945         {0x21, 0x0221105f}),
9946     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9947         {0x14, 0x90170110},
9948         {0x1b, 0x01014020},
9949         {0x21, 0x0221101f}),
9950     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9951         {0x12, 0x90a60160},
9952         {0x14, 0x90170120},
9953         {0x17, 0x90170140},
9954         {0x21, 0x0321102f}),
9955     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9956         {0x12, 0x90a60160},
9957         {0x14, 0x90170130},
9958         {0x21, 0x02211040}),
9959     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9960         {0x12, 0x90a60160},
9961         {0x14, 0x90170140},
9962         {0x21, 0x02211050}),
9963     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9964         {0x12, 0x90a60170},
9965         {0x14, 0x90170120},
9966         {0x21, 0x02211030}),
9967     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9968         {0x12, 0x90a60170},
9969         {0x14, 0x90170130},
9970         {0x21, 0x02211040}),
9971     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9972         {0x12, 0x90a60170},
9973         {0x14, 0x90171130},
9974         {0x21, 0x02211040}),
9975     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9976         {0x12, 0x90a60170},
9977         {0x14, 0x90170140},
9978         {0x21, 0x02211050}),
9979     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9980         {0x12, 0x90a60180},
9981         {0x14, 0x90170130},
9982         {0x21, 0x02211040}),
9983     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9984         {0x12, 0x90a60180},
9985         {0x14, 0x90170120},
9986         {0x21, 0x02211030}),
9987     SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9988         {0x1b, 0x01011020},
9989         {0x21, 0x02211010}),
9990     SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
9991         {0x14, 0x90170110},
9992         {0x1b, 0x90a70130},
9993         {0x21, 0x04211020}),
9994     SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
9995         {0x14, 0x90170110},
9996         {0x1b, 0x90a70130},
9997         {0x21, 0x03211020}),
9998     SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
9999         {0x12, 0x90a60130},
10000         {0x14, 0x90170110},
10001         {0x21, 0x03211020}),
10002     SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10003         {0x12, 0x90a60130},
10004         {0x14, 0x90170110},
10005         {0x21, 0x04211020}),
10006     SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10007         {0x1a, 0x90a70130},
10008         {0x1b, 0x90170110},
10009         {0x21, 0x03211020}),
10010        SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10011         {0x14, 0x90170110},
10012         {0x19, 0x02a11020},
10013         {0x21, 0x0221101f}),
10014        SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC,
10015         {0x17, 0x90170110},
10016         {0x19, 0x03a11030},
10017         {0x21, 0x03211020}),
10018     SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
10019         {0x12, 0x90a60130},
10020         {0x14, 0x90170110},
10021         {0x15, 0x0421101f},
10022         {0x1a, 0x04a11020}),
10023     SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
10024         {0x12, 0x90a60140},
10025         {0x14, 0x90170110},
10026         {0x15, 0x0421101f},
10027         {0x18, 0x02811030},
10028         {0x1a, 0x04a1103f},
10029         {0x1b, 0x02011020}),
10030     SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10031         ALC282_STANDARD_PINS,
10032         {0x12, 0x99a30130},
10033         {0x19, 0x03a11020},
10034         {0x21, 0x0321101f}),
10035     SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10036         ALC282_STANDARD_PINS,
10037         {0x12, 0x99a30130},
10038         {0x19, 0x03a11020},
10039         {0x21, 0x03211040}),
10040     SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10041         ALC282_STANDARD_PINS,
10042         {0x12, 0x99a30130},
10043         {0x19, 0x03a11030},
10044         {0x21, 0x03211020}),
10045     SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10046         ALC282_STANDARD_PINS,
10047         {0x12, 0x99a30130},
10048         {0x19, 0x04a11020},
10049         {0x21, 0x0421101f}),
10050     SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
10051         ALC282_STANDARD_PINS,
10052         {0x12, 0x90a60140},
10053         {0x19, 0x04a11030},
10054         {0x21, 0x04211020}),
10055     SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10056         ALC282_STANDARD_PINS,
10057         {0x12, 0x90a609c0},
10058         {0x18, 0x03a11830},
10059         {0x19, 0x04a19831},
10060         {0x1a, 0x0481303f},
10061         {0x1b, 0x04211020},
10062         {0x21, 0x0321101f}),
10063     SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10064         ALC282_STANDARD_PINS,
10065         {0x12, 0x90a60940},
10066         {0x18, 0x03a11830},
10067         {0x19, 0x04a19831},
10068         {0x1a, 0x0481303f},
10069         {0x1b, 0x04211020},
10070         {0x21, 0x0321101f}),
10071     SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10072         ALC282_STANDARD_PINS,
10073         {0x12, 0x90a60130},
10074         {0x21, 0x0321101f}),
10075     SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10076         {0x12, 0x90a60160},
10077         {0x14, 0x90170120},
10078         {0x21, 0x02211030}),
10079     SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10080         ALC282_STANDARD_PINS,
10081         {0x12, 0x90a60130},
10082         {0x19, 0x03a11020},
10083         {0x21, 0x0321101f}),
10084     SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10085         {0x12, 0x90a60130},
10086         {0x14, 0x90170110},
10087         {0x19, 0x04a11040},
10088         {0x21, 0x04211020}),
10089     SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10090         {0x14, 0x90170110},
10091         {0x19, 0x04a11040},
10092         {0x1d, 0x40600001},
10093         {0x21, 0x04211020}),
10094     SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
10095         {0x14, 0x90170110},
10096         {0x19, 0x04a11040},
10097         {0x21, 0x04211020}),
10098     SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK,
10099         {0x14, 0x90170110},
10100         {0x17, 0x90170111},
10101         {0x19, 0x03a11030},
10102         {0x21, 0x03211020}),
10103     SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
10104         {0x12, 0x90a60130},
10105         {0x17, 0x90170110},
10106         {0x21, 0x02211020}),
10107     SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
10108         {0x12, 0x90a60120},
10109         {0x14, 0x90170110},
10110         {0x21, 0x0321101f}),
10111     SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10112         ALC290_STANDARD_PINS,
10113         {0x15, 0x04211040},
10114         {0x18, 0x90170112},
10115         {0x1a, 0x04a11020}),
10116     SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10117         ALC290_STANDARD_PINS,
10118         {0x15, 0x04211040},
10119         {0x18, 0x90170110},
10120         {0x1a, 0x04a11020}),
10121     SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10122         ALC290_STANDARD_PINS,
10123         {0x15, 0x0421101f},
10124         {0x1a, 0x04a11020}),
10125     SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10126         ALC290_STANDARD_PINS,
10127         {0x15, 0x04211020},
10128         {0x1a, 0x04a11040}),
10129     SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10130         ALC290_STANDARD_PINS,
10131         {0x14, 0x90170110},
10132         {0x15, 0x04211020},
10133         {0x1a, 0x04a11040}),
10134     SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10135         ALC290_STANDARD_PINS,
10136         {0x14, 0x90170110},
10137         {0x15, 0x04211020},
10138         {0x1a, 0x04a11020}),
10139     SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10140         ALC290_STANDARD_PINS,
10141         {0x14, 0x90170110},
10142         {0x15, 0x0421101f},
10143         {0x1a, 0x04a11020}),
10144     SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
10145         ALC292_STANDARD_PINS,
10146         {0x12, 0x90a60140},
10147         {0x16, 0x01014020},
10148         {0x19, 0x01a19030}),
10149     SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
10150         ALC292_STANDARD_PINS,
10151         {0x12, 0x90a60140},
10152         {0x16, 0x01014020},
10153         {0x18, 0x02a19031},
10154         {0x19, 0x01a1903e}),
10155     SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
10156         ALC292_STANDARD_PINS,
10157         {0x12, 0x90a60140}),
10158     SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
10159         ALC292_STANDARD_PINS,
10160         {0x13, 0x90a60140},
10161         {0x16, 0x21014020},
10162         {0x19, 0x21a19030}),
10163     SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
10164         ALC292_STANDARD_PINS,
10165         {0x13, 0x90a60140}),
10166     SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE,
10167         {0x17, 0x90170110},
10168         {0x21, 0x04211020}),
10169     SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
10170         {0x14, 0x90170110},
10171         {0x1b, 0x90a70130},
10172         {0x21, 0x04211020}),
10173     SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10174         {0x12, 0x90a60130},
10175         {0x17, 0x90170110},
10176         {0x21, 0x03211020}),
10177     SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10178         {0x12, 0x90a60130},
10179         {0x17, 0x90170110},
10180         {0x21, 0x04211020}),
10181     SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10182         {0x12, 0x90a60130},
10183         {0x17, 0x90170110},
10184         {0x21, 0x03211020}),
10185     SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10186         {0x12, 0x90a60120},
10187         {0x17, 0x90170110},
10188         {0x21, 0x04211030}),
10189     SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10190         {0x12, 0x90a60130},
10191         {0x17, 0x90170110},
10192         {0x21, 0x03211020}),
10193     SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10194         {0x12, 0x90a60130},
10195         {0x17, 0x90170110},
10196         {0x21, 0x03211020}),
10197     SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10198         {0x14, 0x90170110},
10199         {0x21, 0x04211020}),
10200     SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10201         {0x14, 0x90170110},
10202         {0x21, 0x04211030}),
10203     SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10204         ALC295_STANDARD_PINS,
10205         {0x17, 0x21014020},
10206         {0x18, 0x21a19030}),
10207     SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10208         ALC295_STANDARD_PINS,
10209         {0x17, 0x21014040},
10210         {0x18, 0x21a19050}),
10211     SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10212         ALC295_STANDARD_PINS),
10213     SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10214         ALC298_STANDARD_PINS,
10215         {0x17, 0x90170110}),
10216     SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10217         ALC298_STANDARD_PINS,
10218         {0x17, 0x90170140}),
10219     SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10220         ALC298_STANDARD_PINS,
10221         {0x17, 0x90170150}),
10222     SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
10223         {0x12, 0xb7a60140},
10224         {0x13, 0xb7a60150},
10225         {0x17, 0x90170110},
10226         {0x1a, 0x03011020},
10227         {0x21, 0x03211030}),
10228     SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
10229         {0x12, 0xb7a60140},
10230         {0x17, 0x90170110},
10231         {0x1a, 0x03a11030},
10232         {0x21, 0x03211020}),
10233     SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10234         ALC225_STANDARD_PINS,
10235         {0x12, 0xb7a60130},
10236         {0x17, 0x90170110}),
10237     SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
10238         {0x14, 0x01014010},
10239         {0x17, 0x90170120},
10240         {0x18, 0x02a11030},
10241         {0x19, 0x02a1103f},
10242         {0x21, 0x0221101f}),
10243     {}
10244 };
10245
10246 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
10247  * more machines, don't need to match all valid pins, just need to match
10248  * all the pins defined in the tbl. Just because of this reason, it is possible
10249  * that a single machine matches multiple tbls, so there is one limitation:
10250  *   at most one tbl is allowed to define for the same vendor and same codec
10251  */
10252 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
10253     SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10254         {0x19, 0x40000000},
10255         {0x1b, 0x40000000}),
10256     SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10257         {0x19, 0x40000000},
10258         {0x1a, 0x40000000}),
10259     SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10260         {0x19, 0x40000000},
10261         {0x1a, 0x40000000}),
10262     SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
10263         {0x19, 0x40000000},
10264         {0x1a, 0x40000000}),
10265     {}
10266 };
10267
10268 static void alc269_fill_coef(struct hda_codec *codec)
10269 {
10270     struct alc_spec *spec = codec->spec;
10271     int val;
10272
10273     if (spec->codec_variant != ALC269_TYPE_ALC269VB)
10274         return;
10275
10276     if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
10277         alc_write_coef_idx(codec, 0xf, 0x960b);
10278         alc_write_coef_idx(codec, 0xe, 0x8817);
10279     }
10280
10281     if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
10282         alc_write_coef_idx(codec, 0xf, 0x960b);
10283         alc_write_coef_idx(codec, 0xe, 0x8814);
10284     }
10285
10286     if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
10287         /* Power up output pin */
10288         alc_update_coef_idx(codec, 0x04, 0, 1<<11);
10289     }
10290
10291     if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
10292         val = alc_read_coef_idx(codec, 0xd);
10293         if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
10294             /* Capless ramp up clock control */
10295             alc_write_coef_idx(codec, 0xd, val | (1<<10));
10296         }
10297         val = alc_read_coef_idx(codec, 0x17);
10298         if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
10299             /* Class D power on reset */
10300             alc_write_coef_idx(codec, 0x17, val | (1<<7));
10301         }
10302     }
10303
10304     /* HP */
10305     alc_update_coef_idx(codec, 0x4, 0, 1<<11);
10306 }
10307
10308 /*
10309  */
10310 static int patch_alc269(struct hda_codec *codec)
10311 {
10312     struct alc_spec *spec;
10313     int err;
10314
10315     err = alc_alloc_spec(codec, 0x0b);
10316     if (err < 0)
10317         return err;
10318
10319     spec = codec->spec;
10320     spec->gen.shared_mic_vref_pin = 0x18;
10321     codec->power_save_node = 0;
10322
10323 #ifdef CONFIG_PM
10324     codec->patch_ops.suspend = alc269_suspend;
10325     codec->patch_ops.resume = alc269_resume;
10326 #endif
10327     spec->shutup = alc_default_shutup;
10328     spec->init_hook = alc_default_init;
10329
10330     switch (codec->core.vendor_id) {
10331     case 0x10ec0269:
10332         spec->codec_variant = ALC269_TYPE_ALC269VA;
10333         switch (alc_get_coef0(codec) & 0x00f0) {
10334         case 0x0010:
10335             if (codec->bus->pci &&
10336                 codec->bus->pci->subsystem_vendor == 0x1025 &&
10337                 spec->cdefine.platform_type == 1)
10338                 err = alc_codec_rename(codec, "ALC271X");
10339             spec->codec_variant = ALC269_TYPE_ALC269VB;
10340             break;
10341         case 0x0020:
10342             if (codec->bus->pci &&
10343                 codec->bus->pci->subsystem_vendor == 0x17aa &&
10344                 codec->bus->pci->subsystem_device == 0x21f3)
10345                 err = alc_codec_rename(codec, "ALC3202");
10346             spec->codec_variant = ALC269_TYPE_ALC269VC;
10347             break;
10348         case 0x0030:
10349             spec->codec_variant = ALC269_TYPE_ALC269VD;
10350             break;
10351         default:
10352             alc_fix_pll_init(codec, 0x20, 0x04, 15);
10353         }
10354         if (err < 0)
10355             goto error;
10356         spec->shutup = alc269_shutup;
10357         spec->init_hook = alc269_fill_coef;
10358         alc269_fill_coef(codec);
10359         break;
10360
10361     case 0x10ec0280:
10362     case 0x10ec0290:
10363         spec->codec_variant = ALC269_TYPE_ALC280;
10364         break;
10365     case 0x10ec0282:
10366         spec->codec_variant = ALC269_TYPE_ALC282;
10367         spec->shutup = alc282_shutup;
10368         spec->init_hook = alc282_init;
10369         break;
10370     case 0x10ec0233:
10371     case 0x10ec0283:
10372         spec->codec_variant = ALC269_TYPE_ALC283;
10373         spec->shutup = alc283_shutup;
10374         spec->init_hook = alc283_init;
10375         break;
10376     case 0x10ec0284:
10377     case 0x10ec0292:
10378         spec->codec_variant = ALC269_TYPE_ALC284;
10379         break;
10380     case 0x10ec0293:
10381         spec->codec_variant = ALC269_TYPE_ALC293;
10382         break;
10383     case 0x10ec0286:
10384     case 0x10ec0288:
10385         spec->codec_variant = ALC269_TYPE_ALC286;
10386         break;
10387     case 0x10ec0298:
10388         spec->codec_variant = ALC269_TYPE_ALC298;
10389         break;
10390     case 0x10ec0235:
10391     case 0x10ec0255:
10392         spec->codec_variant = ALC269_TYPE_ALC255;
10393         spec->shutup = alc256_shutup;
10394         spec->init_hook = alc256_init;
10395         break;
10396     case 0x10ec0230:
10397     case 0x10ec0236:
10398     case 0x10ec0256:
10399     case 0x19e58326:
10400         spec->codec_variant = ALC269_TYPE_ALC256;
10401         spec->shutup = alc256_shutup;
10402         spec->init_hook = alc256_init;
10403         spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
10404         break;
10405     case 0x10ec0257:
10406         spec->codec_variant = ALC269_TYPE_ALC257;
10407         spec->shutup = alc256_shutup;
10408         spec->init_hook = alc256_init;
10409         spec->gen.mixer_nid = 0;
10410         break;
10411     case 0x10ec0215:
10412     case 0x10ec0245:
10413     case 0x10ec0285:
10414     case 0x10ec0289:
10415         if (alc_get_coef0(codec) & 0x0010)
10416             spec->codec_variant = ALC269_TYPE_ALC245;
10417         else
10418             spec->codec_variant = ALC269_TYPE_ALC215;
10419         spec->shutup = alc225_shutup;
10420         spec->init_hook = alc225_init;
10421         spec->gen.mixer_nid = 0;
10422         break;
10423     case 0x10ec0225:
10424     case 0x10ec0295:
10425     case 0x10ec0299:
10426         spec->codec_variant = ALC269_TYPE_ALC225;
10427         spec->shutup = alc225_shutup;
10428         spec->init_hook = alc225_init;
10429         spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
10430         break;
10431     case 0x10ec0287:
10432         spec->codec_variant = ALC269_TYPE_ALC287;
10433         spec->shutup = alc225_shutup;
10434         spec->init_hook = alc225_init;
10435         spec->gen.mixer_nid = 0; /* no loopback on ALC287 */
10436         break;
10437     case 0x10ec0234:
10438     case 0x10ec0274:
10439     case 0x10ec0294:
10440         spec->codec_variant = ALC269_TYPE_ALC294;
10441         spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
10442         alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
10443         spec->init_hook = alc294_init;
10444         break;
10445     case 0x10ec0300:
10446         spec->codec_variant = ALC269_TYPE_ALC300;
10447         spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
10448         break;
10449     case 0x10ec0623:
10450         spec->codec_variant = ALC269_TYPE_ALC623;
10451         break;
10452     case 0x10ec0700:
10453     case 0x10ec0701:
10454     case 0x10ec0703:
10455     case 0x10ec0711:
10456         spec->codec_variant = ALC269_TYPE_ALC700;
10457         spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
10458         alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
10459         spec->init_hook = alc294_init;
10460         break;
10461
10462     }
10463
10464     if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
10465         spec->has_alc5505_dsp = 1;
10466         spec->init_hook = alc5505_dsp_init;
10467     }
10468
10469     alc_pre_init(codec);
10470
10471     snd_hda_pick_fixup(codec, alc269_fixup_models,
10472                alc269_fixup_tbl, alc269_fixups);
10473     /* FIXME: both TX300 and ROG Strix G17 have the same SSID, and
10474      * the quirk breaks the latter (bko#214101).
10475      * Clear the wrong entry.
10476      */
10477     if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 &&
10478         codec->core.vendor_id == 0x10ec0294) {
10479         codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n");
10480         codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
10481     }
10482
10483     snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
10484     snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
10485     snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
10486                alc269_fixups);
10487     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
10488
10489     alc_auto_parse_customize_define(codec);
10490
10491     if (has_cdefine_beep(codec))
10492         spec->gen.beep_nid = 0x01;
10493
10494     /* automatic parse from the BIOS config */
10495     err = alc269_parse_auto_config(codec);
10496     if (err < 0)
10497         goto error;
10498
10499     if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
10500         err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
10501         if (err < 0)
10502             goto error;
10503     }
10504
10505     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
10506
10507     return 0;
10508
10509  error:
10510     alc_free(codec);
10511     return err;
10512 }
10513
10514 /*
10515  * ALC861
10516  */
10517
10518 static int alc861_parse_auto_config(struct hda_codec *codec)
10519 {
10520     static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
10521     static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
10522     return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
10523 }
10524
10525 /* Pin config fixes */
10526 enum {
10527     ALC861_FIXUP_FSC_AMILO_PI1505,
10528     ALC861_FIXUP_AMP_VREF_0F,
10529     ALC861_FIXUP_NO_JACK_DETECT,
10530     ALC861_FIXUP_ASUS_A6RP,
10531     ALC660_FIXUP_ASUS_W7J,
10532 };
10533
10534 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
10535 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
10536             const struct hda_fixup *fix, int action)
10537 {
10538     struct alc_spec *spec = codec->spec;
10539     unsigned int val;
10540
10541     if (action != HDA_FIXUP_ACT_INIT)
10542         return;
10543     val = snd_hda_codec_get_pin_target(codec, 0x0f);
10544     if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
10545         val |= AC_PINCTL_IN_EN;
10546     val |= AC_PINCTL_VREF_50;
10547     snd_hda_set_pin_ctl(codec, 0x0f, val);
10548     spec->gen.keep_vref_in_automute = 1;
10549 }
10550
10551 /* suppress the jack-detection */
10552 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
10553                      const struct hda_fixup *fix, int action)
10554 {
10555     if (action == HDA_FIXUP_ACT_PRE_PROBE)
10556         codec->no_jack_detect = 1;
10557 }
10558
10559 static const struct hda_fixup alc861_fixups[] = {
10560     [ALC861_FIXUP_FSC_AMILO_PI1505] = {
10561         .type = HDA_FIXUP_PINS,
10562         .v.pins = (const struct hda_pintbl[]) {
10563             { 0x0b, 0x0221101f }, /* HP */
10564             { 0x0f, 0x90170310 }, /* speaker */
10565             { }
10566         }
10567     },
10568     [ALC861_FIXUP_AMP_VREF_0F] = {
10569         .type = HDA_FIXUP_FUNC,
10570         .v.func = alc861_fixup_asus_amp_vref_0f,
10571     },
10572     [ALC861_FIXUP_NO_JACK_DETECT] = {
10573         .type = HDA_FIXUP_FUNC,
10574         .v.func = alc_fixup_no_jack_detect,
10575     },
10576     [ALC861_FIXUP_ASUS_A6RP] = {
10577         .type = HDA_FIXUP_FUNC,
10578         .v.func = alc861_fixup_asus_amp_vref_0f,
10579         .chained = true,
10580         .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
10581     },
10582     [ALC660_FIXUP_ASUS_W7J] = {
10583         .type = HDA_FIXUP_VERBS,
10584         .v.verbs = (const struct hda_verb[]) {
10585             /* ASUS W7J needs a magic pin setup on unused NID 0x10
10586              * for enabling outputs
10587              */
10588             {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10589             { }
10590         },
10591     }
10592 };
10593
10594 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
10595     SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
10596     SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
10597     SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
10598     SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
10599     SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
10600     SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F),
10601     SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
10602     {}
10603 };
10604
10605 /*
10606  */
10607 static int patch_alc861(struct hda_codec *codec)
10608 {
10609     struct alc_spec *spec;
10610     int err;
10611
10612     err = alc_alloc_spec(codec, 0x15);
10613     if (err < 0)
10614         return err;
10615
10616     spec = codec->spec;
10617     if (has_cdefine_beep(codec))
10618         spec->gen.beep_nid = 0x23;
10619
10620 #ifdef CONFIG_PM
10621     spec->power_hook = alc_power_eapd;
10622 #endif
10623
10624     alc_pre_init(codec);
10625
10626     snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
10627     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
10628
10629     /* automatic parse from the BIOS config */
10630     err = alc861_parse_auto_config(codec);
10631     if (err < 0)
10632         goto error;
10633
10634     if (!spec->gen.no_analog) {
10635         err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
10636         if (err < 0)
10637             goto error;
10638     }
10639
10640     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
10641
10642     return 0;
10643
10644  error:
10645     alc_free(codec);
10646     return err;
10647 }
10648
10649 /*
10650  * ALC861-VD support
10651  *
10652  * Based on ALC882
10653  *
10654  * In addition, an independent DAC
10655  */
10656 static int alc861vd_parse_auto_config(struct hda_codec *codec)
10657 {
10658     static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
10659     static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
10660     return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
10661 }
10662
10663 enum {
10664     ALC660VD_FIX_ASUS_GPIO1,
10665     ALC861VD_FIX_DALLAS,
10666 };
10667
10668 /* exclude VREF80 */
10669 static void alc861vd_fixup_dallas(struct hda_codec *codec,
10670                   const struct hda_fixup *fix, int action)
10671 {
10672     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
10673         snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
10674         snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
10675     }
10676 }
10677
10678 /* reset GPIO1 */
10679 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
10680                       const struct hda_fixup *fix, int action)
10681 {
10682     struct alc_spec *spec = codec->spec;
10683
10684     if (action == HDA_FIXUP_ACT_PRE_PROBE)
10685         spec->gpio_mask |= 0x02;
10686     alc_fixup_gpio(codec, action, 0x01);
10687 }
10688
10689 static const struct hda_fixup alc861vd_fixups[] = {
10690     [ALC660VD_FIX_ASUS_GPIO1] = {
10691         .type = HDA_FIXUP_FUNC,
10692         .v.func = alc660vd_fixup_asus_gpio1,
10693     },
10694     [ALC861VD_FIX_DALLAS] = {
10695         .type = HDA_FIXUP_FUNC,
10696         .v.func = alc861vd_fixup_dallas,
10697     },
10698 };
10699
10700 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
10701     SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
10702     SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
10703     SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
10704     {}
10705 };
10706
10707 /*
10708  */
10709 static int patch_alc861vd(struct hda_codec *codec)
10710 {
10711     struct alc_spec *spec;
10712     int err;
10713
10714     err = alc_alloc_spec(codec, 0x0b);
10715     if (err < 0)
10716         return err;
10717
10718     spec = codec->spec;
10719     if (has_cdefine_beep(codec))
10720         spec->gen.beep_nid = 0x23;
10721
10722     spec->shutup = alc_eapd_shutup;
10723
10724     alc_pre_init(codec);
10725
10726     snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
10727     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
10728
10729     /* automatic parse from the BIOS config */
10730     err = alc861vd_parse_auto_config(codec);
10731     if (err < 0)
10732         goto error;
10733
10734     if (!spec->gen.no_analog) {
10735         err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10736         if (err < 0)
10737             goto error;
10738     }
10739
10740     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
10741
10742     return 0;
10743
10744  error:
10745     alc_free(codec);
10746     return err;
10747 }
10748
10749 /*
10750  * ALC662 support
10751  *
10752  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
10753  * configuration.  Each pin widget can choose any input DACs and a mixer.
10754  * Each ADC is connected from a mixer of all inputs.  This makes possible
10755  * 6-channel independent captures.
10756  *
10757  * In addition, an independent DAC for the multi-playback (not used in this
10758  * driver yet).
10759  */
10760
10761 /*
10762  * BIOS auto configuration
10763  */
10764
10765 static int alc662_parse_auto_config(struct hda_codec *codec)
10766 {
10767     static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
10768     static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
10769     static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
10770     const hda_nid_t *ssids;
10771
10772     if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
10773         codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
10774         codec->core.vendor_id == 0x10ec0671)
10775         ssids = alc663_ssids;
10776     else
10777         ssids = alc662_ssids;
10778     return alc_parse_auto_config(codec, alc662_ignore, ssids);
10779 }
10780
10781 static void alc272_fixup_mario(struct hda_codec *codec,
10782                    const struct hda_fixup *fix, int action)
10783 {
10784     if (action != HDA_FIXUP_ACT_PRE_PROBE)
10785         return;
10786     if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
10787                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
10788                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
10789                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
10790                       (0 << AC_AMPCAP_MUTE_SHIFT)))
10791         codec_warn(codec, "failed to override amp caps for NID 0x2\n");
10792 }
10793
10794 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
10795     { .channels = 2,
10796       .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
10797     { .channels = 4,
10798       .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
10799            SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
10800     { }
10801 };
10802
10803 /* override the 2.1 chmap */
10804 static void alc_fixup_bass_chmap(struct hda_codec *codec,
10805                     const struct hda_fixup *fix, int action)
10806 {
10807     if (action == HDA_FIXUP_ACT_BUILD) {
10808         struct alc_spec *spec = codec->spec;
10809         spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
10810     }
10811 }
10812
10813 /* avoid D3 for keeping GPIO up */
10814 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
10815                       hda_nid_t nid,
10816                       unsigned int power_state)
10817 {
10818     struct alc_spec *spec = codec->spec;
10819     if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
10820         return AC_PWRST_D0;
10821     return power_state;
10822 }
10823
10824 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
10825                    const struct hda_fixup *fix, int action)
10826 {
10827     struct alc_spec *spec = codec->spec;
10828
10829     alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
10830     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
10831         spec->mute_led_polarity = 1;
10832         codec->power_filter = gpio_led_power_filter;
10833     }
10834 }
10835
10836 static void alc662_usi_automute_hook(struct hda_codec *codec,
10837                      struct hda_jack_callback *jack)
10838 {
10839     struct alc_spec *spec = codec->spec;
10840     int vref;
10841     msleep(200);
10842     snd_hda_gen_hp_automute(codec, jack);
10843
10844     vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
10845     msleep(100);
10846     snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
10847                 vref);
10848 }
10849
10850 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
10851                      const struct hda_fixup *fix, int action)
10852 {
10853     struct alc_spec *spec = codec->spec;
10854     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
10855         spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
10856         spec->gen.hp_automute_hook = alc662_usi_automute_hook;
10857     }
10858 }
10859
10860 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
10861                     struct hda_jack_callback *cb)
10862 {
10863     /* surround speakers at 0x1b already get muted automatically when
10864      * headphones are plugged in, but we have to mute/unmute the remaining
10865      * channels manually:
10866      * 0x15 - front left/front right
10867      * 0x18 - front center/ LFE
10868      */
10869     if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
10870         snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
10871         snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
10872     } else {
10873         snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
10874         snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
10875     }
10876 }
10877
10878 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
10879                     const struct hda_fixup *fix, int action)
10880 {
10881     /* Pin 0x1b: shared headphones jack and surround speakers */
10882     if (!is_jack_detectable(codec, 0x1b))
10883         return;
10884
10885     switch (action) {
10886     case HDA_FIXUP_ACT_PRE_PROBE:
10887         snd_hda_jack_detect_enable_callback(codec, 0x1b,
10888                 alc662_aspire_ethos_mute_speakers);
10889         /* subwoofer needs an extra GPIO setting to become audible */
10890         alc_setup_gpio(codec, 0x02);
10891         break;
10892     case HDA_FIXUP_ACT_INIT:
10893         /* Make sure to start in a correct state, i.e. if
10894          * headphones have been plugged in before powering up the system
10895          */
10896         alc662_aspire_ethos_mute_speakers(codec, NULL);
10897         break;
10898     }
10899 }
10900
10901 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
10902                          const struct hda_fixup *fix, int action)
10903 {
10904     struct alc_spec *spec = codec->spec;
10905
10906     static const struct hda_pintbl pincfgs[] = {
10907         { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
10908         { 0x1b, 0x0181304f },
10909         { }
10910     };
10911
10912     switch (action) {
10913     case HDA_FIXUP_ACT_PRE_PROBE:
10914         spec->gen.mixer_nid = 0;
10915         spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
10916         snd_hda_apply_pincfgs(codec, pincfgs);
10917         break;
10918     case HDA_FIXUP_ACT_INIT:
10919         alc_write_coef_idx(codec, 0x19, 0xa054);
10920         break;
10921     }
10922 }
10923
10924 static void alc897_hp_automute_hook(struct hda_codec *codec,
10925                      struct hda_jack_callback *jack)
10926 {
10927     struct alc_spec *spec = codec->spec;
10928     int vref;
10929
10930     snd_hda_gen_hp_automute(codec, jack);
10931     vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
10932     snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
10933                 vref);
10934 }
10935
10936 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
10937                      const struct hda_fixup *fix, int action)
10938 {
10939     struct alc_spec *spec = codec->spec;
10940     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
10941         spec->gen.hp_automute_hook = alc897_hp_automute_hook;
10942     }
10943 }
10944
10945 static const struct coef_fw alc668_coefs[] = {
10946     WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
10947     WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
10948     WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
10949     WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
10950     WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
10951     WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
10952     WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
10953     WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
10954     WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
10955     WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
10956     WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
10957     WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
10958     WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
10959     WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
10960     WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
10961     WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
10962     WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
10963     WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
10964     WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
10965     WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
10966     {}
10967 };
10968
10969 static void alc668_restore_default_value(struct hda_codec *codec)
10970 {
10971     alc_process_coef_fw(codec, alc668_coefs);
10972 }
10973
10974 enum {
10975     ALC662_FIXUP_ASPIRE,
10976     ALC662_FIXUP_LED_GPIO1,
10977     ALC662_FIXUP_IDEAPAD,
10978     ALC272_FIXUP_MARIO,
10979     ALC662_FIXUP_CZC_ET26,
10980     ALC662_FIXUP_CZC_P10T,
10981     ALC662_FIXUP_SKU_IGNORE,
10982     ALC662_FIXUP_HP_RP5800,
10983     ALC662_FIXUP_ASUS_MODE1,
10984     ALC662_FIXUP_ASUS_MODE2,
10985     ALC662_FIXUP_ASUS_MODE3,
10986     ALC662_FIXUP_ASUS_MODE4,
10987     ALC662_FIXUP_ASUS_MODE5,
10988     ALC662_FIXUP_ASUS_MODE6,
10989     ALC662_FIXUP_ASUS_MODE7,
10990     ALC662_FIXUP_ASUS_MODE8,
10991     ALC662_FIXUP_NO_JACK_DETECT,
10992     ALC662_FIXUP_ZOTAC_Z68,
10993     ALC662_FIXUP_INV_DMIC,
10994     ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
10995     ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
10996     ALC662_FIXUP_HEADSET_MODE,
10997     ALC668_FIXUP_HEADSET_MODE,
10998     ALC662_FIXUP_BASS_MODE4_CHMAP,
10999     ALC662_FIXUP_BASS_16,
11000     ALC662_FIXUP_BASS_1A,
11001     ALC662_FIXUP_BASS_CHMAP,
11002     ALC668_FIXUP_AUTO_MUTE,
11003     ALC668_FIXUP_DELL_DISABLE_AAMIX,
11004     ALC668_FIXUP_DELL_XPS13,
11005     ALC662_FIXUP_ASUS_Nx50,
11006     ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
11007     ALC668_FIXUP_ASUS_Nx51,
11008     ALC668_FIXUP_MIC_COEF,
11009     ALC668_FIXUP_ASUS_G751,
11010     ALC891_FIXUP_HEADSET_MODE,
11011     ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
11012     ALC662_FIXUP_ACER_VERITON,
11013     ALC892_FIXUP_ASROCK_MOBO,
11014     ALC662_FIXUP_USI_FUNC,
11015     ALC662_FIXUP_USI_HEADSET_MODE,
11016     ALC662_FIXUP_LENOVO_MULTI_CODECS,
11017     ALC669_FIXUP_ACER_ASPIRE_ETHOS,
11018     ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
11019     ALC671_FIXUP_HP_HEADSET_MIC2,
11020     ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
11021     ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
11022     ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
11023     ALC668_FIXUP_HEADSET_MIC,
11024     ALC668_FIXUP_MIC_DET_COEF,
11025     ALC897_FIXUP_LENOVO_HEADSET_MIC,
11026     ALC897_FIXUP_HEADSET_MIC_PIN,
11027     ALC897_FIXUP_HP_HSMIC_VERB,
11028 };
11029
11030 static const struct hda_fixup alc662_fixups[] = {
11031     [ALC662_FIXUP_ASPIRE] = {
11032         .type = HDA_FIXUP_PINS,
11033         .v.pins = (const struct hda_pintbl[]) {
11034             { 0x15, 0x99130112 }, /* subwoofer */
11035             { }
11036         }
11037     },
11038     [ALC662_FIXUP_LED_GPIO1] = {
11039         .type = HDA_FIXUP_FUNC,
11040         .v.func = alc662_fixup_led_gpio1,
11041     },
11042     [ALC662_FIXUP_IDEAPAD] = {
11043         .type = HDA_FIXUP_PINS,
11044         .v.pins = (const struct hda_pintbl[]) {
11045             { 0x17, 0x99130112 }, /* subwoofer */
11046             { }
11047         },
11048         .chained = true,
11049         .chain_id = ALC662_FIXUP_LED_GPIO1,
11050     },
11051     [ALC272_FIXUP_MARIO] = {
11052         .type = HDA_FIXUP_FUNC,
11053         .v.func = alc272_fixup_mario,
11054     },
11055     [ALC662_FIXUP_CZC_ET26] = {
11056         .type = HDA_FIXUP_PINS,
11057         .v.pins = (const struct hda_pintbl[]) {
11058             {0x12, 0x403cc000},
11059             {0x14, 0x90170110}, /* speaker */
11060             {0x15, 0x411111f0},
11061             {0x16, 0x411111f0},
11062             {0x18, 0x01a19030}, /* mic */
11063             {0x19, 0x90a7013f}, /* int-mic */
11064             {0x1a, 0x01014020},
11065             {0x1b, 0x0121401f},
11066             {0x1c, 0x411111f0},
11067             {0x1d, 0x411111f0},
11068             {0x1e, 0x40478e35},
11069             {}
11070         },
11071         .chained = true,
11072         .chain_id = ALC662_FIXUP_SKU_IGNORE
11073     },
11074     [ALC662_FIXUP_CZC_P10T] = {
11075         .type = HDA_FIXUP_VERBS,
11076         .v.verbs = (const struct hda_verb[]) {
11077             {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
11078             {}
11079         }
11080     },
11081     [ALC662_FIXUP_SKU_IGNORE] = {
11082         .type = HDA_FIXUP_FUNC,
11083         .v.func = alc_fixup_sku_ignore,
11084     },
11085     [ALC662_FIXUP_HP_RP5800] = {
11086         .type = HDA_FIXUP_PINS,
11087         .v.pins = (const struct hda_pintbl[]) {
11088             { 0x14, 0x0221201f }, /* HP out */
11089             { }
11090         },
11091         .chained = true,
11092         .chain_id = ALC662_FIXUP_SKU_IGNORE
11093     },
11094     [ALC662_FIXUP_ASUS_MODE1] = {
11095         .type = HDA_FIXUP_PINS,
11096         .v.pins = (const struct hda_pintbl[]) {
11097             { 0x14, 0x99130110 }, /* speaker */
11098             { 0x18, 0x01a19c20 }, /* mic */
11099             { 0x19, 0x99a3092f }, /* int-mic */
11100             { 0x21, 0x0121401f }, /* HP out */
11101             { }
11102         },
11103         .chained = true,
11104         .chain_id = ALC662_FIXUP_SKU_IGNORE
11105     },
11106     [ALC662_FIXUP_ASUS_MODE2] = {
11107         .type = HDA_FIXUP_PINS,
11108         .v.pins = (const struct hda_pintbl[]) {
11109             { 0x14, 0x99130110 }, /* speaker */
11110             { 0x18, 0x01a19820 }, /* mic */
11111             { 0x19, 0x99a3092f }, /* int-mic */
11112             { 0x1b, 0x0121401f }, /* HP out */
11113             { }
11114         },
11115         .chained = true,
11116         .chain_id = ALC662_FIXUP_SKU_IGNORE
11117     },
11118     [ALC662_FIXUP_ASUS_MODE3] = {
11119         .type = HDA_FIXUP_PINS,
11120         .v.pins = (const struct hda_pintbl[]) {
11121             { 0x14, 0x99130110 }, /* speaker */
11122             { 0x15, 0x0121441f }, /* HP */
11123             { 0x18, 0x01a19840 }, /* mic */
11124             { 0x19, 0x99a3094f }, /* int-mic */
11125             { 0x21, 0x01211420 }, /* HP2 */
11126             { }
11127         },
11128         .chained = true,
11129         .chain_id = ALC662_FIXUP_SKU_IGNORE
11130     },
11131     [ALC662_FIXUP_ASUS_MODE4] = {
11132         .type = HDA_FIXUP_PINS,
11133         .v.pins = (const struct hda_pintbl[]) {
11134             { 0x14, 0x99130110 }, /* speaker */
11135             { 0x16, 0x99130111 }, /* speaker */
11136             { 0x18, 0x01a19840 }, /* mic */
11137             { 0x19, 0x99a3094f }, /* int-mic */
11138             { 0x21, 0x0121441f }, /* HP */
11139             { }
11140         },
11141         .chained = true,
11142         .chain_id = ALC662_FIXUP_SKU_IGNORE
11143     },
11144     [ALC662_FIXUP_ASUS_MODE5] = {
11145         .type = HDA_FIXUP_PINS,
11146         .v.pins = (const struct hda_pintbl[]) {
11147             { 0x14, 0x99130110 }, /* speaker */
11148             { 0x15, 0x0121441f }, /* HP */
11149             { 0x16, 0x99130111 }, /* speaker */
11150             { 0x18, 0x01a19840 }, /* mic */
11151             { 0x19, 0x99a3094f }, /* int-mic */
11152             { }
11153         },
11154         .chained = true,
11155         .chain_id = ALC662_FIXUP_SKU_IGNORE
11156     },
11157     [ALC662_FIXUP_ASUS_MODE6] = {
11158         .type = HDA_FIXUP_PINS,
11159         .v.pins = (const struct hda_pintbl[]) {
11160             { 0x14, 0x99130110 }, /* speaker */
11161             { 0x15, 0x01211420 }, /* HP2 */
11162             { 0x18, 0x01a19840 }, /* mic */
11163             { 0x19, 0x99a3094f }, /* int-mic */
11164             { 0x1b, 0x0121441f }, /* HP */
11165             { }
11166         },
11167         .chained = true,
11168         .chain_id = ALC662_FIXUP_SKU_IGNORE
11169     },
11170     [ALC662_FIXUP_ASUS_MODE7] = {
11171         .type = HDA_FIXUP_PINS,
11172         .v.pins = (const struct hda_pintbl[]) {
11173             { 0x14, 0x99130110 }, /* speaker */
11174             { 0x17, 0x99130111 }, /* speaker */
11175             { 0x18, 0x01a19840 }, /* mic */
11176             { 0x19, 0x99a3094f }, /* int-mic */
11177             { 0x1b, 0x01214020 }, /* HP */
11178             { 0x21, 0x0121401f }, /* HP */
11179             { }
11180         },
11181         .chained = true,
11182         .chain_id = ALC662_FIXUP_SKU_IGNORE
11183     },
11184     [ALC662_FIXUP_ASUS_MODE8] = {
11185         .type = HDA_FIXUP_PINS,
11186         .v.pins = (const struct hda_pintbl[]) {
11187             { 0x14, 0x99130110 }, /* speaker */
11188             { 0x12, 0x99a30970 }, /* int-mic */
11189             { 0x15, 0x01214020 }, /* HP */
11190             { 0x17, 0x99130111 }, /* speaker */
11191             { 0x18, 0x01a19840 }, /* mic */
11192             { 0x21, 0x0121401f }, /* HP */
11193             { }
11194         },
11195         .chained = true,
11196         .chain_id = ALC662_FIXUP_SKU_IGNORE
11197     },
11198     [ALC662_FIXUP_NO_JACK_DETECT] = {
11199         .type = HDA_FIXUP_FUNC,
11200         .v.func = alc_fixup_no_jack_detect,
11201     },
11202     [ALC662_FIXUP_ZOTAC_Z68] = {
11203         .type = HDA_FIXUP_PINS,
11204         .v.pins = (const struct hda_pintbl[]) {
11205             { 0x1b, 0x02214020 }, /* Front HP */
11206             { }
11207         }
11208     },
11209     [ALC662_FIXUP_INV_DMIC] = {
11210         .type = HDA_FIXUP_FUNC,
11211         .v.func = alc_fixup_inv_dmic,
11212     },
11213     [ALC668_FIXUP_DELL_XPS13] = {
11214         .type = HDA_FIXUP_FUNC,
11215         .v.func = alc_fixup_dell_xps13,
11216         .chained = true,
11217         .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
11218     },
11219     [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
11220         .type = HDA_FIXUP_FUNC,
11221         .v.func = alc_fixup_disable_aamix,
11222         .chained = true,
11223         .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
11224     },
11225     [ALC668_FIXUP_AUTO_MUTE] = {
11226         .type = HDA_FIXUP_FUNC,
11227         .v.func = alc_fixup_auto_mute_via_amp,
11228         .chained = true,
11229         .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
11230     },
11231     [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
11232         .type = HDA_FIXUP_PINS,
11233         .v.pins = (const struct hda_pintbl[]) {
11234             { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11235             /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
11236             { }
11237         },
11238         .chained = true,
11239         .chain_id = ALC662_FIXUP_HEADSET_MODE
11240     },
11241     [ALC662_FIXUP_HEADSET_MODE] = {
11242         .type = HDA_FIXUP_FUNC,
11243         .v.func = alc_fixup_headset_mode_alc662,
11244     },
11245     [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
11246         .type = HDA_FIXUP_PINS,
11247         .v.pins = (const struct hda_pintbl[]) {
11248             { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
11249             { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11250             { }
11251         },
11252         .chained = true,
11253         .chain_id = ALC668_FIXUP_HEADSET_MODE
11254     },
11255     [ALC668_FIXUP_HEADSET_MODE] = {
11256         .type = HDA_FIXUP_FUNC,
11257         .v.func = alc_fixup_headset_mode_alc668,
11258     },
11259     [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
11260         .type = HDA_FIXUP_FUNC,
11261         .v.func = alc_fixup_bass_chmap,
11262         .chained = true,
11263         .chain_id = ALC662_FIXUP_ASUS_MODE4
11264     },
11265     [ALC662_FIXUP_BASS_16] = {
11266         .type = HDA_FIXUP_PINS,
11267         .v.pins = (const struct hda_pintbl[]) {
11268             {0x16, 0x80106111}, /* bass speaker */
11269             {}
11270         },
11271         .chained = true,
11272         .chain_id = ALC662_FIXUP_BASS_CHMAP,
11273     },
11274     [ALC662_FIXUP_BASS_1A] = {
11275         .type = HDA_FIXUP_PINS,
11276         .v.pins = (const struct hda_pintbl[]) {
11277             {0x1a, 0x80106111}, /* bass speaker */
11278             {}
11279         },
11280         .chained = true,
11281         .chain_id = ALC662_FIXUP_BASS_CHMAP,
11282     },
11283     [ALC662_FIXUP_BASS_CHMAP] = {
11284         .type = HDA_FIXUP_FUNC,
11285         .v.func = alc_fixup_bass_chmap,
11286     },
11287     [ALC662_FIXUP_ASUS_Nx50] = {
11288         .type = HDA_FIXUP_FUNC,
11289         .v.func = alc_fixup_auto_mute_via_amp,
11290         .chained = true,
11291         .chain_id = ALC662_FIXUP_BASS_1A
11292     },
11293     [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
11294         .type = HDA_FIXUP_FUNC,
11295         .v.func = alc_fixup_headset_mode_alc668,
11296         .chain_id = ALC662_FIXUP_BASS_CHMAP
11297     },
11298     [ALC668_FIXUP_ASUS_Nx51] = {
11299         .type = HDA_FIXUP_PINS,
11300         .v.pins = (const struct hda_pintbl[]) {
11301             { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
11302             { 0x1a, 0x90170151 }, /* bass speaker */
11303             { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11304             {}
11305         },
11306         .chained = true,
11307         .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
11308     },
11309     [ALC668_FIXUP_MIC_COEF] = {
11310         .type = HDA_FIXUP_VERBS,
11311         .v.verbs = (const struct hda_verb[]) {
11312             { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
11313             { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
11314             {}
11315         },
11316     },
11317     [ALC668_FIXUP_ASUS_G751] = {
11318         .type = HDA_FIXUP_PINS,
11319         .v.pins = (const struct hda_pintbl[]) {
11320             { 0x16, 0x0421101f }, /* HP */
11321             {}
11322         },
11323         .chained = true,
11324         .chain_id = ALC668_FIXUP_MIC_COEF
11325     },
11326     [ALC891_FIXUP_HEADSET_MODE] = {
11327         .type = HDA_FIXUP_FUNC,
11328         .v.func = alc_fixup_headset_mode,
11329     },
11330     [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
11331         .type = HDA_FIXUP_PINS,
11332         .v.pins = (const struct hda_pintbl[]) {
11333             { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
11334             { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11335             { }
11336         },
11337         .chained = true,
11338         .chain_id = ALC891_FIXUP_HEADSET_MODE
11339     },
11340     [ALC662_FIXUP_ACER_VERITON] = {
11341         .type = HDA_FIXUP_PINS,
11342         .v.pins = (const struct hda_pintbl[]) {
11343             { 0x15, 0x50170120 }, /* no internal speaker */
11344             { }
11345         }
11346     },
11347     [ALC892_FIXUP_ASROCK_MOBO] = {
11348         .type = HDA_FIXUP_PINS,
11349         .v.pins = (const struct hda_pintbl[]) {
11350             { 0x15, 0x40f000f0 }, /* disabled */
11351             { 0x16, 0x40f000f0 }, /* disabled */
11352             { }
11353         }
11354     },
11355     [ALC662_FIXUP_USI_FUNC] = {
11356         .type = HDA_FIXUP_FUNC,
11357         .v.func = alc662_fixup_usi_headset_mic,
11358     },
11359     [ALC662_FIXUP_USI_HEADSET_MODE] = {
11360         .type = HDA_FIXUP_PINS,
11361         .v.pins = (const struct hda_pintbl[]) {
11362             { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
11363             { 0x18, 0x01a1903d },
11364             { }
11365         },
11366         .chained = true,
11367         .chain_id = ALC662_FIXUP_USI_FUNC
11368     },
11369     [ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
11370         .type = HDA_FIXUP_FUNC,
11371         .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
11372     },
11373     [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
11374         .type = HDA_FIXUP_FUNC,
11375         .v.func = alc662_fixup_aspire_ethos_hp,
11376     },
11377     [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
11378         .type = HDA_FIXUP_PINS,
11379         .v.pins = (const struct hda_pintbl[]) {
11380             { 0x15, 0x92130110 }, /* front speakers */
11381             { 0x18, 0x99130111 }, /* center/subwoofer */
11382             { 0x1b, 0x11130012 }, /* surround plus jack for HP */
11383             { }
11384         },
11385         .chained = true,
11386         .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
11387     },
11388     [ALC671_FIXUP_HP_HEADSET_MIC2] = {
11389         .type = HDA_FIXUP_FUNC,
11390         .v.func = alc671_fixup_hp_headset_mic2,
11391     },
11392     [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
11393         .type = HDA_FIXUP_PINS,
11394         .v.pins = (const struct hda_pintbl[]) {
11395             { 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
11396             { }
11397         },
11398         .chained = true,
11399         .chain_id = ALC662_FIXUP_USI_FUNC
11400     },
11401     [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
11402         .type = HDA_FIXUP_PINS,
11403         .v.pins = (const struct hda_pintbl[]) {
11404             { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
11405             { 0x1b, 0x0221144f },
11406             { }
11407         },
11408         .chained = true,
11409         .chain_id = ALC662_FIXUP_USI_FUNC
11410     },
11411     [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
11412         .type = HDA_FIXUP_PINS,
11413         .v.pins = (const struct hda_pintbl[]) {
11414             { 0x1b, 0x04a1112c },
11415             { }
11416         },
11417         .chained = true,
11418         .chain_id = ALC668_FIXUP_HEADSET_MIC
11419     },
11420     [ALC668_FIXUP_HEADSET_MIC] = {
11421         .type = HDA_FIXUP_FUNC,
11422         .v.func = alc269_fixup_headset_mic,
11423         .chained = true,
11424         .chain_id = ALC668_FIXUP_MIC_DET_COEF
11425     },
11426     [ALC668_FIXUP_MIC_DET_COEF] = {
11427         .type = HDA_FIXUP_VERBS,
11428         .v.verbs = (const struct hda_verb[]) {
11429             { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
11430             { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
11431             {}
11432         },
11433     },
11434     [ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
11435         .type = HDA_FIXUP_FUNC,
11436         .v.func = alc897_fixup_lenovo_headset_mic,
11437     },
11438     [ALC897_FIXUP_HEADSET_MIC_PIN] = {
11439         .type = HDA_FIXUP_PINS,
11440         .v.pins = (const struct hda_pintbl[]) {
11441             { 0x1a, 0x03a11050 },
11442             { }
11443         },
11444         .chained = true,
11445         .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
11446     },
11447     [ALC897_FIXUP_HP_HSMIC_VERB] = {
11448         .type = HDA_FIXUP_PINS,
11449         .v.pins = (const struct hda_pintbl[]) {
11450             { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
11451             { }
11452         },
11453     },
11454 };
11455
11456 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
11457     SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
11458     SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
11459     SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
11460     SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
11461     SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
11462     SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
11463     SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
11464     SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
11465     SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
11466     SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
11467     SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
11468     SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
11469     SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
11470     SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
11471     SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
11472     SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
11473     SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
11474     SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
11475     SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
11476     SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
11477     SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
11478     SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
11479     SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
11480     SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
11481     SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
11482     SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
11483     SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
11484     SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
11485     SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
11486     SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
11487     SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
11488     SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
11489     SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
11490     SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
11491     SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
11492     SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
11493     SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
11494     SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
11495     SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
11496     SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
11497     SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
11498     SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
11499     SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
11500     SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
11501     SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
11502     SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
11503     SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
11504     SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
11505     SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
11506     SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
11507     SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
11508     SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
11509     SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
11510     SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
11511     SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26),
11512     SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
11513
11514 #if 0
11515     /* Below is a quirk table taken from the old code.
11516      * Basically the device should work as is without the fixup table.
11517      * If BIOS doesn't give a proper info, enable the corresponding
11518      * fixup entry.
11519      */
11520     SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
11521     SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
11522     SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
11523     SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
11524     SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
11525     SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
11526     SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
11527     SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
11528     SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
11529     SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
11530     SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
11531     SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
11532     SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
11533     SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
11534     SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
11535     SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
11536     SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
11537     SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
11538     SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
11539     SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
11540     SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
11541     SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
11542     SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
11543     SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
11544     SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
11545     SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
11546     SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
11547     SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
11548     SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
11549     SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
11550     SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
11551     SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
11552     SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
11553     SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
11554     SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
11555     SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
11556     SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
11557     SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
11558     SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
11559     SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
11560     SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
11561     SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
11562     SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
11563     SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
11564     SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
11565     SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
11566     SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
11567     SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
11568     SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
11569     SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
11570 #endif
11571     {}
11572 };
11573
11574 static const struct hda_model_fixup alc662_fixup_models[] = {
11575     {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
11576     {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
11577     {.id = ALC272_FIXUP_MARIO, .name = "mario"},
11578     {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
11579     {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
11580     {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
11581     {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
11582     {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
11583     {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
11584     {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
11585     {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
11586     {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
11587     {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
11588     {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
11589     {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
11590     {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
11591     {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
11592     {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
11593     {.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
11594     {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
11595     {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
11596     {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
11597     {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
11598     {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
11599     {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
11600     {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
11601     {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
11602     {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
11603     {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
11604     {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
11605     {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
11606     {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
11607     {}
11608 };
11609
11610 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
11611     SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
11612         {0x17, 0x02211010},
11613         {0x18, 0x01a19030},
11614         {0x1a, 0x01813040},
11615         {0x21, 0x01014020}),
11616     SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
11617         {0x16, 0x01813030},
11618         {0x17, 0x02211010},
11619         {0x18, 0x01a19040},
11620         {0x21, 0x01014020}),
11621     SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
11622         {0x14, 0x01014010},
11623         {0x18, 0x01a19020},
11624         {0x1a, 0x0181302f},
11625         {0x1b, 0x0221401f}),
11626     SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
11627         {0x12, 0x99a30130},
11628         {0x14, 0x90170110},
11629         {0x15, 0x0321101f},
11630         {0x16, 0x03011020}),
11631     SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
11632         {0x12, 0x99a30140},
11633         {0x14, 0x90170110},
11634         {0x15, 0x0321101f},
11635         {0x16, 0x03011020}),
11636     SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
11637         {0x12, 0x99a30150},
11638         {0x14, 0x90170110},
11639         {0x15, 0x0321101f},
11640         {0x16, 0x03011020}),
11641     SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
11642         {0x14, 0x90170110},
11643         {0x15, 0x0321101f},
11644         {0x16, 0x03011020}),
11645     SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
11646         {0x12, 0x90a60130},
11647         {0x14, 0x90170110},
11648         {0x15, 0x0321101f}),
11649     SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
11650         {0x14, 0x01014010},
11651         {0x17, 0x90170150},
11652         {0x19, 0x02a11060},
11653         {0x1b, 0x01813030},
11654         {0x21, 0x02211020}),
11655     SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
11656         {0x14, 0x01014010},
11657         {0x18, 0x01a19040},
11658         {0x1b, 0x01813030},
11659         {0x21, 0x02211020}),
11660     SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
11661         {0x14, 0x01014020},
11662         {0x17, 0x90170110},
11663         {0x18, 0x01a19050},
11664         {0x1b, 0x01813040},
11665         {0x21, 0x02211030}),
11666     {}
11667 };
11668
11669 /*
11670  */
11671 static int patch_alc662(struct hda_codec *codec)
11672 {
11673     struct alc_spec *spec;
11674     int err;
11675
11676     err = alc_alloc_spec(codec, 0x0b);
11677     if (err < 0)
11678         return err;
11679
11680     spec = codec->spec;
11681
11682     spec->shutup = alc_eapd_shutup;
11683
11684     /* handle multiple HPs as is */
11685     spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
11686
11687     alc_fix_pll_init(codec, 0x20, 0x04, 15);
11688
11689     switch (codec->core.vendor_id) {
11690     case 0x10ec0668:
11691         spec->init_hook = alc668_restore_default_value;
11692         break;
11693     }
11694
11695     alc_pre_init(codec);
11696
11697     snd_hda_pick_fixup(codec, alc662_fixup_models,
11698                alc662_fixup_tbl, alc662_fixups);
11699     snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
11700     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11701
11702     alc_auto_parse_customize_define(codec);
11703
11704     if (has_cdefine_beep(codec))
11705         spec->gen.beep_nid = 0x01;
11706
11707     if ((alc_get_coef0(codec) & (1 << 14)) &&
11708         codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
11709         spec->cdefine.platform_type == 1) {
11710         err = alc_codec_rename(codec, "ALC272X");
11711         if (err < 0)
11712             goto error;
11713     }
11714
11715     /* automatic parse from the BIOS config */
11716     err = alc662_parse_auto_config(codec);
11717     if (err < 0)
11718         goto error;
11719
11720     if (!spec->gen.no_analog && spec->gen.beep_nid) {
11721         switch (codec->core.vendor_id) {
11722         case 0x10ec0662:
11723             err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11724             break;
11725         case 0x10ec0272:
11726         case 0x10ec0663:
11727         case 0x10ec0665:
11728         case 0x10ec0668:
11729             err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
11730             break;
11731         case 0x10ec0273:
11732             err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
11733             break;
11734         }
11735         if (err < 0)
11736             goto error;
11737     }
11738
11739     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11740
11741     return 0;
11742
11743  error:
11744     alc_free(codec);
11745     return err;
11746 }
11747
11748 /*
11749  * ALC680 support
11750  */
11751
11752 static int alc680_parse_auto_config(struct hda_codec *codec)
11753 {
11754     return alc_parse_auto_config(codec, NULL, NULL);
11755 }
11756
11757 /*
11758  */
11759 static int patch_alc680(struct hda_codec *codec)
11760 {
11761     int err;
11762
11763     /* ALC680 has no aa-loopback mixer */
11764     err = alc_alloc_spec(codec, 0);
11765     if (err < 0)
11766         return err;
11767
11768     /* automatic parse from the BIOS config */
11769     err = alc680_parse_auto_config(codec);
11770     if (err < 0) {
11771         alc_free(codec);
11772         return err;
11773     }
11774
11775     return 0;
11776 }
11777
11778 /*
11779  * patch entries
11780  */
11781 static const struct hda_device_id snd_hda_id_realtek[] = {
11782     HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
11783     HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
11784     HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
11785     HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
11786     HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269),
11787     HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
11788     HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
11789     HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
11790     HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
11791     HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
11792     HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
11793     HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
11794     HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
11795     HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
11796     HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
11797     HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
11798     HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
11799     HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
11800     HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
11801     HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
11802     HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
11803     HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
11804     HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
11805     HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
11806     HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
11807     HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
11808     HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
11809     HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
11810     HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
11811     HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
11812     HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
11813     HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
11814     HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
11815     HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
11816     HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
11817     HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
11818     HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
11819     HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
11820     HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
11821     HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
11822     HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
11823     HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
11824     HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
11825     HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
11826     HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
11827     HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
11828     HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
11829     HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
11830     HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
11831     HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
11832     HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
11833     HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
11834     HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
11835     HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
11836     HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
11837     HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
11838     HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
11839     HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
11840     HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
11841     HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
11842     HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
11843     HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
11844     HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
11845     HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
11846     HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
11847     HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
11848     HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
11849     HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
11850     HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
11851     HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
11852     HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
11853     HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
11854     HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662),
11855     HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
11856     HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
11857     HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
11858     HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
11859     HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
11860     HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
11861     {} /* terminator */
11862 };
11863 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
11864
11865 MODULE_LICENSE("GPL");
11866 MODULE_DESCRIPTION("Realtek HD-audio codec");
11867
11868 static struct hda_codec_driver realtek_driver = {
11869     .id = snd_hda_id_realtek,
11870 };
11871
11872 module_hda_codec_driver(realtek_driver);