sound/pci/hda/patch_realtek.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Universal Interface for Intel High Definition Audio Codec
   4  *
   5  * HD audio interface patch for Realtek ALC codecs
   6  *
   7  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   8  *                    PeiSen Hou <pshou@realtek.com.tw>
   9  *                    Takashi Iwai <tiwai@suse.de>
  10  *                    Jonathan Woithe <jwoithe@just42.net>
  11  */
  12
  13 #include <linux/acpi.h>
  14 #include <linux/init.h>
  15 #include <linux/delay.h>
  16 #include <linux/slab.h>
  17 #include <linux/pci.h>
  18 #include <linux/dmi.h>
  19 #include <linux/module.h>
  20 #include <linux/input.h>
  21 #include <linux/leds.h>
  22 #include <linux/ctype.h>
  23 #include <sound/core.h>
  24 #include <sound/jack.h>
  25 #include <sound/hda_codec.h>
  26 #include "hda_local.h"
  27 #include "hda_auto_parser.h"
  28 #include "hda_jack.h"
  29 #include "hda_generic.h"
  30 #include "hda_component.h"
  31
  32 /* keep halting ALC5505 DSP, for power saving */
  33 #define HALT_REALTEK_ALC5505
  34
  35 /* extra amp-initialization sequence types */
  36 enum {
  37         ALC_INIT_UNDEFINED,
  38         ALC_INIT_NONE,
  39         ALC_INIT_DEFAULT,
  40 };
  41
  42 enum {
  43         ALC_HEADSET_MODE_UNKNOWN,
  44         ALC_HEADSET_MODE_UNPLUGGED,
  45         ALC_HEADSET_MODE_HEADSET,
  46         ALC_HEADSET_MODE_MIC,
  47         ALC_HEADSET_MODE_HEADPHONE,
  48 };
  49
  50 enum {
  51         ALC_HEADSET_TYPE_UNKNOWN,
  52         ALC_HEADSET_TYPE_CTIA,
  53         ALC_HEADSET_TYPE_OMTP,
  54 };
  55
  56 enum {
  57         ALC_KEY_MICMUTE_INDEX,
  58 };
  59
  60 struct alc_customize_define {
  61         unsigned int  sku_cfg;
  62         unsigned char port_connectivity;
  63         unsigned char check_sum;
  64         unsigned char customization;
  65         unsigned char external_amp;
  66         unsigned int  enable_pcbeep:1;
  67         unsigned int  platform_type:1;
  68         unsigned int  swap:1;
  69         unsigned int  override:1;
  70         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
  71 };
  72
  73 struct alc_coef_led {
  74         unsigned int idx;
  75         unsigned int mask;
  76         unsigned int on;
  77         unsigned int off;
  78 };
  79
  80 struct alc_spec {
  81         struct hda_gen_spec gen; /* must be at head */
  82
  83         /* codec parameterization */
  84         struct alc_customize_define cdefine;
  85         unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
  86
  87         /* GPIO bits */
  88         unsigned int gpio_mask;
  89         unsigned int gpio_dir;
  90         unsigned int gpio_data;
  91         bool gpio_write_delay;  /* add a delay before writing gpio_data */
  92
  93         /* mute LED for HP laptops, see vref_mute_led_set() */
  94         int mute_led_polarity;
  95         int micmute_led_polarity;
  96         hda_nid_t mute_led_nid;
  97         hda_nid_t cap_mute_led_nid;
  98
  99         unsigned int gpio_mute_led_mask;
 100         unsigned int gpio_mic_led_mask;
 101         struct alc_coef_led mute_led_coef;
 102         struct alc_coef_led mic_led_coef;
 103         struct mutex coef_mutex;
 104
 105         hda_nid_t headset_mic_pin;
 106         hda_nid_t headphone_mic_pin;
 107         int current_headset_mode;
 108         int current_headset_type;
 109
 110         /* hooks */
 111         void (*init_hook)(struct hda_codec *codec);
 112 #ifdef CONFIG_PM
 113         void (*power_hook)(struct hda_codec *codec);
 114 #endif
 115         void (*shutup)(struct hda_codec *codec);
 116
 117         int init_amp;
 118         int codec_variant;      /* flag for other variants */
 119         unsigned int has_alc5505_dsp:1;
 120         unsigned int no_depop_delay:1;
 121         unsigned int done_hp_init:1;
 122         unsigned int no_shutup_pins:1;
 123         unsigned int ultra_low_power:1;
 124         unsigned int has_hs_key:1;
 125         unsigned int no_internal_mic_pin:1;
 126         unsigned int en_3kpull_low:1;
 127
 128         /* for PLL fix */
 129         hda_nid_t pll_nid;
 130         unsigned int pll_coef_idx, pll_coef_bit;
 131         unsigned int coef0;
 132         struct input_dev *kb_dev;
 133         u8 alc_mute_keycode_map[1];
 134
 135         /* component binding */
 136         struct hda_component comps[HDA_MAX_COMPONENTS];
 137 };
 138
 139 /*
 140  * COEF access helper functions
 141  */
 142
 143 static void coef_mutex_lock(struct hda_codec *codec)
 144 {
 145         struct alc_spec *spec = codec->spec;
 146
 147         snd_hda_power_up_pm(codec);
 148         mutex_lock(&spec->coef_mutex);
 149 }
 150
 151 static void coef_mutex_unlock(struct hda_codec *codec)
 152 {
 153         struct alc_spec *spec = codec->spec;
 154
 155         mutex_unlock(&spec->coef_mutex);
 156         snd_hda_power_down_pm(codec);
 157 }
 158
 159 static int __alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 160                                  unsigned int coef_idx)
 161 {
 162         unsigned int val;
 163
 164         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
 165         val = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 166         return val;
 167 }
 168
 169 static int alc_read_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 170                                unsigned int coef_idx)
 171 {
 172         unsigned int val;
 173
 174         coef_mutex_lock(codec);
 175         val = __alc_read_coefex_idx(codec, nid, coef_idx);
 176         coef_mutex_unlock(codec);
 177         return val;
 178 }
 179
 180 #define alc_read_coef_idx(codec, coef_idx) \
 181         alc_read_coefex_idx(codec, 0x20, coef_idx)
 182
 183 static void __alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 184                                    unsigned int coef_idx, unsigned int coef_val)
 185 {
 186         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_COEF_INDEX, coef_idx);
 187         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PROC_COEF, coef_val);
 188 }
 189
 190 static void alc_write_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 191                                  unsigned int coef_idx, unsigned int coef_val)
 192 {
 193         coef_mutex_lock(codec);
 194         __alc_write_coefex_idx(codec, nid, coef_idx, coef_val);
 195         coef_mutex_unlock(codec);
 196 }
 197
 198 #define alc_write_coef_idx(codec, coef_idx, coef_val) \
 199         alc_write_coefex_idx(codec, 0x20, coef_idx, coef_val)
 200
 201 static void __alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 202                                     unsigned int coef_idx, unsigned int mask,
 203                                     unsigned int bits_set)
 204 {
 205         unsigned int val = __alc_read_coefex_idx(codec, nid, coef_idx);
 206
 207         if (val != -1)
 208                 __alc_write_coefex_idx(codec, nid, coef_idx,
 209                                        (val & ~mask) | bits_set);
 210 }
 211
 212 static void alc_update_coefex_idx(struct hda_codec *codec, hda_nid_t nid,
 213                                   unsigned int coef_idx, unsigned int mask,
 214                                   unsigned int bits_set)
 215 {
 216         coef_mutex_lock(codec);
 217         __alc_update_coefex_idx(codec, nid, coef_idx, mask, bits_set);
 218         coef_mutex_unlock(codec);
 219 }
 220
 221 #define alc_update_coef_idx(codec, coef_idx, mask, bits_set)    \
 222         alc_update_coefex_idx(codec, 0x20, coef_idx, mask, bits_set)
 223
 224 /* a special bypass for COEF 0; read the cached value at the second time */
 225 static unsigned int alc_get_coef0(struct hda_codec *codec)
 226 {
 227         struct alc_spec *spec = codec->spec;
 228
 229         if (!spec->coef0)
 230                 spec->coef0 = alc_read_coef_idx(codec, 0);
 231         return spec->coef0;
 232 }
 233
 234 /* coef writes/updates batch */
 235 struct coef_fw {
 236         unsigned char nid;
 237         unsigned char idx;
 238         unsigned short mask;
 239         unsigned short val;
 240 };
 241
 242 #define UPDATE_COEFEX(_nid, _idx, _mask, _val) \
 243         { .nid = (_nid), .idx = (_idx), .mask = (_mask), .val = (_val) }
 244 #define WRITE_COEFEX(_nid, _idx, _val) UPDATE_COEFEX(_nid, _idx, -1, _val)
 245 #define WRITE_COEF(_idx, _val) WRITE_COEFEX(0x20, _idx, _val)
 246 #define UPDATE_COEF(_idx, _mask, _val) UPDATE_COEFEX(0x20, _idx, _mask, _val)
 247
 248 static void alc_process_coef_fw(struct hda_codec *codec,
 249                                 const struct coef_fw *fw)
 250 {
 251         coef_mutex_lock(codec);
 252         for (; fw->nid; fw++) {
 253                 if (fw->mask == (unsigned short)-1)
 254                         __alc_write_coefex_idx(codec, fw->nid, fw->idx, fw->val);
 255                 else
 256                         __alc_update_coefex_idx(codec, fw->nid, fw->idx,
 257                                                 fw->mask, fw->val);
 258         }
 259         coef_mutex_unlock(codec);
 260 }
 261
 262 /*
 263  * GPIO setup tables, used in initialization
 264  */
 265
 266 /* Enable GPIO mask and set output */
 267 static void alc_setup_gpio(struct hda_codec *codec, unsigned int mask)
 268 {
 269         struct alc_spec *spec = codec->spec;
 270
 271         spec->gpio_mask |= mask;
 272         spec->gpio_dir |= mask;
 273         spec->gpio_data |= mask;
 274 }
 275
 276 static void alc_write_gpio_data(struct hda_codec *codec)
 277 {
 278         struct alc_spec *spec = codec->spec;
 279
 280         snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
 281                             spec->gpio_data);
 282 }
 283
 284 static void alc_update_gpio_data(struct hda_codec *codec, unsigned int mask,
 285                                  bool on)
 286 {
 287         struct alc_spec *spec = codec->spec;
 288         unsigned int oldval = spec->gpio_data;
 289
 290         if (on)
 291                 spec->gpio_data |= mask;
 292         else
 293                 spec->gpio_data &= ~mask;
 294         if (oldval != spec->gpio_data)
 295                 alc_write_gpio_data(codec);
 296 }
 297
 298 static void alc_write_gpio(struct hda_codec *codec)
 299 {
 300         struct alc_spec *spec = codec->spec;
 301
 302         if (!spec->gpio_mask)
 303                 return;
 304
 305         snd_hda_codec_write(codec, codec->core.afg, 0,
 306                             AC_VERB_SET_GPIO_MASK, spec->gpio_mask);
 307         snd_hda_codec_write(codec, codec->core.afg, 0,
 308                             AC_VERB_SET_GPIO_DIRECTION, spec->gpio_dir);
 309         if (spec->gpio_write_delay)
 310                 msleep(1);
 311         alc_write_gpio_data(codec);
 312 }
 313
 314 static void alc_fixup_gpio(struct hda_codec *codec, int action,
 315                            unsigned int mask)
 316 {
 317         if (action == HDA_FIXUP_ACT_PRE_PROBE)
 318                 alc_setup_gpio(codec, mask);
 319 }
 320
 321 static void alc_fixup_gpio1(struct hda_codec *codec,
 322                             const struct hda_fixup *fix, int action)
 323 {
 324         alc_fixup_gpio(codec, action, 0x01);
 325 }
 326
 327 static void alc_fixup_gpio2(struct hda_codec *codec,
 328                             const struct hda_fixup *fix, int action)
 329 {
 330         alc_fixup_gpio(codec, action, 0x02);
 331 }
 332
 333 static void alc_fixup_gpio3(struct hda_codec *codec,
 334                             const struct hda_fixup *fix, int action)
 335 {
 336         alc_fixup_gpio(codec, action, 0x03);
 337 }
 338
 339 static void alc_fixup_gpio4(struct hda_codec *codec,
 340                             const struct hda_fixup *fix, int action)
 341 {
 342         alc_fixup_gpio(codec, action, 0x04);
 343 }
 344
 345 static void alc_fixup_micmute_led(struct hda_codec *codec,
 346                                   const struct hda_fixup *fix, int action)
 347 {
 348         if (action == HDA_FIXUP_ACT_PRE_PROBE)
 349                 snd_hda_gen_add_micmute_led_cdev(codec, NULL);
 350 }
 351
 352 /*
 353  * Fix hardware PLL issue
 354  * On some codecs, the analog PLL gating control must be off while
 355  * the default value is 1.
 356  */
 357 static void alc_fix_pll(struct hda_codec *codec)
 358 {
 359         struct alc_spec *spec = codec->spec;
 360
 361         if (spec->pll_nid)
 362                 alc_update_coefex_idx(codec, spec->pll_nid, spec->pll_coef_idx,
 363                                       1 << spec->pll_coef_bit, 0);
 364 }
 365
 366 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 367                              unsigned int coef_idx, unsigned int coef_bit)
 368 {
 369         struct alc_spec *spec = codec->spec;
 370         spec->pll_nid = nid;
 371         spec->pll_coef_idx = coef_idx;
 372         spec->pll_coef_bit = coef_bit;
 373         alc_fix_pll(codec);
 374 }
 375
 376 /* update the master volume per volume-knob's unsol event */
 377 static void alc_update_knob_master(struct hda_codec *codec,
 378                                    struct hda_jack_callback *jack)
 379 {
 380         unsigned int val;
 381         struct snd_kcontrol *kctl;
 382         struct snd_ctl_elem_value *uctl;
 383
 384         kctl = snd_hda_find_mixer_ctl(codec, "Master Playback Volume");
 385         if (!kctl)
 386                 return;
 387         uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);
 388         if (!uctl)
 389                 return;
 390         val = snd_hda_codec_read(codec, jack->nid, 0,
 391                                  AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
 392         val &= HDA_AMP_VOLMASK;
 393         uctl->value.integer.value[0] = val;
 394         uctl->value.integer.value[1] = val;
 395         kctl->put(kctl, uctl);
 396         kfree(uctl);
 397 }
 398
 399 static void alc880_unsol_event(struct hda_codec *codec, unsigned int res)
 400 {
 401         /* For some reason, the res given from ALC880 is broken.
 402            Here we adjust it properly. */
 403         snd_hda_jack_unsol_event(codec, res >> 2);
 404 }
 405
 406 /* Change EAPD to verb control */
 407 static void alc_fill_eapd_coef(struct hda_codec *codec)
 408 {
 409         int coef;
 410
 411         coef = alc_get_coef0(codec);
 412
 413         switch (codec->core.vendor_id) {
 414         case 0x10ec0262:
 415                 alc_update_coef_idx(codec, 0x7, 0, 1<<5);
 416                 break;
 417         case 0x10ec0267:
 418         case 0x10ec0268:
 419                 alc_update_coef_idx(codec, 0x7, 0, 1<<13);
 420                 break;
 421         case 0x10ec0269:
 422                 if ((coef & 0x00f0) == 0x0010)
 423                         alc_update_coef_idx(codec, 0xd, 0, 1<<14);
 424                 if ((coef & 0x00f0) == 0x0020)
 425                         alc_update_coef_idx(codec, 0x4, 1<<15, 0);
 426                 if ((coef & 0x00f0) == 0x0030)
 427                         alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 428                 break;
 429         case 0x10ec0280:
 430         case 0x10ec0284:
 431         case 0x10ec0290:
 432         case 0x10ec0292:
 433                 alc_update_coef_idx(codec, 0x4, 1<<15, 0);
 434                 break;
 435         case 0x10ec0225:
 436         case 0x10ec0295:
 437         case 0x10ec0299:
 438                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
 439                 fallthrough;
 440         case 0x10ec0215:
 441         case 0x10ec0285:
 442         case 0x10ec0289:
 443                 alc_update_coef_idx(codec, 0x36, 1<<13, 0);
 444                 fallthrough;
 445         case 0x10ec0230:
 446         case 0x10ec0233:
 447         case 0x10ec0235:
 448         case 0x10ec0236:
 449         case 0x10ec0245:
 450         case 0x10ec0255:
 451         case 0x10ec0256:
 452         case 0x19e58326:
 453         case 0x10ec0257:
 454         case 0x10ec0282:
 455         case 0x10ec0283:
 456         case 0x10ec0286:
 457         case 0x10ec0288:
 458         case 0x10ec0298:
 459         case 0x10ec0300:
 460                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 461                 break;
 462         case 0x10ec0275:
 463                 alc_update_coef_idx(codec, 0xe, 0, 1<<0);
 464                 break;
 465         case 0x10ec0287:
 466                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 467                 alc_write_coef_idx(codec, 0x8, 0x4ab7);
 468                 break;
 469         case 0x10ec0293:
 470                 alc_update_coef_idx(codec, 0xa, 1<<13, 0);
 471                 break;
 472         case 0x10ec0234:
 473         case 0x10ec0274:
 474         case 0x10ec0294:
 475         case 0x10ec0700:
 476         case 0x10ec0701:
 477         case 0x10ec0703:
 478         case 0x10ec0711:
 479                 alc_update_coef_idx(codec, 0x10, 1<<15, 0);
 480                 break;
 481         case 0x10ec0662:
 482                 if ((coef & 0x00f0) == 0x0030)
 483                         alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
 484                 break;
 485         case 0x10ec0272:
 486         case 0x10ec0273:
 487         case 0x10ec0663:
 488         case 0x10ec0665:
 489         case 0x10ec0670:
 490         case 0x10ec0671:
 491         case 0x10ec0672:
 492                 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
 493                 break;
 494         case 0x10ec0222:
 495         case 0x10ec0623:
 496                 alc_update_coef_idx(codec, 0x19, 1<<13, 0);
 497                 break;
 498         case 0x10ec0668:
 499                 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
 500                 break;
 501         case 0x10ec0867:
 502                 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
 503                 break;
 504         case 0x10ec0888:
 505                 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
 506                         alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 507                 break;
 508         case 0x10ec0892:
 509         case 0x10ec0897:
 510                 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 511                 break;
 512         case 0x10ec0899:
 513         case 0x10ec0900:
 514         case 0x10ec0b00:
 515         case 0x10ec1168:
 516         case 0x10ec1220:
 517                 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
 518                 break;
 519         }
 520 }
 521
 522 /* additional initialization for ALC888 variants */
 523 static void alc888_coef_init(struct hda_codec *codec)
 524 {
 525         switch (alc_get_coef0(codec) & 0x00f0) {
 526         /* alc888-VA */
 527         case 0x00:
 528         /* alc888-VB */
 529         case 0x10:
 530                 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
 531                 break;
 532         }
 533 }
 534
 535 /* turn on/off EAPD control (only if available) */
 536 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
 537 {
 538         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 539                 return;
 540         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
 541                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 542                                     on ? 2 : 0);
 543 }
 544
 545 /* turn on/off EAPD controls of the codec */
 546 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
 547 {
 548         /* We currently only handle front, HP */
 549         static const hda_nid_t pins[] = {
 550                 0x0f, 0x10, 0x14, 0x15, 0x17, 0
 551         };
 552         const hda_nid_t *p;
 553         for (p = pins; *p; p++)
 554                 set_eapd(codec, *p, on);
 555 }
 556
 557 static int find_ext_mic_pin(struct hda_codec *codec);
 558
 559 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
 560 {
 561         const struct hda_pincfg *pin;
 562         int mic_pin = find_ext_mic_pin(codec);
 563         int i;
 564
 565         /* don't shut up pins when unloading the driver; otherwise it breaks
 566          * the default pin setup at the next load of the driver
 567          */
 568         if (codec->bus->shutdown)
 569                 return;
 570
 571         snd_array_for_each(&codec->init_pins, i, pin) {
 572                 /* use read here for syncing after issuing each verb */
 573                 if (pin->nid != mic_pin)
 574                         snd_hda_codec_read(codec, pin->nid, 0,
 575                                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
 576         }
 577
 578         codec->pins_shutup = 1;
 579 }
 580
 581 static void alc_shutup_pins(struct hda_codec *codec)
 582 {
 583         struct alc_spec *spec = codec->spec;
 584
 585         switch (codec->core.vendor_id) {
 586         case 0x10ec0236:
 587         case 0x10ec0256:
 588         case 0x19e58326:
 589         case 0x10ec0283:
 590         case 0x10ec0286:
 591         case 0x10ec0288:
 592         case 0x10ec0298:
 593                 alc_headset_mic_no_shutup(codec);
 594                 break;
 595         default:
 596                 if (!spec->no_shutup_pins)
 597                         snd_hda_shutup_pins(codec);
 598                 break;
 599         }
 600 }
 601
 602 /* generic shutup callback;
 603  * just turning off EAPD and a little pause for avoiding pop-noise
 604  */
 605 static void alc_eapd_shutup(struct hda_codec *codec)
 606 {
 607         struct alc_spec *spec = codec->spec;
 608
 609         alc_auto_setup_eapd(codec, false);
 610         if (!spec->no_depop_delay)
 611                 msleep(200);
 612         alc_shutup_pins(codec);
 613 }
 614
 615 /* generic EAPD initialization */
 616 static void alc_auto_init_amp(struct hda_codec *codec, int type)
 617 {
 618         alc_auto_setup_eapd(codec, true);
 619         alc_write_gpio(codec);
 620         switch (type) {
 621         case ALC_INIT_DEFAULT:
 622                 switch (codec->core.vendor_id) {
 623                 case 0x10ec0260:
 624                         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
 625                         break;
 626                 case 0x10ec0880:
 627                 case 0x10ec0882:
 628                 case 0x10ec0883:
 629                 case 0x10ec0885:
 630                         alc_update_coef_idx(codec, 7, 0, 0x2030);
 631                         break;
 632                 case 0x10ec0888:
 633                         alc888_coef_init(codec);
 634                         break;
 635                 }
 636                 break;
 637         }
 638 }
 639
 640 /* get a primary headphone pin if available */
 641 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
 642 {
 643         if (spec->gen.autocfg.hp_pins[0])
 644                 return spec->gen.autocfg.hp_pins[0];
 645         if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
 646                 return spec->gen.autocfg.line_out_pins[0];
 647         return 0;
 648 }
 649
 650 /*
 651  * Realtek SSID verification
 652  */
 653
 654 /* Could be any non-zero and even value. When used as fixup, tells
 655  * the driver to ignore any present sku defines.
 656  */
 657 #define ALC_FIXUP_SKU_IGNORE (2)
 658
 659 static void alc_fixup_sku_ignore(struct hda_codec *codec,
 660                                  const struct hda_fixup *fix, int action)
 661 {
 662         struct alc_spec *spec = codec->spec;
 663         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 664                 spec->cdefine.fixup = 1;
 665                 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
 666         }
 667 }
 668
 669 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
 670                                     const struct hda_fixup *fix, int action)
 671 {
 672         struct alc_spec *spec = codec->spec;
 673
 674         if (action == HDA_FIXUP_ACT_PROBE) {
 675                 spec->no_depop_delay = 1;
 676                 codec->depop_delay = 0;
 677         }
 678 }
 679
 680 static int alc_auto_parse_customize_define(struct hda_codec *codec)
 681 {
 682         unsigned int ass, tmp, i;
 683         unsigned nid = 0;
 684         struct alc_spec *spec = codec->spec;
 685
 686         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
 687
 688         if (spec->cdefine.fixup) {
 689                 ass = spec->cdefine.sku_cfg;
 690                 if (ass == ALC_FIXUP_SKU_IGNORE)
 691                         return -1;
 692                 goto do_sku;
 693         }
 694
 695         if (!codec->bus->pci)
 696                 return -1;
 697         ass = codec->core.subsystem_id & 0xffff;
 698         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
 699                 goto do_sku;
 700
 701         nid = 0x1d;
 702         if (codec->core.vendor_id == 0x10ec0260)
 703                 nid = 0x17;
 704         ass = snd_hda_codec_get_pincfg(codec, nid);
 705
 706         if (!(ass & 1)) {
 707                 codec_info(codec, "%s: SKU not ready 0x%08x\n",
 708                            codec->core.chip_name, ass);
 709                 return -1;
 710         }
 711
 712         /* check sum */
 713         tmp = 0;
 714         for (i = 1; i < 16; i++) {
 715                 if ((ass >> i) & 1)
 716                         tmp++;
 717         }
 718         if (((ass >> 16) & 0xf) != tmp)
 719                 return -1;
 720
 721         spec->cdefine.port_connectivity = ass >> 30;
 722         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
 723         spec->cdefine.check_sum = (ass >> 16) & 0xf;
 724         spec->cdefine.customization = ass >> 8;
 725 do_sku:
 726         spec->cdefine.sku_cfg = ass;
 727         spec->cdefine.external_amp = (ass & 0x38) >> 3;
 728         spec->cdefine.platform_type = (ass & 0x4) >> 2;
 729         spec->cdefine.swap = (ass & 0x2) >> 1;
 730         spec->cdefine.override = ass & 0x1;
 731
 732         codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
 733                    nid, spec->cdefine.sku_cfg);
 734         codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
 735                    spec->cdefine.port_connectivity);
 736         codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
 737         codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
 738         codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
 739         codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
 740         codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
 741         codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
 742         codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
 743
 744         return 0;
 745 }
 746
 747 /* return the position of NID in the list, or -1 if not found */
 748 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 749 {
 750         int i;
 751         for (i = 0; i < nums; i++)
 752                 if (list[i] == nid)
 753                         return i;
 754         return -1;
 755 }
 756 /* return true if the given NID is found in the list */
 757 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 758 {
 759         return find_idx_in_nid_list(nid, list, nums) >= 0;
 760 }
 761
 762 /* check subsystem ID and set up device-specific initialization;
 763  * return 1 if initialized, 0 if invalid SSID
 764  */
 765 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 766  *      31 ~ 16 :       Manufacture ID
 767  *      15 ~ 8  :       SKU ID
 768  *      7  ~ 0  :       Assembly ID
 769  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 770  */
 771 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
 772 {
 773         unsigned int ass, tmp, i;
 774         unsigned nid;
 775         struct alc_spec *spec = codec->spec;
 776
 777         if (spec->cdefine.fixup) {
 778                 ass = spec->cdefine.sku_cfg;
 779                 if (ass == ALC_FIXUP_SKU_IGNORE)
 780                         return 0;
 781                 goto do_sku;
 782         }
 783
 784         ass = codec->core.subsystem_id & 0xffff;
 785         if (codec->bus->pci &&
 786             ass != codec->bus->pci->subsystem_device && (ass & 1))
 787                 goto do_sku;
 788
 789         /* invalid SSID, check the special NID pin defcfg instead */
 790         /*
 791          * 31~30        : port connectivity
 792          * 29~21        : reserve
 793          * 20           : PCBEEP input
 794          * 19~16        : Check sum (15:1)
 795          * 15~1         : Custom
 796          * 0            : override
 797         */
 798         nid = 0x1d;
 799         if (codec->core.vendor_id == 0x10ec0260)
 800                 nid = 0x17;
 801         ass = snd_hda_codec_get_pincfg(codec, nid);
 802         codec_dbg(codec,
 803                   "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
 804                    ass, nid);
 805         if (!(ass & 1))
 806                 return 0;
 807         if ((ass >> 30) != 1)   /* no physical connection */
 808                 return 0;
 809
 810         /* check sum */
 811         tmp = 0;
 812         for (i = 1; i < 16; i++) {
 813                 if ((ass >> i) & 1)
 814                         tmp++;
 815         }
 816         if (((ass >> 16) & 0xf) != tmp)
 817                 return 0;
 818 do_sku:
 819         codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
 820                    ass & 0xffff, codec->core.vendor_id);
 821         /*
 822          * 0 : override
 823          * 1 :  Swap Jack
 824          * 2 : 0 --> Desktop, 1 --> Laptop
 825          * 3~5 : External Amplifier control
 826          * 7~6 : Reserved
 827         */
 828         tmp = (ass & 0x38) >> 3;        /* external Amp control */
 829         if (spec->init_amp == ALC_INIT_UNDEFINED) {
 830                 switch (tmp) {
 831                 case 1:
 832                         alc_setup_gpio(codec, 0x01);
 833                         break;
 834                 case 3:
 835                         alc_setup_gpio(codec, 0x02);
 836                         break;
 837                 case 7:
 838                         alc_setup_gpio(codec, 0x04);
 839                         break;
 840                 case 5:
 841                 default:
 842                         spec->init_amp = ALC_INIT_DEFAULT;
 843                         break;
 844                 }
 845         }
 846
 847         /* is laptop or Desktop and enable the function "Mute internal speaker
 848          * when the external headphone out jack is plugged"
 849          */
 850         if (!(ass & 0x8000))
 851                 return 1;
 852         /*
 853          * 10~8 : Jack location
 854          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
 855          * 14~13: Resvered
 856          * 15   : 1 --> enable the function "Mute internal speaker
 857          *              when the external headphone out jack is plugged"
 858          */
 859         if (!alc_get_hp_pin(spec)) {
 860                 hda_nid_t nid;
 861                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
 862                 nid = ports[tmp];
 863                 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
 864                                       spec->gen.autocfg.line_outs))
 865                         return 1;
 866                 spec->gen.autocfg.hp_pins[0] = nid;
 867         }
 868         return 1;
 869 }
 870
 871 /* Check the validity of ALC subsystem-id
 872  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
 873 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
 874 {
 875         if (!alc_subsystem_id(codec, ports)) {
 876                 struct alc_spec *spec = codec->spec;
 877                 if (spec->init_amp == ALC_INIT_UNDEFINED) {
 878                         codec_dbg(codec,
 879                                   "realtek: Enable default setup for auto mode as fallback\n");
 880                         spec->init_amp = ALC_INIT_DEFAULT;
 881                 }
 882         }
 883 }
 884
 885 /*
 886  */
 887
 888 static void alc_fixup_inv_dmic(struct hda_codec *codec,
 889                                const struct hda_fixup *fix, int action)
 890 {
 891         struct alc_spec *spec = codec->spec;
 892
 893         spec->gen.inv_dmic_split = 1;
 894 }
 895
 896
 897 static int alc_build_controls(struct hda_codec *codec)
 898 {
 899         int err;
 900
 901         err = snd_hda_gen_build_controls(codec);
 902         if (err < 0)
 903                 return err;
 904
 905         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
 906         return 0;
 907 }
 908
 909
 910 /*
 911  * Common callbacks
 912  */
 913
 914 static void alc_pre_init(struct hda_codec *codec)
 915 {
 916         alc_fill_eapd_coef(codec);
 917 }
 918
 919 #define is_s3_resume(codec) \
 920         ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
 921 #define is_s4_resume(codec) \
 922         ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
 923
 924 static int alc_init(struct hda_codec *codec)
 925 {
 926         struct alc_spec *spec = codec->spec;
 927
 928         /* hibernation resume needs the full chip initialization */
 929         if (is_s4_resume(codec))
 930                 alc_pre_init(codec);
 931
 932         if (spec->init_hook)
 933                 spec->init_hook(codec);
 934
 935         spec->gen.skip_verbs = 1; /* applied in below */
 936         snd_hda_gen_init(codec);
 937         alc_fix_pll(codec);
 938         alc_auto_init_amp(codec, spec->init_amp);
 939         snd_hda_apply_verbs(codec); /* apply verbs here after own init */
 940
 941         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
 942
 943         return 0;
 944 }
 945
 946 #define alc_free        snd_hda_gen_free
 947
 948 #ifdef CONFIG_PM
 949 static inline void alc_shutup(struct hda_codec *codec)
 950 {
 951         struct alc_spec *spec = codec->spec;
 952
 953         if (!snd_hda_get_bool_hint(codec, "shutup"))
 954                 return; /* disabled explicitly by hints */
 955
 956         if (spec && spec->shutup)
 957                 spec->shutup(codec);
 958         else
 959                 alc_shutup_pins(codec);
 960 }
 961
 962 static void alc_power_eapd(struct hda_codec *codec)
 963 {
 964         alc_auto_setup_eapd(codec, false);
 965 }
 966
 967 static int alc_suspend(struct hda_codec *codec)
 968 {
 969         struct alc_spec *spec = codec->spec;
 970         alc_shutup(codec);
 971         if (spec && spec->power_hook)
 972                 spec->power_hook(codec);
 973         return 0;
 974 }
 975
 976 static int alc_resume(struct hda_codec *codec)
 977 {
 978         struct alc_spec *spec = codec->spec;
 979
 980         if (!spec->no_depop_delay)
 981                 msleep(150); /* to avoid pop noise */
 982         codec->patch_ops.init(codec);
 983         snd_hda_regmap_sync(codec);
 984         hda_call_check_power_status(codec, 0x01);
 985         return 0;
 986 }
 987 #endif
 988
 989 /*
 990  */
 991 static const struct hda_codec_ops alc_patch_ops = {
 992         .build_controls = alc_build_controls,
 993         .build_pcms = snd_hda_gen_build_pcms,
 994         .init = alc_init,
 995         .free = alc_free,
 996         .unsol_event = snd_hda_jack_unsol_event,
 997 #ifdef CONFIG_PM
 998         .resume = alc_resume,
 999         .suspend = alc_suspend,
1000         .check_power_status = snd_hda_gen_check_power_status,
1001 #endif
1002 };
1003
1004
1005 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
1006
1007 /*
1008  * Rename codecs appropriately from COEF value or subvendor id
1009  */
1010 struct alc_codec_rename_table {
1011         unsigned int vendor_id;
1012         unsigned short coef_mask;
1013         unsigned short coef_bits;
1014         const char *name;
1015 };
1016
1017 struct alc_codec_rename_pci_table {
1018         unsigned int codec_vendor_id;
1019         unsigned short pci_subvendor;
1020         unsigned short pci_subdevice;
1021         const char *name;
1022 };
1023
1024 static const struct alc_codec_rename_table rename_tbl[] = {
1025         { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
1026         { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
1027         { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
1028         { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
1029         { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
1030         { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
1031         { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
1032         { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
1033         { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
1034         { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
1035         { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
1036         { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
1037         { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
1038         { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
1039         { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
1040         { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
1041         { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
1042         { } /* terminator */
1043 };
1044
1045 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = {
1046         { 0x10ec0280, 0x1028, 0, "ALC3220" },
1047         { 0x10ec0282, 0x1028, 0, "ALC3221" },
1048         { 0x10ec0283, 0x1028, 0, "ALC3223" },
1049         { 0x10ec0288, 0x1028, 0, "ALC3263" },
1050         { 0x10ec0292, 0x1028, 0, "ALC3226" },
1051         { 0x10ec0293, 0x1028, 0, "ALC3235" },
1052         { 0x10ec0255, 0x1028, 0, "ALC3234" },
1053         { 0x10ec0668, 0x1028, 0, "ALC3661" },
1054         { 0x10ec0275, 0x1028, 0, "ALC3260" },
1055         { 0x10ec0899, 0x1028, 0, "ALC3861" },
1056         { 0x10ec0298, 0x1028, 0, "ALC3266" },
1057         { 0x10ec0236, 0x1028, 0, "ALC3204" },
1058         { 0x10ec0256, 0x1028, 0, "ALC3246" },
1059         { 0x10ec0225, 0x1028, 0, "ALC3253" },
1060         { 0x10ec0295, 0x1028, 0, "ALC3254" },
1061         { 0x10ec0299, 0x1028, 0, "ALC3271" },
1062         { 0x10ec0670, 0x1025, 0, "ALC669X" },
1063         { 0x10ec0676, 0x1025, 0, "ALC679X" },
1064         { 0x10ec0282, 0x1043, 0, "ALC3229" },
1065         { 0x10ec0233, 0x1043, 0, "ALC3236" },
1066         { 0x10ec0280, 0x103c, 0, "ALC3228" },
1067         { 0x10ec0282, 0x103c, 0, "ALC3227" },
1068         { 0x10ec0286, 0x103c, 0, "ALC3242" },
1069         { 0x10ec0290, 0x103c, 0, "ALC3241" },
1070         { 0x10ec0668, 0x103c, 0, "ALC3662" },
1071         { 0x10ec0283, 0x17aa, 0, "ALC3239" },
1072         { 0x10ec0292, 0x17aa, 0, "ALC3232" },
1073         { } /* terminator */
1074 };
1075
1076 static int alc_codec_rename_from_preset(struct hda_codec *codec)
1077 {
1078         const struct alc_codec_rename_table *p;
1079         const struct alc_codec_rename_pci_table *q;
1080
1081         for (p = rename_tbl; p->vendor_id; p++) {
1082                 if (p->vendor_id != codec->core.vendor_id)
1083                         continue;
1084                 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1085                         return alc_codec_rename(codec, p->name);
1086         }
1087
1088         if (!codec->bus->pci)
1089                 return 0;
1090         for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1091                 if (q->codec_vendor_id != codec->core.vendor_id)
1092                         continue;
1093                 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1094                         continue;
1095                 if (!q->pci_subdevice ||
1096                     q->pci_subdevice == codec->bus->pci->subsystem_device)
1097                         return alc_codec_rename(codec, q->name);
1098         }
1099
1100         return 0;
1101 }
1102
1103
1104 /*
1105  * Digital-beep handlers
1106  */
1107 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1108
1109 /* additional beep mixers; private_value will be overwritten */
1110 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1111         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1112         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1113 };
1114
1115 /* set up and create beep controls */
1116 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1117                         int idx, int dir)
1118 {
1119         struct snd_kcontrol_new *knew;
1120         unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1121         int i;
1122
1123         for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1124                 knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1125                                             &alc_beep_mixer[i]);
1126                 if (!knew)
1127                         return -ENOMEM;
1128                 knew->private_value = beep_amp;
1129         }
1130         return 0;
1131 }
1132
1133 static const struct snd_pci_quirk beep_allow_list[] = {
1134         SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1135         SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1136         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1137         SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1138         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1139         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1140         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1141         SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1142         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1143         /* denylist -- no beep available */
1144         SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1145         SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1146         {}
1147 };
1148
1149 static inline int has_cdefine_beep(struct hda_codec *codec)
1150 {
1151         struct alc_spec *spec = codec->spec;
1152         const struct snd_pci_quirk *q;
1153         q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list);
1154         if (q)
1155                 return q->value;
1156         return spec->cdefine.enable_pcbeep;
1157 }
1158 #else
1159 #define set_beep_amp(spec, nid, idx, dir)       0
1160 #define has_cdefine_beep(codec)         0
1161 #endif
1162
1163 /* parse the BIOS configuration and set up the alc_spec */
1164 /* return 1 if successful, 0 if the proper config is not found,
1165  * or a negative error code
1166  */
1167 static int alc_parse_auto_config(struct hda_codec *codec,
1168                                  const hda_nid_t *ignore_nids,
1169                                  const hda_nid_t *ssid_nids)
1170 {
1171         struct alc_spec *spec = codec->spec;
1172         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1173         int err;
1174
1175         err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1176                                        spec->parse_flags);
1177         if (err < 0)
1178                 return err;
1179
1180         if (ssid_nids)
1181                 alc_ssid_check(codec, ssid_nids);
1182
1183         err = snd_hda_gen_parse_auto_config(codec, cfg);
1184         if (err < 0)
1185                 return err;
1186
1187         return 1;
1188 }
1189
1190 /* common preparation job for alc_spec */
1191 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1192 {
1193         struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1194         int err;
1195
1196         if (!spec)
1197                 return -ENOMEM;
1198         codec->spec = spec;
1199         snd_hda_gen_spec_init(&spec->gen);
1200         spec->gen.mixer_nid = mixer_nid;
1201         spec->gen.own_eapd_ctl = 1;
1202         codec->single_adc_amp = 1;
1203         /* FIXME: do we need this for all Realtek codec models? */
1204         codec->spdif_status_reset = 1;
1205         codec->forced_resume = 1;
1206         codec->patch_ops = alc_patch_ops;
1207         mutex_init(&spec->coef_mutex);
1208
1209         err = alc_codec_rename_from_preset(codec);
1210         if (err < 0) {
1211                 kfree(spec);
1212                 return err;
1213         }
1214         return 0;
1215 }
1216
1217 static int alc880_parse_auto_config(struct hda_codec *codec)
1218 {
1219         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1220         static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1221         return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1222 }
1223
1224 /*
1225  * ALC880 fix-ups
1226  */
1227 enum {
1228         ALC880_FIXUP_GPIO1,
1229         ALC880_FIXUP_GPIO2,
1230         ALC880_FIXUP_MEDION_RIM,
1231         ALC880_FIXUP_LG,
1232         ALC880_FIXUP_LG_LW25,
1233         ALC880_FIXUP_W810,
1234         ALC880_FIXUP_EAPD_COEF,
1235         ALC880_FIXUP_TCL_S700,
1236         ALC880_FIXUP_VOL_KNOB,
1237         ALC880_FIXUP_FUJITSU,
1238         ALC880_FIXUP_F1734,
1239         ALC880_FIXUP_UNIWILL,
1240         ALC880_FIXUP_UNIWILL_DIG,
1241         ALC880_FIXUP_Z71V,
1242         ALC880_FIXUP_ASUS_W5A,
1243         ALC880_FIXUP_3ST_BASE,
1244         ALC880_FIXUP_3ST,
1245         ALC880_FIXUP_3ST_DIG,
1246         ALC880_FIXUP_5ST_BASE,
1247         ALC880_FIXUP_5ST,
1248         ALC880_FIXUP_5ST_DIG,
1249         ALC880_FIXUP_6ST_BASE,
1250         ALC880_FIXUP_6ST,
1251         ALC880_FIXUP_6ST_DIG,
1252         ALC880_FIXUP_6ST_AUTOMUTE,
1253 };
1254
1255 /* enable the volume-knob widget support on NID 0x21 */
1256 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1257                                   const struct hda_fixup *fix, int action)
1258 {
1259         if (action == HDA_FIXUP_ACT_PROBE)
1260                 snd_hda_jack_detect_enable_callback(codec, 0x21,
1261                                                     alc_update_knob_master);
1262 }
1263
1264 static const struct hda_fixup alc880_fixups[] = {
1265         [ALC880_FIXUP_GPIO1] = {
1266                 .type = HDA_FIXUP_FUNC,
1267                 .v.func = alc_fixup_gpio1,
1268         },
1269         [ALC880_FIXUP_GPIO2] = {
1270                 .type = HDA_FIXUP_FUNC,
1271                 .v.func = alc_fixup_gpio2,
1272         },
1273         [ALC880_FIXUP_MEDION_RIM] = {
1274                 .type = HDA_FIXUP_VERBS,
1275                 .v.verbs = (const struct hda_verb[]) {
1276                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1277                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1278                         { }
1279                 },
1280                 .chained = true,
1281                 .chain_id = ALC880_FIXUP_GPIO2,
1282         },
1283         [ALC880_FIXUP_LG] = {
1284                 .type = HDA_FIXUP_PINS,
1285                 .v.pins = (const struct hda_pintbl[]) {
1286                         /* disable bogus unused pins */
1287                         { 0x16, 0x411111f0 },
1288                         { 0x18, 0x411111f0 },
1289                         { 0x1a, 0x411111f0 },
1290                         { }
1291                 }
1292         },
1293         [ALC880_FIXUP_LG_LW25] = {
1294                 .type = HDA_FIXUP_PINS,
1295                 .v.pins = (const struct hda_pintbl[]) {
1296                         { 0x1a, 0x0181344f }, /* line-in */
1297                         { 0x1b, 0x0321403f }, /* headphone */
1298                         { }
1299                 }
1300         },
1301         [ALC880_FIXUP_W810] = {
1302                 .type = HDA_FIXUP_PINS,
1303                 .v.pins = (const struct hda_pintbl[]) {
1304                         /* disable bogus unused pins */
1305                         { 0x17, 0x411111f0 },
1306                         { }
1307                 },
1308                 .chained = true,
1309                 .chain_id = ALC880_FIXUP_GPIO2,
1310         },
1311         [ALC880_FIXUP_EAPD_COEF] = {
1312                 .type = HDA_FIXUP_VERBS,
1313                 .v.verbs = (const struct hda_verb[]) {
1314                         /* change to EAPD mode */
1315                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1316                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1317                         {}
1318                 },
1319         },
1320         [ALC880_FIXUP_TCL_S700] = {
1321                 .type = HDA_FIXUP_VERBS,
1322                 .v.verbs = (const struct hda_verb[]) {
1323                         /* change to EAPD mode */
1324                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1325                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
1326                         {}
1327                 },
1328                 .chained = true,
1329                 .chain_id = ALC880_FIXUP_GPIO2,
1330         },
1331         [ALC880_FIXUP_VOL_KNOB] = {
1332                 .type = HDA_FIXUP_FUNC,
1333                 .v.func = alc880_fixup_vol_knob,
1334         },
1335         [ALC880_FIXUP_FUJITSU] = {
1336                 /* override all pins as BIOS on old Amilo is broken */
1337                 .type = HDA_FIXUP_PINS,
1338                 .v.pins = (const struct hda_pintbl[]) {
1339                         { 0x14, 0x0121401f }, /* HP */
1340                         { 0x15, 0x99030120 }, /* speaker */
1341                         { 0x16, 0x99030130 }, /* bass speaker */
1342                         { 0x17, 0x411111f0 }, /* N/A */
1343                         { 0x18, 0x411111f0 }, /* N/A */
1344                         { 0x19, 0x01a19950 }, /* mic-in */
1345                         { 0x1a, 0x411111f0 }, /* N/A */
1346                         { 0x1b, 0x411111f0 }, /* N/A */
1347                         { 0x1c, 0x411111f0 }, /* N/A */
1348                         { 0x1d, 0x411111f0 }, /* N/A */
1349                         { 0x1e, 0x01454140 }, /* SPDIF out */
1350                         { }
1351                 },
1352                 .chained = true,
1353                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1354         },
1355         [ALC880_FIXUP_F1734] = {
1356                 /* almost compatible with FUJITSU, but no bass and SPDIF */
1357                 .type = HDA_FIXUP_PINS,
1358                 .v.pins = (const struct hda_pintbl[]) {
1359                         { 0x14, 0x0121401f }, /* HP */
1360                         { 0x15, 0x99030120 }, /* speaker */
1361                         { 0x16, 0x411111f0 }, /* N/A */
1362                         { 0x17, 0x411111f0 }, /* N/A */
1363                         { 0x18, 0x411111f0 }, /* N/A */
1364                         { 0x19, 0x01a19950 }, /* mic-in */
1365                         { 0x1a, 0x411111f0 }, /* N/A */
1366                         { 0x1b, 0x411111f0 }, /* N/A */
1367                         { 0x1c, 0x411111f0 }, /* N/A */
1368                         { 0x1d, 0x411111f0 }, /* N/A */
1369                         { 0x1e, 0x411111f0 }, /* N/A */
1370                         { }
1371                 },
1372                 .chained = true,
1373                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1374         },
1375         [ALC880_FIXUP_UNIWILL] = {
1376                 /* need to fix HP and speaker pins to be parsed correctly */
1377                 .type = HDA_FIXUP_PINS,
1378                 .v.pins = (const struct hda_pintbl[]) {
1379                         { 0x14, 0x0121411f }, /* HP */
1380                         { 0x15, 0x99030120 }, /* speaker */
1381                         { 0x16, 0x99030130 }, /* bass speaker */
1382                         { }
1383                 },
1384         },
1385         [ALC880_FIXUP_UNIWILL_DIG] = {
1386                 .type = HDA_FIXUP_PINS,
1387                 .v.pins = (const struct hda_pintbl[]) {
1388                         /* disable bogus unused pins */
1389                         { 0x17, 0x411111f0 },
1390                         { 0x19, 0x411111f0 },
1391                         { 0x1b, 0x411111f0 },
1392                         { 0x1f, 0x411111f0 },
1393                         { }
1394                 }
1395         },
1396         [ALC880_FIXUP_Z71V] = {
1397                 .type = HDA_FIXUP_PINS,
1398                 .v.pins = (const struct hda_pintbl[]) {
1399                         /* set up the whole pins as BIOS is utterly broken */
1400                         { 0x14, 0x99030120 }, /* speaker */
1401                         { 0x15, 0x0121411f }, /* HP */
1402                         { 0x16, 0x411111f0 }, /* N/A */
1403                         { 0x17, 0x411111f0 }, /* N/A */
1404                         { 0x18, 0x01a19950 }, /* mic-in */
1405                         { 0x19, 0x411111f0 }, /* N/A */
1406                         { 0x1a, 0x01813031 }, /* line-in */
1407                         { 0x1b, 0x411111f0 }, /* N/A */
1408                         { 0x1c, 0x411111f0 }, /* N/A */
1409                         { 0x1d, 0x411111f0 }, /* N/A */
1410                         { 0x1e, 0x0144111e }, /* SPDIF */
1411                         { }
1412                 }
1413         },
1414         [ALC880_FIXUP_ASUS_W5A] = {
1415                 .type = HDA_FIXUP_PINS,
1416                 .v.pins = (const struct hda_pintbl[]) {
1417                         /* set up the whole pins as BIOS is utterly broken */
1418                         { 0x14, 0x0121411f }, /* HP */
1419                         { 0x15, 0x411111f0 }, /* N/A */
1420                         { 0x16, 0x411111f0 }, /* N/A */
1421                         { 0x17, 0x411111f0 }, /* N/A */
1422                         { 0x18, 0x90a60160 }, /* mic */
1423                         { 0x19, 0x411111f0 }, /* N/A */
1424                         { 0x1a, 0x411111f0 }, /* N/A */
1425                         { 0x1b, 0x411111f0 }, /* N/A */
1426                         { 0x1c, 0x411111f0 }, /* N/A */
1427                         { 0x1d, 0x411111f0 }, /* N/A */
1428                         { 0x1e, 0xb743111e }, /* SPDIF out */
1429                         { }
1430                 },
1431                 .chained = true,
1432                 .chain_id = ALC880_FIXUP_GPIO1,
1433         },
1434         [ALC880_FIXUP_3ST_BASE] = {
1435                 .type = HDA_FIXUP_PINS,
1436                 .v.pins = (const struct hda_pintbl[]) {
1437                         { 0x14, 0x01014010 }, /* line-out */
1438                         { 0x15, 0x411111f0 }, /* N/A */
1439                         { 0x16, 0x411111f0 }, /* N/A */
1440                         { 0x17, 0x411111f0 }, /* N/A */
1441                         { 0x18, 0x01a19c30 }, /* mic-in */
1442                         { 0x19, 0x0121411f }, /* HP */
1443                         { 0x1a, 0x01813031 }, /* line-in */
1444                         { 0x1b, 0x02a19c40 }, /* front-mic */
1445                         { 0x1c, 0x411111f0 }, /* N/A */
1446                         { 0x1d, 0x411111f0 }, /* N/A */
1447                         /* 0x1e is filled in below */
1448                         { 0x1f, 0x411111f0 }, /* N/A */
1449                         { }
1450                 }
1451         },
1452         [ALC880_FIXUP_3ST] = {
1453                 .type = HDA_FIXUP_PINS,
1454                 .v.pins = (const struct hda_pintbl[]) {
1455                         { 0x1e, 0x411111f0 }, /* N/A */
1456                         { }
1457                 },
1458                 .chained = true,
1459                 .chain_id = ALC880_FIXUP_3ST_BASE,
1460         },
1461         [ALC880_FIXUP_3ST_DIG] = {
1462                 .type = HDA_FIXUP_PINS,
1463                 .v.pins = (const struct hda_pintbl[]) {
1464                         { 0x1e, 0x0144111e }, /* SPDIF */
1465                         { }
1466                 },
1467                 .chained = true,
1468                 .chain_id = ALC880_FIXUP_3ST_BASE,
1469         },
1470         [ALC880_FIXUP_5ST_BASE] = {
1471                 .type = HDA_FIXUP_PINS,
1472                 .v.pins = (const struct hda_pintbl[]) {
1473                         { 0x14, 0x01014010 }, /* front */
1474                         { 0x15, 0x411111f0 }, /* N/A */
1475                         { 0x16, 0x01011411 }, /* CLFE */
1476                         { 0x17, 0x01016412 }, /* surr */
1477                         { 0x18, 0x01a19c30 }, /* mic-in */
1478                         { 0x19, 0x0121411f }, /* HP */
1479                         { 0x1a, 0x01813031 }, /* line-in */
1480                         { 0x1b, 0x02a19c40 }, /* front-mic */
1481                         { 0x1c, 0x411111f0 }, /* N/A */
1482                         { 0x1d, 0x411111f0 }, /* N/A */
1483                         /* 0x1e is filled in below */
1484                         { 0x1f, 0x411111f0 }, /* N/A */
1485                         { }
1486                 }
1487         },
1488         [ALC880_FIXUP_5ST] = {
1489                 .type = HDA_FIXUP_PINS,
1490                 .v.pins = (const struct hda_pintbl[]) {
1491                         { 0x1e, 0x411111f0 }, /* N/A */
1492                         { }
1493                 },
1494                 .chained = true,
1495                 .chain_id = ALC880_FIXUP_5ST_BASE,
1496         },
1497         [ALC880_FIXUP_5ST_DIG] = {
1498                 .type = HDA_FIXUP_PINS,
1499                 .v.pins = (const struct hda_pintbl[]) {
1500                         { 0x1e, 0x0144111e }, /* SPDIF */
1501                         { }
1502                 },
1503                 .chained = true,
1504                 .chain_id = ALC880_FIXUP_5ST_BASE,
1505         },
1506         [ALC880_FIXUP_6ST_BASE] = {
1507                 .type = HDA_FIXUP_PINS,
1508                 .v.pins = (const struct hda_pintbl[]) {
1509                         { 0x14, 0x01014010 }, /* front */
1510                         { 0x15, 0x01016412 }, /* surr */
1511                         { 0x16, 0x01011411 }, /* CLFE */
1512                         { 0x17, 0x01012414 }, /* side */
1513                         { 0x18, 0x01a19c30 }, /* mic-in */
1514                         { 0x19, 0x02a19c40 }, /* front-mic */
1515                         { 0x1a, 0x01813031 }, /* line-in */
1516                         { 0x1b, 0x0121411f }, /* HP */
1517                         { 0x1c, 0x411111f0 }, /* N/A */
1518                         { 0x1d, 0x411111f0 }, /* N/A */
1519                         /* 0x1e is filled in below */
1520                         { 0x1f, 0x411111f0 }, /* N/A */
1521                         { }
1522                 }
1523         },
1524         [ALC880_FIXUP_6ST] = {
1525                 .type = HDA_FIXUP_PINS,
1526                 .v.pins = (const struct hda_pintbl[]) {
1527                         { 0x1e, 0x411111f0 }, /* N/A */
1528                         { }
1529                 },
1530                 .chained = true,
1531                 .chain_id = ALC880_FIXUP_6ST_BASE,
1532         },
1533         [ALC880_FIXUP_6ST_DIG] = {
1534                 .type = HDA_FIXUP_PINS,
1535                 .v.pins = (const struct hda_pintbl[]) {
1536                         { 0x1e, 0x0144111e }, /* SPDIF */
1537                         { }
1538                 },
1539                 .chained = true,
1540                 .chain_id = ALC880_FIXUP_6ST_BASE,
1541         },
1542         [ALC880_FIXUP_6ST_AUTOMUTE] = {
1543                 .type = HDA_FIXUP_PINS,
1544                 .v.pins = (const struct hda_pintbl[]) {
1545                         { 0x1b, 0x0121401f }, /* HP with jack detect */
1546                         { }
1547                 },
1548                 .chained_before = true,
1549                 .chain_id = ALC880_FIXUP_6ST_BASE,
1550         },
1551 };
1552
1553 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1554         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1555         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1556         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1557         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1558         SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1559         SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1560         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1561         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1562         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1563         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1564         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1565         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1566         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1567         SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1568         SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1569         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1570         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1571         SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1572         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1573         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1574         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1575         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1576         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1577
1578         /* Below is the copied entries from alc880_quirks.c.
1579          * It's not quite sure whether BIOS sets the correct pin-config table
1580          * on these machines, thus they are kept to be compatible with
1581          * the old static quirks.  Once when it's confirmed to work without
1582          * these overrides, it'd be better to remove.
1583          */
1584         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1585         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1586         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1587         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1588         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1589         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1590         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1591         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1592         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1593         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1594         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1595         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1596         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1597         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1598         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1599         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1600         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1601         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1602         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1603         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1604         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1605         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1606         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1607         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1608         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1609         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1610         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1611         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1612         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1613         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1614         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1615         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1616         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1617         /* default Intel */
1618         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1619         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1620         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1621         {}
1622 };
1623
1624 static const struct hda_model_fixup alc880_fixup_models[] = {
1625         {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1626         {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1627         {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1628         {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1629         {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1630         {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1631         {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1632         {}
1633 };
1634
1635
1636 /*
1637  * OK, here we have finally the patch for ALC880
1638  */
1639 static int patch_alc880(struct hda_codec *codec)
1640 {
1641         struct alc_spec *spec;
1642         int err;
1643
1644         err = alc_alloc_spec(codec, 0x0b);
1645         if (err < 0)
1646                 return err;
1647
1648         spec = codec->spec;
1649         spec->gen.need_dac_fix = 1;
1650         spec->gen.beep_nid = 0x01;
1651
1652         codec->patch_ops.unsol_event = alc880_unsol_event;
1653
1654         alc_pre_init(codec);
1655
1656         snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1657                        alc880_fixups);
1658         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1659
1660         /* automatic parse from the BIOS config */
1661         err = alc880_parse_auto_config(codec);
1662         if (err < 0)
1663                 goto error;
1664
1665         if (!spec->gen.no_analog) {
1666                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1667                 if (err < 0)
1668                         goto error;
1669         }
1670
1671         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1672
1673         return 0;
1674
1675  error:
1676         alc_free(codec);
1677         return err;
1678 }
1679
1680
1681 /*
1682  * ALC260 support
1683  */
1684 static int alc260_parse_auto_config(struct hda_codec *codec)
1685 {
1686         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1687         static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1688         return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1689 }
1690
1691 /*
1692  * Pin config fixes
1693  */
1694 enum {
1695         ALC260_FIXUP_HP_DC5750,
1696         ALC260_FIXUP_HP_PIN_0F,
1697         ALC260_FIXUP_COEF,
1698         ALC260_FIXUP_GPIO1,
1699         ALC260_FIXUP_GPIO1_TOGGLE,
1700         ALC260_FIXUP_REPLACER,
1701         ALC260_FIXUP_HP_B1900,
1702         ALC260_FIXUP_KN1,
1703         ALC260_FIXUP_FSC_S7020,
1704         ALC260_FIXUP_FSC_S7020_JWSE,
1705         ALC260_FIXUP_VAIO_PINS,
1706 };
1707
1708 static void alc260_gpio1_automute(struct hda_codec *codec)
1709 {
1710         struct alc_spec *spec = codec->spec;
1711
1712         alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1713 }
1714
1715 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1716                                       const struct hda_fixup *fix, int action)
1717 {
1718         struct alc_spec *spec = codec->spec;
1719         if (action == HDA_FIXUP_ACT_PROBE) {
1720                 /* although the machine has only one output pin, we need to
1721                  * toggle GPIO1 according to the jack state
1722                  */
1723                 spec->gen.automute_hook = alc260_gpio1_automute;
1724                 spec->gen.detect_hp = 1;
1725                 spec->gen.automute_speaker = 1;
1726                 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1727                 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1728                                                     snd_hda_gen_hp_automute);
1729                 alc_setup_gpio(codec, 0x01);
1730         }
1731 }
1732
1733 static void alc260_fixup_kn1(struct hda_codec *codec,
1734                              const struct hda_fixup *fix, int action)
1735 {
1736         struct alc_spec *spec = codec->spec;
1737         static const struct hda_pintbl pincfgs[] = {
1738                 { 0x0f, 0x02214000 }, /* HP/speaker */
1739                 { 0x12, 0x90a60160 }, /* int mic */
1740                 { 0x13, 0x02a19000 }, /* ext mic */
1741                 { 0x18, 0x01446000 }, /* SPDIF out */
1742                 /* disable bogus I/O pins */
1743                 { 0x10, 0x411111f0 },
1744                 { 0x11, 0x411111f0 },
1745                 { 0x14, 0x411111f0 },
1746                 { 0x15, 0x411111f0 },
1747                 { 0x16, 0x411111f0 },
1748                 { 0x17, 0x411111f0 },
1749                 { 0x19, 0x411111f0 },
1750                 { }
1751         };
1752
1753         switch (action) {
1754         case HDA_FIXUP_ACT_PRE_PROBE:
1755                 snd_hda_apply_pincfgs(codec, pincfgs);
1756                 spec->init_amp = ALC_INIT_NONE;
1757                 break;
1758         }
1759 }
1760
1761 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1762                                    const struct hda_fixup *fix, int action)
1763 {
1764         struct alc_spec *spec = codec->spec;
1765         if (action == HDA_FIXUP_ACT_PRE_PROBE)
1766                 spec->init_amp = ALC_INIT_NONE;
1767 }
1768
1769 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1770                                    const struct hda_fixup *fix, int action)
1771 {
1772         struct alc_spec *spec = codec->spec;
1773         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1774                 spec->gen.add_jack_modes = 1;
1775                 spec->gen.hp_mic = 1;
1776         }
1777 }
1778
1779 static const struct hda_fixup alc260_fixups[] = {
1780         [ALC260_FIXUP_HP_DC5750] = {
1781                 .type = HDA_FIXUP_PINS,
1782                 .v.pins = (const struct hda_pintbl[]) {
1783                         { 0x11, 0x90130110 }, /* speaker */
1784                         { }
1785                 }
1786         },
1787         [ALC260_FIXUP_HP_PIN_0F] = {
1788                 .type = HDA_FIXUP_PINS,
1789                 .v.pins = (const struct hda_pintbl[]) {
1790                         { 0x0f, 0x01214000 }, /* HP */
1791                         { }
1792                 }
1793         },
1794         [ALC260_FIXUP_COEF] = {
1795                 .type = HDA_FIXUP_VERBS,
1796                 .v.verbs = (const struct hda_verb[]) {
1797                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1798                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
1799                         { }
1800                 },
1801         },
1802         [ALC260_FIXUP_GPIO1] = {
1803                 .type = HDA_FIXUP_FUNC,
1804                 .v.func = alc_fixup_gpio1,
1805         },
1806         [ALC260_FIXUP_GPIO1_TOGGLE] = {
1807                 .type = HDA_FIXUP_FUNC,
1808                 .v.func = alc260_fixup_gpio1_toggle,
1809                 .chained = true,
1810                 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1811         },
1812         [ALC260_FIXUP_REPLACER] = {
1813                 .type = HDA_FIXUP_VERBS,
1814                 .v.verbs = (const struct hda_verb[]) {
1815                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1816                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3050 },
1817                         { }
1818                 },
1819                 .chained = true,
1820                 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1821         },
1822         [ALC260_FIXUP_HP_B1900] = {
1823                 .type = HDA_FIXUP_FUNC,
1824                 .v.func = alc260_fixup_gpio1_toggle,
1825                 .chained = true,
1826                 .chain_id = ALC260_FIXUP_COEF,
1827         },
1828         [ALC260_FIXUP_KN1] = {
1829                 .type = HDA_FIXUP_FUNC,
1830                 .v.func = alc260_fixup_kn1,
1831         },
1832         [ALC260_FIXUP_FSC_S7020] = {
1833                 .type = HDA_FIXUP_FUNC,
1834                 .v.func = alc260_fixup_fsc_s7020,
1835         },
1836         [ALC260_FIXUP_FSC_S7020_JWSE] = {
1837                 .type = HDA_FIXUP_FUNC,
1838                 .v.func = alc260_fixup_fsc_s7020_jwse,
1839                 .chained = true,
1840                 .chain_id = ALC260_FIXUP_FSC_S7020,
1841         },
1842         [ALC260_FIXUP_VAIO_PINS] = {
1843                 .type = HDA_FIXUP_PINS,
1844                 .v.pins = (const struct hda_pintbl[]) {
1845                         /* Pin configs are missing completely on some VAIOs */
1846                         { 0x0f, 0x01211020 },
1847                         { 0x10, 0x0001003f },
1848                         { 0x11, 0x411111f0 },
1849                         { 0x12, 0x01a15930 },
1850                         { 0x13, 0x411111f0 },
1851                         { 0x14, 0x411111f0 },
1852                         { 0x15, 0x411111f0 },
1853                         { 0x16, 0x411111f0 },
1854                         { 0x17, 0x411111f0 },
1855                         { 0x18, 0x411111f0 },
1856                         { 0x19, 0x411111f0 },
1857                         { }
1858                 }
1859         },
1860 };
1861
1862 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1863         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1864         SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1865         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1866         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1867         SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1868         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1869         SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1870         SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1871         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1872         SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1873         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1874         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1875         {}
1876 };
1877
1878 static const struct hda_model_fixup alc260_fixup_models[] = {
1879         {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1880         {.id = ALC260_FIXUP_COEF, .name = "coef"},
1881         {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1882         {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1883         {}
1884 };
1885
1886 /*
1887  */
1888 static int patch_alc260(struct hda_codec *codec)
1889 {
1890         struct alc_spec *spec;
1891         int err;
1892
1893         err = alc_alloc_spec(codec, 0x07);
1894         if (err < 0)
1895                 return err;
1896
1897         spec = codec->spec;
1898         /* as quite a few machines require HP amp for speaker outputs,
1899          * it's easier to enable it unconditionally; even if it's unneeded,
1900          * it's almost harmless.
1901          */
1902         spec->gen.prefer_hp_amp = 1;
1903         spec->gen.beep_nid = 0x01;
1904
1905         spec->shutup = alc_eapd_shutup;
1906
1907         alc_pre_init(codec);
1908
1909         snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1910                            alc260_fixups);
1911         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1912
1913         /* automatic parse from the BIOS config */
1914         err = alc260_parse_auto_config(codec);
1915         if (err < 0)
1916                 goto error;
1917
1918         if (!spec->gen.no_analog) {
1919                 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1920                 if (err < 0)
1921                         goto error;
1922         }
1923
1924         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1925
1926         return 0;
1927
1928  error:
1929         alc_free(codec);
1930         return err;
1931 }
1932
1933
1934 /*
1935  * ALC882/883/885/888/889 support
1936  *
1937  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1938  * configuration.  Each pin widget can choose any input DACs and a mixer.
1939  * Each ADC is connected from a mixer of all inputs.  This makes possible
1940  * 6-channel independent captures.
1941  *
1942  * In addition, an independent DAC for the multi-playback (not used in this
1943  * driver yet).
1944  */
1945
1946 /*
1947  * Pin config fixes
1948  */
1949 enum {
1950         ALC882_FIXUP_ABIT_AW9D_MAX,
1951         ALC882_FIXUP_LENOVO_Y530,
1952         ALC882_FIXUP_PB_M5210,
1953         ALC882_FIXUP_ACER_ASPIRE_7736,
1954         ALC882_FIXUP_ASUS_W90V,
1955         ALC889_FIXUP_CD,
1956         ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1957         ALC889_FIXUP_VAIO_TT,
1958         ALC888_FIXUP_EEE1601,
1959         ALC886_FIXUP_EAPD,
1960         ALC882_FIXUP_EAPD,
1961         ALC883_FIXUP_EAPD,
1962         ALC883_FIXUP_ACER_EAPD,
1963         ALC882_FIXUP_GPIO1,
1964         ALC882_FIXUP_GPIO2,
1965         ALC882_FIXUP_GPIO3,
1966         ALC889_FIXUP_COEF,
1967         ALC882_FIXUP_ASUS_W2JC,
1968         ALC882_FIXUP_ACER_ASPIRE_4930G,
1969         ALC882_FIXUP_ACER_ASPIRE_8930G,
1970         ALC882_FIXUP_ASPIRE_8930G_VERBS,
1971         ALC885_FIXUP_MACPRO_GPIO,
1972         ALC889_FIXUP_DAC_ROUTE,
1973         ALC889_FIXUP_MBP_VREF,
1974         ALC889_FIXUP_IMAC91_VREF,
1975         ALC889_FIXUP_MBA11_VREF,
1976         ALC889_FIXUP_MBA21_VREF,
1977         ALC889_FIXUP_MP11_VREF,
1978         ALC889_FIXUP_MP41_VREF,
1979         ALC882_FIXUP_INV_DMIC,
1980         ALC882_FIXUP_NO_PRIMARY_HP,
1981         ALC887_FIXUP_ASUS_BASS,
1982         ALC887_FIXUP_BASS_CHMAP,
1983         ALC1220_FIXUP_GB_DUAL_CODECS,
1984         ALC1220_FIXUP_GB_X570,
1985         ALC1220_FIXUP_CLEVO_P950,
1986         ALC1220_FIXUP_CLEVO_PB51ED,
1987         ALC1220_FIXUP_CLEVO_PB51ED_PINS,
1988         ALC887_FIXUP_ASUS_AUDIO,
1989         ALC887_FIXUP_ASUS_HMIC,
1990         ALCS1200A_FIXUP_MIC_VREF,
1991         ALC888VD_FIXUP_MIC_100VREF,
1992 };
1993
1994 static void alc889_fixup_coef(struct hda_codec *codec,
1995                               const struct hda_fixup *fix, int action)
1996 {
1997         if (action != HDA_FIXUP_ACT_INIT)
1998                 return;
1999         alc_update_coef_idx(codec, 7, 0, 0x2030);
2000 }
2001
2002 /* set up GPIO at initialization */
2003 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
2004                                      const struct hda_fixup *fix, int action)
2005 {
2006         struct alc_spec *spec = codec->spec;
2007
2008         spec->gpio_write_delay = true;
2009         alc_fixup_gpio3(codec, fix, action);
2010 }
2011
2012 /* Fix the connection of some pins for ALC889:
2013  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
2014  * work correctly (bko#42740)
2015  */
2016 static void alc889_fixup_dac_route(struct hda_codec *codec,
2017                                    const struct hda_fixup *fix, int action)
2018 {
2019         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2020                 /* fake the connections during parsing the tree */
2021                 static const hda_nid_t conn1[] = { 0x0c, 0x0d };
2022                 static const hda_nid_t conn2[] = { 0x0e, 0x0f };
2023                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2024                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
2025                 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2);
2026                 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2);
2027         } else if (action == HDA_FIXUP_ACT_PROBE) {
2028                 /* restore the connections */
2029                 static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
2030                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
2031                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
2032                 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn);
2033                 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn);
2034         }
2035 }
2036
2037 /* Set VREF on HP pin */
2038 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
2039                                   const struct hda_fixup *fix, int action)
2040 {
2041         static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 };
2042         struct alc_spec *spec = codec->spec;
2043         int i;
2044
2045         if (action != HDA_FIXUP_ACT_INIT)
2046                 return;
2047         for (i = 0; i < ARRAY_SIZE(nids); i++) {
2048                 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
2049                 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
2050                         continue;
2051                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2052                 val |= AC_PINCTL_VREF_80;
2053                 snd_hda_set_pin_ctl(codec, nids[i], val);
2054                 spec->gen.keep_vref_in_automute = 1;
2055                 break;
2056         }
2057 }
2058
2059 static void alc889_fixup_mac_pins(struct hda_codec *codec,
2060                                   const hda_nid_t *nids, int num_nids)
2061 {
2062         struct alc_spec *spec = codec->spec;
2063         int i;
2064
2065         for (i = 0; i < num_nids; i++) {
2066                 unsigned int val;
2067                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2068                 val |= AC_PINCTL_VREF_50;
2069                 snd_hda_set_pin_ctl(codec, nids[i], val);
2070         }
2071         spec->gen.keep_vref_in_automute = 1;
2072 }
2073
2074 /* Set VREF on speaker pins on imac91 */
2075 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
2076                                      const struct hda_fixup *fix, int action)
2077 {
2078         static const hda_nid_t nids[] = { 0x18, 0x1a };
2079
2080         if (action == HDA_FIXUP_ACT_INIT)
2081                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2082 }
2083
2084 /* Set VREF on speaker pins on mba11 */
2085 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2086                                     const struct hda_fixup *fix, int action)
2087 {
2088         static const hda_nid_t nids[] = { 0x18 };
2089
2090         if (action == HDA_FIXUP_ACT_INIT)
2091                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2092 }
2093
2094 /* Set VREF on speaker pins on mba21 */
2095 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2096                                     const struct hda_fixup *fix, int action)
2097 {
2098         static const hda_nid_t nids[] = { 0x18, 0x19 };
2099
2100         if (action == HDA_FIXUP_ACT_INIT)
2101                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2102 }
2103
2104 /* Don't take HP output as primary
2105  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
2106  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
2107  */
2108 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2109                                        const struct hda_fixup *fix, int action)
2110 {
2111         struct alc_spec *spec = codec->spec;
2112         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2113                 spec->gen.no_primary_hp = 1;
2114                 spec->gen.no_multi_io = 1;
2115         }
2116 }
2117
2118 static void alc_fixup_bass_chmap(struct hda_codec *codec,
2119                                  const struct hda_fixup *fix, int action);
2120
2121 /* For dual-codec configuration, we need to disable some features to avoid
2122  * conflicts of kctls and PCM streams
2123  */
2124 static void alc_fixup_dual_codecs(struct hda_codec *codec,
2125                                   const struct hda_fixup *fix, int action)
2126 {
2127         struct alc_spec *spec = codec->spec;
2128
2129         if (action != HDA_FIXUP_ACT_PRE_PROBE)
2130                 return;
2131         /* disable vmaster */
2132         spec->gen.suppress_vmaster = 1;
2133         /* auto-mute and auto-mic switch don't work with multiple codecs */
2134         spec->gen.suppress_auto_mute = 1;
2135         spec->gen.suppress_auto_mic = 1;
2136         /* disable aamix as well */
2137         spec->gen.mixer_nid = 0;
2138         /* add location prefix to avoid conflicts */
2139         codec->force_pin_prefix = 1;
2140 }
2141
2142 static void rename_ctl(struct hda_codec *codec, const char *oldname,
2143                        const char *newname)
2144 {
2145         struct snd_kcontrol *kctl;
2146
2147         kctl = snd_hda_find_mixer_ctl(codec, oldname);
2148         if (kctl)
2149                 snd_ctl_rename(codec->card, kctl, newname);
2150 }
2151
2152 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2153                                          const struct hda_fixup *fix,
2154                                          int action)
2155 {
2156         alc_fixup_dual_codecs(codec, fix, action);
2157         switch (action) {
2158         case HDA_FIXUP_ACT_PRE_PROBE:
2159                 /* override card longname to provide a unique UCM profile */
2160                 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2161                 break;
2162         case HDA_FIXUP_ACT_BUILD:
2163                 /* rename Capture controls depending on the codec */
2164                 rename_ctl(codec, "Capture Volume",
2165                            codec->addr == 0 ?
2166                            "Rear-Panel Capture Volume" :
2167                            "Front-Panel Capture Volume");
2168                 rename_ctl(codec, "Capture Switch",
2169                            codec->addr == 0 ?
2170                            "Rear-Panel Capture Switch" :
2171                            "Front-Panel Capture Switch");
2172                 break;
2173         }
2174 }
2175
2176 static void alc1220_fixup_gb_x570(struct hda_codec *codec,
2177                                      const struct hda_fixup *fix,
2178                                      int action)
2179 {
2180         static const hda_nid_t conn1[] = { 0x0c };
2181         static const struct coef_fw gb_x570_coefs[] = {
2182                 WRITE_COEF(0x07, 0x03c0),
2183                 WRITE_COEF(0x1a, 0x01c1),
2184                 WRITE_COEF(0x1b, 0x0202),
2185                 WRITE_COEF(0x43, 0x3005),
2186                 {}
2187         };
2188
2189         switch (action) {
2190         case HDA_FIXUP_ACT_PRE_PROBE:
2191                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2192                 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2193                 break;
2194         case HDA_FIXUP_ACT_INIT:
2195                 alc_process_coef_fw(codec, gb_x570_coefs);
2196                 break;
2197         }
2198 }
2199
2200 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2201                                      const struct hda_fixup *fix,
2202                                      int action)
2203 {
2204         static const hda_nid_t conn1[] = { 0x0c };
2205
2206         if (action != HDA_FIXUP_ACT_PRE_PROBE)
2207                 return;
2208
2209         alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2210         /* We therefore want to make sure 0x14 (front headphone) and
2211          * 0x1b (speakers) use the stereo DAC 0x02
2212          */
2213         snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2214         snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2215 }
2216
2217 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2218                                 const struct hda_fixup *fix, int action);
2219
2220 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2221                                      const struct hda_fixup *fix,
2222                                      int action)
2223 {
2224         alc1220_fixup_clevo_p950(codec, fix, action);
2225         alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2226 }
2227
2228 static void alc887_asus_hp_automute_hook(struct hda_codec *codec,
2229                                          struct hda_jack_callback *jack)
2230 {
2231         struct alc_spec *spec = codec->spec;
2232         unsigned int vref;
2233
2234         snd_hda_gen_hp_automute(codec, jack);
2235
2236         if (spec->gen.hp_jack_present)
2237                 vref = AC_PINCTL_VREF_80;
2238         else
2239                 vref = AC_PINCTL_VREF_HIZ;
2240         snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref);
2241 }
2242
2243 static void alc887_fixup_asus_jack(struct hda_codec *codec,
2244                                      const struct hda_fixup *fix, int action)
2245 {
2246         struct alc_spec *spec = codec->spec;
2247         if (action != HDA_FIXUP_ACT_PROBE)
2248                 return;
2249         snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP);
2250         spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook;
2251 }
2252
2253 static const struct hda_fixup alc882_fixups[] = {
2254         [ALC882_FIXUP_ABIT_AW9D_MAX] = {
2255                 .type = HDA_FIXUP_PINS,
2256                 .v.pins = (const struct hda_pintbl[]) {
2257                         { 0x15, 0x01080104 }, /* side */
2258                         { 0x16, 0x01011012 }, /* rear */
2259                         { 0x17, 0x01016011 }, /* clfe */
2260                         { }
2261                 }
2262         },
2263         [ALC882_FIXUP_LENOVO_Y530] = {
2264                 .type = HDA_FIXUP_PINS,
2265                 .v.pins = (const struct hda_pintbl[]) {
2266                         { 0x15, 0x99130112 }, /* rear int speakers */
2267                         { 0x16, 0x99130111 }, /* subwoofer */
2268                         { }
2269                 }
2270         },
2271         [ALC882_FIXUP_PB_M5210] = {
2272                 .type = HDA_FIXUP_PINCTLS,
2273                 .v.pins = (const struct hda_pintbl[]) {
2274                         { 0x19, PIN_VREF50 },
2275                         {}
2276                 }
2277         },
2278         [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2279                 .type = HDA_FIXUP_FUNC,
2280                 .v.func = alc_fixup_sku_ignore,
2281         },
2282         [ALC882_FIXUP_ASUS_W90V] = {
2283                 .type = HDA_FIXUP_PINS,
2284                 .v.pins = (const struct hda_pintbl[]) {
2285                         { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2286                         { }
2287                 }
2288         },
2289         [ALC889_FIXUP_CD] = {
2290                 .type = HDA_FIXUP_PINS,
2291                 .v.pins = (const struct hda_pintbl[]) {
2292                         { 0x1c, 0x993301f0 }, /* CD */
2293                         { }
2294                 }
2295         },
2296         [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2297                 .type = HDA_FIXUP_PINS,
2298                 .v.pins = (const struct hda_pintbl[]) {
2299                         { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2300                         { }
2301                 },
2302                 .chained = true,
2303                 .chain_id = ALC889_FIXUP_CD,
2304         },
2305         [ALC889_FIXUP_VAIO_TT] = {
2306                 .type = HDA_FIXUP_PINS,
2307                 .v.pins = (const struct hda_pintbl[]) {
2308                         { 0x17, 0x90170111 }, /* hidden surround speaker */
2309                         { }
2310                 }
2311         },
2312         [ALC888_FIXUP_EEE1601] = {
2313                 .type = HDA_FIXUP_VERBS,
2314                 .v.verbs = (const struct hda_verb[]) {
2315                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2316                         { 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2317                         { }
2318                 }
2319         },
2320         [ALC886_FIXUP_EAPD] = {
2321                 .type = HDA_FIXUP_VERBS,
2322                 .v.verbs = (const struct hda_verb[]) {
2323                         /* change to EAPD mode */
2324                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2325                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0068 },
2326                         { }
2327                 }
2328         },
2329         [ALC882_FIXUP_EAPD] = {
2330                 .type = HDA_FIXUP_VERBS,
2331                 .v.verbs = (const struct hda_verb[]) {
2332                         /* change to EAPD mode */
2333                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2334                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2335                         { }
2336                 }
2337         },
2338         [ALC883_FIXUP_EAPD] = {
2339                 .type = HDA_FIXUP_VERBS,
2340                 .v.verbs = (const struct hda_verb[]) {
2341                         /* change to EAPD mode */
2342                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2343                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2344                         { }
2345                 }
2346         },
2347         [ALC883_FIXUP_ACER_EAPD] = {
2348                 .type = HDA_FIXUP_VERBS,
2349                 .v.verbs = (const struct hda_verb[]) {
2350                         /* eanable EAPD on Acer laptops */
2351                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2352                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2353                         { }
2354                 }
2355         },
2356         [ALC882_FIXUP_GPIO1] = {
2357                 .type = HDA_FIXUP_FUNC,
2358                 .v.func = alc_fixup_gpio1,
2359         },
2360         [ALC882_FIXUP_GPIO2] = {
2361                 .type = HDA_FIXUP_FUNC,
2362                 .v.func = alc_fixup_gpio2,
2363         },
2364         [ALC882_FIXUP_GPIO3] = {
2365                 .type = HDA_FIXUP_FUNC,
2366                 .v.func = alc_fixup_gpio3,
2367         },
2368         [ALC882_FIXUP_ASUS_W2JC] = {
2369                 .type = HDA_FIXUP_FUNC,
2370                 .v.func = alc_fixup_gpio1,
2371                 .chained = true,
2372                 .chain_id = ALC882_FIXUP_EAPD,
2373         },
2374         [ALC889_FIXUP_COEF] = {
2375                 .type = HDA_FIXUP_FUNC,
2376                 .v.func = alc889_fixup_coef,
2377         },
2378         [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2379                 .type = HDA_FIXUP_PINS,
2380                 .v.pins = (const struct hda_pintbl[]) {
2381                         { 0x16, 0x99130111 }, /* CLFE speaker */
2382                         { 0x17, 0x99130112 }, /* surround speaker */
2383                         { }
2384                 },
2385                 .chained = true,
2386                 .chain_id = ALC882_FIXUP_GPIO1,
2387         },
2388         [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2389                 .type = HDA_FIXUP_PINS,
2390                 .v.pins = (const struct hda_pintbl[]) {
2391                         { 0x16, 0x99130111 }, /* CLFE speaker */
2392                         { 0x1b, 0x99130112 }, /* surround speaker */
2393                         { }
2394                 },
2395                 .chained = true,
2396                 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2397         },
2398         [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2399                 /* additional init verbs for Acer Aspire 8930G */
2400                 .type = HDA_FIXUP_VERBS,
2401                 .v.verbs = (const struct hda_verb[]) {
2402                         /* Enable all DACs */
2403                         /* DAC DISABLE/MUTE 1? */
2404                         /*  setting bits 1-5 disables DAC nids 0x02-0x06
2405                          *  apparently. Init=0x38 */
2406                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2407                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2408                         /* DAC DISABLE/MUTE 2? */
2409                         /*  some bit here disables the other DACs.
2410                          *  Init=0x4900 */
2411                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2412                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2413                         /* DMIC fix
2414                          * This laptop has a stereo digital microphone.
2415                          * The mics are only 1cm apart which makes the stereo
2416                          * useless. However, either the mic or the ALC889
2417                          * makes the signal become a difference/sum signal
2418                          * instead of standard stereo, which is annoying.
2419                          * So instead we flip this bit which makes the
2420                          * codec replicate the sum signal to both channels,
2421                          * turning it into a normal mono mic.
2422                          */
2423                         /* DMIC_CONTROL? Init value = 0x0001 */
2424                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2425                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2426                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2427                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2428                         { }
2429                 },
2430                 .chained = true,
2431                 .chain_id = ALC882_FIXUP_GPIO1,
2432         },
2433         [ALC885_FIXUP_MACPRO_GPIO] = {
2434                 .type = HDA_FIXUP_FUNC,
2435                 .v.func = alc885_fixup_macpro_gpio,
2436         },
2437         [ALC889_FIXUP_DAC_ROUTE] = {
2438                 .type = HDA_FIXUP_FUNC,
2439                 .v.func = alc889_fixup_dac_route,
2440         },
2441         [ALC889_FIXUP_MBP_VREF] = {
2442                 .type = HDA_FIXUP_FUNC,
2443                 .v.func = alc889_fixup_mbp_vref,
2444                 .chained = true,
2445                 .chain_id = ALC882_FIXUP_GPIO1,
2446         },
2447         [ALC889_FIXUP_IMAC91_VREF] = {
2448                 .type = HDA_FIXUP_FUNC,
2449                 .v.func = alc889_fixup_imac91_vref,
2450                 .chained = true,
2451                 .chain_id = ALC882_FIXUP_GPIO1,
2452         },
2453         [ALC889_FIXUP_MBA11_VREF] = {
2454                 .type = HDA_FIXUP_FUNC,
2455                 .v.func = alc889_fixup_mba11_vref,
2456                 .chained = true,
2457                 .chain_id = ALC889_FIXUP_MBP_VREF,
2458         },
2459         [ALC889_FIXUP_MBA21_VREF] = {
2460                 .type = HDA_FIXUP_FUNC,
2461                 .v.func = alc889_fixup_mba21_vref,
2462                 .chained = true,
2463                 .chain_id = ALC889_FIXUP_MBP_VREF,
2464         },
2465         [ALC889_FIXUP_MP11_VREF] = {
2466                 .type = HDA_FIXUP_FUNC,
2467                 .v.func = alc889_fixup_mba11_vref,
2468                 .chained = true,
2469                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2470         },
2471         [ALC889_FIXUP_MP41_VREF] = {
2472                 .type = HDA_FIXUP_FUNC,
2473                 .v.func = alc889_fixup_mbp_vref,
2474                 .chained = true,
2475                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2476         },
2477         [ALC882_FIXUP_INV_DMIC] = {
2478                 .type = HDA_FIXUP_FUNC,
2479                 .v.func = alc_fixup_inv_dmic,
2480         },
2481         [ALC882_FIXUP_NO_PRIMARY_HP] = {
2482                 .type = HDA_FIXUP_FUNC,
2483                 .v.func = alc882_fixup_no_primary_hp,
2484         },
2485         [ALC887_FIXUP_ASUS_BASS] = {
2486                 .type = HDA_FIXUP_PINS,
2487                 .v.pins = (const struct hda_pintbl[]) {
2488                         {0x16, 0x99130130}, /* bass speaker */
2489                         {}
2490                 },
2491                 .chained = true,
2492                 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2493         },
2494         [ALC887_FIXUP_BASS_CHMAP] = {
2495                 .type = HDA_FIXUP_FUNC,
2496                 .v.func = alc_fixup_bass_chmap,
2497         },
2498         [ALC1220_FIXUP_GB_DUAL_CODECS] = {
2499                 .type = HDA_FIXUP_FUNC,
2500                 .v.func = alc1220_fixup_gb_dual_codecs,
2501         },
2502         [ALC1220_FIXUP_GB_X570] = {
2503                 .type = HDA_FIXUP_FUNC,
2504                 .v.func = alc1220_fixup_gb_x570,
2505         },
2506         [ALC1220_FIXUP_CLEVO_P950] = {
2507                 .type = HDA_FIXUP_FUNC,
2508                 .v.func = alc1220_fixup_clevo_p950,
2509         },
2510         [ALC1220_FIXUP_CLEVO_PB51ED] = {
2511                 .type = HDA_FIXUP_FUNC,
2512                 .v.func = alc1220_fixup_clevo_pb51ed,
2513         },
2514         [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2515                 .type = HDA_FIXUP_PINS,
2516                 .v.pins = (const struct hda_pintbl[]) {
2517                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
2518                         {}
2519                 },
2520                 .chained = true,
2521                 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2522         },
2523         [ALC887_FIXUP_ASUS_AUDIO] = {
2524                 .type = HDA_FIXUP_PINS,
2525                 .v.pins = (const struct hda_pintbl[]) {
2526                         { 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */
2527                         { 0x19, 0x22219420 },
2528                         {}
2529                 },
2530         },
2531         [ALC887_FIXUP_ASUS_HMIC] = {
2532                 .type = HDA_FIXUP_FUNC,
2533                 .v.func = alc887_fixup_asus_jack,
2534                 .chained = true,
2535                 .chain_id = ALC887_FIXUP_ASUS_AUDIO,
2536         },
2537         [ALCS1200A_FIXUP_MIC_VREF] = {
2538                 .type = HDA_FIXUP_PINCTLS,
2539                 .v.pins = (const struct hda_pintbl[]) {
2540                         { 0x18, PIN_VREF50 }, /* rear mic */
2541                         { 0x19, PIN_VREF50 }, /* front mic */
2542                         {}
2543                 }
2544         },
2545         [ALC888VD_FIXUP_MIC_100VREF] = {
2546                 .type = HDA_FIXUP_PINCTLS,
2547                 .v.pins = (const struct hda_pintbl[]) {
2548                         { 0x18, PIN_VREF100 }, /* headset mic */
2549                         {}
2550                 }
2551         },
2552 };
2553
2554 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2555         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2556         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2557         SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2558         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2559         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2560         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2561         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2562         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2563                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2564         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2565                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2566         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2567                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2568         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2569                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2570         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2571                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2572         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2573         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2574                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2575         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2576                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2577         SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2578                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2579         SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2580         SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2581         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2582         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2583         SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2584         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2585         SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC),
2586         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2587         SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2588         SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2589         SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF),
2590         SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2591         SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2592         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2593         SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2594         SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2595
2596         /* All Apple entries are in codec SSIDs */
2597         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2598         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2599         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2600         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2601         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2602         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2603         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2604         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2605         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2606         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2607         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2608         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2609         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2610         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2611         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2612         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2613         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2614         SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2615         SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2616         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2617         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2618         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2619
2620         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2621         SND_PCI_QUIRK(0x10ec, 0x12d8, "iBase Elo Touch", ALC888VD_FIXUP_MIC_100VREF),
2622         SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD),
2623         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2624         SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2625         SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570),
2626         SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570),
2627         SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570),
2628         SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
2629         SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
2630         SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950),
2631         SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950),
2632         SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2633         SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2634         SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2635         SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS),
2636         SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2637         SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2638         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2639         SND_PCI_QUIRK(0x1558, 0x3702, "Clevo X370SN[VW]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2640         SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2641         SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2642         SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2643         SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2644         SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2645         SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2646         SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2647         SND_PCI_QUIRK(0x1558, 0x66a2, "Clevo PE60RNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2648         SND_PCI_QUIRK(0x1558, 0x66a6, "Clevo PE60SN[CDE]-[GS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2649         SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2650         SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2651         SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2652         SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2653         SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2654         SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2655         SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2656         SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
2657         SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2658         SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
2659         SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950),
2660         SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2661         SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2662         SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950),
2663         SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950),
2664         SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950),
2665         SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950),
2666         SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2667         SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2668         SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950),
2669         SND_PCI_QUIRK(0x1558, 0xd502, "Clevo PD50SNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2670         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2671         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2672         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2673         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2674         {}
2675 };
2676
2677 static const struct hda_model_fixup alc882_fixup_models[] = {
2678         {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2679         {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2680         {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2681         {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2682         {.id = ALC889_FIXUP_CD, .name = "cd"},
2683         {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2684         {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2685         {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2686         {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2687         {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2688         {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2689         {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2690         {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2691         {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2692         {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2693         {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2694         {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2695         {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2696         {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2697         {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2698         {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2699         {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2700         {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2701         {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2702         {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2703         {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2704         {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2705         {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2706         {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2707         {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2708         {.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"},
2709         {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2710         {}
2711 };
2712
2713 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = {
2714         SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950,
2715                 {0x14, 0x01014010},
2716                 {0x15, 0x01011012},
2717                 {0x16, 0x01016011},
2718                 {0x18, 0x01a19040},
2719                 {0x19, 0x02a19050},
2720                 {0x1a, 0x0181304f},
2721                 {0x1b, 0x0221401f},
2722                 {0x1e, 0x01456130}),
2723         SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950,
2724                 {0x14, 0x01015010},
2725                 {0x15, 0x01011012},
2726                 {0x16, 0x01011011},
2727                 {0x18, 0x01a11040},
2728                 {0x19, 0x02a19050},
2729                 {0x1a, 0x0181104f},
2730                 {0x1b, 0x0221401f},
2731                 {0x1e, 0x01451130}),
2732         {}
2733 };
2734
2735 /*
2736  * BIOS auto configuration
2737  */
2738 /* almost identical with ALC880 parser... */
2739 static int alc882_parse_auto_config(struct hda_codec *codec)
2740 {
2741         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2742         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2743         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2744 }
2745
2746 /*
2747  */
2748 static int patch_alc882(struct hda_codec *codec)
2749 {
2750         struct alc_spec *spec;
2751         int err;
2752
2753         err = alc_alloc_spec(codec, 0x0b);
2754         if (err < 0)
2755                 return err;
2756
2757         spec = codec->spec;
2758
2759         switch (codec->core.vendor_id) {
2760         case 0x10ec0882:
2761         case 0x10ec0885:
2762         case 0x10ec0900:
2763         case 0x10ec0b00:
2764         case 0x10ec1220:
2765                 break;
2766         default:
2767                 /* ALC883 and variants */
2768                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2769                 break;
2770         }
2771
2772         alc_pre_init(codec);
2773
2774         snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2775                        alc882_fixups);
2776         snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true);
2777         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2778
2779         alc_auto_parse_customize_define(codec);
2780
2781         if (has_cdefine_beep(codec))
2782                 spec->gen.beep_nid = 0x01;
2783
2784         /* automatic parse from the BIOS config */
2785         err = alc882_parse_auto_config(codec);
2786         if (err < 0)
2787                 goto error;
2788
2789         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2790                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2791                 if (err < 0)
2792                         goto error;
2793         }
2794
2795         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2796
2797         return 0;
2798
2799  error:
2800         alc_free(codec);
2801         return err;
2802 }
2803
2804
2805 /*
2806  * ALC262 support
2807  */
2808 static int alc262_parse_auto_config(struct hda_codec *codec)
2809 {
2810         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2811         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2812         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2813 }
2814
2815 /*
2816  * Pin config fixes
2817  */
2818 enum {
2819         ALC262_FIXUP_FSC_H270,
2820         ALC262_FIXUP_FSC_S7110,
2821         ALC262_FIXUP_HP_Z200,
2822         ALC262_FIXUP_TYAN,
2823         ALC262_FIXUP_LENOVO_3000,
2824         ALC262_FIXUP_BENQ,
2825         ALC262_FIXUP_BENQ_T31,
2826         ALC262_FIXUP_INV_DMIC,
2827         ALC262_FIXUP_INTEL_BAYLEYBAY,
2828 };
2829
2830 static const struct hda_fixup alc262_fixups[] = {
2831         [ALC262_FIXUP_FSC_H270] = {
2832                 .type = HDA_FIXUP_PINS,
2833                 .v.pins = (const struct hda_pintbl[]) {
2834                         { 0x14, 0x99130110 }, /* speaker */
2835                         { 0x15, 0x0221142f }, /* front HP */
2836                         { 0x1b, 0x0121141f }, /* rear HP */
2837                         { }
2838                 }
2839         },
2840         [ALC262_FIXUP_FSC_S7110] = {
2841                 .type = HDA_FIXUP_PINS,
2842                 .v.pins = (const struct hda_pintbl[]) {
2843                         { 0x15, 0x90170110 }, /* speaker */
2844                         { }
2845                 },
2846                 .chained = true,
2847                 .chain_id = ALC262_FIXUP_BENQ,
2848         },
2849         [ALC262_FIXUP_HP_Z200] = {
2850                 .type = HDA_FIXUP_PINS,
2851                 .v.pins = (const struct hda_pintbl[]) {
2852                         { 0x16, 0x99130120 }, /* internal speaker */
2853                         { }
2854                 }
2855         },
2856         [ALC262_FIXUP_TYAN] = {
2857                 .type = HDA_FIXUP_PINS,
2858                 .v.pins = (const struct hda_pintbl[]) {
2859                         { 0x14, 0x1993e1f0 }, /* int AUX */
2860                         { }
2861                 }
2862         },
2863         [ALC262_FIXUP_LENOVO_3000] = {
2864                 .type = HDA_FIXUP_PINCTLS,
2865                 .v.pins = (const struct hda_pintbl[]) {
2866                         { 0x19, PIN_VREF50 },
2867                         {}
2868                 },
2869                 .chained = true,
2870                 .chain_id = ALC262_FIXUP_BENQ,
2871         },
2872         [ALC262_FIXUP_BENQ] = {
2873                 .type = HDA_FIXUP_VERBS,
2874                 .v.verbs = (const struct hda_verb[]) {
2875                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2876                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2877                         {}
2878                 }
2879         },
2880         [ALC262_FIXUP_BENQ_T31] = {
2881                 .type = HDA_FIXUP_VERBS,
2882                 .v.verbs = (const struct hda_verb[]) {
2883                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2884                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2885                         {}
2886                 }
2887         },
2888         [ALC262_FIXUP_INV_DMIC] = {
2889                 .type = HDA_FIXUP_FUNC,
2890                 .v.func = alc_fixup_inv_dmic,
2891         },
2892         [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2893                 .type = HDA_FIXUP_FUNC,
2894                 .v.func = alc_fixup_no_depop_delay,
2895         },
2896 };
2897
2898 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2899         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2900         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2901         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2902         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2903         SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2904         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2905         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2906         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2907         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2908         SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2909         {}
2910 };
2911
2912 static const struct hda_model_fixup alc262_fixup_models[] = {
2913         {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2914         {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2915         {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2916         {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2917         {.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2918         {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2919         {.id = ALC262_FIXUP_BENQ, .name = "benq"},
2920         {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2921         {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2922         {}
2923 };
2924
2925 /*
2926  */
2927 static int patch_alc262(struct hda_codec *codec)
2928 {
2929         struct alc_spec *spec;
2930         int err;
2931
2932         err = alc_alloc_spec(codec, 0x0b);
2933         if (err < 0)
2934                 return err;
2935
2936         spec = codec->spec;
2937         spec->gen.shared_mic_vref_pin = 0x18;
2938
2939         spec->shutup = alc_eapd_shutup;
2940
2941 #if 0
2942         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2943          * under-run
2944          */
2945         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2946 #endif
2947         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2948
2949         alc_pre_init(codec);
2950
2951         snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2952                        alc262_fixups);
2953         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2954
2955         alc_auto_parse_customize_define(codec);
2956
2957         if (has_cdefine_beep(codec))
2958                 spec->gen.beep_nid = 0x01;
2959
2960         /* automatic parse from the BIOS config */
2961         err = alc262_parse_auto_config(codec);
2962         if (err < 0)
2963                 goto error;
2964
2965         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2966                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2967                 if (err < 0)
2968                         goto error;
2969         }
2970
2971         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2972
2973         return 0;
2974
2975  error:
2976         alc_free(codec);
2977         return err;
2978 }
2979
2980 /*
2981  *  ALC268
2982  */
2983 /* bind Beep switches of both NID 0x0f and 0x10 */
2984 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2985                                   struct snd_ctl_elem_value *ucontrol)
2986 {
2987         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2988         unsigned long pval;
2989         int err;
2990
2991         mutex_lock(&codec->control_mutex);
2992         pval = kcontrol->private_value;
2993         kcontrol->private_value = (pval & ~0xff) | 0x0f;
2994         err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2995         if (err >= 0) {
2996                 kcontrol->private_value = (pval & ~0xff) | 0x10;
2997                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2998         }
2999         kcontrol->private_value = pval;
3000         mutex_unlock(&codec->control_mutex);
3001         return err;
3002 }
3003
3004 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
3005         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
3006         {
3007                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3008                 .name = "Beep Playback Switch",
3009                 .subdevice = HDA_SUBDEV_AMP_FLAG,
3010                 .info = snd_hda_mixer_amp_switch_info,
3011                 .get = snd_hda_mixer_amp_switch_get,
3012                 .put = alc268_beep_switch_put,
3013                 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
3014         },
3015 };
3016
3017 /* set PCBEEP vol = 0, mute connections */
3018 static const struct hda_verb alc268_beep_init_verbs[] = {
3019         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3020         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3021         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3022         { }
3023 };
3024
3025 enum {
3026         ALC268_FIXUP_INV_DMIC,
3027         ALC268_FIXUP_HP_EAPD,
3028         ALC268_FIXUP_SPDIF,
3029 };
3030
3031 static const struct hda_fixup alc268_fixups[] = {
3032         [ALC268_FIXUP_INV_DMIC] = {
3033                 .type = HDA_FIXUP_FUNC,
3034                 .v.func = alc_fixup_inv_dmic,
3035         },
3036         [ALC268_FIXUP_HP_EAPD] = {
3037                 .type = HDA_FIXUP_VERBS,
3038                 .v.verbs = (const struct hda_verb[]) {
3039                         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
3040                         {}
3041                 }
3042         },
3043         [ALC268_FIXUP_SPDIF] = {
3044                 .type = HDA_FIXUP_PINS,
3045                 .v.pins = (const struct hda_pintbl[]) {
3046                         { 0x1e, 0x014b1180 }, /* enable SPDIF out */
3047                         {}
3048                 }
3049         },
3050 };
3051
3052 static const struct hda_model_fixup alc268_fixup_models[] = {
3053         {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
3054         {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
3055         {.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
3056         {}
3057 };
3058
3059 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
3060         SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
3061         SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
3062         /* below is codec SSID since multiple Toshiba laptops have the
3063          * same PCI SSID 1179:ff00
3064          */
3065         SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
3066         {}
3067 };
3068
3069 /*
3070  * BIOS auto configuration
3071  */
3072 static int alc268_parse_auto_config(struct hda_codec *codec)
3073 {
3074         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3075         return alc_parse_auto_config(codec, NULL, alc268_ssids);
3076 }
3077
3078 /*
3079  */
3080 static int patch_alc268(struct hda_codec *codec)
3081 {
3082         struct alc_spec *spec;
3083         int i, err;
3084
3085         /* ALC268 has no aa-loopback mixer */
3086         err = alc_alloc_spec(codec, 0);
3087         if (err < 0)
3088                 return err;
3089
3090         spec = codec->spec;
3091         if (has_cdefine_beep(codec))
3092                 spec->gen.beep_nid = 0x01;
3093
3094         spec->shutup = alc_eapd_shutup;
3095
3096         alc_pre_init(codec);
3097
3098         snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
3099         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
3100
3101         /* automatic parse from the BIOS config */
3102         err = alc268_parse_auto_config(codec);
3103         if (err < 0)
3104                 goto error;
3105
3106         if (err > 0 && !spec->gen.no_analog &&
3107             spec->gen.autocfg.speaker_pins[0] != 0x1d) {
3108                 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
3109                         if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
3110                                                   &alc268_beep_mixer[i])) {
3111                                 err = -ENOMEM;
3112                                 goto error;
3113                         }
3114                 }
3115                 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
3116                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
3117                         /* override the amp caps for beep generator */
3118                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
3119                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
3120                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
3121                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3122                                           (0 << AC_AMPCAP_MUTE_SHIFT));
3123         }
3124
3125         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
3126
3127         return 0;
3128
3129  error:
3130         alc_free(codec);
3131         return err;
3132 }
3133
3134 /*
3135  * ALC269
3136  */
3137
3138 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
3139         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3140 };
3141
3142 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
3143         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3144 };
3145
3146 /* different alc269-variants */
3147 enum {
3148         ALC269_TYPE_ALC269VA,
3149         ALC269_TYPE_ALC269VB,
3150         ALC269_TYPE_ALC269VC,
3151         ALC269_TYPE_ALC269VD,
3152         ALC269_TYPE_ALC280,
3153         ALC269_TYPE_ALC282,
3154         ALC269_TYPE_ALC283,
3155         ALC269_TYPE_ALC284,
3156         ALC269_TYPE_ALC293,
3157         ALC269_TYPE_ALC286,
3158         ALC269_TYPE_ALC298,
3159         ALC269_TYPE_ALC255,
3160         ALC269_TYPE_ALC256,
3161         ALC269_TYPE_ALC257,
3162         ALC269_TYPE_ALC215,
3163         ALC269_TYPE_ALC225,
3164         ALC269_TYPE_ALC245,
3165         ALC269_TYPE_ALC287,
3166         ALC269_TYPE_ALC294,
3167         ALC269_TYPE_ALC300,
3168         ALC269_TYPE_ALC623,
3169         ALC269_TYPE_ALC700,
3170 };
3171
3172 /*
3173  * BIOS auto configuration
3174  */
3175 static int alc269_parse_auto_config(struct hda_codec *codec)
3176 {
3177         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
3178         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
3179         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3180         struct alc_spec *spec = codec->spec;
3181         const hda_nid_t *ssids;
3182
3183         switch (spec->codec_variant) {
3184         case ALC269_TYPE_ALC269VA:
3185         case ALC269_TYPE_ALC269VC:
3186         case ALC269_TYPE_ALC280:
3187         case ALC269_TYPE_ALC284:
3188         case ALC269_TYPE_ALC293:
3189                 ssids = alc269va_ssids;
3190                 break;
3191         case ALC269_TYPE_ALC269VB:
3192         case ALC269_TYPE_ALC269VD:
3193         case ALC269_TYPE_ALC282:
3194         case ALC269_TYPE_ALC283:
3195         case ALC269_TYPE_ALC286:
3196         case ALC269_TYPE_ALC298:
3197         case ALC269_TYPE_ALC255:
3198         case ALC269_TYPE_ALC256:
3199         case ALC269_TYPE_ALC257:
3200         case ALC269_TYPE_ALC215:
3201         case ALC269_TYPE_ALC225:
3202         case ALC269_TYPE_ALC245:
3203         case ALC269_TYPE_ALC287:
3204         case ALC269_TYPE_ALC294:
3205         case ALC269_TYPE_ALC300:
3206         case ALC269_TYPE_ALC623:
3207         case ALC269_TYPE_ALC700:
3208                 ssids = alc269_ssids;
3209                 break;
3210         default:
3211                 ssids = alc269_ssids;
3212                 break;
3213         }
3214
3215         return alc_parse_auto_config(codec, alc269_ignore, ssids);
3216 }
3217
3218 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
3219         { SND_JACK_BTN_0, KEY_PLAYPAUSE },
3220         { SND_JACK_BTN_1, KEY_VOICECOMMAND },
3221         { SND_JACK_BTN_2, KEY_VOLUMEUP },
3222         { SND_JACK_BTN_3, KEY_VOLUMEDOWN },
3223         {}
3224 };
3225
3226 static void alc_headset_btn_callback(struct hda_codec *codec,
3227                                      struct hda_jack_callback *jack)
3228 {
3229         int report = 0;
3230
3231         if (jack->unsol_res & (7 << 13))
3232                 report |= SND_JACK_BTN_0;
3233
3234         if (jack->unsol_res  & (1 << 16 | 3 << 8))
3235                 report |= SND_JACK_BTN_1;
3236
3237         /* Volume up key */
3238         if (jack->unsol_res & (7 << 23))
3239                 report |= SND_JACK_BTN_2;
3240
3241         /* Volume down key */
3242         if (jack->unsol_res & (7 << 10))
3243                 report |= SND_JACK_BTN_3;
3244
3245         snd_hda_jack_set_button_state(codec, jack->nid, report);
3246 }
3247
3248 static void alc_disable_headset_jack_key(struct hda_codec *codec)
3249 {
3250         struct alc_spec *spec = codec->spec;
3251
3252         if (!spec->has_hs_key)
3253                 return;
3254
3255         switch (codec->core.vendor_id) {
3256         case 0x10ec0215:
3257         case 0x10ec0225:
3258         case 0x10ec0285:
3259         case 0x10ec0287:
3260         case 0x10ec0295:
3261         case 0x10ec0289:
3262         case 0x10ec0299:
3263                 alc_write_coef_idx(codec, 0x48, 0x0);
3264                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3265                 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0);
3266                 break;
3267         case 0x10ec0230:
3268         case 0x10ec0236:
3269         case 0x10ec0256:
3270         case 0x10ec0257:
3271         case 0x19e58326:
3272                 alc_write_coef_idx(codec, 0x48, 0x0);
3273                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3274                 break;
3275         }
3276 }
3277
3278 static void alc_enable_headset_jack_key(struct hda_codec *codec)
3279 {
3280         struct alc_spec *spec = codec->spec;
3281
3282         if (!spec->has_hs_key)
3283                 return;
3284
3285         switch (codec->core.vendor_id) {
3286         case 0x10ec0215:
3287         case 0x10ec0225:
3288         case 0x10ec0285:
3289         case 0x10ec0287:
3290         case 0x10ec0295:
3291         case 0x10ec0289:
3292         case 0x10ec0299:
3293                 alc_write_coef_idx(codec, 0x48, 0xd011);
3294                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3295                 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
3296                 break;
3297         case 0x10ec0230:
3298         case 0x10ec0236:
3299         case 0x10ec0256:
3300         case 0x10ec0257:
3301         case 0x19e58326:
3302                 alc_write_coef_idx(codec, 0x48, 0xd011);
3303                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3304                 break;
3305         }
3306 }
3307
3308 static void alc_fixup_headset_jack(struct hda_codec *codec,
3309                                     const struct hda_fixup *fix, int action)
3310 {
3311         struct alc_spec *spec = codec->spec;
3312         hda_nid_t hp_pin;
3313
3314         switch (action) {
3315         case HDA_FIXUP_ACT_PRE_PROBE:
3316                 spec->has_hs_key = 1;
3317                 snd_hda_jack_detect_enable_callback(codec, 0x55,
3318                                                     alc_headset_btn_callback);
3319                 break;
3320         case HDA_FIXUP_ACT_BUILD:
3321                 hp_pin = alc_get_hp_pin(spec);
3322                 if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55,
3323                                                         alc_headset_btn_keymap,
3324                                                         hp_pin))
3325                         snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack",
3326                                               false, SND_JACK_HEADSET,
3327                                               alc_headset_btn_keymap);
3328
3329                 alc_enable_headset_jack_key(codec);
3330                 break;
3331         }
3332 }
3333
3334 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
3335 {
3336         alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
3337 }
3338
3339 static void alc269_shutup(struct hda_codec *codec)
3340 {
3341         struct alc_spec *spec = codec->spec;
3342
3343         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3344                 alc269vb_toggle_power_output(codec, 0);
3345         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3346                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3347                 msleep(150);
3348         }
3349         alc_shutup_pins(codec);
3350 }
3351
3352 static const struct coef_fw alc282_coefs[] = {
3353         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3354         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3355         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3356         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3357         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3358         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3359         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3360         WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3361         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3362         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3363         WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3364         UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3365         WRITE_COEF(0x34, 0xa0c0), /* ANC */
3366         UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3367         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3368         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3369         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3370         WRITE_COEF(0x63, 0x2902), /* PLL */
3371         WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3372         WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3373         WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3374         WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3375         UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3376         WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3377         UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3378         WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3379         WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3380         UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3381         WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3382         {}
3383 };
3384
3385 static void alc282_restore_default_value(struct hda_codec *codec)
3386 {
3387         alc_process_coef_fw(codec, alc282_coefs);
3388 }
3389
3390 static void alc282_init(struct hda_codec *codec)
3391 {
3392         struct alc_spec *spec = codec->spec;
3393         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3394         bool hp_pin_sense;
3395         int coef78;
3396
3397         alc282_restore_default_value(codec);
3398
3399         if (!hp_pin)
3400                 return;
3401         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3402         coef78 = alc_read_coef_idx(codec, 0x78);
3403
3404         /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3405         /* Headphone capless set to high power mode */
3406         alc_write_coef_idx(codec, 0x78, 0x9004);
3407
3408         if (hp_pin_sense)
3409                 msleep(2);
3410
3411         snd_hda_codec_write(codec, hp_pin, 0,
3412                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3413
3414         if (hp_pin_sense)
3415                 msleep(85);
3416
3417         snd_hda_codec_write(codec, hp_pin, 0,
3418                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3419
3420         if (hp_pin_sense)
3421                 msleep(100);
3422
3423         /* Headphone capless set to normal mode */
3424         alc_write_coef_idx(codec, 0x78, coef78);
3425 }
3426
3427 static void alc282_shutup(struct hda_codec *codec)
3428 {
3429         struct alc_spec *spec = codec->spec;
3430         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3431         bool hp_pin_sense;
3432         int coef78;
3433
3434         if (!hp_pin) {
3435                 alc269_shutup(codec);
3436                 return;
3437         }
3438
3439         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3440         coef78 = alc_read_coef_idx(codec, 0x78);
3441         alc_write_coef_idx(codec, 0x78, 0x9004);
3442
3443         if (hp_pin_sense)
3444                 msleep(2);
3445
3446         snd_hda_codec_write(codec, hp_pin, 0,
3447                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3448
3449         if (hp_pin_sense)
3450                 msleep(85);
3451
3452         if (!spec->no_shutup_pins)
3453                 snd_hda_codec_write(codec, hp_pin, 0,
3454                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3455
3456         if (hp_pin_sense)
3457                 msleep(100);
3458
3459         alc_auto_setup_eapd(codec, false);
3460         alc_shutup_pins(codec);
3461         alc_write_coef_idx(codec, 0x78, coef78);
3462 }
3463
3464 static const struct coef_fw alc283_coefs[] = {
3465         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3466         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3467         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3468         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3469         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3470         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3471         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3472         WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3473         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3474         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3475         WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3476         UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3477         WRITE_COEF(0x22, 0xa0c0), /* ANC */
3478         UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3479         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3480         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3481         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3482         WRITE_COEF(0x2e, 0x2902), /* PLL */
3483         WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3484         WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3485         WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3486         WRITE_COEF(0x36, 0x0), /* capless control 5 */
3487         UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3488         WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3489         UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3490         WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3491         WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3492         UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3493         WRITE_COEF(0x49, 0x0), /* test mode */
3494         UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3495         UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3496         WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3497         UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3498         {}
3499 };
3500
3501 static void alc283_restore_default_value(struct hda_codec *codec)
3502 {
3503         alc_process_coef_fw(codec, alc283_coefs);
3504 }
3505
3506 static void alc283_init(struct hda_codec *codec)
3507 {
3508         struct alc_spec *spec = codec->spec;
3509         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3510         bool hp_pin_sense;
3511
3512         alc283_restore_default_value(codec);
3513
3514         if (!hp_pin)
3515                 return;
3516
3517         msleep(30);
3518         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3519
3520         /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3521         /* Headphone capless set to high power mode */
3522         alc_write_coef_idx(codec, 0x43, 0x9004);
3523
3524         snd_hda_codec_write(codec, hp_pin, 0,
3525                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3526
3527         if (hp_pin_sense)
3528                 msleep(85);
3529
3530         snd_hda_codec_write(codec, hp_pin, 0,
3531                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3532
3533         if (hp_pin_sense)
3534                 msleep(85);
3535         /* Index 0x46 Combo jack auto switch control 2 */
3536         /* 3k pull low control for Headset jack. */
3537         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3538         /* Headphone capless set to normal mode */
3539         alc_write_coef_idx(codec, 0x43, 0x9614);
3540 }
3541
3542 static void alc283_shutup(struct hda_codec *codec)
3543 {
3544         struct alc_spec *spec = codec->spec;
3545         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3546         bool hp_pin_sense;
3547
3548         if (!hp_pin) {
3549                 alc269_shutup(codec);
3550                 return;
3551         }
3552
3553         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3554
3555         alc_write_coef_idx(codec, 0x43, 0x9004);
3556
3557         /*depop hp during suspend*/
3558         alc_write_coef_idx(codec, 0x06, 0x2100);
3559
3560         snd_hda_codec_write(codec, hp_pin, 0,
3561                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3562
3563         if (hp_pin_sense)
3564                 msleep(100);
3565
3566         if (!spec->no_shutup_pins)
3567                 snd_hda_codec_write(codec, hp_pin, 0,
3568                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3569
3570         alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3571
3572         if (hp_pin_sense)
3573                 msleep(100);
3574         alc_auto_setup_eapd(codec, false);
3575         alc_shutup_pins(codec);
3576         alc_write_coef_idx(codec, 0x43, 0x9614);
3577 }
3578
3579 static void alc256_init(struct hda_codec *codec)
3580 {
3581         struct alc_spec *spec = codec->spec;
3582         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3583         bool hp_pin_sense;
3584
3585         if (spec->ultra_low_power) {
3586                 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3587                 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3588                 alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3589                 alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3590                 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3591                 msleep(30);
3592         }
3593
3594         if (!hp_pin)
3595                 hp_pin = 0x21;
3596
3597         msleep(30);
3598
3599         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3600
3601         if (hp_pin_sense)
3602                 msleep(2);
3603
3604         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3605
3606         snd_hda_codec_write(codec, hp_pin, 0,
3607                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3608
3609         if (hp_pin_sense || spec->ultra_low_power)
3610                 msleep(85);
3611
3612         snd_hda_codec_write(codec, hp_pin, 0,
3613                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3614
3615         if (hp_pin_sense || spec->ultra_low_power)
3616                 msleep(100);
3617
3618         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3619         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3620         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3621         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3622         /*
3623          * Expose headphone mic (or possibly Line In on some machines) instead
3624          * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See
3625          * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of
3626          * this register.
3627          */
3628         alc_write_coef_idx(codec, 0x36, 0x5757);
3629 }
3630
3631 static void alc256_shutup(struct hda_codec *codec)
3632 {
3633         struct alc_spec *spec = codec->spec;
3634         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3635         bool hp_pin_sense;
3636
3637         if (!hp_pin)
3638                 hp_pin = 0x21;
3639
3640         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3641         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3642
3643         if (hp_pin_sense)
3644                 msleep(2);
3645
3646         snd_hda_codec_write(codec, hp_pin, 0,
3647                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3648
3649         if (hp_pin_sense || spec->ultra_low_power)
3650                 msleep(85);
3651
3652         /* 3k pull low control for Headset jack. */
3653         /* NOTE: call this before clearing the pin, otherwise codec stalls */
3654         /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly
3655          * when booting with headset plugged. So skip setting it for the codec alc257
3656          */
3657         if (spec->en_3kpull_low)
3658                 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3659
3660         if (!spec->no_shutup_pins)
3661                 snd_hda_codec_write(codec, hp_pin, 0,
3662                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3663
3664         if (hp_pin_sense || spec->ultra_low_power)
3665                 msleep(100);
3666
3667         alc_auto_setup_eapd(codec, false);
3668         alc_shutup_pins(codec);
3669         if (spec->ultra_low_power) {
3670                 msleep(50);
3671                 alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3672                 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3673                 alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3674                 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3675                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3676                 msleep(30);
3677         }
3678 }
3679
3680 static void alc285_hp_init(struct hda_codec *codec)
3681 {
3682         struct alc_spec *spec = codec->spec;
3683         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3684         int i, val;
3685         int coef38, coef0d, coef36;
3686
3687         alc_write_coefex_idx(codec, 0x58, 0x00, 0x1888); /* write default value */
3688         alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */
3689         coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */
3690         coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */
3691         coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */
3692         alc_update_coef_idx(codec, 0x38, 1<<4, 0x0);
3693         alc_update_coef_idx(codec, 0x0d, 0x110, 0x0);
3694
3695         alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
3696
3697         if (hp_pin)
3698                 snd_hda_codec_write(codec, hp_pin, 0,
3699                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3700
3701         msleep(130);
3702         alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14);
3703         alc_update_coef_idx(codec, 0x36, 1<<13, 0x0);
3704
3705         if (hp_pin)
3706                 snd_hda_codec_write(codec, hp_pin, 0,
3707                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3708         msleep(10);
3709         alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */
3710         alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880);
3711         alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049);
3712         alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0);
3713
3714         alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */
3715         val = alc_read_coefex_idx(codec, 0x58, 0x00);
3716         for (i = 0; i < 20 && val & 0x8000; i++) {
3717                 msleep(50);
3718                 val = alc_read_coefex_idx(codec, 0x58, 0x00);
3719         } /* Wait for depop procedure finish  */
3720
3721         alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */
3722         alc_update_coef_idx(codec, 0x38, 1<<4, coef38);
3723         alc_update_coef_idx(codec, 0x0d, 0x110, coef0d);
3724         alc_update_coef_idx(codec, 0x36, 3<<13, coef36);
3725
3726         msleep(50);
3727         alc_update_coef_idx(codec, 0x4a, 1<<15, 0);
3728 }
3729
3730 static void alc225_init(struct hda_codec *codec)
3731 {
3732         struct alc_spec *spec = codec->spec;
3733         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3734         bool hp1_pin_sense, hp2_pin_sense;
3735
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 (spec->codec_variant != ALC269_TYPE_ALC287 &&
3744                 spec->codec_variant != ALC269_TYPE_ALC245)
3745                 /* required only at boot or S3 and S4 resume time */
3746                 if (!spec->done_hp_init ||
3747                         is_s3_resume(codec) ||
3748                         is_s4_resume(codec)) {
3749                         alc285_hp_init(codec);
3750                         spec->done_hp_init = true;
3751                 }
3752
3753         if (!hp_pin)
3754                 hp_pin = 0x21;
3755         msleep(30);
3756
3757         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3758         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3759
3760         if (hp1_pin_sense || hp2_pin_sense)
3761                 msleep(2);
3762
3763         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3764
3765         if (hp1_pin_sense || spec->ultra_low_power)
3766                 snd_hda_codec_write(codec, hp_pin, 0,
3767                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3768         if (hp2_pin_sense)
3769                 snd_hda_codec_write(codec, 0x16, 0,
3770                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3771
3772         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3773                 msleep(85);
3774
3775         if (hp1_pin_sense || spec->ultra_low_power)
3776                 snd_hda_codec_write(codec, hp_pin, 0,
3777                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3778         if (hp2_pin_sense)
3779                 snd_hda_codec_write(codec, 0x16, 0,
3780                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3781
3782         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3783                 msleep(100);
3784
3785         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3786         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3787 }
3788
3789 static void alc225_shutup(struct hda_codec *codec)
3790 {
3791         struct alc_spec *spec = codec->spec;
3792         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3793         bool hp1_pin_sense, hp2_pin_sense;
3794
3795         if (!hp_pin)
3796                 hp_pin = 0x21;
3797
3798         alc_disable_headset_jack_key(codec);
3799         /* 3k pull low control for Headset jack. */
3800         alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3801
3802         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3803         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3804
3805         if (hp1_pin_sense || hp2_pin_sense)
3806                 msleep(2);
3807
3808         if (hp1_pin_sense || spec->ultra_low_power)
3809                 snd_hda_codec_write(codec, hp_pin, 0,
3810                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3811         if (hp2_pin_sense)
3812                 snd_hda_codec_write(codec, 0x16, 0,
3813                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3814
3815         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3816                 msleep(85);
3817
3818         if (hp1_pin_sense || spec->ultra_low_power)
3819                 snd_hda_codec_write(codec, hp_pin, 0,
3820                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3821         if (hp2_pin_sense)
3822                 snd_hda_codec_write(codec, 0x16, 0,
3823                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3824
3825         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3826                 msleep(100);
3827
3828         alc_auto_setup_eapd(codec, false);
3829         alc_shutup_pins(codec);
3830         if (spec->ultra_low_power) {
3831                 msleep(50);
3832                 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3833                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3834                 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3835                 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3836                 msleep(30);
3837         }
3838
3839         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3840         alc_enable_headset_jack_key(codec);
3841 }
3842
3843 static void alc_default_init(struct hda_codec *codec)
3844 {
3845         struct alc_spec *spec = codec->spec;
3846         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3847         bool hp_pin_sense;
3848
3849         if (!hp_pin)
3850                 return;
3851
3852         msleep(30);
3853
3854         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3855
3856         if (hp_pin_sense)
3857                 msleep(2);
3858
3859         snd_hda_codec_write(codec, hp_pin, 0,
3860                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3861
3862         if (hp_pin_sense)
3863                 msleep(85);
3864
3865         snd_hda_codec_write(codec, hp_pin, 0,
3866                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3867
3868         if (hp_pin_sense)
3869                 msleep(100);
3870 }
3871
3872 static void alc_default_shutup(struct hda_codec *codec)
3873 {
3874         struct alc_spec *spec = codec->spec;
3875         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3876         bool hp_pin_sense;
3877
3878         if (!hp_pin) {
3879                 alc269_shutup(codec);
3880                 return;
3881         }
3882
3883         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3884
3885         if (hp_pin_sense)
3886                 msleep(2);
3887
3888         snd_hda_codec_write(codec, hp_pin, 0,
3889                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3890
3891         if (hp_pin_sense)
3892                 msleep(85);
3893
3894         if (!spec->no_shutup_pins)
3895                 snd_hda_codec_write(codec, hp_pin, 0,
3896                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3897
3898         if (hp_pin_sense)
3899                 msleep(100);
3900
3901         alc_auto_setup_eapd(codec, false);
3902         alc_shutup_pins(codec);
3903 }
3904
3905 static void alc294_hp_init(struct hda_codec *codec)
3906 {
3907         struct alc_spec *spec = codec->spec;
3908         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3909         int i, val;
3910
3911         if (!hp_pin)
3912                 return;
3913
3914         snd_hda_codec_write(codec, hp_pin, 0,
3915                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3916
3917         msleep(100);
3918
3919         if (!spec->no_shutup_pins)
3920                 snd_hda_codec_write(codec, hp_pin, 0,
3921                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3922
3923         alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3924         alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3925
3926         /* Wait for depop procedure finish  */
3927         val = alc_read_coefex_idx(codec, 0x58, 0x01);
3928         for (i = 0; i < 20 && val & 0x0080; i++) {
3929                 msleep(50);
3930                 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3931         }
3932         /* Set HP depop to auto mode */
3933         alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3934         msleep(50);
3935 }
3936
3937 static void alc294_init(struct hda_codec *codec)
3938 {
3939         struct alc_spec *spec = codec->spec;
3940
3941         /* required only at boot or S4 resume time */
3942         if (!spec->done_hp_init ||
3943             codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3944                 alc294_hp_init(codec);
3945                 spec->done_hp_init = true;
3946         }
3947         alc_default_init(codec);
3948 }
3949
3950 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3951                              unsigned int val)
3952 {
3953         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3954         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3955         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3956 }
3957
3958 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3959 {
3960         unsigned int val;
3961
3962         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3963         val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3964                 & 0xffff;
3965         val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3966                 << 16;
3967         return val;
3968 }
3969
3970 static void alc5505_dsp_halt(struct hda_codec *codec)
3971 {
3972         unsigned int val;
3973
3974         alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3975         alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3976         alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3977         alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3978         alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3979         alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3980         alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3981         val = alc5505_coef_get(codec, 0x6220);
3982         alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3983 }
3984
3985 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3986 {
3987         alc5505_coef_set(codec, 0x61b8, 0x04133302);
3988         alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3989         alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3990         alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3991         alc5505_coef_set(codec, 0x6220, 0x2002010f);
3992         alc5505_coef_set(codec, 0x880c, 0x00000004);
3993 }
3994
3995 static void alc5505_dsp_init(struct hda_codec *codec)
3996 {
3997         unsigned int val;
3998
3999         alc5505_dsp_halt(codec);
4000         alc5505_dsp_back_from_halt(codec);
4001         alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
4002         alc5505_coef_set(codec, 0x61b0, 0x5b16);
4003         alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
4004         alc5505_coef_set(codec, 0x61b4, 0x04132b02);
4005         alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
4006         alc5505_coef_set(codec, 0x61b8, 0x041f3302);
4007         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
4008         alc5505_coef_set(codec, 0x61b8, 0x041b3302);
4009         alc5505_coef_set(codec, 0x61b8, 0x04173302);
4010         alc5505_coef_set(codec, 0x61b8, 0x04163302);
4011         alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
4012         alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
4013         alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
4014
4015         val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
4016         if (val <= 3)
4017                 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
4018         else
4019                 alc5505_coef_set(codec, 0x6220, 0x6002018f);
4020
4021         alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
4022         alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
4023         alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
4024         alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
4025         alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
4026         alc5505_coef_set(codec, 0x880c, 0x00000003);
4027         alc5505_coef_set(codec, 0x880c, 0x00000010);
4028
4029 #ifdef HALT_REALTEK_ALC5505
4030         alc5505_dsp_halt(codec);
4031 #endif
4032 }
4033
4034 #ifdef HALT_REALTEK_ALC5505
4035 #define alc5505_dsp_suspend(codec)      do { } while (0) /* NOP */
4036 #define alc5505_dsp_resume(codec)       do { } while (0) /* NOP */
4037 #else
4038 #define alc5505_dsp_suspend(codec)      alc5505_dsp_halt(codec)
4039 #define alc5505_dsp_resume(codec)       alc5505_dsp_back_from_halt(codec)
4040 #endif
4041
4042 #ifdef CONFIG_PM
4043 static int alc269_suspend(struct hda_codec *codec)
4044 {
4045         struct alc_spec *spec = codec->spec;
4046
4047         if (spec->has_alc5505_dsp)
4048                 alc5505_dsp_suspend(codec);
4049
4050         return alc_suspend(codec);
4051 }
4052
4053 static int alc269_resume(struct hda_codec *codec)
4054 {
4055         struct alc_spec *spec = codec->spec;
4056
4057         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4058                 alc269vb_toggle_power_output(codec, 0);
4059         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4060                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
4061                 msleep(150);
4062         }
4063
4064         codec->patch_ops.init(codec);
4065
4066         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4067                 alc269vb_toggle_power_output(codec, 1);
4068         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4069                         (alc_get_coef0(codec) & 0x00ff) == 0x017) {
4070                 msleep(200);
4071         }
4072
4073         snd_hda_regmap_sync(codec);
4074         hda_call_check_power_status(codec, 0x01);
4075
4076         /* on some machine, the BIOS will clear the codec gpio data when enter
4077          * suspend, and won't restore the data after resume, so we restore it
4078          * in the driver.
4079          */
4080         if (spec->gpio_data)
4081                 alc_write_gpio_data(codec);
4082
4083         if (spec->has_alc5505_dsp)
4084                 alc5505_dsp_resume(codec);
4085
4086         return 0;
4087 }
4088 #endif /* CONFIG_PM */
4089
4090 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
4091                                                  const struct hda_fixup *fix, int action)
4092 {
4093         struct alc_spec *spec = codec->spec;
4094
4095         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4096                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4097 }
4098
4099 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
4100                                                  const struct hda_fixup *fix,
4101                                                  int action)
4102 {
4103         unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
4104         unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
4105
4106         if (cfg_headphone && cfg_headset_mic == 0x411111f0)
4107                 snd_hda_codec_set_pincfg(codec, 0x19,
4108                         (cfg_headphone & ~AC_DEFCFG_DEVICE) |
4109                         (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
4110 }
4111
4112 static void alc269_fixup_hweq(struct hda_codec *codec,
4113                                const struct hda_fixup *fix, int action)
4114 {
4115         if (action == HDA_FIXUP_ACT_INIT)
4116                 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
4117 }
4118
4119 static void alc269_fixup_headset_mic(struct hda_codec *codec,
4120                                        const struct hda_fixup *fix, int action)
4121 {
4122         struct alc_spec *spec = codec->spec;
4123
4124         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4125                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4126 }
4127
4128 static void alc271_fixup_dmic(struct hda_codec *codec,
4129                               const struct hda_fixup *fix, int action)
4130 {
4131         static const struct hda_verb verbs[] = {
4132                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4133                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4134                 {}
4135         };
4136         unsigned int cfg;
4137
4138         if (strcmp(codec->core.chip_name, "ALC271X") &&
4139             strcmp(codec->core.chip_name, "ALC269VB"))
4140                 return;
4141         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4142         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4143                 snd_hda_sequence_write(codec, verbs);
4144 }
4145
4146 /* Fix the speaker amp after resume, etc */
4147 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec,
4148                                           const struct hda_fixup *fix,
4149                                           int action)
4150 {
4151         if (action == HDA_FIXUP_ACT_INIT)
4152                 alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000);
4153 }
4154
4155 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4156                                  const struct hda_fixup *fix, int action)
4157 {
4158         struct alc_spec *spec = codec->spec;
4159
4160         if (action != HDA_FIXUP_ACT_PROBE)
4161                 return;
4162
4163         /* Due to a hardware problem on Lenovo Ideadpad, we need to
4164          * fix the sample rate of analog I/O to 44.1kHz
4165          */
4166         spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
4167         spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
4168 }
4169
4170 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4171                                      const struct hda_fixup *fix, int action)
4172 {
4173         /* The digital-mic unit sends PDM (differential signal) instead of
4174          * the standard PCM, thus you can't record a valid mono stream as is.
4175          * Below is a workaround specific to ALC269 to control the dmic
4176          * signal source as mono.
4177          */
4178         if (action == HDA_FIXUP_ACT_INIT)
4179                 alc_update_coef_idx(codec, 0x07, 0, 0x80);
4180 }
4181
4182 static void alc269_quanta_automute(struct hda_codec *codec)
4183 {
4184         snd_hda_gen_update_outputs(codec);
4185
4186         alc_write_coef_idx(codec, 0x0c, 0x680);
4187         alc_write_coef_idx(codec, 0x0c, 0x480);
4188 }
4189
4190 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4191                                      const struct hda_fixup *fix, int action)
4192 {
4193         struct alc_spec *spec = codec->spec;
4194         if (action != HDA_FIXUP_ACT_PROBE)
4195                 return;
4196         spec->gen.automute_hook = alc269_quanta_automute;
4197 }
4198
4199 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
4200                                          struct hda_jack_callback *jack)
4201 {
4202         struct alc_spec *spec = codec->spec;
4203         int vref;
4204         msleep(200);
4205         snd_hda_gen_hp_automute(codec, jack);
4206
4207         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4208         msleep(100);
4209         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4210                             vref);
4211         msleep(500);
4212         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4213                             vref);
4214 }
4215
4216 /*
4217  * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
4218  */
4219 struct hda_alc298_mbxinit {
4220         unsigned char value_0x23;
4221         unsigned char value_0x25;
4222 };
4223
4224 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
4225                                          const struct hda_alc298_mbxinit *initval,
4226                                          bool first)
4227 {
4228         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
4229         alc_write_coef_idx(codec, 0x26, 0xb000);
4230
4231         if (first)
4232                 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
4233
4234         snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4235         alc_write_coef_idx(codec, 0x26, 0xf000);
4236         alc_write_coef_idx(codec, 0x23, initval->value_0x23);
4237
4238         if (initval->value_0x23 != 0x1e)
4239                 alc_write_coef_idx(codec, 0x25, initval->value_0x25);
4240
4241         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4242         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4243 }
4244
4245 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
4246                                            const struct hda_fixup *fix,
4247                                            int action)
4248 {
4249         /* Initialization magic */
4250         static const struct hda_alc298_mbxinit dac_init[] = {
4251                 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
4252                 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
4253                 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
4254                 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
4255                 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
4256                 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
4257                 {0x2f, 0x00},
4258                 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
4259                 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
4260                 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
4261                 {}
4262         };
4263         const struct hda_alc298_mbxinit *seq;
4264
4265         if (action != HDA_FIXUP_ACT_INIT)
4266                 return;
4267
4268         /* Start */
4269         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
4270         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4271         alc_write_coef_idx(codec, 0x26, 0xf000);
4272         alc_write_coef_idx(codec, 0x22, 0x31);
4273         alc_write_coef_idx(codec, 0x23, 0x0b);
4274         alc_write_coef_idx(codec, 0x25, 0x00);
4275         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4276         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4277
4278         for (seq = dac_init; seq->value_0x23; seq++)
4279                 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
4280 }
4281
4282 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
4283                                      const struct hda_fixup *fix, int action)
4284 {
4285         struct alc_spec *spec = codec->spec;
4286         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4287                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4288                 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
4289         }
4290 }
4291
4292 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin,
4293                                 bool polarity, bool on)
4294 {
4295         unsigned int pinval;
4296
4297         if (!pin)
4298                 return;
4299         if (polarity)
4300                 on = !on;
4301         pinval = snd_hda_codec_get_pin_target(codec, pin);
4302         pinval &= ~AC_PINCTL_VREFEN;
4303         pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ;
4304         /* temporarily power up/down for setting VREF */
4305         snd_hda_power_up_pm(codec);
4306         snd_hda_set_pin_ctl_cache(codec, pin, pinval);
4307         snd_hda_power_down_pm(codec);
4308 }
4309
4310 /* update mute-LED according to the speaker mute state via mic VREF pin */
4311 static int vref_mute_led_set(struct led_classdev *led_cdev,
4312                              enum led_brightness brightness)
4313 {
4314         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4315         struct alc_spec *spec = codec->spec;
4316
4317         alc_update_vref_led(codec, spec->mute_led_nid,
4318                             spec->mute_led_polarity, brightness);
4319         return 0;
4320 }
4321
4322 /* Make sure the led works even in runtime suspend */
4323 static unsigned int led_power_filter(struct hda_codec *codec,
4324                                                   hda_nid_t nid,
4325                                                   unsigned int power_state)
4326 {
4327         struct alc_spec *spec = codec->spec;
4328
4329         if (power_state != AC_PWRST_D3 || nid == 0 ||
4330             (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4331                 return power_state;
4332
4333         /* Set pin ctl again, it might have just been set to 0 */
4334         snd_hda_set_pin_ctl(codec, nid,
4335                             snd_hda_codec_get_pin_target(codec, nid));
4336
4337         return snd_hda_gen_path_power_filter(codec, nid, power_state);
4338 }
4339
4340 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4341                                      const struct hda_fixup *fix, int action)
4342 {
4343         struct alc_spec *spec = codec->spec;
4344         const struct dmi_device *dev = NULL;
4345
4346         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4347                 return;
4348
4349         while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4350                 int pol, pin;
4351                 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4352                         continue;
4353                 if (pin < 0x0a || pin >= 0x10)
4354                         break;
4355                 spec->mute_led_polarity = pol;
4356                 spec->mute_led_nid = pin - 0x0a + 0x18;
4357                 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4358                 codec->power_filter = led_power_filter;
4359                 codec_dbg(codec,
4360                           "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4361                            spec->mute_led_polarity);
4362                 break;
4363         }
4364 }
4365
4366 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4367                                           const struct hda_fixup *fix,
4368                                           int action, hda_nid_t pin)
4369 {
4370         struct alc_spec *spec = codec->spec;
4371
4372         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4373                 spec->mute_led_polarity = 0;
4374                 spec->mute_led_nid = pin;
4375                 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4376                 codec->power_filter = led_power_filter;
4377         }
4378 }
4379
4380 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4381                                 const struct hda_fixup *fix, int action)
4382 {
4383         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4384 }
4385
4386 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4387                                 const struct hda_fixup *fix, int action)
4388 {
4389         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4390 }
4391
4392 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4393                                 const struct hda_fixup *fix, int action)
4394 {
4395         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4396 }
4397
4398 /* update LED status via GPIO */
4399 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4400                                 int polarity, bool enabled)
4401 {
4402         if (polarity)
4403                 enabled = !enabled;
4404         alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
4405 }
4406
4407 /* turn on/off mute LED via GPIO per vmaster hook */
4408 static int gpio_mute_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_mute_led_mask,
4415                             spec->mute_led_polarity, !brightness);
4416         return 0;
4417 }
4418
4419 /* turn on/off mic-mute LED via GPIO per capture hook */
4420 static int micmute_led_set(struct led_classdev *led_cdev,
4421                            enum led_brightness brightness)
4422 {
4423         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4424         struct alc_spec *spec = codec->spec;
4425
4426         alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4427                             spec->micmute_led_polarity, !brightness);
4428         return 0;
4429 }
4430
4431 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
4432 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4433                                   int action,
4434                                   unsigned int mute_mask,
4435                                   unsigned int micmute_mask)
4436 {
4437         struct alc_spec *spec = codec->spec;
4438
4439         alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4440
4441         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4442                 return;
4443         if (mute_mask) {
4444                 spec->gpio_mute_led_mask = mute_mask;
4445                 snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set);
4446         }
4447         if (micmute_mask) {
4448                 spec->gpio_mic_led_mask = micmute_mask;
4449                 snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4450         }
4451 }
4452
4453 static void alc236_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, 0x02, 0x01);
4457 }
4458
4459 static void alc269_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, 0x08, 0x10);
4463 }
4464
4465 static void alc285_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, 0x04, 0x01);
4469 }
4470
4471 static void alc286_fixup_hp_gpio_led(struct hda_codec *codec,
4472                                 const struct hda_fixup *fix, int action)
4473 {
4474         alc_fixup_hp_gpio_led(codec, action, 0x02, 0x20);
4475 }
4476
4477 static void alc287_fixup_hp_gpio_led(struct hda_codec *codec,
4478                                 const struct hda_fixup *fix, int action)
4479 {
4480         alc_fixup_hp_gpio_led(codec, action, 0x10, 0);
4481 }
4482
4483 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
4484                                 const struct hda_fixup *fix, int action)
4485 {
4486         struct alc_spec *spec = codec->spec;
4487
4488         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4489                 spec->micmute_led_polarity = 1;
4490         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4491 }
4492
4493 /* turn on/off mic-mute LED per capture hook via VREF change */
4494 static int vref_micmute_led_set(struct led_classdev *led_cdev,
4495                                 enum led_brightness brightness)
4496 {
4497         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4498         struct alc_spec *spec = codec->spec;
4499
4500         alc_update_vref_led(codec, spec->cap_mute_led_nid,
4501                             spec->micmute_led_polarity, brightness);
4502         return 0;
4503 }
4504
4505 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4506                                 const struct hda_fixup *fix, int action)
4507 {
4508         struct alc_spec *spec = codec->spec;
4509
4510         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4511         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4512                 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4513                  * enable headphone amp
4514                  */
4515                 spec->gpio_mask |= 0x10;
4516                 spec->gpio_dir |= 0x10;
4517                 spec->cap_mute_led_nid = 0x18;
4518                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4519                 codec->power_filter = led_power_filter;
4520         }
4521 }
4522
4523 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4524                                    const struct hda_fixup *fix, int action)
4525 {
4526         struct alc_spec *spec = codec->spec;
4527
4528         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4529         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4530                 spec->cap_mute_led_nid = 0x18;
4531                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4532                 codec->power_filter = led_power_filter;
4533         }
4534 }
4535
4536 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp;
4537  * it needs to toggle the GPIO0 once on and off at each time (bko#210633)
4538  */
4539 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec,
4540                                      const struct hda_fixup *fix, int action)
4541 {
4542         struct alc_spec *spec = codec->spec;
4543
4544         switch (action) {
4545         case HDA_FIXUP_ACT_PRE_PROBE:
4546                 spec->gpio_mask |= 0x01;
4547                 spec->gpio_dir |= 0x01;
4548                 break;
4549         case HDA_FIXUP_ACT_INIT:
4550                 /* need to toggle GPIO to enable the amp */
4551                 alc_update_gpio_data(codec, 0x01, true);
4552                 msleep(100);
4553                 alc_update_gpio_data(codec, 0x01, false);
4554                 break;
4555         }
4556 }
4557
4558 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */
4559 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo,
4560                                     struct hda_codec *codec,
4561                                     struct snd_pcm_substream *substream,
4562                                     int action)
4563 {
4564         switch (action) {
4565         case HDA_GEN_PCM_ACT_PREPARE:
4566                 alc_update_gpio_data(codec, 0x04, true);
4567                 break;
4568         case HDA_GEN_PCM_ACT_CLEANUP:
4569                 alc_update_gpio_data(codec, 0x04, false);
4570                 break;
4571         }
4572 }
4573
4574 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec,
4575                                       const struct hda_fixup *fix,
4576                                       int action)
4577 {
4578         struct alc_spec *spec = codec->spec;
4579
4580         if (action == HDA_FIXUP_ACT_PROBE) {
4581                 spec->gpio_mask |= 0x04;
4582                 spec->gpio_dir |= 0x04;
4583                 spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook;
4584         }
4585 }
4586
4587 static void alc_update_coef_led(struct hda_codec *codec,
4588                                 struct alc_coef_led *led,
4589                                 bool polarity, bool on)
4590 {
4591         if (polarity)
4592                 on = !on;
4593         /* temporarily power up/down for setting COEF bit */
4594         alc_update_coef_idx(codec, led->idx, led->mask,
4595                             on ? led->on : led->off);
4596 }
4597
4598 /* update mute-LED according to the speaker mute state via COEF bit */
4599 static int coef_mute_led_set(struct led_classdev *led_cdev,
4600                              enum led_brightness brightness)
4601 {
4602         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4603         struct alc_spec *spec = codec->spec;
4604
4605         alc_update_coef_led(codec, &spec->mute_led_coef,
4606                             spec->mute_led_polarity, brightness);
4607         return 0;
4608 }
4609
4610 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4611                                           const struct hda_fixup *fix,
4612                                           int action)
4613 {
4614         struct alc_spec *spec = codec->spec;
4615
4616         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4617                 spec->mute_led_polarity = 0;
4618                 spec->mute_led_coef.idx = 0x0b;
4619                 spec->mute_led_coef.mask = 1 << 3;
4620                 spec->mute_led_coef.on = 1 << 3;
4621                 spec->mute_led_coef.off = 0;
4622                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4623         }
4624 }
4625
4626 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4627                                           const struct hda_fixup *fix,
4628                                           int action)
4629 {
4630         struct alc_spec *spec = codec->spec;
4631
4632         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4633                 spec->mute_led_polarity = 0;
4634                 spec->mute_led_coef.idx = 0x34;
4635                 spec->mute_led_coef.mask = 1 << 5;
4636                 spec->mute_led_coef.on = 0;
4637                 spec->mute_led_coef.off = 1 << 5;
4638                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4639         }
4640 }
4641
4642 static void alc236_fixup_hp_mute_led_coefbit2(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->mute_led_polarity = 0;
4649                 spec->mute_led_coef.idx = 0x07;
4650                 spec->mute_led_coef.mask = 1;
4651                 spec->mute_led_coef.on = 1;
4652                 spec->mute_led_coef.off = 0;
4653                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4654         }
4655 }
4656
4657 static void alc245_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4658                                           const struct hda_fixup *fix,
4659                                           int action)
4660 {
4661         struct alc_spec *spec = codec->spec;
4662
4663         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4664                 spec->mute_led_polarity = 0;
4665                 spec->mute_led_coef.idx = 0x0b;
4666                 spec->mute_led_coef.mask = 3 << 2;
4667                 spec->mute_led_coef.on = 2 << 2;
4668                 spec->mute_led_coef.off = 1 << 2;
4669                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4670         }
4671 }
4672
4673 /* turn on/off mic-mute LED per capture hook by coef bit */
4674 static int coef_micmute_led_set(struct led_classdev *led_cdev,
4675                                 enum led_brightness brightness)
4676 {
4677         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4678         struct alc_spec *spec = codec->spec;
4679
4680         alc_update_coef_led(codec, &spec->mic_led_coef,
4681                             spec->micmute_led_polarity, brightness);
4682         return 0;
4683 }
4684
4685 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4686                                 const struct hda_fixup *fix, int action)
4687 {
4688         struct alc_spec *spec = codec->spec;
4689
4690         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4691                 spec->mic_led_coef.idx = 0x19;
4692                 spec->mic_led_coef.mask = 1 << 13;
4693                 spec->mic_led_coef.on = 1 << 13;
4694                 spec->mic_led_coef.off = 0;
4695                 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4696         }
4697 }
4698
4699 static void alc285_fixup_hp_gpio_micmute_led(struct hda_codec *codec,
4700                                 const struct hda_fixup *fix, int action)
4701 {
4702         struct alc_spec *spec = codec->spec;
4703
4704         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4705                 spec->micmute_led_polarity = 1;
4706         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4707 }
4708
4709 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4710                                 const struct hda_fixup *fix, int action)
4711 {
4712         struct alc_spec *spec = codec->spec;
4713
4714         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4715                 spec->mic_led_coef.idx = 0x35;
4716                 spec->mic_led_coef.mask = 3 << 2;
4717                 spec->mic_led_coef.on = 2 << 2;
4718                 spec->mic_led_coef.off = 1 << 2;
4719                 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4720         }
4721 }
4722
4723 static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4724                                 const struct hda_fixup *fix, int action)
4725 {
4726         alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4727         alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4728 }
4729
4730 static void alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec *codec,
4731                                 const struct hda_fixup *fix, int action)
4732 {
4733         alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4734         alc285_fixup_hp_gpio_micmute_led(codec, fix, action);
4735 }
4736
4737 static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4738                                 const struct hda_fixup *fix, int action)
4739 {
4740         alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4741         alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4742 }
4743
4744 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec,
4745                                 const struct hda_fixup *fix, int action)
4746 {
4747         struct alc_spec *spec = codec->spec;
4748
4749         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4750                 spec->cap_mute_led_nid = 0x1a;
4751                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4752                 codec->power_filter = led_power_filter;
4753         }
4754 }
4755
4756 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec,
4757                                 const struct hda_fixup *fix, int action)
4758 {
4759         alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4760         alc236_fixup_hp_micmute_led_vref(codec, fix, action);
4761 }
4762
4763 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec,
4764                                                   const unsigned short coefs[2])
4765 {
4766         alc_write_coef_idx(codec, 0x23, coefs[0]);
4767         alc_write_coef_idx(codec, 0x25, coefs[1]);
4768         alc_write_coef_idx(codec, 0x26, 0xb011);
4769 }
4770
4771 struct alc298_samsung_amp_desc {
4772         unsigned char nid;
4773         unsigned short init_seq[2][2];
4774 };
4775
4776 static void alc298_fixup_samsung_amp(struct hda_codec *codec,
4777                                      const struct hda_fixup *fix, int action)
4778 {
4779         int i, j;
4780         static const unsigned short init_seq[][2] = {
4781                 { 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 },
4782                 { 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 },
4783                 { 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e },
4784                 { 0x41, 0x07 }, { 0x400, 0x1 }
4785         };
4786         static const struct alc298_samsung_amp_desc amps[] = {
4787                 { 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } },
4788                 { 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } }
4789         };
4790
4791         if (action != HDA_FIXUP_ACT_INIT)
4792                 return;
4793
4794         for (i = 0; i < ARRAY_SIZE(amps); i++) {
4795                 alc_write_coef_idx(codec, 0x22, amps[i].nid);
4796
4797                 for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++)
4798                         alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]);
4799
4800                 for (j = 0; j < ARRAY_SIZE(init_seq); j++)
4801                         alc298_samsung_write_coef_pack(codec, init_seq[j]);
4802         }
4803 }
4804
4805 #if IS_REACHABLE(CONFIG_INPUT)
4806 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4807                                    struct hda_jack_callback *event)
4808 {
4809         struct alc_spec *spec = codec->spec;
4810
4811         /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4812            send both key on and key off event for every interrupt. */
4813         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4814         input_sync(spec->kb_dev);
4815         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4816         input_sync(spec->kb_dev);
4817 }
4818
4819 static int alc_register_micmute_input_device(struct hda_codec *codec)
4820 {
4821         struct alc_spec *spec = codec->spec;
4822         int i;
4823
4824         spec->kb_dev = input_allocate_device();
4825         if (!spec->kb_dev) {
4826                 codec_err(codec, "Out of memory (input_allocate_device)\n");
4827                 return -ENOMEM;
4828         }
4829
4830         spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4831
4832         spec->kb_dev->name = "Microphone Mute Button";
4833         spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4834         spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4835         spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4836         spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4837         for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4838                 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4839
4840         if (input_register_device(spec->kb_dev)) {
4841                 codec_err(codec, "input_register_device failed\n");
4842                 input_free_device(spec->kb_dev);
4843                 spec->kb_dev = NULL;
4844                 return -ENOMEM;
4845         }
4846
4847         return 0;
4848 }
4849
4850 /* GPIO1 = set according to SKU external amp
4851  * GPIO2 = mic mute hotkey
4852  * GPIO3 = mute LED
4853  * GPIO4 = mic mute LED
4854  */
4855 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4856                                              const struct hda_fixup *fix, int action)
4857 {
4858         struct alc_spec *spec = codec->spec;
4859
4860         alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4861         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4862                 spec->init_amp = ALC_INIT_DEFAULT;
4863                 if (alc_register_micmute_input_device(codec) != 0)
4864                         return;
4865
4866                 spec->gpio_mask |= 0x06;
4867                 spec->gpio_dir |= 0x02;
4868                 spec->gpio_data |= 0x02;
4869                 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4870                                           AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
4871                 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4872                                                     gpio2_mic_hotkey_event);
4873                 return;
4874         }
4875
4876         if (!spec->kb_dev)
4877                 return;
4878
4879         switch (action) {
4880         case HDA_FIXUP_ACT_FREE:
4881                 input_unregister_device(spec->kb_dev);
4882                 spec->kb_dev = NULL;
4883         }
4884 }
4885
4886 /* Line2 = mic mute hotkey
4887  * GPIO2 = mic mute LED
4888  */
4889 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
4890                                              const struct hda_fixup *fix, int action)
4891 {
4892         struct alc_spec *spec = codec->spec;
4893
4894         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4895         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4896                 spec->init_amp = ALC_INIT_DEFAULT;
4897                 if (alc_register_micmute_input_device(codec) != 0)
4898                         return;
4899
4900                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
4901                                                     gpio2_mic_hotkey_event);
4902                 return;
4903         }
4904
4905         if (!spec->kb_dev)
4906                 return;
4907
4908         switch (action) {
4909         case HDA_FIXUP_ACT_FREE:
4910                 input_unregister_device(spec->kb_dev);
4911                 spec->kb_dev = NULL;
4912         }
4913 }
4914 #else /* INPUT */
4915 #define alc280_fixup_hp_gpio2_mic_hotkey        NULL
4916 #define alc233_fixup_lenovo_line2_mic_hotkey    NULL
4917 #endif /* INPUT */
4918
4919 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
4920                                 const struct hda_fixup *fix, int action)
4921 {
4922         struct alc_spec *spec = codec->spec;
4923
4924         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
4925         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4926                 spec->cap_mute_led_nid = 0x18;
4927                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4928         }
4929 }
4930
4931 static const struct coef_fw alc225_pre_hsmode[] = {
4932         UPDATE_COEF(0x4a, 1<<8, 0),
4933         UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4934         UPDATE_COEF(0x63, 3<<14, 3<<14),
4935         UPDATE_COEF(0x4a, 3<<4, 2<<4),
4936         UPDATE_COEF(0x4a, 3<<10, 3<<10),
4937         UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4938         UPDATE_COEF(0x4a, 3<<10, 0),
4939         {}
4940 };
4941
4942 static void alc_headset_mode_unplugged(struct hda_codec *codec)
4943 {
4944         struct alc_spec *spec = codec->spec;
4945         static const struct coef_fw coef0255[] = {
4946                 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
4947                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4948                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4949                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4950                 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
4951                 {}
4952         };
4953         static const struct coef_fw coef0256[] = {
4954                 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
4955                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4956                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4957                 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
4958                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4959                 {}
4960         };
4961         static const struct coef_fw coef0233[] = {
4962                 WRITE_COEF(0x1b, 0x0c0b),
4963                 WRITE_COEF(0x45, 0xc429),
4964                 UPDATE_COEF(0x35, 0x4000, 0),
4965                 WRITE_COEF(0x06, 0x2104),
4966                 WRITE_COEF(0x1a, 0x0001),
4967                 WRITE_COEF(0x26, 0x0004),
4968                 WRITE_COEF(0x32, 0x42a3),
4969                 {}
4970         };
4971         static const struct coef_fw coef0288[] = {
4972                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4973                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4974                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4975                 UPDATE_COEF(0x66, 0x0008, 0),
4976                 UPDATE_COEF(0x67, 0x2000, 0),
4977                 {}
4978         };
4979         static const struct coef_fw coef0298[] = {
4980                 UPDATE_COEF(0x19, 0x1300, 0x0300),
4981                 {}
4982         };
4983         static const struct coef_fw coef0292[] = {
4984                 WRITE_COEF(0x76, 0x000e),
4985                 WRITE_COEF(0x6c, 0x2400),
4986                 WRITE_COEF(0x18, 0x7308),
4987                 WRITE_COEF(0x6b, 0xc429),
4988                 {}
4989         };
4990         static const struct coef_fw coef0293[] = {
4991                 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
4992                 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
4993                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
4994                 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
4995                 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
4996                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4997                 {}
4998         };
4999         static const struct coef_fw coef0668[] = {
5000                 WRITE_COEF(0x15, 0x0d40),
5001                 WRITE_COEF(0xb7, 0x802b),
5002                 {}
5003         };
5004         static const struct coef_fw coef0225[] = {
5005                 UPDATE_COEF(0x63, 3<<14, 0),
5006                 {}
5007         };
5008         static const struct coef_fw coef0274[] = {
5009                 UPDATE_COEF(0x4a, 0x0100, 0),
5010                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
5011                 UPDATE_COEF(0x6b, 0xf000, 0x5000),
5012                 UPDATE_COEF(0x4a, 0x0010, 0),
5013                 UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
5014                 WRITE_COEF(0x45, 0x5289),
5015                 UPDATE_COEF(0x4a, 0x0c00, 0),
5016                 {}
5017         };
5018
5019         if (spec->no_internal_mic_pin) {
5020                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5021                 return;
5022         }
5023
5024         switch (codec->core.vendor_id) {
5025         case 0x10ec0255:
5026                 alc_process_coef_fw(codec, coef0255);
5027                 break;
5028         case 0x10ec0230:
5029         case 0x10ec0236:
5030         case 0x10ec0256:
5031         case 0x19e58326:
5032                 alc_process_coef_fw(codec, coef0256);
5033                 break;
5034         case 0x10ec0234:
5035         case 0x10ec0274:
5036         case 0x10ec0294:
5037                 alc_process_coef_fw(codec, coef0274);
5038                 break;
5039         case 0x10ec0233:
5040         case 0x10ec0283:
5041                 alc_process_coef_fw(codec, coef0233);
5042                 break;
5043         case 0x10ec0286:
5044         case 0x10ec0288:
5045                 alc_process_coef_fw(codec, coef0288);
5046                 break;
5047         case 0x10ec0298:
5048                 alc_process_coef_fw(codec, coef0298);
5049                 alc_process_coef_fw(codec, coef0288);
5050                 break;
5051         case 0x10ec0292:
5052                 alc_process_coef_fw(codec, coef0292);
5053                 break;
5054         case 0x10ec0293:
5055                 alc_process_coef_fw(codec, coef0293);
5056                 break;
5057         case 0x10ec0668:
5058                 alc_process_coef_fw(codec, coef0668);
5059                 break;
5060         case 0x10ec0215:
5061         case 0x10ec0225:
5062         case 0x10ec0285:
5063         case 0x10ec0295:
5064         case 0x10ec0289:
5065         case 0x10ec0299:
5066                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5067                 alc_process_coef_fw(codec, coef0225);
5068                 break;
5069         case 0x10ec0867:
5070                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5071                 break;
5072         }
5073         codec_dbg(codec, "Headset jack set to unplugged mode.\n");
5074 }
5075
5076
5077 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
5078                                     hda_nid_t mic_pin)
5079 {
5080         static const struct coef_fw coef0255[] = {
5081                 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
5082                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5083                 {}
5084         };
5085         static const struct coef_fw coef0256[] = {
5086                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
5087                 WRITE_COEFEX(0x57, 0x03, 0x09a3),
5088                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5089                 {}
5090         };
5091         static const struct coef_fw coef0233[] = {
5092                 UPDATE_COEF(0x35, 0, 1<<14),
5093                 WRITE_COEF(0x06, 0x2100),
5094                 WRITE_COEF(0x1a, 0x0021),
5095                 WRITE_COEF(0x26, 0x008c),
5096                 {}
5097         };
5098         static const struct coef_fw coef0288[] = {
5099                 UPDATE_COEF(0x4f, 0x00c0, 0),
5100                 UPDATE_COEF(0x50, 0x2000, 0),
5101                 UPDATE_COEF(0x56, 0x0006, 0),
5102                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5103                 UPDATE_COEF(0x66, 0x0008, 0x0008),
5104                 UPDATE_COEF(0x67, 0x2000, 0x2000),
5105                 {}
5106         };
5107         static const struct coef_fw coef0292[] = {
5108                 WRITE_COEF(0x19, 0xa208),
5109                 WRITE_COEF(0x2e, 0xacf0),
5110                 {}
5111         };
5112         static const struct coef_fw coef0293[] = {
5113                 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
5114                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
5115                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5116                 {}
5117         };
5118         static const struct coef_fw coef0688[] = {
5119                 WRITE_COEF(0xb7, 0x802b),
5120                 WRITE_COEF(0xb5, 0x1040),
5121                 UPDATE_COEF(0xc3, 0, 1<<12),
5122                 {}
5123         };
5124         static const struct coef_fw coef0225[] = {
5125                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
5126                 UPDATE_COEF(0x4a, 3<<4, 2<<4),
5127                 UPDATE_COEF(0x63, 3<<14, 0),
5128                 {}
5129         };
5130         static const struct coef_fw coef0274[] = {
5131                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
5132                 UPDATE_COEF(0x4a, 0x0010, 0),
5133                 UPDATE_COEF(0x6b, 0xf000, 0),
5134                 {}
5135         };
5136
5137         switch (codec->core.vendor_id) {
5138         case 0x10ec0255:
5139                 alc_write_coef_idx(codec, 0x45, 0xc489);
5140                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5141                 alc_process_coef_fw(codec, coef0255);
5142                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5143                 break;
5144         case 0x10ec0230:
5145         case 0x10ec0236:
5146         case 0x10ec0256:
5147         case 0x19e58326:
5148                 alc_write_coef_idx(codec, 0x45, 0xc489);
5149                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5150                 alc_process_coef_fw(codec, coef0256);
5151                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5152                 break;
5153         case 0x10ec0234:
5154         case 0x10ec0274:
5155         case 0x10ec0294:
5156                 alc_write_coef_idx(codec, 0x45, 0x4689);
5157                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5158                 alc_process_coef_fw(codec, coef0274);
5159                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5160                 break;
5161         case 0x10ec0233:
5162         case 0x10ec0283:
5163                 alc_write_coef_idx(codec, 0x45, 0xc429);
5164                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5165                 alc_process_coef_fw(codec, coef0233);
5166                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5167                 break;
5168         case 0x10ec0286:
5169         case 0x10ec0288:
5170         case 0x10ec0298:
5171                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5172                 alc_process_coef_fw(codec, coef0288);
5173                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5174                 break;
5175         case 0x10ec0292:
5176                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5177                 alc_process_coef_fw(codec, coef0292);
5178                 break;
5179         case 0x10ec0293:
5180                 /* Set to TRS mode */
5181                 alc_write_coef_idx(codec, 0x45, 0xc429);
5182                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5183                 alc_process_coef_fw(codec, coef0293);
5184                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5185                 break;
5186         case 0x10ec0867:
5187                 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
5188                 fallthrough;
5189         case 0x10ec0221:
5190         case 0x10ec0662:
5191                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5192                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5193                 break;
5194         case 0x10ec0668:
5195                 alc_write_coef_idx(codec, 0x11, 0x0001);
5196                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5197                 alc_process_coef_fw(codec, coef0688);
5198                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5199                 break;
5200         case 0x10ec0215:
5201         case 0x10ec0225:
5202         case 0x10ec0285:
5203         case 0x10ec0295:
5204         case 0x10ec0289:
5205         case 0x10ec0299:
5206                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5207                 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
5208                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5209                 alc_process_coef_fw(codec, coef0225);
5210                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5211                 break;
5212         }
5213         codec_dbg(codec, "Headset jack set to mic-in mode.\n");
5214 }
5215
5216 static void alc_headset_mode_default(struct hda_codec *codec)
5217 {
5218         static const struct coef_fw coef0225[] = {
5219                 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
5220                 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
5221                 UPDATE_COEF(0x49, 3<<8, 0<<8),
5222                 UPDATE_COEF(0x4a, 3<<4, 3<<4),
5223                 UPDATE_COEF(0x63, 3<<14, 0),
5224                 UPDATE_COEF(0x67, 0xf000, 0x3000),
5225                 {}
5226         };
5227         static const struct coef_fw coef0255[] = {
5228                 WRITE_COEF(0x45, 0xc089),
5229                 WRITE_COEF(0x45, 0xc489),
5230                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5231                 WRITE_COEF(0x49, 0x0049),
5232                 {}
5233         };
5234         static const struct coef_fw coef0256[] = {
5235                 WRITE_COEF(0x45, 0xc489),
5236                 WRITE_COEFEX(0x57, 0x03, 0x0da3),
5237                 WRITE_COEF(0x49, 0x0049),
5238                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5239                 WRITE_COEF(0x06, 0x6100),
5240                 {}
5241         };
5242         static const struct coef_fw coef0233[] = {
5243                 WRITE_COEF(0x06, 0x2100),
5244                 WRITE_COEF(0x32, 0x4ea3),
5245                 {}
5246         };
5247         static const struct coef_fw coef0288[] = {
5248                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
5249                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5250                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5251                 UPDATE_COEF(0x66, 0x0008, 0),
5252                 UPDATE_COEF(0x67, 0x2000, 0),
5253                 {}
5254         };
5255         static const struct coef_fw coef0292[] = {
5256                 WRITE_COEF(0x76, 0x000e),
5257                 WRITE_COEF(0x6c, 0x2400),
5258                 WRITE_COEF(0x6b, 0xc429),
5259                 WRITE_COEF(0x18, 0x7308),
5260                 {}
5261         };
5262         static const struct coef_fw coef0293[] = {
5263                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5264                 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
5265                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5266                 {}
5267         };
5268         static const struct coef_fw coef0688[] = {
5269                 WRITE_COEF(0x11, 0x0041),
5270                 WRITE_COEF(0x15, 0x0d40),
5271                 WRITE_COEF(0xb7, 0x802b),
5272                 {}
5273         };
5274         static const struct coef_fw coef0274[] = {
5275                 WRITE_COEF(0x45, 0x4289),
5276                 UPDATE_COEF(0x4a, 0x0010, 0x0010),
5277                 UPDATE_COEF(0x6b, 0x0f00, 0),
5278                 UPDATE_COEF(0x49, 0x0300, 0x0300),
5279                 {}
5280         };
5281
5282         switch (codec->core.vendor_id) {
5283         case 0x10ec0215:
5284         case 0x10ec0225:
5285         case 0x10ec0285:
5286         case 0x10ec0295:
5287         case 0x10ec0289:
5288         case 0x10ec0299:
5289                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5290                 alc_process_coef_fw(codec, coef0225);
5291                 break;
5292         case 0x10ec0255:
5293                 alc_process_coef_fw(codec, coef0255);
5294                 break;
5295         case 0x10ec0230:
5296         case 0x10ec0236:
5297         case 0x10ec0256:
5298         case 0x19e58326:
5299                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5300                 alc_write_coef_idx(codec, 0x45, 0xc089);
5301                 msleep(50);
5302                 alc_process_coef_fw(codec, coef0256);
5303                 break;
5304         case 0x10ec0234:
5305         case 0x10ec0274:
5306         case 0x10ec0294:
5307                 alc_process_coef_fw(codec, coef0274);
5308                 break;
5309         case 0x10ec0233:
5310         case 0x10ec0283:
5311                 alc_process_coef_fw(codec, coef0233);
5312                 break;
5313         case 0x10ec0286:
5314         case 0x10ec0288:
5315         case 0x10ec0298:
5316                 alc_process_coef_fw(codec, coef0288);
5317                 break;
5318         case 0x10ec0292:
5319                 alc_process_coef_fw(codec, coef0292);
5320                 break;
5321         case 0x10ec0293:
5322                 alc_process_coef_fw(codec, coef0293);
5323                 break;
5324         case 0x10ec0668:
5325                 alc_process_coef_fw(codec, coef0688);
5326                 break;
5327         case 0x10ec0867:
5328                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5329                 break;
5330         }
5331         codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
5332 }
5333
5334 /* Iphone type */
5335 static void alc_headset_mode_ctia(struct hda_codec *codec)
5336 {
5337         int val;
5338
5339         static const struct coef_fw coef0255[] = {
5340                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5341                 WRITE_COEF(0x1b, 0x0c2b),
5342                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5343                 {}
5344         };
5345         static const struct coef_fw coef0256[] = {
5346                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5347                 WRITE_COEF(0x1b, 0x0e6b),
5348                 {}
5349         };
5350         static const struct coef_fw coef0233[] = {
5351                 WRITE_COEF(0x45, 0xd429),
5352                 WRITE_COEF(0x1b, 0x0c2b),
5353                 WRITE_COEF(0x32, 0x4ea3),
5354                 {}
5355         };
5356         static const struct coef_fw coef0288[] = {
5357                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5358                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5359                 UPDATE_COEF(0x66, 0x0008, 0),
5360                 UPDATE_COEF(0x67, 0x2000, 0),
5361                 {}
5362         };
5363         static const struct coef_fw coef0292[] = {
5364                 WRITE_COEF(0x6b, 0xd429),
5365                 WRITE_COEF(0x76, 0x0008),
5366                 WRITE_COEF(0x18, 0x7388),
5367                 {}
5368         };
5369         static const struct coef_fw coef0293[] = {
5370                 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
5371                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5372                 {}
5373         };
5374         static const struct coef_fw coef0688[] = {
5375                 WRITE_COEF(0x11, 0x0001),
5376                 WRITE_COEF(0x15, 0x0d60),
5377                 WRITE_COEF(0xc3, 0x0000),
5378                 {}
5379         };
5380         static const struct coef_fw coef0225_1[] = {
5381                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5382                 UPDATE_COEF(0x63, 3<<14, 2<<14),
5383                 {}
5384         };
5385         static const struct coef_fw coef0225_2[] = {
5386                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5387                 UPDATE_COEF(0x63, 3<<14, 1<<14),
5388                 {}
5389         };
5390
5391         switch (codec->core.vendor_id) {
5392         case 0x10ec0255:
5393                 alc_process_coef_fw(codec, coef0255);
5394                 break;
5395         case 0x10ec0230:
5396         case 0x10ec0236:
5397         case 0x10ec0256:
5398         case 0x19e58326:
5399                 alc_process_coef_fw(codec, coef0256);
5400                 break;
5401         case 0x10ec0234:
5402         case 0x10ec0274:
5403         case 0x10ec0294:
5404                 alc_write_coef_idx(codec, 0x45, 0xd689);
5405                 break;
5406         case 0x10ec0233:
5407         case 0x10ec0283:
5408                 alc_process_coef_fw(codec, coef0233);
5409                 break;
5410         case 0x10ec0298:
5411                 val = alc_read_coef_idx(codec, 0x50);
5412                 if (val & (1 << 12)) {
5413                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5414                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5415                         msleep(300);
5416                 } else {
5417                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5418                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5419                         msleep(300);
5420                 }
5421                 break;
5422         case 0x10ec0286:
5423         case 0x10ec0288:
5424                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5425                 msleep(300);
5426                 alc_process_coef_fw(codec, coef0288);
5427                 break;
5428         case 0x10ec0292:
5429                 alc_process_coef_fw(codec, coef0292);
5430                 break;
5431         case 0x10ec0293:
5432                 alc_process_coef_fw(codec, coef0293);
5433                 break;
5434         case 0x10ec0668:
5435                 alc_process_coef_fw(codec, coef0688);
5436                 break;
5437         case 0x10ec0215:
5438         case 0x10ec0225:
5439         case 0x10ec0285:
5440         case 0x10ec0295:
5441         case 0x10ec0289:
5442         case 0x10ec0299:
5443                 val = alc_read_coef_idx(codec, 0x45);
5444                 if (val & (1 << 9))
5445                         alc_process_coef_fw(codec, coef0225_2);
5446                 else
5447                         alc_process_coef_fw(codec, coef0225_1);
5448                 break;
5449         case 0x10ec0867:
5450                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5451                 break;
5452         }
5453         codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
5454 }
5455
5456 /* Nokia type */
5457 static void alc_headset_mode_omtp(struct hda_codec *codec)
5458 {
5459         static const struct coef_fw coef0255[] = {
5460                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5461                 WRITE_COEF(0x1b, 0x0c2b),
5462                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5463                 {}
5464         };
5465         static const struct coef_fw coef0256[] = {
5466                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5467                 WRITE_COEF(0x1b, 0x0e6b),
5468                 {}
5469         };
5470         static const struct coef_fw coef0233[] = {
5471                 WRITE_COEF(0x45, 0xe429),
5472                 WRITE_COEF(0x1b, 0x0c2b),
5473                 WRITE_COEF(0x32, 0x4ea3),
5474                 {}
5475         };
5476         static const struct coef_fw coef0288[] = {
5477                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5478                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5479                 UPDATE_COEF(0x66, 0x0008, 0),
5480                 UPDATE_COEF(0x67, 0x2000, 0),
5481                 {}
5482         };
5483         static const struct coef_fw coef0292[] = {
5484                 WRITE_COEF(0x6b, 0xe429),
5485                 WRITE_COEF(0x76, 0x0008),
5486                 WRITE_COEF(0x18, 0x7388),
5487                 {}
5488         };
5489         static const struct coef_fw coef0293[] = {
5490                 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
5491                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5492                 {}
5493         };
5494         static const struct coef_fw coef0688[] = {
5495                 WRITE_COEF(0x11, 0x0001),
5496                 WRITE_COEF(0x15, 0x0d50),
5497                 WRITE_COEF(0xc3, 0x0000),
5498                 {}
5499         };
5500         static const struct coef_fw coef0225[] = {
5501                 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
5502                 UPDATE_COEF(0x63, 3<<14, 2<<14),
5503                 {}
5504         };
5505
5506         switch (codec->core.vendor_id) {
5507         case 0x10ec0255:
5508                 alc_process_coef_fw(codec, coef0255);
5509                 break;
5510         case 0x10ec0230:
5511         case 0x10ec0236:
5512         case 0x10ec0256:
5513         case 0x19e58326:
5514                 alc_process_coef_fw(codec, coef0256);
5515                 break;
5516         case 0x10ec0234:
5517         case 0x10ec0274:
5518         case 0x10ec0294:
5519                 alc_write_coef_idx(codec, 0x45, 0xe689);
5520                 break;
5521         case 0x10ec0233:
5522         case 0x10ec0283:
5523                 alc_process_coef_fw(codec, coef0233);
5524                 break;
5525         case 0x10ec0298:
5526                 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
5527                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5528                 msleep(300);
5529                 break;
5530         case 0x10ec0286:
5531         case 0x10ec0288:
5532                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5533                 msleep(300);
5534                 alc_process_coef_fw(codec, coef0288);
5535                 break;
5536         case 0x10ec0292:
5537                 alc_process_coef_fw(codec, coef0292);
5538                 break;
5539         case 0x10ec0293:
5540                 alc_process_coef_fw(codec, coef0293);
5541                 break;
5542         case 0x10ec0668:
5543                 alc_process_coef_fw(codec, coef0688);
5544                 break;
5545         case 0x10ec0215:
5546         case 0x10ec0225:
5547         case 0x10ec0285:
5548         case 0x10ec0295:
5549         case 0x10ec0289:
5550         case 0x10ec0299:
5551                 alc_process_coef_fw(codec, coef0225);
5552                 break;
5553         }
5554         codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5555 }
5556
5557 static void alc_determine_headset_type(struct hda_codec *codec)
5558 {
5559         int val;
5560         bool is_ctia = false;
5561         struct alc_spec *spec = codec->spec;
5562         static const struct coef_fw coef0255[] = {
5563                 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
5564                 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
5565  conteol) */
5566                 {}
5567         };
5568         static const struct coef_fw coef0288[] = {
5569                 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
5570                 {}
5571         };
5572         static const struct coef_fw coef0298[] = {
5573                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5574                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5575                 UPDATE_COEF(0x66, 0x0008, 0),
5576                 UPDATE_COEF(0x67, 0x2000, 0),
5577                 UPDATE_COEF(0x19, 0x1300, 0x1300),
5578                 {}
5579         };
5580         static const struct coef_fw coef0293[] = {
5581                 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
5582                 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
5583                 {}
5584         };
5585         static const struct coef_fw coef0688[] = {
5586                 WRITE_COEF(0x11, 0x0001),
5587                 WRITE_COEF(0xb7, 0x802b),
5588                 WRITE_COEF(0x15, 0x0d60),
5589                 WRITE_COEF(0xc3, 0x0c00),
5590                 {}
5591         };
5592         static const struct coef_fw coef0274[] = {
5593                 UPDATE_COEF(0x4a, 0x0010, 0),
5594                 UPDATE_COEF(0x4a, 0x8000, 0),
5595                 WRITE_COEF(0x45, 0xd289),
5596                 UPDATE_COEF(0x49, 0x0300, 0x0300),
5597                 {}
5598         };
5599
5600         if (spec->no_internal_mic_pin) {
5601                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5602                 return;
5603         }
5604
5605         switch (codec->core.vendor_id) {
5606         case 0x10ec0255:
5607                 alc_process_coef_fw(codec, coef0255);
5608                 msleep(300);
5609                 val = alc_read_coef_idx(codec, 0x46);
5610                 is_ctia = (val & 0x0070) == 0x0070;
5611                 break;
5612         case 0x10ec0230:
5613         case 0x10ec0236:
5614         case 0x10ec0256:
5615         case 0x19e58326:
5616                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5617                 alc_write_coef_idx(codec, 0x06, 0x6104);
5618                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5619
5620                 snd_hda_codec_write(codec, 0x21, 0,
5621                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5622                 msleep(80);
5623                 snd_hda_codec_write(codec, 0x21, 0,
5624                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5625
5626                 alc_process_coef_fw(codec, coef0255);
5627                 msleep(300);
5628                 val = alc_read_coef_idx(codec, 0x46);
5629                 is_ctia = (val & 0x0070) == 0x0070;
5630
5631                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5632                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5633
5634                 snd_hda_codec_write(codec, 0x21, 0,
5635                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5636                 msleep(80);
5637                 snd_hda_codec_write(codec, 0x21, 0,
5638                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5639                 break;
5640         case 0x10ec0234:
5641         case 0x10ec0274:
5642         case 0x10ec0294:
5643                 alc_process_coef_fw(codec, coef0274);
5644                 msleep(850);
5645                 val = alc_read_coef_idx(codec, 0x46);
5646                 is_ctia = (val & 0x00f0) == 0x00f0;
5647                 break;
5648         case 0x10ec0233:
5649         case 0x10ec0283:
5650                 alc_write_coef_idx(codec, 0x45, 0xd029);
5651                 msleep(300);
5652                 val = alc_read_coef_idx(codec, 0x46);
5653                 is_ctia = (val & 0x0070) == 0x0070;
5654                 break;
5655         case 0x10ec0298:
5656                 snd_hda_codec_write(codec, 0x21, 0,
5657                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5658                 msleep(100);
5659                 snd_hda_codec_write(codec, 0x21, 0,
5660                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5661                 msleep(200);
5662
5663                 val = alc_read_coef_idx(codec, 0x50);
5664                 if (val & (1 << 12)) {
5665                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5666                         alc_process_coef_fw(codec, coef0288);
5667                         msleep(350);
5668                         val = alc_read_coef_idx(codec, 0x50);
5669                         is_ctia = (val & 0x0070) == 0x0070;
5670                 } else {
5671                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5672                         alc_process_coef_fw(codec, coef0288);
5673                         msleep(350);
5674                         val = alc_read_coef_idx(codec, 0x50);
5675                         is_ctia = (val & 0x0070) == 0x0070;
5676                 }
5677                 alc_process_coef_fw(codec, coef0298);
5678                 snd_hda_codec_write(codec, 0x21, 0,
5679                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5680                 msleep(75);
5681                 snd_hda_codec_write(codec, 0x21, 0,
5682                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5683                 break;
5684         case 0x10ec0286:
5685         case 0x10ec0288:
5686                 alc_process_coef_fw(codec, coef0288);
5687                 msleep(350);
5688                 val = alc_read_coef_idx(codec, 0x50);
5689                 is_ctia = (val & 0x0070) == 0x0070;
5690                 break;
5691         case 0x10ec0292:
5692                 alc_write_coef_idx(codec, 0x6b, 0xd429);
5693                 msleep(300);
5694                 val = alc_read_coef_idx(codec, 0x6c);
5695                 is_ctia = (val & 0x001c) == 0x001c;
5696                 break;
5697         case 0x10ec0293:
5698                 alc_process_coef_fw(codec, coef0293);
5699                 msleep(300);
5700                 val = alc_read_coef_idx(codec, 0x46);
5701                 is_ctia = (val & 0x0070) == 0x0070;
5702                 break;
5703         case 0x10ec0668:
5704                 alc_process_coef_fw(codec, coef0688);
5705                 msleep(300);
5706                 val = alc_read_coef_idx(codec, 0xbe);
5707                 is_ctia = (val & 0x1c02) == 0x1c02;
5708                 break;
5709         case 0x10ec0215:
5710         case 0x10ec0225:
5711         case 0x10ec0285:
5712         case 0x10ec0295:
5713         case 0x10ec0289:
5714         case 0x10ec0299:
5715                 snd_hda_codec_write(codec, 0x21, 0,
5716                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5717                 msleep(80);
5718                 snd_hda_codec_write(codec, 0x21, 0,
5719                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5720
5721                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5722                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5723                 val = alc_read_coef_idx(codec, 0x45);
5724                 if (val & (1 << 9)) {
5725                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5726                         alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5727                         msleep(800);
5728                         val = alc_read_coef_idx(codec, 0x46);
5729                         is_ctia = (val & 0x00f0) == 0x00f0;
5730                 } else {
5731                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5732                         alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5733                         msleep(800);
5734                         val = alc_read_coef_idx(codec, 0x46);
5735                         is_ctia = (val & 0x00f0) == 0x00f0;
5736                 }
5737                 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5738                 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5739                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5740
5741                 snd_hda_codec_write(codec, 0x21, 0,
5742                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5743                 msleep(80);
5744                 snd_hda_codec_write(codec, 0x21, 0,
5745                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5746                 break;
5747         case 0x10ec0867:
5748                 is_ctia = true;
5749                 break;
5750         }
5751
5752         codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5753                     is_ctia ? "yes" : "no");
5754         spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5755 }
5756
5757 static void alc_update_headset_mode(struct hda_codec *codec)
5758 {
5759         struct alc_spec *spec = codec->spec;
5760
5761         hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5762         hda_nid_t hp_pin = alc_get_hp_pin(spec);
5763
5764         int new_headset_mode;
5765
5766         if (!snd_hda_jack_detect(codec, hp_pin))
5767                 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5768         else if (mux_pin == spec->headset_mic_pin)
5769                 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5770         else if (mux_pin == spec->headphone_mic_pin)
5771                 new_headset_mode = ALC_HEADSET_MODE_MIC;
5772         else
5773                 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5774
5775         if (new_headset_mode == spec->current_headset_mode) {
5776                 snd_hda_gen_update_outputs(codec);
5777                 return;
5778         }
5779
5780         switch (new_headset_mode) {
5781         case ALC_HEADSET_MODE_UNPLUGGED:
5782                 alc_headset_mode_unplugged(codec);
5783                 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5784                 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5785                 spec->gen.hp_jack_present = false;
5786                 break;
5787         case ALC_HEADSET_MODE_HEADSET:
5788                 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5789                         alc_determine_headset_type(codec);
5790                 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5791                         alc_headset_mode_ctia(codec);
5792                 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5793                         alc_headset_mode_omtp(codec);
5794                 spec->gen.hp_jack_present = true;
5795                 break;
5796         case ALC_HEADSET_MODE_MIC:
5797                 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5798                 spec->gen.hp_jack_present = false;
5799                 break;
5800         case ALC_HEADSET_MODE_HEADPHONE:
5801                 alc_headset_mode_default(codec);
5802                 spec->gen.hp_jack_present = true;
5803                 break;
5804         }
5805         if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5806                 snd_hda_set_pin_ctl_cache(codec, hp_pin,
5807                                           AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5808                 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5809                         snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5810                                                   PIN_VREFHIZ);
5811         }
5812         spec->current_headset_mode = new_headset_mode;
5813
5814         snd_hda_gen_update_outputs(codec);
5815 }
5816
5817 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5818                                          struct snd_kcontrol *kcontrol,
5819                                          struct snd_ctl_elem_value *ucontrol)
5820 {
5821         alc_update_headset_mode(codec);
5822 }
5823
5824 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5825                                        struct hda_jack_callback *jack)
5826 {
5827         snd_hda_gen_hp_automute(codec, jack);
5828         alc_update_headset_mode(codec);
5829 }
5830
5831 static void alc_probe_headset_mode(struct hda_codec *codec)
5832 {
5833         int i;
5834         struct alc_spec *spec = codec->spec;
5835         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5836
5837         /* Find mic pins */
5838         for (i = 0; i < cfg->num_inputs; i++) {
5839                 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
5840                         spec->headset_mic_pin = cfg->inputs[i].pin;
5841                 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
5842                         spec->headphone_mic_pin = cfg->inputs[i].pin;
5843         }
5844
5845         WARN_ON(spec->gen.cap_sync_hook);
5846         spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
5847         spec->gen.automute_hook = alc_update_headset_mode;
5848         spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
5849 }
5850
5851 static void alc_fixup_headset_mode(struct hda_codec *codec,
5852                                 const struct hda_fixup *fix, int action)
5853 {
5854         struct alc_spec *spec = codec->spec;
5855
5856         switch (action) {
5857         case HDA_FIXUP_ACT_PRE_PROBE:
5858                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
5859                 break;
5860         case HDA_FIXUP_ACT_PROBE:
5861                 alc_probe_headset_mode(codec);
5862                 break;
5863         case HDA_FIXUP_ACT_INIT:
5864                 if (is_s3_resume(codec) || is_s4_resume(codec)) {
5865                         spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5866                         spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5867                 }
5868                 alc_update_headset_mode(codec);
5869                 break;
5870         }
5871 }
5872
5873 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
5874                                 const struct hda_fixup *fix, int action)
5875 {
5876         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5877                 struct alc_spec *spec = codec->spec;
5878                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5879         }
5880         else
5881                 alc_fixup_headset_mode(codec, fix, action);
5882 }
5883
5884 static void alc255_set_default_jack_type(struct hda_codec *codec)
5885 {
5886         /* Set to iphone type */
5887         static const struct coef_fw alc255fw[] = {
5888                 WRITE_COEF(0x1b, 0x880b),
5889                 WRITE_COEF(0x45, 0xd089),
5890                 WRITE_COEF(0x1b, 0x080b),
5891                 WRITE_COEF(0x46, 0x0004),
5892                 WRITE_COEF(0x1b, 0x0c0b),
5893                 {}
5894         };
5895         static const struct coef_fw alc256fw[] = {
5896                 WRITE_COEF(0x1b, 0x884b),
5897                 WRITE_COEF(0x45, 0xd089),
5898                 WRITE_COEF(0x1b, 0x084b),
5899                 WRITE_COEF(0x46, 0x0004),
5900                 WRITE_COEF(0x1b, 0x0c4b),
5901                 {}
5902         };
5903         switch (codec->core.vendor_id) {
5904         case 0x10ec0255:
5905                 alc_process_coef_fw(codec, alc255fw);
5906                 break;
5907         case 0x10ec0230:
5908         case 0x10ec0236:
5909         case 0x10ec0256:
5910         case 0x19e58326:
5911                 alc_process_coef_fw(codec, alc256fw);
5912                 break;
5913         }
5914         msleep(30);
5915 }
5916
5917 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
5918                                 const struct hda_fixup *fix, int action)
5919 {
5920         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5921                 alc255_set_default_jack_type(codec);
5922         }
5923         alc_fixup_headset_mode(codec, fix, action);
5924 }
5925
5926 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
5927                                 const struct hda_fixup *fix, int action)
5928 {
5929         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5930                 struct alc_spec *spec = codec->spec;
5931                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5932                 alc255_set_default_jack_type(codec);
5933         }
5934         else
5935                 alc_fixup_headset_mode(codec, fix, action);
5936 }
5937
5938 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
5939                                        struct hda_jack_callback *jack)
5940 {
5941         struct alc_spec *spec = codec->spec;
5942
5943         alc_update_headset_jack_cb(codec, jack);
5944         /* Headset Mic enable or disable, only for Dell Dino */
5945         alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
5946 }
5947
5948 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
5949                                 const struct hda_fixup *fix, int action)
5950 {
5951         alc_fixup_headset_mode(codec, fix, action);
5952         if (action == HDA_FIXUP_ACT_PROBE) {
5953                 struct alc_spec *spec = codec->spec;
5954                 /* toggled via hp_automute_hook */
5955                 spec->gpio_mask |= 0x40;
5956                 spec->gpio_dir |= 0x40;
5957                 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
5958         }
5959 }
5960
5961 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
5962                                         const struct hda_fixup *fix, int action)
5963 {
5964         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5965                 struct alc_spec *spec = codec->spec;
5966                 spec->gen.auto_mute_via_amp = 1;
5967         }
5968 }
5969
5970 static void alc_fixup_no_shutup(struct hda_codec *codec,
5971                                 const struct hda_fixup *fix, int action)
5972 {
5973         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5974                 struct alc_spec *spec = codec->spec;
5975                 spec->no_shutup_pins = 1;
5976         }
5977 }
5978
5979 static void alc_fixup_disable_aamix(struct hda_codec *codec,
5980                                     const struct hda_fixup *fix, int action)
5981 {
5982         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5983                 struct alc_spec *spec = codec->spec;
5984                 /* Disable AA-loopback as it causes white noise */
5985                 spec->gen.mixer_nid = 0;
5986         }
5987 }
5988
5989 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
5990 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
5991                                   const struct hda_fixup *fix, int action)
5992 {
5993         static const struct hda_pintbl pincfgs[] = {
5994                 { 0x16, 0x21211010 }, /* dock headphone */
5995                 { 0x19, 0x21a11010 }, /* dock mic */
5996                 { }
5997         };
5998         struct alc_spec *spec = codec->spec;
5999
6000         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6001                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6002                 codec->power_save_node = 0; /* avoid click noises */
6003                 snd_hda_apply_pincfgs(codec, pincfgs);
6004         }
6005 }
6006
6007 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
6008                                   const struct hda_fixup *fix, int action)
6009 {
6010         static const struct hda_pintbl pincfgs[] = {
6011                 { 0x17, 0x21211010 }, /* dock headphone */
6012                 { 0x19, 0x21a11010 }, /* dock mic */
6013                 { }
6014         };
6015         struct alc_spec *spec = codec->spec;
6016
6017         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6018                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6019                 snd_hda_apply_pincfgs(codec, pincfgs);
6020         } else if (action == HDA_FIXUP_ACT_INIT) {
6021                 /* Enable DOCK device */
6022                 snd_hda_codec_write(codec, 0x17, 0,
6023                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6024                 /* Enable DOCK device */
6025                 snd_hda_codec_write(codec, 0x19, 0,
6026                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6027         }
6028 }
6029
6030 static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
6031                                   const struct hda_fixup *fix, int action)
6032 {
6033         /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
6034          * the speaker output becomes too low by some reason on Thinkpads with
6035          * ALC298 codec
6036          */
6037         static const hda_nid_t preferred_pairs[] = {
6038                 0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
6039                 0
6040         };
6041         struct alc_spec *spec = codec->spec;
6042
6043         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6044                 spec->gen.preferred_dacs = preferred_pairs;
6045 }
6046
6047 static void alc295_fixup_asus_dacs(struct hda_codec *codec,
6048                                    const struct hda_fixup *fix, int action)
6049 {
6050         static const hda_nid_t preferred_pairs[] = {
6051                 0x17, 0x02, 0x21, 0x03, 0
6052         };
6053         struct alc_spec *spec = codec->spec;
6054
6055         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6056                 spec->gen.preferred_dacs = preferred_pairs;
6057 }
6058
6059 static void alc_shutup_dell_xps13(struct hda_codec *codec)
6060 {
6061         struct alc_spec *spec = codec->spec;
6062         int hp_pin = alc_get_hp_pin(spec);
6063
6064         /* Prevent pop noises when headphones are plugged in */
6065         snd_hda_codec_write(codec, hp_pin, 0,
6066                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
6067         msleep(20);
6068 }
6069
6070 static void alc_fixup_dell_xps13(struct hda_codec *codec,
6071                                 const struct hda_fixup *fix, int action)
6072 {
6073         struct alc_spec *spec = codec->spec;
6074         struct hda_input_mux *imux = &spec->gen.input_mux;
6075         int i;
6076
6077         switch (action) {
6078         case HDA_FIXUP_ACT_PRE_PROBE:
6079                 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
6080                  * it causes a click noise at start up
6081                  */
6082                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6083                 spec->shutup = alc_shutup_dell_xps13;
6084                 break;
6085         case HDA_FIXUP_ACT_PROBE:
6086                 /* Make the internal mic the default input source. */
6087                 for (i = 0; i < imux->num_items; i++) {
6088                         if (spec->gen.imux_pins[i] == 0x12) {
6089                                 spec->gen.cur_mux[0] = i;
6090                                 break;
6091                         }
6092                 }
6093                 break;
6094         }
6095 }
6096
6097 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
6098                                 const struct hda_fixup *fix, int action)
6099 {
6100         struct alc_spec *spec = codec->spec;
6101
6102         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6103                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6104                 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
6105
6106                 /* Disable boost for mic-in permanently. (This code is only called
6107                    from quirks that guarantee that the headphone is at NID 0x1b.) */
6108                 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
6109                 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
6110         } else
6111                 alc_fixup_headset_mode(codec, fix, action);
6112 }
6113
6114 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
6115                                 const struct hda_fixup *fix, int action)
6116 {
6117         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6118                 alc_write_coef_idx(codec, 0xc4, 0x8000);
6119                 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
6120                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
6121         }
6122         alc_fixup_headset_mode(codec, fix, action);
6123 }
6124
6125 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
6126 static int find_ext_mic_pin(struct hda_codec *codec)
6127 {
6128         struct alc_spec *spec = codec->spec;
6129         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6130         hda_nid_t nid;
6131         unsigned int defcfg;
6132         int i;
6133
6134         for (i = 0; i < cfg->num_inputs; i++) {
6135                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
6136                         continue;
6137                 nid = cfg->inputs[i].pin;
6138                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
6139                 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
6140                         continue;
6141                 return nid;
6142         }
6143
6144         return 0;
6145 }
6146
6147 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
6148                                     const struct hda_fixup *fix,
6149                                     int action)
6150 {
6151         struct alc_spec *spec = codec->spec;
6152
6153         if (action == HDA_FIXUP_ACT_PROBE) {
6154                 int mic_pin = find_ext_mic_pin(codec);
6155                 int hp_pin = alc_get_hp_pin(spec);
6156
6157                 if (snd_BUG_ON(!mic_pin || !hp_pin))
6158                         return;
6159                 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
6160         }
6161 }
6162
6163 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
6164                                              const struct hda_fixup *fix,
6165                                              int action)
6166 {
6167         struct alc_spec *spec = codec->spec;
6168         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6169         int i;
6170
6171         /* The mic boosts on level 2 and 3 are too noisy
6172            on the internal mic input.
6173            Therefore limit the boost to 0 or 1. */
6174
6175         if (action != HDA_FIXUP_ACT_PROBE)
6176                 return;
6177
6178         for (i = 0; i < cfg->num_inputs; i++) {
6179                 hda_nid_t nid = cfg->inputs[i].pin;
6180                 unsigned int defcfg;
6181                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
6182                         continue;
6183                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
6184                 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
6185                         continue;
6186
6187                 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
6188                                           (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
6189                                           (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6190                                           (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
6191                                           (0 << AC_AMPCAP_MUTE_SHIFT));
6192         }
6193 }
6194
6195 static void alc283_hp_automute_hook(struct hda_codec *codec,
6196                                     struct hda_jack_callback *jack)
6197 {
6198         struct alc_spec *spec = codec->spec;
6199         int vref;
6200
6201         msleep(200);
6202         snd_hda_gen_hp_automute(codec, jack);
6203
6204         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
6205
6206         msleep(600);
6207         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6208                             vref);
6209 }
6210
6211 static void alc283_fixup_chromebook(struct hda_codec *codec,
6212                                     const struct hda_fixup *fix, int action)
6213 {
6214         struct alc_spec *spec = codec->spec;
6215
6216         switch (action) {
6217         case HDA_FIXUP_ACT_PRE_PROBE:
6218                 snd_hda_override_wcaps(codec, 0x03, 0);
6219                 /* Disable AA-loopback as it causes white noise */
6220                 spec->gen.mixer_nid = 0;
6221                 break;
6222         case HDA_FIXUP_ACT_INIT:
6223                 /* MIC2-VREF control */
6224                 /* Set to manual mode */
6225                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6226                 /* Enable Line1 input control by verb */
6227                 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
6228                 break;
6229         }
6230 }
6231
6232 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
6233                                     const struct hda_fixup *fix, int action)
6234 {
6235         struct alc_spec *spec = codec->spec;
6236
6237         switch (action) {
6238         case HDA_FIXUP_ACT_PRE_PROBE:
6239                 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
6240                 break;
6241         case HDA_FIXUP_ACT_INIT:
6242                 /* MIC2-VREF control */
6243                 /* Set to manual mode */
6244                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6245                 break;
6246         }
6247 }
6248
6249 /* mute tablet speaker pin (0x14) via dock plugging in addition */
6250 static void asus_tx300_automute(struct hda_codec *codec)
6251 {
6252         struct alc_spec *spec = codec->spec;
6253         snd_hda_gen_update_outputs(codec);
6254         if (snd_hda_jack_detect(codec, 0x1b))
6255                 spec->gen.mute_bits |= (1ULL << 0x14);
6256 }
6257
6258 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
6259                                     const struct hda_fixup *fix, int action)
6260 {
6261         struct alc_spec *spec = codec->spec;
6262         static const struct hda_pintbl dock_pins[] = {
6263                 { 0x1b, 0x21114000 }, /* dock speaker pin */
6264                 {}
6265         };
6266
6267         switch (action) {
6268         case HDA_FIXUP_ACT_PRE_PROBE:
6269                 spec->init_amp = ALC_INIT_DEFAULT;
6270                 /* TX300 needs to set up GPIO2 for the speaker amp */
6271                 alc_setup_gpio(codec, 0x04);
6272                 snd_hda_apply_pincfgs(codec, dock_pins);
6273                 spec->gen.auto_mute_via_amp = 1;
6274                 spec->gen.automute_hook = asus_tx300_automute;
6275                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
6276                                                     snd_hda_gen_hp_automute);
6277                 break;
6278         case HDA_FIXUP_ACT_PROBE:
6279                 spec->init_amp = ALC_INIT_DEFAULT;
6280                 break;
6281         case HDA_FIXUP_ACT_BUILD:
6282                 /* this is a bit tricky; give more sane names for the main
6283                  * (tablet) speaker and the dock speaker, respectively
6284                  */
6285                 rename_ctl(codec, "Speaker Playback Switch",
6286                            "Dock Speaker Playback Switch");
6287                 rename_ctl(codec, "Bass Speaker Playback Switch",
6288                            "Speaker Playback Switch");
6289                 break;
6290         }
6291 }
6292
6293 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
6294                                        const struct hda_fixup *fix, int action)
6295 {
6296         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6297                 /* DAC node 0x03 is giving mono output. We therefore want to
6298                    make sure 0x14 (front speaker) and 0x15 (headphones) use the
6299                    stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
6300                 static const hda_nid_t conn1[] = { 0x0c };
6301                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
6302                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
6303         }
6304 }
6305
6306 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
6307                                         const struct hda_fixup *fix, int action)
6308 {
6309         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6310                 /* The speaker is routed to the Node 0x06 by a mistake, as a result
6311                    we can't adjust the speaker's volume since this node does not has
6312                    Amp-out capability. we change the speaker's route to:
6313                    Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
6314                    Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
6315                    speaker's volume now. */
6316
6317                 static const hda_nid_t conn1[] = { 0x0c };
6318                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
6319         }
6320 }
6321
6322 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
6323 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
6324                                       const struct hda_fixup *fix, int action)
6325 {
6326         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6327                 static const hda_nid_t conn[] = { 0x02, 0x03 };
6328                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6329         }
6330 }
6331
6332 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
6333 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
6334                                           const struct hda_fixup *fix, int action)
6335 {
6336         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6337                 static const hda_nid_t conn[] = { 0x02 };
6338                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6339         }
6340 }
6341
6342 /* Hook to update amp GPIO4 for automute */
6343 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
6344                                           struct hda_jack_callback *jack)
6345 {
6346         struct alc_spec *spec = codec->spec;
6347
6348         snd_hda_gen_hp_automute(codec, jack);
6349         /* mute_led_polarity is set to 0, so we pass inverted value here */
6350         alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
6351                             !spec->gen.hp_jack_present);
6352 }
6353
6354 /* Manage GPIOs for HP EliteBook Folio 9480m.
6355  *
6356  * GPIO4 is the headphone amplifier power control
6357  * GPIO3 is the audio output mute indicator LED
6358  */
6359
6360 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
6361                                   const struct hda_fixup *fix,
6362                                   int action)
6363 {
6364         struct alc_spec *spec = codec->spec;
6365
6366         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
6367         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6368                 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
6369                 spec->gpio_mask |= 0x10;
6370                 spec->gpio_dir |= 0x10;
6371                 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
6372         }
6373 }
6374
6375 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
6376                                    const struct hda_fixup *fix,
6377                                    int action)
6378 {
6379         struct alc_spec *spec = codec->spec;
6380
6381         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6382                 spec->gpio_mask |= 0x04;
6383                 spec->gpio_dir |= 0x04;
6384                 /* set data bit low */
6385         }
6386 }
6387
6388 /* Quirk for Thinkpad X1 7th and 8th Gen
6389  * The following fixed routing needed
6390  * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly
6391  * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC
6392  * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp
6393  */
6394 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
6395                                           const struct hda_fixup *fix, int action)
6396 {
6397         static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
6398         static const hda_nid_t preferred_pairs[] = {
6399                 0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
6400         };
6401         struct alc_spec *spec = codec->spec;
6402
6403         switch (action) {
6404         case HDA_FIXUP_ACT_PRE_PROBE:
6405                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6406                 spec->gen.preferred_dacs = preferred_pairs;
6407                 break;
6408         case HDA_FIXUP_ACT_BUILD:
6409                 /* The generic parser creates somewhat unintuitive volume ctls
6410                  * with the fixed routing above, and the shared DAC2 may be
6411                  * confusing for PA.
6412                  * Rename those to unique names so that PA doesn't touch them
6413                  * and use only Master volume.
6414                  */
6415                 rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
6416                 rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
6417                 break;
6418         }
6419 }
6420
6421 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
6422                                          const struct hda_fixup *fix,
6423                                          int action)
6424 {
6425         alc_fixup_dual_codecs(codec, fix, action);
6426         switch (action) {
6427         case HDA_FIXUP_ACT_PRE_PROBE:
6428                 /* override card longname to provide a unique UCM profile */
6429                 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
6430                 break;
6431         case HDA_FIXUP_ACT_BUILD:
6432                 /* rename Capture controls depending on the codec */
6433                 rename_ctl(codec, "Capture Volume",
6434                            codec->addr == 0 ?
6435                            "Rear-Panel Capture Volume" :
6436                            "Front-Panel Capture Volume");
6437                 rename_ctl(codec, "Capture Switch",
6438                            codec->addr == 0 ?
6439                            "Rear-Panel Capture Switch" :
6440                            "Front-Panel Capture Switch");
6441                 break;
6442         }
6443 }
6444
6445 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
6446                                       const struct hda_fixup *fix, int action)
6447 {
6448         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6449                 return;
6450
6451         codec->power_save_node = 1;
6452 }
6453
6454 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
6455 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
6456                                     const struct hda_fixup *fix, int action)
6457 {
6458         struct alc_spec *spec = codec->spec;
6459         static const hda_nid_t preferred_pairs[] = {
6460                 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
6461                 0
6462         };
6463
6464         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6465                 return;
6466
6467         spec->gen.preferred_dacs = preferred_pairs;
6468         spec->gen.auto_mute_via_amp = 1;
6469         codec->power_save_node = 0;
6470 }
6471
6472 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */
6473 static void alc289_fixup_asus_ga401(struct hda_codec *codec,
6474                                     const struct hda_fixup *fix, int action)
6475 {
6476         static const hda_nid_t preferred_pairs[] = {
6477                 0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0
6478         };
6479         struct alc_spec *spec = codec->spec;
6480
6481         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6482                 spec->gen.preferred_dacs = preferred_pairs;
6483                 spec->gen.obey_preferred_dacs = 1;
6484         }
6485 }
6486
6487 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
6488 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
6489                               const struct hda_fixup *fix, int action)
6490 {
6491         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6492                 return;
6493
6494         snd_hda_override_wcaps(codec, 0x03, 0);
6495 }
6496
6497 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec)
6498 {
6499         switch (codec->core.vendor_id) {
6500         case 0x10ec0274:
6501         case 0x10ec0294:
6502         case 0x10ec0225:
6503         case 0x10ec0295:
6504         case 0x10ec0299:
6505                 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
6506                 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
6507                 break;
6508         case 0x10ec0230:
6509         case 0x10ec0235:
6510         case 0x10ec0236:
6511         case 0x10ec0255:
6512         case 0x10ec0256:
6513         case 0x10ec0257:
6514         case 0x19e58326:
6515                 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
6516                 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
6517                 break;
6518         }
6519 }
6520
6521 static void alc295_fixup_chromebook(struct hda_codec *codec,
6522                                     const struct hda_fixup *fix, int action)
6523 {
6524         struct alc_spec *spec = codec->spec;
6525
6526         switch (action) {
6527         case HDA_FIXUP_ACT_PRE_PROBE:
6528                 spec->ultra_low_power = true;
6529                 break;
6530         case HDA_FIXUP_ACT_INIT:
6531                 alc_combo_jack_hp_jd_restart(codec);
6532                 break;
6533         }
6534 }
6535
6536 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
6537                                   const struct hda_fixup *fix, int action)
6538 {
6539         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6540                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6541 }
6542
6543
6544 static void alc294_gx502_toggle_output(struct hda_codec *codec,
6545                                         struct hda_jack_callback *cb)
6546 {
6547         /* The Windows driver sets the codec up in a very different way where
6548          * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it
6549          */
6550         if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6551                 alc_write_coef_idx(codec, 0x10, 0x8a20);
6552         else
6553                 alc_write_coef_idx(codec, 0x10, 0x0a20);
6554 }
6555
6556 static void alc294_fixup_gx502_hp(struct hda_codec *codec,
6557                                         const struct hda_fixup *fix, int action)
6558 {
6559         /* Pin 0x21: headphones/headset mic */
6560         if (!is_jack_detectable(codec, 0x21))
6561                 return;
6562
6563         switch (action) {
6564         case HDA_FIXUP_ACT_PRE_PROBE:
6565                 snd_hda_jack_detect_enable_callback(codec, 0x21,
6566                                 alc294_gx502_toggle_output);
6567                 break;
6568         case HDA_FIXUP_ACT_INIT:
6569                 /* Make sure to start in a correct state, i.e. if
6570                  * headphones have been plugged in before powering up the system
6571                  */
6572                 alc294_gx502_toggle_output(codec, NULL);
6573                 break;
6574         }
6575 }
6576
6577 static void alc294_gu502_toggle_output(struct hda_codec *codec,
6578                                        struct hda_jack_callback *cb)
6579 {
6580         /* Windows sets 0x10 to 0x8420 for Node 0x20 which is
6581          * responsible from changes between speakers and headphones
6582          */
6583         if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6584                 alc_write_coef_idx(codec, 0x10, 0x8420);
6585         else
6586                 alc_write_coef_idx(codec, 0x10, 0x0a20);
6587 }
6588
6589 static void alc294_fixup_gu502_hp(struct hda_codec *codec,
6590                                   const struct hda_fixup *fix, int action)
6591 {
6592         if (!is_jack_detectable(codec, 0x21))
6593                 return;
6594
6595         switch (action) {
6596         case HDA_FIXUP_ACT_PRE_PROBE:
6597                 snd_hda_jack_detect_enable_callback(codec, 0x21,
6598                                 alc294_gu502_toggle_output);
6599                 break;
6600         case HDA_FIXUP_ACT_INIT:
6601                 alc294_gu502_toggle_output(codec, NULL);
6602                 break;
6603         }
6604 }
6605
6606 static void  alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec,
6607                               const struct hda_fixup *fix, int action)
6608 {
6609         if (action != HDA_FIXUP_ACT_INIT)
6610                 return;
6611
6612         msleep(100);
6613         alc_write_coef_idx(codec, 0x65, 0x0);
6614 }
6615
6616 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec,
6617                                     const struct hda_fixup *fix, int action)
6618 {
6619         switch (action) {
6620         case HDA_FIXUP_ACT_INIT:
6621                 alc_combo_jack_hp_jd_restart(codec);
6622                 break;
6623         }
6624 }
6625
6626 static void alc_fixup_no_int_mic(struct hda_codec *codec,
6627                                     const struct hda_fixup *fix, int action)
6628 {
6629         struct alc_spec *spec = codec->spec;
6630
6631         switch (action) {
6632         case HDA_FIXUP_ACT_PRE_PROBE:
6633                 /* Mic RING SLEEVE swap for combo jack */
6634                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
6635                 spec->no_internal_mic_pin = true;
6636                 break;
6637         case HDA_FIXUP_ACT_INIT:
6638                 alc_combo_jack_hp_jd_restart(codec);
6639                 break;
6640         }
6641 }
6642
6643 /* GPIO1 = amplifier on/off
6644  * GPIO3 = mic mute LED
6645  */
6646 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
6647                                           const struct hda_fixup *fix, int action)
6648 {
6649         static const hda_nid_t conn[] = { 0x02 };
6650
6651         struct alc_spec *spec = codec->spec;
6652         static const struct hda_pintbl pincfgs[] = {
6653                 { 0x14, 0x90170110 },  /* front/high speakers */
6654                 { 0x17, 0x90170130 },  /* back/bass speakers */
6655                 { }
6656         };
6657
6658         //enable micmute led
6659         alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
6660
6661         switch (action) {
6662         case HDA_FIXUP_ACT_PRE_PROBE:
6663                 spec->micmute_led_polarity = 1;
6664                 /* needed for amp of back speakers */
6665                 spec->gpio_mask |= 0x01;
6666                 spec->gpio_dir |= 0x01;
6667                 snd_hda_apply_pincfgs(codec, pincfgs);
6668                 /* share DAC to have unified volume control */
6669                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
6670                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6671                 break;
6672         case HDA_FIXUP_ACT_INIT:
6673                 /* need to toggle GPIO to enable the amp of back speakers */
6674                 alc_update_gpio_data(codec, 0x01, true);
6675                 msleep(100);
6676                 alc_update_gpio_data(codec, 0x01, false);
6677                 break;
6678         }
6679 }
6680
6681 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
6682                                           const struct hda_fixup *fix, int action)
6683 {
6684         static const hda_nid_t conn[] = { 0x02 };
6685         static const struct hda_pintbl pincfgs[] = {
6686                 { 0x14, 0x90170110 },  /* rear speaker */
6687                 { }
6688         };
6689
6690         switch (action) {
6691         case HDA_FIXUP_ACT_PRE_PROBE:
6692                 snd_hda_apply_pincfgs(codec, pincfgs);
6693                 /* force front speaker to DAC1 */
6694                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6695                 break;
6696         }
6697 }
6698
6699 static void alc285_fixup_hp_envy_x360(struct hda_codec *codec,
6700                                       const struct hda_fixup *fix,
6701                                       int action)
6702 {
6703         static const struct coef_fw coefs[] = {
6704                 WRITE_COEF(0x08, 0x6a0c), WRITE_COEF(0x0d, 0xa023),
6705                 WRITE_COEF(0x10, 0x0320), WRITE_COEF(0x1a, 0x8c03),
6706                 WRITE_COEF(0x25, 0x1800), WRITE_COEF(0x26, 0x003a),
6707                 WRITE_COEF(0x28, 0x1dfe), WRITE_COEF(0x29, 0xb014),
6708                 WRITE_COEF(0x2b, 0x1dfe), WRITE_COEF(0x37, 0xfe15),
6709                 WRITE_COEF(0x38, 0x7909), WRITE_COEF(0x45, 0xd489),
6710                 WRITE_COEF(0x46, 0x00f4), WRITE_COEF(0x4a, 0x21e0),
6711                 WRITE_COEF(0x66, 0x03f0), WRITE_COEF(0x67, 0x1000),
6712                 WRITE_COEF(0x6e, 0x1005), { }
6713         };
6714
6715         static const struct hda_pintbl pincfgs[] = {
6716                 { 0x12, 0xb7a60130 },  /* Internal microphone*/
6717                 { 0x14, 0x90170150 },  /* B&O soundbar speakers */
6718                 { 0x17, 0x90170153 },  /* Side speakers */
6719                 { 0x19, 0x03a11040 },  /* Headset microphone */
6720                 { }
6721         };
6722
6723         switch (action) {
6724         case HDA_FIXUP_ACT_PRE_PROBE:
6725                 snd_hda_apply_pincfgs(codec, pincfgs);
6726
6727                 /* Fixes volume control problem for side speakers */
6728                 alc295_fixup_disable_dac3(codec, fix, action);
6729
6730                 /* Fixes no sound from headset speaker */
6731                 snd_hda_codec_amp_stereo(codec, 0x21, HDA_OUTPUT, 0, -1, 0);
6732
6733                 /* Auto-enable headset mic when plugged */
6734                 snd_hda_jack_set_gating_jack(codec, 0x19, 0x21);
6735
6736                 /* Headset mic volume enhancement */
6737                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREF50);
6738                 break;
6739         case HDA_FIXUP_ACT_INIT:
6740                 alc_process_coef_fw(codec, coefs);
6741                 break;
6742         case HDA_FIXUP_ACT_BUILD:
6743                 rename_ctl(codec, "Bass Speaker Playback Volume",
6744                            "B&O-Tuned Playback Volume");
6745                 rename_ctl(codec, "Front Playback Switch",
6746                            "B&O Soundbar Playback Switch");
6747                 rename_ctl(codec, "Bass Speaker Playback Switch",
6748                            "Side Speaker Playback Switch");
6749                 break;
6750         }
6751 }
6752
6753 /* for hda_fixup_thinkpad_acpi() */
6754 #include "thinkpad_helper.c"
6755
6756 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
6757                                     const struct hda_fixup *fix, int action)
6758 {
6759         alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
6760         hda_fixup_thinkpad_acpi(codec, fix, action);
6761 }
6762
6763 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
6764 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
6765                                                   const struct hda_fixup *fix,
6766                                                   int action)
6767 {
6768         struct alc_spec *spec = codec->spec;
6769
6770         switch (action) {
6771         case HDA_FIXUP_ACT_PRE_PROBE:
6772                 spec->gen.suppress_auto_mute = 1;
6773                 break;
6774         }
6775 }
6776
6777 static void comp_acpi_device_notify(acpi_handle handle, u32 event, void *data)
6778 {
6779         struct hda_codec *cdc = data;
6780         struct alc_spec *spec = cdc->spec;
6781
6782         codec_info(cdc, "ACPI Notification %d\n", event);
6783
6784         hda_component_acpi_device_notify(spec->comps, ARRAY_SIZE(spec->comps),
6785                                          handle, event, data);
6786 }
6787
6788 static int comp_bind(struct device *dev)
6789 {
6790         struct hda_codec *cdc = dev_to_hda_codec(dev);
6791         struct alc_spec *spec = cdc->spec;
6792         int ret;
6793
6794         ret = hda_component_manager_bind(cdc, spec->comps);
6795         if (ret)
6796                 return ret;
6797
6798         return hda_component_manager_bind_acpi_notifications(cdc,
6799                                                              spec->comps, ARRAY_SIZE(spec->comps),
6800                                                              comp_acpi_device_notify, cdc);
6801 }
6802
6803 static void comp_unbind(struct device *dev)
6804 {
6805         struct hda_codec *cdc = dev_to_hda_codec(dev);
6806         struct alc_spec *spec = cdc->spec;
6807
6808         hda_component_manager_unbind_acpi_notifications(cdc, spec->comps, comp_acpi_device_notify);
6809         hda_component_manager_unbind(cdc, spec->comps);
6810 }
6811
6812 static const struct component_master_ops comp_master_ops = {
6813         .bind = comp_bind,
6814         .unbind = comp_unbind,
6815 };
6816
6817 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc,
6818                                        struct snd_pcm_substream *sub, int action)
6819 {
6820         struct alc_spec *spec = cdc->spec;
6821
6822         hda_component_manager_playback_hook(spec->comps, ARRAY_SIZE(spec->comps), action);
6823 }
6824
6825 static void comp_generic_fixup(struct hda_codec *cdc, int action, const char *bus,
6826                                const char *hid, const char *match_str, int count)
6827 {
6828         struct alc_spec *spec = cdc->spec;
6829         int ret;
6830
6831         switch (action) {
6832         case HDA_FIXUP_ACT_PRE_PROBE:
6833                 ret = hda_component_manager_init(cdc, spec->comps, count, bus, hid,
6834                                                  match_str, &comp_master_ops);
6835                 if (ret)
6836                         return;
6837
6838                 spec->gen.pcm_playback_hook = comp_generic_playback_hook;
6839                 break;
6840         case HDA_FIXUP_ACT_FREE:
6841                 hda_component_manager_free(cdc, &comp_master_ops);
6842                 break;
6843         }
6844 }
6845
6846 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6847 {
6848         comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
6849 }
6850
6851 static void cs35l41_fixup_i2c_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6852 {
6853         comp_generic_fixup(cdc, action, "i2c", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
6854 }
6855
6856 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6857 {
6858         comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 2);
6859 }
6860
6861 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6862 {
6863         comp_generic_fixup(codec, action, "spi", "CSC3551", "-%s:00-cs35l41-hda.%d", 4);
6864 }
6865
6866 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6867                                                  int action)
6868 {
6869         comp_generic_fixup(cdc, action, "i2c", "CLSA0100", "-%s:00-cs35l41-hda.%d", 2);
6870 }
6871
6872 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6873                                                  int action)
6874 {
6875         comp_generic_fixup(cdc, action, "i2c", "CLSA0101", "-%s:00-cs35l41-hda.%d", 2);
6876 }
6877
6878 static void cs35l56_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6879 {
6880         comp_generic_fixup(cdc, action, "i2c", "CSC3556", "-%s:00-cs35l56-hda.%d", 2);
6881 }
6882
6883 static void cs35l56_fixup_i2c_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6884 {
6885         comp_generic_fixup(cdc, action, "i2c", "CSC3556", "-%s:00-cs35l56-hda.%d", 4);
6886 }
6887
6888 static void cs35l56_fixup_spi_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6889 {
6890         comp_generic_fixup(cdc, action, "spi", "CSC3556", "-%s:00-cs35l56-hda.%d", 2);
6891 }
6892
6893 static void cs35l56_fixup_spi_four(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6894 {
6895         comp_generic_fixup(cdc, action, "spi", "CSC3556", "-%s:00-cs35l56-hda.%d", 4);
6896 }
6897
6898 static void alc285_fixup_asus_ga403u(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6899 {
6900         /*
6901          * The same SSID has been re-used in different hardware, they have
6902          * different codecs and the newer GA403U has a ALC285.
6903          */
6904         if (cdc->core.vendor_id == 0x10ec0285)
6905                 cs35l56_fixup_i2c_two(cdc, fix, action);
6906         else
6907                 alc_fixup_inv_dmic(cdc, fix, action);
6908 }
6909
6910 static void tas2781_fixup_i2c(struct hda_codec *cdc,
6911         const struct hda_fixup *fix, int action)
6912 {
6913         comp_generic_fixup(cdc, action, "i2c", "TIAS2781", "-%s:00", 1);
6914 }
6915
6916 static void yoga7_14arb7_fixup_i2c(struct hda_codec *cdc,
6917         const struct hda_fixup *fix, int action)
6918 {
6919         comp_generic_fixup(cdc, action, "i2c", "INT8866", "-%s:00", 1);
6920 }
6921
6922 static void alc256_fixup_acer_sfg16_micmute_led(struct hda_codec *codec,
6923         const struct hda_fixup *fix, int action)
6924 {
6925         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
6926 }
6927
6928
6929 /* for alc295_fixup_hp_top_speakers */
6930 #include "hp_x360_helper.c"
6931
6932 /* for alc285_fixup_ideapad_s740_coef() */
6933 #include "ideapad_s740_helper.c"
6934
6935 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
6936         WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
6937         WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
6938         WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
6939         {}
6940 };
6941
6942 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
6943                                            const struct hda_fixup *fix,
6944                                            int action)
6945 {
6946         /*
6947          * A certain other OS sets these coeffs to different values. On at least
6948          * one TongFang barebone these settings might survive even a cold
6949          * reboot. So to restore a clean slate the values are explicitly reset
6950          * to default here. Without this, the external microphone is always in a
6951          * plugged-in state, while the internal microphone is always in an
6952          * unplugged state, breaking the ability to use the internal microphone.
6953          */
6954         alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
6955 }
6956
6957 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
6958         WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06),
6959         WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074),
6960         WRITE_COEF(0x49, 0x0149),
6961         {}
6962 };
6963
6964 static void alc233_fixup_no_audio_jack(struct hda_codec *codec,
6965                                        const struct hda_fixup *fix,
6966                                        int action)
6967 {
6968         /*
6969          * The audio jack input and output is not detected on the ASRock NUC Box
6970          * 1100 series when cold booting without this fix. Warm rebooting from a
6971          * certain other OS makes the audio functional, as COEF settings are
6972          * preserved in this case. This fix sets these altered COEF values as
6973          * the default.
6974          */
6975         alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs);
6976 }
6977
6978 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec,
6979                                                     const struct hda_fixup *fix,
6980                                                     int action)
6981 {
6982         /*
6983          * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec,
6984          * but uses the 0x8686 subproduct id in both cases. The ALC256 codec
6985          * needs an additional quirk for sound working after suspend and resume.
6986          */
6987         if (codec->core.vendor_id == 0x10ec0256) {
6988                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
6989                 snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120);
6990         } else {
6991                 snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c);
6992         }
6993 }
6994
6995 static void alc256_decrease_headphone_amp_val(struct hda_codec *codec,
6996                                               const struct hda_fixup *fix, int action)
6997 {
6998         u32 caps;
6999         u8 nsteps, offs;
7000
7001         if (action != HDA_FIXUP_ACT_PRE_PROBE)
7002                 return;
7003
7004         caps = query_amp_caps(codec, 0x3, HDA_OUTPUT);
7005         nsteps = ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) - 10;
7006         offs = ((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT) - 10;
7007         caps &= ~AC_AMPCAP_NUM_STEPS & ~AC_AMPCAP_OFFSET;
7008         caps |= (nsteps << AC_AMPCAP_NUM_STEPS_SHIFT) | (offs << AC_AMPCAP_OFFSET_SHIFT);
7009
7010         if (snd_hda_override_amp_caps(codec, 0x3, HDA_OUTPUT, caps))
7011                 codec_warn(codec, "failed to override amp caps for NID 0x3\n");
7012 }
7013
7014 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec,
7015                                                   const struct hda_fixup *fix,
7016                                                   int action)
7017 {
7018         struct alc_spec *spec = codec->spec;
7019         struct hda_input_mux *imux = &spec->gen.input_mux;
7020         int i;
7021
7022         alc269_fixup_limit_int_mic_boost(codec, fix, action);
7023
7024         switch (action) {
7025         case HDA_FIXUP_ACT_PRE_PROBE:
7026                 /**
7027                  * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic)
7028                  * to Hi-Z to avoid pop noises at startup and when plugging and
7029                  * unplugging headphones.
7030                  */
7031                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
7032                 snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ);
7033                 break;
7034         case HDA_FIXUP_ACT_PROBE:
7035                 /**
7036                  * Make the internal mic (0x12) the default input source to
7037                  * prevent pop noises on cold boot.
7038                  */
7039                 for (i = 0; i < imux->num_items; i++) {
7040                         if (spec->gen.imux_pins[i] == 0x12) {
7041                                 spec->gen.cur_mux[0] = i;
7042                                 break;
7043                         }
7044                 }
7045                 break;
7046         }
7047 }
7048
7049 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec,
7050                                           const struct hda_fixup *fix, int action)
7051 {
7052         /*
7053          * The Pin Complex 0x17 for the bass speakers is wrongly reported as
7054          * unconnected.
7055          */
7056         static const struct hda_pintbl pincfgs[] = {
7057                 { 0x17, 0x90170121 },
7058                 { }
7059         };
7060         /*
7061          * Avoid DAC 0x06 and 0x08, as they have no volume controls.
7062          * DAC 0x02 and 0x03 would be fine.
7063          */
7064         static const hda_nid_t conn[] = { 0x02, 0x03 };
7065         /*
7066          * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02.
7067          * Headphones (0x21) are connected to DAC 0x03.
7068          */
7069         static const hda_nid_t preferred_pairs[] = {
7070                 0x14, 0x02,
7071                 0x17, 0x02,
7072                 0x21, 0x03,
7073                 0
7074         };
7075         struct alc_spec *spec = codec->spec;
7076
7077         switch (action) {
7078         case HDA_FIXUP_ACT_PRE_PROBE:
7079                 snd_hda_apply_pincfgs(codec, pincfgs);
7080                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7081                 spec->gen.preferred_dacs = preferred_pairs;
7082                 break;
7083         }
7084 }
7085
7086 static void alc295_fixup_dell_inspiron_top_speakers(struct hda_codec *codec,
7087                                           const struct hda_fixup *fix, int action)
7088 {
7089         static const struct hda_pintbl pincfgs[] = {
7090                 { 0x14, 0x90170151 },
7091                 { 0x17, 0x90170150 },
7092                 { }
7093         };
7094         static const hda_nid_t conn[] = { 0x02, 0x03 };
7095         static const hda_nid_t preferred_pairs[] = {
7096                 0x14, 0x02,
7097                 0x17, 0x03,
7098                 0x21, 0x02,
7099                 0
7100         };
7101         struct alc_spec *spec = codec->spec;
7102
7103         alc_fixup_no_shutup(codec, fix, action);
7104
7105         switch (action) {
7106         case HDA_FIXUP_ACT_PRE_PROBE:
7107                 snd_hda_apply_pincfgs(codec, pincfgs);
7108                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7109                 spec->gen.preferred_dacs = preferred_pairs;
7110                 break;
7111         }
7112 }
7113
7114 /* Forcibly assign NID 0x03 to HP while NID 0x02 to SPK */
7115 static void alc287_fixup_bind_dacs(struct hda_codec *codec,
7116                                     const struct hda_fixup *fix, int action)
7117 {
7118         struct alc_spec *spec = codec->spec;
7119         static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
7120         static const hda_nid_t preferred_pairs[] = {
7121                 0x17, 0x02, 0x21, 0x03, 0
7122         };
7123
7124         if (action != HDA_FIXUP_ACT_PRE_PROBE)
7125                 return;
7126
7127         snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7128         spec->gen.preferred_dacs = preferred_pairs;
7129         spec->gen.auto_mute_via_amp = 1;
7130         if (spec->gen.autocfg.speaker_pins[0] != 0x14) {
7131                 snd_hda_codec_write_cache(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
7132                                         0x0); /* Make sure 0x14 was disable */
7133         }
7134 }
7135 /* Fix none verb table of Headset Mic pin */
7136 static void alc_fixup_headset_mic(struct hda_codec *codec,
7137                                    const struct hda_fixup *fix, int action)
7138 {
7139         struct alc_spec *spec = codec->spec;
7140         static const struct hda_pintbl pincfgs[] = {
7141                 { 0x19, 0x03a1103c },
7142                 { }
7143         };
7144
7145         switch (action) {
7146         case HDA_FIXUP_ACT_PRE_PROBE:
7147                 snd_hda_apply_pincfgs(codec, pincfgs);
7148                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
7149                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
7150                 break;
7151         }
7152 }
7153
7154 static void alc245_fixup_hp_spectre_x360_eu0xxx(struct hda_codec *codec,
7155                                           const struct hda_fixup *fix, int action)
7156 {
7157         /*
7158          * The Pin Complex 0x14 for the treble speakers is wrongly reported as
7159          * unconnected.
7160          * The Pin Complex 0x17 for the bass speakers has the lowest association
7161          * and sequence values so shift it up a bit to squeeze 0x14 in.
7162          */
7163         static const struct hda_pintbl pincfgs[] = {
7164                 { 0x14, 0x90170110 }, // top/treble
7165                 { 0x17, 0x90170111 }, // bottom/bass
7166                 { }
7167         };
7168
7169         /*
7170          * Force DAC 0x02 for the bass speakers 0x17.
7171          */
7172         static const hda_nid_t conn[] = { 0x02 };
7173
7174         switch (action) {
7175         case HDA_FIXUP_ACT_PRE_PROBE:
7176                 snd_hda_apply_pincfgs(codec, pincfgs);
7177                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7178                 break;
7179         }
7180
7181         cs35l41_fixup_i2c_two(codec, fix, action);
7182         alc245_fixup_hp_mute_led_coefbit(codec, fix, action);
7183         alc245_fixup_hp_gpio_led(codec, fix, action);
7184 }
7185
7186
7187 enum {
7188         ALC269_FIXUP_GPIO2,
7189         ALC269_FIXUP_SONY_VAIO,
7190         ALC275_FIXUP_SONY_VAIO_GPIO2,
7191         ALC269_FIXUP_DELL_M101Z,
7192         ALC269_FIXUP_SKU_IGNORE,
7193         ALC269_FIXUP_ASUS_G73JW,
7194         ALC269_FIXUP_ASUS_N7601ZM_PINS,
7195         ALC269_FIXUP_ASUS_N7601ZM,
7196         ALC269_FIXUP_LENOVO_EAPD,
7197         ALC275_FIXUP_SONY_HWEQ,
7198         ALC275_FIXUP_SONY_DISABLE_AAMIX,
7199         ALC271_FIXUP_DMIC,
7200         ALC269_FIXUP_PCM_44K,
7201         ALC269_FIXUP_STEREO_DMIC,
7202         ALC269_FIXUP_HEADSET_MIC,
7203         ALC269_FIXUP_QUANTA_MUTE,
7204         ALC269_FIXUP_LIFEBOOK,
7205         ALC269_FIXUP_LIFEBOOK_EXTMIC,
7206         ALC269_FIXUP_LIFEBOOK_HP_PIN,
7207         ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
7208         ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
7209         ALC269_FIXUP_AMIC,
7210         ALC269_FIXUP_DMIC,
7211         ALC269VB_FIXUP_AMIC,
7212         ALC269VB_FIXUP_DMIC,
7213         ALC269_FIXUP_HP_MUTE_LED,
7214         ALC269_FIXUP_HP_MUTE_LED_MIC1,
7215         ALC269_FIXUP_HP_MUTE_LED_MIC2,
7216         ALC269_FIXUP_HP_MUTE_LED_MIC3,
7217         ALC269_FIXUP_HP_GPIO_LED,
7218         ALC269_FIXUP_HP_GPIO_MIC1_LED,
7219         ALC269_FIXUP_HP_LINE1_MIC1_LED,
7220         ALC269_FIXUP_INV_DMIC,
7221         ALC269_FIXUP_LENOVO_DOCK,
7222         ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
7223         ALC269_FIXUP_NO_SHUTUP,
7224         ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
7225         ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
7226         ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7227         ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7228         ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7229         ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7230         ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
7231         ALC269_FIXUP_HEADSET_MODE,
7232         ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
7233         ALC269_FIXUP_ASPIRE_HEADSET_MIC,
7234         ALC269_FIXUP_ASUS_X101_FUNC,
7235         ALC269_FIXUP_ASUS_X101_VERB,
7236         ALC269_FIXUP_ASUS_X101,
7237         ALC271_FIXUP_AMIC_MIC2,
7238         ALC271_FIXUP_HP_GATE_MIC_JACK,
7239         ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
7240         ALC269_FIXUP_ACER_AC700,
7241         ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
7242         ALC269VB_FIXUP_ASUS_ZENBOOK,
7243         ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
7244         ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE,
7245         ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
7246         ALC269VB_FIXUP_ORDISSIMO_EVE2,
7247         ALC283_FIXUP_CHROME_BOOK,
7248         ALC283_FIXUP_SENSE_COMBO_JACK,
7249         ALC282_FIXUP_ASUS_TX300,
7250         ALC283_FIXUP_INT_MIC,
7251         ALC290_FIXUP_MONO_SPEAKERS,
7252         ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7253         ALC290_FIXUP_SUBWOOFER,
7254         ALC290_FIXUP_SUBWOOFER_HSJACK,
7255         ALC269_FIXUP_THINKPAD_ACPI,
7256         ALC269_FIXUP_DMIC_THINKPAD_ACPI,
7257         ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO,
7258         ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
7259         ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7260         ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7261         ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7262         ALC255_FIXUP_HEADSET_MODE,
7263         ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
7264         ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7265         ALC292_FIXUP_TPT440_DOCK,
7266         ALC292_FIXUP_TPT440,
7267         ALC283_FIXUP_HEADSET_MIC,
7268         ALC255_FIXUP_MIC_MUTE_LED,
7269         ALC282_FIXUP_ASPIRE_V5_PINS,
7270         ALC269VB_FIXUP_ASPIRE_E1_COEF,
7271         ALC280_FIXUP_HP_GPIO4,
7272         ALC286_FIXUP_HP_GPIO_LED,
7273         ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
7274         ALC280_FIXUP_HP_DOCK_PINS,
7275         ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
7276         ALC280_FIXUP_HP_9480M,
7277         ALC245_FIXUP_HP_X360_AMP,
7278         ALC285_FIXUP_HP_SPECTRE_X360_EB1,
7279         ALC285_FIXUP_HP_ENVY_X360,
7280         ALC288_FIXUP_DELL_HEADSET_MODE,
7281         ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
7282         ALC288_FIXUP_DELL_XPS_13,
7283         ALC288_FIXUP_DISABLE_AAMIX,
7284         ALC292_FIXUP_DELL_E7X_AAMIX,
7285         ALC292_FIXUP_DELL_E7X,
7286         ALC292_FIXUP_DISABLE_AAMIX,
7287         ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
7288         ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
7289         ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7290         ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
7291         ALC275_FIXUP_DELL_XPS,
7292         ALC293_FIXUP_LENOVO_SPK_NOISE,
7293         ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7294         ALC255_FIXUP_DELL_SPK_NOISE,
7295         ALC225_FIXUP_DISABLE_MIC_VREF,
7296         ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7297         ALC295_FIXUP_DISABLE_DAC3,
7298         ALC285_FIXUP_SPEAKER2_TO_DAC1,
7299         ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1,
7300         ALC285_FIXUP_ASUS_HEADSET_MIC,
7301         ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS,
7302         ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1,
7303         ALC285_FIXUP_ASUS_I2C_HEADSET_MIC,
7304         ALC280_FIXUP_HP_HEADSET_MIC,
7305         ALC221_FIXUP_HP_FRONT_MIC,
7306         ALC292_FIXUP_TPT460,
7307         ALC298_FIXUP_SPK_VOLUME,
7308         ALC298_FIXUP_LENOVO_SPK_VOLUME,
7309         ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
7310         ALC269_FIXUP_ATIV_BOOK_8,
7311         ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
7312         ALC221_FIXUP_HP_MIC_NO_PRESENCE,
7313         ALC256_FIXUP_ASUS_HEADSET_MODE,
7314         ALC256_FIXUP_ASUS_MIC,
7315         ALC256_FIXUP_ASUS_AIO_GPIO2,
7316         ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
7317         ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
7318         ALC233_FIXUP_LENOVO_MULTI_CODECS,
7319         ALC233_FIXUP_ACER_HEADSET_MIC,
7320         ALC294_FIXUP_LENOVO_MIC_LOCATION,
7321         ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
7322         ALC225_FIXUP_S3_POP_NOISE,
7323         ALC700_FIXUP_INTEL_REFERENCE,
7324         ALC274_FIXUP_DELL_BIND_DACS,
7325         ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7326         ALC298_FIXUP_TPT470_DOCK_FIX,
7327         ALC298_FIXUP_TPT470_DOCK,
7328         ALC255_FIXUP_DUMMY_LINEOUT_VERB,
7329         ALC255_FIXUP_DELL_HEADSET_MIC,
7330         ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
7331         ALC298_FIXUP_HUAWEI_MBX_STEREO,
7332         ALC295_FIXUP_HP_X360,
7333         ALC221_FIXUP_HP_HEADSET_MIC,
7334         ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
7335         ALC295_FIXUP_HP_AUTO_MUTE,
7336         ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7337         ALC294_FIXUP_ASUS_MIC,
7338         ALC294_FIXUP_ASUS_HEADSET_MIC,
7339         ALC294_FIXUP_ASUS_SPK,
7340         ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7341         ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
7342         ALC255_FIXUP_ACER_HEADSET_MIC,
7343         ALC295_FIXUP_CHROME_BOOK,
7344         ALC225_FIXUP_HEADSET_JACK,
7345         ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
7346         ALC225_FIXUP_WYSE_AUTO_MUTE,
7347         ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
7348         ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
7349         ALC256_FIXUP_ASUS_HEADSET_MIC,
7350         ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7351         ALC299_FIXUP_PREDATOR_SPK,
7352         ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
7353         ALC289_FIXUP_DELL_SPK1,
7354         ALC289_FIXUP_DELL_SPK2,
7355         ALC289_FIXUP_DUAL_SPK,
7356         ALC289_FIXUP_RTK_AMP_DUAL_SPK,
7357         ALC294_FIXUP_SPK2_TO_DAC1,
7358         ALC294_FIXUP_ASUS_DUAL_SPK,
7359         ALC285_FIXUP_THINKPAD_X1_GEN7,
7360         ALC285_FIXUP_THINKPAD_HEADSET_JACK,
7361         ALC294_FIXUP_ASUS_ALLY,
7362         ALC294_FIXUP_ASUS_ALLY_PINS,
7363         ALC294_FIXUP_ASUS_ALLY_VERBS,
7364         ALC294_FIXUP_ASUS_ALLY_SPEAKER,
7365         ALC294_FIXUP_ASUS_HPE,
7366         ALC294_FIXUP_ASUS_COEF_1B,
7367         ALC294_FIXUP_ASUS_GX502_HP,
7368         ALC294_FIXUP_ASUS_GX502_PINS,
7369         ALC294_FIXUP_ASUS_GX502_VERBS,
7370         ALC294_FIXUP_ASUS_GU502_HP,
7371         ALC294_FIXUP_ASUS_GU502_PINS,
7372         ALC294_FIXUP_ASUS_GU502_VERBS,
7373         ALC294_FIXUP_ASUS_G513_PINS,
7374         ALC285_FIXUP_ASUS_G533Z_PINS,
7375         ALC285_FIXUP_HP_GPIO_LED,
7376         ALC285_FIXUP_HP_MUTE_LED,
7377         ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED,
7378         ALC236_FIXUP_HP_MUTE_LED_COEFBIT2,
7379         ALC236_FIXUP_HP_GPIO_LED,
7380         ALC236_FIXUP_HP_MUTE_LED,
7381         ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
7382         ALC298_FIXUP_SAMSUNG_AMP,
7383         ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7384         ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7385         ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
7386         ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
7387         ALC269VC_FIXUP_ACER_HEADSET_MIC,
7388         ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE,
7389         ALC289_FIXUP_ASUS_GA401,
7390         ALC289_FIXUP_ASUS_GA502,
7391         ALC256_FIXUP_ACER_MIC_NO_PRESENCE,
7392         ALC285_FIXUP_HP_GPIO_AMP_INIT,
7393         ALC269_FIXUP_CZC_B20,
7394         ALC269_FIXUP_CZC_TMI,
7395         ALC269_FIXUP_CZC_L101,
7396         ALC269_FIXUP_LEMOTE_A1802,
7397         ALC269_FIXUP_LEMOTE_A190X,
7398         ALC256_FIXUP_INTEL_NUC8_RUGGED,
7399         ALC233_FIXUP_INTEL_NUC8_DMIC,
7400         ALC233_FIXUP_INTEL_NUC8_BOOST,
7401         ALC256_FIXUP_INTEL_NUC10,
7402         ALC255_FIXUP_XIAOMI_HEADSET_MIC,
7403         ALC274_FIXUP_HP_MIC,
7404         ALC274_FIXUP_HP_HEADSET_MIC,
7405         ALC274_FIXUP_HP_ENVY_GPIO,
7406         ALC256_FIXUP_ASUS_HPE,
7407         ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
7408         ALC287_FIXUP_HP_GPIO_LED,
7409         ALC256_FIXUP_HP_HEADSET_MIC,
7410         ALC245_FIXUP_HP_GPIO_LED,
7411         ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
7412         ALC282_FIXUP_ACER_DISABLE_LINEOUT,
7413         ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST,
7414         ALC256_FIXUP_ACER_HEADSET_MIC,
7415         ALC285_FIXUP_IDEAPAD_S740_COEF,
7416         ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7417         ALC295_FIXUP_ASUS_DACS,
7418         ALC295_FIXUP_HP_OMEN,
7419         ALC285_FIXUP_HP_SPECTRE_X360,
7420         ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP,
7421         ALC623_FIXUP_LENOVO_THINKSTATION_P340,
7422         ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
7423         ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7424         ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
7425         ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
7426         ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
7427         ALC298_FIXUP_LENOVO_C940_DUET7,
7428         ALC287_FIXUP_LENOVO_14IRP8_DUETITL,
7429         ALC287_FIXUP_13S_GEN2_SPEAKERS,
7430         ALC256_FIXUP_SET_COEF_DEFAULTS,
7431         ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7432         ALC233_FIXUP_NO_AUDIO_JACK,
7433         ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME,
7434         ALC285_FIXUP_LEGION_Y9000X_SPEAKERS,
7435         ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
7436         ALC287_FIXUP_LEGION_16ACHG6,
7437         ALC287_FIXUP_CS35L41_I2C_2,
7438         ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED,
7439         ALC287_FIXUP_CS35L41_I2C_4,
7440         ALC245_FIXUP_CS35L41_SPI_2,
7441         ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED,
7442         ALC245_FIXUP_CS35L41_SPI_4,
7443         ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED,
7444         ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED,
7445         ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE,
7446         ALC287_FIXUP_LEGION_16ITHG6,
7447         ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
7448         ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN,
7449         ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN,
7450         ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS,
7451         ALC236_FIXUP_DELL_DUAL_CODECS,
7452         ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
7453         ALC287_FIXUP_TAS2781_I2C,
7454         ALC287_FIXUP_YOGA7_14ARB7_I2C,
7455         ALC245_FIXUP_HP_MUTE_LED_COEFBIT,
7456         ALC245_FIXUP_HP_X360_MUTE_LEDS,
7457         ALC287_FIXUP_THINKPAD_I2S_SPK,
7458         ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD,
7459         ALC2XX_FIXUP_HEADSET_MIC,
7460         ALC289_FIXUP_DELL_CS35L41_SPI_2,
7461         ALC294_FIXUP_CS35L41_I2C_2,
7462         ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED,
7463         ALC256_FIXUP_ACER_SFG16_MICMUTE_LED,
7464         ALC256_FIXUP_HEADPHONE_AMP_VOL,
7465         ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX,
7466         ALC285_FIXUP_CS35L56_SPI_2,
7467         ALC285_FIXUP_CS35L56_I2C_2,
7468         ALC285_FIXUP_CS35L56_I2C_4,
7469         ALC285_FIXUP_ASUS_GA403U,
7470         ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC,
7471         ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1,
7472         ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC,
7473         ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1
7474 };
7475
7476 /* A special fixup for Lenovo C940 and Yoga Duet 7;
7477  * both have the very same PCI SSID, and we need to apply different fixups
7478  * depending on the codec ID
7479  */
7480 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
7481                                            const struct hda_fixup *fix,
7482                                            int action)
7483 {
7484         int id;
7485
7486         if (codec->core.vendor_id == 0x10ec0298)
7487                 id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
7488         else
7489                 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
7490         __snd_hda_apply_fixup(codec, id, action, 0);
7491 }
7492
7493 /* A special fixup for Lenovo Slim/Yoga Pro 9 14IRP8 and Yoga DuetITL 2021;
7494  * 14IRP8 PCI SSID will mistakenly be matched with the DuetITL codec SSID,
7495  * so we need to apply a different fixup in this case. The only DuetITL codec
7496  * SSID reported so far is the 17aa:3802 while the 14IRP8 has the 17aa:38be
7497  * and 17aa:38bf. If it weren't for the PCI SSID, the 14IRP8 models would
7498  * have matched correctly by their codecs.
7499  */
7500 static void alc287_fixup_lenovo_14irp8_duetitl(struct hda_codec *codec,
7501                                               const struct hda_fixup *fix,
7502                                               int action)
7503 {
7504         int id;
7505
7506         if (codec->core.subsystem_id == 0x17aa3802)
7507                 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* DuetITL */
7508         else
7509                 id = ALC287_FIXUP_TAS2781_I2C; /* 14IRP8 */
7510         __snd_hda_apply_fixup(codec, id, action, 0);
7511 }
7512
7513 static const struct hda_fixup alc269_fixups[] = {
7514         [ALC269_FIXUP_GPIO2] = {
7515                 .type = HDA_FIXUP_FUNC,
7516                 .v.func = alc_fixup_gpio2,
7517         },
7518         [ALC269_FIXUP_SONY_VAIO] = {
7519                 .type = HDA_FIXUP_PINCTLS,
7520                 .v.pins = (const struct hda_pintbl[]) {
7521                         {0x19, PIN_VREFGRD},
7522                         {}
7523                 }
7524         },
7525         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
7526                 .type = HDA_FIXUP_FUNC,
7527                 .v.func = alc275_fixup_gpio4_off,
7528                 .chained = true,
7529                 .chain_id = ALC269_FIXUP_SONY_VAIO
7530         },
7531         [ALC269_FIXUP_DELL_M101Z] = {
7532                 .type = HDA_FIXUP_VERBS,
7533                 .v.verbs = (const struct hda_verb[]) {
7534                         /* Enables internal speaker */
7535                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
7536                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
7537                         {}
7538                 }
7539         },
7540         [ALC269_FIXUP_SKU_IGNORE] = {
7541                 .type = HDA_FIXUP_FUNC,
7542                 .v.func = alc_fixup_sku_ignore,
7543         },
7544         [ALC269_FIXUP_ASUS_G73JW] = {
7545                 .type = HDA_FIXUP_PINS,
7546                 .v.pins = (const struct hda_pintbl[]) {
7547                         { 0x17, 0x99130111 }, /* subwoofer */
7548                         { }
7549                 }
7550         },
7551         [ALC269_FIXUP_ASUS_N7601ZM_PINS] = {
7552                 .type = HDA_FIXUP_PINS,
7553                 .v.pins = (const struct hda_pintbl[]) {
7554                         { 0x19, 0x03A11050 },
7555                         { 0x1a, 0x03A11C30 },
7556                         { 0x21, 0x03211420 },
7557                         { }
7558                 }
7559         },
7560         [ALC269_FIXUP_ASUS_N7601ZM] = {
7561                 .type = HDA_FIXUP_VERBS,
7562                 .v.verbs = (const struct hda_verb[]) {
7563                         {0x20, AC_VERB_SET_COEF_INDEX, 0x62},
7564                         {0x20, AC_VERB_SET_PROC_COEF, 0xa007},
7565                         {0x20, AC_VERB_SET_COEF_INDEX, 0x10},
7566                         {0x20, AC_VERB_SET_PROC_COEF, 0x8420},
7567                         {0x20, AC_VERB_SET_COEF_INDEX, 0x0f},
7568                         {0x20, AC_VERB_SET_PROC_COEF, 0x7774},
7569                         { }
7570                 },
7571                 .chained = true,
7572                 .chain_id = ALC269_FIXUP_ASUS_N7601ZM_PINS,
7573         },
7574         [ALC269_FIXUP_LENOVO_EAPD] = {
7575                 .type = HDA_FIXUP_VERBS,
7576                 .v.verbs = (const struct hda_verb[]) {
7577                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
7578                         {}
7579                 }
7580         },
7581         [ALC275_FIXUP_SONY_HWEQ] = {
7582                 .type = HDA_FIXUP_FUNC,
7583                 .v.func = alc269_fixup_hweq,
7584                 .chained = true,
7585                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
7586         },
7587         [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
7588                 .type = HDA_FIXUP_FUNC,
7589                 .v.func = alc_fixup_disable_aamix,
7590                 .chained = true,
7591                 .chain_id = ALC269_FIXUP_SONY_VAIO
7592         },
7593         [ALC271_FIXUP_DMIC] = {
7594                 .type = HDA_FIXUP_FUNC,
7595                 .v.func = alc271_fixup_dmic,
7596         },
7597         [ALC269_FIXUP_PCM_44K] = {
7598                 .type = HDA_FIXUP_FUNC,
7599                 .v.func = alc269_fixup_pcm_44k,
7600                 .chained = true,
7601                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
7602         },
7603         [ALC269_FIXUP_STEREO_DMIC] = {
7604                 .type = HDA_FIXUP_FUNC,
7605                 .v.func = alc269_fixup_stereo_dmic,
7606         },
7607         [ALC269_FIXUP_HEADSET_MIC] = {
7608                 .type = HDA_FIXUP_FUNC,
7609                 .v.func = alc269_fixup_headset_mic,
7610         },
7611         [ALC269_FIXUP_QUANTA_MUTE] = {
7612                 .type = HDA_FIXUP_FUNC,
7613                 .v.func = alc269_fixup_quanta_mute,
7614         },
7615         [ALC269_FIXUP_LIFEBOOK] = {
7616                 .type = HDA_FIXUP_PINS,
7617                 .v.pins = (const struct hda_pintbl[]) {
7618                         { 0x1a, 0x2101103f }, /* dock line-out */
7619                         { 0x1b, 0x23a11040 }, /* dock mic-in */
7620                         { }
7621                 },
7622                 .chained = true,
7623                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
7624         },
7625         [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
7626                 .type = HDA_FIXUP_PINS,
7627                 .v.pins = (const struct hda_pintbl[]) {
7628                         { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
7629                         { }
7630                 },
7631         },
7632         [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
7633                 .type = HDA_FIXUP_PINS,
7634                 .v.pins = (const struct hda_pintbl[]) {
7635                         { 0x21, 0x0221102f }, /* HP out */
7636                         { }
7637                 },
7638         },
7639         [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
7640                 .type = HDA_FIXUP_FUNC,
7641                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7642         },
7643         [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
7644                 .type = HDA_FIXUP_FUNC,
7645                 .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
7646         },
7647         [ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO] = {
7648                 .type = HDA_FIXUP_PINS,
7649                 .v.pins = (const struct hda_pintbl[]) {
7650                         { 0x18, 0x03a19020 }, /* headset mic */
7651                         { 0x1b, 0x90170150 }, /* speaker */
7652                         { }
7653                 },
7654         },
7655         [ALC269_FIXUP_AMIC] = {
7656                 .type = HDA_FIXUP_PINS,
7657                 .v.pins = (const struct hda_pintbl[]) {
7658                         { 0x14, 0x99130110 }, /* speaker */
7659                         { 0x15, 0x0121401f }, /* HP out */
7660                         { 0x18, 0x01a19c20 }, /* mic */
7661                         { 0x19, 0x99a3092f }, /* int-mic */
7662                         { }
7663                 },
7664         },
7665         [ALC269_FIXUP_DMIC] = {
7666                 .type = HDA_FIXUP_PINS,
7667                 .v.pins = (const struct hda_pintbl[]) {
7668                         { 0x12, 0x99a3092f }, /* int-mic */
7669                         { 0x14, 0x99130110 }, /* speaker */
7670                         { 0x15, 0x0121401f }, /* HP out */
7671                         { 0x18, 0x01a19c20 }, /* mic */
7672                         { }
7673                 },
7674         },
7675         [ALC269VB_FIXUP_AMIC] = {
7676                 .type = HDA_FIXUP_PINS,
7677                 .v.pins = (const struct hda_pintbl[]) {
7678                         { 0x14, 0x99130110 }, /* speaker */
7679                         { 0x18, 0x01a19c20 }, /* mic */
7680                         { 0x19, 0x99a3092f }, /* int-mic */
7681                         { 0x21, 0x0121401f }, /* HP out */
7682                         { }
7683                 },
7684         },
7685         [ALC269VB_FIXUP_DMIC] = {
7686                 .type = HDA_FIXUP_PINS,
7687                 .v.pins = (const struct hda_pintbl[]) {
7688                         { 0x12, 0x99a3092f }, /* int-mic */
7689                         { 0x14, 0x99130110 }, /* speaker */
7690                         { 0x18, 0x01a19c20 }, /* mic */
7691                         { 0x21, 0x0121401f }, /* HP out */
7692                         { }
7693                 },
7694         },
7695         [ALC269_FIXUP_HP_MUTE_LED] = {
7696                 .type = HDA_FIXUP_FUNC,
7697                 .v.func = alc269_fixup_hp_mute_led,
7698         },
7699         [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
7700                 .type = HDA_FIXUP_FUNC,
7701                 .v.func = alc269_fixup_hp_mute_led_mic1,
7702         },
7703         [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
7704                 .type = HDA_FIXUP_FUNC,
7705                 .v.func = alc269_fixup_hp_mute_led_mic2,
7706         },
7707         [ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
7708                 .type = HDA_FIXUP_FUNC,
7709                 .v.func = alc269_fixup_hp_mute_led_mic3,
7710                 .chained = true,
7711                 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE
7712         },
7713         [ALC269_FIXUP_HP_GPIO_LED] = {
7714                 .type = HDA_FIXUP_FUNC,
7715                 .v.func = alc269_fixup_hp_gpio_led,
7716         },
7717         [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
7718                 .type = HDA_FIXUP_FUNC,
7719                 .v.func = alc269_fixup_hp_gpio_mic1_led,
7720         },
7721         [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
7722                 .type = HDA_FIXUP_FUNC,
7723                 .v.func = alc269_fixup_hp_line1_mic1_led,
7724         },
7725         [ALC269_FIXUP_INV_DMIC] = {
7726                 .type = HDA_FIXUP_FUNC,
7727                 .v.func = alc_fixup_inv_dmic,
7728         },
7729         [ALC269_FIXUP_NO_SHUTUP] = {
7730                 .type = HDA_FIXUP_FUNC,
7731                 .v.func = alc_fixup_no_shutup,
7732         },
7733         [ALC269_FIXUP_LENOVO_DOCK] = {
7734                 .type = HDA_FIXUP_PINS,
7735                 .v.pins = (const struct hda_pintbl[]) {
7736                         { 0x19, 0x23a11040 }, /* dock mic */
7737                         { 0x1b, 0x2121103f }, /* dock headphone */
7738                         { }
7739                 },
7740                 .chained = true,
7741                 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
7742         },
7743         [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
7744                 .type = HDA_FIXUP_FUNC,
7745                 .v.func = alc269_fixup_limit_int_mic_boost,
7746                 .chained = true,
7747                 .chain_id = ALC269_FIXUP_LENOVO_DOCK,
7748         },
7749         [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
7750                 .type = HDA_FIXUP_FUNC,
7751                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7752                 .chained = true,
7753                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7754         },
7755         [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7756                 .type = HDA_FIXUP_PINS,
7757                 .v.pins = (const struct hda_pintbl[]) {
7758                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7759                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7760                         { }
7761                 },
7762                 .chained = true,
7763                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7764         },
7765         [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
7766                 .type = HDA_FIXUP_PINS,
7767                 .v.pins = (const struct hda_pintbl[]) {
7768                         { 0x16, 0x21014020 }, /* dock line out */
7769                         { 0x19, 0x21a19030 }, /* dock mic */
7770                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7771                         { }
7772                 },
7773                 .chained = true,
7774                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7775         },
7776         [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
7777                 .type = HDA_FIXUP_PINS,
7778                 .v.pins = (const struct hda_pintbl[]) {
7779                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7780                         { }
7781                 },
7782                 .chained = true,
7783                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7784         },
7785         [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
7786                 .type = HDA_FIXUP_PINS,
7787                 .v.pins = (const struct hda_pintbl[]) {
7788                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7789                         { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7790                         { }
7791                 },
7792                 .chained = true,
7793                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7794         },
7795         [ALC269_FIXUP_HEADSET_MODE] = {
7796                 .type = HDA_FIXUP_FUNC,
7797                 .v.func = alc_fixup_headset_mode,
7798                 .chained = true,
7799                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7800         },
7801         [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7802                 .type = HDA_FIXUP_FUNC,
7803                 .v.func = alc_fixup_headset_mode_no_hp_mic,
7804         },
7805         [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
7806                 .type = HDA_FIXUP_PINS,
7807                 .v.pins = (const struct hda_pintbl[]) {
7808                         { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
7809                         { }
7810                 },
7811                 .chained = true,
7812                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
7813         },
7814         [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
7815                 .type = HDA_FIXUP_PINS,
7816                 .v.pins = (const struct hda_pintbl[]) {
7817                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7818                         { }
7819                 },
7820                 .chained = true,
7821                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7822         },
7823         [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
7824                 .type = HDA_FIXUP_PINS,
7825                 .v.pins = (const struct hda_pintbl[]) {
7826                         {0x12, 0x90a60130},
7827                         {0x13, 0x40000000},
7828                         {0x14, 0x90170110},
7829                         {0x18, 0x411111f0},
7830                         {0x19, 0x04a11040},
7831                         {0x1a, 0x411111f0},
7832                         {0x1b, 0x90170112},
7833                         {0x1d, 0x40759a05},
7834                         {0x1e, 0x411111f0},
7835                         {0x21, 0x04211020},
7836                         { }
7837                 },
7838                 .chained = true,
7839                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7840         },
7841         [ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
7842                 .type = HDA_FIXUP_FUNC,
7843                 .v.func = alc298_fixup_huawei_mbx_stereo,
7844                 .chained = true,
7845                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7846         },
7847         [ALC269_FIXUP_ASUS_X101_FUNC] = {
7848                 .type = HDA_FIXUP_FUNC,
7849                 .v.func = alc269_fixup_x101_headset_mic,
7850         },
7851         [ALC269_FIXUP_ASUS_X101_VERB] = {
7852                 .type = HDA_FIXUP_VERBS,
7853                 .v.verbs = (const struct hda_verb[]) {
7854                         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
7855                         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
7856                         {0x20, AC_VERB_SET_PROC_COEF,  0x0310},
7857                         { }
7858                 },
7859                 .chained = true,
7860                 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
7861         },
7862         [ALC269_FIXUP_ASUS_X101] = {
7863                 .type = HDA_FIXUP_PINS,
7864                 .v.pins = (const struct hda_pintbl[]) {
7865                         { 0x18, 0x04a1182c }, /* Headset mic */
7866                         { }
7867                 },
7868                 .chained = true,
7869                 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
7870         },
7871         [ALC271_FIXUP_AMIC_MIC2] = {
7872                 .type = HDA_FIXUP_PINS,
7873                 .v.pins = (const struct hda_pintbl[]) {
7874                         { 0x14, 0x99130110 }, /* speaker */
7875                         { 0x19, 0x01a19c20 }, /* mic */
7876                         { 0x1b, 0x99a7012f }, /* int-mic */
7877                         { 0x21, 0x0121401f }, /* HP out */
7878                         { }
7879                 },
7880         },
7881         [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
7882                 .type = HDA_FIXUP_FUNC,
7883                 .v.func = alc271_hp_gate_mic_jack,
7884                 .chained = true,
7885                 .chain_id = ALC271_FIXUP_AMIC_MIC2,
7886         },
7887         [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
7888                 .type = HDA_FIXUP_FUNC,
7889                 .v.func = alc269_fixup_limit_int_mic_boost,
7890                 .chained = true,
7891                 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
7892         },
7893         [ALC269_FIXUP_ACER_AC700] = {
7894                 .type = HDA_FIXUP_PINS,
7895                 .v.pins = (const struct hda_pintbl[]) {
7896                         { 0x12, 0x99a3092f }, /* int-mic */
7897                         { 0x14, 0x99130110 }, /* speaker */
7898                         { 0x18, 0x03a11c20 }, /* mic */
7899                         { 0x1e, 0x0346101e }, /* SPDIF1 */
7900                         { 0x21, 0x0321101f }, /* HP out */
7901                         { }
7902                 },
7903                 .chained = true,
7904                 .chain_id = ALC271_FIXUP_DMIC,
7905         },
7906         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
7907                 .type = HDA_FIXUP_FUNC,
7908                 .v.func = alc269_fixup_limit_int_mic_boost,
7909                 .chained = true,
7910                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7911         },
7912         [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
7913                 .type = HDA_FIXUP_FUNC,
7914                 .v.func = alc269_fixup_limit_int_mic_boost,
7915                 .chained = true,
7916                 .chain_id = ALC269VB_FIXUP_DMIC,
7917         },
7918         [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
7919                 .type = HDA_FIXUP_VERBS,
7920                 .v.verbs = (const struct hda_verb[]) {
7921                         /* class-D output amp +5dB */
7922                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
7923                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
7924                         {}
7925                 },
7926                 .chained = true,
7927                 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
7928         },
7929         [ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7930                 .type = HDA_FIXUP_PINS,
7931                 .v.pins = (const struct hda_pintbl[]) {
7932                         { 0x18, 0x01a110f0 },  /* use as headset mic */
7933                         { }
7934                 },
7935                 .chained = true,
7936                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7937         },
7938         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
7939                 .type = HDA_FIXUP_FUNC,
7940                 .v.func = alc269_fixup_limit_int_mic_boost,
7941                 .chained = true,
7942                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
7943         },
7944         [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
7945                 .type = HDA_FIXUP_PINS,
7946                 .v.pins = (const struct hda_pintbl[]) {
7947                         { 0x12, 0x99a3092f }, /* int-mic */
7948                         { 0x18, 0x03a11d20 }, /* mic */
7949                         { 0x19, 0x411111f0 }, /* Unused bogus pin */
7950                         { }
7951                 },
7952         },
7953         [ALC283_FIXUP_CHROME_BOOK] = {
7954                 .type = HDA_FIXUP_FUNC,
7955                 .v.func = alc283_fixup_chromebook,
7956         },
7957         [ALC283_FIXUP_SENSE_COMBO_JACK] = {
7958                 .type = HDA_FIXUP_FUNC,
7959                 .v.func = alc283_fixup_sense_combo_jack,
7960                 .chained = true,
7961                 .chain_id = ALC283_FIXUP_CHROME_BOOK,
7962         },
7963         [ALC282_FIXUP_ASUS_TX300] = {
7964                 .type = HDA_FIXUP_FUNC,
7965                 .v.func = alc282_fixup_asus_tx300,
7966         },
7967         [ALC283_FIXUP_INT_MIC] = {
7968                 .type = HDA_FIXUP_VERBS,
7969                 .v.verbs = (const struct hda_verb[]) {
7970                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
7971                         {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
7972                         { }
7973                 },
7974                 .chained = true,
7975                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
7976         },
7977         [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
7978                 .type = HDA_FIXUP_PINS,
7979                 .v.pins = (const struct hda_pintbl[]) {
7980                         { 0x17, 0x90170112 }, /* subwoofer */
7981                         { }
7982                 },
7983                 .chained = true,
7984                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7985         },
7986         [ALC290_FIXUP_SUBWOOFER] = {
7987                 .type = HDA_FIXUP_PINS,
7988                 .v.pins = (const struct hda_pintbl[]) {
7989                         { 0x17, 0x90170112 }, /* subwoofer */
7990                         { }
7991                 },
7992                 .chained = true,
7993                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
7994         },
7995         [ALC290_FIXUP_MONO_SPEAKERS] = {
7996                 .type = HDA_FIXUP_FUNC,
7997                 .v.func = alc290_fixup_mono_speakers,
7998         },
7999         [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
8000                 .type = HDA_FIXUP_FUNC,
8001                 .v.func = alc290_fixup_mono_speakers,
8002                 .chained = true,
8003                 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
8004         },
8005         [ALC269_FIXUP_THINKPAD_ACPI] = {
8006                 .type = HDA_FIXUP_FUNC,
8007                 .v.func = alc_fixup_thinkpad_acpi,
8008                 .chained = true,
8009                 .chain_id = ALC269_FIXUP_SKU_IGNORE,
8010         },
8011         [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
8012                 .type = HDA_FIXUP_FUNC,
8013                 .v.func = alc_fixup_inv_dmic,
8014                 .chained = true,
8015                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
8016         },
8017         [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
8018                 .type = HDA_FIXUP_PINS,
8019                 .v.pins = (const struct hda_pintbl[]) {
8020                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8021                         { }
8022                 },
8023                 .chained = true,
8024                 .chain_id = ALC255_FIXUP_HEADSET_MODE
8025         },
8026         [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8027                 .type = HDA_FIXUP_PINS,
8028                 .v.pins = (const struct hda_pintbl[]) {
8029                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8030                         { }
8031                 },
8032                 .chained = true,
8033                 .chain_id = ALC255_FIXUP_HEADSET_MODE
8034         },
8035         [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8036                 .type = HDA_FIXUP_PINS,
8037                 .v.pins = (const struct hda_pintbl[]) {
8038                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8039                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8040                         { }
8041                 },
8042                 .chained = true,
8043                 .chain_id = ALC255_FIXUP_HEADSET_MODE
8044         },
8045         [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
8046                 .type = HDA_FIXUP_PINS,
8047                 .v.pins = (const struct hda_pintbl[]) {
8048                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8049                         { }
8050                 },
8051                 .chained = true,
8052                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8053         },
8054         [ALC255_FIXUP_HEADSET_MODE] = {
8055                 .type = HDA_FIXUP_FUNC,
8056                 .v.func = alc_fixup_headset_mode_alc255,
8057                 .chained = true,
8058                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
8059         },
8060         [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
8061                 .type = HDA_FIXUP_FUNC,
8062                 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
8063         },
8064         [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8065                 .type = HDA_FIXUP_PINS,
8066                 .v.pins = (const struct hda_pintbl[]) {
8067                         { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8068                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8069                         { }
8070                 },
8071                 .chained = true,
8072                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8073         },
8074         [ALC292_FIXUP_TPT440_DOCK] = {
8075                 .type = HDA_FIXUP_FUNC,
8076                 .v.func = alc_fixup_tpt440_dock,
8077                 .chained = true,
8078                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
8079         },
8080         [ALC292_FIXUP_TPT440] = {
8081                 .type = HDA_FIXUP_FUNC,
8082                 .v.func = alc_fixup_disable_aamix,
8083                 .chained = true,
8084                 .chain_id = ALC292_FIXUP_TPT440_DOCK,
8085         },
8086         [ALC283_FIXUP_HEADSET_MIC] = {
8087                 .type = HDA_FIXUP_PINS,
8088                 .v.pins = (const struct hda_pintbl[]) {
8089                         { 0x19, 0x04a110f0 },
8090                         { },
8091                 },
8092         },
8093         [ALC255_FIXUP_MIC_MUTE_LED] = {
8094                 .type = HDA_FIXUP_FUNC,
8095                 .v.func = alc_fixup_micmute_led,
8096         },
8097         [ALC282_FIXUP_ASPIRE_V5_PINS] = {
8098                 .type = HDA_FIXUP_PINS,
8099                 .v.pins = (const struct hda_pintbl[]) {
8100                         { 0x12, 0x90a60130 },
8101                         { 0x14, 0x90170110 },
8102                         { 0x17, 0x40000008 },
8103                         { 0x18, 0x411111f0 },
8104                         { 0x19, 0x01a1913c },
8105                         { 0x1a, 0x411111f0 },
8106                         { 0x1b, 0x411111f0 },
8107                         { 0x1d, 0x40f89b2d },
8108                         { 0x1e, 0x411111f0 },
8109                         { 0x21, 0x0321101f },
8110                         { },
8111                 },
8112         },
8113         [ALC269VB_FIXUP_ASPIRE_E1_COEF] = {
8114                 .type = HDA_FIXUP_FUNC,
8115                 .v.func = alc269vb_fixup_aspire_e1_coef,
8116         },
8117         [ALC280_FIXUP_HP_GPIO4] = {
8118                 .type = HDA_FIXUP_FUNC,
8119                 .v.func = alc280_fixup_hp_gpio4,
8120         },
8121         [ALC286_FIXUP_HP_GPIO_LED] = {
8122                 .type = HDA_FIXUP_FUNC,
8123                 .v.func = alc286_fixup_hp_gpio_led,
8124         },
8125         [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
8126                 .type = HDA_FIXUP_FUNC,
8127                 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
8128         },
8129         [ALC280_FIXUP_HP_DOCK_PINS] = {
8130                 .type = HDA_FIXUP_PINS,
8131                 .v.pins = (const struct hda_pintbl[]) {
8132                         { 0x1b, 0x21011020 }, /* line-out */
8133                         { 0x1a, 0x01a1903c }, /* headset mic */
8134                         { 0x18, 0x2181103f }, /* line-in */
8135                         { },
8136                 },
8137                 .chained = true,
8138                 .chain_id = ALC280_FIXUP_HP_GPIO4
8139         },
8140         [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
8141                 .type = HDA_FIXUP_PINS,
8142                 .v.pins = (const struct hda_pintbl[]) {
8143                         { 0x1b, 0x21011020 }, /* line-out */
8144                         { 0x18, 0x2181103f }, /* line-in */
8145                         { },
8146                 },
8147                 .chained = true,
8148                 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
8149         },
8150         [ALC280_FIXUP_HP_9480M] = {
8151                 .type = HDA_FIXUP_FUNC,
8152                 .v.func = alc280_fixup_hp_9480m,
8153         },
8154         [ALC245_FIXUP_HP_X360_AMP] = {
8155                 .type = HDA_FIXUP_FUNC,
8156                 .v.func = alc245_fixup_hp_x360_amp,
8157                 .chained = true,
8158                 .chain_id = ALC245_FIXUP_HP_GPIO_LED
8159         },
8160         [ALC288_FIXUP_DELL_HEADSET_MODE] = {
8161                 .type = HDA_FIXUP_FUNC,
8162                 .v.func = alc_fixup_headset_mode_dell_alc288,
8163                 .chained = true,
8164                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
8165         },
8166         [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8167                 .type = HDA_FIXUP_PINS,
8168                 .v.pins = (const struct hda_pintbl[]) {
8169                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8170                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8171                         { }
8172                 },
8173                 .chained = true,
8174                 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
8175         },
8176         [ALC288_FIXUP_DISABLE_AAMIX] = {
8177                 .type = HDA_FIXUP_FUNC,
8178                 .v.func = alc_fixup_disable_aamix,
8179                 .chained = true,
8180                 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
8181         },
8182         [ALC288_FIXUP_DELL_XPS_13] = {
8183                 .type = HDA_FIXUP_FUNC,
8184                 .v.func = alc_fixup_dell_xps13,
8185                 .chained = true,
8186                 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
8187         },
8188         [ALC292_FIXUP_DISABLE_AAMIX] = {
8189                 .type = HDA_FIXUP_FUNC,
8190                 .v.func = alc_fixup_disable_aamix,
8191                 .chained = true,
8192                 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
8193         },
8194         [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
8195                 .type = HDA_FIXUP_FUNC,
8196                 .v.func = alc_fixup_disable_aamix,
8197                 .chained = true,
8198                 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
8199         },
8200         [ALC292_FIXUP_DELL_E7X_AAMIX] = {
8201                 .type = HDA_FIXUP_FUNC,
8202                 .v.func = alc_fixup_dell_xps13,
8203                 .chained = true,
8204                 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
8205         },
8206         [ALC292_FIXUP_DELL_E7X] = {
8207                 .type = HDA_FIXUP_FUNC,
8208                 .v.func = alc_fixup_micmute_led,
8209                 /* micmute fixup must be applied at last */
8210                 .chained_before = true,
8211                 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
8212         },
8213         [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
8214                 .type = HDA_FIXUP_PINS,
8215                 .v.pins = (const struct hda_pintbl[]) {
8216                         { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
8217                         { }
8218                 },
8219                 .chained_before = true,
8220                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
8221         },
8222         [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8223                 .type = HDA_FIXUP_PINS,
8224                 .v.pins = (const struct hda_pintbl[]) {
8225                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8226                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8227                         { }
8228                 },
8229                 .chained = true,
8230                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8231         },
8232         [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
8233                 .type = HDA_FIXUP_PINS,
8234                 .v.pins = (const struct hda_pintbl[]) {
8235                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8236                         { }
8237                 },
8238                 .chained = true,
8239                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8240         },
8241         [ALC275_FIXUP_DELL_XPS] = {
8242                 .type = HDA_FIXUP_VERBS,
8243                 .v.verbs = (const struct hda_verb[]) {
8244                         /* Enables internal speaker */
8245                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
8246                         {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
8247                         {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
8248                         {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
8249                         {}
8250                 }
8251         },
8252         [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
8253                 .type = HDA_FIXUP_FUNC,
8254                 .v.func = alc_fixup_disable_aamix,
8255                 .chained = true,
8256                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8257         },
8258         [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
8259                 .type = HDA_FIXUP_FUNC,
8260                 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
8261         },
8262         [ALC233_FIXUP_INTEL_NUC8_DMIC] = {
8263                 .type = HDA_FIXUP_FUNC,
8264                 .v.func = alc_fixup_inv_dmic,
8265                 .chained = true,
8266                 .chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST,
8267         },
8268         [ALC233_FIXUP_INTEL_NUC8_BOOST] = {
8269                 .type = HDA_FIXUP_FUNC,
8270                 .v.func = alc269_fixup_limit_int_mic_boost
8271         },
8272         [ALC255_FIXUP_DELL_SPK_NOISE] = {
8273                 .type = HDA_FIXUP_FUNC,
8274                 .v.func = alc_fixup_disable_aamix,
8275                 .chained = true,
8276                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8277         },
8278         [ALC225_FIXUP_DISABLE_MIC_VREF] = {
8279                 .type = HDA_FIXUP_FUNC,
8280                 .v.func = alc_fixup_disable_mic_vref,
8281                 .chained = true,
8282                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8283         },
8284         [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8285                 .type = HDA_FIXUP_VERBS,
8286                 .v.verbs = (const struct hda_verb[]) {
8287                         /* Disable pass-through path for FRONT 14h */
8288                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8289                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8290                         {}
8291                 },
8292                 .chained = true,
8293                 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
8294         },
8295         [ALC280_FIXUP_HP_HEADSET_MIC] = {
8296                 .type = HDA_FIXUP_FUNC,
8297                 .v.func = alc_fixup_disable_aamix,
8298                 .chained = true,
8299                 .chain_id = ALC269_FIXUP_HEADSET_MIC,
8300         },
8301         [ALC221_FIXUP_HP_FRONT_MIC] = {
8302                 .type = HDA_FIXUP_PINS,
8303                 .v.pins = (const struct hda_pintbl[]) {
8304                         { 0x19, 0x02a19020 }, /* Front Mic */
8305                         { }
8306                 },
8307         },
8308         [ALC292_FIXUP_TPT460] = {
8309                 .type = HDA_FIXUP_FUNC,
8310                 .v.func = alc_fixup_tpt440_dock,
8311                 .chained = true,
8312                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
8313         },
8314         [ALC298_FIXUP_SPK_VOLUME] = {
8315                 .type = HDA_FIXUP_FUNC,
8316                 .v.func = alc298_fixup_speaker_volume,
8317                 .chained = true,
8318                 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
8319         },
8320         [ALC298_FIXUP_LENOVO_SPK_VOLUME] = {
8321                 .type = HDA_FIXUP_FUNC,
8322                 .v.func = alc298_fixup_speaker_volume,
8323         },
8324         [ALC295_FIXUP_DISABLE_DAC3] = {
8325                 .type = HDA_FIXUP_FUNC,
8326                 .v.func = alc295_fixup_disable_dac3,
8327         },
8328         [ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
8329                 .type = HDA_FIXUP_FUNC,
8330                 .v.func = alc285_fixup_speaker2_to_dac1,
8331                 .chained = true,
8332                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8333         },
8334         [ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1] = {
8335                 .type = HDA_FIXUP_FUNC,
8336                 .v.func = alc285_fixup_speaker2_to_dac1,
8337                 .chained = true,
8338                 .chain_id = ALC245_FIXUP_CS35L41_SPI_2
8339         },
8340         [ALC285_FIXUP_ASUS_HEADSET_MIC] = {
8341                 .type = HDA_FIXUP_PINS,
8342                 .v.pins = (const struct hda_pintbl[]) {
8343                         { 0x19, 0x03a11050 },
8344                         { 0x1b, 0x03a11c30 },
8345                         { }
8346                 },
8347                 .chained = true,
8348                 .chain_id = ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1
8349         },
8350         [ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS] = {
8351                 .type = HDA_FIXUP_PINS,
8352                 .v.pins = (const struct hda_pintbl[]) {
8353                         { 0x14, 0x90170120 },
8354                         { }
8355                 },
8356                 .chained = true,
8357                 .chain_id = ALC285_FIXUP_ASUS_HEADSET_MIC
8358         },
8359         [ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1] = {
8360                 .type = HDA_FIXUP_FUNC,
8361                 .v.func = alc285_fixup_speaker2_to_dac1,
8362                 .chained = true,
8363                 .chain_id = ALC287_FIXUP_CS35L41_I2C_2
8364         },
8365         [ALC285_FIXUP_ASUS_I2C_HEADSET_MIC] = {
8366                 .type = HDA_FIXUP_PINS,
8367                 .v.pins = (const struct hda_pintbl[]) {
8368                         { 0x19, 0x03a11050 },
8369                         { 0x1b, 0x03a11c30 },
8370                         { }
8371                 },
8372                 .chained = true,
8373                 .chain_id = ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1
8374         },
8375         [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
8376                 .type = HDA_FIXUP_PINS,
8377                 .v.pins = (const struct hda_pintbl[]) {
8378                         { 0x1b, 0x90170151 },
8379                         { }
8380                 },
8381                 .chained = true,
8382                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8383         },
8384         [ALC269_FIXUP_ATIV_BOOK_8] = {
8385                 .type = HDA_FIXUP_FUNC,
8386                 .v.func = alc_fixup_auto_mute_via_amp,
8387                 .chained = true,
8388                 .chain_id = ALC269_FIXUP_NO_SHUTUP
8389         },
8390         [ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
8391                 .type = HDA_FIXUP_PINS,
8392                 .v.pins = (const struct hda_pintbl[]) {
8393                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8394                         { 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
8395                         { }
8396                 },
8397                 .chained = true,
8398                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8399         },
8400         [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
8401                 .type = HDA_FIXUP_PINS,
8402                 .v.pins = (const struct hda_pintbl[]) {
8403                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8404                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8405                         { }
8406                 },
8407                 .chained = true,
8408                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8409         },
8410         [ALC256_FIXUP_ASUS_HEADSET_MODE] = {
8411                 .type = HDA_FIXUP_FUNC,
8412                 .v.func = alc_fixup_headset_mode,
8413         },
8414         [ALC256_FIXUP_ASUS_MIC] = {
8415                 .type = HDA_FIXUP_PINS,
8416                 .v.pins = (const struct hda_pintbl[]) {
8417                         { 0x13, 0x90a60160 }, /* use as internal mic */
8418                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8419                         { }
8420                 },
8421                 .chained = true,
8422                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8423         },
8424         [ALC256_FIXUP_ASUS_AIO_GPIO2] = {
8425                 .type = HDA_FIXUP_FUNC,
8426                 /* Set up GPIO2 for the speaker amp */
8427                 .v.func = alc_fixup_gpio4,
8428         },
8429         [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8430                 .type = HDA_FIXUP_PINS,
8431                 .v.pins = (const struct hda_pintbl[]) {
8432                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8433                         { }
8434                 },
8435                 .chained = true,
8436                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8437         },
8438         [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
8439                 .type = HDA_FIXUP_VERBS,
8440                 .v.verbs = (const struct hda_verb[]) {
8441                         /* Enables internal speaker */
8442                         {0x20, AC_VERB_SET_COEF_INDEX, 0x40},
8443                         {0x20, AC_VERB_SET_PROC_COEF, 0x8800},
8444                         {}
8445                 },
8446                 .chained = true,
8447                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8448         },
8449         [ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
8450                 .type = HDA_FIXUP_FUNC,
8451                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8452                 .chained = true,
8453                 .chain_id = ALC269_FIXUP_GPIO2
8454         },
8455         [ALC233_FIXUP_ACER_HEADSET_MIC] = {
8456                 .type = HDA_FIXUP_VERBS,
8457                 .v.verbs = (const struct hda_verb[]) {
8458                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8459                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8460                         { }
8461                 },
8462                 .chained = true,
8463                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8464         },
8465         [ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
8466                 .type = HDA_FIXUP_PINS,
8467                 .v.pins = (const struct hda_pintbl[]) {
8468                         /* Change the mic location from front to right, otherwise there are
8469                            two front mics with the same name, pulseaudio can't handle them.
8470                            This is just a temporary workaround, after applying this fixup,
8471                            there will be one "Front Mic" and one "Mic" in this machine.
8472                          */
8473                         { 0x1a, 0x04a19040 },
8474                         { }
8475                 },
8476         },
8477         [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
8478                 .type = HDA_FIXUP_PINS,
8479                 .v.pins = (const struct hda_pintbl[]) {
8480                         { 0x16, 0x0101102f }, /* Rear Headset HP */
8481                         { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
8482                         { 0x1a, 0x01a19030 }, /* Rear Headset MIC */
8483                         { 0x1b, 0x02011020 },
8484                         { }
8485                 },
8486                 .chained = true,
8487                 .chain_id = ALC225_FIXUP_S3_POP_NOISE
8488         },
8489         [ALC225_FIXUP_S3_POP_NOISE] = {
8490                 .type = HDA_FIXUP_FUNC,
8491                 .v.func = alc225_fixup_s3_pop_noise,
8492                 .chained = true,
8493                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8494         },
8495         [ALC700_FIXUP_INTEL_REFERENCE] = {
8496                 .type = HDA_FIXUP_VERBS,
8497                 .v.verbs = (const struct hda_verb[]) {
8498                         /* Enables internal speaker */
8499                         {0x20, AC_VERB_SET_COEF_INDEX, 0x45},
8500                         {0x20, AC_VERB_SET_PROC_COEF, 0x5289},
8501                         {0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
8502                         {0x20, AC_VERB_SET_PROC_COEF, 0x001b},
8503                         {0x58, AC_VERB_SET_COEF_INDEX, 0x00},
8504                         {0x58, AC_VERB_SET_PROC_COEF, 0x3888},
8505                         {0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
8506                         {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
8507                         {}
8508                 }
8509         },
8510         [ALC274_FIXUP_DELL_BIND_DACS] = {
8511                 .type = HDA_FIXUP_FUNC,
8512                 .v.func = alc274_fixup_bind_dacs,
8513                 .chained = true,
8514                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8515         },
8516         [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
8517                 .type = HDA_FIXUP_PINS,
8518                 .v.pins = (const struct hda_pintbl[]) {
8519                         { 0x1b, 0x0401102f },
8520                         { }
8521                 },
8522                 .chained = true,
8523                 .chain_id = ALC274_FIXUP_DELL_BIND_DACS
8524         },
8525         [ALC298_FIXUP_TPT470_DOCK_FIX] = {
8526                 .type = HDA_FIXUP_FUNC,
8527                 .v.func = alc_fixup_tpt470_dock,
8528                 .chained = true,
8529                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
8530         },
8531         [ALC298_FIXUP_TPT470_DOCK] = {
8532                 .type = HDA_FIXUP_FUNC,
8533                 .v.func = alc_fixup_tpt470_dacs,
8534                 .chained = true,
8535                 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
8536         },
8537         [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
8538                 .type = HDA_FIXUP_PINS,
8539                 .v.pins = (const struct hda_pintbl[]) {
8540                         { 0x14, 0x0201101f },
8541                         { }
8542                 },
8543                 .chained = true,
8544                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8545         },
8546         [ALC255_FIXUP_DELL_HEADSET_MIC] = {
8547                 .type = HDA_FIXUP_PINS,
8548                 .v.pins = (const struct hda_pintbl[]) {
8549                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8550                         { }
8551                 },
8552                 .chained = true,
8553                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8554         },
8555         [ALC295_FIXUP_HP_X360] = {
8556                 .type = HDA_FIXUP_FUNC,
8557                 .v.func = alc295_fixup_hp_top_speakers,
8558                 .chained = true,
8559                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
8560         },
8561         [ALC221_FIXUP_HP_HEADSET_MIC] = {
8562                 .type = HDA_FIXUP_PINS,
8563                 .v.pins = (const struct hda_pintbl[]) {
8564                         { 0x19, 0x0181313f},
8565                         { }
8566                 },
8567                 .chained = true,
8568                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8569         },
8570         [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
8571                 .type = HDA_FIXUP_FUNC,
8572                 .v.func = alc285_fixup_invalidate_dacs,
8573                 .chained = true,
8574                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8575         },
8576         [ALC295_FIXUP_HP_AUTO_MUTE] = {
8577                 .type = HDA_FIXUP_FUNC,
8578                 .v.func = alc_fixup_auto_mute_via_amp,
8579         },
8580         [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
8581                 .type = HDA_FIXUP_PINS,
8582                 .v.pins = (const struct hda_pintbl[]) {
8583                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8584                         { }
8585                 },
8586                 .chained = true,
8587                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8588         },
8589         [ALC294_FIXUP_ASUS_MIC] = {
8590                 .type = HDA_FIXUP_PINS,
8591                 .v.pins = (const struct hda_pintbl[]) {
8592                         { 0x13, 0x90a60160 }, /* use as internal mic */
8593                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8594                         { }
8595                 },
8596                 .chained = true,
8597                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8598         },
8599         [ALC294_FIXUP_ASUS_HEADSET_MIC] = {
8600                 .type = HDA_FIXUP_PINS,
8601                 .v.pins = (const struct hda_pintbl[]) {
8602                         { 0x19, 0x01a1103c }, /* use as headset mic */
8603                         { }
8604                 },
8605                 .chained = true,
8606                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8607         },
8608         [ALC294_FIXUP_ASUS_SPK] = {
8609                 .type = HDA_FIXUP_VERBS,
8610                 .v.verbs = (const struct hda_verb[]) {
8611                         /* Set EAPD high */
8612                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
8613                         { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
8614                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8615                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8616                         { }
8617                 },
8618                 .chained = true,
8619                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8620         },
8621         [ALC295_FIXUP_CHROME_BOOK] = {
8622                 .type = HDA_FIXUP_FUNC,
8623                 .v.func = alc295_fixup_chromebook,
8624                 .chained = true,
8625                 .chain_id = ALC225_FIXUP_HEADSET_JACK
8626         },
8627         [ALC225_FIXUP_HEADSET_JACK] = {
8628                 .type = HDA_FIXUP_FUNC,
8629                 .v.func = alc_fixup_headset_jack,
8630         },
8631         [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
8632                 .type = HDA_FIXUP_PINS,
8633                 .v.pins = (const struct hda_pintbl[]) {
8634                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8635                         { }
8636                 },
8637                 .chained = true,
8638                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8639         },
8640         [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
8641                 .type = HDA_FIXUP_VERBS,
8642                 .v.verbs = (const struct hda_verb[]) {
8643                         /* Disable PCBEEP-IN passthrough */
8644                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8645                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8646                         { }
8647                 },
8648                 .chained = true,
8649                 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
8650         },
8651         [ALC255_FIXUP_ACER_HEADSET_MIC] = {
8652                 .type = HDA_FIXUP_PINS,
8653                 .v.pins = (const struct hda_pintbl[]) {
8654                         { 0x19, 0x03a11130 },
8655                         { 0x1a, 0x90a60140 }, /* use as internal mic */
8656                         { }
8657                 },
8658                 .chained = true,
8659                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8660         },
8661         [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
8662                 .type = HDA_FIXUP_PINS,
8663                 .v.pins = (const struct hda_pintbl[]) {
8664                         { 0x16, 0x01011020 }, /* Rear Line out */
8665                         { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
8666                         { }
8667                 },
8668                 .chained = true,
8669                 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
8670         },
8671         [ALC225_FIXUP_WYSE_AUTO_MUTE] = {
8672                 .type = HDA_FIXUP_FUNC,
8673                 .v.func = alc_fixup_auto_mute_via_amp,
8674                 .chained = true,
8675                 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
8676         },
8677         [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
8678                 .type = HDA_FIXUP_FUNC,
8679                 .v.func = alc_fixup_disable_mic_vref,
8680                 .chained = true,
8681                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8682         },
8683         [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
8684                 .type = HDA_FIXUP_VERBS,
8685                 .v.verbs = (const struct hda_verb[]) {
8686                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
8687                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
8688                         { }
8689                 },
8690                 .chained = true,
8691                 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
8692         },
8693         [ALC256_FIXUP_ASUS_HEADSET_MIC] = {
8694                 .type = HDA_FIXUP_PINS,
8695                 .v.pins = (const struct hda_pintbl[]) {
8696                         { 0x19, 0x03a11020 }, /* headset mic with jack detect */
8697                         { }
8698                 },
8699                 .chained = true,
8700                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8701         },
8702         [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8703                 .type = HDA_FIXUP_PINS,
8704                 .v.pins = (const struct hda_pintbl[]) {
8705                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8706                         { }
8707                 },
8708                 .chained = true,
8709                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8710         },
8711         [ALC299_FIXUP_PREDATOR_SPK] = {
8712                 .type = HDA_FIXUP_PINS,
8713                 .v.pins = (const struct hda_pintbl[]) {
8714                         { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
8715                         { }
8716                 }
8717         },
8718         [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
8719                 .type = HDA_FIXUP_PINS,
8720                 .v.pins = (const struct hda_pintbl[]) {
8721                         { 0x19, 0x04a11040 },
8722                         { 0x21, 0x04211020 },
8723                         { }
8724                 },
8725                 .chained = true,
8726                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8727         },
8728         [ALC289_FIXUP_DELL_SPK1] = {
8729                 .type = HDA_FIXUP_PINS,
8730                 .v.pins = (const struct hda_pintbl[]) {
8731                         { 0x14, 0x90170140 },
8732                         { }
8733                 },
8734                 .chained = true,
8735                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8736         },
8737         [ALC289_FIXUP_DELL_SPK2] = {
8738                 .type = HDA_FIXUP_PINS,
8739                 .v.pins = (const struct hda_pintbl[]) {
8740                         { 0x17, 0x90170130 }, /* bass spk */
8741                         { }
8742                 },
8743                 .chained = true,
8744                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8745         },
8746         [ALC289_FIXUP_DUAL_SPK] = {
8747                 .type = HDA_FIXUP_FUNC,
8748                 .v.func = alc285_fixup_speaker2_to_dac1,
8749                 .chained = true,
8750                 .chain_id = ALC289_FIXUP_DELL_SPK2
8751         },
8752         [ALC289_FIXUP_RTK_AMP_DUAL_SPK] = {
8753                 .type = HDA_FIXUP_FUNC,
8754                 .v.func = alc285_fixup_speaker2_to_dac1,
8755                 .chained = true,
8756                 .chain_id = ALC289_FIXUP_DELL_SPK1
8757         },
8758         [ALC294_FIXUP_SPK2_TO_DAC1] = {
8759                 .type = HDA_FIXUP_FUNC,
8760                 .v.func = alc285_fixup_speaker2_to_dac1,
8761                 .chained = true,
8762                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8763         },
8764         [ALC294_FIXUP_ASUS_DUAL_SPK] = {
8765                 .type = HDA_FIXUP_FUNC,
8766                 /* The GPIO must be pulled to initialize the AMP */
8767                 .v.func = alc_fixup_gpio4,
8768                 .chained = true,
8769                 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1
8770         },
8771         [ALC294_FIXUP_ASUS_ALLY] = {
8772                 .type = HDA_FIXUP_FUNC,
8773                 .v.func = cs35l41_fixup_i2c_two,
8774                 .chained = true,
8775                 .chain_id = ALC294_FIXUP_ASUS_ALLY_PINS
8776         },
8777         [ALC294_FIXUP_ASUS_ALLY_PINS] = {
8778                 .type = HDA_FIXUP_PINS,
8779                 .v.pins = (const struct hda_pintbl[]) {
8780                         { 0x19, 0x03a11050 },
8781                         { 0x1a, 0x03a11c30 },
8782                         { 0x21, 0x03211420 },
8783                         { }
8784                 },
8785                 .chained = true,
8786                 .chain_id = ALC294_FIXUP_ASUS_ALLY_VERBS
8787         },
8788         [ALC294_FIXUP_ASUS_ALLY_VERBS] = {
8789                 .type = HDA_FIXUP_VERBS,
8790                 .v.verbs = (const struct hda_verb[]) {
8791                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8792                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8793                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x46 },
8794                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0004 },
8795                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x47 },
8796                         { 0x20, AC_VERB_SET_PROC_COEF, 0xa47a },
8797                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x49 },
8798                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0049},
8799                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x4a },
8800                         { 0x20, AC_VERB_SET_PROC_COEF, 0x201b },
8801                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x6b },
8802                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4278},
8803                         { }
8804                 },
8805                 .chained = true,
8806                 .chain_id = ALC294_FIXUP_ASUS_ALLY_SPEAKER
8807         },
8808         [ALC294_FIXUP_ASUS_ALLY_SPEAKER] = {
8809                 .type = HDA_FIXUP_FUNC,
8810                 .v.func = alc285_fixup_speaker2_to_dac1,
8811         },
8812         [ALC285_FIXUP_THINKPAD_X1_GEN7] = {
8813                 .type = HDA_FIXUP_FUNC,
8814                 .v.func = alc285_fixup_thinkpad_x1_gen7,
8815                 .chained = true,
8816                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8817         },
8818         [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
8819                 .type = HDA_FIXUP_FUNC,
8820                 .v.func = alc_fixup_headset_jack,
8821                 .chained = true,
8822                 .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
8823         },
8824         [ALC294_FIXUP_ASUS_HPE] = {
8825                 .type = HDA_FIXUP_VERBS,
8826                 .v.verbs = (const struct hda_verb[]) {
8827                         /* Set EAPD high */
8828                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8829                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8830                         { }
8831                 },
8832                 .chained = true,
8833                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8834         },
8835         [ALC294_FIXUP_ASUS_GX502_PINS] = {
8836                 .type = HDA_FIXUP_PINS,
8837                 .v.pins = (const struct hda_pintbl[]) {
8838                         { 0x19, 0x03a11050 }, /* front HP mic */
8839                         { 0x1a, 0x01a11830 }, /* rear external mic */
8840                         { 0x21, 0x03211020 }, /* front HP out */
8841                         { }
8842                 },
8843                 .chained = true,
8844                 .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS
8845         },
8846         [ALC294_FIXUP_ASUS_GX502_VERBS] = {
8847                 .type = HDA_FIXUP_VERBS,
8848                 .v.verbs = (const struct hda_verb[]) {
8849                         /* set 0x15 to HP-OUT ctrl */
8850                         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8851                         /* unmute the 0x15 amp */
8852                         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8853                         { }
8854                 },
8855                 .chained = true,
8856                 .chain_id = ALC294_FIXUP_ASUS_GX502_HP
8857         },
8858         [ALC294_FIXUP_ASUS_GX502_HP] = {
8859                 .type = HDA_FIXUP_FUNC,
8860                 .v.func = alc294_fixup_gx502_hp,
8861         },
8862         [ALC294_FIXUP_ASUS_GU502_PINS] = {
8863                 .type = HDA_FIXUP_PINS,
8864                 .v.pins = (const struct hda_pintbl[]) {
8865                         { 0x19, 0x01a11050 }, /* rear HP mic */
8866                         { 0x1a, 0x01a11830 }, /* rear external mic */
8867                         { 0x21, 0x012110f0 }, /* rear HP out */
8868                         { }
8869                 },
8870                 .chained = true,
8871                 .chain_id = ALC294_FIXUP_ASUS_GU502_VERBS
8872         },
8873         [ALC294_FIXUP_ASUS_GU502_VERBS] = {
8874                 .type = HDA_FIXUP_VERBS,
8875                 .v.verbs = (const struct hda_verb[]) {
8876                         /* set 0x15 to HP-OUT ctrl */
8877                         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8878                         /* unmute the 0x15 amp */
8879                         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8880                         /* set 0x1b to HP-OUT */
8881                         { 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
8882                         { }
8883                 },
8884                 .chained = true,
8885                 .chain_id = ALC294_FIXUP_ASUS_GU502_HP
8886         },
8887         [ALC294_FIXUP_ASUS_GU502_HP] = {
8888                 .type = HDA_FIXUP_FUNC,
8889                 .v.func = alc294_fixup_gu502_hp,
8890         },
8891          [ALC294_FIXUP_ASUS_G513_PINS] = {
8892                 .type = HDA_FIXUP_PINS,
8893                 .v.pins = (const struct hda_pintbl[]) {
8894                                 { 0x19, 0x03a11050 }, /* front HP mic */
8895                                 { 0x1a, 0x03a11c30 }, /* rear external mic */
8896                                 { 0x21, 0x03211420 }, /* front HP out */
8897                                 { }
8898                 },
8899         },
8900         [ALC285_FIXUP_ASUS_G533Z_PINS] = {
8901                 .type = HDA_FIXUP_PINS,
8902                 .v.pins = (const struct hda_pintbl[]) {
8903                         { 0x14, 0x90170152 }, /* Speaker Surround Playback Switch */
8904                         { 0x19, 0x03a19020 }, /* Mic Boost Volume */
8905                         { 0x1a, 0x03a11c30 }, /* Mic Boost Volume */
8906                         { 0x1e, 0x90170151 }, /* Rear jack, IN OUT EAPD Detect */
8907                         { 0x21, 0x03211420 },
8908                         { }
8909                 },
8910         },
8911         [ALC294_FIXUP_ASUS_COEF_1B] = {
8912                 .type = HDA_FIXUP_VERBS,
8913                 .v.verbs = (const struct hda_verb[]) {
8914                         /* Set bit 10 to correct noisy output after reboot from
8915                          * Windows 10 (due to pop noise reduction?)
8916                          */
8917                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
8918                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
8919                         { }
8920                 },
8921                 .chained = true,
8922                 .chain_id = ALC289_FIXUP_ASUS_GA401,
8923         },
8924         [ALC285_FIXUP_HP_GPIO_LED] = {
8925                 .type = HDA_FIXUP_FUNC,
8926                 .v.func = alc285_fixup_hp_gpio_led,
8927         },
8928         [ALC285_FIXUP_HP_MUTE_LED] = {
8929                 .type = HDA_FIXUP_FUNC,
8930                 .v.func = alc285_fixup_hp_mute_led,
8931         },
8932         [ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED] = {
8933                 .type = HDA_FIXUP_FUNC,
8934                 .v.func = alc285_fixup_hp_spectre_x360_mute_led,
8935         },
8936         [ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = {
8937             .type = HDA_FIXUP_FUNC,
8938             .v.func = alc236_fixup_hp_mute_led_coefbit2,
8939         },
8940         [ALC236_FIXUP_HP_GPIO_LED] = {
8941                 .type = HDA_FIXUP_FUNC,
8942                 .v.func = alc236_fixup_hp_gpio_led,
8943         },
8944         [ALC236_FIXUP_HP_MUTE_LED] = {
8945                 .type = HDA_FIXUP_FUNC,
8946                 .v.func = alc236_fixup_hp_mute_led,
8947         },
8948         [ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = {
8949                 .type = HDA_FIXUP_FUNC,
8950                 .v.func = alc236_fixup_hp_mute_led_micmute_vref,
8951         },
8952         [ALC298_FIXUP_SAMSUNG_AMP] = {
8953                 .type = HDA_FIXUP_FUNC,
8954                 .v.func = alc298_fixup_samsung_amp,
8955                 .chained = true,
8956                 .chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET
8957         },
8958         [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8959                 .type = HDA_FIXUP_VERBS,
8960                 .v.verbs = (const struct hda_verb[]) {
8961                         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
8962                         { }
8963                 },
8964         },
8965         [ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8966                 .type = HDA_FIXUP_VERBS,
8967                 .v.verbs = (const struct hda_verb[]) {
8968                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08},
8969                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf},
8970                         { }
8971                 },
8972         },
8973         [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8974                 .type = HDA_FIXUP_PINS,
8975                 .v.pins = (const struct hda_pintbl[]) {
8976                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8977                         { }
8978                 },
8979                 .chained = true,
8980                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8981         },
8982         [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = {
8983                 .type = HDA_FIXUP_PINS,
8984                 .v.pins = (const struct hda_pintbl[]) {
8985                         { 0x14, 0x90100120 }, /* use as internal speaker */
8986                         { 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */
8987                         { 0x1a, 0x01011020 }, /* use as line out */
8988                         { },
8989                 },
8990                 .chained = true,
8991                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8992         },
8993         [ALC269VC_FIXUP_ACER_HEADSET_MIC] = {
8994                 .type = HDA_FIXUP_PINS,
8995                 .v.pins = (const struct hda_pintbl[]) {
8996                         { 0x18, 0x02a11030 }, /* use as headset mic */
8997                         { }
8998                 },
8999                 .chained = true,
9000                 .chain_id = ALC269_FIXUP_HEADSET_MIC
9001         },
9002         [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = {
9003                 .type = HDA_FIXUP_PINS,
9004                 .v.pins = (const struct hda_pintbl[]) {
9005                         { 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */
9006                         { }
9007                 },
9008                 .chained = true,
9009                 .chain_id = ALC269_FIXUP_HEADSET_MIC
9010         },
9011         [ALC289_FIXUP_ASUS_GA401] = {
9012                 .type = HDA_FIXUP_FUNC,
9013                 .v.func = alc289_fixup_asus_ga401,
9014                 .chained = true,
9015                 .chain_id = ALC289_FIXUP_ASUS_GA502,
9016         },
9017         [ALC289_FIXUP_ASUS_GA502] = {
9018                 .type = HDA_FIXUP_PINS,
9019                 .v.pins = (const struct hda_pintbl[]) {
9020                         { 0x19, 0x03a11020 }, /* headset mic with jack detect */
9021                         { }
9022                 },
9023         },
9024         [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = {
9025                 .type = HDA_FIXUP_PINS,
9026                 .v.pins = (const struct hda_pintbl[]) {
9027                         { 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */
9028                         { }
9029                 },
9030                 .chained = true,
9031                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
9032         },
9033         [ALC285_FIXUP_HP_GPIO_AMP_INIT] = {
9034                 .type = HDA_FIXUP_FUNC,
9035                 .v.func = alc285_fixup_hp_gpio_amp_init,
9036                 .chained = true,
9037                 .chain_id = ALC285_FIXUP_HP_GPIO_LED
9038         },
9039         [ALC269_FIXUP_CZC_B20] = {
9040                 .type = HDA_FIXUP_PINS,
9041                 .v.pins = (const struct hda_pintbl[]) {
9042                         { 0x12, 0x411111f0 },
9043                         { 0x14, 0x90170110 }, /* speaker */
9044                         { 0x15, 0x032f1020 }, /* HP out */
9045                         { 0x17, 0x411111f0 },
9046                         { 0x18, 0x03ab1040 }, /* mic */
9047                         { 0x19, 0xb7a7013f },
9048                         { 0x1a, 0x0181305f },
9049                         { 0x1b, 0x411111f0 },
9050                         { 0x1d, 0x411111f0 },
9051                         { 0x1e, 0x411111f0 },
9052                         { }
9053                 },
9054                 .chain_id = ALC269_FIXUP_DMIC,
9055         },
9056         [ALC269_FIXUP_CZC_TMI] = {
9057                 .type = HDA_FIXUP_PINS,
9058                 .v.pins = (const struct hda_pintbl[]) {
9059                         { 0x12, 0x4000c000 },
9060                         { 0x14, 0x90170110 }, /* speaker */
9061                         { 0x15, 0x0421401f }, /* HP out */
9062                         { 0x17, 0x411111f0 },
9063                         { 0x18, 0x04a19020 }, /* mic */
9064                         { 0x19, 0x411111f0 },
9065                         { 0x1a, 0x411111f0 },
9066                         { 0x1b, 0x411111f0 },
9067                         { 0x1d, 0x40448505 },
9068                         { 0x1e, 0x411111f0 },
9069                         { 0x20, 0x8000ffff },
9070                         { }
9071                 },
9072                 .chain_id = ALC269_FIXUP_DMIC,
9073         },
9074         [ALC269_FIXUP_CZC_L101] = {
9075                 .type = HDA_FIXUP_PINS,
9076                 .v.pins = (const struct hda_pintbl[]) {
9077                         { 0x12, 0x40000000 },
9078                         { 0x14, 0x01014010 }, /* speaker */
9079                         { 0x15, 0x411111f0 }, /* HP out */
9080                         { 0x16, 0x411111f0 },
9081                         { 0x18, 0x01a19020 }, /* mic */
9082                         { 0x19, 0x02a19021 },
9083                         { 0x1a, 0x0181302f },
9084                         { 0x1b, 0x0221401f },
9085                         { 0x1c, 0x411111f0 },
9086                         { 0x1d, 0x4044c601 },
9087                         { 0x1e, 0x411111f0 },
9088                         { }
9089                 },
9090                 .chain_id = ALC269_FIXUP_DMIC,
9091         },
9092         [ALC269_FIXUP_LEMOTE_A1802] = {
9093                 .type = HDA_FIXUP_PINS,
9094                 .v.pins = (const struct hda_pintbl[]) {
9095                         { 0x12, 0x40000000 },
9096                         { 0x14, 0x90170110 }, /* speaker */
9097                         { 0x17, 0x411111f0 },
9098                         { 0x18, 0x03a19040 }, /* mic1 */
9099                         { 0x19, 0x90a70130 }, /* mic2 */
9100                         { 0x1a, 0x411111f0 },
9101                         { 0x1b, 0x411111f0 },
9102                         { 0x1d, 0x40489d2d },
9103                         { 0x1e, 0x411111f0 },
9104                         { 0x20, 0x0003ffff },
9105                         { 0x21, 0x03214020 },
9106                         { }
9107                 },
9108                 .chain_id = ALC269_FIXUP_DMIC,
9109         },
9110         [ALC269_FIXUP_LEMOTE_A190X] = {
9111                 .type = HDA_FIXUP_PINS,
9112                 .v.pins = (const struct hda_pintbl[]) {
9113                         { 0x14, 0x99130110 }, /* speaker */
9114                         { 0x15, 0x0121401f }, /* HP out */
9115                         { 0x18, 0x01a19c20 }, /* rear  mic */
9116                         { 0x19, 0x99a3092f }, /* front mic */
9117                         { 0x1b, 0x0201401f }, /* front lineout */
9118                         { }
9119                 },
9120                 .chain_id = ALC269_FIXUP_DMIC,
9121         },
9122         [ALC256_FIXUP_INTEL_NUC8_RUGGED] = {
9123                 .type = HDA_FIXUP_PINS,
9124                 .v.pins = (const struct hda_pintbl[]) {
9125                         { 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9126                         { }
9127                 },
9128                 .chained = true,
9129                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9130         },
9131         [ALC256_FIXUP_INTEL_NUC10] = {
9132                 .type = HDA_FIXUP_PINS,
9133                 .v.pins = (const struct hda_pintbl[]) {
9134                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9135                         { }
9136                 },
9137                 .chained = true,
9138                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9139         },
9140         [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = {
9141                 .type = HDA_FIXUP_VERBS,
9142                 .v.verbs = (const struct hda_verb[]) {
9143                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9144                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9145                         { }
9146                 },
9147                 .chained = true,
9148                 .chain_id = ALC289_FIXUP_ASUS_GA502
9149         },
9150         [ALC274_FIXUP_HP_MIC] = {
9151                 .type = HDA_FIXUP_VERBS,
9152                 .v.verbs = (const struct hda_verb[]) {
9153                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9154                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9155                         { }
9156                 },
9157         },
9158         [ALC274_FIXUP_HP_HEADSET_MIC] = {
9159                 .type = HDA_FIXUP_FUNC,
9160                 .v.func = alc274_fixup_hp_headset_mic,
9161                 .chained = true,
9162                 .chain_id = ALC274_FIXUP_HP_MIC
9163         },
9164         [ALC274_FIXUP_HP_ENVY_GPIO] = {
9165                 .type = HDA_FIXUP_FUNC,
9166                 .v.func = alc274_fixup_hp_envy_gpio,
9167         },
9168         [ALC256_FIXUP_ASUS_HPE] = {
9169                 .type = HDA_FIXUP_VERBS,
9170                 .v.verbs = (const struct hda_verb[]) {
9171                         /* Set EAPD high */
9172                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9173                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7778 },
9174                         { }
9175                 },
9176                 .chained = true,
9177                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9178         },
9179         [ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = {
9180                 .type = HDA_FIXUP_FUNC,
9181                 .v.func = alc_fixup_headset_jack,
9182                 .chained = true,
9183                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
9184         },
9185         [ALC287_FIXUP_HP_GPIO_LED] = {
9186                 .type = HDA_FIXUP_FUNC,
9187                 .v.func = alc287_fixup_hp_gpio_led,
9188         },
9189         [ALC256_FIXUP_HP_HEADSET_MIC] = {
9190                 .type = HDA_FIXUP_FUNC,
9191                 .v.func = alc274_fixup_hp_headset_mic,
9192         },
9193         [ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = {
9194                 .type = HDA_FIXUP_FUNC,
9195                 .v.func = alc_fixup_no_int_mic,
9196                 .chained = true,
9197                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
9198         },
9199         [ALC282_FIXUP_ACER_DISABLE_LINEOUT] = {
9200                 .type = HDA_FIXUP_PINS,
9201                 .v.pins = (const struct hda_pintbl[]) {
9202                         { 0x1b, 0x411111f0 },
9203                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9204                         { },
9205                 },
9206                 .chained = true,
9207                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9208         },
9209         [ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = {
9210                 .type = HDA_FIXUP_FUNC,
9211                 .v.func = alc269_fixup_limit_int_mic_boost,
9212                 .chained = true,
9213                 .chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
9214         },
9215         [ALC256_FIXUP_ACER_HEADSET_MIC] = {
9216                 .type = HDA_FIXUP_PINS,
9217                 .v.pins = (const struct hda_pintbl[]) {
9218                         { 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */
9219                         { 0x1a, 0x90a1092f }, /* use as internal mic */
9220                         { }
9221                 },
9222                 .chained = true,
9223                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9224         },
9225         [ALC285_FIXUP_IDEAPAD_S740_COEF] = {
9226                 .type = HDA_FIXUP_FUNC,
9227                 .v.func = alc285_fixup_ideapad_s740_coef,
9228                 .chained = true,
9229                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9230         },
9231         [ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9232                 .type = HDA_FIXUP_FUNC,
9233                 .v.func = alc269_fixup_limit_int_mic_boost,
9234                 .chained = true,
9235                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9236         },
9237         [ALC295_FIXUP_ASUS_DACS] = {
9238                 .type = HDA_FIXUP_FUNC,
9239                 .v.func = alc295_fixup_asus_dacs,
9240         },
9241         [ALC295_FIXUP_HP_OMEN] = {
9242                 .type = HDA_FIXUP_PINS,
9243                 .v.pins = (const struct hda_pintbl[]) {
9244                         { 0x12, 0xb7a60130 },
9245                         { 0x13, 0x40000000 },
9246                         { 0x14, 0x411111f0 },
9247                         { 0x16, 0x411111f0 },
9248                         { 0x17, 0x90170110 },
9249                         { 0x18, 0x411111f0 },
9250                         { 0x19, 0x02a11030 },
9251                         { 0x1a, 0x411111f0 },
9252                         { 0x1b, 0x04a19030 },
9253                         { 0x1d, 0x40600001 },
9254                         { 0x1e, 0x411111f0 },
9255                         { 0x21, 0x03211020 },
9256                         {}
9257                 },
9258                 .chained = true,
9259                 .chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED,
9260         },
9261         [ALC285_FIXUP_HP_SPECTRE_X360] = {
9262                 .type = HDA_FIXUP_FUNC,
9263                 .v.func = alc285_fixup_hp_spectre_x360,
9264         },
9265         [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
9266                 .type = HDA_FIXUP_FUNC,
9267                 .v.func = alc285_fixup_hp_spectre_x360_eb1
9268         },
9269         [ALC285_FIXUP_HP_ENVY_X360] = {
9270                 .type = HDA_FIXUP_FUNC,
9271                 .v.func = alc285_fixup_hp_envy_x360,
9272                 .chained = true,
9273                 .chain_id = ALC285_FIXUP_HP_GPIO_AMP_INIT,
9274         },
9275         [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
9276                 .type = HDA_FIXUP_FUNC,
9277                 .v.func = alc285_fixup_ideapad_s740_coef,
9278                 .chained = true,
9279                 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9280         },
9281         [ALC623_FIXUP_LENOVO_THINKSTATION_P340] = {
9282                 .type = HDA_FIXUP_FUNC,
9283                 .v.func = alc_fixup_no_shutup,
9284                 .chained = true,
9285                 .chain_id = ALC283_FIXUP_HEADSET_MIC,
9286         },
9287         [ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = {
9288                 .type = HDA_FIXUP_PINS,
9289                 .v.pins = (const struct hda_pintbl[]) {
9290                         { 0x21, 0x03211030 }, /* Change the Headphone location to Left */
9291                         { }
9292                 },
9293                 .chained = true,
9294                 .chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC
9295         },
9296         [ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9297                 .type = HDA_FIXUP_FUNC,
9298                 .v.func = alc269_fixup_limit_int_mic_boost,
9299                 .chained = true,
9300                 .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
9301         },
9302         [ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = {
9303                 .type = HDA_FIXUP_FUNC,
9304                 .v.func = alc285_fixup_ideapad_s740_coef,
9305                 .chained = true,
9306                 .chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
9307         },
9308         [ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = {
9309                 .type = HDA_FIXUP_FUNC,
9310                 .v.func = alc287_fixup_legion_15imhg05_speakers,
9311                 .chained = true,
9312                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9313         },
9314         [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
9315                 .type = HDA_FIXUP_VERBS,
9316                 //.v.verbs = legion_15imhg05_coefs,
9317                 .v.verbs = (const struct hda_verb[]) {
9318                          // set left speaker Legion 7i.
9319                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9320                          { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9321
9322                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9323                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9324                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9325                          { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9326                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9327
9328                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9329                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9330                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9331                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9332                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9333
9334                          // set right speaker Legion 7i.
9335                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9336                          { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9337
9338                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9339                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9340                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9341                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9342                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9343
9344                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9345                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9346                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9347                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9348                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9349                          {}
9350                 },
9351                 .chained = true,
9352                 .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
9353         },
9354         [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
9355                 .type = HDA_FIXUP_FUNC,
9356                 .v.func = alc287_fixup_legion_15imhg05_speakers,
9357                 .chained = true,
9358                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9359         },
9360         [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
9361                 .type = HDA_FIXUP_VERBS,
9362                 .v.verbs = (const struct hda_verb[]) {
9363                          // set left speaker Yoga 7i.
9364                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9365                          { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9366
9367                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9368                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9369                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9370                          { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9371                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9372
9373                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9374                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9375                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9376                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9377                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9378
9379                          // set right speaker Yoga 7i.
9380                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9381                          { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9382
9383                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9384                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9385                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9386                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9387                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9388
9389                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9390                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9391                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9392                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9393                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9394                          {}
9395                 },
9396                 .chained = true,
9397                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9398         },
9399         [ALC298_FIXUP_LENOVO_C940_DUET7] = {
9400                 .type = HDA_FIXUP_FUNC,
9401                 .v.func = alc298_fixup_lenovo_c940_duet7,
9402         },
9403         [ALC287_FIXUP_LENOVO_14IRP8_DUETITL] = {
9404                 .type = HDA_FIXUP_FUNC,
9405                 .v.func = alc287_fixup_lenovo_14irp8_duetitl,
9406         },
9407         [ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
9408                 .type = HDA_FIXUP_VERBS,
9409                 .v.verbs = (const struct hda_verb[]) {
9410                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9411                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9412                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9413                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9414                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9415                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9416                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9417                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9418                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9419                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9420                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9421                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9422                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9423                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9424                         {}
9425                 },
9426                 .chained = true,
9427                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9428         },
9429         [ALC256_FIXUP_SET_COEF_DEFAULTS] = {
9430                 .type = HDA_FIXUP_FUNC,
9431                 .v.func = alc256_fixup_set_coef_defaults,
9432         },
9433         [ALC245_FIXUP_HP_GPIO_LED] = {
9434                 .type = HDA_FIXUP_FUNC,
9435                 .v.func = alc245_fixup_hp_gpio_led,
9436         },
9437         [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
9438                 .type = HDA_FIXUP_PINS,
9439                 .v.pins = (const struct hda_pintbl[]) {
9440                         { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
9441                         { }
9442                 },
9443                 .chained = true,
9444                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
9445         },
9446         [ALC233_FIXUP_NO_AUDIO_JACK] = {
9447                 .type = HDA_FIXUP_FUNC,
9448                 .v.func = alc233_fixup_no_audio_jack,
9449         },
9450         [ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = {
9451                 .type = HDA_FIXUP_FUNC,
9452                 .v.func = alc256_fixup_mic_no_presence_and_resume,
9453                 .chained = true,
9454                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9455         },
9456         [ALC287_FIXUP_LEGION_16ACHG6] = {
9457                 .type = HDA_FIXUP_FUNC,
9458                 .v.func = alc287_fixup_legion_16achg6_speakers,
9459         },
9460         [ALC287_FIXUP_CS35L41_I2C_2] = {
9461                 .type = HDA_FIXUP_FUNC,
9462                 .v.func = cs35l41_fixup_i2c_two,
9463         },
9464         [ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = {
9465                 .type = HDA_FIXUP_FUNC,
9466                 .v.func = cs35l41_fixup_i2c_two,
9467                 .chained = true,
9468                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9469         },
9470         [ALC287_FIXUP_CS35L41_I2C_4] = {
9471                 .type = HDA_FIXUP_FUNC,
9472                 .v.func = cs35l41_fixup_i2c_four,
9473         },
9474         [ALC245_FIXUP_CS35L41_SPI_2] = {
9475                 .type = HDA_FIXUP_FUNC,
9476                 .v.func = cs35l41_fixup_spi_two,
9477         },
9478         [ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = {
9479                 .type = HDA_FIXUP_FUNC,
9480                 .v.func = cs35l41_fixup_spi_two,
9481                 .chained = true,
9482                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9483         },
9484         [ALC245_FIXUP_CS35L41_SPI_4] = {
9485                 .type = HDA_FIXUP_FUNC,
9486                 .v.func = cs35l41_fixup_spi_four,
9487         },
9488         [ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = {
9489                 .type = HDA_FIXUP_FUNC,
9490                 .v.func = cs35l41_fixup_spi_four,
9491                 .chained = true,
9492                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9493         },
9494         [ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = {
9495                 .type = HDA_FIXUP_VERBS,
9496                 .v.verbs = (const struct hda_verb[]) {
9497                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 },
9498                          { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 },
9499                          { }
9500                 },
9501                 .chained = true,
9502                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9503         },
9504         [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = {
9505                 .type = HDA_FIXUP_FUNC,
9506                 .v.func = alc_fixup_dell4_mic_no_presence_quiet,
9507                 .chained = true,
9508                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9509         },
9510         [ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = {
9511                 .type = HDA_FIXUP_PINS,
9512                 .v.pins = (const struct hda_pintbl[]) {
9513                         { 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */
9514                         { }
9515                 },
9516                 .chained = true,
9517                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9518         },
9519         [ALC287_FIXUP_LEGION_16ITHG6] = {
9520                 .type = HDA_FIXUP_FUNC,
9521                 .v.func = alc287_fixup_legion_16ithg6_speakers,
9522         },
9523         [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = {
9524                 .type = HDA_FIXUP_VERBS,
9525                 .v.verbs = (const struct hda_verb[]) {
9526                         // enable left speaker
9527                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9528                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9529
9530                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9531                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9532                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9533                         { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9534                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9535
9536                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9537                         { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9538                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9539                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9540                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9541
9542                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9543                         { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9544                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9545                         { 0x20, AC_VERB_SET_PROC_COEF, 0x40 },
9546                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9547
9548                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9549                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9550                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9551                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9552                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9553
9554                         // enable right speaker
9555                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9556                         { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9557
9558                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9559                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9560                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9561                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9562                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9563
9564                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9565                         { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9566                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9567                         { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9568                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9569
9570                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9571                         { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9572                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9573                         { 0x20, AC_VERB_SET_PROC_COEF, 0x44 },
9574                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9575
9576                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9577                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9578                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9579                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9580                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9581
9582                         { },
9583                 },
9584         },
9585         [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = {
9586                 .type = HDA_FIXUP_FUNC,
9587                 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
9588                 .chained = true,
9589                 .chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
9590         },
9591         [ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN] = {
9592                 .type = HDA_FIXUP_FUNC,
9593                 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
9594                 .chained = true,
9595                 .chain_id = ALC287_FIXUP_CS35L41_I2C_2,
9596         },
9597         [ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = {
9598                 .type = HDA_FIXUP_FUNC,
9599                 .v.func = alc295_fixup_dell_inspiron_top_speakers,
9600                 .chained = true,
9601                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9602         },
9603         [ALC236_FIXUP_DELL_DUAL_CODECS] = {
9604                 .type = HDA_FIXUP_PINS,
9605                 .v.func = alc1220_fixup_gb_dual_codecs,
9606                 .chained = true,
9607                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9608         },
9609         [ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = {
9610                 .type = HDA_FIXUP_FUNC,
9611                 .v.func = cs35l41_fixup_i2c_two,
9612                 .chained = true,
9613                 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
9614         },
9615         [ALC287_FIXUP_TAS2781_I2C] = {
9616                 .type = HDA_FIXUP_FUNC,
9617                 .v.func = tas2781_fixup_i2c,
9618                 .chained = true,
9619                 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9620         },
9621         [ALC287_FIXUP_YOGA7_14ARB7_I2C] = {
9622                 .type = HDA_FIXUP_FUNC,
9623                 .v.func = yoga7_14arb7_fixup_i2c,
9624                 .chained = true,
9625                 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9626         },
9627         [ALC245_FIXUP_HP_MUTE_LED_COEFBIT] = {
9628                 .type = HDA_FIXUP_FUNC,
9629                 .v.func = alc245_fixup_hp_mute_led_coefbit,
9630         },
9631         [ALC245_FIXUP_HP_X360_MUTE_LEDS] = {
9632                 .type = HDA_FIXUP_FUNC,
9633                 .v.func = alc245_fixup_hp_mute_led_coefbit,
9634                 .chained = true,
9635                 .chain_id = ALC245_FIXUP_HP_GPIO_LED
9636         },
9637         [ALC287_FIXUP_THINKPAD_I2S_SPK] = {
9638                 .type = HDA_FIXUP_FUNC,
9639                 .v.func = alc287_fixup_bind_dacs,
9640                 .chained = true,
9641                 .chain_id = ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
9642         },
9643         [ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = {
9644                 .type = HDA_FIXUP_FUNC,
9645                 .v.func = alc287_fixup_bind_dacs,
9646                 .chained = true,
9647                 .chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
9648         },
9649         [ALC2XX_FIXUP_HEADSET_MIC] = {
9650                 .type = HDA_FIXUP_FUNC,
9651                 .v.func = alc_fixup_headset_mic,
9652         },
9653         [ALC289_FIXUP_DELL_CS35L41_SPI_2] = {
9654                 .type = HDA_FIXUP_FUNC,
9655                 .v.func = cs35l41_fixup_spi_two,
9656                 .chained = true,
9657                 .chain_id = ALC289_FIXUP_DUAL_SPK
9658         },
9659         [ALC294_FIXUP_CS35L41_I2C_2] = {
9660                 .type = HDA_FIXUP_FUNC,
9661                 .v.func = cs35l41_fixup_i2c_two,
9662         },
9663         [ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED] = {
9664                 .type = HDA_FIXUP_FUNC,
9665                 .v.func = cs35l56_fixup_spi_four,
9666                 .chained = true,
9667                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9668         },
9669         [ALC256_FIXUP_ACER_SFG16_MICMUTE_LED] = {
9670                 .type = HDA_FIXUP_FUNC,
9671                 .v.func = alc256_fixup_acer_sfg16_micmute_led,
9672         },
9673         [ALC256_FIXUP_HEADPHONE_AMP_VOL] = {
9674                 .type = HDA_FIXUP_FUNC,
9675                 .v.func = alc256_decrease_headphone_amp_val,
9676         },
9677         [ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX] = {
9678                 .type = HDA_FIXUP_FUNC,
9679                 .v.func = alc245_fixup_hp_spectre_x360_eu0xxx,
9680         },
9681         [ALC285_FIXUP_CS35L56_SPI_2] = {
9682                 .type = HDA_FIXUP_FUNC,
9683                 .v.func = cs35l56_fixup_spi_two,
9684         },
9685         [ALC285_FIXUP_CS35L56_I2C_2] = {
9686                 .type = HDA_FIXUP_FUNC,
9687                 .v.func = cs35l56_fixup_i2c_two,
9688         },
9689         [ALC285_FIXUP_CS35L56_I2C_4] = {
9690                 .type = HDA_FIXUP_FUNC,
9691                 .v.func = cs35l56_fixup_i2c_four,
9692         },
9693         [ALC285_FIXUP_ASUS_GA403U] = {
9694                 .type = HDA_FIXUP_FUNC,
9695                 .v.func = alc285_fixup_asus_ga403u,
9696         },
9697         [ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC] = {
9698                 .type = HDA_FIXUP_PINS,
9699                 .v.pins = (const struct hda_pintbl[]) {
9700                         { 0x19, 0x03a11050 },
9701                         { 0x1b, 0x03a11c30 },
9702                         { }
9703                 },
9704                 .chained = true,
9705                 .chain_id = ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1
9706         },
9707         [ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1] = {
9708                 .type = HDA_FIXUP_FUNC,
9709                 .v.func = alc285_fixup_speaker2_to_dac1,
9710                 .chained = true,
9711                 .chain_id = ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC,
9712         },
9713         [ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC] = {
9714                 .type = HDA_FIXUP_PINS,
9715                 .v.pins = (const struct hda_pintbl[]) {
9716                         { 0x19, 0x03a11050 },
9717                         { 0x1b, 0x03a11c30 },
9718                         { }
9719                 },
9720                 .chained = true,
9721                 .chain_id = ALC285_FIXUP_CS35L56_SPI_2
9722         },
9723         [ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1] = {
9724                 .type = HDA_FIXUP_FUNC,
9725                 .v.func = alc285_fixup_speaker2_to_dac1,
9726                 .chained = true,
9727                 .chain_id = ALC285_FIXUP_ASUS_GA403U,
9728         },
9729 };
9730
9731 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
9732         SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
9733         SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
9734         SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
9735         SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
9736         SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9737         SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
9738         SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
9739         SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9740         SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9741         SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
9742         SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9743         SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF),
9744         SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK),
9745         SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
9746         SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC),
9747         SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
9748         SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
9749         SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9750         SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9751         SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK),
9752         SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK),
9753         SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
9754         SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
9755         SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE),
9756         SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC),
9757         SND_PCI_QUIRK(0x1025, 0x126a, "Acer Swift SF114-32", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9758         SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9759         SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9760         SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9761         SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
9762         SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9763         SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9764         SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9765         SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
9766         SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
9767         SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9768         SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9769         SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9770         SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
9771         SND_PCI_QUIRK(0x1025, 0x1534, "Acer Predator PH315-54", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9772         SND_PCI_QUIRK(0x1025, 0x169a, "Acer Swift SFG16", ALC256_FIXUP_ACER_SFG16_MICMUTE_LED),
9773         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
9774         SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
9775         SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
9776         SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
9777         SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
9778         SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
9779         SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
9780         SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
9781         SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9782         SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9783         SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9784         SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9785         SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9786         SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
9787         SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
9788         SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
9789         SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9790         SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9791         SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
9792         SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9793         SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
9794         SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9795         SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9796         SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9797         SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9798         SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9799         SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9800         SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9801         SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9802         SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9803         SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
9804         SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
9805         SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
9806         SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
9807         SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9808         SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
9809         SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
9810         SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9811         SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9812         SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9813         SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9814         SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
9815         SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
9816         SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
9817         SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9818         SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9819         SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9820         SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9821         SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9822         SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9823         SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9824         SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET),
9825         SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
9826         SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
9827         SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
9828         SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9829         SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9830         SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
9831         SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK),
9832         SND_PCI_QUIRK(0x1028, 0x0b27, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
9833         SND_PCI_QUIRK(0x1028, 0x0b28, "Dell", ALC245_FIXUP_CS35L41_SPI_2),
9834         SND_PCI_QUIRK(0x1028, 0x0b37, "Dell Inspiron 16 Plus 7620 2-in-1", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9835         SND_PCI_QUIRK(0x1028, 0x0b71, "Dell Inspiron 16 Plus 7620", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9836         SND_PCI_QUIRK(0x1028, 0x0beb, "Dell XPS 15 9530 (2023)", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9837         SND_PCI_QUIRK(0x1028, 0x0c03, "Dell Precision 5340", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9838         SND_PCI_QUIRK(0x1028, 0x0c0b, "Dell Oasis 14 RPL-P", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9839         SND_PCI_QUIRK(0x1028, 0x0c0d, "Dell Oasis", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9840         SND_PCI_QUIRK(0x1028, 0x0c0e, "Dell Oasis 16", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9841         SND_PCI_QUIRK(0x1028, 0x0c19, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9842         SND_PCI_QUIRK(0x1028, 0x0c1a, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9843         SND_PCI_QUIRK(0x1028, 0x0c1b, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9844         SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9845         SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9846         SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9847         SND_PCI_QUIRK(0x1028, 0x0c28, "Dell Inspiron 16 Plus 7630", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9848         SND_PCI_QUIRK(0x1028, 0x0c4d, "Dell", ALC287_FIXUP_CS35L41_I2C_4),
9849         SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9850         SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9851         SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9852         SND_PCI_QUIRK(0x1028, 0x0cc0, "Dell Oasis 13", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9853         SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9854         SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9855         SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9856         SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9857         SND_PCI_QUIRK(0x1028, 0x0cc5, "Dell Oasis 14", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9858         SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9859         SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9860         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
9861         SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
9862         SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
9863         SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9864         SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9865         SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9866         SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9867         SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
9868         SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9869         SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9870         SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9871         SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9872         SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9873         SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9874         SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9875         SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9876         SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9877         SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9878         SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9879         SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9880         SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9881         SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
9882         SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
9883         SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9884         SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9885         SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9886         SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9887         SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9888         SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9889         SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9890         SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9891         SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
9892         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9893         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9894         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9895         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9896         SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9897         SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9898         SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9899         SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9900         SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9901         SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9902         SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9903         SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9904         SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9905         SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9906         SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9907         SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9908         SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9909         SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9910         SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
9911         SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9912         SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9913         SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9914         SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9915         SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9916         SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9917         SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
9918         SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9919         SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9920         SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9921         SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9922         SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC295_FIXUP_HP_X360),
9923         SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
9924         SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
9925         SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9926         SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9927         SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9928         SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9929         SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9930         SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9931         SND_PCI_QUIRK(0x103c, 0x84ae, "HP 15-db0403ng", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9932         SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN),
9933         SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9934         SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
9935         SND_PCI_QUIRK(0x103c, 0x8537, "HP ProBook 440 G6", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9936         SND_PCI_QUIRK(0x103c, 0x85de, "HP Envy x360 13-ar0xxx", ALC285_FIXUP_HP_ENVY_X360),
9937         SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9938         SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9939         SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9940         SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
9941         SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9942         SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9943         SND_PCI_QUIRK(0x103c, 0x86f9, "HP Spectre x360 13-aw0xxx", ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED),
9944         SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9945         SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9946         SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
9947         SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
9948         SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
9949         SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9950         SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9951         SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9952         SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
9953         SND_PCI_QUIRK(0x103c, 0x876e, "HP ENVY x360 Convertible 13-ay0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
9954         SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
9955         SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9956         SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation",
9957                       ALC285_FIXUP_HP_GPIO_AMP_INIT),
9958         SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
9959                       ALC285_FIXUP_HP_GPIO_AMP_INIT),
9960         SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9961         SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9962         SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9963         SND_PCI_QUIRK(0x103c, 0x87b7, "HP Laptop 14-fq0xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9964         SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
9965         SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9966         SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9967         SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9968         SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9969         SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED),
9970         SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
9971         SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9972         SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9973         SND_PCI_QUIRK(0x103c, 0x87fe, "HP Laptop 15s-fq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9974         SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9975         SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9976         SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9977         SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9978         SND_PCI_QUIRK(0x103c, 0x881d, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9979         SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9980         SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9981         SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9982         SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9983         SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9984         SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9985         SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9986         SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9987         SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9988         SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9989         SND_PCI_QUIRK(0x103c, 0x888a, "HP ENVY x360 Convertible 15-eu0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
9990         SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
9991         SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED),
9992         SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
9993         SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9994         SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
9995         SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED),
9996         SND_PCI_QUIRK(0x103c, 0x890e, "HP 255 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9997         SND_PCI_QUIRK(0x103c, 0x8919, "HP Pavilion Aero Laptop 13-be0xxx", ALC287_FIXUP_HP_GPIO_LED),
9998         SND_PCI_QUIRK(0x103c, 0x896d, "HP ZBook Firefly 16 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9999         SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10000         SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10001         SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10002         SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10003         SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10004         SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10005         SND_PCI_QUIRK(0x103c, 0x897d, "HP mt440 Mobile Thin Client U74", ALC236_FIXUP_HP_GPIO_LED),
10006         SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4),
10007         SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
10008         SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
10009         SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10010         SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2),
10011         SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10012         SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2),
10013         SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED),
10014         SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED),
10015         SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
10016         SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED),
10017         SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED),
10018         SND_PCI_QUIRK(0x103c, 0x89c0, "HP ZBook Power 15.6 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10019         SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10020         SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10021         SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10022         SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10023         SND_PCI_QUIRK(0x103c, 0x89e7, "HP Elite x2 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10024         SND_PCI_QUIRK(0x103c, 0x8a0f, "HP Pavilion 14-ec1xxx", ALC287_FIXUP_HP_GPIO_LED),
10025         SND_PCI_QUIRK(0x103c, 0x8a20, "HP Laptop 15s-fq5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10026         SND_PCI_QUIRK(0x103c, 0x8a25, "HP Victus 16-d1xxx (MB 8A25)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT),
10027         SND_PCI_QUIRK(0x103c, 0x8a28, "HP Envy 13", ALC287_FIXUP_CS35L41_I2C_2),
10028         SND_PCI_QUIRK(0x103c, 0x8a29, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10029         SND_PCI_QUIRK(0x103c, 0x8a2a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10030         SND_PCI_QUIRK(0x103c, 0x8a2b, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10031         SND_PCI_QUIRK(0x103c, 0x8a2c, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10032         SND_PCI_QUIRK(0x103c, 0x8a2d, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10033         SND_PCI_QUIRK(0x103c, 0x8a2e, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10034         SND_PCI_QUIRK(0x103c, 0x8a2e, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10035         SND_PCI_QUIRK(0x103c, 0x8a30, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10036         SND_PCI_QUIRK(0x103c, 0x8a31, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10037         SND_PCI_QUIRK(0x103c, 0x8a6e, "HP EDNA 360", ALC287_FIXUP_CS35L41_I2C_4),
10038         SND_PCI_QUIRK(0x103c, 0x8a74, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
10039         SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
10040         SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
10041         SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
10042         SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
10043         SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED),
10044         SND_PCI_QUIRK(0x103c, 0x8ab9, "HP EliteBook 840 G8 (MB 8AB8)", ALC285_FIXUP_HP_GPIO_LED),
10045         SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10046         SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10047         SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10048         SND_PCI_QUIRK(0x103c, 0x8ad8, "HP 800 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10049         SND_PCI_QUIRK(0x103c, 0x8b0f, "HP Elite mt645 G7 Mobile Thin Client U81", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10050         SND_PCI_QUIRK(0x103c, 0x8b2f, "HP 255 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
10051         SND_PCI_QUIRK(0x103c, 0x8b3a, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10052         SND_PCI_QUIRK(0x103c, 0x8b3f, "HP mt440 Mobile Thin Client U91", ALC236_FIXUP_HP_GPIO_LED),
10053         SND_PCI_QUIRK(0x103c, 0x8b42, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10054         SND_PCI_QUIRK(0x103c, 0x8b43, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10055         SND_PCI_QUIRK(0x103c, 0x8b44, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10056         SND_PCI_QUIRK(0x103c, 0x8b45, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10057         SND_PCI_QUIRK(0x103c, 0x8b46, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10058         SND_PCI_QUIRK(0x103c, 0x8b47, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10059         SND_PCI_QUIRK(0x103c, 0x8b59, "HP Elite mt645 G7 Mobile Thin Client U89", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10060         SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10061         SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10062         SND_PCI_QUIRK(0x103c, 0x8b63, "HP Elite Dragonfly 13.5 inch G4", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10063         SND_PCI_QUIRK(0x103c, 0x8b65, "HP ProBook 455 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10064         SND_PCI_QUIRK(0x103c, 0x8b66, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10065         SND_PCI_QUIRK(0x103c, 0x8b70, "HP EliteBook 835 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10066         SND_PCI_QUIRK(0x103c, 0x8b72, "HP EliteBook 845 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10067         SND_PCI_QUIRK(0x103c, 0x8b74, "HP EliteBook 845W G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10068         SND_PCI_QUIRK(0x103c, 0x8b77, "HP ElieBook 865 G10", ALC287_FIXUP_CS35L41_I2C_2),
10069         SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED),
10070         SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED),
10071         SND_PCI_QUIRK(0x103c, 0x8b87, "HP", ALC236_FIXUP_HP_GPIO_LED),
10072         SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED),
10073         SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED),
10074         SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED),
10075         SND_PCI_QUIRK(0x103c, 0x8b8f, "HP", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10076         SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10077         SND_PCI_QUIRK(0x103c, 0x8b96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10078         SND_PCI_QUIRK(0x103c, 0x8b97, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10079         SND_PCI_QUIRK(0x103c, 0x8bdd, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10080         SND_PCI_QUIRK(0x103c, 0x8bde, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10081         SND_PCI_QUIRK(0x103c, 0x8bdf, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10082         SND_PCI_QUIRK(0x103c, 0x8be0, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10083         SND_PCI_QUIRK(0x103c, 0x8be1, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10084         SND_PCI_QUIRK(0x103c, 0x8be2, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10085         SND_PCI_QUIRK(0x103c, 0x8be3, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10086         SND_PCI_QUIRK(0x103c, 0x8be5, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10087         SND_PCI_QUIRK(0x103c, 0x8be6, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10088         SND_PCI_QUIRK(0x103c, 0x8be7, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10089         SND_PCI_QUIRK(0x103c, 0x8be8, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10090         SND_PCI_QUIRK(0x103c, 0x8be9, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10091         SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED),
10092         SND_PCI_QUIRK(0x103c, 0x8c15, "HP Spectre x360 2-in-1 Laptop 14-eu0xxx", ALC245_FIXUP_HP_SPECTRE_X360_EU0XXX),
10093         SND_PCI_QUIRK(0x103c, 0x8c16, "HP Spectre 16", ALC287_FIXUP_CS35L41_I2C_2),
10094         SND_PCI_QUIRK(0x103c, 0x8c17, "HP Spectre 16", ALC287_FIXUP_CS35L41_I2C_2),
10095         SND_PCI_QUIRK(0x103c, 0x8c46, "HP EliteBook 830 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10096         SND_PCI_QUIRK(0x103c, 0x8c47, "HP EliteBook 840 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10097         SND_PCI_QUIRK(0x103c, 0x8c48, "HP EliteBook 860 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10098         SND_PCI_QUIRK(0x103c, 0x8c49, "HP Elite x360 830 2-in-1 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10099         SND_PCI_QUIRK(0x103c, 0x8c4f, "HP Envy 15", ALC287_FIXUP_CS35L41_I2C_2),
10100         SND_PCI_QUIRK(0x103c, 0x8c50, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10101         SND_PCI_QUIRK(0x103c, 0x8c51, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10102         SND_PCI_QUIRK(0x103c, 0x8c52, "HP EliteBook 1040 G11", ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED),
10103         SND_PCI_QUIRK(0x103c, 0x8c53, "HP Elite x360 1040 2-in-1 G11", ALC245_FIXUP_CS35L56_SPI_4_HP_GPIO_LED),
10104         SND_PCI_QUIRK(0x103c, 0x8c66, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10105         SND_PCI_QUIRK(0x103c, 0x8c67, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10106         SND_PCI_QUIRK(0x103c, 0x8c68, "HP Envy 17", ALC287_FIXUP_CS35L41_I2C_2),
10107         SND_PCI_QUIRK(0x103c, 0x8c6a, "HP Envy 16", ALC287_FIXUP_CS35L41_I2C_2),
10108         SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10109         SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10110         SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10111         SND_PCI_QUIRK(0x103c, 0x8c8a, "HP EliteBook 630", ALC236_FIXUP_HP_GPIO_LED),
10112         SND_PCI_QUIRK(0x103c, 0x8c8c, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
10113         SND_PCI_QUIRK(0x103c, 0x8c90, "HP EliteBook 640", ALC236_FIXUP_HP_GPIO_LED),
10114         SND_PCI_QUIRK(0x103c, 0x8c91, "HP EliteBook 660", ALC236_FIXUP_HP_GPIO_LED),
10115         SND_PCI_QUIRK(0x103c, 0x8c96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10116         SND_PCI_QUIRK(0x103c, 0x8c97, "HP ZBook", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
10117         SND_PCI_QUIRK(0x103c, 0x8ca1, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
10118         SND_PCI_QUIRK(0x103c, 0x8ca2, "HP ZBook Power", ALC236_FIXUP_HP_GPIO_LED),
10119         SND_PCI_QUIRK(0x103c, 0x8ca4, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10120         SND_PCI_QUIRK(0x103c, 0x8ca7, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
10121         SND_PCI_QUIRK(0x103c, 0x8cdd, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
10122         SND_PCI_QUIRK(0x103c, 0x8cde, "HP Spectre", ALC287_FIXUP_CS35L41_I2C_2),
10123         SND_PCI_QUIRK(0x103c, 0x8cdf, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10124         SND_PCI_QUIRK(0x103c, 0x8ce0, "HP SnowWhite", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
10125         SND_PCI_QUIRK(0x103c, 0x8cf5, "HP ZBook Studio 16", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
10126         SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
10127         SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
10128         SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10129         SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
10130         SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
10131         SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10132         SND_PCI_QUIRK(0x1043, 0x10d3, "ASUS K6500ZC", ALC294_FIXUP_ASUS_SPK),
10133         SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10134         SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10135         SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10136         SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10137         SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
10138         SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
10139         SND_PCI_QUIRK(0x1043, 0x12a3, "Asus N7691ZM", ALC269_FIXUP_ASUS_N7601ZM),
10140         SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
10141         SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
10142         SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
10143         SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE),
10144         SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
10145         SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
10146         SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650PY/PZ/PV/PU/PYV/PZV/PIV/PVV", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
10147         SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X/GA402N", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
10148         SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604VI/VC/VE/VG/VJ/VQ/VU/VV/VY/VZ", ALC285_FIXUP_ASUS_HEADSET_MIC),
10149         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603VQ/VU/VV/VJ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10150         SND_PCI_QUIRK(0x1043, 0x1493, "ASUS GV601VV/VU/VJ/VQ/VI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10151         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G614JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10152         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS G513PI/PU/PV", ALC287_FIXUP_CS35L41_I2C_2),
10153         SND_PCI_QUIRK(0x1043, 0x1503, "ASUS G733PY/PZ/PZV/PYV", ALC287_FIXUP_CS35L41_I2C_2),
10154         SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
10155         SND_PCI_QUIRK(0x1043, 0x1533, "ASUS GV302XA/XJ/XQ/XU/XV/XI", ALC287_FIXUP_CS35L41_I2C_2),
10156         SND_PCI_QUIRK(0x1043, 0x1573, "ASUS GZ301VV/VQ/VU/VJ/VA/VC/VE/VVC/VQC/VUC/VJC/VEC/VCC", ALC285_FIXUP_ASUS_HEADSET_MIC),
10157         SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK),
10158         SND_PCI_QUIRK(0x1043, 0x1663, "ASUS GU603ZI/ZJ/ZQ/ZU/ZV", ALC285_FIXUP_ASUS_HEADSET_MIC),
10159         SND_PCI_QUIRK(0x1043, 0x1683, "ASUS UM3402YAR", ALC287_FIXUP_CS35L41_I2C_2),
10160         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS UX3402VA", ALC245_FIXUP_CS35L41_SPI_2),
10161         SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
10162         SND_PCI_QUIRK(0x1043, 0x16d3, "ASUS UX5304VA", ALC245_FIXUP_CS35L41_SPI_2),
10163         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
10164         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS UX7602VI/BZ", ALC245_FIXUP_CS35L41_SPI_2),
10165         SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS),
10166         SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
10167         SND_PCI_QUIRK(0x1043, 0x17f3, "ROG Ally NR2301L/X", ALC294_FIXUP_ASUS_ALLY),
10168         SND_PCI_QUIRK(0x1043, 0x1863, "ASUS UX6404VI/VV", ALC245_FIXUP_CS35L41_SPI_2),
10169         SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS),
10170         SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
10171         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS UM3504DA", ALC294_FIXUP_CS35L41_I2C_2),
10172         SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
10173         SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
10174         SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
10175         SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
10176         SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
10177         SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
10178         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
10179         SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
10180         SND_PCI_QUIRK(0x1043, 0x1a63, "ASUS UX3405MA", ALC245_FIXUP_CS35L41_SPI_2),
10181         SND_PCI_QUIRK(0x1043, 0x1a83, "ASUS UM5302LA", ALC294_FIXUP_CS35L41_I2C_2),
10182         SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
10183         SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
10184         SND_PCI_QUIRK(0x1043, 0x1b13, "ASUS U41SV/GA403U", ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC),
10185         SND_PCI_QUIRK(0x1043, 0x1b93, "ASUS G614JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
10186         SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
10187         SND_PCI_QUIRK(0x1043, 0x1c03, "ASUS UM3406HA", ALC287_FIXUP_CS35L41_I2C_2),
10188         SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10189         SND_PCI_QUIRK(0x1043, 0x1c33, "ASUS UX5304MA", ALC245_FIXUP_CS35L41_SPI_2),
10190         SND_PCI_QUIRK(0x1043, 0x1c43, "ASUS UX8406MA", ALC245_FIXUP_CS35L41_SPI_2),
10191         SND_PCI_QUIRK(0x1043, 0x1c62, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
10192         SND_PCI_QUIRK(0x1043, 0x1c63, "ASUS GU605M", ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1),
10193         SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS),
10194         SND_PCI_QUIRK(0x1043, 0x1c9f, "ASUS G614JU/JV/JI", ALC285_FIXUP_ASUS_HEADSET_MIC),
10195         SND_PCI_QUIRK(0x1043, 0x1caf, "ASUS G634JY/JZ/JI/JG", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10196         SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
10197         SND_PCI_QUIRK(0x1043, 0x1ccf, "ASUS G814JU/JV/JI", ALC245_FIXUP_CS35L41_SPI_2),
10198         SND_PCI_QUIRK(0x1043, 0x1cdf, "ASUS G814JY/JZ/JG", ALC245_FIXUP_CS35L41_SPI_2),
10199         SND_PCI_QUIRK(0x1043, 0x1cef, "ASUS G834JY/JZ/JI/JG", ALC285_FIXUP_ASUS_HEADSET_MIC),
10200         SND_PCI_QUIRK(0x1043, 0x1d1f, "ASUS G713PI/PU/PV/PVN", ALC287_FIXUP_CS35L41_I2C_2),
10201         SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401),
10202         SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE),
10203         SND_PCI_QUIRK(0x1043, 0x1da2, "ASUS UP6502ZA/ZD", ALC245_FIXUP_CS35L41_SPI_2),
10204         SND_PCI_QUIRK(0x1043, 0x1df3, "ASUS UM5606", ALC285_FIXUP_CS35L56_I2C_4),
10205         SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402ZA", ALC245_FIXUP_CS35L41_SPI_2),
10206         SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
10207         SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2),
10208         SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
10209         SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS),
10210         SND_PCI_QUIRK(0x1043, 0x1e63, "ASUS H7606W", ALC285_FIXUP_CS35L56_I2C_2),
10211         SND_PCI_QUIRK(0x1043, 0x1e83, "ASUS GA605W", ALC285_FIXUP_CS35L56_I2C_2),
10212         SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
10213         SND_PCI_QUIRK(0x1043, 0x1ee2, "ASUS UM6702RA/RC", ALC287_FIXUP_CS35L41_I2C_2),
10214         SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401),
10215         SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
10216         SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2),
10217         SND_PCI_QUIRK(0x1043, 0x1f1f, "ASUS H7604JI/JV/J3D", ALC245_FIXUP_CS35L41_SPI_2),
10218         SND_PCI_QUIRK(0x1043, 0x1f62, "ASUS UX7602ZM", ALC245_FIXUP_CS35L41_SPI_2),
10219         SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401),
10220         SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
10221         SND_PCI_QUIRK(0x1043, 0x3a20, "ASUS G614JZR", ALC245_FIXUP_CS35L41_SPI_2),
10222         SND_PCI_QUIRK(0x1043, 0x3a30, "ASUS G814JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
10223         SND_PCI_QUIRK(0x1043, 0x3a40, "ASUS G814JZR", ALC245_FIXUP_CS35L41_SPI_2),
10224         SND_PCI_QUIRK(0x1043, 0x3a50, "ASUS G834JYR/JZR", ALC245_FIXUP_CS35L41_SPI_2),
10225         SND_PCI_QUIRK(0x1043, 0x3a60, "ASUS G634JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
10226         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
10227         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
10228         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10229         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
10230         SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
10231         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
10232         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10233         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
10234         SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
10235         SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10236         SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10237         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
10238         SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
10239         SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10240         SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
10241         SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
10242         SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
10243         SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
10244         SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
10245         SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10246         SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10247         SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10248         SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10249         SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10250         SND_PCI_QUIRK(0x10ec, 0x12f6, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
10251         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
10252         SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
10253         SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10254         SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP),
10255         SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP),
10256         SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
10257         SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP),
10258         SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP),
10259         SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
10260         SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
10261         SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP),
10262         SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
10263         SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP),
10264         SND_PCI_QUIRK(0x144d, 0xc868, "Samsung Galaxy Book2 Pro (NP930XED)", ALC298_FIXUP_SAMSUNG_AMP),
10265         SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
10266         SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
10267         SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
10268         SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK),
10269         SND_PCI_QUIRK(0x152d, 0x1262, "Huawei NBLB-WAX9N", ALC2XX_FIXUP_HEADSET_MIC),
10270         SND_PCI_QUIRK(0x1558, 0x0353, "Clevo V35[05]SN[CDE]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10271         SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10272         SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10273         SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10274         SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10275         SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10276         SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10277         SND_PCI_QUIRK(0x1558, 0x2624, "Clevo L240TU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10278         SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10279         SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10280         SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10281         SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10282         SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10283         SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10284         SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10285         SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10286         SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10287         SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10288         SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10289         SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10290         SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10291         SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10292         SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10293         SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10294         SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10295         SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10296         SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10297         SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10298         SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10299         SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10300         SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10301         SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10302         SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10303         SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10304         SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10305         SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10306         SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10307         SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10308         SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10309         SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10310         SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10311         SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10312         SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10313         SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10314         SND_PCI_QUIRK(0x1558, 0x7724, "Clevo L140AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10315         SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10316         SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10317         SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10318         SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10319         SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10320         SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10321         SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10322         SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10323         SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10324         SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
10325         SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10326         SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10327         SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10328         SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10329         SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10330         SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME),
10331         SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10332         SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10333         SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10334         SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10335         SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10336         SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10337         SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10338         SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10339         SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10340         SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10341         SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10342         SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10343         SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10344         SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10345         SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10346         SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10347         SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10348         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
10349         SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10350         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
10351         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
10352         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
10353         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
10354         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
10355         SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
10356         SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
10357         SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
10358         SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
10359         SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
10360         SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
10361         SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
10362         SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
10363         SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
10364         SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
10365         SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
10366         SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
10367         SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10368         SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
10369         SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
10370         SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
10371         SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10372         SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10373         SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
10374         SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
10375         SND_PCI_QUIRK(0x17aa, 0x2234, "Thinkpad ICE-1", ALC287_FIXUP_TAS2781_I2C),
10376         SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
10377         SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10378         SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10379         SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
10380         SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10381         SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10382         SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10383         SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10384         SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10385         SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10386         SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10387         SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10388         SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10389         SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10390         SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10391         SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10392         SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10393         SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10394         SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10395         SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10396         SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10397         SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10398         SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10399         SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10400         SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10401         SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10402         SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10403         SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10404         SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10405         SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10406         SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10407         SND_PCI_QUIRK(0x17aa, 0x334b, "Lenovo ThinkCentre M70 Gen5", ALC283_FIXUP_HEADSET_MIC),
10408         SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10409         SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga Pro 9 14IRP8 / DuetITL 2021", ALC287_FIXUP_LENOVO_14IRP8_DUETITL),
10410         SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10411         SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
10412         SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
10413         SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10414         SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10415         SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
10416         SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10417         SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10418         SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
10419         SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6),
10420         SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10421         SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10422         SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10423         SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6),
10424         SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10425         SND_PCI_QUIRK(0x17aa, 0x386f, "Legion 7i 16IAX7", ALC287_FIXUP_CS35L41_I2C_2),
10426         SND_PCI_QUIRK(0x17aa, 0x3870, "Lenovo Yoga 7 14ARB7", ALC287_FIXUP_YOGA7_14ARB7_I2C),
10427         SND_PCI_QUIRK(0x17aa, 0x3877, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2),
10428         SND_PCI_QUIRK(0x17aa, 0x3878, "Lenovo Legion 7 Slim 16ARHA7", ALC287_FIXUP_CS35L41_I2C_2),
10429         SND_PCI_QUIRK(0x17aa, 0x387d, "Yoga S780-16 pro Quad AAC", ALC287_FIXUP_TAS2781_I2C),
10430         SND_PCI_QUIRK(0x17aa, 0x387e, "Yoga S780-16 pro Quad YC", ALC287_FIXUP_TAS2781_I2C),
10431         SND_PCI_QUIRK(0x17aa, 0x3881, "YB9 dual power mode2 YC", ALC287_FIXUP_TAS2781_I2C),
10432         SND_PCI_QUIRK(0x17aa, 0x3882, "Lenovo Yoga Pro 7 14APH8", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10433         SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10434         SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10435         SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C),
10436         SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C),
10437         SND_PCI_QUIRK(0x17aa, 0x38a9, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10438         SND_PCI_QUIRK(0x17aa, 0x38ab, "Thinkbook 16P", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10439         SND_PCI_QUIRK(0x17aa, 0x38b4, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
10440         SND_PCI_QUIRK(0x17aa, 0x38b5, "Legion Slim 7 16IRH8", ALC287_FIXUP_CS35L41_I2C_2),
10441         SND_PCI_QUIRK(0x17aa, 0x38b6, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
10442         SND_PCI_QUIRK(0x17aa, 0x38b7, "Legion Slim 7 16APH8", ALC287_FIXUP_CS35L41_I2C_2),
10443         SND_PCI_QUIRK(0x17aa, 0x38ba, "Yoga S780-14.5 Air AMD quad YC", ALC287_FIXUP_TAS2781_I2C),
10444         SND_PCI_QUIRK(0x17aa, 0x38bb, "Yoga S780-14.5 Air AMD quad AAC", ALC287_FIXUP_TAS2781_I2C),
10445         SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C),
10446         SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C),
10447         SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C),
10448         SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10449         SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10450         SND_PCI_QUIRK(0x17aa, 0x38d2, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
10451         SND_PCI_QUIRK(0x17aa, 0x38d7, "Lenovo Yoga 9 14IMH9", ALC287_FIXUP_YOGA9_14IMH9_BASS_SPK_PIN),
10452         SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10453         SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
10454         SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10455         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
10456         SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10457         SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
10458         SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
10459         SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10460         SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
10461         SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
10462         SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
10463         SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
10464         SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
10465         SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
10466         SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
10467         SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
10468         SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10469         SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10470         SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10471         SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10472         SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10473         SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10474         SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10475         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
10476         SND_PCI_QUIRK(0x17aa, 0x9e56, "Lenovo ZhaoYang CF4620Z", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10477         SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK),
10478         SND_PCI_QUIRK(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC),
10479         SND_PCI_QUIRK(0x1854, 0x0440, "LG CQ6", ALC256_FIXUP_HEADPHONE_AMP_VOL),
10480         SND_PCI_QUIRK(0x1854, 0x0441, "LG CQ6 AIO", ALC256_FIXUP_HEADPHONE_AMP_VOL),
10481         SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
10482         SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10483         SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
10484         SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI),
10485         SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101),
10486         SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
10487         SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
10488         SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
10489         SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE),
10490         SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
10491         SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
10492         SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
10493         SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10494         SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10495         SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10496         SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10497         SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10498         SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
10499         SND_PCI_QUIRK(0x1d05, 0x1387, "TongFang GMxIXxx", ALC2XX_FIXUP_HEADSET_MIC),
10500         SND_PCI_QUIRK(0x1d17, 0x3288, "Haier Boyue G42", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
10501         SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10502         SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
10503         SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
10504         SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
10505         SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10506         SND_PCI_QUIRK(0x2782, 0x0232, "CHUWI CoreBook XPro", ALC269VB_FIXUP_CHUWI_COREBOOK_XPRO),
10507         SND_PCI_QUIRK(0x2782, 0x1707, "Vaio VJFE-ADL", ALC298_FIXUP_SPK_VOLUME),
10508         SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
10509         SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
10510         SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
10511         SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK),
10512         SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10513         SND_PCI_QUIRK(0xf111, 0x0005, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10514         SND_PCI_QUIRK(0xf111, 0x0006, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10515
10516 #if 0
10517         /* Below is a quirk table taken from the old code.
10518          * Basically the device should work as is without the fixup table.
10519          * If BIOS doesn't give a proper info, enable the corresponding
10520          * fixup entry.
10521          */
10522         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
10523                       ALC269_FIXUP_AMIC),
10524         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
10525         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
10526         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
10527         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
10528         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
10529         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
10530         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
10531         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
10532         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
10533         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
10534         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
10535         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
10536         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
10537         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
10538         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
10539         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
10540         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
10541         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
10542         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
10543         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
10544         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
10545         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
10546         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
10547         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
10548         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
10549         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
10550         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
10551         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
10552         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
10553         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
10554         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
10555         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
10556         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
10557         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
10558         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
10559         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
10560         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
10561         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
10562         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
10563 #endif
10564         {}
10565 };
10566
10567 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
10568         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
10569         SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
10570         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
10571         SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
10572         SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
10573         {}
10574 };
10575
10576 static const struct hda_model_fixup alc269_fixup_models[] = {
10577         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
10578         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
10579         {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
10580         {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
10581         {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
10582         {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
10583         {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
10584         {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
10585         {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
10586         {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
10587         {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10588         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
10589         {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
10590         {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
10591         {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
10592         {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
10593         {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
10594         {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
10595         {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
10596         {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
10597         {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
10598         {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
10599         {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
10600         {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
10601         {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
10602         {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
10603         {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
10604         {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
10605         {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
10606         {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
10607         {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
10608         {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
10609         {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
10610         {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
10611         {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
10612         {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
10613         {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
10614         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
10615         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
10616         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
10617         {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
10618         {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
10619         {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
10620         {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
10621         {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
10622         {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
10623         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
10624         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
10625         {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
10626         {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
10627         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
10628         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
10629         {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
10630         {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
10631         {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
10632         {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
10633         {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
10634         {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
10635         {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
10636         {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
10637         {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
10638         {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
10639         {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
10640         {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
10641         {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
10642         {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
10643         {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
10644         {.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"},
10645         {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
10646         {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10647         {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
10648         {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
10649         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
10650         {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
10651         {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
10652         {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
10653         {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
10654         {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
10655         {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
10656         {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
10657         {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
10658         {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
10659         {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
10660         {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
10661         {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
10662         {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
10663         {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
10664         {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
10665         {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
10666         {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
10667         {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
10668         {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
10669         {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
10670         {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
10671         {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
10672         {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
10673         {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
10674         {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
10675         {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
10676         {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
10677         {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
10678         {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
10679         {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
10680         {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
10681         {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
10682         {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
10683         {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
10684         {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
10685         {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
10686         {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
10687         {.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"},
10688         {.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"},
10689         {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
10690         {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
10691         {.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"},
10692         {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
10693         {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
10694         {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
10695         {.id = ALC285_FIXUP_HP_ENVY_X360, .name = "alc285-hp-envy-x360"},
10696         {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
10697         {.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"},
10698         {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
10699         {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
10700         {.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"},
10701         {}
10702 };
10703 #define ALC225_STANDARD_PINS \
10704         {0x21, 0x04211020}
10705
10706 #define ALC256_STANDARD_PINS \
10707         {0x12, 0x90a60140}, \
10708         {0x14, 0x90170110}, \
10709         {0x21, 0x02211020}
10710
10711 #define ALC282_STANDARD_PINS \
10712         {0x14, 0x90170110}
10713
10714 #define ALC290_STANDARD_PINS \
10715         {0x12, 0x99a30130}
10716
10717 #define ALC292_STANDARD_PINS \
10718         {0x14, 0x90170110}, \
10719         {0x15, 0x0221401f}
10720
10721 #define ALC295_STANDARD_PINS \
10722         {0x12, 0xb7a60130}, \
10723         {0x14, 0x90170110}, \
10724         {0x21, 0x04211020}
10725
10726 #define ALC298_STANDARD_PINS \
10727         {0x12, 0x90a60130}, \
10728         {0x21, 0x03211020}
10729
10730 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
10731         SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
10732                 {0x14, 0x01014020},
10733                 {0x17, 0x90170110},
10734                 {0x18, 0x02a11030},
10735                 {0x19, 0x0181303F},
10736                 {0x21, 0x0221102f}),
10737         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
10738                 {0x12, 0x90a601c0},
10739                 {0x14, 0x90171120},
10740                 {0x21, 0x02211030}),
10741         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10742                 {0x14, 0x90170110},
10743                 {0x1b, 0x90a70130},
10744                 {0x21, 0x03211020}),
10745         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10746                 {0x1a, 0x90a70130},
10747                 {0x1b, 0x90170110},
10748                 {0x21, 0x03211020}),
10749         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10750                 ALC225_STANDARD_PINS,
10751                 {0x12, 0xb7a60130},
10752                 {0x14, 0x901701a0}),
10753         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10754                 ALC225_STANDARD_PINS,
10755                 {0x12, 0xb7a60130},
10756                 {0x14, 0x901701b0}),
10757         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10758                 ALC225_STANDARD_PINS,
10759                 {0x12, 0xb7a60150},
10760                 {0x14, 0x901701a0}),
10761         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10762                 ALC225_STANDARD_PINS,
10763                 {0x12, 0xb7a60150},
10764                 {0x14, 0x901701b0}),
10765         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10766                 ALC225_STANDARD_PINS,
10767                 {0x12, 0xb7a60130},
10768                 {0x1b, 0x90170110}),
10769         SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10770                 {0x1b, 0x01111010},
10771                 {0x1e, 0x01451130},
10772                 {0x21, 0x02211020}),
10773         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
10774                 {0x12, 0x90a60140},
10775                 {0x14, 0x90170110},
10776                 {0x19, 0x02a11030},
10777                 {0x21, 0x02211020}),
10778         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10779                 {0x14, 0x90170110},
10780                 {0x19, 0x02a11030},
10781                 {0x1a, 0x02a11040},
10782                 {0x1b, 0x01014020},
10783                 {0x21, 0x0221101f}),
10784         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10785                 {0x14, 0x90170110},
10786                 {0x19, 0x02a11030},
10787                 {0x1a, 0x02a11040},
10788                 {0x1b, 0x01011020},
10789                 {0x21, 0x0221101f}),
10790         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10791                 {0x14, 0x90170110},
10792                 {0x19, 0x02a11020},
10793                 {0x1a, 0x02a11030},
10794                 {0x21, 0x0221101f}),
10795         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
10796                 {0x21, 0x02211010}),
10797         SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10798                 {0x14, 0x90170110},
10799                 {0x19, 0x02a11020},
10800                 {0x21, 0x02211030}),
10801         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
10802                 {0x14, 0x90170110},
10803                 {0x21, 0x02211020}),
10804         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10805                 {0x14, 0x90170130},
10806                 {0x21, 0x02211040}),
10807         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10808                 {0x12, 0x90a60140},
10809                 {0x14, 0x90170110},
10810                 {0x21, 0x02211020}),
10811         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10812                 {0x12, 0x90a60160},
10813                 {0x14, 0x90170120},
10814                 {0x21, 0x02211030}),
10815         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10816                 {0x14, 0x90170110},
10817                 {0x1b, 0x02011020},
10818                 {0x21, 0x0221101f}),
10819         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10820                 {0x14, 0x90170110},
10821                 {0x1b, 0x01011020},
10822                 {0x21, 0x0221101f}),
10823         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10824                 {0x14, 0x90170130},
10825                 {0x1b, 0x01014020},
10826                 {0x21, 0x0221103f}),
10827         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10828                 {0x14, 0x90170130},
10829                 {0x1b, 0x01011020},
10830                 {0x21, 0x0221103f}),
10831         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10832                 {0x14, 0x90170130},
10833                 {0x1b, 0x02011020},
10834                 {0x21, 0x0221103f}),
10835         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10836                 {0x14, 0x90170150},
10837                 {0x1b, 0x02011020},
10838                 {0x21, 0x0221105f}),
10839         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10840                 {0x14, 0x90170110},
10841                 {0x1b, 0x01014020},
10842                 {0x21, 0x0221101f}),
10843         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10844                 {0x12, 0x90a60160},
10845                 {0x14, 0x90170120},
10846                 {0x17, 0x90170140},
10847                 {0x21, 0x0321102f}),
10848         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10849                 {0x12, 0x90a60160},
10850                 {0x14, 0x90170130},
10851                 {0x21, 0x02211040}),
10852         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10853                 {0x12, 0x90a60160},
10854                 {0x14, 0x90170140},
10855                 {0x21, 0x02211050}),
10856         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10857                 {0x12, 0x90a60170},
10858                 {0x14, 0x90170120},
10859                 {0x21, 0x02211030}),
10860         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10861                 {0x12, 0x90a60170},
10862                 {0x14, 0x90170130},
10863                 {0x21, 0x02211040}),
10864         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10865                 {0x12, 0x90a60170},
10866                 {0x14, 0x90171130},
10867                 {0x21, 0x02211040}),
10868         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10869                 {0x12, 0x90a60170},
10870                 {0x14, 0x90170140},
10871                 {0x21, 0x02211050}),
10872         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10873                 {0x12, 0x90a60180},
10874                 {0x14, 0x90170130},
10875                 {0x21, 0x02211040}),
10876         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10877                 {0x12, 0x90a60180},
10878                 {0x14, 0x90170120},
10879                 {0x21, 0x02211030}),
10880         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10881                 {0x1b, 0x01011020},
10882                 {0x21, 0x02211010}),
10883         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10884                 {0x14, 0x90170110},
10885                 {0x1b, 0x90a70130},
10886                 {0x21, 0x04211020}),
10887         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10888                 {0x14, 0x90170110},
10889                 {0x1b, 0x90a70130},
10890                 {0x21, 0x03211020}),
10891         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10892                 {0x12, 0x90a60130},
10893                 {0x14, 0x90170110},
10894                 {0x21, 0x03211020}),
10895         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10896                 {0x12, 0x90a60130},
10897                 {0x14, 0x90170110},
10898                 {0x21, 0x04211020}),
10899         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10900                 {0x1a, 0x90a70130},
10901                 {0x1b, 0x90170110},
10902                 {0x21, 0x03211020}),
10903        SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10904                 {0x14, 0x90170110},
10905                 {0x19, 0x02a11020},
10906                 {0x21, 0x0221101f}),
10907        SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC,
10908                 {0x17, 0x90170110},
10909                 {0x19, 0x03a11030},
10910                 {0x21, 0x03211020}),
10911         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
10912                 {0x12, 0x90a60130},
10913                 {0x14, 0x90170110},
10914                 {0x15, 0x0421101f},
10915                 {0x1a, 0x04a11020}),
10916         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
10917                 {0x12, 0x90a60140},
10918                 {0x14, 0x90170110},
10919                 {0x15, 0x0421101f},
10920                 {0x18, 0x02811030},
10921                 {0x1a, 0x04a1103f},
10922                 {0x1b, 0x02011020}),
10923         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10924                 ALC282_STANDARD_PINS,
10925                 {0x12, 0x99a30130},
10926                 {0x19, 0x03a11020},
10927                 {0x21, 0x0321101f}),
10928         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10929                 ALC282_STANDARD_PINS,
10930                 {0x12, 0x99a30130},
10931                 {0x19, 0x03a11020},
10932                 {0x21, 0x03211040}),
10933         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10934                 ALC282_STANDARD_PINS,
10935                 {0x12, 0x99a30130},
10936                 {0x19, 0x03a11030},
10937                 {0x21, 0x03211020}),
10938         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10939                 ALC282_STANDARD_PINS,
10940                 {0x12, 0x99a30130},
10941                 {0x19, 0x04a11020},
10942                 {0x21, 0x0421101f}),
10943         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
10944                 ALC282_STANDARD_PINS,
10945                 {0x12, 0x90a60140},
10946                 {0x19, 0x04a11030},
10947                 {0x21, 0x04211020}),
10948         SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10949                 ALC282_STANDARD_PINS,
10950                 {0x12, 0x90a609c0},
10951                 {0x18, 0x03a11830},
10952                 {0x19, 0x04a19831},
10953                 {0x1a, 0x0481303f},
10954                 {0x1b, 0x04211020},
10955                 {0x21, 0x0321101f}),
10956         SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10957                 ALC282_STANDARD_PINS,
10958                 {0x12, 0x90a60940},
10959                 {0x18, 0x03a11830},
10960                 {0x19, 0x04a19831},
10961                 {0x1a, 0x0481303f},
10962                 {0x1b, 0x04211020},
10963                 {0x21, 0x0321101f}),
10964         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10965                 ALC282_STANDARD_PINS,
10966                 {0x12, 0x90a60130},
10967                 {0x21, 0x0321101f}),
10968         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10969                 {0x12, 0x90a60160},
10970                 {0x14, 0x90170120},
10971                 {0x21, 0x02211030}),
10972         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10973                 ALC282_STANDARD_PINS,
10974                 {0x12, 0x90a60130},
10975                 {0x19, 0x03a11020},
10976                 {0x21, 0x0321101f}),
10977         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10978                 {0x12, 0x90a60130},
10979                 {0x14, 0x90170110},
10980                 {0x19, 0x04a11040},
10981                 {0x21, 0x04211020}),
10982         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10983                 {0x14, 0x90170110},
10984                 {0x19, 0x04a11040},
10985                 {0x1d, 0x40600001},
10986                 {0x21, 0x04211020}),
10987         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
10988                 {0x14, 0x90170110},
10989                 {0x19, 0x04a11040},
10990                 {0x21, 0x04211020}),
10991         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK,
10992                 {0x14, 0x90170110},
10993                 {0x17, 0x90170111},
10994                 {0x19, 0x03a11030},
10995                 {0x21, 0x03211020}),
10996         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
10997                 {0x17, 0x90170110},
10998                 {0x19, 0x03a11030},
10999                 {0x21, 0x03211020}),
11000         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
11001                 {0x17, 0x90170110}, /* 0x231f with RTK I2S AMP */
11002                 {0x19, 0x04a11040},
11003                 {0x21, 0x04211020}),
11004         SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
11005                 {0x12, 0x90a60130},
11006                 {0x17, 0x90170110},
11007                 {0x21, 0x02211020}),
11008         SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
11009                 {0x12, 0x90a60120},
11010                 {0x14, 0x90170110},
11011                 {0x21, 0x0321101f}),
11012         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11013                 ALC290_STANDARD_PINS,
11014                 {0x15, 0x04211040},
11015                 {0x18, 0x90170112},
11016                 {0x1a, 0x04a11020}),
11017         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11018                 ALC290_STANDARD_PINS,
11019                 {0x15, 0x04211040},
11020                 {0x18, 0x90170110},
11021                 {0x1a, 0x04a11020}),
11022         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11023                 ALC290_STANDARD_PINS,
11024                 {0x15, 0x0421101f},
11025                 {0x1a, 0x04a11020}),
11026         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11027                 ALC290_STANDARD_PINS,
11028                 {0x15, 0x04211020},
11029                 {0x1a, 0x04a11040}),
11030         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11031                 ALC290_STANDARD_PINS,
11032                 {0x14, 0x90170110},
11033                 {0x15, 0x04211020},
11034                 {0x1a, 0x04a11040}),
11035         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11036                 ALC290_STANDARD_PINS,
11037                 {0x14, 0x90170110},
11038                 {0x15, 0x04211020},
11039                 {0x1a, 0x04a11020}),
11040         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
11041                 ALC290_STANDARD_PINS,
11042                 {0x14, 0x90170110},
11043                 {0x15, 0x0421101f},
11044                 {0x1a, 0x04a11020}),
11045         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
11046                 ALC292_STANDARD_PINS,
11047                 {0x12, 0x90a60140},
11048                 {0x16, 0x01014020},
11049                 {0x19, 0x01a19030}),
11050         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
11051                 ALC292_STANDARD_PINS,
11052                 {0x12, 0x90a60140},
11053                 {0x16, 0x01014020},
11054                 {0x18, 0x02a19031},
11055                 {0x19, 0x01a1903e}),
11056         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
11057                 ALC292_STANDARD_PINS,
11058                 {0x12, 0x90a60140}),
11059         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
11060                 ALC292_STANDARD_PINS,
11061                 {0x13, 0x90a60140},
11062                 {0x16, 0x21014020},
11063                 {0x19, 0x21a19030}),
11064         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
11065                 ALC292_STANDARD_PINS,
11066                 {0x13, 0x90a60140}),
11067         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE,
11068                 {0x17, 0x90170110},
11069                 {0x21, 0x04211020}),
11070         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
11071                 {0x14, 0x90170110},
11072                 {0x1b, 0x90a70130},
11073                 {0x21, 0x04211020}),
11074         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11075                 {0x12, 0x90a60130},
11076                 {0x17, 0x90170110},
11077                 {0x21, 0x03211020}),
11078         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11079                 {0x12, 0x90a60130},
11080                 {0x17, 0x90170110},
11081                 {0x21, 0x04211020}),
11082         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
11083                 {0x12, 0x90a60130},
11084                 {0x17, 0x90170110},
11085                 {0x21, 0x03211020}),
11086         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11087                 {0x12, 0x90a60120},
11088                 {0x17, 0x90170110},
11089                 {0x21, 0x04211030}),
11090         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11091                 {0x12, 0x90a60130},
11092                 {0x17, 0x90170110},
11093                 {0x21, 0x03211020}),
11094         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
11095                 {0x12, 0x90a60130},
11096                 {0x17, 0x90170110},
11097                 {0x21, 0x03211020}),
11098         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11099                 ALC298_STANDARD_PINS,
11100                 {0x17, 0x90170110}),
11101         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11102                 ALC298_STANDARD_PINS,
11103                 {0x17, 0x90170140}),
11104         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
11105                 ALC298_STANDARD_PINS,
11106                 {0x17, 0x90170150}),
11107         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
11108                 {0x12, 0xb7a60140},
11109                 {0x13, 0xb7a60150},
11110                 {0x17, 0x90170110},
11111                 {0x1a, 0x03011020},
11112                 {0x21, 0x03211030}),
11113         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
11114                 {0x12, 0xb7a60140},
11115                 {0x17, 0x90170110},
11116                 {0x1a, 0x03a11030},
11117                 {0x21, 0x03211020}),
11118         SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11119                 ALC225_STANDARD_PINS,
11120                 {0x12, 0xb7a60130},
11121                 {0x17, 0x90170110}),
11122         SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
11123                 {0x14, 0x01014010},
11124                 {0x17, 0x90170120},
11125                 {0x18, 0x02a11030},
11126                 {0x19, 0x02a1103f},
11127                 {0x21, 0x0221101f}),
11128         {}
11129 };
11130
11131 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
11132  * more machines, don't need to match all valid pins, just need to match
11133  * all the pins defined in the tbl. Just because of this reason, it is possible
11134  * that a single machine matches multiple tbls, so there is one limitation:
11135  *   at most one tbl is allowed to define for the same vendor and same codec
11136  */
11137 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
11138         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1025, "Acer", ALC2XX_FIXUP_HEADSET_MIC,
11139                 {0x19, 0x40000000}),
11140         SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11141                 {0x19, 0x40000000},
11142                 {0x1b, 0x40000000}),
11143         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
11144                 {0x19, 0x40000000},
11145                 {0x1b, 0x40000000}),
11146         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11147                 {0x19, 0x40000000},
11148                 {0x1a, 0x40000000}),
11149         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
11150                 {0x19, 0x40000000},
11151                 {0x1a, 0x40000000}),
11152         SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
11153                 {0x19, 0x40000000},
11154                 {0x1a, 0x40000000}),
11155         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC2XX_FIXUP_HEADSET_MIC,
11156                 {0x19, 0x40000000}),
11157         {}
11158 };
11159
11160 static void alc269_fill_coef(struct hda_codec *codec)
11161 {
11162         struct alc_spec *spec = codec->spec;
11163         int val;
11164
11165         if (spec->codec_variant != ALC269_TYPE_ALC269VB)
11166                 return;
11167
11168         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
11169                 alc_write_coef_idx(codec, 0xf, 0x960b);
11170                 alc_write_coef_idx(codec, 0xe, 0x8817);
11171         }
11172
11173         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
11174                 alc_write_coef_idx(codec, 0xf, 0x960b);
11175                 alc_write_coef_idx(codec, 0xe, 0x8814);
11176         }
11177
11178         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
11179                 /* Power up output pin */
11180                 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
11181         }
11182
11183         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
11184                 val = alc_read_coef_idx(codec, 0xd);
11185                 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
11186                         /* Capless ramp up clock control */
11187                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
11188                 }
11189                 val = alc_read_coef_idx(codec, 0x17);
11190                 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
11191                         /* Class D power on reset */
11192                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
11193                 }
11194         }
11195
11196         /* HP */
11197         alc_update_coef_idx(codec, 0x4, 0, 1<<11);
11198 }
11199
11200 /*
11201  */
11202 static int patch_alc269(struct hda_codec *codec)
11203 {
11204         struct alc_spec *spec;
11205         int err;
11206
11207         err = alc_alloc_spec(codec, 0x0b);
11208         if (err < 0)
11209                 return err;
11210
11211         spec = codec->spec;
11212         spec->gen.shared_mic_vref_pin = 0x18;
11213         codec->power_save_node = 0;
11214         spec->en_3kpull_low = true;
11215
11216 #ifdef CONFIG_PM
11217         codec->patch_ops.suspend = alc269_suspend;
11218         codec->patch_ops.resume = alc269_resume;
11219 #endif
11220         spec->shutup = alc_default_shutup;
11221         spec->init_hook = alc_default_init;
11222
11223         switch (codec->core.vendor_id) {
11224         case 0x10ec0269:
11225                 spec->codec_variant = ALC269_TYPE_ALC269VA;
11226                 switch (alc_get_coef0(codec) & 0x00f0) {
11227                 case 0x0010:
11228                         if (codec->bus->pci &&
11229                             codec->bus->pci->subsystem_vendor == 0x1025 &&
11230                             spec->cdefine.platform_type == 1)
11231                                 err = alc_codec_rename(codec, "ALC271X");
11232                         spec->codec_variant = ALC269_TYPE_ALC269VB;
11233                         break;
11234                 case 0x0020:
11235                         if (codec->bus->pci &&
11236                             codec->bus->pci->subsystem_vendor == 0x17aa &&
11237                             codec->bus->pci->subsystem_device == 0x21f3)
11238                                 err = alc_codec_rename(codec, "ALC3202");
11239                         spec->codec_variant = ALC269_TYPE_ALC269VC;
11240                         break;
11241                 case 0x0030:
11242                         spec->codec_variant = ALC269_TYPE_ALC269VD;
11243                         break;
11244                 default:
11245                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
11246                 }
11247                 if (err < 0)
11248                         goto error;
11249                 spec->shutup = alc269_shutup;
11250                 spec->init_hook = alc269_fill_coef;
11251                 alc269_fill_coef(codec);
11252                 break;
11253
11254         case 0x10ec0280:
11255         case 0x10ec0290:
11256                 spec->codec_variant = ALC269_TYPE_ALC280;
11257                 break;
11258         case 0x10ec0282:
11259                 spec->codec_variant = ALC269_TYPE_ALC282;
11260                 spec->shutup = alc282_shutup;
11261                 spec->init_hook = alc282_init;
11262                 break;
11263         case 0x10ec0233:
11264         case 0x10ec0283:
11265                 spec->codec_variant = ALC269_TYPE_ALC283;
11266                 spec->shutup = alc283_shutup;
11267                 spec->init_hook = alc283_init;
11268                 break;
11269         case 0x10ec0284:
11270         case 0x10ec0292:
11271                 spec->codec_variant = ALC269_TYPE_ALC284;
11272                 break;
11273         case 0x10ec0293:
11274                 spec->codec_variant = ALC269_TYPE_ALC293;
11275                 break;
11276         case 0x10ec0286:
11277         case 0x10ec0288:
11278                 spec->codec_variant = ALC269_TYPE_ALC286;
11279                 break;
11280         case 0x10ec0298:
11281                 spec->codec_variant = ALC269_TYPE_ALC298;
11282                 break;
11283         case 0x10ec0235:
11284         case 0x10ec0255:
11285                 spec->codec_variant = ALC269_TYPE_ALC255;
11286                 spec->shutup = alc256_shutup;
11287                 spec->init_hook = alc256_init;
11288                 break;
11289         case 0x10ec0230:
11290         case 0x10ec0236:
11291         case 0x10ec0256:
11292         case 0x19e58326:
11293                 spec->codec_variant = ALC269_TYPE_ALC256;
11294                 spec->shutup = alc256_shutup;
11295                 spec->init_hook = alc256_init;
11296                 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
11297                 if (codec->core.vendor_id == 0x10ec0236 &&
11298                     codec->bus->pci->vendor != PCI_VENDOR_ID_AMD)
11299                         spec->en_3kpull_low = false;
11300                 break;
11301         case 0x10ec0257:
11302                 spec->codec_variant = ALC269_TYPE_ALC257;
11303                 spec->shutup = alc256_shutup;
11304                 spec->init_hook = alc256_init;
11305                 spec->gen.mixer_nid = 0;
11306                 spec->en_3kpull_low = false;
11307                 break;
11308         case 0x10ec0215:
11309         case 0x10ec0245:
11310         case 0x10ec0285:
11311         case 0x10ec0289:
11312                 if (alc_get_coef0(codec) & 0x0010)
11313                         spec->codec_variant = ALC269_TYPE_ALC245;
11314                 else
11315                         spec->codec_variant = ALC269_TYPE_ALC215;
11316                 spec->shutup = alc225_shutup;
11317                 spec->init_hook = alc225_init;
11318                 spec->gen.mixer_nid = 0;
11319                 break;
11320         case 0x10ec0225:
11321         case 0x10ec0295:
11322         case 0x10ec0299:
11323                 spec->codec_variant = ALC269_TYPE_ALC225;
11324                 spec->shutup = alc225_shutup;
11325                 spec->init_hook = alc225_init;
11326                 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
11327                 break;
11328         case 0x10ec0287:
11329                 spec->codec_variant = ALC269_TYPE_ALC287;
11330                 spec->shutup = alc225_shutup;
11331                 spec->init_hook = alc225_init;
11332                 spec->gen.mixer_nid = 0; /* no loopback on ALC287 */
11333                 break;
11334         case 0x10ec0234:
11335         case 0x10ec0274:
11336         case 0x10ec0294:
11337                 spec->codec_variant = ALC269_TYPE_ALC294;
11338                 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
11339                 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
11340                 spec->init_hook = alc294_init;
11341                 break;
11342         case 0x10ec0300:
11343                 spec->codec_variant = ALC269_TYPE_ALC300;
11344                 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
11345                 break;
11346         case 0x10ec0623:
11347                 spec->codec_variant = ALC269_TYPE_ALC623;
11348                 break;
11349         case 0x10ec0700:
11350         case 0x10ec0701:
11351         case 0x10ec0703:
11352         case 0x10ec0711:
11353                 spec->codec_variant = ALC269_TYPE_ALC700;
11354                 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
11355                 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
11356                 spec->init_hook = alc294_init;
11357                 break;
11358
11359         }
11360
11361         if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
11362                 spec->has_alc5505_dsp = 1;
11363                 spec->init_hook = alc5505_dsp_init;
11364         }
11365
11366         alc_pre_init(codec);
11367
11368         snd_hda_pick_fixup(codec, alc269_fixup_models,
11369                        alc269_fixup_tbl, alc269_fixups);
11370         /* FIXME: both TX300 and ROG Strix G17 have the same SSID, and
11371          * the quirk breaks the latter (bko#214101).
11372          * Clear the wrong entry.
11373          */
11374         if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 &&
11375             codec->core.vendor_id == 0x10ec0294) {
11376                 codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n");
11377                 codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
11378         }
11379
11380         snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
11381         snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
11382         snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
11383                            alc269_fixups);
11384         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11385
11386         alc_auto_parse_customize_define(codec);
11387
11388         if (has_cdefine_beep(codec))
11389                 spec->gen.beep_nid = 0x01;
11390
11391         /* automatic parse from the BIOS config */
11392         err = alc269_parse_auto_config(codec);
11393         if (err < 0)
11394                 goto error;
11395
11396         if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
11397                 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
11398                 if (err < 0)
11399                         goto error;
11400         }
11401
11402         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11403
11404         return 0;
11405
11406  error:
11407         alc_free(codec);
11408         return err;
11409 }
11410
11411 /*
11412  * ALC861
11413  */
11414
11415 static int alc861_parse_auto_config(struct hda_codec *codec)
11416 {
11417         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
11418         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
11419         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
11420 }
11421
11422 /* Pin config fixes */
11423 enum {
11424         ALC861_FIXUP_FSC_AMILO_PI1505,
11425         ALC861_FIXUP_AMP_VREF_0F,
11426         ALC861_FIXUP_NO_JACK_DETECT,
11427         ALC861_FIXUP_ASUS_A6RP,
11428         ALC660_FIXUP_ASUS_W7J,
11429 };
11430
11431 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
11432 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
11433                         const struct hda_fixup *fix, int action)
11434 {
11435         struct alc_spec *spec = codec->spec;
11436         unsigned int val;
11437
11438         if (action != HDA_FIXUP_ACT_INIT)
11439                 return;
11440         val = snd_hda_codec_get_pin_target(codec, 0x0f);
11441         if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
11442                 val |= AC_PINCTL_IN_EN;
11443         val |= AC_PINCTL_VREF_50;
11444         snd_hda_set_pin_ctl(codec, 0x0f, val);
11445         spec->gen.keep_vref_in_automute = 1;
11446 }
11447
11448 /* suppress the jack-detection */
11449 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
11450                                      const struct hda_fixup *fix, int action)
11451 {
11452         if (action == HDA_FIXUP_ACT_PRE_PROBE)
11453                 codec->no_jack_detect = 1;
11454 }
11455
11456 static const struct hda_fixup alc861_fixups[] = {
11457         [ALC861_FIXUP_FSC_AMILO_PI1505] = {
11458                 .type = HDA_FIXUP_PINS,
11459                 .v.pins = (const struct hda_pintbl[]) {
11460                         { 0x0b, 0x0221101f }, /* HP */
11461                         { 0x0f, 0x90170310 }, /* speaker */
11462                         { }
11463                 }
11464         },
11465         [ALC861_FIXUP_AMP_VREF_0F] = {
11466                 .type = HDA_FIXUP_FUNC,
11467                 .v.func = alc861_fixup_asus_amp_vref_0f,
11468         },
11469         [ALC861_FIXUP_NO_JACK_DETECT] = {
11470                 .type = HDA_FIXUP_FUNC,
11471                 .v.func = alc_fixup_no_jack_detect,
11472         },
11473         [ALC861_FIXUP_ASUS_A6RP] = {
11474                 .type = HDA_FIXUP_FUNC,
11475                 .v.func = alc861_fixup_asus_amp_vref_0f,
11476                 .chained = true,
11477                 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
11478         },
11479         [ALC660_FIXUP_ASUS_W7J] = {
11480                 .type = HDA_FIXUP_VERBS,
11481                 .v.verbs = (const struct hda_verb[]) {
11482                         /* ASUS W7J needs a magic pin setup on unused NID 0x10
11483                          * for enabling outputs
11484                          */
11485                         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11486                         { }
11487                 },
11488         }
11489 };
11490
11491 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
11492         SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
11493         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
11494         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
11495         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
11496         SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
11497         SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F),
11498         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
11499         {}
11500 };
11501
11502 /*
11503  */
11504 static int patch_alc861(struct hda_codec *codec)
11505 {
11506         struct alc_spec *spec;
11507         int err;
11508
11509         err = alc_alloc_spec(codec, 0x15);
11510         if (err < 0)
11511                 return err;
11512
11513         spec = codec->spec;
11514         if (has_cdefine_beep(codec))
11515                 spec->gen.beep_nid = 0x23;
11516
11517 #ifdef CONFIG_PM
11518         spec->power_hook = alc_power_eapd;
11519 #endif
11520
11521         alc_pre_init(codec);
11522
11523         snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
11524         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11525
11526         /* automatic parse from the BIOS config */
11527         err = alc861_parse_auto_config(codec);
11528         if (err < 0)
11529                 goto error;
11530
11531         if (!spec->gen.no_analog) {
11532                 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
11533                 if (err < 0)
11534                         goto error;
11535         }
11536
11537         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11538
11539         return 0;
11540
11541  error:
11542         alc_free(codec);
11543         return err;
11544 }
11545
11546 /*
11547  * ALC861-VD support
11548  *
11549  * Based on ALC882
11550  *
11551  * In addition, an independent DAC
11552  */
11553 static int alc861vd_parse_auto_config(struct hda_codec *codec)
11554 {
11555         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
11556         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11557         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
11558 }
11559
11560 enum {
11561         ALC660VD_FIX_ASUS_GPIO1,
11562         ALC861VD_FIX_DALLAS,
11563 };
11564
11565 /* exclude VREF80 */
11566 static void alc861vd_fixup_dallas(struct hda_codec *codec,
11567                                   const struct hda_fixup *fix, int action)
11568 {
11569         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11570                 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
11571                 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
11572         }
11573 }
11574
11575 /* reset GPIO1 */
11576 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
11577                                       const struct hda_fixup *fix, int action)
11578 {
11579         struct alc_spec *spec = codec->spec;
11580
11581         if (action == HDA_FIXUP_ACT_PRE_PROBE)
11582                 spec->gpio_mask |= 0x02;
11583         alc_fixup_gpio(codec, action, 0x01);
11584 }
11585
11586 static const struct hda_fixup alc861vd_fixups[] = {
11587         [ALC660VD_FIX_ASUS_GPIO1] = {
11588                 .type = HDA_FIXUP_FUNC,
11589                 .v.func = alc660vd_fixup_asus_gpio1,
11590         },
11591         [ALC861VD_FIX_DALLAS] = {
11592                 .type = HDA_FIXUP_FUNC,
11593                 .v.func = alc861vd_fixup_dallas,
11594         },
11595 };
11596
11597 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
11598         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
11599         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
11600         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
11601         {}
11602 };
11603
11604 /*
11605  */
11606 static int patch_alc861vd(struct hda_codec *codec)
11607 {
11608         struct alc_spec *spec;
11609         int err;
11610
11611         err = alc_alloc_spec(codec, 0x0b);
11612         if (err < 0)
11613                 return err;
11614
11615         spec = codec->spec;
11616         if (has_cdefine_beep(codec))
11617                 spec->gen.beep_nid = 0x23;
11618
11619         spec->shutup = alc_eapd_shutup;
11620
11621         alc_pre_init(codec);
11622
11623         snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
11624         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11625
11626         /* automatic parse from the BIOS config */
11627         err = alc861vd_parse_auto_config(codec);
11628         if (err < 0)
11629                 goto error;
11630
11631         if (!spec->gen.no_analog) {
11632                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11633                 if (err < 0)
11634                         goto error;
11635         }
11636
11637         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11638
11639         return 0;
11640
11641  error:
11642         alc_free(codec);
11643         return err;
11644 }
11645
11646 /*
11647  * ALC662 support
11648  *
11649  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
11650  * configuration.  Each pin widget can choose any input DACs and a mixer.
11651  * Each ADC is connected from a mixer of all inputs.  This makes possible
11652  * 6-channel independent captures.
11653  *
11654  * In addition, an independent DAC for the multi-playback (not used in this
11655  * driver yet).
11656  */
11657
11658 /*
11659  * BIOS auto configuration
11660  */
11661
11662 static int alc662_parse_auto_config(struct hda_codec *codec)
11663 {
11664         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
11665         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
11666         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11667         const hda_nid_t *ssids;
11668
11669         if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
11670             codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
11671             codec->core.vendor_id == 0x10ec0671)
11672                 ssids = alc663_ssids;
11673         else
11674                 ssids = alc662_ssids;
11675         return alc_parse_auto_config(codec, alc662_ignore, ssids);
11676 }
11677
11678 static void alc272_fixup_mario(struct hda_codec *codec,
11679                                const struct hda_fixup *fix, int action)
11680 {
11681         if (action != HDA_FIXUP_ACT_PRE_PROBE)
11682                 return;
11683         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
11684                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
11685                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
11686                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
11687                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
11688                 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
11689 }
11690
11691 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
11692         { .channels = 2,
11693           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
11694         { .channels = 4,
11695           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
11696                    SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
11697         { }
11698 };
11699
11700 /* override the 2.1 chmap */
11701 static void alc_fixup_bass_chmap(struct hda_codec *codec,
11702                                     const struct hda_fixup *fix, int action)
11703 {
11704         if (action == HDA_FIXUP_ACT_BUILD) {
11705                 struct alc_spec *spec = codec->spec;
11706                 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
11707         }
11708 }
11709
11710 /* avoid D3 for keeping GPIO up */
11711 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
11712                                           hda_nid_t nid,
11713                                           unsigned int power_state)
11714 {
11715         struct alc_spec *spec = codec->spec;
11716         if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
11717                 return AC_PWRST_D0;
11718         return power_state;
11719 }
11720
11721 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
11722                                    const struct hda_fixup *fix, int action)
11723 {
11724         struct alc_spec *spec = codec->spec;
11725
11726         alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
11727         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11728                 spec->mute_led_polarity = 1;
11729                 codec->power_filter = gpio_led_power_filter;
11730         }
11731 }
11732
11733 static void alc662_usi_automute_hook(struct hda_codec *codec,
11734                                          struct hda_jack_callback *jack)
11735 {
11736         struct alc_spec *spec = codec->spec;
11737         int vref;
11738         msleep(200);
11739         snd_hda_gen_hp_automute(codec, jack);
11740
11741         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
11742         msleep(100);
11743         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11744                             vref);
11745 }
11746
11747 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
11748                                      const struct hda_fixup *fix, int action)
11749 {
11750         struct alc_spec *spec = codec->spec;
11751         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11752                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11753                 spec->gen.hp_automute_hook = alc662_usi_automute_hook;
11754         }
11755 }
11756
11757 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
11758                                         struct hda_jack_callback *cb)
11759 {
11760         /* surround speakers at 0x1b already get muted automatically when
11761          * headphones are plugged in, but we have to mute/unmute the remaining
11762          * channels manually:
11763          * 0x15 - front left/front right
11764          * 0x18 - front center/ LFE
11765          */
11766         if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
11767                 snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
11768                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
11769         } else {
11770                 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
11771                 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
11772         }
11773 }
11774
11775 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
11776                                         const struct hda_fixup *fix, int action)
11777 {
11778     /* Pin 0x1b: shared headphones jack and surround speakers */
11779         if (!is_jack_detectable(codec, 0x1b))
11780                 return;
11781
11782         switch (action) {
11783         case HDA_FIXUP_ACT_PRE_PROBE:
11784                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
11785                                 alc662_aspire_ethos_mute_speakers);
11786                 /* subwoofer needs an extra GPIO setting to become audible */
11787                 alc_setup_gpio(codec, 0x02);
11788                 break;
11789         case HDA_FIXUP_ACT_INIT:
11790                 /* Make sure to start in a correct state, i.e. if
11791                  * headphones have been plugged in before powering up the system
11792                  */
11793                 alc662_aspire_ethos_mute_speakers(codec, NULL);
11794                 break;
11795         }
11796 }
11797
11798 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
11799                                              const struct hda_fixup *fix, int action)
11800 {
11801         struct alc_spec *spec = codec->spec;
11802
11803         static const struct hda_pintbl pincfgs[] = {
11804                 { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
11805                 { 0x1b, 0x0181304f },
11806                 { }
11807         };
11808
11809         switch (action) {
11810         case HDA_FIXUP_ACT_PRE_PROBE:
11811                 spec->gen.mixer_nid = 0;
11812                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11813                 snd_hda_apply_pincfgs(codec, pincfgs);
11814                 break;
11815         case HDA_FIXUP_ACT_INIT:
11816                 alc_write_coef_idx(codec, 0x19, 0xa054);
11817                 break;
11818         }
11819 }
11820
11821 static void alc897_hp_automute_hook(struct hda_codec *codec,
11822                                          struct hda_jack_callback *jack)
11823 {
11824         struct alc_spec *spec = codec->spec;
11825         int vref;
11826
11827         snd_hda_gen_hp_automute(codec, jack);
11828         vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
11829         snd_hda_set_pin_ctl(codec, 0x1b, vref);
11830 }
11831
11832 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
11833                                      const struct hda_fixup *fix, int action)
11834 {
11835         struct alc_spec *spec = codec->spec;
11836         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11837                 spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11838                 spec->no_shutup_pins = 1;
11839         }
11840         if (action == HDA_FIXUP_ACT_PROBE) {
11841                 snd_hda_set_pin_ctl_cache(codec, 0x1a, PIN_IN | AC_PINCTL_VREF_100);
11842         }
11843 }
11844
11845 static void alc897_fixup_lenovo_headset_mode(struct hda_codec *codec,
11846                                      const struct hda_fixup *fix, int action)
11847 {
11848         struct alc_spec *spec = codec->spec;
11849
11850         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11851                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11852                 spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11853         }
11854 }
11855
11856 static const struct coef_fw alc668_coefs[] = {
11857         WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
11858         WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
11859         WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
11860         WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
11861         WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
11862         WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
11863         WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
11864         WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
11865         WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
11866         WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
11867         WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
11868         WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
11869         WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
11870         WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
11871         WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
11872         WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
11873         WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
11874         WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
11875         WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
11876         WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
11877         {}
11878 };
11879
11880 static void alc668_restore_default_value(struct hda_codec *codec)
11881 {
11882         alc_process_coef_fw(codec, alc668_coefs);
11883 }
11884
11885 enum {
11886         ALC662_FIXUP_ASPIRE,
11887         ALC662_FIXUP_LED_GPIO1,
11888         ALC662_FIXUP_IDEAPAD,
11889         ALC272_FIXUP_MARIO,
11890         ALC662_FIXUP_CZC_ET26,
11891         ALC662_FIXUP_CZC_P10T,
11892         ALC662_FIXUP_SKU_IGNORE,
11893         ALC662_FIXUP_HP_RP5800,
11894         ALC662_FIXUP_ASUS_MODE1,
11895         ALC662_FIXUP_ASUS_MODE2,
11896         ALC662_FIXUP_ASUS_MODE3,
11897         ALC662_FIXUP_ASUS_MODE4,
11898         ALC662_FIXUP_ASUS_MODE5,
11899         ALC662_FIXUP_ASUS_MODE6,
11900         ALC662_FIXUP_ASUS_MODE7,
11901         ALC662_FIXUP_ASUS_MODE8,
11902         ALC662_FIXUP_NO_JACK_DETECT,
11903         ALC662_FIXUP_ZOTAC_Z68,
11904         ALC662_FIXUP_INV_DMIC,
11905         ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
11906         ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
11907         ALC662_FIXUP_HEADSET_MODE,
11908         ALC668_FIXUP_HEADSET_MODE,
11909         ALC662_FIXUP_BASS_MODE4_CHMAP,
11910         ALC662_FIXUP_BASS_16,
11911         ALC662_FIXUP_BASS_1A,
11912         ALC662_FIXUP_BASS_CHMAP,
11913         ALC668_FIXUP_AUTO_MUTE,
11914         ALC668_FIXUP_DELL_DISABLE_AAMIX,
11915         ALC668_FIXUP_DELL_XPS13,
11916         ALC662_FIXUP_ASUS_Nx50,
11917         ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
11918         ALC668_FIXUP_ASUS_Nx51,
11919         ALC668_FIXUP_MIC_COEF,
11920         ALC668_FIXUP_ASUS_G751,
11921         ALC891_FIXUP_HEADSET_MODE,
11922         ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
11923         ALC662_FIXUP_ACER_VERITON,
11924         ALC892_FIXUP_ASROCK_MOBO,
11925         ALC662_FIXUP_USI_FUNC,
11926         ALC662_FIXUP_USI_HEADSET_MODE,
11927         ALC662_FIXUP_LENOVO_MULTI_CODECS,
11928         ALC669_FIXUP_ACER_ASPIRE_ETHOS,
11929         ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
11930         ALC671_FIXUP_HP_HEADSET_MIC2,
11931         ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
11932         ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
11933         ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
11934         ALC668_FIXUP_HEADSET_MIC,
11935         ALC668_FIXUP_MIC_DET_COEF,
11936         ALC897_FIXUP_LENOVO_HEADSET_MIC,
11937         ALC897_FIXUP_HEADSET_MIC_PIN,
11938         ALC897_FIXUP_HP_HSMIC_VERB,
11939         ALC897_FIXUP_LENOVO_HEADSET_MODE,
11940         ALC897_FIXUP_HEADSET_MIC_PIN2,
11941         ALC897_FIXUP_UNIS_H3C_X500S,
11942 };
11943
11944 static const struct hda_fixup alc662_fixups[] = {
11945         [ALC662_FIXUP_ASPIRE] = {
11946                 .type = HDA_FIXUP_PINS,
11947                 .v.pins = (const struct hda_pintbl[]) {
11948                         { 0x15, 0x99130112 }, /* subwoofer */
11949                         { }
11950                 }
11951         },
11952         [ALC662_FIXUP_LED_GPIO1] = {
11953                 .type = HDA_FIXUP_FUNC,
11954                 .v.func = alc662_fixup_led_gpio1,
11955         },
11956         [ALC662_FIXUP_IDEAPAD] = {
11957                 .type = HDA_FIXUP_PINS,
11958                 .v.pins = (const struct hda_pintbl[]) {
11959                         { 0x17, 0x99130112 }, /* subwoofer */
11960                         { }
11961                 },
11962                 .chained = true,
11963                 .chain_id = ALC662_FIXUP_LED_GPIO1,
11964         },
11965         [ALC272_FIXUP_MARIO] = {
11966                 .type = HDA_FIXUP_FUNC,
11967                 .v.func = alc272_fixup_mario,
11968         },
11969         [ALC662_FIXUP_CZC_ET26] = {
11970                 .type = HDA_FIXUP_PINS,
11971                 .v.pins = (const struct hda_pintbl[]) {
11972                         {0x12, 0x403cc000},
11973                         {0x14, 0x90170110}, /* speaker */
11974                         {0x15, 0x411111f0},
11975                         {0x16, 0x411111f0},
11976                         {0x18, 0x01a19030}, /* mic */
11977                         {0x19, 0x90a7013f}, /* int-mic */
11978                         {0x1a, 0x01014020},
11979                         {0x1b, 0x0121401f},
11980                         {0x1c, 0x411111f0},
11981                         {0x1d, 0x411111f0},
11982                         {0x1e, 0x40478e35},
11983                         {}
11984                 },
11985                 .chained = true,
11986                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11987         },
11988         [ALC662_FIXUP_CZC_P10T] = {
11989                 .type = HDA_FIXUP_VERBS,
11990                 .v.verbs = (const struct hda_verb[]) {
11991                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
11992                         {}
11993                 }
11994         },
11995         [ALC662_FIXUP_SKU_IGNORE] = {
11996                 .type = HDA_FIXUP_FUNC,
11997                 .v.func = alc_fixup_sku_ignore,
11998         },
11999         [ALC662_FIXUP_HP_RP5800] = {
12000                 .type = HDA_FIXUP_PINS,
12001                 .v.pins = (const struct hda_pintbl[]) {
12002                         { 0x14, 0x0221201f }, /* HP out */
12003                         { }
12004                 },
12005                 .chained = true,
12006                 .chain_id = ALC662_FIXUP_SKU_IGNORE
12007         },
12008         [ALC662_FIXUP_ASUS_MODE1] = {
12009                 .type = HDA_FIXUP_PINS,
12010                 .v.pins = (const struct hda_pintbl[]) {
12011                         { 0x14, 0x99130110 }, /* speaker */
12012                         { 0x18, 0x01a19c20 }, /* mic */
12013                         { 0x19, 0x99a3092f }, /* int-mic */
12014                         { 0x21, 0x0121401f }, /* HP out */
12015                         { }
12016                 },
12017                 .chained = true,
12018                 .chain_id = ALC662_FIXUP_SKU_IGNORE
12019         },
12020         [ALC662_FIXUP_ASUS_MODE2] = {
12021                 .type = HDA_FIXUP_PINS,
12022                 .v.pins = (const struct hda_pintbl[]) {
12023                         { 0x14, 0x99130110 }, /* speaker */
12024                         { 0x18, 0x01a19820 }, /* mic */
12025                         { 0x19, 0x99a3092f }, /* int-mic */
12026                         { 0x1b, 0x0121401f }, /* HP out */
12027                         { }
12028                 },
12029                 .chained = true,
12030                 .chain_id = ALC662_FIXUP_SKU_IGNORE
12031         },
12032         [ALC662_FIXUP_ASUS_MODE3] = {
12033                 .type = HDA_FIXUP_PINS,
12034                 .v.pins = (const struct hda_pintbl[]) {
12035                         { 0x14, 0x99130110 }, /* speaker */
12036                         { 0x15, 0x0121441f }, /* HP */
12037                         { 0x18, 0x01a19840 }, /* mic */
12038                         { 0x19, 0x99a3094f }, /* int-mic */
12039                         { 0x21, 0x01211420 }, /* HP2 */
12040                         { }
12041                 },
12042                 .chained = true,
12043                 .chain_id = ALC662_FIXUP_SKU_IGNORE
12044         },
12045         [ALC662_FIXUP_ASUS_MODE4] = {
12046                 .type = HDA_FIXUP_PINS,
12047                 .v.pins = (const struct hda_pintbl[]) {
12048                         { 0x14, 0x99130110 }, /* speaker */
12049                         { 0x16, 0x99130111 }, /* speaker */
12050                         { 0x18, 0x01a19840 }, /* mic */
12051                         { 0x19, 0x99a3094f }, /* int-mic */
12052                         { 0x21, 0x0121441f }, /* HP */
12053                         { }
12054                 },
12055                 .chained = true,
12056                 .chain_id = ALC662_FIXUP_SKU_IGNORE
12057         },
12058         [ALC662_FIXUP_ASUS_MODE5] = {
12059                 .type = HDA_FIXUP_PINS,
12060                 .v.pins = (const struct hda_pintbl[]) {
12061                         { 0x14, 0x99130110 }, /* speaker */
12062                         { 0x15, 0x0121441f }, /* HP */
12063                         { 0x16, 0x99130111 }, /* speaker */
12064                         { 0x18, 0x01a19840 }, /* mic */
12065                         { 0x19, 0x99a3094f }, /* int-mic */
12066                         { }
12067                 },
12068                 .chained = true,
12069                 .chain_id = ALC662_FIXUP_SKU_IGNORE
12070         },
12071         [ALC662_FIXUP_ASUS_MODE6] = {
12072                 .type = HDA_FIXUP_PINS,
12073                 .v.pins = (const struct hda_pintbl[]) {
12074                         { 0x14, 0x99130110 }, /* speaker */
12075                         { 0x15, 0x01211420 }, /* HP2 */
12076                         { 0x18, 0x01a19840 }, /* mic */
12077                         { 0x19, 0x99a3094f }, /* int-mic */
12078                         { 0x1b, 0x0121441f }, /* HP */
12079                         { }
12080                 },
12081                 .chained = true,
12082                 .chain_id = ALC662_FIXUP_SKU_IGNORE
12083         },
12084         [ALC662_FIXUP_ASUS_MODE7] = {
12085                 .type = HDA_FIXUP_PINS,
12086                 .v.pins = (const struct hda_pintbl[]) {
12087                         { 0x14, 0x99130110 }, /* speaker */
12088                         { 0x17, 0x99130111 }, /* speaker */
12089                         { 0x18, 0x01a19840 }, /* mic */
12090                         { 0x19, 0x99a3094f }, /* int-mic */
12091                         { 0x1b, 0x01214020 }, /* HP */
12092                         { 0x21, 0x0121401f }, /* HP */
12093                         { }
12094                 },
12095                 .chained = true,
12096                 .chain_id = ALC662_FIXUP_SKU_IGNORE
12097         },
12098         [ALC662_FIXUP_ASUS_MODE8] = {
12099                 .type = HDA_FIXUP_PINS,
12100                 .v.pins = (const struct hda_pintbl[]) {
12101                         { 0x14, 0x99130110 }, /* speaker */
12102                         { 0x12, 0x99a30970 }, /* int-mic */
12103                         { 0x15, 0x01214020 }, /* HP */
12104                         { 0x17, 0x99130111 }, /* speaker */
12105                         { 0x18, 0x01a19840 }, /* mic */
12106                         { 0x21, 0x0121401f }, /* HP */
12107                         { }
12108                 },
12109                 .chained = true,
12110                 .chain_id = ALC662_FIXUP_SKU_IGNORE
12111         },
12112         [ALC662_FIXUP_NO_JACK_DETECT] = {
12113                 .type = HDA_FIXUP_FUNC,
12114                 .v.func = alc_fixup_no_jack_detect,
12115         },
12116         [ALC662_FIXUP_ZOTAC_Z68] = {
12117                 .type = HDA_FIXUP_PINS,
12118                 .v.pins = (const struct hda_pintbl[]) {
12119                         { 0x1b, 0x02214020 }, /* Front HP */
12120                         { }
12121                 }
12122         },
12123         [ALC662_FIXUP_INV_DMIC] = {
12124                 .type = HDA_FIXUP_FUNC,
12125                 .v.func = alc_fixup_inv_dmic,
12126         },
12127         [ALC668_FIXUP_DELL_XPS13] = {
12128                 .type = HDA_FIXUP_FUNC,
12129                 .v.func = alc_fixup_dell_xps13,
12130                 .chained = true,
12131                 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
12132         },
12133         [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
12134                 .type = HDA_FIXUP_FUNC,
12135                 .v.func = alc_fixup_disable_aamix,
12136                 .chained = true,
12137                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
12138         },
12139         [ALC668_FIXUP_AUTO_MUTE] = {
12140                 .type = HDA_FIXUP_FUNC,
12141                 .v.func = alc_fixup_auto_mute_via_amp,
12142                 .chained = true,
12143                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
12144         },
12145         [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
12146                 .type = HDA_FIXUP_PINS,
12147                 .v.pins = (const struct hda_pintbl[]) {
12148                         { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12149                         /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
12150                         { }
12151                 },
12152                 .chained = true,
12153                 .chain_id = ALC662_FIXUP_HEADSET_MODE
12154         },
12155         [ALC662_FIXUP_HEADSET_MODE] = {
12156                 .type = HDA_FIXUP_FUNC,
12157                 .v.func = alc_fixup_headset_mode_alc662,
12158         },
12159         [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
12160                 .type = HDA_FIXUP_PINS,
12161                 .v.pins = (const struct hda_pintbl[]) {
12162                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12163                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12164                         { }
12165                 },
12166                 .chained = true,
12167                 .chain_id = ALC668_FIXUP_HEADSET_MODE
12168         },
12169         [ALC668_FIXUP_HEADSET_MODE] = {
12170                 .type = HDA_FIXUP_FUNC,
12171                 .v.func = alc_fixup_headset_mode_alc668,
12172         },
12173         [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
12174                 .type = HDA_FIXUP_FUNC,
12175                 .v.func = alc_fixup_bass_chmap,
12176                 .chained = true,
12177                 .chain_id = ALC662_FIXUP_ASUS_MODE4
12178         },
12179         [ALC662_FIXUP_BASS_16] = {
12180                 .type = HDA_FIXUP_PINS,
12181                 .v.pins = (const struct hda_pintbl[]) {
12182                         {0x16, 0x80106111}, /* bass speaker */
12183                         {}
12184                 },
12185                 .chained = true,
12186                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
12187         },
12188         [ALC662_FIXUP_BASS_1A] = {
12189                 .type = HDA_FIXUP_PINS,
12190                 .v.pins = (const struct hda_pintbl[]) {
12191                         {0x1a, 0x80106111}, /* bass speaker */
12192                         {}
12193                 },
12194                 .chained = true,
12195                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
12196         },
12197         [ALC662_FIXUP_BASS_CHMAP] = {
12198                 .type = HDA_FIXUP_FUNC,
12199                 .v.func = alc_fixup_bass_chmap,
12200         },
12201         [ALC662_FIXUP_ASUS_Nx50] = {
12202                 .type = HDA_FIXUP_FUNC,
12203                 .v.func = alc_fixup_auto_mute_via_amp,
12204                 .chained = true,
12205                 .chain_id = ALC662_FIXUP_BASS_1A
12206         },
12207         [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
12208                 .type = HDA_FIXUP_FUNC,
12209                 .v.func = alc_fixup_headset_mode_alc668,
12210                 .chain_id = ALC662_FIXUP_BASS_CHMAP
12211         },
12212         [ALC668_FIXUP_ASUS_Nx51] = {
12213                 .type = HDA_FIXUP_PINS,
12214                 .v.pins = (const struct hda_pintbl[]) {
12215                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12216                         { 0x1a, 0x90170151 }, /* bass speaker */
12217                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12218                         {}
12219                 },
12220                 .chained = true,
12221                 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
12222         },
12223         [ALC668_FIXUP_MIC_COEF] = {
12224                 .type = HDA_FIXUP_VERBS,
12225                 .v.verbs = (const struct hda_verb[]) {
12226                         { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
12227                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
12228                         {}
12229                 },
12230         },
12231         [ALC668_FIXUP_ASUS_G751] = {
12232                 .type = HDA_FIXUP_PINS,
12233                 .v.pins = (const struct hda_pintbl[]) {
12234                         { 0x16, 0x0421101f }, /* HP */
12235                         {}
12236                 },
12237                 .chained = true,
12238                 .chain_id = ALC668_FIXUP_MIC_COEF
12239         },
12240         [ALC891_FIXUP_HEADSET_MODE] = {
12241                 .type = HDA_FIXUP_FUNC,
12242                 .v.func = alc_fixup_headset_mode,
12243         },
12244         [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
12245                 .type = HDA_FIXUP_PINS,
12246                 .v.pins = (const struct hda_pintbl[]) {
12247                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
12248                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
12249                         { }
12250                 },
12251                 .chained = true,
12252                 .chain_id = ALC891_FIXUP_HEADSET_MODE
12253         },
12254         [ALC662_FIXUP_ACER_VERITON] = {
12255                 .type = HDA_FIXUP_PINS,
12256                 .v.pins = (const struct hda_pintbl[]) {
12257                         { 0x15, 0x50170120 }, /* no internal speaker */
12258                         { }
12259                 }
12260         },
12261         [ALC892_FIXUP_ASROCK_MOBO] = {
12262                 .type = HDA_FIXUP_PINS,
12263                 .v.pins = (const struct hda_pintbl[]) {
12264                         { 0x15, 0x40f000f0 }, /* disabled */
12265                         { 0x16, 0x40f000f0 }, /* disabled */
12266                         { }
12267                 }
12268         },
12269         [ALC662_FIXUP_USI_FUNC] = {
12270                 .type = HDA_FIXUP_FUNC,
12271                 .v.func = alc662_fixup_usi_headset_mic,
12272         },
12273         [ALC662_FIXUP_USI_HEADSET_MODE] = {
12274                 .type = HDA_FIXUP_PINS,
12275                 .v.pins = (const struct hda_pintbl[]) {
12276                         { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
12277                         { 0x18, 0x01a1903d },
12278                         { }
12279                 },
12280                 .chained = true,
12281                 .chain_id = ALC662_FIXUP_USI_FUNC
12282         },
12283         [ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
12284                 .type = HDA_FIXUP_FUNC,
12285                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
12286         },
12287         [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
12288                 .type = HDA_FIXUP_FUNC,
12289                 .v.func = alc662_fixup_aspire_ethos_hp,
12290         },
12291         [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
12292                 .type = HDA_FIXUP_PINS,
12293                 .v.pins = (const struct hda_pintbl[]) {
12294                         { 0x15, 0x92130110 }, /* front speakers */
12295                         { 0x18, 0x99130111 }, /* center/subwoofer */
12296                         { 0x1b, 0x11130012 }, /* surround plus jack for HP */
12297                         { }
12298                 },
12299                 .chained = true,
12300                 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
12301         },
12302         [ALC671_FIXUP_HP_HEADSET_MIC2] = {
12303                 .type = HDA_FIXUP_FUNC,
12304                 .v.func = alc671_fixup_hp_headset_mic2,
12305         },
12306         [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
12307                 .type = HDA_FIXUP_PINS,
12308                 .v.pins = (const struct hda_pintbl[]) {
12309                         { 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
12310                         { }
12311                 },
12312                 .chained = true,
12313                 .chain_id = ALC662_FIXUP_USI_FUNC
12314         },
12315         [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
12316                 .type = HDA_FIXUP_PINS,
12317                 .v.pins = (const struct hda_pintbl[]) {
12318                         { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12319                         { 0x1b, 0x0221144f },
12320                         { }
12321                 },
12322                 .chained = true,
12323                 .chain_id = ALC662_FIXUP_USI_FUNC
12324         },
12325         [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
12326                 .type = HDA_FIXUP_PINS,
12327                 .v.pins = (const struct hda_pintbl[]) {
12328                         { 0x1b, 0x04a1112c },
12329                         { }
12330                 },
12331                 .chained = true,
12332                 .chain_id = ALC668_FIXUP_HEADSET_MIC
12333         },
12334         [ALC668_FIXUP_HEADSET_MIC] = {
12335                 .type = HDA_FIXUP_FUNC,
12336                 .v.func = alc269_fixup_headset_mic,
12337                 .chained = true,
12338                 .chain_id = ALC668_FIXUP_MIC_DET_COEF
12339         },
12340         [ALC668_FIXUP_MIC_DET_COEF] = {
12341                 .type = HDA_FIXUP_VERBS,
12342                 .v.verbs = (const struct hda_verb[]) {
12343                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
12344                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
12345                         {}
12346                 },
12347         },
12348         [ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
12349                 .type = HDA_FIXUP_FUNC,
12350                 .v.func = alc897_fixup_lenovo_headset_mic,
12351         },
12352         [ALC897_FIXUP_HEADSET_MIC_PIN] = {
12353                 .type = HDA_FIXUP_PINS,
12354                 .v.pins = (const struct hda_pintbl[]) {
12355                         { 0x1a, 0x03a11050 },
12356                         { }
12357                 },
12358                 .chained = true,
12359                 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
12360         },
12361         [ALC897_FIXUP_HP_HSMIC_VERB] = {
12362                 .type = HDA_FIXUP_PINS,
12363                 .v.pins = (const struct hda_pintbl[]) {
12364                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
12365                         { }
12366                 },
12367         },
12368         [ALC897_FIXUP_LENOVO_HEADSET_MODE] = {
12369                 .type = HDA_FIXUP_FUNC,
12370                 .v.func = alc897_fixup_lenovo_headset_mode,
12371         },
12372         [ALC897_FIXUP_HEADSET_MIC_PIN2] = {
12373                 .type = HDA_FIXUP_PINS,
12374                 .v.pins = (const struct hda_pintbl[]) {
12375                         { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12376                         { }
12377                 },
12378                 .chained = true,
12379                 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MODE
12380         },
12381         [ALC897_FIXUP_UNIS_H3C_X500S] = {
12382                 .type = HDA_FIXUP_VERBS,
12383                 .v.verbs = (const struct hda_verb[]) {
12384                         { 0x14, AC_VERB_SET_EAPD_BTLENABLE, 0 },
12385                         {}
12386                 },
12387         },
12388 };
12389
12390 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
12391         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
12392         SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
12393         SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
12394         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
12395         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
12396         SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
12397         SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
12398         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
12399         SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
12400         SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
12401         SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
12402         SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12403         SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12404         SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
12405         SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
12406         SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
12407         SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12408         SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12409         SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12410         SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12411         SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12412         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
12413         SND_PCI_QUIRK(0x103c, 0x870c, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12414         SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12415         SND_PCI_QUIRK(0x103c, 0x872b, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12416         SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
12417         SND_PCI_QUIRK(0x103c, 0x8768, "HP Slim Desktop S01", ALC671_FIXUP_HP_HEADSET_MIC2),
12418         SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
12419         SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
12420         SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
12421         SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
12422         SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
12423         SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
12424         SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
12425         SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12426         SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
12427         SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
12428         SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
12429         SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
12430         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
12431         SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
12432         SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12433         SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
12434         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
12435         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
12436         SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
12437         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
12438         SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
12439         SND_PCI_QUIRK(0x17aa, 0x1064, "Lenovo P3 Tower", ALC897_FIXUP_HEADSET_MIC_PIN),
12440         SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
12441         SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
12442         SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
12443         SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
12444         SND_PCI_QUIRK(0x17aa, 0x3321, "Lenovo ThinkCentre M70 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12445         SND_PCI_QUIRK(0x17aa, 0x331b, "Lenovo ThinkCentre M90 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12446         SND_PCI_QUIRK(0x17aa, 0x3364, "Lenovo ThinkCentre M90 Gen5", ALC897_FIXUP_HEADSET_MIC_PIN),
12447         SND_PCI_QUIRK(0x17aa, 0x3742, "Lenovo TianYi510Pro-14IOB", ALC897_FIXUP_HEADSET_MIC_PIN2),
12448         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
12449         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
12450         SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
12451         SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
12452         SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
12453         SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26),
12454         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
12455         SND_PCI_QUIRK(0x1c6c, 0x1239, "Compaq N14JP6-V2", ALC897_FIXUP_HP_HSMIC_VERB),
12456
12457 #if 0
12458         /* Below is a quirk table taken from the old code.
12459          * Basically the device should work as is without the fixup table.
12460          * If BIOS doesn't give a proper info, enable the corresponding
12461          * fixup entry.
12462          */
12463         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
12464         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
12465         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
12466         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
12467         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12468         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12469         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12470         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
12471         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
12472         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12473         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
12474         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
12475         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
12476         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
12477         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
12478         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12479         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
12480         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
12481         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12482         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12483         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12484         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12485         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
12486         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
12487         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
12488         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12489         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
12490         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12491         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12492         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
12493         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12494         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12495         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
12496         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
12497         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
12498         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
12499         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
12500         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
12501         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
12502         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12503         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
12504         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
12505         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12506         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
12507         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
12508         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
12509         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
12510         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
12511         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12512         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
12513 #endif
12514         {}
12515 };
12516
12517 static const struct hda_model_fixup alc662_fixup_models[] = {
12518         {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
12519         {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
12520         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
12521         {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
12522         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
12523         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
12524         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
12525         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
12526         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
12527         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
12528         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
12529         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
12530         {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
12531         {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
12532         {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
12533         {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
12534         {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
12535         {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
12536         {.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
12537         {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
12538         {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
12539         {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
12540         {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
12541         {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
12542         {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
12543         {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
12544         {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
12545         {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
12546         {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
12547         {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
12548         {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
12549         {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
12550         {.id = ALC897_FIXUP_UNIS_H3C_X500S, .name = "unis-h3c-x500s"},
12551         {}
12552 };
12553
12554 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
12555         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12556                 {0x17, 0x02211010},
12557                 {0x18, 0x01a19030},
12558                 {0x1a, 0x01813040},
12559                 {0x21, 0x01014020}),
12560         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12561                 {0x16, 0x01813030},
12562                 {0x17, 0x02211010},
12563                 {0x18, 0x01a19040},
12564                 {0x21, 0x01014020}),
12565         SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
12566                 {0x14, 0x01014010},
12567                 {0x18, 0x01a19020},
12568                 {0x1a, 0x0181302f},
12569                 {0x1b, 0x0221401f}),
12570         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12571                 {0x12, 0x99a30130},
12572                 {0x14, 0x90170110},
12573                 {0x15, 0x0321101f},
12574                 {0x16, 0x03011020}),
12575         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12576                 {0x12, 0x99a30140},
12577                 {0x14, 0x90170110},
12578                 {0x15, 0x0321101f},
12579                 {0x16, 0x03011020}),
12580         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12581                 {0x12, 0x99a30150},
12582                 {0x14, 0x90170110},
12583                 {0x15, 0x0321101f},
12584                 {0x16, 0x03011020}),
12585         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12586                 {0x14, 0x90170110},
12587                 {0x15, 0x0321101f},
12588                 {0x16, 0x03011020}),
12589         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
12590                 {0x12, 0x90a60130},
12591                 {0x14, 0x90170110},
12592                 {0x15, 0x0321101f}),
12593         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12594                 {0x14, 0x01014010},
12595                 {0x17, 0x90170150},
12596                 {0x19, 0x02a11060},
12597                 {0x1b, 0x01813030},
12598                 {0x21, 0x02211020}),
12599         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12600                 {0x14, 0x01014010},
12601                 {0x18, 0x01a19040},
12602                 {0x1b, 0x01813030},
12603                 {0x21, 0x02211020}),
12604         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12605                 {0x14, 0x01014020},
12606                 {0x17, 0x90170110},
12607                 {0x18, 0x01a19050},
12608                 {0x1b, 0x01813040},
12609                 {0x21, 0x02211030}),
12610         {}
12611 };
12612
12613 /*
12614  */
12615 static int patch_alc662(struct hda_codec *codec)
12616 {
12617         struct alc_spec *spec;
12618         int err;
12619
12620         err = alc_alloc_spec(codec, 0x0b);
12621         if (err < 0)
12622                 return err;
12623
12624         spec = codec->spec;
12625
12626         spec->shutup = alc_eapd_shutup;
12627
12628         /* handle multiple HPs as is */
12629         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
12630
12631         alc_fix_pll_init(codec, 0x20, 0x04, 15);
12632
12633         switch (codec->core.vendor_id) {
12634         case 0x10ec0668:
12635                 spec->init_hook = alc668_restore_default_value;
12636                 break;
12637         }
12638
12639         alc_pre_init(codec);
12640
12641         snd_hda_pick_fixup(codec, alc662_fixup_models,
12642                        alc662_fixup_tbl, alc662_fixups);
12643         snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
12644         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12645
12646         alc_auto_parse_customize_define(codec);
12647
12648         if (has_cdefine_beep(codec))
12649                 spec->gen.beep_nid = 0x01;
12650
12651         if ((alc_get_coef0(codec) & (1 << 14)) &&
12652             codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
12653             spec->cdefine.platform_type == 1) {
12654                 err = alc_codec_rename(codec, "ALC272X");
12655                 if (err < 0)
12656                         goto error;
12657         }
12658
12659         /* automatic parse from the BIOS config */
12660         err = alc662_parse_auto_config(codec);
12661         if (err < 0)
12662                 goto error;
12663
12664         if (!spec->gen.no_analog && spec->gen.beep_nid) {
12665                 switch (codec->core.vendor_id) {
12666                 case 0x10ec0662:
12667                         err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12668                         break;
12669                 case 0x10ec0272:
12670                 case 0x10ec0663:
12671                 case 0x10ec0665:
12672                 case 0x10ec0668:
12673                         err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
12674                         break;
12675                 case 0x10ec0273:
12676                         err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
12677                         break;
12678                 }
12679                 if (err < 0)
12680                         goto error;
12681         }
12682
12683         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12684
12685         return 0;
12686
12687  error:
12688         alc_free(codec);
12689         return err;
12690 }
12691
12692 /*
12693  * ALC680 support
12694  */
12695
12696 static int alc680_parse_auto_config(struct hda_codec *codec)
12697 {
12698         return alc_parse_auto_config(codec, NULL, NULL);
12699 }
12700
12701 /*
12702  */
12703 static int patch_alc680(struct hda_codec *codec)
12704 {
12705         int err;
12706
12707         /* ALC680 has no aa-loopback mixer */
12708         err = alc_alloc_spec(codec, 0);
12709         if (err < 0)
12710                 return err;
12711
12712         /* automatic parse from the BIOS config */
12713         err = alc680_parse_auto_config(codec);
12714         if (err < 0) {
12715                 alc_free(codec);
12716                 return err;
12717         }
12718
12719         return 0;
12720 }
12721
12722 /*
12723  * patch entries
12724  */
12725 static const struct hda_device_id snd_hda_id_realtek[] = {
12726         HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
12727         HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
12728         HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
12729         HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
12730         HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269),
12731         HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
12732         HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
12733         HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
12734         HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
12735         HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
12736         HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
12737         HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
12738         HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
12739         HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
12740         HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
12741         HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
12742         HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
12743         HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
12744         HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
12745         HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
12746         HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
12747         HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
12748         HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
12749         HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
12750         HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
12751         HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
12752         HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
12753         HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
12754         HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
12755         HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
12756         HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
12757         HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
12758         HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
12759         HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
12760         HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
12761         HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
12762         HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
12763         HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
12764         HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
12765         HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
12766         HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
12767         HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
12768         HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
12769         HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
12770         HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
12771         HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
12772         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
12773         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
12774         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
12775         HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
12776         HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
12777         HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
12778         HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
12779         HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
12780         HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
12781         HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
12782         HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
12783         HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
12784         HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
12785         HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
12786         HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
12787         HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
12788         HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
12789         HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
12790         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
12791         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
12792         HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
12793         HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
12794         HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
12795         HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
12796         HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
12797         HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
12798         HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662),
12799         HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
12800         HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
12801         HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
12802         HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
12803         HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
12804         HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
12805         {} /* terminator */
12806 };
12807 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
12808
12809 MODULE_LICENSE("GPL");
12810 MODULE_DESCRIPTION("Realtek HD-audio codec");
12811 MODULE_IMPORT_NS(SND_HDA_SCODEC_COMPONENT);
12812
12813 static struct hda_codec_driver realtek_driver = {
12814         .id = snd_hda_id_realtek,
12815 };
12816
12817 module_hda_codec_driver(realtek_driver);