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/init.h>
  14 #include <linux/delay.h>
  15 #include <linux/slab.h>
  16 #include <linux/pci.h>
  17 #include <linux/dmi.h>
  18 #include <linux/module.h>
  19 #include <linux/input.h>
  20 #include <linux/leds.h>
  21 #include <linux/ctype.h>
  22 #include <sound/core.h>
  23 #include <sound/jack.h>
  24 #include <sound/hda_codec.h>
  25 #include "hda_local.h"
  26 #include "hda_auto_parser.h"
  27 #include "hda_jack.h"
  28 #include "hda_generic.h"
  29 #include "hda_component.h"
  30
  31 /* keep halting ALC5505 DSP, for power saving */
  32 #define HALT_REALTEK_ALC5505
  33
  34 /* extra amp-initialization sequence types */
  35 enum {
  36         ALC_INIT_UNDEFINED,
  37         ALC_INIT_NONE,
  38         ALC_INIT_DEFAULT,
  39 };
  40
  41 enum {
  42         ALC_HEADSET_MODE_UNKNOWN,
  43         ALC_HEADSET_MODE_UNPLUGGED,
  44         ALC_HEADSET_MODE_HEADSET,
  45         ALC_HEADSET_MODE_MIC,
  46         ALC_HEADSET_MODE_HEADPHONE,
  47 };
  48
  49 enum {
  50         ALC_HEADSET_TYPE_UNKNOWN,
  51         ALC_HEADSET_TYPE_CTIA,
  52         ALC_HEADSET_TYPE_OMTP,
  53 };
  54
  55 enum {
  56         ALC_KEY_MICMUTE_INDEX,
  57 };
  58
  59 struct alc_customize_define {
  60         unsigned int  sku_cfg;
  61         unsigned char port_connectivity;
  62         unsigned char check_sum;
  63         unsigned char customization;
  64         unsigned char external_amp;
  65         unsigned int  enable_pcbeep:1;
  66         unsigned int  platform_type:1;
  67         unsigned int  swap:1;
  68         unsigned int  override:1;
  69         unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
  70 };
  71
  72 struct alc_coef_led {
  73         unsigned int idx;
  74         unsigned int mask;
  75         unsigned int on;
  76         unsigned int off;
  77 };
  78
  79 struct alc_spec {
  80         struct hda_gen_spec gen; /* must be at head */
  81
  82         /* codec parameterization */
  83         struct alc_customize_define cdefine;
  84         unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
  85
  86         /* GPIO bits */
  87         unsigned int gpio_mask;
  88         unsigned int gpio_dir;
  89         unsigned int gpio_data;
  90         bool gpio_write_delay;  /* add a delay before writing gpio_data */
  91
  92         /* mute LED for HP laptops, see vref_mute_led_set() */
  93         int mute_led_polarity;
  94         int micmute_led_polarity;
  95         hda_nid_t mute_led_nid;
  96         hda_nid_t cap_mute_led_nid;
  97
  98         unsigned int gpio_mute_led_mask;
  99         unsigned int gpio_mic_led_mask;
 100         struct alc_coef_led mute_led_coef;
 101         struct alc_coef_led mic_led_coef;
 102         struct mutex coef_mutex;
 103
 104         hda_nid_t headset_mic_pin;
 105         hda_nid_t headphone_mic_pin;
 106         int current_headset_mode;
 107         int current_headset_type;
 108
 109         /* hooks */
 110         void (*init_hook)(struct hda_codec *codec);
 111 #ifdef CONFIG_PM
 112         void (*power_hook)(struct hda_codec *codec);
 113 #endif
 114         void (*shutup)(struct hda_codec *codec);
 115
 116         int init_amp;
 117         int codec_variant;      /* flag for other variants */
 118         unsigned int has_alc5505_dsp:1;
 119         unsigned int no_depop_delay:1;
 120         unsigned int done_hp_init:1;
 121         unsigned int no_shutup_pins:1;
 122         unsigned int ultra_low_power:1;
 123         unsigned int has_hs_key:1;
 124         unsigned int no_internal_mic_pin:1;
 125         unsigned int en_3kpull_low:1;
 126
 127         /* for PLL fix */
 128         hda_nid_t pll_nid;
 129         unsigned int pll_coef_idx, pll_coef_bit;
 130         unsigned int coef0;
 131         struct input_dev *kb_dev;
 132         u8 alc_mute_keycode_map[1];
 133
 134         /* component binding */
 135         struct component_match *match;
 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 0x10ec0230:
 442         case 0x10ec0233:
 443         case 0x10ec0235:
 444         case 0x10ec0236:
 445         case 0x10ec0245:
 446         case 0x10ec0255:
 447         case 0x10ec0256:
 448         case 0x19e58326:
 449         case 0x10ec0257:
 450         case 0x10ec0282:
 451         case 0x10ec0283:
 452         case 0x10ec0286:
 453         case 0x10ec0288:
 454         case 0x10ec0285:
 455         case 0x10ec0298:
 456         case 0x10ec0289:
 457         case 0x10ec0300:
 458                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 459                 break;
 460         case 0x10ec0275:
 461                 alc_update_coef_idx(codec, 0xe, 0, 1<<0);
 462                 break;
 463         case 0x10ec0287:
 464                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
 465                 alc_write_coef_idx(codec, 0x8, 0x4ab7);
 466                 break;
 467         case 0x10ec0293:
 468                 alc_update_coef_idx(codec, 0xa, 1<<13, 0);
 469                 break;
 470         case 0x10ec0234:
 471         case 0x10ec0274:
 472         case 0x10ec0294:
 473         case 0x10ec0700:
 474         case 0x10ec0701:
 475         case 0x10ec0703:
 476         case 0x10ec0711:
 477                 alc_update_coef_idx(codec, 0x10, 1<<15, 0);
 478                 break;
 479         case 0x10ec0662:
 480                 if ((coef & 0x00f0) == 0x0030)
 481                         alc_update_coef_idx(codec, 0x4, 1<<10, 0); /* EAPD Ctrl */
 482                 break;
 483         case 0x10ec0272:
 484         case 0x10ec0273:
 485         case 0x10ec0663:
 486         case 0x10ec0665:
 487         case 0x10ec0670:
 488         case 0x10ec0671:
 489         case 0x10ec0672:
 490                 alc_update_coef_idx(codec, 0xd, 0, 1<<14); /* EAPD Ctrl */
 491                 break;
 492         case 0x10ec0222:
 493         case 0x10ec0623:
 494                 alc_update_coef_idx(codec, 0x19, 1<<13, 0);
 495                 break;
 496         case 0x10ec0668:
 497                 alc_update_coef_idx(codec, 0x7, 3<<13, 0);
 498                 break;
 499         case 0x10ec0867:
 500                 alc_update_coef_idx(codec, 0x4, 1<<10, 0);
 501                 break;
 502         case 0x10ec0888:
 503                 if ((coef & 0x00f0) == 0x0020 || (coef & 0x00f0) == 0x0030)
 504                         alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 505                 break;
 506         case 0x10ec0892:
 507         case 0x10ec0897:
 508                 alc_update_coef_idx(codec, 0x7, 1<<5, 0);
 509                 break;
 510         case 0x10ec0899:
 511         case 0x10ec0900:
 512         case 0x10ec0b00:
 513         case 0x10ec1168:
 514         case 0x10ec1220:
 515                 alc_update_coef_idx(codec, 0x7, 1<<1, 0);
 516                 break;
 517         }
 518 }
 519
 520 /* additional initialization for ALC888 variants */
 521 static void alc888_coef_init(struct hda_codec *codec)
 522 {
 523         switch (alc_get_coef0(codec) & 0x00f0) {
 524         /* alc888-VA */
 525         case 0x00:
 526         /* alc888-VB */
 527         case 0x10:
 528                 alc_update_coef_idx(codec, 7, 0, 0x2030); /* Turn EAPD to High */
 529                 break;
 530         }
 531 }
 532
 533 /* turn on/off EAPD control (only if available) */
 534 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
 535 {
 536         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 537                 return;
 538         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
 539                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 540                                     on ? 2 : 0);
 541 }
 542
 543 /* turn on/off EAPD controls of the codec */
 544 static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
 545 {
 546         /* We currently only handle front, HP */
 547         static const hda_nid_t pins[] = {
 548                 0x0f, 0x10, 0x14, 0x15, 0x17, 0
 549         };
 550         const hda_nid_t *p;
 551         for (p = pins; *p; p++)
 552                 set_eapd(codec, *p, on);
 553 }
 554
 555 static int find_ext_mic_pin(struct hda_codec *codec);
 556
 557 static void alc_headset_mic_no_shutup(struct hda_codec *codec)
 558 {
 559         const struct hda_pincfg *pin;
 560         int mic_pin = find_ext_mic_pin(codec);
 561         int i;
 562
 563         /* don't shut up pins when unloading the driver; otherwise it breaks
 564          * the default pin setup at the next load of the driver
 565          */
 566         if (codec->bus->shutdown)
 567                 return;
 568
 569         snd_array_for_each(&codec->init_pins, i, pin) {
 570                 /* use read here for syncing after issuing each verb */
 571                 if (pin->nid != mic_pin)
 572                         snd_hda_codec_read(codec, pin->nid, 0,
 573                                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
 574         }
 575
 576         codec->pins_shutup = 1;
 577 }
 578
 579 static void alc_shutup_pins(struct hda_codec *codec)
 580 {
 581         struct alc_spec *spec = codec->spec;
 582
 583         switch (codec->core.vendor_id) {
 584         case 0x10ec0236:
 585         case 0x10ec0256:
 586         case 0x19e58326:
 587         case 0x10ec0283:
 588         case 0x10ec0286:
 589         case 0x10ec0288:
 590         case 0x10ec0298:
 591                 alc_headset_mic_no_shutup(codec);
 592                 break;
 593         default:
 594                 if (!spec->no_shutup_pins)
 595                         snd_hda_shutup_pins(codec);
 596                 break;
 597         }
 598 }
 599
 600 /* generic shutup callback;
 601  * just turning off EAPD and a little pause for avoiding pop-noise
 602  */
 603 static void alc_eapd_shutup(struct hda_codec *codec)
 604 {
 605         struct alc_spec *spec = codec->spec;
 606
 607         alc_auto_setup_eapd(codec, false);
 608         if (!spec->no_depop_delay)
 609                 msleep(200);
 610         alc_shutup_pins(codec);
 611 }
 612
 613 /* generic EAPD initialization */
 614 static void alc_auto_init_amp(struct hda_codec *codec, int type)
 615 {
 616         alc_auto_setup_eapd(codec, true);
 617         alc_write_gpio(codec);
 618         switch (type) {
 619         case ALC_INIT_DEFAULT:
 620                 switch (codec->core.vendor_id) {
 621                 case 0x10ec0260:
 622                         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x2010);
 623                         break;
 624                 case 0x10ec0880:
 625                 case 0x10ec0882:
 626                 case 0x10ec0883:
 627                 case 0x10ec0885:
 628                         alc_update_coef_idx(codec, 7, 0, 0x2030);
 629                         break;
 630                 case 0x10ec0888:
 631                         alc888_coef_init(codec);
 632                         break;
 633                 }
 634                 break;
 635         }
 636 }
 637
 638 /* get a primary headphone pin if available */
 639 static hda_nid_t alc_get_hp_pin(struct alc_spec *spec)
 640 {
 641         if (spec->gen.autocfg.hp_pins[0])
 642                 return spec->gen.autocfg.hp_pins[0];
 643         if (spec->gen.autocfg.line_out_type == AC_JACK_HP_OUT)
 644                 return spec->gen.autocfg.line_out_pins[0];
 645         return 0;
 646 }
 647
 648 /*
 649  * Realtek SSID verification
 650  */
 651
 652 /* Could be any non-zero and even value. When used as fixup, tells
 653  * the driver to ignore any present sku defines.
 654  */
 655 #define ALC_FIXUP_SKU_IGNORE (2)
 656
 657 static void alc_fixup_sku_ignore(struct hda_codec *codec,
 658                                  const struct hda_fixup *fix, int action)
 659 {
 660         struct alc_spec *spec = codec->spec;
 661         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 662                 spec->cdefine.fixup = 1;
 663                 spec->cdefine.sku_cfg = ALC_FIXUP_SKU_IGNORE;
 664         }
 665 }
 666
 667 static void alc_fixup_no_depop_delay(struct hda_codec *codec,
 668                                     const struct hda_fixup *fix, int action)
 669 {
 670         struct alc_spec *spec = codec->spec;
 671
 672         if (action == HDA_FIXUP_ACT_PROBE) {
 673                 spec->no_depop_delay = 1;
 674                 codec->depop_delay = 0;
 675         }
 676 }
 677
 678 static int alc_auto_parse_customize_define(struct hda_codec *codec)
 679 {
 680         unsigned int ass, tmp, i;
 681         unsigned nid = 0;
 682         struct alc_spec *spec = codec->spec;
 683
 684         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
 685
 686         if (spec->cdefine.fixup) {
 687                 ass = spec->cdefine.sku_cfg;
 688                 if (ass == ALC_FIXUP_SKU_IGNORE)
 689                         return -1;
 690                 goto do_sku;
 691         }
 692
 693         if (!codec->bus->pci)
 694                 return -1;
 695         ass = codec->core.subsystem_id & 0xffff;
 696         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
 697                 goto do_sku;
 698
 699         nid = 0x1d;
 700         if (codec->core.vendor_id == 0x10ec0260)
 701                 nid = 0x17;
 702         ass = snd_hda_codec_get_pincfg(codec, nid);
 703
 704         if (!(ass & 1)) {
 705                 codec_info(codec, "%s: SKU not ready 0x%08x\n",
 706                            codec->core.chip_name, ass);
 707                 return -1;
 708         }
 709
 710         /* check sum */
 711         tmp = 0;
 712         for (i = 1; i < 16; i++) {
 713                 if ((ass >> i) & 1)
 714                         tmp++;
 715         }
 716         if (((ass >> 16) & 0xf) != tmp)
 717                 return -1;
 718
 719         spec->cdefine.port_connectivity = ass >> 30;
 720         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
 721         spec->cdefine.check_sum = (ass >> 16) & 0xf;
 722         spec->cdefine.customization = ass >> 8;
 723 do_sku:
 724         spec->cdefine.sku_cfg = ass;
 725         spec->cdefine.external_amp = (ass & 0x38) >> 3;
 726         spec->cdefine.platform_type = (ass & 0x4) >> 2;
 727         spec->cdefine.swap = (ass & 0x2) >> 1;
 728         spec->cdefine.override = ass & 0x1;
 729
 730         codec_dbg(codec, "SKU: Nid=0x%x sku_cfg=0x%08x\n",
 731                    nid, spec->cdefine.sku_cfg);
 732         codec_dbg(codec, "SKU: port_connectivity=0x%x\n",
 733                    spec->cdefine.port_connectivity);
 734         codec_dbg(codec, "SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
 735         codec_dbg(codec, "SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
 736         codec_dbg(codec, "SKU: customization=0x%08x\n", spec->cdefine.customization);
 737         codec_dbg(codec, "SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
 738         codec_dbg(codec, "SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
 739         codec_dbg(codec, "SKU: swap=0x%x\n", spec->cdefine.swap);
 740         codec_dbg(codec, "SKU: override=0x%x\n", spec->cdefine.override);
 741
 742         return 0;
 743 }
 744
 745 /* return the position of NID in the list, or -1 if not found */
 746 static int find_idx_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 747 {
 748         int i;
 749         for (i = 0; i < nums; i++)
 750                 if (list[i] == nid)
 751                         return i;
 752         return -1;
 753 }
 754 /* return true if the given NID is found in the list */
 755 static bool found_in_nid_list(hda_nid_t nid, const hda_nid_t *list, int nums)
 756 {
 757         return find_idx_in_nid_list(nid, list, nums) >= 0;
 758 }
 759
 760 /* check subsystem ID and set up device-specific initialization;
 761  * return 1 if initialized, 0 if invalid SSID
 762  */
 763 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
 764  *      31 ~ 16 :       Manufacture ID
 765  *      15 ~ 8  :       SKU ID
 766  *      7  ~ 0  :       Assembly ID
 767  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
 768  */
 769 static int alc_subsystem_id(struct hda_codec *codec, const hda_nid_t *ports)
 770 {
 771         unsigned int ass, tmp, i;
 772         unsigned nid;
 773         struct alc_spec *spec = codec->spec;
 774
 775         if (spec->cdefine.fixup) {
 776                 ass = spec->cdefine.sku_cfg;
 777                 if (ass == ALC_FIXUP_SKU_IGNORE)
 778                         return 0;
 779                 goto do_sku;
 780         }
 781
 782         ass = codec->core.subsystem_id & 0xffff;
 783         if (codec->bus->pci &&
 784             ass != codec->bus->pci->subsystem_device && (ass & 1))
 785                 goto do_sku;
 786
 787         /* invalid SSID, check the special NID pin defcfg instead */
 788         /*
 789          * 31~30        : port connectivity
 790          * 29~21        : reserve
 791          * 20           : PCBEEP input
 792          * 19~16        : Check sum (15:1)
 793          * 15~1         : Custom
 794          * 0            : override
 795         */
 796         nid = 0x1d;
 797         if (codec->core.vendor_id == 0x10ec0260)
 798                 nid = 0x17;
 799         ass = snd_hda_codec_get_pincfg(codec, nid);
 800         codec_dbg(codec,
 801                   "realtek: No valid SSID, checking pincfg 0x%08x for NID 0x%x\n",
 802                    ass, nid);
 803         if (!(ass & 1))
 804                 return 0;
 805         if ((ass >> 30) != 1)   /* no physical connection */
 806                 return 0;
 807
 808         /* check sum */
 809         tmp = 0;
 810         for (i = 1; i < 16; i++) {
 811                 if ((ass >> i) & 1)
 812                         tmp++;
 813         }
 814         if (((ass >> 16) & 0xf) != tmp)
 815                 return 0;
 816 do_sku:
 817         codec_dbg(codec, "realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
 818                    ass & 0xffff, codec->core.vendor_id);
 819         /*
 820          * 0 : override
 821          * 1 :  Swap Jack
 822          * 2 : 0 --> Desktop, 1 --> Laptop
 823          * 3~5 : External Amplifier control
 824          * 7~6 : Reserved
 825         */
 826         tmp = (ass & 0x38) >> 3;        /* external Amp control */
 827         if (spec->init_amp == ALC_INIT_UNDEFINED) {
 828                 switch (tmp) {
 829                 case 1:
 830                         alc_setup_gpio(codec, 0x01);
 831                         break;
 832                 case 3:
 833                         alc_setup_gpio(codec, 0x02);
 834                         break;
 835                 case 7:
 836                         alc_setup_gpio(codec, 0x04);
 837                         break;
 838                 case 5:
 839                 default:
 840                         spec->init_amp = ALC_INIT_DEFAULT;
 841                         break;
 842                 }
 843         }
 844
 845         /* is laptop or Desktop and enable the function "Mute internal speaker
 846          * when the external headphone out jack is plugged"
 847          */
 848         if (!(ass & 0x8000))
 849                 return 1;
 850         /*
 851          * 10~8 : Jack location
 852          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
 853          * 14~13: Resvered
 854          * 15   : 1 --> enable the function "Mute internal speaker
 855          *              when the external headphone out jack is plugged"
 856          */
 857         if (!alc_get_hp_pin(spec)) {
 858                 hda_nid_t nid;
 859                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
 860                 nid = ports[tmp];
 861                 if (found_in_nid_list(nid, spec->gen.autocfg.line_out_pins,
 862                                       spec->gen.autocfg.line_outs))
 863                         return 1;
 864                 spec->gen.autocfg.hp_pins[0] = nid;
 865         }
 866         return 1;
 867 }
 868
 869 /* Check the validity of ALC subsystem-id
 870  * ports contains an array of 4 pin NIDs for port-A, E, D and I */
 871 static void alc_ssid_check(struct hda_codec *codec, const hda_nid_t *ports)
 872 {
 873         if (!alc_subsystem_id(codec, ports)) {
 874                 struct alc_spec *spec = codec->spec;
 875                 if (spec->init_amp == ALC_INIT_UNDEFINED) {
 876                         codec_dbg(codec,
 877                                   "realtek: Enable default setup for auto mode as fallback\n");
 878                         spec->init_amp = ALC_INIT_DEFAULT;
 879                 }
 880         }
 881 }
 882
 883 /*
 884  */
 885
 886 static void alc_fixup_inv_dmic(struct hda_codec *codec,
 887                                const struct hda_fixup *fix, int action)
 888 {
 889         struct alc_spec *spec = codec->spec;
 890
 891         spec->gen.inv_dmic_split = 1;
 892 }
 893
 894
 895 static int alc_build_controls(struct hda_codec *codec)
 896 {
 897         int err;
 898
 899         err = snd_hda_gen_build_controls(codec);
 900         if (err < 0)
 901                 return err;
 902
 903         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_BUILD);
 904         return 0;
 905 }
 906
 907
 908 /*
 909  * Common callbacks
 910  */
 911
 912 static void alc_pre_init(struct hda_codec *codec)
 913 {
 914         alc_fill_eapd_coef(codec);
 915 }
 916
 917 #define is_s3_resume(codec) \
 918         ((codec)->core.dev.power.power_state.event == PM_EVENT_RESUME)
 919 #define is_s4_resume(codec) \
 920         ((codec)->core.dev.power.power_state.event == PM_EVENT_RESTORE)
 921
 922 static int alc_init(struct hda_codec *codec)
 923 {
 924         struct alc_spec *spec = codec->spec;
 925
 926         /* hibernation resume needs the full chip initialization */
 927         if (is_s4_resume(codec))
 928                 alc_pre_init(codec);
 929
 930         if (spec->init_hook)
 931                 spec->init_hook(codec);
 932
 933         spec->gen.skip_verbs = 1; /* applied in below */
 934         snd_hda_gen_init(codec);
 935         alc_fix_pll(codec);
 936         alc_auto_init_amp(codec, spec->init_amp);
 937         snd_hda_apply_verbs(codec); /* apply verbs here after own init */
 938
 939         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
 940
 941         return 0;
 942 }
 943
 944 #define alc_free        snd_hda_gen_free
 945
 946 #ifdef CONFIG_PM
 947 static inline void alc_shutup(struct hda_codec *codec)
 948 {
 949         struct alc_spec *spec = codec->spec;
 950
 951         if (!snd_hda_get_bool_hint(codec, "shutup"))
 952                 return; /* disabled explicitly by hints */
 953
 954         if (spec && spec->shutup)
 955                 spec->shutup(codec);
 956         else
 957                 alc_shutup_pins(codec);
 958 }
 959
 960 static void alc_power_eapd(struct hda_codec *codec)
 961 {
 962         alc_auto_setup_eapd(codec, false);
 963 }
 964
 965 static int alc_suspend(struct hda_codec *codec)
 966 {
 967         struct alc_spec *spec = codec->spec;
 968         alc_shutup(codec);
 969         if (spec && spec->power_hook)
 970                 spec->power_hook(codec);
 971         return 0;
 972 }
 973
 974 static int alc_resume(struct hda_codec *codec)
 975 {
 976         struct alc_spec *spec = codec->spec;
 977
 978         if (!spec->no_depop_delay)
 979                 msleep(150); /* to avoid pop noise */
 980         codec->patch_ops.init(codec);
 981         snd_hda_regmap_sync(codec);
 982         hda_call_check_power_status(codec, 0x01);
 983         return 0;
 984 }
 985 #endif
 986
 987 /*
 988  */
 989 static const struct hda_codec_ops alc_patch_ops = {
 990         .build_controls = alc_build_controls,
 991         .build_pcms = snd_hda_gen_build_pcms,
 992         .init = alc_init,
 993         .free = alc_free,
 994         .unsol_event = snd_hda_jack_unsol_event,
 995 #ifdef CONFIG_PM
 996         .resume = alc_resume,
 997         .suspend = alc_suspend,
 998         .check_power_status = snd_hda_gen_check_power_status,
 999 #endif
1000 };
1001
1002
1003 #define alc_codec_rename(codec, name) snd_hda_codec_set_name(codec, name)
1004
1005 /*
1006  * Rename codecs appropriately from COEF value or subvendor id
1007  */
1008 struct alc_codec_rename_table {
1009         unsigned int vendor_id;
1010         unsigned short coef_mask;
1011         unsigned short coef_bits;
1012         const char *name;
1013 };
1014
1015 struct alc_codec_rename_pci_table {
1016         unsigned int codec_vendor_id;
1017         unsigned short pci_subvendor;
1018         unsigned short pci_subdevice;
1019         const char *name;
1020 };
1021
1022 static const struct alc_codec_rename_table rename_tbl[] = {
1023         { 0x10ec0221, 0xf00f, 0x1003, "ALC231" },
1024         { 0x10ec0269, 0xfff0, 0x3010, "ALC277" },
1025         { 0x10ec0269, 0xf0f0, 0x2010, "ALC259" },
1026         { 0x10ec0269, 0xf0f0, 0x3010, "ALC258" },
1027         { 0x10ec0269, 0x00f0, 0x0010, "ALC269VB" },
1028         { 0x10ec0269, 0xffff, 0xa023, "ALC259" },
1029         { 0x10ec0269, 0xffff, 0x6023, "ALC281X" },
1030         { 0x10ec0269, 0x00f0, 0x0020, "ALC269VC" },
1031         { 0x10ec0269, 0x00f0, 0x0030, "ALC269VD" },
1032         { 0x10ec0662, 0xffff, 0x4020, "ALC656" },
1033         { 0x10ec0887, 0x00f0, 0x0030, "ALC887-VD" },
1034         { 0x10ec0888, 0x00f0, 0x0030, "ALC888-VD" },
1035         { 0x10ec0888, 0xf0f0, 0x3020, "ALC886" },
1036         { 0x10ec0899, 0x2000, 0x2000, "ALC899" },
1037         { 0x10ec0892, 0xffff, 0x8020, "ALC661" },
1038         { 0x10ec0892, 0xffff, 0x8011, "ALC661" },
1039         { 0x10ec0892, 0xffff, 0x4011, "ALC656" },
1040         { } /* terminator */
1041 };
1042
1043 static const struct alc_codec_rename_pci_table rename_pci_tbl[] = {
1044         { 0x10ec0280, 0x1028, 0, "ALC3220" },
1045         { 0x10ec0282, 0x1028, 0, "ALC3221" },
1046         { 0x10ec0283, 0x1028, 0, "ALC3223" },
1047         { 0x10ec0288, 0x1028, 0, "ALC3263" },
1048         { 0x10ec0292, 0x1028, 0, "ALC3226" },
1049         { 0x10ec0293, 0x1028, 0, "ALC3235" },
1050         { 0x10ec0255, 0x1028, 0, "ALC3234" },
1051         { 0x10ec0668, 0x1028, 0, "ALC3661" },
1052         { 0x10ec0275, 0x1028, 0, "ALC3260" },
1053         { 0x10ec0899, 0x1028, 0, "ALC3861" },
1054         { 0x10ec0298, 0x1028, 0, "ALC3266" },
1055         { 0x10ec0236, 0x1028, 0, "ALC3204" },
1056         { 0x10ec0256, 0x1028, 0, "ALC3246" },
1057         { 0x10ec0225, 0x1028, 0, "ALC3253" },
1058         { 0x10ec0295, 0x1028, 0, "ALC3254" },
1059         { 0x10ec0299, 0x1028, 0, "ALC3271" },
1060         { 0x10ec0670, 0x1025, 0, "ALC669X" },
1061         { 0x10ec0676, 0x1025, 0, "ALC679X" },
1062         { 0x10ec0282, 0x1043, 0, "ALC3229" },
1063         { 0x10ec0233, 0x1043, 0, "ALC3236" },
1064         { 0x10ec0280, 0x103c, 0, "ALC3228" },
1065         { 0x10ec0282, 0x103c, 0, "ALC3227" },
1066         { 0x10ec0286, 0x103c, 0, "ALC3242" },
1067         { 0x10ec0290, 0x103c, 0, "ALC3241" },
1068         { 0x10ec0668, 0x103c, 0, "ALC3662" },
1069         { 0x10ec0283, 0x17aa, 0, "ALC3239" },
1070         { 0x10ec0292, 0x17aa, 0, "ALC3232" },
1071         { } /* terminator */
1072 };
1073
1074 static int alc_codec_rename_from_preset(struct hda_codec *codec)
1075 {
1076         const struct alc_codec_rename_table *p;
1077         const struct alc_codec_rename_pci_table *q;
1078
1079         for (p = rename_tbl; p->vendor_id; p++) {
1080                 if (p->vendor_id != codec->core.vendor_id)
1081                         continue;
1082                 if ((alc_get_coef0(codec) & p->coef_mask) == p->coef_bits)
1083                         return alc_codec_rename(codec, p->name);
1084         }
1085
1086         if (!codec->bus->pci)
1087                 return 0;
1088         for (q = rename_pci_tbl; q->codec_vendor_id; q++) {
1089                 if (q->codec_vendor_id != codec->core.vendor_id)
1090                         continue;
1091                 if (q->pci_subvendor != codec->bus->pci->subsystem_vendor)
1092                         continue;
1093                 if (!q->pci_subdevice ||
1094                     q->pci_subdevice == codec->bus->pci->subsystem_device)
1095                         return alc_codec_rename(codec, q->name);
1096         }
1097
1098         return 0;
1099 }
1100
1101
1102 /*
1103  * Digital-beep handlers
1104  */
1105 #ifdef CONFIG_SND_HDA_INPUT_BEEP
1106
1107 /* additional beep mixers; private_value will be overwritten */
1108 static const struct snd_kcontrol_new alc_beep_mixer[] = {
1109         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
1110         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
1111 };
1112
1113 /* set up and create beep controls */
1114 static int set_beep_amp(struct alc_spec *spec, hda_nid_t nid,
1115                         int idx, int dir)
1116 {
1117         struct snd_kcontrol_new *knew;
1118         unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir);
1119         int i;
1120
1121         for (i = 0; i < ARRAY_SIZE(alc_beep_mixer); i++) {
1122                 knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
1123                                             &alc_beep_mixer[i]);
1124                 if (!knew)
1125                         return -ENOMEM;
1126                 knew->private_value = beep_amp;
1127         }
1128         return 0;
1129 }
1130
1131 static const struct snd_pci_quirk beep_allow_list[] = {
1132         SND_PCI_QUIRK(0x1043, 0x103c, "ASUS", 1),
1133         SND_PCI_QUIRK(0x1043, 0x115d, "ASUS", 1),
1134         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
1135         SND_PCI_QUIRK(0x1043, 0x8376, "EeePC", 1),
1136         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
1137         SND_PCI_QUIRK(0x1043, 0x831a, "EeePC", 1),
1138         SND_PCI_QUIRK(0x1043, 0x834a, "EeePC", 1),
1139         SND_PCI_QUIRK(0x1458, 0xa002, "GA-MA790X", 1),
1140         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
1141         /* denylist -- no beep available */
1142         SND_PCI_QUIRK(0x17aa, 0x309e, "Lenovo ThinkCentre M73", 0),
1143         SND_PCI_QUIRK(0x17aa, 0x30a3, "Lenovo ThinkCentre M93", 0),
1144         {}
1145 };
1146
1147 static inline int has_cdefine_beep(struct hda_codec *codec)
1148 {
1149         struct alc_spec *spec = codec->spec;
1150         const struct snd_pci_quirk *q;
1151         q = snd_pci_quirk_lookup(codec->bus->pci, beep_allow_list);
1152         if (q)
1153                 return q->value;
1154         return spec->cdefine.enable_pcbeep;
1155 }
1156 #else
1157 #define set_beep_amp(spec, nid, idx, dir)       0
1158 #define has_cdefine_beep(codec)         0
1159 #endif
1160
1161 /* parse the BIOS configuration and set up the alc_spec */
1162 /* return 1 if successful, 0 if the proper config is not found,
1163  * or a negative error code
1164  */
1165 static int alc_parse_auto_config(struct hda_codec *codec,
1166                                  const hda_nid_t *ignore_nids,
1167                                  const hda_nid_t *ssid_nids)
1168 {
1169         struct alc_spec *spec = codec->spec;
1170         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
1171         int err;
1172
1173         err = snd_hda_parse_pin_defcfg(codec, cfg, ignore_nids,
1174                                        spec->parse_flags);
1175         if (err < 0)
1176                 return err;
1177
1178         if (ssid_nids)
1179                 alc_ssid_check(codec, ssid_nids);
1180
1181         err = snd_hda_gen_parse_auto_config(codec, cfg);
1182         if (err < 0)
1183                 return err;
1184
1185         return 1;
1186 }
1187
1188 /* common preparation job for alc_spec */
1189 static int alc_alloc_spec(struct hda_codec *codec, hda_nid_t mixer_nid)
1190 {
1191         struct alc_spec *spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1192         int err;
1193
1194         if (!spec)
1195                 return -ENOMEM;
1196         codec->spec = spec;
1197         snd_hda_gen_spec_init(&spec->gen);
1198         spec->gen.mixer_nid = mixer_nid;
1199         spec->gen.own_eapd_ctl = 1;
1200         codec->single_adc_amp = 1;
1201         /* FIXME: do we need this for all Realtek codec models? */
1202         codec->spdif_status_reset = 1;
1203         codec->forced_resume = 1;
1204         codec->patch_ops = alc_patch_ops;
1205         mutex_init(&spec->coef_mutex);
1206
1207         err = alc_codec_rename_from_preset(codec);
1208         if (err < 0) {
1209                 kfree(spec);
1210                 return err;
1211         }
1212         return 0;
1213 }
1214
1215 static int alc880_parse_auto_config(struct hda_codec *codec)
1216 {
1217         static const hda_nid_t alc880_ignore[] = { 0x1d, 0 };
1218         static const hda_nid_t alc880_ssids[] = { 0x15, 0x1b, 0x14, 0 };
1219         return alc_parse_auto_config(codec, alc880_ignore, alc880_ssids);
1220 }
1221
1222 /*
1223  * ALC880 fix-ups
1224  */
1225 enum {
1226         ALC880_FIXUP_GPIO1,
1227         ALC880_FIXUP_GPIO2,
1228         ALC880_FIXUP_MEDION_RIM,
1229         ALC880_FIXUP_LG,
1230         ALC880_FIXUP_LG_LW25,
1231         ALC880_FIXUP_W810,
1232         ALC880_FIXUP_EAPD_COEF,
1233         ALC880_FIXUP_TCL_S700,
1234         ALC880_FIXUP_VOL_KNOB,
1235         ALC880_FIXUP_FUJITSU,
1236         ALC880_FIXUP_F1734,
1237         ALC880_FIXUP_UNIWILL,
1238         ALC880_FIXUP_UNIWILL_DIG,
1239         ALC880_FIXUP_Z71V,
1240         ALC880_FIXUP_ASUS_W5A,
1241         ALC880_FIXUP_3ST_BASE,
1242         ALC880_FIXUP_3ST,
1243         ALC880_FIXUP_3ST_DIG,
1244         ALC880_FIXUP_5ST_BASE,
1245         ALC880_FIXUP_5ST,
1246         ALC880_FIXUP_5ST_DIG,
1247         ALC880_FIXUP_6ST_BASE,
1248         ALC880_FIXUP_6ST,
1249         ALC880_FIXUP_6ST_DIG,
1250         ALC880_FIXUP_6ST_AUTOMUTE,
1251 };
1252
1253 /* enable the volume-knob widget support on NID 0x21 */
1254 static void alc880_fixup_vol_knob(struct hda_codec *codec,
1255                                   const struct hda_fixup *fix, int action)
1256 {
1257         if (action == HDA_FIXUP_ACT_PROBE)
1258                 snd_hda_jack_detect_enable_callback(codec, 0x21,
1259                                                     alc_update_knob_master);
1260 }
1261
1262 static const struct hda_fixup alc880_fixups[] = {
1263         [ALC880_FIXUP_GPIO1] = {
1264                 .type = HDA_FIXUP_FUNC,
1265                 .v.func = alc_fixup_gpio1,
1266         },
1267         [ALC880_FIXUP_GPIO2] = {
1268                 .type = HDA_FIXUP_FUNC,
1269                 .v.func = alc_fixup_gpio2,
1270         },
1271         [ALC880_FIXUP_MEDION_RIM] = {
1272                 .type = HDA_FIXUP_VERBS,
1273                 .v.verbs = (const struct hda_verb[]) {
1274                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1275                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1276                         { }
1277                 },
1278                 .chained = true,
1279                 .chain_id = ALC880_FIXUP_GPIO2,
1280         },
1281         [ALC880_FIXUP_LG] = {
1282                 .type = HDA_FIXUP_PINS,
1283                 .v.pins = (const struct hda_pintbl[]) {
1284                         /* disable bogus unused pins */
1285                         { 0x16, 0x411111f0 },
1286                         { 0x18, 0x411111f0 },
1287                         { 0x1a, 0x411111f0 },
1288                         { }
1289                 }
1290         },
1291         [ALC880_FIXUP_LG_LW25] = {
1292                 .type = HDA_FIXUP_PINS,
1293                 .v.pins = (const struct hda_pintbl[]) {
1294                         { 0x1a, 0x0181344f }, /* line-in */
1295                         { 0x1b, 0x0321403f }, /* headphone */
1296                         { }
1297                 }
1298         },
1299         [ALC880_FIXUP_W810] = {
1300                 .type = HDA_FIXUP_PINS,
1301                 .v.pins = (const struct hda_pintbl[]) {
1302                         /* disable bogus unused pins */
1303                         { 0x17, 0x411111f0 },
1304                         { }
1305                 },
1306                 .chained = true,
1307                 .chain_id = ALC880_FIXUP_GPIO2,
1308         },
1309         [ALC880_FIXUP_EAPD_COEF] = {
1310                 .type = HDA_FIXUP_VERBS,
1311                 .v.verbs = (const struct hda_verb[]) {
1312                         /* change to EAPD mode */
1313                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1314                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3060 },
1315                         {}
1316                 },
1317         },
1318         [ALC880_FIXUP_TCL_S700] = {
1319                 .type = HDA_FIXUP_VERBS,
1320                 .v.verbs = (const struct hda_verb[]) {
1321                         /* change to EAPD mode */
1322                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
1323                         { 0x20, AC_VERB_SET_PROC_COEF,  0x3070 },
1324                         {}
1325                 },
1326                 .chained = true,
1327                 .chain_id = ALC880_FIXUP_GPIO2,
1328         },
1329         [ALC880_FIXUP_VOL_KNOB] = {
1330                 .type = HDA_FIXUP_FUNC,
1331                 .v.func = alc880_fixup_vol_knob,
1332         },
1333         [ALC880_FIXUP_FUJITSU] = {
1334                 /* override all pins as BIOS on old Amilo is broken */
1335                 .type = HDA_FIXUP_PINS,
1336                 .v.pins = (const struct hda_pintbl[]) {
1337                         { 0x14, 0x0121401f }, /* HP */
1338                         { 0x15, 0x99030120 }, /* speaker */
1339                         { 0x16, 0x99030130 }, /* bass speaker */
1340                         { 0x17, 0x411111f0 }, /* N/A */
1341                         { 0x18, 0x411111f0 }, /* N/A */
1342                         { 0x19, 0x01a19950 }, /* mic-in */
1343                         { 0x1a, 0x411111f0 }, /* N/A */
1344                         { 0x1b, 0x411111f0 }, /* N/A */
1345                         { 0x1c, 0x411111f0 }, /* N/A */
1346                         { 0x1d, 0x411111f0 }, /* N/A */
1347                         { 0x1e, 0x01454140 }, /* SPDIF out */
1348                         { }
1349                 },
1350                 .chained = true,
1351                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1352         },
1353         [ALC880_FIXUP_F1734] = {
1354                 /* almost compatible with FUJITSU, but no bass and SPDIF */
1355                 .type = HDA_FIXUP_PINS,
1356                 .v.pins = (const struct hda_pintbl[]) {
1357                         { 0x14, 0x0121401f }, /* HP */
1358                         { 0x15, 0x99030120 }, /* speaker */
1359                         { 0x16, 0x411111f0 }, /* N/A */
1360                         { 0x17, 0x411111f0 }, /* N/A */
1361                         { 0x18, 0x411111f0 }, /* N/A */
1362                         { 0x19, 0x01a19950 }, /* mic-in */
1363                         { 0x1a, 0x411111f0 }, /* N/A */
1364                         { 0x1b, 0x411111f0 }, /* N/A */
1365                         { 0x1c, 0x411111f0 }, /* N/A */
1366                         { 0x1d, 0x411111f0 }, /* N/A */
1367                         { 0x1e, 0x411111f0 }, /* N/A */
1368                         { }
1369                 },
1370                 .chained = true,
1371                 .chain_id = ALC880_FIXUP_VOL_KNOB,
1372         },
1373         [ALC880_FIXUP_UNIWILL] = {
1374                 /* need to fix HP and speaker pins to be parsed correctly */
1375                 .type = HDA_FIXUP_PINS,
1376                 .v.pins = (const struct hda_pintbl[]) {
1377                         { 0x14, 0x0121411f }, /* HP */
1378                         { 0x15, 0x99030120 }, /* speaker */
1379                         { 0x16, 0x99030130 }, /* bass speaker */
1380                         { }
1381                 },
1382         },
1383         [ALC880_FIXUP_UNIWILL_DIG] = {
1384                 .type = HDA_FIXUP_PINS,
1385                 .v.pins = (const struct hda_pintbl[]) {
1386                         /* disable bogus unused pins */
1387                         { 0x17, 0x411111f0 },
1388                         { 0x19, 0x411111f0 },
1389                         { 0x1b, 0x411111f0 },
1390                         { 0x1f, 0x411111f0 },
1391                         { }
1392                 }
1393         },
1394         [ALC880_FIXUP_Z71V] = {
1395                 .type = HDA_FIXUP_PINS,
1396                 .v.pins = (const struct hda_pintbl[]) {
1397                         /* set up the whole pins as BIOS is utterly broken */
1398                         { 0x14, 0x99030120 }, /* speaker */
1399                         { 0x15, 0x0121411f }, /* HP */
1400                         { 0x16, 0x411111f0 }, /* N/A */
1401                         { 0x17, 0x411111f0 }, /* N/A */
1402                         { 0x18, 0x01a19950 }, /* mic-in */
1403                         { 0x19, 0x411111f0 }, /* N/A */
1404                         { 0x1a, 0x01813031 }, /* line-in */
1405                         { 0x1b, 0x411111f0 }, /* N/A */
1406                         { 0x1c, 0x411111f0 }, /* N/A */
1407                         { 0x1d, 0x411111f0 }, /* N/A */
1408                         { 0x1e, 0x0144111e }, /* SPDIF */
1409                         { }
1410                 }
1411         },
1412         [ALC880_FIXUP_ASUS_W5A] = {
1413                 .type = HDA_FIXUP_PINS,
1414                 .v.pins = (const struct hda_pintbl[]) {
1415                         /* set up the whole pins as BIOS is utterly broken */
1416                         { 0x14, 0x0121411f }, /* HP */
1417                         { 0x15, 0x411111f0 }, /* N/A */
1418                         { 0x16, 0x411111f0 }, /* N/A */
1419                         { 0x17, 0x411111f0 }, /* N/A */
1420                         { 0x18, 0x90a60160 }, /* mic */
1421                         { 0x19, 0x411111f0 }, /* N/A */
1422                         { 0x1a, 0x411111f0 }, /* N/A */
1423                         { 0x1b, 0x411111f0 }, /* N/A */
1424                         { 0x1c, 0x411111f0 }, /* N/A */
1425                         { 0x1d, 0x411111f0 }, /* N/A */
1426                         { 0x1e, 0xb743111e }, /* SPDIF out */
1427                         { }
1428                 },
1429                 .chained = true,
1430                 .chain_id = ALC880_FIXUP_GPIO1,
1431         },
1432         [ALC880_FIXUP_3ST_BASE] = {
1433                 .type = HDA_FIXUP_PINS,
1434                 .v.pins = (const struct hda_pintbl[]) {
1435                         { 0x14, 0x01014010 }, /* line-out */
1436                         { 0x15, 0x411111f0 }, /* N/A */
1437                         { 0x16, 0x411111f0 }, /* N/A */
1438                         { 0x17, 0x411111f0 }, /* N/A */
1439                         { 0x18, 0x01a19c30 }, /* mic-in */
1440                         { 0x19, 0x0121411f }, /* HP */
1441                         { 0x1a, 0x01813031 }, /* line-in */
1442                         { 0x1b, 0x02a19c40 }, /* front-mic */
1443                         { 0x1c, 0x411111f0 }, /* N/A */
1444                         { 0x1d, 0x411111f0 }, /* N/A */
1445                         /* 0x1e is filled in below */
1446                         { 0x1f, 0x411111f0 }, /* N/A */
1447                         { }
1448                 }
1449         },
1450         [ALC880_FIXUP_3ST] = {
1451                 .type = HDA_FIXUP_PINS,
1452                 .v.pins = (const struct hda_pintbl[]) {
1453                         { 0x1e, 0x411111f0 }, /* N/A */
1454                         { }
1455                 },
1456                 .chained = true,
1457                 .chain_id = ALC880_FIXUP_3ST_BASE,
1458         },
1459         [ALC880_FIXUP_3ST_DIG] = {
1460                 .type = HDA_FIXUP_PINS,
1461                 .v.pins = (const struct hda_pintbl[]) {
1462                         { 0x1e, 0x0144111e }, /* SPDIF */
1463                         { }
1464                 },
1465                 .chained = true,
1466                 .chain_id = ALC880_FIXUP_3ST_BASE,
1467         },
1468         [ALC880_FIXUP_5ST_BASE] = {
1469                 .type = HDA_FIXUP_PINS,
1470                 .v.pins = (const struct hda_pintbl[]) {
1471                         { 0x14, 0x01014010 }, /* front */
1472                         { 0x15, 0x411111f0 }, /* N/A */
1473                         { 0x16, 0x01011411 }, /* CLFE */
1474                         { 0x17, 0x01016412 }, /* surr */
1475                         { 0x18, 0x01a19c30 }, /* mic-in */
1476                         { 0x19, 0x0121411f }, /* HP */
1477                         { 0x1a, 0x01813031 }, /* line-in */
1478                         { 0x1b, 0x02a19c40 }, /* front-mic */
1479                         { 0x1c, 0x411111f0 }, /* N/A */
1480                         { 0x1d, 0x411111f0 }, /* N/A */
1481                         /* 0x1e is filled in below */
1482                         { 0x1f, 0x411111f0 }, /* N/A */
1483                         { }
1484                 }
1485         },
1486         [ALC880_FIXUP_5ST] = {
1487                 .type = HDA_FIXUP_PINS,
1488                 .v.pins = (const struct hda_pintbl[]) {
1489                         { 0x1e, 0x411111f0 }, /* N/A */
1490                         { }
1491                 },
1492                 .chained = true,
1493                 .chain_id = ALC880_FIXUP_5ST_BASE,
1494         },
1495         [ALC880_FIXUP_5ST_DIG] = {
1496                 .type = HDA_FIXUP_PINS,
1497                 .v.pins = (const struct hda_pintbl[]) {
1498                         { 0x1e, 0x0144111e }, /* SPDIF */
1499                         { }
1500                 },
1501                 .chained = true,
1502                 .chain_id = ALC880_FIXUP_5ST_BASE,
1503         },
1504         [ALC880_FIXUP_6ST_BASE] = {
1505                 .type = HDA_FIXUP_PINS,
1506                 .v.pins = (const struct hda_pintbl[]) {
1507                         { 0x14, 0x01014010 }, /* front */
1508                         { 0x15, 0x01016412 }, /* surr */
1509                         { 0x16, 0x01011411 }, /* CLFE */
1510                         { 0x17, 0x01012414 }, /* side */
1511                         { 0x18, 0x01a19c30 }, /* mic-in */
1512                         { 0x19, 0x02a19c40 }, /* front-mic */
1513                         { 0x1a, 0x01813031 }, /* line-in */
1514                         { 0x1b, 0x0121411f }, /* HP */
1515                         { 0x1c, 0x411111f0 }, /* N/A */
1516                         { 0x1d, 0x411111f0 }, /* N/A */
1517                         /* 0x1e is filled in below */
1518                         { 0x1f, 0x411111f0 }, /* N/A */
1519                         { }
1520                 }
1521         },
1522         [ALC880_FIXUP_6ST] = {
1523                 .type = HDA_FIXUP_PINS,
1524                 .v.pins = (const struct hda_pintbl[]) {
1525                         { 0x1e, 0x411111f0 }, /* N/A */
1526                         { }
1527                 },
1528                 .chained = true,
1529                 .chain_id = ALC880_FIXUP_6ST_BASE,
1530         },
1531         [ALC880_FIXUP_6ST_DIG] = {
1532                 .type = HDA_FIXUP_PINS,
1533                 .v.pins = (const struct hda_pintbl[]) {
1534                         { 0x1e, 0x0144111e }, /* SPDIF */
1535                         { }
1536                 },
1537                 .chained = true,
1538                 .chain_id = ALC880_FIXUP_6ST_BASE,
1539         },
1540         [ALC880_FIXUP_6ST_AUTOMUTE] = {
1541                 .type = HDA_FIXUP_PINS,
1542                 .v.pins = (const struct hda_pintbl[]) {
1543                         { 0x1b, 0x0121401f }, /* HP with jack detect */
1544                         { }
1545                 },
1546                 .chained_before = true,
1547                 .chain_id = ALC880_FIXUP_6ST_BASE,
1548         },
1549 };
1550
1551 static const struct snd_pci_quirk alc880_fixup_tbl[] = {
1552         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_FIXUP_W810),
1553         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS W5A", ALC880_FIXUP_ASUS_W5A),
1554         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_FIXUP_Z71V),
1555         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_FIXUP_GPIO1),
1556         SND_PCI_QUIRK(0x147b, 0x1045, "ABit AA8XE", ALC880_FIXUP_6ST_AUTOMUTE),
1557         SND_PCI_QUIRK(0x1558, 0x5401, "Clevo GPIO2", ALC880_FIXUP_GPIO2),
1558         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo", ALC880_FIXUP_EAPD_COEF),
1559         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_FIXUP_UNIWILL_DIG),
1560         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwill", ALC880_FIXUP_F1734),
1561         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_FIXUP_UNIWILL),
1562         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_FIXUP_VOL_KNOB),
1563         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_FIXUP_W810),
1564         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_FIXUP_MEDION_RIM),
1565         SND_PCI_QUIRK(0x1631, 0xe011, "PB 13201056", ALC880_FIXUP_6ST_AUTOMUTE),
1566         SND_PCI_QUIRK(0x1734, 0x107c, "FSC Amilo M1437", ALC880_FIXUP_FUJITSU),
1567         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FIXUP_FUJITSU),
1568         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_FIXUP_F1734),
1569         SND_PCI_QUIRK(0x1734, 0x10b0, "FSC Amilo Pi1556", ALC880_FIXUP_FUJITSU),
1570         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_FIXUP_LG),
1571         SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_FIXUP_LG),
1572         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_FIXUP_LG),
1573         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_FIXUP_LG_LW25),
1574         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_FIXUP_TCL_S700),
1575
1576         /* Below is the copied entries from alc880_quirks.c.
1577          * It's not quite sure whether BIOS sets the correct pin-config table
1578          * on these machines, thus they are kept to be compatible with
1579          * the old static quirks.  Once when it's confirmed to work without
1580          * these overrides, it'd be better to remove.
1581          */
1582         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_FIXUP_5ST_DIG),
1583         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_FIXUP_6ST),
1584         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_FIXUP_3ST_DIG),
1585         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_FIXUP_6ST_DIG),
1586         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_FIXUP_6ST_DIG),
1587         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_FIXUP_6ST_DIG),
1588         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_FIXUP_3ST_DIG),
1589         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_FIXUP_3ST),
1590         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_FIXUP_6ST_DIG),
1591         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_FIXUP_3ST),
1592         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_FIXUP_3ST),
1593         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_FIXUP_5ST),
1594         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_FIXUP_5ST),
1595         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_FIXUP_5ST),
1596         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_FIXUP_6ST_DIG),
1597         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_FIXUP_6ST_DIG),
1598         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_FIXUP_6ST_DIG),
1599         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_FIXUP_6ST_DIG),
1600         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_FIXUP_5ST_DIG),
1601         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_FIXUP_5ST_DIG),
1602         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_FIXUP_5ST_DIG),
1603         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_FIXUP_6ST_DIG), /* broken BIOS */
1604         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_FIXUP_6ST_DIG),
1605         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1606         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1607         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1608         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1609         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1610         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1611         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_FIXUP_3ST_DIG),
1612         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1613         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1614         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_FIXUP_5ST_DIG),
1615         /* default Intel */
1616         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_FIXUP_3ST),
1617         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_FIXUP_5ST_DIG),
1618         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_FIXUP_6ST_DIG),
1619         {}
1620 };
1621
1622 static const struct hda_model_fixup alc880_fixup_models[] = {
1623         {.id = ALC880_FIXUP_3ST, .name = "3stack"},
1624         {.id = ALC880_FIXUP_3ST_DIG, .name = "3stack-digout"},
1625         {.id = ALC880_FIXUP_5ST, .name = "5stack"},
1626         {.id = ALC880_FIXUP_5ST_DIG, .name = "5stack-digout"},
1627         {.id = ALC880_FIXUP_6ST, .name = "6stack"},
1628         {.id = ALC880_FIXUP_6ST_DIG, .name = "6stack-digout"},
1629         {.id = ALC880_FIXUP_6ST_AUTOMUTE, .name = "6stack-automute"},
1630         {}
1631 };
1632
1633
1634 /*
1635  * OK, here we have finally the patch for ALC880
1636  */
1637 static int patch_alc880(struct hda_codec *codec)
1638 {
1639         struct alc_spec *spec;
1640         int err;
1641
1642         err = alc_alloc_spec(codec, 0x0b);
1643         if (err < 0)
1644                 return err;
1645
1646         spec = codec->spec;
1647         spec->gen.need_dac_fix = 1;
1648         spec->gen.beep_nid = 0x01;
1649
1650         codec->patch_ops.unsol_event = alc880_unsol_event;
1651
1652         alc_pre_init(codec);
1653
1654         snd_hda_pick_fixup(codec, alc880_fixup_models, alc880_fixup_tbl,
1655                        alc880_fixups);
1656         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1657
1658         /* automatic parse from the BIOS config */
1659         err = alc880_parse_auto_config(codec);
1660         if (err < 0)
1661                 goto error;
1662
1663         if (!spec->gen.no_analog) {
1664                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
1665                 if (err < 0)
1666                         goto error;
1667         }
1668
1669         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1670
1671         return 0;
1672
1673  error:
1674         alc_free(codec);
1675         return err;
1676 }
1677
1678
1679 /*
1680  * ALC260 support
1681  */
1682 static int alc260_parse_auto_config(struct hda_codec *codec)
1683 {
1684         static const hda_nid_t alc260_ignore[] = { 0x17, 0 };
1685         static const hda_nid_t alc260_ssids[] = { 0x10, 0x15, 0x0f, 0 };
1686         return alc_parse_auto_config(codec, alc260_ignore, alc260_ssids);
1687 }
1688
1689 /*
1690  * Pin config fixes
1691  */
1692 enum {
1693         ALC260_FIXUP_HP_DC5750,
1694         ALC260_FIXUP_HP_PIN_0F,
1695         ALC260_FIXUP_COEF,
1696         ALC260_FIXUP_GPIO1,
1697         ALC260_FIXUP_GPIO1_TOGGLE,
1698         ALC260_FIXUP_REPLACER,
1699         ALC260_FIXUP_HP_B1900,
1700         ALC260_FIXUP_KN1,
1701         ALC260_FIXUP_FSC_S7020,
1702         ALC260_FIXUP_FSC_S7020_JWSE,
1703         ALC260_FIXUP_VAIO_PINS,
1704 };
1705
1706 static void alc260_gpio1_automute(struct hda_codec *codec)
1707 {
1708         struct alc_spec *spec = codec->spec;
1709
1710         alc_update_gpio_data(codec, 0x01, spec->gen.hp_jack_present);
1711 }
1712
1713 static void alc260_fixup_gpio1_toggle(struct hda_codec *codec,
1714                                       const struct hda_fixup *fix, int action)
1715 {
1716         struct alc_spec *spec = codec->spec;
1717         if (action == HDA_FIXUP_ACT_PROBE) {
1718                 /* although the machine has only one output pin, we need to
1719                  * toggle GPIO1 according to the jack state
1720                  */
1721                 spec->gen.automute_hook = alc260_gpio1_automute;
1722                 spec->gen.detect_hp = 1;
1723                 spec->gen.automute_speaker = 1;
1724                 spec->gen.autocfg.hp_pins[0] = 0x0f; /* copy it for automute */
1725                 snd_hda_jack_detect_enable_callback(codec, 0x0f,
1726                                                     snd_hda_gen_hp_automute);
1727                 alc_setup_gpio(codec, 0x01);
1728         }
1729 }
1730
1731 static void alc260_fixup_kn1(struct hda_codec *codec,
1732                              const struct hda_fixup *fix, int action)
1733 {
1734         struct alc_spec *spec = codec->spec;
1735         static const struct hda_pintbl pincfgs[] = {
1736                 { 0x0f, 0x02214000 }, /* HP/speaker */
1737                 { 0x12, 0x90a60160 }, /* int mic */
1738                 { 0x13, 0x02a19000 }, /* ext mic */
1739                 { 0x18, 0x01446000 }, /* SPDIF out */
1740                 /* disable bogus I/O pins */
1741                 { 0x10, 0x411111f0 },
1742                 { 0x11, 0x411111f0 },
1743                 { 0x14, 0x411111f0 },
1744                 { 0x15, 0x411111f0 },
1745                 { 0x16, 0x411111f0 },
1746                 { 0x17, 0x411111f0 },
1747                 { 0x19, 0x411111f0 },
1748                 { }
1749         };
1750
1751         switch (action) {
1752         case HDA_FIXUP_ACT_PRE_PROBE:
1753                 snd_hda_apply_pincfgs(codec, pincfgs);
1754                 spec->init_amp = ALC_INIT_NONE;
1755                 break;
1756         }
1757 }
1758
1759 static void alc260_fixup_fsc_s7020(struct hda_codec *codec,
1760                                    const struct hda_fixup *fix, int action)
1761 {
1762         struct alc_spec *spec = codec->spec;
1763         if (action == HDA_FIXUP_ACT_PRE_PROBE)
1764                 spec->init_amp = ALC_INIT_NONE;
1765 }
1766
1767 static void alc260_fixup_fsc_s7020_jwse(struct hda_codec *codec,
1768                                    const struct hda_fixup *fix, int action)
1769 {
1770         struct alc_spec *spec = codec->spec;
1771         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1772                 spec->gen.add_jack_modes = 1;
1773                 spec->gen.hp_mic = 1;
1774         }
1775 }
1776
1777 static const struct hda_fixup alc260_fixups[] = {
1778         [ALC260_FIXUP_HP_DC5750] = {
1779                 .type = HDA_FIXUP_PINS,
1780                 .v.pins = (const struct hda_pintbl[]) {
1781                         { 0x11, 0x90130110 }, /* speaker */
1782                         { }
1783                 }
1784         },
1785         [ALC260_FIXUP_HP_PIN_0F] = {
1786                 .type = HDA_FIXUP_PINS,
1787                 .v.pins = (const struct hda_pintbl[]) {
1788                         { 0x0f, 0x01214000 }, /* HP */
1789                         { }
1790                 }
1791         },
1792         [ALC260_FIXUP_COEF] = {
1793                 .type = HDA_FIXUP_VERBS,
1794                 .v.verbs = (const struct hda_verb[]) {
1795                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1796                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3040 },
1797                         { }
1798                 },
1799         },
1800         [ALC260_FIXUP_GPIO1] = {
1801                 .type = HDA_FIXUP_FUNC,
1802                 .v.func = alc_fixup_gpio1,
1803         },
1804         [ALC260_FIXUP_GPIO1_TOGGLE] = {
1805                 .type = HDA_FIXUP_FUNC,
1806                 .v.func = alc260_fixup_gpio1_toggle,
1807                 .chained = true,
1808                 .chain_id = ALC260_FIXUP_HP_PIN_0F,
1809         },
1810         [ALC260_FIXUP_REPLACER] = {
1811                 .type = HDA_FIXUP_VERBS,
1812                 .v.verbs = (const struct hda_verb[]) {
1813                         { 0x1a, AC_VERB_SET_COEF_INDEX, 0x07 },
1814                         { 0x1a, AC_VERB_SET_PROC_COEF,  0x3050 },
1815                         { }
1816                 },
1817                 .chained = true,
1818                 .chain_id = ALC260_FIXUP_GPIO1_TOGGLE,
1819         },
1820         [ALC260_FIXUP_HP_B1900] = {
1821                 .type = HDA_FIXUP_FUNC,
1822                 .v.func = alc260_fixup_gpio1_toggle,
1823                 .chained = true,
1824                 .chain_id = ALC260_FIXUP_COEF,
1825         },
1826         [ALC260_FIXUP_KN1] = {
1827                 .type = HDA_FIXUP_FUNC,
1828                 .v.func = alc260_fixup_kn1,
1829         },
1830         [ALC260_FIXUP_FSC_S7020] = {
1831                 .type = HDA_FIXUP_FUNC,
1832                 .v.func = alc260_fixup_fsc_s7020,
1833         },
1834         [ALC260_FIXUP_FSC_S7020_JWSE] = {
1835                 .type = HDA_FIXUP_FUNC,
1836                 .v.func = alc260_fixup_fsc_s7020_jwse,
1837                 .chained = true,
1838                 .chain_id = ALC260_FIXUP_FSC_S7020,
1839         },
1840         [ALC260_FIXUP_VAIO_PINS] = {
1841                 .type = HDA_FIXUP_PINS,
1842                 .v.pins = (const struct hda_pintbl[]) {
1843                         /* Pin configs are missing completely on some VAIOs */
1844                         { 0x0f, 0x01211020 },
1845                         { 0x10, 0x0001003f },
1846                         { 0x11, 0x411111f0 },
1847                         { 0x12, 0x01a15930 },
1848                         { 0x13, 0x411111f0 },
1849                         { 0x14, 0x411111f0 },
1850                         { 0x15, 0x411111f0 },
1851                         { 0x16, 0x411111f0 },
1852                         { 0x17, 0x411111f0 },
1853                         { 0x18, 0x411111f0 },
1854                         { 0x19, 0x411111f0 },
1855                         { }
1856                 }
1857         },
1858 };
1859
1860 static const struct snd_pci_quirk alc260_fixup_tbl[] = {
1861         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_FIXUP_GPIO1),
1862         SND_PCI_QUIRK(0x1025, 0x007f, "Acer Aspire 9500", ALC260_FIXUP_COEF),
1863         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_FIXUP_GPIO1),
1864         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", ALC260_FIXUP_HP_DC5750),
1865         SND_PCI_QUIRK(0x103c, 0x30ba, "HP Presario B1900", ALC260_FIXUP_HP_B1900),
1866         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_FIXUP_VAIO_PINS),
1867         SND_PCI_QUIRK(0x104d, 0x81e2, "Sony VAIO TX", ALC260_FIXUP_HP_PIN_0F),
1868         SND_PCI_QUIRK(0x10cf, 0x1326, "FSC LifeBook S7020", ALC260_FIXUP_FSC_S7020),
1869         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FIXUP_GPIO1),
1870         SND_PCI_QUIRK(0x152d, 0x0729, "Quanta KN1", ALC260_FIXUP_KN1),
1871         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_FIXUP_REPLACER),
1872         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_FIXUP_COEF),
1873         {}
1874 };
1875
1876 static const struct hda_model_fixup alc260_fixup_models[] = {
1877         {.id = ALC260_FIXUP_GPIO1, .name = "gpio1"},
1878         {.id = ALC260_FIXUP_COEF, .name = "coef"},
1879         {.id = ALC260_FIXUP_FSC_S7020, .name = "fujitsu"},
1880         {.id = ALC260_FIXUP_FSC_S7020_JWSE, .name = "fujitsu-jwse"},
1881         {}
1882 };
1883
1884 /*
1885  */
1886 static int patch_alc260(struct hda_codec *codec)
1887 {
1888         struct alc_spec *spec;
1889         int err;
1890
1891         err = alc_alloc_spec(codec, 0x07);
1892         if (err < 0)
1893                 return err;
1894
1895         spec = codec->spec;
1896         /* as quite a few machines require HP amp for speaker outputs,
1897          * it's easier to enable it unconditionally; even if it's unneeded,
1898          * it's almost harmless.
1899          */
1900         spec->gen.prefer_hp_amp = 1;
1901         spec->gen.beep_nid = 0x01;
1902
1903         spec->shutup = alc_eapd_shutup;
1904
1905         alc_pre_init(codec);
1906
1907         snd_hda_pick_fixup(codec, alc260_fixup_models, alc260_fixup_tbl,
1908                            alc260_fixups);
1909         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1910
1911         /* automatic parse from the BIOS config */
1912         err = alc260_parse_auto_config(codec);
1913         if (err < 0)
1914                 goto error;
1915
1916         if (!spec->gen.no_analog) {
1917                 err = set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
1918                 if (err < 0)
1919                         goto error;
1920         }
1921
1922         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1923
1924         return 0;
1925
1926  error:
1927         alc_free(codec);
1928         return err;
1929 }
1930
1931
1932 /*
1933  * ALC882/883/885/888/889 support
1934  *
1935  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
1936  * configuration.  Each pin widget can choose any input DACs and a mixer.
1937  * Each ADC is connected from a mixer of all inputs.  This makes possible
1938  * 6-channel independent captures.
1939  *
1940  * In addition, an independent DAC for the multi-playback (not used in this
1941  * driver yet).
1942  */
1943
1944 /*
1945  * Pin config fixes
1946  */
1947 enum {
1948         ALC882_FIXUP_ABIT_AW9D_MAX,
1949         ALC882_FIXUP_LENOVO_Y530,
1950         ALC882_FIXUP_PB_M5210,
1951         ALC882_FIXUP_ACER_ASPIRE_7736,
1952         ALC882_FIXUP_ASUS_W90V,
1953         ALC889_FIXUP_CD,
1954         ALC889_FIXUP_FRONT_HP_NO_PRESENCE,
1955         ALC889_FIXUP_VAIO_TT,
1956         ALC888_FIXUP_EEE1601,
1957         ALC886_FIXUP_EAPD,
1958         ALC882_FIXUP_EAPD,
1959         ALC883_FIXUP_EAPD,
1960         ALC883_FIXUP_ACER_EAPD,
1961         ALC882_FIXUP_GPIO1,
1962         ALC882_FIXUP_GPIO2,
1963         ALC882_FIXUP_GPIO3,
1964         ALC889_FIXUP_COEF,
1965         ALC882_FIXUP_ASUS_W2JC,
1966         ALC882_FIXUP_ACER_ASPIRE_4930G,
1967         ALC882_FIXUP_ACER_ASPIRE_8930G,
1968         ALC882_FIXUP_ASPIRE_8930G_VERBS,
1969         ALC885_FIXUP_MACPRO_GPIO,
1970         ALC889_FIXUP_DAC_ROUTE,
1971         ALC889_FIXUP_MBP_VREF,
1972         ALC889_FIXUP_IMAC91_VREF,
1973         ALC889_FIXUP_MBA11_VREF,
1974         ALC889_FIXUP_MBA21_VREF,
1975         ALC889_FIXUP_MP11_VREF,
1976         ALC889_FIXUP_MP41_VREF,
1977         ALC882_FIXUP_INV_DMIC,
1978         ALC882_FIXUP_NO_PRIMARY_HP,
1979         ALC887_FIXUP_ASUS_BASS,
1980         ALC887_FIXUP_BASS_CHMAP,
1981         ALC1220_FIXUP_GB_DUAL_CODECS,
1982         ALC1220_FIXUP_GB_X570,
1983         ALC1220_FIXUP_CLEVO_P950,
1984         ALC1220_FIXUP_CLEVO_PB51ED,
1985         ALC1220_FIXUP_CLEVO_PB51ED_PINS,
1986         ALC887_FIXUP_ASUS_AUDIO,
1987         ALC887_FIXUP_ASUS_HMIC,
1988         ALCS1200A_FIXUP_MIC_VREF,
1989         ALC888VD_FIXUP_MIC_100VREF,
1990 };
1991
1992 static void alc889_fixup_coef(struct hda_codec *codec,
1993                               const struct hda_fixup *fix, int action)
1994 {
1995         if (action != HDA_FIXUP_ACT_INIT)
1996                 return;
1997         alc_update_coef_idx(codec, 7, 0, 0x2030);
1998 }
1999
2000 /* set up GPIO at initialization */
2001 static void alc885_fixup_macpro_gpio(struct hda_codec *codec,
2002                                      const struct hda_fixup *fix, int action)
2003 {
2004         struct alc_spec *spec = codec->spec;
2005
2006         spec->gpio_write_delay = true;
2007         alc_fixup_gpio3(codec, fix, action);
2008 }
2009
2010 /* Fix the connection of some pins for ALC889:
2011  * At least, Acer Aspire 5935 shows the connections to DAC3/4 don't
2012  * work correctly (bko#42740)
2013  */
2014 static void alc889_fixup_dac_route(struct hda_codec *codec,
2015                                    const struct hda_fixup *fix, int action)
2016 {
2017         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2018                 /* fake the connections during parsing the tree */
2019                 static const hda_nid_t conn1[] = { 0x0c, 0x0d };
2020                 static const hda_nid_t conn2[] = { 0x0e, 0x0f };
2021                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2022                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
2023                 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn2), conn2);
2024                 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn2), conn2);
2025         } else if (action == HDA_FIXUP_ACT_PROBE) {
2026                 /* restore the connections */
2027                 static const hda_nid_t conn[] = { 0x0c, 0x0d, 0x0e, 0x0f, 0x26 };
2028                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
2029                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn), conn);
2030                 snd_hda_override_conn_list(codec, 0x18, ARRAY_SIZE(conn), conn);
2031                 snd_hda_override_conn_list(codec, 0x1a, ARRAY_SIZE(conn), conn);
2032         }
2033 }
2034
2035 /* Set VREF on HP pin */
2036 static void alc889_fixup_mbp_vref(struct hda_codec *codec,
2037                                   const struct hda_fixup *fix, int action)
2038 {
2039         static const hda_nid_t nids[] = { 0x14, 0x15, 0x19 };
2040         struct alc_spec *spec = codec->spec;
2041         int i;
2042
2043         if (action != HDA_FIXUP_ACT_INIT)
2044                 return;
2045         for (i = 0; i < ARRAY_SIZE(nids); i++) {
2046                 unsigned int val = snd_hda_codec_get_pincfg(codec, nids[i]);
2047                 if (get_defcfg_device(val) != AC_JACK_HP_OUT)
2048                         continue;
2049                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2050                 val |= AC_PINCTL_VREF_80;
2051                 snd_hda_set_pin_ctl(codec, nids[i], val);
2052                 spec->gen.keep_vref_in_automute = 1;
2053                 break;
2054         }
2055 }
2056
2057 static void alc889_fixup_mac_pins(struct hda_codec *codec,
2058                                   const hda_nid_t *nids, int num_nids)
2059 {
2060         struct alc_spec *spec = codec->spec;
2061         int i;
2062
2063         for (i = 0; i < num_nids; i++) {
2064                 unsigned int val;
2065                 val = snd_hda_codec_get_pin_target(codec, nids[i]);
2066                 val |= AC_PINCTL_VREF_50;
2067                 snd_hda_set_pin_ctl(codec, nids[i], val);
2068         }
2069         spec->gen.keep_vref_in_automute = 1;
2070 }
2071
2072 /* Set VREF on speaker pins on imac91 */
2073 static void alc889_fixup_imac91_vref(struct hda_codec *codec,
2074                                      const struct hda_fixup *fix, int action)
2075 {
2076         static const hda_nid_t nids[] = { 0x18, 0x1a };
2077
2078         if (action == HDA_FIXUP_ACT_INIT)
2079                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2080 }
2081
2082 /* Set VREF on speaker pins on mba11 */
2083 static void alc889_fixup_mba11_vref(struct hda_codec *codec,
2084                                     const struct hda_fixup *fix, int action)
2085 {
2086         static const hda_nid_t nids[] = { 0x18 };
2087
2088         if (action == HDA_FIXUP_ACT_INIT)
2089                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2090 }
2091
2092 /* Set VREF on speaker pins on mba21 */
2093 static void alc889_fixup_mba21_vref(struct hda_codec *codec,
2094                                     const struct hda_fixup *fix, int action)
2095 {
2096         static const hda_nid_t nids[] = { 0x18, 0x19 };
2097
2098         if (action == HDA_FIXUP_ACT_INIT)
2099                 alc889_fixup_mac_pins(codec, nids, ARRAY_SIZE(nids));
2100 }
2101
2102 /* Don't take HP output as primary
2103  * Strangely, the speaker output doesn't work on Vaio Z and some Vaio
2104  * all-in-one desktop PCs (for example VGC-LN51JGB) through DAC 0x05
2105  */
2106 static void alc882_fixup_no_primary_hp(struct hda_codec *codec,
2107                                        const struct hda_fixup *fix, int action)
2108 {
2109         struct alc_spec *spec = codec->spec;
2110         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2111                 spec->gen.no_primary_hp = 1;
2112                 spec->gen.no_multi_io = 1;
2113         }
2114 }
2115
2116 static void alc_fixup_bass_chmap(struct hda_codec *codec,
2117                                  const struct hda_fixup *fix, int action);
2118
2119 /* For dual-codec configuration, we need to disable some features to avoid
2120  * conflicts of kctls and PCM streams
2121  */
2122 static void alc_fixup_dual_codecs(struct hda_codec *codec,
2123                                   const struct hda_fixup *fix, int action)
2124 {
2125         struct alc_spec *spec = codec->spec;
2126
2127         if (action != HDA_FIXUP_ACT_PRE_PROBE)
2128                 return;
2129         /* disable vmaster */
2130         spec->gen.suppress_vmaster = 1;
2131         /* auto-mute and auto-mic switch don't work with multiple codecs */
2132         spec->gen.suppress_auto_mute = 1;
2133         spec->gen.suppress_auto_mic = 1;
2134         /* disable aamix as well */
2135         spec->gen.mixer_nid = 0;
2136         /* add location prefix to avoid conflicts */
2137         codec->force_pin_prefix = 1;
2138 }
2139
2140 static void rename_ctl(struct hda_codec *codec, const char *oldname,
2141                        const char *newname)
2142 {
2143         struct snd_kcontrol *kctl;
2144
2145         kctl = snd_hda_find_mixer_ctl(codec, oldname);
2146         if (kctl)
2147                 snd_ctl_rename(codec->card, kctl, newname);
2148 }
2149
2150 static void alc1220_fixup_gb_dual_codecs(struct hda_codec *codec,
2151                                          const struct hda_fixup *fix,
2152                                          int action)
2153 {
2154         alc_fixup_dual_codecs(codec, fix, action);
2155         switch (action) {
2156         case HDA_FIXUP_ACT_PRE_PROBE:
2157                 /* override card longname to provide a unique UCM profile */
2158                 strcpy(codec->card->longname, "HDAudio-Gigabyte-ALC1220DualCodecs");
2159                 break;
2160         case HDA_FIXUP_ACT_BUILD:
2161                 /* rename Capture controls depending on the codec */
2162                 rename_ctl(codec, "Capture Volume",
2163                            codec->addr == 0 ?
2164                            "Rear-Panel Capture Volume" :
2165                            "Front-Panel Capture Volume");
2166                 rename_ctl(codec, "Capture Switch",
2167                            codec->addr == 0 ?
2168                            "Rear-Panel Capture Switch" :
2169                            "Front-Panel Capture Switch");
2170                 break;
2171         }
2172 }
2173
2174 static void alc1220_fixup_gb_x570(struct hda_codec *codec,
2175                                      const struct hda_fixup *fix,
2176                                      int action)
2177 {
2178         static const hda_nid_t conn1[] = { 0x0c };
2179         static const struct coef_fw gb_x570_coefs[] = {
2180                 WRITE_COEF(0x07, 0x03c0),
2181                 WRITE_COEF(0x1a, 0x01c1),
2182                 WRITE_COEF(0x1b, 0x0202),
2183                 WRITE_COEF(0x43, 0x3005),
2184                 {}
2185         };
2186
2187         switch (action) {
2188         case HDA_FIXUP_ACT_PRE_PROBE:
2189                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2190                 snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2191                 break;
2192         case HDA_FIXUP_ACT_INIT:
2193                 alc_process_coef_fw(codec, gb_x570_coefs);
2194                 break;
2195         }
2196 }
2197
2198 static void alc1220_fixup_clevo_p950(struct hda_codec *codec,
2199                                      const struct hda_fixup *fix,
2200                                      int action)
2201 {
2202         static const hda_nid_t conn1[] = { 0x0c };
2203
2204         if (action != HDA_FIXUP_ACT_PRE_PROBE)
2205                 return;
2206
2207         alc_update_coef_idx(codec, 0x7, 0, 0x3c3);
2208         /* We therefore want to make sure 0x14 (front headphone) and
2209          * 0x1b (speakers) use the stereo DAC 0x02
2210          */
2211         snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
2212         snd_hda_override_conn_list(codec, 0x1b, ARRAY_SIZE(conn1), conn1);
2213 }
2214
2215 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
2216                                 const struct hda_fixup *fix, int action);
2217
2218 static void alc1220_fixup_clevo_pb51ed(struct hda_codec *codec,
2219                                      const struct hda_fixup *fix,
2220                                      int action)
2221 {
2222         alc1220_fixup_clevo_p950(codec, fix, action);
2223         alc_fixup_headset_mode_no_hp_mic(codec, fix, action);
2224 }
2225
2226 static void alc887_asus_hp_automute_hook(struct hda_codec *codec,
2227                                          struct hda_jack_callback *jack)
2228 {
2229         struct alc_spec *spec = codec->spec;
2230         unsigned int vref;
2231
2232         snd_hda_gen_hp_automute(codec, jack);
2233
2234         if (spec->gen.hp_jack_present)
2235                 vref = AC_PINCTL_VREF_80;
2236         else
2237                 vref = AC_PINCTL_VREF_HIZ;
2238         snd_hda_set_pin_ctl(codec, 0x19, PIN_HP | vref);
2239 }
2240
2241 static void alc887_fixup_asus_jack(struct hda_codec *codec,
2242                                      const struct hda_fixup *fix, int action)
2243 {
2244         struct alc_spec *spec = codec->spec;
2245         if (action != HDA_FIXUP_ACT_PROBE)
2246                 return;
2247         snd_hda_set_pin_ctl_cache(codec, 0x1b, PIN_HP);
2248         spec->gen.hp_automute_hook = alc887_asus_hp_automute_hook;
2249 }
2250
2251 static const struct hda_fixup alc882_fixups[] = {
2252         [ALC882_FIXUP_ABIT_AW9D_MAX] = {
2253                 .type = HDA_FIXUP_PINS,
2254                 .v.pins = (const struct hda_pintbl[]) {
2255                         { 0x15, 0x01080104 }, /* side */
2256                         { 0x16, 0x01011012 }, /* rear */
2257                         { 0x17, 0x01016011 }, /* clfe */
2258                         { }
2259                 }
2260         },
2261         [ALC882_FIXUP_LENOVO_Y530] = {
2262                 .type = HDA_FIXUP_PINS,
2263                 .v.pins = (const struct hda_pintbl[]) {
2264                         { 0x15, 0x99130112 }, /* rear int speakers */
2265                         { 0x16, 0x99130111 }, /* subwoofer */
2266                         { }
2267                 }
2268         },
2269         [ALC882_FIXUP_PB_M5210] = {
2270                 .type = HDA_FIXUP_PINCTLS,
2271                 .v.pins = (const struct hda_pintbl[]) {
2272                         { 0x19, PIN_VREF50 },
2273                         {}
2274                 }
2275         },
2276         [ALC882_FIXUP_ACER_ASPIRE_7736] = {
2277                 .type = HDA_FIXUP_FUNC,
2278                 .v.func = alc_fixup_sku_ignore,
2279         },
2280         [ALC882_FIXUP_ASUS_W90V] = {
2281                 .type = HDA_FIXUP_PINS,
2282                 .v.pins = (const struct hda_pintbl[]) {
2283                         { 0x16, 0x99130110 }, /* fix sequence for CLFE */
2284                         { }
2285                 }
2286         },
2287         [ALC889_FIXUP_CD] = {
2288                 .type = HDA_FIXUP_PINS,
2289                 .v.pins = (const struct hda_pintbl[]) {
2290                         { 0x1c, 0x993301f0 }, /* CD */
2291                         { }
2292                 }
2293         },
2294         [ALC889_FIXUP_FRONT_HP_NO_PRESENCE] = {
2295                 .type = HDA_FIXUP_PINS,
2296                 .v.pins = (const struct hda_pintbl[]) {
2297                         { 0x1b, 0x02214120 }, /* Front HP jack is flaky, disable jack detect */
2298                         { }
2299                 },
2300                 .chained = true,
2301                 .chain_id = ALC889_FIXUP_CD,
2302         },
2303         [ALC889_FIXUP_VAIO_TT] = {
2304                 .type = HDA_FIXUP_PINS,
2305                 .v.pins = (const struct hda_pintbl[]) {
2306                         { 0x17, 0x90170111 }, /* hidden surround speaker */
2307                         { }
2308                 }
2309         },
2310         [ALC888_FIXUP_EEE1601] = {
2311                 .type = HDA_FIXUP_VERBS,
2312                 .v.verbs = (const struct hda_verb[]) {
2313                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2314                         { 0x20, AC_VERB_SET_PROC_COEF,  0x0838 },
2315                         { }
2316                 }
2317         },
2318         [ALC886_FIXUP_EAPD] = {
2319                 .type = HDA_FIXUP_VERBS,
2320                 .v.verbs = (const struct hda_verb[]) {
2321                         /* change to EAPD mode */
2322                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2323                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0068 },
2324                         { }
2325                 }
2326         },
2327         [ALC882_FIXUP_EAPD] = {
2328                 .type = HDA_FIXUP_VERBS,
2329                 .v.verbs = (const struct hda_verb[]) {
2330                         /* change to EAPD mode */
2331                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2332                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3060 },
2333                         { }
2334                 }
2335         },
2336         [ALC883_FIXUP_EAPD] = {
2337                 .type = HDA_FIXUP_VERBS,
2338                 .v.verbs = (const struct hda_verb[]) {
2339                         /* change to EAPD mode */
2340                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2341                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2342                         { }
2343                 }
2344         },
2345         [ALC883_FIXUP_ACER_EAPD] = {
2346                 .type = HDA_FIXUP_VERBS,
2347                 .v.verbs = (const struct hda_verb[]) {
2348                         /* eanable EAPD on Acer laptops */
2349                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2350                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2351                         { }
2352                 }
2353         },
2354         [ALC882_FIXUP_GPIO1] = {
2355                 .type = HDA_FIXUP_FUNC,
2356                 .v.func = alc_fixup_gpio1,
2357         },
2358         [ALC882_FIXUP_GPIO2] = {
2359                 .type = HDA_FIXUP_FUNC,
2360                 .v.func = alc_fixup_gpio2,
2361         },
2362         [ALC882_FIXUP_GPIO3] = {
2363                 .type = HDA_FIXUP_FUNC,
2364                 .v.func = alc_fixup_gpio3,
2365         },
2366         [ALC882_FIXUP_ASUS_W2JC] = {
2367                 .type = HDA_FIXUP_FUNC,
2368                 .v.func = alc_fixup_gpio1,
2369                 .chained = true,
2370                 .chain_id = ALC882_FIXUP_EAPD,
2371         },
2372         [ALC889_FIXUP_COEF] = {
2373                 .type = HDA_FIXUP_FUNC,
2374                 .v.func = alc889_fixup_coef,
2375         },
2376         [ALC882_FIXUP_ACER_ASPIRE_4930G] = {
2377                 .type = HDA_FIXUP_PINS,
2378                 .v.pins = (const struct hda_pintbl[]) {
2379                         { 0x16, 0x99130111 }, /* CLFE speaker */
2380                         { 0x17, 0x99130112 }, /* surround speaker */
2381                         { }
2382                 },
2383                 .chained = true,
2384                 .chain_id = ALC882_FIXUP_GPIO1,
2385         },
2386         [ALC882_FIXUP_ACER_ASPIRE_8930G] = {
2387                 .type = HDA_FIXUP_PINS,
2388                 .v.pins = (const struct hda_pintbl[]) {
2389                         { 0x16, 0x99130111 }, /* CLFE speaker */
2390                         { 0x1b, 0x99130112 }, /* surround speaker */
2391                         { }
2392                 },
2393                 .chained = true,
2394                 .chain_id = ALC882_FIXUP_ASPIRE_8930G_VERBS,
2395         },
2396         [ALC882_FIXUP_ASPIRE_8930G_VERBS] = {
2397                 /* additional init verbs for Acer Aspire 8930G */
2398                 .type = HDA_FIXUP_VERBS,
2399                 .v.verbs = (const struct hda_verb[]) {
2400                         /* Enable all DACs */
2401                         /* DAC DISABLE/MUTE 1? */
2402                         /*  setting bits 1-5 disables DAC nids 0x02-0x06
2403                          *  apparently. Init=0x38 */
2404                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x03 },
2405                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2406                         /* DAC DISABLE/MUTE 2? */
2407                         /*  some bit here disables the other DACs.
2408                          *  Init=0x4900 */
2409                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08 },
2410                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0000 },
2411                         /* DMIC fix
2412                          * This laptop has a stereo digital microphone.
2413                          * The mics are only 1cm apart which makes the stereo
2414                          * useless. However, either the mic or the ALC889
2415                          * makes the signal become a difference/sum signal
2416                          * instead of standard stereo, which is annoying.
2417                          * So instead we flip this bit which makes the
2418                          * codec replicate the sum signal to both channels,
2419                          * turning it into a normal mono mic.
2420                          */
2421                         /* DMIC_CONTROL? Init value = 0x0001 */
2422                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0b },
2423                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0003 },
2424                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2425                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2426                         { }
2427                 },
2428                 .chained = true,
2429                 .chain_id = ALC882_FIXUP_GPIO1,
2430         },
2431         [ALC885_FIXUP_MACPRO_GPIO] = {
2432                 .type = HDA_FIXUP_FUNC,
2433                 .v.func = alc885_fixup_macpro_gpio,
2434         },
2435         [ALC889_FIXUP_DAC_ROUTE] = {
2436                 .type = HDA_FIXUP_FUNC,
2437                 .v.func = alc889_fixup_dac_route,
2438         },
2439         [ALC889_FIXUP_MBP_VREF] = {
2440                 .type = HDA_FIXUP_FUNC,
2441                 .v.func = alc889_fixup_mbp_vref,
2442                 .chained = true,
2443                 .chain_id = ALC882_FIXUP_GPIO1,
2444         },
2445         [ALC889_FIXUP_IMAC91_VREF] = {
2446                 .type = HDA_FIXUP_FUNC,
2447                 .v.func = alc889_fixup_imac91_vref,
2448                 .chained = true,
2449                 .chain_id = ALC882_FIXUP_GPIO1,
2450         },
2451         [ALC889_FIXUP_MBA11_VREF] = {
2452                 .type = HDA_FIXUP_FUNC,
2453                 .v.func = alc889_fixup_mba11_vref,
2454                 .chained = true,
2455                 .chain_id = ALC889_FIXUP_MBP_VREF,
2456         },
2457         [ALC889_FIXUP_MBA21_VREF] = {
2458                 .type = HDA_FIXUP_FUNC,
2459                 .v.func = alc889_fixup_mba21_vref,
2460                 .chained = true,
2461                 .chain_id = ALC889_FIXUP_MBP_VREF,
2462         },
2463         [ALC889_FIXUP_MP11_VREF] = {
2464                 .type = HDA_FIXUP_FUNC,
2465                 .v.func = alc889_fixup_mba11_vref,
2466                 .chained = true,
2467                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2468         },
2469         [ALC889_FIXUP_MP41_VREF] = {
2470                 .type = HDA_FIXUP_FUNC,
2471                 .v.func = alc889_fixup_mbp_vref,
2472                 .chained = true,
2473                 .chain_id = ALC885_FIXUP_MACPRO_GPIO,
2474         },
2475         [ALC882_FIXUP_INV_DMIC] = {
2476                 .type = HDA_FIXUP_FUNC,
2477                 .v.func = alc_fixup_inv_dmic,
2478         },
2479         [ALC882_FIXUP_NO_PRIMARY_HP] = {
2480                 .type = HDA_FIXUP_FUNC,
2481                 .v.func = alc882_fixup_no_primary_hp,
2482         },
2483         [ALC887_FIXUP_ASUS_BASS] = {
2484                 .type = HDA_FIXUP_PINS,
2485                 .v.pins = (const struct hda_pintbl[]) {
2486                         {0x16, 0x99130130}, /* bass speaker */
2487                         {}
2488                 },
2489                 .chained = true,
2490                 .chain_id = ALC887_FIXUP_BASS_CHMAP,
2491         },
2492         [ALC887_FIXUP_BASS_CHMAP] = {
2493                 .type = HDA_FIXUP_FUNC,
2494                 .v.func = alc_fixup_bass_chmap,
2495         },
2496         [ALC1220_FIXUP_GB_DUAL_CODECS] = {
2497                 .type = HDA_FIXUP_FUNC,
2498                 .v.func = alc1220_fixup_gb_dual_codecs,
2499         },
2500         [ALC1220_FIXUP_GB_X570] = {
2501                 .type = HDA_FIXUP_FUNC,
2502                 .v.func = alc1220_fixup_gb_x570,
2503         },
2504         [ALC1220_FIXUP_CLEVO_P950] = {
2505                 .type = HDA_FIXUP_FUNC,
2506                 .v.func = alc1220_fixup_clevo_p950,
2507         },
2508         [ALC1220_FIXUP_CLEVO_PB51ED] = {
2509                 .type = HDA_FIXUP_FUNC,
2510                 .v.func = alc1220_fixup_clevo_pb51ed,
2511         },
2512         [ALC1220_FIXUP_CLEVO_PB51ED_PINS] = {
2513                 .type = HDA_FIXUP_PINS,
2514                 .v.pins = (const struct hda_pintbl[]) {
2515                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
2516                         {}
2517                 },
2518                 .chained = true,
2519                 .chain_id = ALC1220_FIXUP_CLEVO_PB51ED,
2520         },
2521         [ALC887_FIXUP_ASUS_AUDIO] = {
2522                 .type = HDA_FIXUP_PINS,
2523                 .v.pins = (const struct hda_pintbl[]) {
2524                         { 0x15, 0x02a14150 }, /* use as headset mic, without its own jack detect */
2525                         { 0x19, 0x22219420 },
2526                         {}
2527                 },
2528         },
2529         [ALC887_FIXUP_ASUS_HMIC] = {
2530                 .type = HDA_FIXUP_FUNC,
2531                 .v.func = alc887_fixup_asus_jack,
2532                 .chained = true,
2533                 .chain_id = ALC887_FIXUP_ASUS_AUDIO,
2534         },
2535         [ALCS1200A_FIXUP_MIC_VREF] = {
2536                 .type = HDA_FIXUP_PINCTLS,
2537                 .v.pins = (const struct hda_pintbl[]) {
2538                         { 0x18, PIN_VREF50 }, /* rear mic */
2539                         { 0x19, PIN_VREF50 }, /* front mic */
2540                         {}
2541                 }
2542         },
2543         [ALC888VD_FIXUP_MIC_100VREF] = {
2544                 .type = HDA_FIXUP_PINCTLS,
2545                 .v.pins = (const struct hda_pintbl[]) {
2546                         { 0x18, PIN_VREF100 }, /* headset mic */
2547                         {}
2548                 }
2549         },
2550 };
2551
2552 static const struct snd_pci_quirk alc882_fixup_tbl[] = {
2553         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_FIXUP_ACER_EAPD),
2554         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2555         SND_PCI_QUIRK(0x1025, 0x0107, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2556         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_FIXUP_ACER_EAPD),
2557         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_FIXUP_ACER_EAPD),
2558         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_FIXUP_ACER_EAPD),
2559         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_FIXUP_ACER_EAPD),
2560         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
2561                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2562         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
2563                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2564         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
2565                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2566         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
2567                       ALC882_FIXUP_ACER_ASPIRE_8930G),
2568         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
2569                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2570         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", ALC882_FIXUP_PB_M5210),
2571         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
2572                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2573         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
2574                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2575         SND_PCI_QUIRK(0x1025, 0x021e, "Acer Aspire 5739G",
2576                       ALC882_FIXUP_ACER_ASPIRE_4930G),
2577         SND_PCI_QUIRK(0x1025, 0x0259, "Acer Aspire 5935", ALC889_FIXUP_DAC_ROUTE),
2578         SND_PCI_QUIRK(0x1025, 0x026b, "Acer Aspire 8940G", ALC882_FIXUP_ACER_ASPIRE_8930G),
2579         SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", ALC882_FIXUP_ACER_ASPIRE_7736),
2580         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_FIXUP_EAPD),
2581         SND_PCI_QUIRK(0x1043, 0x1873, "ASUS W90V", ALC882_FIXUP_ASUS_W90V),
2582         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_FIXUP_ASUS_W2JC),
2583         SND_PCI_QUIRK(0x1043, 0x2390, "Asus D700SA", ALC887_FIXUP_ASUS_HMIC),
2584         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_FIXUP_EEE1601),
2585         SND_PCI_QUIRK(0x1043, 0x84bc, "ASUS ET2700", ALC887_FIXUP_ASUS_BASS),
2586         SND_PCI_QUIRK(0x1043, 0x8691, "ASUS ROG Ranger VIII", ALC882_FIXUP_GPIO3),
2587         SND_PCI_QUIRK(0x1043, 0x8797, "ASUS TUF B550M-PLUS", ALCS1200A_FIXUP_MIC_VREF),
2588         SND_PCI_QUIRK(0x104d, 0x9043, "Sony Vaio VGC-LN51JGB", ALC882_FIXUP_NO_PRIMARY_HP),
2589         SND_PCI_QUIRK(0x104d, 0x9044, "Sony VAIO AiO", ALC882_FIXUP_NO_PRIMARY_HP),
2590         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC889_FIXUP_VAIO_TT),
2591         SND_PCI_QUIRK(0x104d, 0x905a, "Sony Vaio Z", ALC882_FIXUP_NO_PRIMARY_HP),
2592         SND_PCI_QUIRK(0x104d, 0x9060, "Sony Vaio VPCL14M1R", ALC882_FIXUP_NO_PRIMARY_HP),
2593
2594         /* All Apple entries are in codec SSIDs */
2595         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC889_FIXUP_MBP_VREF),
2596         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC889_FIXUP_MBP_VREF),
2597         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2598         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC889_FIXUP_MP11_VREF),
2599         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_FIXUP_MACPRO_GPIO),
2600         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_FIXUP_MACPRO_GPIO),
2601         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC889_FIXUP_MBP_VREF),
2602         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889_FIXUP_MBP_VREF),
2603         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_FIXUP_EAPD),
2604         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC889_FIXUP_MBA11_VREF),
2605         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC889_FIXUP_MBA21_VREF),
2606         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889_FIXUP_MBP_VREF),
2607         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC889_FIXUP_MBP_VREF),
2608         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_FIXUP_MACPRO_GPIO),
2609         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC889_FIXUP_IMAC91_VREF),
2610         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC889_FIXUP_IMAC91_VREF),
2611         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC889_FIXUP_IMAC91_VREF),
2612         SND_PCI_QUIRK(0x106b, 0x4200, "Mac Pro 4,1/5,1", ALC889_FIXUP_MP41_VREF),
2613         SND_PCI_QUIRK(0x106b, 0x4300, "iMac 9,1", ALC889_FIXUP_IMAC91_VREF),
2614         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC889_FIXUP_IMAC91_VREF),
2615         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC889_FIXUP_IMAC91_VREF),
2616         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC889_FIXUP_MBA11_VREF),
2617
2618         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC882_FIXUP_EAPD),
2619         SND_PCI_QUIRK(0x10ec, 0x12d8, "iBase Elo Touch", ALC888VD_FIXUP_MIC_100VREF),
2620         SND_PCI_QUIRK(0x13fe, 0x1009, "Advantech MIT-W101", ALC886_FIXUP_EAPD),
2621         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte EP45-DS3/Z87X-UD3H", ALC889_FIXUP_FRONT_HP_NO_PRESENCE),
2622         SND_PCI_QUIRK(0x1458, 0xa0b8, "Gigabyte AZ370-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2623         SND_PCI_QUIRK(0x1458, 0xa0cd, "Gigabyte X570 Aorus Master", ALC1220_FIXUP_GB_X570),
2624         SND_PCI_QUIRK(0x1458, 0xa0ce, "Gigabyte X570 Aorus Xtreme", ALC1220_FIXUP_GB_X570),
2625         SND_PCI_QUIRK(0x1458, 0xa0d5, "Gigabyte X570S Aorus Master", ALC1220_FIXUP_GB_X570),
2626         SND_PCI_QUIRK(0x1462, 0x11f7, "MSI-GE63", ALC1220_FIXUP_CLEVO_P950),
2627         SND_PCI_QUIRK(0x1462, 0x1228, "MSI-GP63", ALC1220_FIXUP_CLEVO_P950),
2628         SND_PCI_QUIRK(0x1462, 0x1229, "MSI-GP73", ALC1220_FIXUP_CLEVO_P950),
2629         SND_PCI_QUIRK(0x1462, 0x1275, "MSI-GL63", ALC1220_FIXUP_CLEVO_P950),
2630         SND_PCI_QUIRK(0x1462, 0x1276, "MSI-GL73", ALC1220_FIXUP_CLEVO_P950),
2631         SND_PCI_QUIRK(0x1462, 0x1293, "MSI-GP65", ALC1220_FIXUP_CLEVO_P950),
2632         SND_PCI_QUIRK(0x1462, 0x7350, "MSI-7350", ALC889_FIXUP_CD),
2633         SND_PCI_QUIRK(0x1462, 0xcc34, "MSI Godlike X570", ALC1220_FIXUP_GB_DUAL_CODECS),
2634         SND_PCI_QUIRK(0x1462, 0xda57, "MSI Z270-Gaming", ALC1220_FIXUP_GB_DUAL_CODECS),
2635         SND_PCI_QUIRK_VENDOR(0x1462, "MSI", ALC882_FIXUP_GPIO3),
2636         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", ALC882_FIXUP_ABIT_AW9D_MAX),
2637         SND_PCI_QUIRK(0x1558, 0x3702, "Clevo X370SN[VW]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2638         SND_PCI_QUIRK(0x1558, 0x50d3, "Clevo PC50[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2639         SND_PCI_QUIRK(0x1558, 0x65d1, "Clevo PB51[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2640         SND_PCI_QUIRK(0x1558, 0x65d2, "Clevo PB51R[CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2641         SND_PCI_QUIRK(0x1558, 0x65e1, "Clevo PB51[ED][DF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2642         SND_PCI_QUIRK(0x1558, 0x65e5, "Clevo PC50D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2643         SND_PCI_QUIRK(0x1558, 0x65f1, "Clevo PC50HS", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2644         SND_PCI_QUIRK(0x1558, 0x65f5, "Clevo PD50PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2645         SND_PCI_QUIRK(0x1558, 0x66a2, "Clevo PE60RNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2646         SND_PCI_QUIRK(0x1558, 0x67d1, "Clevo PB71[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2647         SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2648         SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2649         SND_PCI_QUIRK(0x1558, 0x67f1, "Clevo PC70H[PRS]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2650         SND_PCI_QUIRK(0x1558, 0x67f5, "Clevo PD70PN[NRT]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2651         SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2652         SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2653         SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED),
2654         SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950),
2655         SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950),
2656         SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950),
2657         SND_PCI_QUIRK(0x1558, 0x95e1, "Clevo P95xER", ALC1220_FIXUP_CLEVO_P950),
2658         SND_PCI_QUIRK(0x1558, 0x95e2, "Clevo P950ER", ALC1220_FIXUP_CLEVO_P950),
2659         SND_PCI_QUIRK(0x1558, 0x95e3, "Clevo P955[ER]T", ALC1220_FIXUP_CLEVO_P950),
2660         SND_PCI_QUIRK(0x1558, 0x95e4, "Clevo P955ER", ALC1220_FIXUP_CLEVO_P950),
2661         SND_PCI_QUIRK(0x1558, 0x95e5, "Clevo P955EE6", ALC1220_FIXUP_CLEVO_P950),
2662         SND_PCI_QUIRK(0x1558, 0x95e6, "Clevo P950R[CDF]", ALC1220_FIXUP_CLEVO_P950),
2663         SND_PCI_QUIRK(0x1558, 0x96e1, "Clevo P960[ER][CDFN]-K", ALC1220_FIXUP_CLEVO_P950),
2664         SND_PCI_QUIRK(0x1558, 0x97e1, "Clevo P970[ER][CDFN]", ALC1220_FIXUP_CLEVO_P950),
2665         SND_PCI_QUIRK(0x1558, 0x97e2, "Clevo P970RC-M", ALC1220_FIXUP_CLEVO_P950),
2666         SND_PCI_QUIRK(0x1558, 0xd502, "Clevo PD50SNE", ALC1220_FIXUP_CLEVO_PB51ED_PINS),
2667         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC882_FIXUP_EAPD),
2668         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_FIXUP_EAPD),
2669         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", ALC882_FIXUP_LENOVO_Y530),
2670         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_FIXUP_COEF),
2671         {}
2672 };
2673
2674 static const struct hda_model_fixup alc882_fixup_models[] = {
2675         {.id = ALC882_FIXUP_ABIT_AW9D_MAX, .name = "abit-aw9d"},
2676         {.id = ALC882_FIXUP_LENOVO_Y530, .name = "lenovo-y530"},
2677         {.id = ALC882_FIXUP_ACER_ASPIRE_7736, .name = "acer-aspire-7736"},
2678         {.id = ALC882_FIXUP_ASUS_W90V, .name = "asus-w90v"},
2679         {.id = ALC889_FIXUP_CD, .name = "cd"},
2680         {.id = ALC889_FIXUP_FRONT_HP_NO_PRESENCE, .name = "no-front-hp"},
2681         {.id = ALC889_FIXUP_VAIO_TT, .name = "vaio-tt"},
2682         {.id = ALC888_FIXUP_EEE1601, .name = "eee1601"},
2683         {.id = ALC882_FIXUP_EAPD, .name = "alc882-eapd"},
2684         {.id = ALC883_FIXUP_EAPD, .name = "alc883-eapd"},
2685         {.id = ALC882_FIXUP_GPIO1, .name = "gpio1"},
2686         {.id = ALC882_FIXUP_GPIO2, .name = "gpio2"},
2687         {.id = ALC882_FIXUP_GPIO3, .name = "gpio3"},
2688         {.id = ALC889_FIXUP_COEF, .name = "alc889-coef"},
2689         {.id = ALC882_FIXUP_ASUS_W2JC, .name = "asus-w2jc"},
2690         {.id = ALC882_FIXUP_ACER_ASPIRE_4930G, .name = "acer-aspire-4930g"},
2691         {.id = ALC882_FIXUP_ACER_ASPIRE_8930G, .name = "acer-aspire-8930g"},
2692         {.id = ALC883_FIXUP_ACER_EAPD, .name = "acer-aspire"},
2693         {.id = ALC885_FIXUP_MACPRO_GPIO, .name = "macpro-gpio"},
2694         {.id = ALC889_FIXUP_DAC_ROUTE, .name = "dac-route"},
2695         {.id = ALC889_FIXUP_MBP_VREF, .name = "mbp-vref"},
2696         {.id = ALC889_FIXUP_IMAC91_VREF, .name = "imac91-vref"},
2697         {.id = ALC889_FIXUP_MBA11_VREF, .name = "mba11-vref"},
2698         {.id = ALC889_FIXUP_MBA21_VREF, .name = "mba21-vref"},
2699         {.id = ALC889_FIXUP_MP11_VREF, .name = "mp11-vref"},
2700         {.id = ALC889_FIXUP_MP41_VREF, .name = "mp41-vref"},
2701         {.id = ALC882_FIXUP_INV_DMIC, .name = "inv-dmic"},
2702         {.id = ALC882_FIXUP_NO_PRIMARY_HP, .name = "no-primary-hp"},
2703         {.id = ALC887_FIXUP_ASUS_BASS, .name = "asus-bass"},
2704         {.id = ALC1220_FIXUP_GB_DUAL_CODECS, .name = "dual-codecs"},
2705         {.id = ALC1220_FIXUP_GB_X570, .name = "gb-x570"},
2706         {.id = ALC1220_FIXUP_CLEVO_P950, .name = "clevo-p950"},
2707         {}
2708 };
2709
2710 static const struct snd_hda_pin_quirk alc882_pin_fixup_tbl[] = {
2711         SND_HDA_PIN_QUIRK(0x10ec1220, 0x1043, "ASUS", ALC1220_FIXUP_CLEVO_P950,
2712                 {0x14, 0x01014010},
2713                 {0x15, 0x01011012},
2714                 {0x16, 0x01016011},
2715                 {0x18, 0x01a19040},
2716                 {0x19, 0x02a19050},
2717                 {0x1a, 0x0181304f},
2718                 {0x1b, 0x0221401f},
2719                 {0x1e, 0x01456130}),
2720         SND_HDA_PIN_QUIRK(0x10ec1220, 0x1462, "MS-7C35", ALC1220_FIXUP_CLEVO_P950,
2721                 {0x14, 0x01015010},
2722                 {0x15, 0x01011012},
2723                 {0x16, 0x01011011},
2724                 {0x18, 0x01a11040},
2725                 {0x19, 0x02a19050},
2726                 {0x1a, 0x0181104f},
2727                 {0x1b, 0x0221401f},
2728                 {0x1e, 0x01451130}),
2729         {}
2730 };
2731
2732 /*
2733  * BIOS auto configuration
2734  */
2735 /* almost identical with ALC880 parser... */
2736 static int alc882_parse_auto_config(struct hda_codec *codec)
2737 {
2738         static const hda_nid_t alc882_ignore[] = { 0x1d, 0 };
2739         static const hda_nid_t alc882_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2740         return alc_parse_auto_config(codec, alc882_ignore, alc882_ssids);
2741 }
2742
2743 /*
2744  */
2745 static int patch_alc882(struct hda_codec *codec)
2746 {
2747         struct alc_spec *spec;
2748         int err;
2749
2750         err = alc_alloc_spec(codec, 0x0b);
2751         if (err < 0)
2752                 return err;
2753
2754         spec = codec->spec;
2755
2756         switch (codec->core.vendor_id) {
2757         case 0x10ec0882:
2758         case 0x10ec0885:
2759         case 0x10ec0900:
2760         case 0x10ec0b00:
2761         case 0x10ec1220:
2762                 break;
2763         default:
2764                 /* ALC883 and variants */
2765                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2766                 break;
2767         }
2768
2769         alc_pre_init(codec);
2770
2771         snd_hda_pick_fixup(codec, alc882_fixup_models, alc882_fixup_tbl,
2772                        alc882_fixups);
2773         snd_hda_pick_pin_fixup(codec, alc882_pin_fixup_tbl, alc882_fixups, true);
2774         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2775
2776         alc_auto_parse_customize_define(codec);
2777
2778         if (has_cdefine_beep(codec))
2779                 spec->gen.beep_nid = 0x01;
2780
2781         /* automatic parse from the BIOS config */
2782         err = alc882_parse_auto_config(codec);
2783         if (err < 0)
2784                 goto error;
2785
2786         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2787                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2788                 if (err < 0)
2789                         goto error;
2790         }
2791
2792         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2793
2794         return 0;
2795
2796  error:
2797         alc_free(codec);
2798         return err;
2799 }
2800
2801
2802 /*
2803  * ALC262 support
2804  */
2805 static int alc262_parse_auto_config(struct hda_codec *codec)
2806 {
2807         static const hda_nid_t alc262_ignore[] = { 0x1d, 0 };
2808         static const hda_nid_t alc262_ssids[] = { 0x15, 0x1b, 0x14, 0 };
2809         return alc_parse_auto_config(codec, alc262_ignore, alc262_ssids);
2810 }
2811
2812 /*
2813  * Pin config fixes
2814  */
2815 enum {
2816         ALC262_FIXUP_FSC_H270,
2817         ALC262_FIXUP_FSC_S7110,
2818         ALC262_FIXUP_HP_Z200,
2819         ALC262_FIXUP_TYAN,
2820         ALC262_FIXUP_LENOVO_3000,
2821         ALC262_FIXUP_BENQ,
2822         ALC262_FIXUP_BENQ_T31,
2823         ALC262_FIXUP_INV_DMIC,
2824         ALC262_FIXUP_INTEL_BAYLEYBAY,
2825 };
2826
2827 static const struct hda_fixup alc262_fixups[] = {
2828         [ALC262_FIXUP_FSC_H270] = {
2829                 .type = HDA_FIXUP_PINS,
2830                 .v.pins = (const struct hda_pintbl[]) {
2831                         { 0x14, 0x99130110 }, /* speaker */
2832                         { 0x15, 0x0221142f }, /* front HP */
2833                         { 0x1b, 0x0121141f }, /* rear HP */
2834                         { }
2835                 }
2836         },
2837         [ALC262_FIXUP_FSC_S7110] = {
2838                 .type = HDA_FIXUP_PINS,
2839                 .v.pins = (const struct hda_pintbl[]) {
2840                         { 0x15, 0x90170110 }, /* speaker */
2841                         { }
2842                 },
2843                 .chained = true,
2844                 .chain_id = ALC262_FIXUP_BENQ,
2845         },
2846         [ALC262_FIXUP_HP_Z200] = {
2847                 .type = HDA_FIXUP_PINS,
2848                 .v.pins = (const struct hda_pintbl[]) {
2849                         { 0x16, 0x99130120 }, /* internal speaker */
2850                         { }
2851                 }
2852         },
2853         [ALC262_FIXUP_TYAN] = {
2854                 .type = HDA_FIXUP_PINS,
2855                 .v.pins = (const struct hda_pintbl[]) {
2856                         { 0x14, 0x1993e1f0 }, /* int AUX */
2857                         { }
2858                 }
2859         },
2860         [ALC262_FIXUP_LENOVO_3000] = {
2861                 .type = HDA_FIXUP_PINCTLS,
2862                 .v.pins = (const struct hda_pintbl[]) {
2863                         { 0x19, PIN_VREF50 },
2864                         {}
2865                 },
2866                 .chained = true,
2867                 .chain_id = ALC262_FIXUP_BENQ,
2868         },
2869         [ALC262_FIXUP_BENQ] = {
2870                 .type = HDA_FIXUP_VERBS,
2871                 .v.verbs = (const struct hda_verb[]) {
2872                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2873                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3070 },
2874                         {}
2875                 }
2876         },
2877         [ALC262_FIXUP_BENQ_T31] = {
2878                 .type = HDA_FIXUP_VERBS,
2879                 .v.verbs = (const struct hda_verb[]) {
2880                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x07 },
2881                         { 0x20, AC_VERB_SET_PROC_COEF, 0x3050 },
2882                         {}
2883                 }
2884         },
2885         [ALC262_FIXUP_INV_DMIC] = {
2886                 .type = HDA_FIXUP_FUNC,
2887                 .v.func = alc_fixup_inv_dmic,
2888         },
2889         [ALC262_FIXUP_INTEL_BAYLEYBAY] = {
2890                 .type = HDA_FIXUP_FUNC,
2891                 .v.func = alc_fixup_no_depop_delay,
2892         },
2893 };
2894
2895 static const struct snd_pci_quirk alc262_fixup_tbl[] = {
2896         SND_PCI_QUIRK(0x103c, 0x170b, "HP Z200", ALC262_FIXUP_HP_Z200),
2897         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu Lifebook S7110", ALC262_FIXUP_FSC_S7110),
2898         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FIXUP_BENQ),
2899         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_FIXUP_TYAN),
2900         SND_PCI_QUIRK(0x1734, 0x1141, "FSC ESPRIMO U9210", ALC262_FIXUP_FSC_H270),
2901         SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", ALC262_FIXUP_FSC_H270),
2902         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000", ALC262_FIXUP_LENOVO_3000),
2903         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_FIXUP_BENQ),
2904         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_FIXUP_BENQ_T31),
2905         SND_PCI_QUIRK(0x8086, 0x7270, "BayleyBay", ALC262_FIXUP_INTEL_BAYLEYBAY),
2906         {}
2907 };
2908
2909 static const struct hda_model_fixup alc262_fixup_models[] = {
2910         {.id = ALC262_FIXUP_INV_DMIC, .name = "inv-dmic"},
2911         {.id = ALC262_FIXUP_FSC_H270, .name = "fsc-h270"},
2912         {.id = ALC262_FIXUP_FSC_S7110, .name = "fsc-s7110"},
2913         {.id = ALC262_FIXUP_HP_Z200, .name = "hp-z200"},
2914         {.id = ALC262_FIXUP_TYAN, .name = "tyan"},
2915         {.id = ALC262_FIXUP_LENOVO_3000, .name = "lenovo-3000"},
2916         {.id = ALC262_FIXUP_BENQ, .name = "benq"},
2917         {.id = ALC262_FIXUP_BENQ_T31, .name = "benq-t31"},
2918         {.id = ALC262_FIXUP_INTEL_BAYLEYBAY, .name = "bayleybay"},
2919         {}
2920 };
2921
2922 /*
2923  */
2924 static int patch_alc262(struct hda_codec *codec)
2925 {
2926         struct alc_spec *spec;
2927         int err;
2928
2929         err = alc_alloc_spec(codec, 0x0b);
2930         if (err < 0)
2931                 return err;
2932
2933         spec = codec->spec;
2934         spec->gen.shared_mic_vref_pin = 0x18;
2935
2936         spec->shutup = alc_eapd_shutup;
2937
2938 #if 0
2939         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
2940          * under-run
2941          */
2942         alc_update_coefex_idx(codec, 0x1a, 7, 0, 0x80);
2943 #endif
2944         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
2945
2946         alc_pre_init(codec);
2947
2948         snd_hda_pick_fixup(codec, alc262_fixup_models, alc262_fixup_tbl,
2949                        alc262_fixups);
2950         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
2951
2952         alc_auto_parse_customize_define(codec);
2953
2954         if (has_cdefine_beep(codec))
2955                 spec->gen.beep_nid = 0x01;
2956
2957         /* automatic parse from the BIOS config */
2958         err = alc262_parse_auto_config(codec);
2959         if (err < 0)
2960                 goto error;
2961
2962         if (!spec->gen.no_analog && spec->gen.beep_nid) {
2963                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
2964                 if (err < 0)
2965                         goto error;
2966         }
2967
2968         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
2969
2970         return 0;
2971
2972  error:
2973         alc_free(codec);
2974         return err;
2975 }
2976
2977 /*
2978  *  ALC268
2979  */
2980 /* bind Beep switches of both NID 0x0f and 0x10 */
2981 static int alc268_beep_switch_put(struct snd_kcontrol *kcontrol,
2982                                   struct snd_ctl_elem_value *ucontrol)
2983 {
2984         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2985         unsigned long pval;
2986         int err;
2987
2988         mutex_lock(&codec->control_mutex);
2989         pval = kcontrol->private_value;
2990         kcontrol->private_value = (pval & ~0xff) | 0x0f;
2991         err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2992         if (err >= 0) {
2993                 kcontrol->private_value = (pval & ~0xff) | 0x10;
2994                 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
2995         }
2996         kcontrol->private_value = pval;
2997         mutex_unlock(&codec->control_mutex);
2998         return err;
2999 }
3000
3001 static const struct snd_kcontrol_new alc268_beep_mixer[] = {
3002         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
3003         {
3004                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3005                 .name = "Beep Playback Switch",
3006                 .subdevice = HDA_SUBDEV_AMP_FLAG,
3007                 .info = snd_hda_mixer_amp_switch_info,
3008                 .get = snd_hda_mixer_amp_switch_get,
3009                 .put = alc268_beep_switch_put,
3010                 .private_value = HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT)
3011         },
3012 };
3013
3014 /* set PCBEEP vol = 0, mute connections */
3015 static const struct hda_verb alc268_beep_init_verbs[] = {
3016         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3017         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3018         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3019         { }
3020 };
3021
3022 enum {
3023         ALC268_FIXUP_INV_DMIC,
3024         ALC268_FIXUP_HP_EAPD,
3025         ALC268_FIXUP_SPDIF,
3026 };
3027
3028 static const struct hda_fixup alc268_fixups[] = {
3029         [ALC268_FIXUP_INV_DMIC] = {
3030                 .type = HDA_FIXUP_FUNC,
3031                 .v.func = alc_fixup_inv_dmic,
3032         },
3033         [ALC268_FIXUP_HP_EAPD] = {
3034                 .type = HDA_FIXUP_VERBS,
3035                 .v.verbs = (const struct hda_verb[]) {
3036                         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0},
3037                         {}
3038                 }
3039         },
3040         [ALC268_FIXUP_SPDIF] = {
3041                 .type = HDA_FIXUP_PINS,
3042                 .v.pins = (const struct hda_pintbl[]) {
3043                         { 0x1e, 0x014b1180 }, /* enable SPDIF out */
3044                         {}
3045                 }
3046         },
3047 };
3048
3049 static const struct hda_model_fixup alc268_fixup_models[] = {
3050         {.id = ALC268_FIXUP_INV_DMIC, .name = "inv-dmic"},
3051         {.id = ALC268_FIXUP_HP_EAPD, .name = "hp-eapd"},
3052         {.id = ALC268_FIXUP_SPDIF, .name = "spdif"},
3053         {}
3054 };
3055
3056 static const struct snd_pci_quirk alc268_fixup_tbl[] = {
3057         SND_PCI_QUIRK(0x1025, 0x0139, "Acer TravelMate 6293", ALC268_FIXUP_SPDIF),
3058         SND_PCI_QUIRK(0x1025, 0x015b, "Acer AOA 150 (ZG5)", ALC268_FIXUP_INV_DMIC),
3059         /* below is codec SSID since multiple Toshiba laptops have the
3060          * same PCI SSID 1179:ff00
3061          */
3062         SND_PCI_QUIRK(0x1179, 0xff06, "Toshiba P200", ALC268_FIXUP_HP_EAPD),
3063         {}
3064 };
3065
3066 /*
3067  * BIOS auto configuration
3068  */
3069 static int alc268_parse_auto_config(struct hda_codec *codec)
3070 {
3071         static const hda_nid_t alc268_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3072         return alc_parse_auto_config(codec, NULL, alc268_ssids);
3073 }
3074
3075 /*
3076  */
3077 static int patch_alc268(struct hda_codec *codec)
3078 {
3079         struct alc_spec *spec;
3080         int i, err;
3081
3082         /* ALC268 has no aa-loopback mixer */
3083         err = alc_alloc_spec(codec, 0);
3084         if (err < 0)
3085                 return err;
3086
3087         spec = codec->spec;
3088         if (has_cdefine_beep(codec))
3089                 spec->gen.beep_nid = 0x01;
3090
3091         spec->shutup = alc_eapd_shutup;
3092
3093         alc_pre_init(codec);
3094
3095         snd_hda_pick_fixup(codec, alc268_fixup_models, alc268_fixup_tbl, alc268_fixups);
3096         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
3097
3098         /* automatic parse from the BIOS config */
3099         err = alc268_parse_auto_config(codec);
3100         if (err < 0)
3101                 goto error;
3102
3103         if (err > 0 && !spec->gen.no_analog &&
3104             spec->gen.autocfg.speaker_pins[0] != 0x1d) {
3105                 for (i = 0; i < ARRAY_SIZE(alc268_beep_mixer); i++) {
3106                         if (!snd_hda_gen_add_kctl(&spec->gen, NULL,
3107                                                   &alc268_beep_mixer[i])) {
3108                                 err = -ENOMEM;
3109                                 goto error;
3110                         }
3111                 }
3112                 snd_hda_add_verbs(codec, alc268_beep_init_verbs);
3113                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
3114                         /* override the amp caps for beep generator */
3115                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
3116                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
3117                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
3118                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3119                                           (0 << AC_AMPCAP_MUTE_SHIFT));
3120         }
3121
3122         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
3123
3124         return 0;
3125
3126  error:
3127         alc_free(codec);
3128         return err;
3129 }
3130
3131 /*
3132  * ALC269
3133  */
3134
3135 static const struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
3136         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3137 };
3138
3139 static const struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
3140         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
3141 };
3142
3143 /* different alc269-variants */
3144 enum {
3145         ALC269_TYPE_ALC269VA,
3146         ALC269_TYPE_ALC269VB,
3147         ALC269_TYPE_ALC269VC,
3148         ALC269_TYPE_ALC269VD,
3149         ALC269_TYPE_ALC280,
3150         ALC269_TYPE_ALC282,
3151         ALC269_TYPE_ALC283,
3152         ALC269_TYPE_ALC284,
3153         ALC269_TYPE_ALC293,
3154         ALC269_TYPE_ALC286,
3155         ALC269_TYPE_ALC298,
3156         ALC269_TYPE_ALC255,
3157         ALC269_TYPE_ALC256,
3158         ALC269_TYPE_ALC257,
3159         ALC269_TYPE_ALC215,
3160         ALC269_TYPE_ALC225,
3161         ALC269_TYPE_ALC245,
3162         ALC269_TYPE_ALC287,
3163         ALC269_TYPE_ALC294,
3164         ALC269_TYPE_ALC300,
3165         ALC269_TYPE_ALC623,
3166         ALC269_TYPE_ALC700,
3167 };
3168
3169 /*
3170  * BIOS auto configuration
3171  */
3172 static int alc269_parse_auto_config(struct hda_codec *codec)
3173 {
3174         static const hda_nid_t alc269_ignore[] = { 0x1d, 0 };
3175         static const hda_nid_t alc269_ssids[] = { 0, 0x1b, 0x14, 0x21 };
3176         static const hda_nid_t alc269va_ssids[] = { 0x15, 0x1b, 0x14, 0 };
3177         struct alc_spec *spec = codec->spec;
3178         const hda_nid_t *ssids;
3179
3180         switch (spec->codec_variant) {
3181         case ALC269_TYPE_ALC269VA:
3182         case ALC269_TYPE_ALC269VC:
3183         case ALC269_TYPE_ALC280:
3184         case ALC269_TYPE_ALC284:
3185         case ALC269_TYPE_ALC293:
3186                 ssids = alc269va_ssids;
3187                 break;
3188         case ALC269_TYPE_ALC269VB:
3189         case ALC269_TYPE_ALC269VD:
3190         case ALC269_TYPE_ALC282:
3191         case ALC269_TYPE_ALC283:
3192         case ALC269_TYPE_ALC286:
3193         case ALC269_TYPE_ALC298:
3194         case ALC269_TYPE_ALC255:
3195         case ALC269_TYPE_ALC256:
3196         case ALC269_TYPE_ALC257:
3197         case ALC269_TYPE_ALC215:
3198         case ALC269_TYPE_ALC225:
3199         case ALC269_TYPE_ALC245:
3200         case ALC269_TYPE_ALC287:
3201         case ALC269_TYPE_ALC294:
3202         case ALC269_TYPE_ALC300:
3203         case ALC269_TYPE_ALC623:
3204         case ALC269_TYPE_ALC700:
3205                 ssids = alc269_ssids;
3206                 break;
3207         default:
3208                 ssids = alc269_ssids;
3209                 break;
3210         }
3211
3212         return alc_parse_auto_config(codec, alc269_ignore, ssids);
3213 }
3214
3215 static const struct hda_jack_keymap alc_headset_btn_keymap[] = {
3216         { SND_JACK_BTN_0, KEY_PLAYPAUSE },
3217         { SND_JACK_BTN_1, KEY_VOICECOMMAND },
3218         { SND_JACK_BTN_2, KEY_VOLUMEUP },
3219         { SND_JACK_BTN_3, KEY_VOLUMEDOWN },
3220         {}
3221 };
3222
3223 static void alc_headset_btn_callback(struct hda_codec *codec,
3224                                      struct hda_jack_callback *jack)
3225 {
3226         int report = 0;
3227
3228         if (jack->unsol_res & (7 << 13))
3229                 report |= SND_JACK_BTN_0;
3230
3231         if (jack->unsol_res  & (1 << 16 | 3 << 8))
3232                 report |= SND_JACK_BTN_1;
3233
3234         /* Volume up key */
3235         if (jack->unsol_res & (7 << 23))
3236                 report |= SND_JACK_BTN_2;
3237
3238         /* Volume down key */
3239         if (jack->unsol_res & (7 << 10))
3240                 report |= SND_JACK_BTN_3;
3241
3242         snd_hda_jack_set_button_state(codec, jack->nid, report);
3243 }
3244
3245 static void alc_disable_headset_jack_key(struct hda_codec *codec)
3246 {
3247         struct alc_spec *spec = codec->spec;
3248
3249         if (!spec->has_hs_key)
3250                 return;
3251
3252         switch (codec->core.vendor_id) {
3253         case 0x10ec0215:
3254         case 0x10ec0225:
3255         case 0x10ec0285:
3256         case 0x10ec0287:
3257         case 0x10ec0295:
3258         case 0x10ec0289:
3259         case 0x10ec0299:
3260                 alc_write_coef_idx(codec, 0x48, 0x0);
3261                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3262                 alc_update_coef_idx(codec, 0x44, 0x0045 << 8, 0x0);
3263                 break;
3264         case 0x10ec0230:
3265         case 0x10ec0236:
3266         case 0x10ec0256:
3267         case 0x19e58326:
3268                 alc_write_coef_idx(codec, 0x48, 0x0);
3269                 alc_update_coef_idx(codec, 0x49, 0x0045, 0x0);
3270                 break;
3271         }
3272 }
3273
3274 static void alc_enable_headset_jack_key(struct hda_codec *codec)
3275 {
3276         struct alc_spec *spec = codec->spec;
3277
3278         if (!spec->has_hs_key)
3279                 return;
3280
3281         switch (codec->core.vendor_id) {
3282         case 0x10ec0215:
3283         case 0x10ec0225:
3284         case 0x10ec0285:
3285         case 0x10ec0287:
3286         case 0x10ec0295:
3287         case 0x10ec0289:
3288         case 0x10ec0299:
3289                 alc_write_coef_idx(codec, 0x48, 0xd011);
3290                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3291                 alc_update_coef_idx(codec, 0x44, 0x007f << 8, 0x0045 << 8);
3292                 break;
3293         case 0x10ec0230:
3294         case 0x10ec0236:
3295         case 0x10ec0256:
3296         case 0x19e58326:
3297                 alc_write_coef_idx(codec, 0x48, 0xd011);
3298                 alc_update_coef_idx(codec, 0x49, 0x007f, 0x0045);
3299                 break;
3300         }
3301 }
3302
3303 static void alc_fixup_headset_jack(struct hda_codec *codec,
3304                                     const struct hda_fixup *fix, int action)
3305 {
3306         struct alc_spec *spec = codec->spec;
3307         hda_nid_t hp_pin;
3308
3309         switch (action) {
3310         case HDA_FIXUP_ACT_PRE_PROBE:
3311                 spec->has_hs_key = 1;
3312                 snd_hda_jack_detect_enable_callback(codec, 0x55,
3313                                                     alc_headset_btn_callback);
3314                 break;
3315         case HDA_FIXUP_ACT_BUILD:
3316                 hp_pin = alc_get_hp_pin(spec);
3317                 if (!hp_pin || snd_hda_jack_bind_keymap(codec, 0x55,
3318                                                         alc_headset_btn_keymap,
3319                                                         hp_pin))
3320                         snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack",
3321                                               false, SND_JACK_HEADSET,
3322                                               alc_headset_btn_keymap);
3323
3324                 alc_enable_headset_jack_key(codec);
3325                 break;
3326         }
3327 }
3328
3329 static void alc269vb_toggle_power_output(struct hda_codec *codec, int power_up)
3330 {
3331         alc_update_coef_idx(codec, 0x04, 1 << 11, power_up ? (1 << 11) : 0);
3332 }
3333
3334 static void alc269_shutup(struct hda_codec *codec)
3335 {
3336         struct alc_spec *spec = codec->spec;
3337
3338         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
3339                 alc269vb_toggle_power_output(codec, 0);
3340         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
3341                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
3342                 msleep(150);
3343         }
3344         alc_shutup_pins(codec);
3345 }
3346
3347 static const struct coef_fw alc282_coefs[] = {
3348         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3349         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3350         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3351         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3352         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3353         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3354         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3355         WRITE_COEF(0x0e, 0x6e00), /* LDO1/2/3, DAC/ADC */
3356         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3357         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3358         WRITE_COEF(0x6f, 0x0), /* Class D test 4 */
3359         UPDATE_COEF(0x0c, 0xfe00, 0), /* IO power down directly */
3360         WRITE_COEF(0x34, 0xa0c0), /* ANC */
3361         UPDATE_COEF(0x16, 0x0008, 0), /* AGC MUX */
3362         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3363         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3364         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3365         WRITE_COEF(0x63, 0x2902), /* PLL */
3366         WRITE_COEF(0x68, 0xa080), /* capless control 2 */
3367         WRITE_COEF(0x69, 0x3400), /* capless control 3 */
3368         WRITE_COEF(0x6a, 0x2f3e), /* capless control 4 */
3369         WRITE_COEF(0x6b, 0x0), /* capless control 5 */
3370         UPDATE_COEF(0x6d, 0x0fff, 0x0900), /* class D test 2 */
3371         WRITE_COEF(0x6e, 0x110a), /* class D test 3 */
3372         UPDATE_COEF(0x70, 0x00f8, 0x00d8), /* class D test 5 */
3373         WRITE_COEF(0x71, 0x0014), /* class D test 6 */
3374         WRITE_COEF(0x72, 0xc2ba), /* classD OCP */
3375         UPDATE_COEF(0x77, 0x0f80, 0), /* classD pure DC test */
3376         WRITE_COEF(0x6c, 0xfc06), /* Class D amp control */
3377         {}
3378 };
3379
3380 static void alc282_restore_default_value(struct hda_codec *codec)
3381 {
3382         alc_process_coef_fw(codec, alc282_coefs);
3383 }
3384
3385 static void alc282_init(struct hda_codec *codec)
3386 {
3387         struct alc_spec *spec = codec->spec;
3388         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3389         bool hp_pin_sense;
3390         int coef78;
3391
3392         alc282_restore_default_value(codec);
3393
3394         if (!hp_pin)
3395                 return;
3396         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3397         coef78 = alc_read_coef_idx(codec, 0x78);
3398
3399         /* Index 0x78 Direct Drive HP AMP LPM Control 1 */
3400         /* Headphone capless set to high power mode */
3401         alc_write_coef_idx(codec, 0x78, 0x9004);
3402
3403         if (hp_pin_sense)
3404                 msleep(2);
3405
3406         snd_hda_codec_write(codec, hp_pin, 0,
3407                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3408
3409         if (hp_pin_sense)
3410                 msleep(85);
3411
3412         snd_hda_codec_write(codec, hp_pin, 0,
3413                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3414
3415         if (hp_pin_sense)
3416                 msleep(100);
3417
3418         /* Headphone capless set to normal mode */
3419         alc_write_coef_idx(codec, 0x78, coef78);
3420 }
3421
3422 static void alc282_shutup(struct hda_codec *codec)
3423 {
3424         struct alc_spec *spec = codec->spec;
3425         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3426         bool hp_pin_sense;
3427         int coef78;
3428
3429         if (!hp_pin) {
3430                 alc269_shutup(codec);
3431                 return;
3432         }
3433
3434         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3435         coef78 = alc_read_coef_idx(codec, 0x78);
3436         alc_write_coef_idx(codec, 0x78, 0x9004);
3437
3438         if (hp_pin_sense)
3439                 msleep(2);
3440
3441         snd_hda_codec_write(codec, hp_pin, 0,
3442                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3443
3444         if (hp_pin_sense)
3445                 msleep(85);
3446
3447         if (!spec->no_shutup_pins)
3448                 snd_hda_codec_write(codec, hp_pin, 0,
3449                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3450
3451         if (hp_pin_sense)
3452                 msleep(100);
3453
3454         alc_auto_setup_eapd(codec, false);
3455         alc_shutup_pins(codec);
3456         alc_write_coef_idx(codec, 0x78, coef78);
3457 }
3458
3459 static const struct coef_fw alc283_coefs[] = {
3460         WRITE_COEF(0x03, 0x0002), /* Power Down Control */
3461         UPDATE_COEF(0x05, 0xff3f, 0x0700), /* FIFO and filter clock */
3462         WRITE_COEF(0x07, 0x0200), /* DMIC control */
3463         UPDATE_COEF(0x06, 0x00f0, 0), /* Analog clock */
3464         UPDATE_COEF(0x08, 0xfffc, 0x0c2c), /* JD */
3465         WRITE_COEF(0x0a, 0xcccc), /* JD offset1 */
3466         WRITE_COEF(0x0b, 0xcccc), /* JD offset2 */
3467         WRITE_COEF(0x0e, 0x6fc0), /* LDO1/2/3, DAC/ADC */
3468         UPDATE_COEF(0x0f, 0xf800, 0x1000), /* JD */
3469         UPDATE_COEF(0x10, 0xfc00, 0x0c00), /* Capless */
3470         WRITE_COEF(0x3a, 0x0), /* Class D test 4 */
3471         UPDATE_COEF(0x0c, 0xfe00, 0x0), /* IO power down directly */
3472         WRITE_COEF(0x22, 0xa0c0), /* ANC */
3473         UPDATE_COEFEX(0x53, 0x01, 0x000f, 0x0008), /* AGC MUX */
3474         UPDATE_COEF(0x1d, 0x00e0, 0), /* DAC simple content protection */
3475         UPDATE_COEF(0x1f, 0x00e0, 0), /* ADC simple content protection */
3476         WRITE_COEF(0x21, 0x8804), /* DAC ADC Zero Detection */
3477         WRITE_COEF(0x2e, 0x2902), /* PLL */
3478         WRITE_COEF(0x33, 0xa080), /* capless control 2 */
3479         WRITE_COEF(0x34, 0x3400), /* capless control 3 */
3480         WRITE_COEF(0x35, 0x2f3e), /* capless control 4 */
3481         WRITE_COEF(0x36, 0x0), /* capless control 5 */
3482         UPDATE_COEF(0x38, 0x0fff, 0x0900), /* class D test 2 */
3483         WRITE_COEF(0x39, 0x110a), /* class D test 3 */
3484         UPDATE_COEF(0x3b, 0x00f8, 0x00d8), /* class D test 5 */
3485         WRITE_COEF(0x3c, 0x0014), /* class D test 6 */
3486         WRITE_COEF(0x3d, 0xc2ba), /* classD OCP */
3487         UPDATE_COEF(0x42, 0x0f80, 0x0), /* classD pure DC test */
3488         WRITE_COEF(0x49, 0x0), /* test mode */
3489         UPDATE_COEF(0x40, 0xf800, 0x9800), /* Class D DC enable */
3490         UPDATE_COEF(0x42, 0xf000, 0x2000), /* DC offset */
3491         WRITE_COEF(0x37, 0xfc06), /* Class D amp control */
3492         UPDATE_COEF(0x1b, 0x8000, 0), /* HP JD control */
3493         {}
3494 };
3495
3496 static void alc283_restore_default_value(struct hda_codec *codec)
3497 {
3498         alc_process_coef_fw(codec, alc283_coefs);
3499 }
3500
3501 static void alc283_init(struct hda_codec *codec)
3502 {
3503         struct alc_spec *spec = codec->spec;
3504         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3505         bool hp_pin_sense;
3506
3507         alc283_restore_default_value(codec);
3508
3509         if (!hp_pin)
3510                 return;
3511
3512         msleep(30);
3513         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3514
3515         /* Index 0x43 Direct Drive HP AMP LPM Control 1 */
3516         /* Headphone capless set to high power mode */
3517         alc_write_coef_idx(codec, 0x43, 0x9004);
3518
3519         snd_hda_codec_write(codec, hp_pin, 0,
3520                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3521
3522         if (hp_pin_sense)
3523                 msleep(85);
3524
3525         snd_hda_codec_write(codec, hp_pin, 0,
3526                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3527
3528         if (hp_pin_sense)
3529                 msleep(85);
3530         /* Index 0x46 Combo jack auto switch control 2 */
3531         /* 3k pull low control for Headset jack. */
3532         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3533         /* Headphone capless set to normal mode */
3534         alc_write_coef_idx(codec, 0x43, 0x9614);
3535 }
3536
3537 static void alc283_shutup(struct hda_codec *codec)
3538 {
3539         struct alc_spec *spec = codec->spec;
3540         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3541         bool hp_pin_sense;
3542
3543         if (!hp_pin) {
3544                 alc269_shutup(codec);
3545                 return;
3546         }
3547
3548         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3549
3550         alc_write_coef_idx(codec, 0x43, 0x9004);
3551
3552         /*depop hp during suspend*/
3553         alc_write_coef_idx(codec, 0x06, 0x2100);
3554
3555         snd_hda_codec_write(codec, hp_pin, 0,
3556                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3557
3558         if (hp_pin_sense)
3559                 msleep(100);
3560
3561         if (!spec->no_shutup_pins)
3562                 snd_hda_codec_write(codec, hp_pin, 0,
3563                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3564
3565         alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3566
3567         if (hp_pin_sense)
3568                 msleep(100);
3569         alc_auto_setup_eapd(codec, false);
3570         alc_shutup_pins(codec);
3571         alc_write_coef_idx(codec, 0x43, 0x9614);
3572 }
3573
3574 static void alc256_init(struct hda_codec *codec)
3575 {
3576         struct alc_spec *spec = codec->spec;
3577         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3578         bool hp_pin_sense;
3579
3580         if (spec->ultra_low_power) {
3581                 alc_update_coef_idx(codec, 0x03, 1<<1, 1<<1);
3582                 alc_update_coef_idx(codec, 0x08, 3<<2, 3<<2);
3583                 alc_update_coef_idx(codec, 0x08, 7<<4, 0);
3584                 alc_update_coef_idx(codec, 0x3b, 1<<15, 0);
3585                 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3586                 msleep(30);
3587         }
3588
3589         if (!hp_pin)
3590                 hp_pin = 0x21;
3591
3592         msleep(30);
3593
3594         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3595
3596         if (hp_pin_sense)
3597                 msleep(2);
3598
3599         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3600
3601         snd_hda_codec_write(codec, hp_pin, 0,
3602                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3603
3604         if (hp_pin_sense || spec->ultra_low_power)
3605                 msleep(85);
3606
3607         snd_hda_codec_write(codec, hp_pin, 0,
3608                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3609
3610         if (hp_pin_sense || spec->ultra_low_power)
3611                 msleep(100);
3612
3613         alc_update_coef_idx(codec, 0x46, 3 << 12, 0);
3614         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3615         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 1 << 15); /* Clear bit */
3616         alc_update_coefex_idx(codec, 0x53, 0x02, 0x8000, 0 << 15);
3617         /*
3618          * Expose headphone mic (or possibly Line In on some machines) instead
3619          * of PC Beep on 1Ah, and disable 1Ah loopback for all outputs. See
3620          * Documentation/sound/hd-audio/realtek-pc-beep.rst for details of
3621          * this register.
3622          */
3623         alc_write_coef_idx(codec, 0x36, 0x5757);
3624 }
3625
3626 static void alc256_shutup(struct hda_codec *codec)
3627 {
3628         struct alc_spec *spec = codec->spec;
3629         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3630         bool hp_pin_sense;
3631
3632         if (!hp_pin)
3633                 hp_pin = 0x21;
3634
3635         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3636         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3637
3638         if (hp_pin_sense)
3639                 msleep(2);
3640
3641         snd_hda_codec_write(codec, hp_pin, 0,
3642                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3643
3644         if (hp_pin_sense || spec->ultra_low_power)
3645                 msleep(85);
3646
3647         /* 3k pull low control for Headset jack. */
3648         /* NOTE: call this before clearing the pin, otherwise codec stalls */
3649         /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly
3650          * when booting with headset plugged. So skip setting it for the codec alc257
3651          */
3652         if (spec->en_3kpull_low)
3653                 alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
3654
3655         if (!spec->no_shutup_pins)
3656                 snd_hda_codec_write(codec, hp_pin, 0,
3657                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3658
3659         if (hp_pin_sense || spec->ultra_low_power)
3660                 msleep(100);
3661
3662         alc_auto_setup_eapd(codec, false);
3663         alc_shutup_pins(codec);
3664         if (spec->ultra_low_power) {
3665                 msleep(50);
3666                 alc_update_coef_idx(codec, 0x03, 1<<1, 0);
3667                 alc_update_coef_idx(codec, 0x08, 7<<4, 7<<4);
3668                 alc_update_coef_idx(codec, 0x08, 3<<2, 0);
3669                 alc_update_coef_idx(codec, 0x3b, 1<<15, 1<<15);
3670                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3671                 msleep(30);
3672         }
3673 }
3674
3675 static void alc285_hp_init(struct hda_codec *codec)
3676 {
3677         struct alc_spec *spec = codec->spec;
3678         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3679         int i, val;
3680         int coef38, coef0d, coef36;
3681
3682         alc_update_coef_idx(codec, 0x4a, 1<<15, 1<<15); /* Reset HP JD */
3683         coef38 = alc_read_coef_idx(codec, 0x38); /* Amp control */
3684         coef0d = alc_read_coef_idx(codec, 0x0d); /* Digital Misc control */
3685         coef36 = alc_read_coef_idx(codec, 0x36); /* Passthrough Control */
3686         alc_update_coef_idx(codec, 0x38, 1<<4, 0x0);
3687         alc_update_coef_idx(codec, 0x0d, 0x110, 0x0);
3688
3689         alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
3690
3691         if (hp_pin)
3692                 snd_hda_codec_write(codec, hp_pin, 0,
3693                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3694
3695         msleep(130);
3696         alc_update_coef_idx(codec, 0x36, 1<<14, 1<<14);
3697         alc_update_coef_idx(codec, 0x36, 1<<13, 0x0);
3698
3699         if (hp_pin)
3700                 snd_hda_codec_write(codec, hp_pin, 0,
3701                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3702         msleep(10);
3703         alc_write_coef_idx(codec, 0x67, 0x0); /* Set HP depop to manual mode */
3704         alc_write_coefex_idx(codec, 0x58, 0x00, 0x7880);
3705         alc_write_coefex_idx(codec, 0x58, 0x0f, 0xf049);
3706         alc_update_coefex_idx(codec, 0x58, 0x03, 0x00f0, 0x00c0);
3707
3708         alc_write_coefex_idx(codec, 0x58, 0x00, 0xf888); /* HP depop procedure start */
3709         val = alc_read_coefex_idx(codec, 0x58, 0x00);
3710         for (i = 0; i < 20 && val & 0x8000; i++) {
3711                 msleep(50);
3712                 val = alc_read_coefex_idx(codec, 0x58, 0x00);
3713         } /* Wait for depop procedure finish  */
3714
3715         alc_write_coefex_idx(codec, 0x58, 0x00, val); /* write back the result */
3716         alc_update_coef_idx(codec, 0x38, 1<<4, coef38);
3717         alc_update_coef_idx(codec, 0x0d, 0x110, coef0d);
3718         alc_update_coef_idx(codec, 0x36, 3<<13, coef36);
3719
3720         msleep(50);
3721         alc_update_coef_idx(codec, 0x4a, 1<<15, 0);
3722 }
3723
3724 static void alc225_init(struct hda_codec *codec)
3725 {
3726         struct alc_spec *spec = codec->spec;
3727         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3728         bool hp1_pin_sense, hp2_pin_sense;
3729
3730         if (spec->ultra_low_power) {
3731                 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 3<<2);
3732                 alc_update_coef_idx(codec, 0x0e, 7<<6, 7<<6);
3733                 alc_update_coef_idx(codec, 0x33, 1<<11, 0);
3734                 msleep(30);
3735         }
3736
3737         if (spec->codec_variant != ALC269_TYPE_ALC287 &&
3738                 spec->codec_variant != ALC269_TYPE_ALC245)
3739                 /* required only at boot or S3 and S4 resume time */
3740                 if (!spec->done_hp_init ||
3741                         is_s3_resume(codec) ||
3742                         is_s4_resume(codec)) {
3743                         alc285_hp_init(codec);
3744                         spec->done_hp_init = true;
3745                 }
3746
3747         if (!hp_pin)
3748                 hp_pin = 0x21;
3749         msleep(30);
3750
3751         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3752         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3753
3754         if (hp1_pin_sense || hp2_pin_sense)
3755                 msleep(2);
3756
3757         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x1); /* Low power */
3758
3759         if (hp1_pin_sense || spec->ultra_low_power)
3760                 snd_hda_codec_write(codec, hp_pin, 0,
3761                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3762         if (hp2_pin_sense)
3763                 snd_hda_codec_write(codec, 0x16, 0,
3764                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3765
3766         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3767                 msleep(85);
3768
3769         if (hp1_pin_sense || spec->ultra_low_power)
3770                 snd_hda_codec_write(codec, hp_pin, 0,
3771                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3772         if (hp2_pin_sense)
3773                 snd_hda_codec_write(codec, 0x16, 0,
3774                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3775
3776         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3777                 msleep(100);
3778
3779         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3780         alc_update_coefex_idx(codec, 0x57, 0x04, 0x0007, 0x4); /* Hight power */
3781 }
3782
3783 static void alc225_shutup(struct hda_codec *codec)
3784 {
3785         struct alc_spec *spec = codec->spec;
3786         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3787         bool hp1_pin_sense, hp2_pin_sense;
3788
3789         if (!hp_pin)
3790                 hp_pin = 0x21;
3791
3792         alc_disable_headset_jack_key(codec);
3793         /* 3k pull low control for Headset jack. */
3794         alc_update_coef_idx(codec, 0x4a, 0, 3 << 10);
3795
3796         hp1_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3797         hp2_pin_sense = snd_hda_jack_detect(codec, 0x16);
3798
3799         if (hp1_pin_sense || hp2_pin_sense)
3800                 msleep(2);
3801
3802         if (hp1_pin_sense || spec->ultra_low_power)
3803                 snd_hda_codec_write(codec, hp_pin, 0,
3804                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3805         if (hp2_pin_sense)
3806                 snd_hda_codec_write(codec, 0x16, 0,
3807                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3808
3809         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3810                 msleep(85);
3811
3812         if (hp1_pin_sense || spec->ultra_low_power)
3813                 snd_hda_codec_write(codec, hp_pin, 0,
3814                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3815         if (hp2_pin_sense)
3816                 snd_hda_codec_write(codec, 0x16, 0,
3817                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3818
3819         if (hp1_pin_sense || hp2_pin_sense || spec->ultra_low_power)
3820                 msleep(100);
3821
3822         alc_auto_setup_eapd(codec, false);
3823         alc_shutup_pins(codec);
3824         if (spec->ultra_low_power) {
3825                 msleep(50);
3826                 alc_update_coef_idx(codec, 0x08, 0x0f << 2, 0x0c << 2);
3827                 alc_update_coef_idx(codec, 0x0e, 7<<6, 0);
3828                 alc_update_coef_idx(codec, 0x33, 1<<11, 1<<11);
3829                 alc_update_coef_idx(codec, 0x4a, 3<<4, 2<<4);
3830                 msleep(30);
3831         }
3832
3833         alc_update_coef_idx(codec, 0x4a, 3 << 10, 0);
3834         alc_enable_headset_jack_key(codec);
3835 }
3836
3837 static void alc_default_init(struct hda_codec *codec)
3838 {
3839         struct alc_spec *spec = codec->spec;
3840         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3841         bool hp_pin_sense;
3842
3843         if (!hp_pin)
3844                 return;
3845
3846         msleep(30);
3847
3848         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3849
3850         if (hp_pin_sense)
3851                 msleep(2);
3852
3853         snd_hda_codec_write(codec, hp_pin, 0,
3854                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3855
3856         if (hp_pin_sense)
3857                 msleep(85);
3858
3859         snd_hda_codec_write(codec, hp_pin, 0,
3860                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
3861
3862         if (hp_pin_sense)
3863                 msleep(100);
3864 }
3865
3866 static void alc_default_shutup(struct hda_codec *codec)
3867 {
3868         struct alc_spec *spec = codec->spec;
3869         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3870         bool hp_pin_sense;
3871
3872         if (!hp_pin) {
3873                 alc269_shutup(codec);
3874                 return;
3875         }
3876
3877         hp_pin_sense = snd_hda_jack_detect(codec, hp_pin);
3878
3879         if (hp_pin_sense)
3880                 msleep(2);
3881
3882         snd_hda_codec_write(codec, hp_pin, 0,
3883                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3884
3885         if (hp_pin_sense)
3886                 msleep(85);
3887
3888         if (!spec->no_shutup_pins)
3889                 snd_hda_codec_write(codec, hp_pin, 0,
3890                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3891
3892         if (hp_pin_sense)
3893                 msleep(100);
3894
3895         alc_auto_setup_eapd(codec, false);
3896         alc_shutup_pins(codec);
3897 }
3898
3899 static void alc294_hp_init(struct hda_codec *codec)
3900 {
3901         struct alc_spec *spec = codec->spec;
3902         hda_nid_t hp_pin = alc_get_hp_pin(spec);
3903         int i, val;
3904
3905         if (!hp_pin)
3906                 return;
3907
3908         snd_hda_codec_write(codec, hp_pin, 0,
3909                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
3910
3911         msleep(100);
3912
3913         if (!spec->no_shutup_pins)
3914                 snd_hda_codec_write(codec, hp_pin, 0,
3915                                     AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
3916
3917         alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
3918         alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
3919
3920         /* Wait for depop procedure finish  */
3921         val = alc_read_coefex_idx(codec, 0x58, 0x01);
3922         for (i = 0; i < 20 && val & 0x0080; i++) {
3923                 msleep(50);
3924                 val = alc_read_coefex_idx(codec, 0x58, 0x01);
3925         }
3926         /* Set HP depop to auto mode */
3927         alc_update_coef_idx(codec, 0x6f, 0x000f, 0x000b);
3928         msleep(50);
3929 }
3930
3931 static void alc294_init(struct hda_codec *codec)
3932 {
3933         struct alc_spec *spec = codec->spec;
3934
3935         /* required only at boot or S4 resume time */
3936         if (!spec->done_hp_init ||
3937             codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
3938                 alc294_hp_init(codec);
3939                 spec->done_hp_init = true;
3940         }
3941         alc_default_init(codec);
3942 }
3943
3944 static void alc5505_coef_set(struct hda_codec *codec, unsigned int index_reg,
3945                              unsigned int val)
3946 {
3947         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3948         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val & 0xffff); /* LSB */
3949         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_PROC_COEF, val >> 16); /* MSB */
3950 }
3951
3952 static int alc5505_coef_get(struct hda_codec *codec, unsigned int index_reg)
3953 {
3954         unsigned int val;
3955
3956         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_COEF_INDEX, index_reg >> 1);
3957         val = snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3958                 & 0xffff;
3959         val |= snd_hda_codec_read(codec, 0x51, 0, AC_VERB_GET_PROC_COEF, 0)
3960                 << 16;
3961         return val;
3962 }
3963
3964 static void alc5505_dsp_halt(struct hda_codec *codec)
3965 {
3966         unsigned int val;
3967
3968         alc5505_coef_set(codec, 0x3000, 0x000c); /* DSP CPU stop */
3969         alc5505_coef_set(codec, 0x880c, 0x0008); /* DDR enter self refresh */
3970         alc5505_coef_set(codec, 0x61c0, 0x11110080); /* Clock control for PLL and CPU */
3971         alc5505_coef_set(codec, 0x6230, 0xfc0d4011); /* Disable Input OP */
3972         alc5505_coef_set(codec, 0x61b4, 0x040a2b03); /* Stop PLL2 */
3973         alc5505_coef_set(codec, 0x61b0, 0x00005b17); /* Stop PLL1 */
3974         alc5505_coef_set(codec, 0x61b8, 0x04133303); /* Stop PLL3 */
3975         val = alc5505_coef_get(codec, 0x6220);
3976         alc5505_coef_set(codec, 0x6220, (val | 0x3000)); /* switch Ringbuffer clock to DBUS clock */
3977 }
3978
3979 static void alc5505_dsp_back_from_halt(struct hda_codec *codec)
3980 {
3981         alc5505_coef_set(codec, 0x61b8, 0x04133302);
3982         alc5505_coef_set(codec, 0x61b0, 0x00005b16);
3983         alc5505_coef_set(codec, 0x61b4, 0x040a2b02);
3984         alc5505_coef_set(codec, 0x6230, 0xf80d4011);
3985         alc5505_coef_set(codec, 0x6220, 0x2002010f);
3986         alc5505_coef_set(codec, 0x880c, 0x00000004);
3987 }
3988
3989 static void alc5505_dsp_init(struct hda_codec *codec)
3990 {
3991         unsigned int val;
3992
3993         alc5505_dsp_halt(codec);
3994         alc5505_dsp_back_from_halt(codec);
3995         alc5505_coef_set(codec, 0x61b0, 0x5b14); /* PLL1 control */
3996         alc5505_coef_set(codec, 0x61b0, 0x5b16);
3997         alc5505_coef_set(codec, 0x61b4, 0x04132b00); /* PLL2 control */
3998         alc5505_coef_set(codec, 0x61b4, 0x04132b02);
3999         alc5505_coef_set(codec, 0x61b8, 0x041f3300); /* PLL3 control*/
4000         alc5505_coef_set(codec, 0x61b8, 0x041f3302);
4001         snd_hda_codec_write(codec, 0x51, 0, AC_VERB_SET_CODEC_RESET, 0); /* Function reset */
4002         alc5505_coef_set(codec, 0x61b8, 0x041b3302);
4003         alc5505_coef_set(codec, 0x61b8, 0x04173302);
4004         alc5505_coef_set(codec, 0x61b8, 0x04163302);
4005         alc5505_coef_set(codec, 0x8800, 0x348b328b); /* DRAM control */
4006         alc5505_coef_set(codec, 0x8808, 0x00020022); /* DRAM control */
4007         alc5505_coef_set(codec, 0x8818, 0x00000400); /* DRAM control */
4008
4009         val = alc5505_coef_get(codec, 0x6200) >> 16; /* Read revision ID */
4010         if (val <= 3)
4011                 alc5505_coef_set(codec, 0x6220, 0x2002010f); /* I/O PAD Configuration */
4012         else
4013                 alc5505_coef_set(codec, 0x6220, 0x6002018f);
4014
4015         alc5505_coef_set(codec, 0x61ac, 0x055525f0); /**/
4016         alc5505_coef_set(codec, 0x61c0, 0x12230080); /* Clock control */
4017         alc5505_coef_set(codec, 0x61b4, 0x040e2b02); /* PLL2 control */
4018         alc5505_coef_set(codec, 0x61bc, 0x010234f8); /* OSC Control */
4019         alc5505_coef_set(codec, 0x880c, 0x00000004); /* DRAM Function control */
4020         alc5505_coef_set(codec, 0x880c, 0x00000003);
4021         alc5505_coef_set(codec, 0x880c, 0x00000010);
4022
4023 #ifdef HALT_REALTEK_ALC5505
4024         alc5505_dsp_halt(codec);
4025 #endif
4026 }
4027
4028 #ifdef HALT_REALTEK_ALC5505
4029 #define alc5505_dsp_suspend(codec)      do { } while (0) /* NOP */
4030 #define alc5505_dsp_resume(codec)       do { } while (0) /* NOP */
4031 #else
4032 #define alc5505_dsp_suspend(codec)      alc5505_dsp_halt(codec)
4033 #define alc5505_dsp_resume(codec)       alc5505_dsp_back_from_halt(codec)
4034 #endif
4035
4036 #ifdef CONFIG_PM
4037 static int alc269_suspend(struct hda_codec *codec)
4038 {
4039         struct alc_spec *spec = codec->spec;
4040
4041         if (spec->has_alc5505_dsp)
4042                 alc5505_dsp_suspend(codec);
4043
4044         return alc_suspend(codec);
4045 }
4046
4047 static int alc269_resume(struct hda_codec *codec)
4048 {
4049         struct alc_spec *spec = codec->spec;
4050
4051         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4052                 alc269vb_toggle_power_output(codec, 0);
4053         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4054                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
4055                 msleep(150);
4056         }
4057
4058         codec->patch_ops.init(codec);
4059
4060         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
4061                 alc269vb_toggle_power_output(codec, 1);
4062         if (spec->codec_variant == ALC269_TYPE_ALC269VB &&
4063                         (alc_get_coef0(codec) & 0x00ff) == 0x017) {
4064                 msleep(200);
4065         }
4066
4067         snd_hda_regmap_sync(codec);
4068         hda_call_check_power_status(codec, 0x01);
4069
4070         /* on some machine, the BIOS will clear the codec gpio data when enter
4071          * suspend, and won't restore the data after resume, so we restore it
4072          * in the driver.
4073          */
4074         if (spec->gpio_data)
4075                 alc_write_gpio_data(codec);
4076
4077         if (spec->has_alc5505_dsp)
4078                 alc5505_dsp_resume(codec);
4079
4080         return 0;
4081 }
4082 #endif /* CONFIG_PM */
4083
4084 static void alc269_fixup_pincfg_no_hp_to_lineout(struct hda_codec *codec,
4085                                                  const struct hda_fixup *fix, int action)
4086 {
4087         struct alc_spec *spec = codec->spec;
4088
4089         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4090                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
4091 }
4092
4093 static void alc269_fixup_pincfg_U7x7_headset_mic(struct hda_codec *codec,
4094                                                  const struct hda_fixup *fix,
4095                                                  int action)
4096 {
4097         unsigned int cfg_headphone = snd_hda_codec_get_pincfg(codec, 0x21);
4098         unsigned int cfg_headset_mic = snd_hda_codec_get_pincfg(codec, 0x19);
4099
4100         if (cfg_headphone && cfg_headset_mic == 0x411111f0)
4101                 snd_hda_codec_set_pincfg(codec, 0x19,
4102                         (cfg_headphone & ~AC_DEFCFG_DEVICE) |
4103                         (AC_JACK_MIC_IN << AC_DEFCFG_DEVICE_SHIFT));
4104 }
4105
4106 static void alc269_fixup_hweq(struct hda_codec *codec,
4107                                const struct hda_fixup *fix, int action)
4108 {
4109         if (action == HDA_FIXUP_ACT_INIT)
4110                 alc_update_coef_idx(codec, 0x1e, 0, 0x80);
4111 }
4112
4113 static void alc269_fixup_headset_mic(struct hda_codec *codec,
4114                                        const struct hda_fixup *fix, int action)
4115 {
4116         struct alc_spec *spec = codec->spec;
4117
4118         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4119                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4120 }
4121
4122 static void alc271_fixup_dmic(struct hda_codec *codec,
4123                               const struct hda_fixup *fix, int action)
4124 {
4125         static const struct hda_verb verbs[] = {
4126                 {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
4127                 {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
4128                 {}
4129         };
4130         unsigned int cfg;
4131
4132         if (strcmp(codec->core.chip_name, "ALC271X") &&
4133             strcmp(codec->core.chip_name, "ALC269VB"))
4134                 return;
4135         cfg = snd_hda_codec_get_pincfg(codec, 0x12);
4136         if (get_defcfg_connect(cfg) == AC_JACK_PORT_FIXED)
4137                 snd_hda_sequence_write(codec, verbs);
4138 }
4139
4140 /* Fix the speaker amp after resume, etc */
4141 static void alc269vb_fixup_aspire_e1_coef(struct hda_codec *codec,
4142                                           const struct hda_fixup *fix,
4143                                           int action)
4144 {
4145         if (action == HDA_FIXUP_ACT_INIT)
4146                 alc_update_coef_idx(codec, 0x0d, 0x6000, 0x6000);
4147 }
4148
4149 static void alc269_fixup_pcm_44k(struct hda_codec *codec,
4150                                  const struct hda_fixup *fix, int action)
4151 {
4152         struct alc_spec *spec = codec->spec;
4153
4154         if (action != HDA_FIXUP_ACT_PROBE)
4155                 return;
4156
4157         /* Due to a hardware problem on Lenovo Ideadpad, we need to
4158          * fix the sample rate of analog I/O to 44.1kHz
4159          */
4160         spec->gen.stream_analog_playback = &alc269_44k_pcm_analog_playback;
4161         spec->gen.stream_analog_capture = &alc269_44k_pcm_analog_capture;
4162 }
4163
4164 static void alc269_fixup_stereo_dmic(struct hda_codec *codec,
4165                                      const struct hda_fixup *fix, int action)
4166 {
4167         /* The digital-mic unit sends PDM (differential signal) instead of
4168          * the standard PCM, thus you can't record a valid mono stream as is.
4169          * Below is a workaround specific to ALC269 to control the dmic
4170          * signal source as mono.
4171          */
4172         if (action == HDA_FIXUP_ACT_INIT)
4173                 alc_update_coef_idx(codec, 0x07, 0, 0x80);
4174 }
4175
4176 static void alc269_quanta_automute(struct hda_codec *codec)
4177 {
4178         snd_hda_gen_update_outputs(codec);
4179
4180         alc_write_coef_idx(codec, 0x0c, 0x680);
4181         alc_write_coef_idx(codec, 0x0c, 0x480);
4182 }
4183
4184 static void alc269_fixup_quanta_mute(struct hda_codec *codec,
4185                                      const struct hda_fixup *fix, int action)
4186 {
4187         struct alc_spec *spec = codec->spec;
4188         if (action != HDA_FIXUP_ACT_PROBE)
4189                 return;
4190         spec->gen.automute_hook = alc269_quanta_automute;
4191 }
4192
4193 static void alc269_x101_hp_automute_hook(struct hda_codec *codec,
4194                                          struct hda_jack_callback *jack)
4195 {
4196         struct alc_spec *spec = codec->spec;
4197         int vref;
4198         msleep(200);
4199         snd_hda_gen_hp_automute(codec, jack);
4200
4201         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
4202         msleep(100);
4203         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4204                             vref);
4205         msleep(500);
4206         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4207                             vref);
4208 }
4209
4210 /*
4211  * Magic sequence to make Huawei Matebook X right speaker working (bko#197801)
4212  */
4213 struct hda_alc298_mbxinit {
4214         unsigned char value_0x23;
4215         unsigned char value_0x25;
4216 };
4217
4218 static void alc298_huawei_mbx_stereo_seq(struct hda_codec *codec,
4219                                          const struct hda_alc298_mbxinit *initval,
4220                                          bool first)
4221 {
4222         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x0);
4223         alc_write_coef_idx(codec, 0x26, 0xb000);
4224
4225         if (first)
4226                 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_GET_PIN_SENSE, 0x0);
4227
4228         snd_hda_codec_write(codec, 0x6, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4229         alc_write_coef_idx(codec, 0x26, 0xf000);
4230         alc_write_coef_idx(codec, 0x23, initval->value_0x23);
4231
4232         if (initval->value_0x23 != 0x1e)
4233                 alc_write_coef_idx(codec, 0x25, initval->value_0x25);
4234
4235         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4236         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4237 }
4238
4239 static void alc298_fixup_huawei_mbx_stereo(struct hda_codec *codec,
4240                                            const struct hda_fixup *fix,
4241                                            int action)
4242 {
4243         /* Initialization magic */
4244         static const struct hda_alc298_mbxinit dac_init[] = {
4245                 {0x0c, 0x00}, {0x0d, 0x00}, {0x0e, 0x00}, {0x0f, 0x00},
4246                 {0x10, 0x00}, {0x1a, 0x40}, {0x1b, 0x82}, {0x1c, 0x00},
4247                 {0x1d, 0x00}, {0x1e, 0x00}, {0x1f, 0x00},
4248                 {0x20, 0xc2}, {0x21, 0xc8}, {0x22, 0x26}, {0x23, 0x24},
4249                 {0x27, 0xff}, {0x28, 0xff}, {0x29, 0xff}, {0x2a, 0x8f},
4250                 {0x2b, 0x02}, {0x2c, 0x48}, {0x2d, 0x34}, {0x2e, 0x00},
4251                 {0x2f, 0x00},
4252                 {0x30, 0x00}, {0x31, 0x00}, {0x32, 0x00}, {0x33, 0x00},
4253                 {0x34, 0x00}, {0x35, 0x01}, {0x36, 0x93}, {0x37, 0x0c},
4254                 {0x38, 0x00}, {0x39, 0x00}, {0x3a, 0xf8}, {0x38, 0x80},
4255                 {}
4256         };
4257         const struct hda_alc298_mbxinit *seq;
4258
4259         if (action != HDA_FIXUP_ACT_INIT)
4260                 return;
4261
4262         /* Start */
4263         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x00);
4264         snd_hda_codec_write(codec, 0x06, 0, AC_VERB_SET_DIGI_CONVERT_3, 0x80);
4265         alc_write_coef_idx(codec, 0x26, 0xf000);
4266         alc_write_coef_idx(codec, 0x22, 0x31);
4267         alc_write_coef_idx(codec, 0x23, 0x0b);
4268         alc_write_coef_idx(codec, 0x25, 0x00);
4269         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0x26);
4270         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, 0xb010);
4271
4272         for (seq = dac_init; seq->value_0x23; seq++)
4273                 alc298_huawei_mbx_stereo_seq(codec, seq, seq == dac_init);
4274 }
4275
4276 static void alc269_fixup_x101_headset_mic(struct hda_codec *codec,
4277                                      const struct hda_fixup *fix, int action)
4278 {
4279         struct alc_spec *spec = codec->spec;
4280         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4281                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
4282                 spec->gen.hp_automute_hook = alc269_x101_hp_automute_hook;
4283         }
4284 }
4285
4286 static void alc_update_vref_led(struct hda_codec *codec, hda_nid_t pin,
4287                                 bool polarity, bool on)
4288 {
4289         unsigned int pinval;
4290
4291         if (!pin)
4292                 return;
4293         if (polarity)
4294                 on = !on;
4295         pinval = snd_hda_codec_get_pin_target(codec, pin);
4296         pinval &= ~AC_PINCTL_VREFEN;
4297         pinval |= on ? AC_PINCTL_VREF_80 : AC_PINCTL_VREF_HIZ;
4298         /* temporarily power up/down for setting VREF */
4299         snd_hda_power_up_pm(codec);
4300         snd_hda_set_pin_ctl_cache(codec, pin, pinval);
4301         snd_hda_power_down_pm(codec);
4302 }
4303
4304 /* update mute-LED according to the speaker mute state via mic VREF pin */
4305 static int vref_mute_led_set(struct led_classdev *led_cdev,
4306                              enum led_brightness brightness)
4307 {
4308         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4309         struct alc_spec *spec = codec->spec;
4310
4311         alc_update_vref_led(codec, spec->mute_led_nid,
4312                             spec->mute_led_polarity, brightness);
4313         return 0;
4314 }
4315
4316 /* Make sure the led works even in runtime suspend */
4317 static unsigned int led_power_filter(struct hda_codec *codec,
4318                                                   hda_nid_t nid,
4319                                                   unsigned int power_state)
4320 {
4321         struct alc_spec *spec = codec->spec;
4322
4323         if (power_state != AC_PWRST_D3 || nid == 0 ||
4324             (nid != spec->mute_led_nid && nid != spec->cap_mute_led_nid))
4325                 return power_state;
4326
4327         /* Set pin ctl again, it might have just been set to 0 */
4328         snd_hda_set_pin_ctl(codec, nid,
4329                             snd_hda_codec_get_pin_target(codec, nid));
4330
4331         return snd_hda_gen_path_power_filter(codec, nid, power_state);
4332 }
4333
4334 static void alc269_fixup_hp_mute_led(struct hda_codec *codec,
4335                                      const struct hda_fixup *fix, int action)
4336 {
4337         struct alc_spec *spec = codec->spec;
4338         const struct dmi_device *dev = NULL;
4339
4340         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4341                 return;
4342
4343         while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4344                 int pol, pin;
4345                 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", &pol, &pin) != 2)
4346                         continue;
4347                 if (pin < 0x0a || pin >= 0x10)
4348                         break;
4349                 spec->mute_led_polarity = pol;
4350                 spec->mute_led_nid = pin - 0x0a + 0x18;
4351                 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4352                 codec->power_filter = led_power_filter;
4353                 codec_dbg(codec,
4354                           "Detected mute LED for %x:%d\n", spec->mute_led_nid,
4355                            spec->mute_led_polarity);
4356                 break;
4357         }
4358 }
4359
4360 static void alc269_fixup_hp_mute_led_micx(struct hda_codec *codec,
4361                                           const struct hda_fixup *fix,
4362                                           int action, hda_nid_t pin)
4363 {
4364         struct alc_spec *spec = codec->spec;
4365
4366         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4367                 spec->mute_led_polarity = 0;
4368                 spec->mute_led_nid = pin;
4369                 snd_hda_gen_add_mute_led_cdev(codec, vref_mute_led_set);
4370                 codec->power_filter = led_power_filter;
4371         }
4372 }
4373
4374 static void alc269_fixup_hp_mute_led_mic1(struct hda_codec *codec,
4375                                 const struct hda_fixup *fix, int action)
4376 {
4377         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x18);
4378 }
4379
4380 static void alc269_fixup_hp_mute_led_mic2(struct hda_codec *codec,
4381                                 const struct hda_fixup *fix, int action)
4382 {
4383         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x19);
4384 }
4385
4386 static void alc269_fixup_hp_mute_led_mic3(struct hda_codec *codec,
4387                                 const struct hda_fixup *fix, int action)
4388 {
4389         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1b);
4390 }
4391
4392 /* update LED status via GPIO */
4393 static void alc_update_gpio_led(struct hda_codec *codec, unsigned int mask,
4394                                 int polarity, bool enabled)
4395 {
4396         if (polarity)
4397                 enabled = !enabled;
4398         alc_update_gpio_data(codec, mask, !enabled); /* muted -> LED on */
4399 }
4400
4401 /* turn on/off mute LED via GPIO per vmaster hook */
4402 static int gpio_mute_led_set(struct led_classdev *led_cdev,
4403                              enum led_brightness brightness)
4404 {
4405         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4406         struct alc_spec *spec = codec->spec;
4407
4408         alc_update_gpio_led(codec, spec->gpio_mute_led_mask,
4409                             spec->mute_led_polarity, !brightness);
4410         return 0;
4411 }
4412
4413 /* turn on/off mic-mute LED via GPIO per capture hook */
4414 static int micmute_led_set(struct led_classdev *led_cdev,
4415                            enum led_brightness brightness)
4416 {
4417         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4418         struct alc_spec *spec = codec->spec;
4419
4420         alc_update_gpio_led(codec, spec->gpio_mic_led_mask,
4421                             spec->micmute_led_polarity, !brightness);
4422         return 0;
4423 }
4424
4425 /* setup mute and mic-mute GPIO bits, add hooks appropriately */
4426 static void alc_fixup_hp_gpio_led(struct hda_codec *codec,
4427                                   int action,
4428                                   unsigned int mute_mask,
4429                                   unsigned int micmute_mask)
4430 {
4431         struct alc_spec *spec = codec->spec;
4432
4433         alc_fixup_gpio(codec, action, mute_mask | micmute_mask);
4434
4435         if (action != HDA_FIXUP_ACT_PRE_PROBE)
4436                 return;
4437         if (mute_mask) {
4438                 spec->gpio_mute_led_mask = mute_mask;
4439                 snd_hda_gen_add_mute_led_cdev(codec, gpio_mute_led_set);
4440         }
4441         if (micmute_mask) {
4442                 spec->gpio_mic_led_mask = micmute_mask;
4443                 snd_hda_gen_add_micmute_led_cdev(codec, micmute_led_set);
4444         }
4445 }
4446
4447 static void alc236_fixup_hp_gpio_led(struct hda_codec *codec,
4448                                 const struct hda_fixup *fix, int action)
4449 {
4450         alc_fixup_hp_gpio_led(codec, action, 0x02, 0x01);
4451 }
4452
4453 static void alc269_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, 0x08, 0x10);
4457 }
4458
4459 static void alc285_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, 0x04, 0x01);
4463 }
4464
4465 static void alc286_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, 0x02, 0x20);
4469 }
4470
4471 static void alc287_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, 0x10, 0);
4475 }
4476
4477 static void alc245_fixup_hp_gpio_led(struct hda_codec *codec,
4478                                 const struct hda_fixup *fix, int action)
4479 {
4480         struct alc_spec *spec = codec->spec;
4481
4482         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4483                 spec->micmute_led_polarity = 1;
4484         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4485 }
4486
4487 /* turn on/off mic-mute LED per capture hook via VREF change */
4488 static int vref_micmute_led_set(struct led_classdev *led_cdev,
4489                                 enum led_brightness brightness)
4490 {
4491         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4492         struct alc_spec *spec = codec->spec;
4493
4494         alc_update_vref_led(codec, spec->cap_mute_led_nid,
4495                             spec->micmute_led_polarity, brightness);
4496         return 0;
4497 }
4498
4499 static void alc269_fixup_hp_gpio_mic1_led(struct hda_codec *codec,
4500                                 const struct hda_fixup *fix, int action)
4501 {
4502         struct alc_spec *spec = codec->spec;
4503
4504         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4505         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4506                 /* Like hp_gpio_mic1_led, but also needs GPIO4 low to
4507                  * enable headphone amp
4508                  */
4509                 spec->gpio_mask |= 0x10;
4510                 spec->gpio_dir |= 0x10;
4511                 spec->cap_mute_led_nid = 0x18;
4512                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4513                 codec->power_filter = led_power_filter;
4514         }
4515 }
4516
4517 static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
4518                                    const struct hda_fixup *fix, int action)
4519 {
4520         struct alc_spec *spec = codec->spec;
4521
4522         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
4523         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4524                 spec->cap_mute_led_nid = 0x18;
4525                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4526                 codec->power_filter = led_power_filter;
4527         }
4528 }
4529
4530 /* HP Spectre x360 14 model needs a unique workaround for enabling the amp;
4531  * it needs to toggle the GPIO0 once on and off at each time (bko#210633)
4532  */
4533 static void alc245_fixup_hp_x360_amp(struct hda_codec *codec,
4534                                      const struct hda_fixup *fix, int action)
4535 {
4536         struct alc_spec *spec = codec->spec;
4537
4538         switch (action) {
4539         case HDA_FIXUP_ACT_PRE_PROBE:
4540                 spec->gpio_mask |= 0x01;
4541                 spec->gpio_dir |= 0x01;
4542                 break;
4543         case HDA_FIXUP_ACT_INIT:
4544                 /* need to toggle GPIO to enable the amp */
4545                 alc_update_gpio_data(codec, 0x01, true);
4546                 msleep(100);
4547                 alc_update_gpio_data(codec, 0x01, false);
4548                 break;
4549         }
4550 }
4551
4552 /* toggle GPIO2 at each time stream is started; we use PREPARE state instead */
4553 static void alc274_hp_envy_pcm_hook(struct hda_pcm_stream *hinfo,
4554                                     struct hda_codec *codec,
4555                                     struct snd_pcm_substream *substream,
4556                                     int action)
4557 {
4558         switch (action) {
4559         case HDA_GEN_PCM_ACT_PREPARE:
4560                 alc_update_gpio_data(codec, 0x04, true);
4561                 break;
4562         case HDA_GEN_PCM_ACT_CLEANUP:
4563                 alc_update_gpio_data(codec, 0x04, false);
4564                 break;
4565         }
4566 }
4567
4568 static void alc274_fixup_hp_envy_gpio(struct hda_codec *codec,
4569                                       const struct hda_fixup *fix,
4570                                       int action)
4571 {
4572         struct alc_spec *spec = codec->spec;
4573
4574         if (action == HDA_FIXUP_ACT_PROBE) {
4575                 spec->gpio_mask |= 0x04;
4576                 spec->gpio_dir |= 0x04;
4577                 spec->gen.pcm_playback_hook = alc274_hp_envy_pcm_hook;
4578         }
4579 }
4580
4581 static void alc_update_coef_led(struct hda_codec *codec,
4582                                 struct alc_coef_led *led,
4583                                 bool polarity, bool on)
4584 {
4585         if (polarity)
4586                 on = !on;
4587         /* temporarily power up/down for setting COEF bit */
4588         alc_update_coef_idx(codec, led->idx, led->mask,
4589                             on ? led->on : led->off);
4590 }
4591
4592 /* update mute-LED according to the speaker mute state via COEF bit */
4593 static int coef_mute_led_set(struct led_classdev *led_cdev,
4594                              enum led_brightness brightness)
4595 {
4596         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4597         struct alc_spec *spec = codec->spec;
4598
4599         alc_update_coef_led(codec, &spec->mute_led_coef,
4600                             spec->mute_led_polarity, brightness);
4601         return 0;
4602 }
4603
4604 static void alc285_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4605                                           const struct hda_fixup *fix,
4606                                           int action)
4607 {
4608         struct alc_spec *spec = codec->spec;
4609
4610         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4611                 spec->mute_led_polarity = 0;
4612                 spec->mute_led_coef.idx = 0x0b;
4613                 spec->mute_led_coef.mask = 1 << 3;
4614                 spec->mute_led_coef.on = 1 << 3;
4615                 spec->mute_led_coef.off = 0;
4616                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4617         }
4618 }
4619
4620 static void alc236_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4621                                           const struct hda_fixup *fix,
4622                                           int action)
4623 {
4624         struct alc_spec *spec = codec->spec;
4625
4626         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4627                 spec->mute_led_polarity = 0;
4628                 spec->mute_led_coef.idx = 0x34;
4629                 spec->mute_led_coef.mask = 1 << 5;
4630                 spec->mute_led_coef.on = 0;
4631                 spec->mute_led_coef.off = 1 << 5;
4632                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4633         }
4634 }
4635
4636 static void alc236_fixup_hp_mute_led_coefbit2(struct hda_codec *codec,
4637                                           const struct hda_fixup *fix, int action)
4638 {
4639         struct alc_spec *spec = codec->spec;
4640
4641         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4642                 spec->mute_led_polarity = 0;
4643                 spec->mute_led_coef.idx = 0x07;
4644                 spec->mute_led_coef.mask = 1;
4645                 spec->mute_led_coef.on = 1;
4646                 spec->mute_led_coef.off = 0;
4647                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4648         }
4649 }
4650
4651 static void alc245_fixup_hp_mute_led_coefbit(struct hda_codec *codec,
4652                                           const struct hda_fixup *fix,
4653                                           int action)
4654 {
4655         struct alc_spec *spec = codec->spec;
4656
4657         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4658                 spec->mute_led_polarity = 0;
4659                 spec->mute_led_coef.idx = 0x0b;
4660                 spec->mute_led_coef.mask = 3 << 2;
4661                 spec->mute_led_coef.on = 2 << 2;
4662                 spec->mute_led_coef.off = 1 << 2;
4663                 snd_hda_gen_add_mute_led_cdev(codec, coef_mute_led_set);
4664         }
4665 }
4666
4667 /* turn on/off mic-mute LED per capture hook by coef bit */
4668 static int coef_micmute_led_set(struct led_classdev *led_cdev,
4669                                 enum led_brightness brightness)
4670 {
4671         struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
4672         struct alc_spec *spec = codec->spec;
4673
4674         alc_update_coef_led(codec, &spec->mic_led_coef,
4675                             spec->micmute_led_polarity, brightness);
4676         return 0;
4677 }
4678
4679 static void alc285_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4680                                 const struct hda_fixup *fix, int action)
4681 {
4682         struct alc_spec *spec = codec->spec;
4683
4684         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4685                 spec->mic_led_coef.idx = 0x19;
4686                 spec->mic_led_coef.mask = 1 << 13;
4687                 spec->mic_led_coef.on = 1 << 13;
4688                 spec->mic_led_coef.off = 0;
4689                 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4690         }
4691 }
4692
4693 static void alc285_fixup_hp_gpio_micmute_led(struct hda_codec *codec,
4694                                 const struct hda_fixup *fix, int action)
4695 {
4696         struct alc_spec *spec = codec->spec;
4697
4698         if (action == HDA_FIXUP_ACT_PRE_PROBE)
4699                 spec->micmute_led_polarity = 1;
4700         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4701 }
4702
4703 static void alc236_fixup_hp_coef_micmute_led(struct hda_codec *codec,
4704                                 const struct hda_fixup *fix, int action)
4705 {
4706         struct alc_spec *spec = codec->spec;
4707
4708         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4709                 spec->mic_led_coef.idx = 0x35;
4710                 spec->mic_led_coef.mask = 3 << 2;
4711                 spec->mic_led_coef.on = 2 << 2;
4712                 spec->mic_led_coef.off = 1 << 2;
4713                 snd_hda_gen_add_micmute_led_cdev(codec, coef_micmute_led_set);
4714         }
4715 }
4716
4717 static void alc285_fixup_hp_mute_led(struct hda_codec *codec,
4718                                 const struct hda_fixup *fix, int action)
4719 {
4720         alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4721         alc285_fixup_hp_coef_micmute_led(codec, fix, action);
4722 }
4723
4724 static void alc285_fixup_hp_spectre_x360_mute_led(struct hda_codec *codec,
4725                                 const struct hda_fixup *fix, int action)
4726 {
4727         alc285_fixup_hp_mute_led_coefbit(codec, fix, action);
4728         alc285_fixup_hp_gpio_micmute_led(codec, fix, action);
4729 }
4730
4731 static void alc236_fixup_hp_mute_led(struct hda_codec *codec,
4732                                 const struct hda_fixup *fix, int action)
4733 {
4734         alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4735         alc236_fixup_hp_coef_micmute_led(codec, fix, action);
4736 }
4737
4738 static void alc236_fixup_hp_micmute_led_vref(struct hda_codec *codec,
4739                                 const struct hda_fixup *fix, int action)
4740 {
4741         struct alc_spec *spec = codec->spec;
4742
4743         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4744                 spec->cap_mute_led_nid = 0x1a;
4745                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4746                 codec->power_filter = led_power_filter;
4747         }
4748 }
4749
4750 static void alc236_fixup_hp_mute_led_micmute_vref(struct hda_codec *codec,
4751                                 const struct hda_fixup *fix, int action)
4752 {
4753         alc236_fixup_hp_mute_led_coefbit(codec, fix, action);
4754         alc236_fixup_hp_micmute_led_vref(codec, fix, action);
4755 }
4756
4757 static inline void alc298_samsung_write_coef_pack(struct hda_codec *codec,
4758                                                   const unsigned short coefs[2])
4759 {
4760         alc_write_coef_idx(codec, 0x23, coefs[0]);
4761         alc_write_coef_idx(codec, 0x25, coefs[1]);
4762         alc_write_coef_idx(codec, 0x26, 0xb011);
4763 }
4764
4765 struct alc298_samsung_amp_desc {
4766         unsigned char nid;
4767         unsigned short init_seq[2][2];
4768 };
4769
4770 static void alc298_fixup_samsung_amp(struct hda_codec *codec,
4771                                      const struct hda_fixup *fix, int action)
4772 {
4773         int i, j;
4774         static const unsigned short init_seq[][2] = {
4775                 { 0x19, 0x00 }, { 0x20, 0xc0 }, { 0x22, 0x44 }, { 0x23, 0x08 },
4776                 { 0x24, 0x85 }, { 0x25, 0x41 }, { 0x35, 0x40 }, { 0x36, 0x01 },
4777                 { 0x38, 0x81 }, { 0x3a, 0x03 }, { 0x3b, 0x81 }, { 0x40, 0x3e },
4778                 { 0x41, 0x07 }, { 0x400, 0x1 }
4779         };
4780         static const struct alc298_samsung_amp_desc amps[] = {
4781                 { 0x3a, { { 0x18, 0x1 }, { 0x26, 0x0 } } },
4782                 { 0x39, { { 0x18, 0x2 }, { 0x26, 0x1 } } }
4783         };
4784
4785         if (action != HDA_FIXUP_ACT_INIT)
4786                 return;
4787
4788         for (i = 0; i < ARRAY_SIZE(amps); i++) {
4789                 alc_write_coef_idx(codec, 0x22, amps[i].nid);
4790
4791                 for (j = 0; j < ARRAY_SIZE(amps[i].init_seq); j++)
4792                         alc298_samsung_write_coef_pack(codec, amps[i].init_seq[j]);
4793
4794                 for (j = 0; j < ARRAY_SIZE(init_seq); j++)
4795                         alc298_samsung_write_coef_pack(codec, init_seq[j]);
4796         }
4797 }
4798
4799 #if IS_REACHABLE(CONFIG_INPUT)
4800 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
4801                                    struct hda_jack_callback *event)
4802 {
4803         struct alc_spec *spec = codec->spec;
4804
4805         /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
4806            send both key on and key off event for every interrupt. */
4807         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 1);
4808         input_sync(spec->kb_dev);
4809         input_report_key(spec->kb_dev, spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX], 0);
4810         input_sync(spec->kb_dev);
4811 }
4812
4813 static int alc_register_micmute_input_device(struct hda_codec *codec)
4814 {
4815         struct alc_spec *spec = codec->spec;
4816         int i;
4817
4818         spec->kb_dev = input_allocate_device();
4819         if (!spec->kb_dev) {
4820                 codec_err(codec, "Out of memory (input_allocate_device)\n");
4821                 return -ENOMEM;
4822         }
4823
4824         spec->alc_mute_keycode_map[ALC_KEY_MICMUTE_INDEX] = KEY_MICMUTE;
4825
4826         spec->kb_dev->name = "Microphone Mute Button";
4827         spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
4828         spec->kb_dev->keycodesize = sizeof(spec->alc_mute_keycode_map[0]);
4829         spec->kb_dev->keycodemax = ARRAY_SIZE(spec->alc_mute_keycode_map);
4830         spec->kb_dev->keycode = spec->alc_mute_keycode_map;
4831         for (i = 0; i < ARRAY_SIZE(spec->alc_mute_keycode_map); i++)
4832                 set_bit(spec->alc_mute_keycode_map[i], spec->kb_dev->keybit);
4833
4834         if (input_register_device(spec->kb_dev)) {
4835                 codec_err(codec, "input_register_device failed\n");
4836                 input_free_device(spec->kb_dev);
4837                 spec->kb_dev = NULL;
4838                 return -ENOMEM;
4839         }
4840
4841         return 0;
4842 }
4843
4844 /* GPIO1 = set according to SKU external amp
4845  * GPIO2 = mic mute hotkey
4846  * GPIO3 = mute LED
4847  * GPIO4 = mic mute LED
4848  */
4849 static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
4850                                              const struct hda_fixup *fix, int action)
4851 {
4852         struct alc_spec *spec = codec->spec;
4853
4854         alc_fixup_hp_gpio_led(codec, action, 0x08, 0x10);
4855         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4856                 spec->init_amp = ALC_INIT_DEFAULT;
4857                 if (alc_register_micmute_input_device(codec) != 0)
4858                         return;
4859
4860                 spec->gpio_mask |= 0x06;
4861                 spec->gpio_dir |= 0x02;
4862                 spec->gpio_data |= 0x02;
4863                 snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4864                                           AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
4865                 snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4866                                                     gpio2_mic_hotkey_event);
4867                 return;
4868         }
4869
4870         if (!spec->kb_dev)
4871                 return;
4872
4873         switch (action) {
4874         case HDA_FIXUP_ACT_FREE:
4875                 input_unregister_device(spec->kb_dev);
4876                 spec->kb_dev = NULL;
4877         }
4878 }
4879
4880 /* Line2 = mic mute hotkey
4881  * GPIO2 = mic mute LED
4882  */
4883 static void alc233_fixup_lenovo_line2_mic_hotkey(struct hda_codec *codec,
4884                                              const struct hda_fixup *fix, int action)
4885 {
4886         struct alc_spec *spec = codec->spec;
4887
4888         alc_fixup_hp_gpio_led(codec, action, 0, 0x04);
4889         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4890                 spec->init_amp = ALC_INIT_DEFAULT;
4891                 if (alc_register_micmute_input_device(codec) != 0)
4892                         return;
4893
4894                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
4895                                                     gpio2_mic_hotkey_event);
4896                 return;
4897         }
4898
4899         if (!spec->kb_dev)
4900                 return;
4901
4902         switch (action) {
4903         case HDA_FIXUP_ACT_FREE:
4904                 input_unregister_device(spec->kb_dev);
4905                 spec->kb_dev = NULL;
4906         }
4907 }
4908 #else /* INPUT */
4909 #define alc280_fixup_hp_gpio2_mic_hotkey        NULL
4910 #define alc233_fixup_lenovo_line2_mic_hotkey    NULL
4911 #endif /* INPUT */
4912
4913 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
4914                                 const struct hda_fixup *fix, int action)
4915 {
4916         struct alc_spec *spec = codec->spec;
4917
4918         alc269_fixup_hp_mute_led_micx(codec, fix, action, 0x1a);
4919         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4920                 spec->cap_mute_led_nid = 0x18;
4921                 snd_hda_gen_add_micmute_led_cdev(codec, vref_micmute_led_set);
4922         }
4923 }
4924
4925 static const struct coef_fw alc225_pre_hsmode[] = {
4926         UPDATE_COEF(0x4a, 1<<8, 0),
4927         UPDATE_COEFEX(0x57, 0x05, 1<<14, 0),
4928         UPDATE_COEF(0x63, 3<<14, 3<<14),
4929         UPDATE_COEF(0x4a, 3<<4, 2<<4),
4930         UPDATE_COEF(0x4a, 3<<10, 3<<10),
4931         UPDATE_COEF(0x45, 0x3f<<10, 0x34<<10),
4932         UPDATE_COEF(0x4a, 3<<10, 0),
4933         {}
4934 };
4935
4936 static void alc_headset_mode_unplugged(struct hda_codec *codec)
4937 {
4938         struct alc_spec *spec = codec->spec;
4939         static const struct coef_fw coef0255[] = {
4940                 WRITE_COEF(0x1b, 0x0c0b), /* LDO and MISC control */
4941                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4942                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4943                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4944                 WRITE_COEFEX(0x57, 0x03, 0x8aa6), /* Direct Drive HP Amp control */
4945                 {}
4946         };
4947         static const struct coef_fw coef0256[] = {
4948                 WRITE_COEF(0x1b, 0x0c4b), /* LDO and MISC control */
4949                 WRITE_COEF(0x45, 0xd089), /* UAJ function set to menual mode */
4950                 WRITE_COEF(0x06, 0x6104), /* Set MIC2 Vref gate with HP */
4951                 WRITE_COEFEX(0x57, 0x03, 0x09a3), /* Direct Drive HP Amp control */
4952                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
4953                 {}
4954         };
4955         static const struct coef_fw coef0233[] = {
4956                 WRITE_COEF(0x1b, 0x0c0b),
4957                 WRITE_COEF(0x45, 0xc429),
4958                 UPDATE_COEF(0x35, 0x4000, 0),
4959                 WRITE_COEF(0x06, 0x2104),
4960                 WRITE_COEF(0x1a, 0x0001),
4961                 WRITE_COEF(0x26, 0x0004),
4962                 WRITE_COEF(0x32, 0x42a3),
4963                 {}
4964         };
4965         static const struct coef_fw coef0288[] = {
4966                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
4967                 UPDATE_COEF(0x50, 0x2000, 0x2000),
4968                 UPDATE_COEF(0x56, 0x0006, 0x0006),
4969                 UPDATE_COEF(0x66, 0x0008, 0),
4970                 UPDATE_COEF(0x67, 0x2000, 0),
4971                 {}
4972         };
4973         static const struct coef_fw coef0298[] = {
4974                 UPDATE_COEF(0x19, 0x1300, 0x0300),
4975                 {}
4976         };
4977         static const struct coef_fw coef0292[] = {
4978                 WRITE_COEF(0x76, 0x000e),
4979                 WRITE_COEF(0x6c, 0x2400),
4980                 WRITE_COEF(0x18, 0x7308),
4981                 WRITE_COEF(0x6b, 0xc429),
4982                 {}
4983         };
4984         static const struct coef_fw coef0293[] = {
4985                 UPDATE_COEF(0x10, 7<<8, 6<<8), /* SET Line1 JD to 0 */
4986                 UPDATE_COEFEX(0x57, 0x05, 1<<15|1<<13, 0x0), /* SET charge pump by verb */
4987                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 1<<10), /* SET EN_OSW to 1 */
4988                 UPDATE_COEF(0x1a, 1<<3, 1<<3), /* Combo JD gating with LINE1-VREFO */
4989                 WRITE_COEF(0x45, 0xc429), /* Set to TRS type */
4990                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
4991                 {}
4992         };
4993         static const struct coef_fw coef0668[] = {
4994                 WRITE_COEF(0x15, 0x0d40),
4995                 WRITE_COEF(0xb7, 0x802b),
4996                 {}
4997         };
4998         static const struct coef_fw coef0225[] = {
4999                 UPDATE_COEF(0x63, 3<<14, 0),
5000                 {}
5001         };
5002         static const struct coef_fw coef0274[] = {
5003                 UPDATE_COEF(0x4a, 0x0100, 0),
5004                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0),
5005                 UPDATE_COEF(0x6b, 0xf000, 0x5000),
5006                 UPDATE_COEF(0x4a, 0x0010, 0),
5007                 UPDATE_COEF(0x4a, 0x0c00, 0x0c00),
5008                 WRITE_COEF(0x45, 0x5289),
5009                 UPDATE_COEF(0x4a, 0x0c00, 0),
5010                 {}
5011         };
5012
5013         if (spec->no_internal_mic_pin) {
5014                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5015                 return;
5016         }
5017
5018         switch (codec->core.vendor_id) {
5019         case 0x10ec0255:
5020                 alc_process_coef_fw(codec, coef0255);
5021                 break;
5022         case 0x10ec0230:
5023         case 0x10ec0236:
5024         case 0x10ec0256:
5025         case 0x19e58326:
5026                 alc_process_coef_fw(codec, coef0256);
5027                 break;
5028         case 0x10ec0234:
5029         case 0x10ec0274:
5030         case 0x10ec0294:
5031                 alc_process_coef_fw(codec, coef0274);
5032                 break;
5033         case 0x10ec0233:
5034         case 0x10ec0283:
5035                 alc_process_coef_fw(codec, coef0233);
5036                 break;
5037         case 0x10ec0286:
5038         case 0x10ec0288:
5039                 alc_process_coef_fw(codec, coef0288);
5040                 break;
5041         case 0x10ec0298:
5042                 alc_process_coef_fw(codec, coef0298);
5043                 alc_process_coef_fw(codec, coef0288);
5044                 break;
5045         case 0x10ec0292:
5046                 alc_process_coef_fw(codec, coef0292);
5047                 break;
5048         case 0x10ec0293:
5049                 alc_process_coef_fw(codec, coef0293);
5050                 break;
5051         case 0x10ec0668:
5052                 alc_process_coef_fw(codec, coef0668);
5053                 break;
5054         case 0x10ec0215:
5055         case 0x10ec0225:
5056         case 0x10ec0285:
5057         case 0x10ec0295:
5058         case 0x10ec0289:
5059         case 0x10ec0299:
5060                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5061                 alc_process_coef_fw(codec, coef0225);
5062                 break;
5063         case 0x10ec0867:
5064                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5065                 break;
5066         }
5067         codec_dbg(codec, "Headset jack set to unplugged mode.\n");
5068 }
5069
5070
5071 static void alc_headset_mode_mic_in(struct hda_codec *codec, hda_nid_t hp_pin,
5072                                     hda_nid_t mic_pin)
5073 {
5074         static const struct coef_fw coef0255[] = {
5075                 WRITE_COEFEX(0x57, 0x03, 0x8aa6),
5076                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5077                 {}
5078         };
5079         static const struct coef_fw coef0256[] = {
5080                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14), /* Direct Drive HP Amp control(Set to verb control)*/
5081                 WRITE_COEFEX(0x57, 0x03, 0x09a3),
5082                 WRITE_COEF(0x06, 0x6100), /* Set MIC2 Vref gate to normal */
5083                 {}
5084         };
5085         static const struct coef_fw coef0233[] = {
5086                 UPDATE_COEF(0x35, 0, 1<<14),
5087                 WRITE_COEF(0x06, 0x2100),
5088                 WRITE_COEF(0x1a, 0x0021),
5089                 WRITE_COEF(0x26, 0x008c),
5090                 {}
5091         };
5092         static const struct coef_fw coef0288[] = {
5093                 UPDATE_COEF(0x4f, 0x00c0, 0),
5094                 UPDATE_COEF(0x50, 0x2000, 0),
5095                 UPDATE_COEF(0x56, 0x0006, 0),
5096                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400),
5097                 UPDATE_COEF(0x66, 0x0008, 0x0008),
5098                 UPDATE_COEF(0x67, 0x2000, 0x2000),
5099                 {}
5100         };
5101         static const struct coef_fw coef0292[] = {
5102                 WRITE_COEF(0x19, 0xa208),
5103                 WRITE_COEF(0x2e, 0xacf0),
5104                 {}
5105         };
5106         static const struct coef_fw coef0293[] = {
5107                 UPDATE_COEFEX(0x57, 0x05, 0, 1<<15|1<<13), /* SET charge pump by verb */
5108                 UPDATE_COEFEX(0x57, 0x03, 1<<10, 0), /* SET EN_OSW to 0 */
5109                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5110                 {}
5111         };
5112         static const struct coef_fw coef0688[] = {
5113                 WRITE_COEF(0xb7, 0x802b),
5114                 WRITE_COEF(0xb5, 0x1040),
5115                 UPDATE_COEF(0xc3, 0, 1<<12),
5116                 {}
5117         };
5118         static const struct coef_fw coef0225[] = {
5119                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 1<<14),
5120                 UPDATE_COEF(0x4a, 3<<4, 2<<4),
5121                 UPDATE_COEF(0x63, 3<<14, 0),
5122                 {}
5123         };
5124         static const struct coef_fw coef0274[] = {
5125                 UPDATE_COEFEX(0x57, 0x05, 0x4000, 0x4000),
5126                 UPDATE_COEF(0x4a, 0x0010, 0),
5127                 UPDATE_COEF(0x6b, 0xf000, 0),
5128                 {}
5129         };
5130
5131         switch (codec->core.vendor_id) {
5132         case 0x10ec0255:
5133                 alc_write_coef_idx(codec, 0x45, 0xc489);
5134                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5135                 alc_process_coef_fw(codec, coef0255);
5136                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5137                 break;
5138         case 0x10ec0230:
5139         case 0x10ec0236:
5140         case 0x10ec0256:
5141         case 0x19e58326:
5142                 alc_write_coef_idx(codec, 0x45, 0xc489);
5143                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5144                 alc_process_coef_fw(codec, coef0256);
5145                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5146                 break;
5147         case 0x10ec0234:
5148         case 0x10ec0274:
5149         case 0x10ec0294:
5150                 alc_write_coef_idx(codec, 0x45, 0x4689);
5151                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5152                 alc_process_coef_fw(codec, coef0274);
5153                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5154                 break;
5155         case 0x10ec0233:
5156         case 0x10ec0283:
5157                 alc_write_coef_idx(codec, 0x45, 0xc429);
5158                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5159                 alc_process_coef_fw(codec, coef0233);
5160                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5161                 break;
5162         case 0x10ec0286:
5163         case 0x10ec0288:
5164         case 0x10ec0298:
5165                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5166                 alc_process_coef_fw(codec, coef0288);
5167                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5168                 break;
5169         case 0x10ec0292:
5170                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5171                 alc_process_coef_fw(codec, coef0292);
5172                 break;
5173         case 0x10ec0293:
5174                 /* Set to TRS mode */
5175                 alc_write_coef_idx(codec, 0x45, 0xc429);
5176                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5177                 alc_process_coef_fw(codec, coef0293);
5178                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5179                 break;
5180         case 0x10ec0867:
5181                 alc_update_coefex_idx(codec, 0x57, 0x5, 0, 1<<14);
5182                 fallthrough;
5183         case 0x10ec0221:
5184         case 0x10ec0662:
5185                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5186                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5187                 break;
5188         case 0x10ec0668:
5189                 alc_write_coef_idx(codec, 0x11, 0x0001);
5190                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5191                 alc_process_coef_fw(codec, coef0688);
5192                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5193                 break;
5194         case 0x10ec0215:
5195         case 0x10ec0225:
5196         case 0x10ec0285:
5197         case 0x10ec0295:
5198         case 0x10ec0289:
5199         case 0x10ec0299:
5200                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5201                 alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x31<<10);
5202                 snd_hda_set_pin_ctl_cache(codec, hp_pin, 0);
5203                 alc_process_coef_fw(codec, coef0225);
5204                 snd_hda_set_pin_ctl_cache(codec, mic_pin, PIN_VREF50);
5205                 break;
5206         }
5207         codec_dbg(codec, "Headset jack set to mic-in mode.\n");
5208 }
5209
5210 static void alc_headset_mode_default(struct hda_codec *codec)
5211 {
5212         static const struct coef_fw coef0225[] = {
5213                 UPDATE_COEF(0x45, 0x3f<<10, 0x30<<10),
5214                 UPDATE_COEF(0x45, 0x3f<<10, 0x31<<10),
5215                 UPDATE_COEF(0x49, 3<<8, 0<<8),
5216                 UPDATE_COEF(0x4a, 3<<4, 3<<4),
5217                 UPDATE_COEF(0x63, 3<<14, 0),
5218                 UPDATE_COEF(0x67, 0xf000, 0x3000),
5219                 {}
5220         };
5221         static const struct coef_fw coef0255[] = {
5222                 WRITE_COEF(0x45, 0xc089),
5223                 WRITE_COEF(0x45, 0xc489),
5224                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5225                 WRITE_COEF(0x49, 0x0049),
5226                 {}
5227         };
5228         static const struct coef_fw coef0256[] = {
5229                 WRITE_COEF(0x45, 0xc489),
5230                 WRITE_COEFEX(0x57, 0x03, 0x0da3),
5231                 WRITE_COEF(0x49, 0x0049),
5232                 UPDATE_COEFEX(0x57, 0x05, 1<<14, 0), /* Direct Drive HP Amp control(Set to verb control)*/
5233                 WRITE_COEF(0x06, 0x6100),
5234                 {}
5235         };
5236         static const struct coef_fw coef0233[] = {
5237                 WRITE_COEF(0x06, 0x2100),
5238                 WRITE_COEF(0x32, 0x4ea3),
5239                 {}
5240         };
5241         static const struct coef_fw coef0288[] = {
5242                 UPDATE_COEF(0x4f, 0xfcc0, 0xc400), /* Set to TRS type */
5243                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5244                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5245                 UPDATE_COEF(0x66, 0x0008, 0),
5246                 UPDATE_COEF(0x67, 0x2000, 0),
5247                 {}
5248         };
5249         static const struct coef_fw coef0292[] = {
5250                 WRITE_COEF(0x76, 0x000e),
5251                 WRITE_COEF(0x6c, 0x2400),
5252                 WRITE_COEF(0x6b, 0xc429),
5253                 WRITE_COEF(0x18, 0x7308),
5254                 {}
5255         };
5256         static const struct coef_fw coef0293[] = {
5257                 UPDATE_COEF(0x4a, 0x000f, 0x000e), /* Combo Jack auto detect */
5258                 WRITE_COEF(0x45, 0xC429), /* Set to TRS type */
5259                 UPDATE_COEF(0x1a, 1<<3, 0), /* Combo JD gating without LINE1-VREFO */
5260                 {}
5261         };
5262         static const struct coef_fw coef0688[] = {
5263                 WRITE_COEF(0x11, 0x0041),
5264                 WRITE_COEF(0x15, 0x0d40),
5265                 WRITE_COEF(0xb7, 0x802b),
5266                 {}
5267         };
5268         static const struct coef_fw coef0274[] = {
5269                 WRITE_COEF(0x45, 0x4289),
5270                 UPDATE_COEF(0x4a, 0x0010, 0x0010),
5271                 UPDATE_COEF(0x6b, 0x0f00, 0),
5272                 UPDATE_COEF(0x49, 0x0300, 0x0300),
5273                 {}
5274         };
5275
5276         switch (codec->core.vendor_id) {
5277         case 0x10ec0215:
5278         case 0x10ec0225:
5279         case 0x10ec0285:
5280         case 0x10ec0295:
5281         case 0x10ec0289:
5282         case 0x10ec0299:
5283                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5284                 alc_process_coef_fw(codec, coef0225);
5285                 break;
5286         case 0x10ec0255:
5287                 alc_process_coef_fw(codec, coef0255);
5288                 break;
5289         case 0x10ec0230:
5290         case 0x10ec0236:
5291         case 0x10ec0256:
5292         case 0x19e58326:
5293                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5294                 alc_write_coef_idx(codec, 0x45, 0xc089);
5295                 msleep(50);
5296                 alc_process_coef_fw(codec, coef0256);
5297                 break;
5298         case 0x10ec0234:
5299         case 0x10ec0274:
5300         case 0x10ec0294:
5301                 alc_process_coef_fw(codec, coef0274);
5302                 break;
5303         case 0x10ec0233:
5304         case 0x10ec0283:
5305                 alc_process_coef_fw(codec, coef0233);
5306                 break;
5307         case 0x10ec0286:
5308         case 0x10ec0288:
5309         case 0x10ec0298:
5310                 alc_process_coef_fw(codec, coef0288);
5311                 break;
5312         case 0x10ec0292:
5313                 alc_process_coef_fw(codec, coef0292);
5314                 break;
5315         case 0x10ec0293:
5316                 alc_process_coef_fw(codec, coef0293);
5317                 break;
5318         case 0x10ec0668:
5319                 alc_process_coef_fw(codec, coef0688);
5320                 break;
5321         case 0x10ec0867:
5322                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5323                 break;
5324         }
5325         codec_dbg(codec, "Headset jack set to headphone (default) mode.\n");
5326 }
5327
5328 /* Iphone type */
5329 static void alc_headset_mode_ctia(struct hda_codec *codec)
5330 {
5331         int val;
5332
5333         static const struct coef_fw coef0255[] = {
5334                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5335                 WRITE_COEF(0x1b, 0x0c2b),
5336                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5337                 {}
5338         };
5339         static const struct coef_fw coef0256[] = {
5340                 WRITE_COEF(0x45, 0xd489), /* Set to CTIA type */
5341                 WRITE_COEF(0x1b, 0x0e6b),
5342                 {}
5343         };
5344         static const struct coef_fw coef0233[] = {
5345                 WRITE_COEF(0x45, 0xd429),
5346                 WRITE_COEF(0x1b, 0x0c2b),
5347                 WRITE_COEF(0x32, 0x4ea3),
5348                 {}
5349         };
5350         static const struct coef_fw coef0288[] = {
5351                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5352                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5353                 UPDATE_COEF(0x66, 0x0008, 0),
5354                 UPDATE_COEF(0x67, 0x2000, 0),
5355                 {}
5356         };
5357         static const struct coef_fw coef0292[] = {
5358                 WRITE_COEF(0x6b, 0xd429),
5359                 WRITE_COEF(0x76, 0x0008),
5360                 WRITE_COEF(0x18, 0x7388),
5361                 {}
5362         };
5363         static const struct coef_fw coef0293[] = {
5364                 WRITE_COEF(0x45, 0xd429), /* Set to ctia type */
5365                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5366                 {}
5367         };
5368         static const struct coef_fw coef0688[] = {
5369                 WRITE_COEF(0x11, 0x0001),
5370                 WRITE_COEF(0x15, 0x0d60),
5371                 WRITE_COEF(0xc3, 0x0000),
5372                 {}
5373         };
5374         static const struct coef_fw coef0225_1[] = {
5375                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5376                 UPDATE_COEF(0x63, 3<<14, 2<<14),
5377                 {}
5378         };
5379         static const struct coef_fw coef0225_2[] = {
5380                 UPDATE_COEF(0x45, 0x3f<<10, 0x35<<10),
5381                 UPDATE_COEF(0x63, 3<<14, 1<<14),
5382                 {}
5383         };
5384
5385         switch (codec->core.vendor_id) {
5386         case 0x10ec0255:
5387                 alc_process_coef_fw(codec, coef0255);
5388                 break;
5389         case 0x10ec0230:
5390         case 0x10ec0236:
5391         case 0x10ec0256:
5392         case 0x19e58326:
5393                 alc_process_coef_fw(codec, coef0256);
5394                 break;
5395         case 0x10ec0234:
5396         case 0x10ec0274:
5397         case 0x10ec0294:
5398                 alc_write_coef_idx(codec, 0x45, 0xd689);
5399                 break;
5400         case 0x10ec0233:
5401         case 0x10ec0283:
5402                 alc_process_coef_fw(codec, coef0233);
5403                 break;
5404         case 0x10ec0298:
5405                 val = alc_read_coef_idx(codec, 0x50);
5406                 if (val & (1 << 12)) {
5407                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5408                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5409                         msleep(300);
5410                 } else {
5411                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
5412                         alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5413                         msleep(300);
5414                 }
5415                 break;
5416         case 0x10ec0286:
5417         case 0x10ec0288:
5418                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xd400);
5419                 msleep(300);
5420                 alc_process_coef_fw(codec, coef0288);
5421                 break;
5422         case 0x10ec0292:
5423                 alc_process_coef_fw(codec, coef0292);
5424                 break;
5425         case 0x10ec0293:
5426                 alc_process_coef_fw(codec, coef0293);
5427                 break;
5428         case 0x10ec0668:
5429                 alc_process_coef_fw(codec, coef0688);
5430                 break;
5431         case 0x10ec0215:
5432         case 0x10ec0225:
5433         case 0x10ec0285:
5434         case 0x10ec0295:
5435         case 0x10ec0289:
5436         case 0x10ec0299:
5437                 val = alc_read_coef_idx(codec, 0x45);
5438                 if (val & (1 << 9))
5439                         alc_process_coef_fw(codec, coef0225_2);
5440                 else
5441                         alc_process_coef_fw(codec, coef0225_1);
5442                 break;
5443         case 0x10ec0867:
5444                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5445                 break;
5446         }
5447         codec_dbg(codec, "Headset jack set to iPhone-style headset mode.\n");
5448 }
5449
5450 /* Nokia type */
5451 static void alc_headset_mode_omtp(struct hda_codec *codec)
5452 {
5453         static const struct coef_fw coef0255[] = {
5454                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5455                 WRITE_COEF(0x1b, 0x0c2b),
5456                 WRITE_COEFEX(0x57, 0x03, 0x8ea6),
5457                 {}
5458         };
5459         static const struct coef_fw coef0256[] = {
5460                 WRITE_COEF(0x45, 0xe489), /* Set to OMTP Type */
5461                 WRITE_COEF(0x1b, 0x0e6b),
5462                 {}
5463         };
5464         static const struct coef_fw coef0233[] = {
5465                 WRITE_COEF(0x45, 0xe429),
5466                 WRITE_COEF(0x1b, 0x0c2b),
5467                 WRITE_COEF(0x32, 0x4ea3),
5468                 {}
5469         };
5470         static const struct coef_fw coef0288[] = {
5471                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5472                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5473                 UPDATE_COEF(0x66, 0x0008, 0),
5474                 UPDATE_COEF(0x67, 0x2000, 0),
5475                 {}
5476         };
5477         static const struct coef_fw coef0292[] = {
5478                 WRITE_COEF(0x6b, 0xe429),
5479                 WRITE_COEF(0x76, 0x0008),
5480                 WRITE_COEF(0x18, 0x7388),
5481                 {}
5482         };
5483         static const struct coef_fw coef0293[] = {
5484                 WRITE_COEF(0x45, 0xe429), /* Set to omtp type */
5485                 UPDATE_COEF(0x10, 7<<8, 7<<8), /* SET Line1 JD to 1 */
5486                 {}
5487         };
5488         static const struct coef_fw coef0688[] = {
5489                 WRITE_COEF(0x11, 0x0001),
5490                 WRITE_COEF(0x15, 0x0d50),
5491                 WRITE_COEF(0xc3, 0x0000),
5492                 {}
5493         };
5494         static const struct coef_fw coef0225[] = {
5495                 UPDATE_COEF(0x45, 0x3f<<10, 0x39<<10),
5496                 UPDATE_COEF(0x63, 3<<14, 2<<14),
5497                 {}
5498         };
5499
5500         switch (codec->core.vendor_id) {
5501         case 0x10ec0255:
5502                 alc_process_coef_fw(codec, coef0255);
5503                 break;
5504         case 0x10ec0230:
5505         case 0x10ec0236:
5506         case 0x10ec0256:
5507         case 0x19e58326:
5508                 alc_process_coef_fw(codec, coef0256);
5509                 break;
5510         case 0x10ec0234:
5511         case 0x10ec0274:
5512         case 0x10ec0294:
5513                 alc_write_coef_idx(codec, 0x45, 0xe689);
5514                 break;
5515         case 0x10ec0233:
5516         case 0x10ec0283:
5517                 alc_process_coef_fw(codec, coef0233);
5518                 break;
5519         case 0x10ec0298:
5520                 alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);/* Headset output enable */
5521                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5522                 msleep(300);
5523                 break;
5524         case 0x10ec0286:
5525         case 0x10ec0288:
5526                 alc_update_coef_idx(codec, 0x4f, 0xfcc0, 0xe400);
5527                 msleep(300);
5528                 alc_process_coef_fw(codec, coef0288);
5529                 break;
5530         case 0x10ec0292:
5531                 alc_process_coef_fw(codec, coef0292);
5532                 break;
5533         case 0x10ec0293:
5534                 alc_process_coef_fw(codec, coef0293);
5535                 break;
5536         case 0x10ec0668:
5537                 alc_process_coef_fw(codec, coef0688);
5538                 break;
5539         case 0x10ec0215:
5540         case 0x10ec0225:
5541         case 0x10ec0285:
5542         case 0x10ec0295:
5543         case 0x10ec0289:
5544         case 0x10ec0299:
5545                 alc_process_coef_fw(codec, coef0225);
5546                 break;
5547         }
5548         codec_dbg(codec, "Headset jack set to Nokia-style headset mode.\n");
5549 }
5550
5551 static void alc_determine_headset_type(struct hda_codec *codec)
5552 {
5553         int val;
5554         bool is_ctia = false;
5555         struct alc_spec *spec = codec->spec;
5556         static const struct coef_fw coef0255[] = {
5557                 WRITE_COEF(0x45, 0xd089), /* combo jack auto switch control(Check type)*/
5558                 WRITE_COEF(0x49, 0x0149), /* combo jack auto switch control(Vref
5559  conteol) */
5560                 {}
5561         };
5562         static const struct coef_fw coef0288[] = {
5563                 UPDATE_COEF(0x4f, 0xfcc0, 0xd400), /* Check Type */
5564                 {}
5565         };
5566         static const struct coef_fw coef0298[] = {
5567                 UPDATE_COEF(0x50, 0x2000, 0x2000),
5568                 UPDATE_COEF(0x56, 0x0006, 0x0006),
5569                 UPDATE_COEF(0x66, 0x0008, 0),
5570                 UPDATE_COEF(0x67, 0x2000, 0),
5571                 UPDATE_COEF(0x19, 0x1300, 0x1300),
5572                 {}
5573         };
5574         static const struct coef_fw coef0293[] = {
5575                 UPDATE_COEF(0x4a, 0x000f, 0x0008), /* Combo Jack auto detect */
5576                 WRITE_COEF(0x45, 0xD429), /* Set to ctia type */
5577                 {}
5578         };
5579         static const struct coef_fw coef0688[] = {
5580                 WRITE_COEF(0x11, 0x0001),
5581                 WRITE_COEF(0xb7, 0x802b),
5582                 WRITE_COEF(0x15, 0x0d60),
5583                 WRITE_COEF(0xc3, 0x0c00),
5584                 {}
5585         };
5586         static const struct coef_fw coef0274[] = {
5587                 UPDATE_COEF(0x4a, 0x0010, 0),
5588                 UPDATE_COEF(0x4a, 0x8000, 0),
5589                 WRITE_COEF(0x45, 0xd289),
5590                 UPDATE_COEF(0x49, 0x0300, 0x0300),
5591                 {}
5592         };
5593
5594         if (spec->no_internal_mic_pin) {
5595                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
5596                 return;
5597         }
5598
5599         switch (codec->core.vendor_id) {
5600         case 0x10ec0255:
5601                 alc_process_coef_fw(codec, coef0255);
5602                 msleep(300);
5603                 val = alc_read_coef_idx(codec, 0x46);
5604                 is_ctia = (val & 0x0070) == 0x0070;
5605                 break;
5606         case 0x10ec0230:
5607         case 0x10ec0236:
5608         case 0x10ec0256:
5609         case 0x19e58326:
5610                 alc_write_coef_idx(codec, 0x1b, 0x0e4b);
5611                 alc_write_coef_idx(codec, 0x06, 0x6104);
5612                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x09a3);
5613
5614                 snd_hda_codec_write(codec, 0x21, 0,
5615                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5616                 msleep(80);
5617                 snd_hda_codec_write(codec, 0x21, 0,
5618                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5619
5620                 alc_process_coef_fw(codec, coef0255);
5621                 msleep(300);
5622                 val = alc_read_coef_idx(codec, 0x46);
5623                 is_ctia = (val & 0x0070) == 0x0070;
5624
5625                 alc_write_coefex_idx(codec, 0x57, 0x3, 0x0da3);
5626                 alc_update_coefex_idx(codec, 0x57, 0x5, 1<<14, 0);
5627
5628                 snd_hda_codec_write(codec, 0x21, 0,
5629                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5630                 msleep(80);
5631                 snd_hda_codec_write(codec, 0x21, 0,
5632                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5633                 break;
5634         case 0x10ec0234:
5635         case 0x10ec0274:
5636         case 0x10ec0294:
5637                 alc_process_coef_fw(codec, coef0274);
5638                 msleep(850);
5639                 val = alc_read_coef_idx(codec, 0x46);
5640                 is_ctia = (val & 0x00f0) == 0x00f0;
5641                 break;
5642         case 0x10ec0233:
5643         case 0x10ec0283:
5644                 alc_write_coef_idx(codec, 0x45, 0xd029);
5645                 msleep(300);
5646                 val = alc_read_coef_idx(codec, 0x46);
5647                 is_ctia = (val & 0x0070) == 0x0070;
5648                 break;
5649         case 0x10ec0298:
5650                 snd_hda_codec_write(codec, 0x21, 0,
5651                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5652                 msleep(100);
5653                 snd_hda_codec_write(codec, 0x21, 0,
5654                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5655                 msleep(200);
5656
5657                 val = alc_read_coef_idx(codec, 0x50);
5658                 if (val & (1 << 12)) {
5659                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0020);
5660                         alc_process_coef_fw(codec, coef0288);
5661                         msleep(350);
5662                         val = alc_read_coef_idx(codec, 0x50);
5663                         is_ctia = (val & 0x0070) == 0x0070;
5664                 } else {
5665                         alc_update_coef_idx(codec, 0x8e, 0x0070, 0x0010);
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                 }
5671                 alc_process_coef_fw(codec, coef0298);
5672                 snd_hda_codec_write(codec, 0x21, 0,
5673                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
5674                 msleep(75);
5675                 snd_hda_codec_write(codec, 0x21, 0,
5676                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5677                 break;
5678         case 0x10ec0286:
5679         case 0x10ec0288:
5680                 alc_process_coef_fw(codec, coef0288);
5681                 msleep(350);
5682                 val = alc_read_coef_idx(codec, 0x50);
5683                 is_ctia = (val & 0x0070) == 0x0070;
5684                 break;
5685         case 0x10ec0292:
5686                 alc_write_coef_idx(codec, 0x6b, 0xd429);
5687                 msleep(300);
5688                 val = alc_read_coef_idx(codec, 0x6c);
5689                 is_ctia = (val & 0x001c) == 0x001c;
5690                 break;
5691         case 0x10ec0293:
5692                 alc_process_coef_fw(codec, coef0293);
5693                 msleep(300);
5694                 val = alc_read_coef_idx(codec, 0x46);
5695                 is_ctia = (val & 0x0070) == 0x0070;
5696                 break;
5697         case 0x10ec0668:
5698                 alc_process_coef_fw(codec, coef0688);
5699                 msleep(300);
5700                 val = alc_read_coef_idx(codec, 0xbe);
5701                 is_ctia = (val & 0x1c02) == 0x1c02;
5702                 break;
5703         case 0x10ec0215:
5704         case 0x10ec0225:
5705         case 0x10ec0285:
5706         case 0x10ec0295:
5707         case 0x10ec0289:
5708         case 0x10ec0299:
5709                 snd_hda_codec_write(codec, 0x21, 0,
5710                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
5711                 msleep(80);
5712                 snd_hda_codec_write(codec, 0x21, 0,
5713                             AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
5714
5715                 alc_process_coef_fw(codec, alc225_pre_hsmode);
5716                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x1000);
5717                 val = alc_read_coef_idx(codec, 0x45);
5718                 if (val & (1 << 9)) {
5719                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5720                         alc_update_coef_idx(codec, 0x49, 3<<8, 2<<8);
5721                         msleep(800);
5722                         val = alc_read_coef_idx(codec, 0x46);
5723                         is_ctia = (val & 0x00f0) == 0x00f0;
5724                 } else {
5725                         alc_update_coef_idx(codec, 0x45, 0x3f<<10, 0x34<<10);
5726                         alc_update_coef_idx(codec, 0x49, 3<<8, 1<<8);
5727                         msleep(800);
5728                         val = alc_read_coef_idx(codec, 0x46);
5729                         is_ctia = (val & 0x00f0) == 0x00f0;
5730                 }
5731                 alc_update_coef_idx(codec, 0x4a, 7<<6, 7<<6);
5732                 alc_update_coef_idx(codec, 0x4a, 3<<4, 3<<4);
5733                 alc_update_coef_idx(codec, 0x67, 0xf000, 0x3000);
5734
5735                 snd_hda_codec_write(codec, 0x21, 0,
5736                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
5737                 msleep(80);
5738                 snd_hda_codec_write(codec, 0x21, 0,
5739                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
5740                 break;
5741         case 0x10ec0867:
5742                 is_ctia = true;
5743                 break;
5744         }
5745
5746         codec_dbg(codec, "Headset jack detected iPhone-style headset: %s\n",
5747                     is_ctia ? "yes" : "no");
5748         spec->current_headset_type = is_ctia ? ALC_HEADSET_TYPE_CTIA : ALC_HEADSET_TYPE_OMTP;
5749 }
5750
5751 static void alc_update_headset_mode(struct hda_codec *codec)
5752 {
5753         struct alc_spec *spec = codec->spec;
5754
5755         hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
5756         hda_nid_t hp_pin = alc_get_hp_pin(spec);
5757
5758         int new_headset_mode;
5759
5760         if (!snd_hda_jack_detect(codec, hp_pin))
5761                 new_headset_mode = ALC_HEADSET_MODE_UNPLUGGED;
5762         else if (mux_pin == spec->headset_mic_pin)
5763                 new_headset_mode = ALC_HEADSET_MODE_HEADSET;
5764         else if (mux_pin == spec->headphone_mic_pin)
5765                 new_headset_mode = ALC_HEADSET_MODE_MIC;
5766         else
5767                 new_headset_mode = ALC_HEADSET_MODE_HEADPHONE;
5768
5769         if (new_headset_mode == spec->current_headset_mode) {
5770                 snd_hda_gen_update_outputs(codec);
5771                 return;
5772         }
5773
5774         switch (new_headset_mode) {
5775         case ALC_HEADSET_MODE_UNPLUGGED:
5776                 alc_headset_mode_unplugged(codec);
5777                 spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5778                 spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5779                 spec->gen.hp_jack_present = false;
5780                 break;
5781         case ALC_HEADSET_MODE_HEADSET:
5782                 if (spec->current_headset_type == ALC_HEADSET_TYPE_UNKNOWN)
5783                         alc_determine_headset_type(codec);
5784                 if (spec->current_headset_type == ALC_HEADSET_TYPE_CTIA)
5785                         alc_headset_mode_ctia(codec);
5786                 else if (spec->current_headset_type == ALC_HEADSET_TYPE_OMTP)
5787                         alc_headset_mode_omtp(codec);
5788                 spec->gen.hp_jack_present = true;
5789                 break;
5790         case ALC_HEADSET_MODE_MIC:
5791                 alc_headset_mode_mic_in(codec, hp_pin, spec->headphone_mic_pin);
5792                 spec->gen.hp_jack_present = false;
5793                 break;
5794         case ALC_HEADSET_MODE_HEADPHONE:
5795                 alc_headset_mode_default(codec);
5796                 spec->gen.hp_jack_present = true;
5797                 break;
5798         }
5799         if (new_headset_mode != ALC_HEADSET_MODE_MIC) {
5800                 snd_hda_set_pin_ctl_cache(codec, hp_pin,
5801                                           AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
5802                 if (spec->headphone_mic_pin && spec->headphone_mic_pin != hp_pin)
5803                         snd_hda_set_pin_ctl_cache(codec, spec->headphone_mic_pin,
5804                                                   PIN_VREFHIZ);
5805         }
5806         spec->current_headset_mode = new_headset_mode;
5807
5808         snd_hda_gen_update_outputs(codec);
5809 }
5810
5811 static void alc_update_headset_mode_hook(struct hda_codec *codec,
5812                                          struct snd_kcontrol *kcontrol,
5813                                          struct snd_ctl_elem_value *ucontrol)
5814 {
5815         alc_update_headset_mode(codec);
5816 }
5817
5818 static void alc_update_headset_jack_cb(struct hda_codec *codec,
5819                                        struct hda_jack_callback *jack)
5820 {
5821         snd_hda_gen_hp_automute(codec, jack);
5822         alc_update_headset_mode(codec);
5823 }
5824
5825 static void alc_probe_headset_mode(struct hda_codec *codec)
5826 {
5827         int i;
5828         struct alc_spec *spec = codec->spec;
5829         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
5830
5831         /* Find mic pins */
5832         for (i = 0; i < cfg->num_inputs; i++) {
5833                 if (cfg->inputs[i].is_headset_mic && !spec->headset_mic_pin)
5834                         spec->headset_mic_pin = cfg->inputs[i].pin;
5835                 if (cfg->inputs[i].is_headphone_mic && !spec->headphone_mic_pin)
5836                         spec->headphone_mic_pin = cfg->inputs[i].pin;
5837         }
5838
5839         WARN_ON(spec->gen.cap_sync_hook);
5840         spec->gen.cap_sync_hook = alc_update_headset_mode_hook;
5841         spec->gen.automute_hook = alc_update_headset_mode;
5842         spec->gen.hp_automute_hook = alc_update_headset_jack_cb;
5843 }
5844
5845 static void alc_fixup_headset_mode(struct hda_codec *codec,
5846                                 const struct hda_fixup *fix, int action)
5847 {
5848         struct alc_spec *spec = codec->spec;
5849
5850         switch (action) {
5851         case HDA_FIXUP_ACT_PRE_PROBE:
5852                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC | HDA_PINCFG_HEADPHONE_MIC;
5853                 break;
5854         case HDA_FIXUP_ACT_PROBE:
5855                 alc_probe_headset_mode(codec);
5856                 break;
5857         case HDA_FIXUP_ACT_INIT:
5858                 if (is_s3_resume(codec) || is_s4_resume(codec)) {
5859                         spec->current_headset_mode = ALC_HEADSET_MODE_UNKNOWN;
5860                         spec->current_headset_type = ALC_HEADSET_TYPE_UNKNOWN;
5861                 }
5862                 alc_update_headset_mode(codec);
5863                 break;
5864         }
5865 }
5866
5867 static void alc_fixup_headset_mode_no_hp_mic(struct hda_codec *codec,
5868                                 const struct hda_fixup *fix, int action)
5869 {
5870         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5871                 struct alc_spec *spec = codec->spec;
5872                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5873         }
5874         else
5875                 alc_fixup_headset_mode(codec, fix, action);
5876 }
5877
5878 static void alc255_set_default_jack_type(struct hda_codec *codec)
5879 {
5880         /* Set to iphone type */
5881         static const struct coef_fw alc255fw[] = {
5882                 WRITE_COEF(0x1b, 0x880b),
5883                 WRITE_COEF(0x45, 0xd089),
5884                 WRITE_COEF(0x1b, 0x080b),
5885                 WRITE_COEF(0x46, 0x0004),
5886                 WRITE_COEF(0x1b, 0x0c0b),
5887                 {}
5888         };
5889         static const struct coef_fw alc256fw[] = {
5890                 WRITE_COEF(0x1b, 0x884b),
5891                 WRITE_COEF(0x45, 0xd089),
5892                 WRITE_COEF(0x1b, 0x084b),
5893                 WRITE_COEF(0x46, 0x0004),
5894                 WRITE_COEF(0x1b, 0x0c4b),
5895                 {}
5896         };
5897         switch (codec->core.vendor_id) {
5898         case 0x10ec0255:
5899                 alc_process_coef_fw(codec, alc255fw);
5900                 break;
5901         case 0x10ec0230:
5902         case 0x10ec0236:
5903         case 0x10ec0256:
5904         case 0x19e58326:
5905                 alc_process_coef_fw(codec, alc256fw);
5906                 break;
5907         }
5908         msleep(30);
5909 }
5910
5911 static void alc_fixup_headset_mode_alc255(struct hda_codec *codec,
5912                                 const struct hda_fixup *fix, int action)
5913 {
5914         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5915                 alc255_set_default_jack_type(codec);
5916         }
5917         alc_fixup_headset_mode(codec, fix, action);
5918 }
5919
5920 static void alc_fixup_headset_mode_alc255_no_hp_mic(struct hda_codec *codec,
5921                                 const struct hda_fixup *fix, int action)
5922 {
5923         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5924                 struct alc_spec *spec = codec->spec;
5925                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
5926                 alc255_set_default_jack_type(codec);
5927         }
5928         else
5929                 alc_fixup_headset_mode(codec, fix, action);
5930 }
5931
5932 static void alc288_update_headset_jack_cb(struct hda_codec *codec,
5933                                        struct hda_jack_callback *jack)
5934 {
5935         struct alc_spec *spec = codec->spec;
5936
5937         alc_update_headset_jack_cb(codec, jack);
5938         /* Headset Mic enable or disable, only for Dell Dino */
5939         alc_update_gpio_data(codec, 0x40, spec->gen.hp_jack_present);
5940 }
5941
5942 static void alc_fixup_headset_mode_dell_alc288(struct hda_codec *codec,
5943                                 const struct hda_fixup *fix, int action)
5944 {
5945         alc_fixup_headset_mode(codec, fix, action);
5946         if (action == HDA_FIXUP_ACT_PROBE) {
5947                 struct alc_spec *spec = codec->spec;
5948                 /* toggled via hp_automute_hook */
5949                 spec->gpio_mask |= 0x40;
5950                 spec->gpio_dir |= 0x40;
5951                 spec->gen.hp_automute_hook = alc288_update_headset_jack_cb;
5952         }
5953 }
5954
5955 static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
5956                                         const struct hda_fixup *fix, int action)
5957 {
5958         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5959                 struct alc_spec *spec = codec->spec;
5960                 spec->gen.auto_mute_via_amp = 1;
5961         }
5962 }
5963
5964 static void alc_fixup_no_shutup(struct hda_codec *codec,
5965                                 const struct hda_fixup *fix, int action)
5966 {
5967         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5968                 struct alc_spec *spec = codec->spec;
5969                 spec->no_shutup_pins = 1;
5970         }
5971 }
5972
5973 static void alc_fixup_disable_aamix(struct hda_codec *codec,
5974                                     const struct hda_fixup *fix, int action)
5975 {
5976         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5977                 struct alc_spec *spec = codec->spec;
5978                 /* Disable AA-loopback as it causes white noise */
5979                 spec->gen.mixer_nid = 0;
5980         }
5981 }
5982
5983 /* fixup for Thinkpad docks: add dock pins, avoid HP parser fixup */
5984 static void alc_fixup_tpt440_dock(struct hda_codec *codec,
5985                                   const struct hda_fixup *fix, int action)
5986 {
5987         static const struct hda_pintbl pincfgs[] = {
5988                 { 0x16, 0x21211010 }, /* dock headphone */
5989                 { 0x19, 0x21a11010 }, /* dock mic */
5990                 { }
5991         };
5992         struct alc_spec *spec = codec->spec;
5993
5994         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
5995                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
5996                 codec->power_save_node = 0; /* avoid click noises */
5997                 snd_hda_apply_pincfgs(codec, pincfgs);
5998         }
5999 }
6000
6001 static void alc_fixup_tpt470_dock(struct hda_codec *codec,
6002                                   const struct hda_fixup *fix, int action)
6003 {
6004         static const struct hda_pintbl pincfgs[] = {
6005                 { 0x17, 0x21211010 }, /* dock headphone */
6006                 { 0x19, 0x21a11010 }, /* dock mic */
6007                 { }
6008         };
6009         struct alc_spec *spec = codec->spec;
6010
6011         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6012                 spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
6013                 snd_hda_apply_pincfgs(codec, pincfgs);
6014         } else if (action == HDA_FIXUP_ACT_INIT) {
6015                 /* Enable DOCK device */
6016                 snd_hda_codec_write(codec, 0x17, 0,
6017                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6018                 /* Enable DOCK device */
6019                 snd_hda_codec_write(codec, 0x19, 0,
6020                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0);
6021         }
6022 }
6023
6024 static void alc_fixup_tpt470_dacs(struct hda_codec *codec,
6025                                   const struct hda_fixup *fix, int action)
6026 {
6027         /* Assure the speaker pin to be coupled with DAC NID 0x03; otherwise
6028          * the speaker output becomes too low by some reason on Thinkpads with
6029          * ALC298 codec
6030          */
6031         static const hda_nid_t preferred_pairs[] = {
6032                 0x14, 0x03, 0x17, 0x02, 0x21, 0x02,
6033                 0
6034         };
6035         struct alc_spec *spec = codec->spec;
6036
6037         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6038                 spec->gen.preferred_dacs = preferred_pairs;
6039 }
6040
6041 static void alc295_fixup_asus_dacs(struct hda_codec *codec,
6042                                    const struct hda_fixup *fix, int action)
6043 {
6044         static const hda_nid_t preferred_pairs[] = {
6045                 0x17, 0x02, 0x21, 0x03, 0
6046         };
6047         struct alc_spec *spec = codec->spec;
6048
6049         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6050                 spec->gen.preferred_dacs = preferred_pairs;
6051 }
6052
6053 static void alc_shutup_dell_xps13(struct hda_codec *codec)
6054 {
6055         struct alc_spec *spec = codec->spec;
6056         int hp_pin = alc_get_hp_pin(spec);
6057
6058         /* Prevent pop noises when headphones are plugged in */
6059         snd_hda_codec_write(codec, hp_pin, 0,
6060                             AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
6061         msleep(20);
6062 }
6063
6064 static void alc_fixup_dell_xps13(struct hda_codec *codec,
6065                                 const struct hda_fixup *fix, int action)
6066 {
6067         struct alc_spec *spec = codec->spec;
6068         struct hda_input_mux *imux = &spec->gen.input_mux;
6069         int i;
6070
6071         switch (action) {
6072         case HDA_FIXUP_ACT_PRE_PROBE:
6073                 /* mic pin 0x19 must be initialized with Vref Hi-Z, otherwise
6074                  * it causes a click noise at start up
6075                  */
6076                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6077                 spec->shutup = alc_shutup_dell_xps13;
6078                 break;
6079         case HDA_FIXUP_ACT_PROBE:
6080                 /* Make the internal mic the default input source. */
6081                 for (i = 0; i < imux->num_items; i++) {
6082                         if (spec->gen.imux_pins[i] == 0x12) {
6083                                 spec->gen.cur_mux[0] = i;
6084                                 break;
6085                         }
6086                 }
6087                 break;
6088         }
6089 }
6090
6091 static void alc_fixup_headset_mode_alc662(struct hda_codec *codec,
6092                                 const struct hda_fixup *fix, int action)
6093 {
6094         struct alc_spec *spec = codec->spec;
6095
6096         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6097                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
6098                 spec->gen.hp_mic = 1; /* Mic-in is same pin as headphone */
6099
6100                 /* Disable boost for mic-in permanently. (This code is only called
6101                    from quirks that guarantee that the headphone is at NID 0x1b.) */
6102                 snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000);
6103                 snd_hda_override_wcaps(codec, 0x1b, get_wcaps(codec, 0x1b) & ~AC_WCAP_IN_AMP);
6104         } else
6105                 alc_fixup_headset_mode(codec, fix, action);
6106 }
6107
6108 static void alc_fixup_headset_mode_alc668(struct hda_codec *codec,
6109                                 const struct hda_fixup *fix, int action)
6110 {
6111         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6112                 alc_write_coef_idx(codec, 0xc4, 0x8000);
6113                 alc_update_coef_idx(codec, 0xc2, ~0xfe, 0);
6114                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
6115         }
6116         alc_fixup_headset_mode(codec, fix, action);
6117 }
6118
6119 /* Returns the nid of the external mic input pin, or 0 if it cannot be found. */
6120 static int find_ext_mic_pin(struct hda_codec *codec)
6121 {
6122         struct alc_spec *spec = codec->spec;
6123         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6124         hda_nid_t nid;
6125         unsigned int defcfg;
6126         int i;
6127
6128         for (i = 0; i < cfg->num_inputs; i++) {
6129                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
6130                         continue;
6131                 nid = cfg->inputs[i].pin;
6132                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
6133                 if (snd_hda_get_input_pin_attr(defcfg) == INPUT_PIN_ATTR_INT)
6134                         continue;
6135                 return nid;
6136         }
6137
6138         return 0;
6139 }
6140
6141 static void alc271_hp_gate_mic_jack(struct hda_codec *codec,
6142                                     const struct hda_fixup *fix,
6143                                     int action)
6144 {
6145         struct alc_spec *spec = codec->spec;
6146
6147         if (action == HDA_FIXUP_ACT_PROBE) {
6148                 int mic_pin = find_ext_mic_pin(codec);
6149                 int hp_pin = alc_get_hp_pin(spec);
6150
6151                 if (snd_BUG_ON(!mic_pin || !hp_pin))
6152                         return;
6153                 snd_hda_jack_set_gating_jack(codec, mic_pin, hp_pin);
6154         }
6155 }
6156
6157 static void alc269_fixup_limit_int_mic_boost(struct hda_codec *codec,
6158                                              const struct hda_fixup *fix,
6159                                              int action)
6160 {
6161         struct alc_spec *spec = codec->spec;
6162         struct auto_pin_cfg *cfg = &spec->gen.autocfg;
6163         int i;
6164
6165         /* The mic boosts on level 2 and 3 are too noisy
6166            on the internal mic input.
6167            Therefore limit the boost to 0 or 1. */
6168
6169         if (action != HDA_FIXUP_ACT_PROBE)
6170                 return;
6171
6172         for (i = 0; i < cfg->num_inputs; i++) {
6173                 hda_nid_t nid = cfg->inputs[i].pin;
6174                 unsigned int defcfg;
6175                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
6176                         continue;
6177                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
6178                 if (snd_hda_get_input_pin_attr(defcfg) != INPUT_PIN_ATTR_INT)
6179                         continue;
6180
6181                 snd_hda_override_amp_caps(codec, nid, HDA_INPUT,
6182                                           (0x00 << AC_AMPCAP_OFFSET_SHIFT) |
6183                                           (0x01 << AC_AMPCAP_NUM_STEPS_SHIFT) |
6184                                           (0x2f << AC_AMPCAP_STEP_SIZE_SHIFT) |
6185                                           (0 << AC_AMPCAP_MUTE_SHIFT));
6186         }
6187 }
6188
6189 static void alc283_hp_automute_hook(struct hda_codec *codec,
6190                                     struct hda_jack_callback *jack)
6191 {
6192         struct alc_spec *spec = codec->spec;
6193         int vref;
6194
6195         msleep(200);
6196         snd_hda_gen_hp_automute(codec, jack);
6197
6198         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
6199
6200         msleep(600);
6201         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6202                             vref);
6203 }
6204
6205 static void alc283_fixup_chromebook(struct hda_codec *codec,
6206                                     const struct hda_fixup *fix, int action)
6207 {
6208         struct alc_spec *spec = codec->spec;
6209
6210         switch (action) {
6211         case HDA_FIXUP_ACT_PRE_PROBE:
6212                 snd_hda_override_wcaps(codec, 0x03, 0);
6213                 /* Disable AA-loopback as it causes white noise */
6214                 spec->gen.mixer_nid = 0;
6215                 break;
6216         case HDA_FIXUP_ACT_INIT:
6217                 /* MIC2-VREF control */
6218                 /* Set to manual mode */
6219                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6220                 /* Enable Line1 input control by verb */
6221                 alc_update_coef_idx(codec, 0x1a, 0, 1 << 4);
6222                 break;
6223         }
6224 }
6225
6226 static void alc283_fixup_sense_combo_jack(struct hda_codec *codec,
6227                                     const struct hda_fixup *fix, int action)
6228 {
6229         struct alc_spec *spec = codec->spec;
6230
6231         switch (action) {
6232         case HDA_FIXUP_ACT_PRE_PROBE:
6233                 spec->gen.hp_automute_hook = alc283_hp_automute_hook;
6234                 break;
6235         case HDA_FIXUP_ACT_INIT:
6236                 /* MIC2-VREF control */
6237                 /* Set to manual mode */
6238                 alc_update_coef_idx(codec, 0x06, 0x000c, 0);
6239                 break;
6240         }
6241 }
6242
6243 /* mute tablet speaker pin (0x14) via dock plugging in addition */
6244 static void asus_tx300_automute(struct hda_codec *codec)
6245 {
6246         struct alc_spec *spec = codec->spec;
6247         snd_hda_gen_update_outputs(codec);
6248         if (snd_hda_jack_detect(codec, 0x1b))
6249                 spec->gen.mute_bits |= (1ULL << 0x14);
6250 }
6251
6252 static void alc282_fixup_asus_tx300(struct hda_codec *codec,
6253                                     const struct hda_fixup *fix, int action)
6254 {
6255         struct alc_spec *spec = codec->spec;
6256         static const struct hda_pintbl dock_pins[] = {
6257                 { 0x1b, 0x21114000 }, /* dock speaker pin */
6258                 {}
6259         };
6260
6261         switch (action) {
6262         case HDA_FIXUP_ACT_PRE_PROBE:
6263                 spec->init_amp = ALC_INIT_DEFAULT;
6264                 /* TX300 needs to set up GPIO2 for the speaker amp */
6265                 alc_setup_gpio(codec, 0x04);
6266                 snd_hda_apply_pincfgs(codec, dock_pins);
6267                 spec->gen.auto_mute_via_amp = 1;
6268                 spec->gen.automute_hook = asus_tx300_automute;
6269                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
6270                                                     snd_hda_gen_hp_automute);
6271                 break;
6272         case HDA_FIXUP_ACT_PROBE:
6273                 spec->init_amp = ALC_INIT_DEFAULT;
6274                 break;
6275         case HDA_FIXUP_ACT_BUILD:
6276                 /* this is a bit tricky; give more sane names for the main
6277                  * (tablet) speaker and the dock speaker, respectively
6278                  */
6279                 rename_ctl(codec, "Speaker Playback Switch",
6280                            "Dock Speaker Playback Switch");
6281                 rename_ctl(codec, "Bass Speaker Playback Switch",
6282                            "Speaker Playback Switch");
6283                 break;
6284         }
6285 }
6286
6287 static void alc290_fixup_mono_speakers(struct hda_codec *codec,
6288                                        const struct hda_fixup *fix, int action)
6289 {
6290         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6291                 /* DAC node 0x03 is giving mono output. We therefore want to
6292                    make sure 0x14 (front speaker) and 0x15 (headphones) use the
6293                    stereo DAC, while leaving 0x17 (bass speaker) for node 0x03. */
6294                 static const hda_nid_t conn1[] = { 0x0c };
6295                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn1), conn1);
6296                 snd_hda_override_conn_list(codec, 0x15, ARRAY_SIZE(conn1), conn1);
6297         }
6298 }
6299
6300 static void alc298_fixup_speaker_volume(struct hda_codec *codec,
6301                                         const struct hda_fixup *fix, int action)
6302 {
6303         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6304                 /* The speaker is routed to the Node 0x06 by a mistake, as a result
6305                    we can't adjust the speaker's volume since this node does not has
6306                    Amp-out capability. we change the speaker's route to:
6307                    Node 0x02 (Audio Output) -> Node 0x0c (Audio Mixer) -> Node 0x17 (
6308                    Pin Complex), since Node 0x02 has Amp-out caps, we can adjust
6309                    speaker's volume now. */
6310
6311                 static const hda_nid_t conn1[] = { 0x0c };
6312                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn1), conn1);
6313         }
6314 }
6315
6316 /* disable DAC3 (0x06) selection on NID 0x17 as it has no volume amp control */
6317 static void alc295_fixup_disable_dac3(struct hda_codec *codec,
6318                                       const struct hda_fixup *fix, int action)
6319 {
6320         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6321                 static const hda_nid_t conn[] = { 0x02, 0x03 };
6322                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6323         }
6324 }
6325
6326 /* force NID 0x17 (Bass Speaker) to DAC1 to share it with the main speaker */
6327 static void alc285_fixup_speaker2_to_dac1(struct hda_codec *codec,
6328                                           const struct hda_fixup *fix, int action)
6329 {
6330         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6331                 static const hda_nid_t conn[] = { 0x02 };
6332                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6333         }
6334 }
6335
6336 /* Hook to update amp GPIO4 for automute */
6337 static void alc280_hp_gpio4_automute_hook(struct hda_codec *codec,
6338                                           struct hda_jack_callback *jack)
6339 {
6340         struct alc_spec *spec = codec->spec;
6341
6342         snd_hda_gen_hp_automute(codec, jack);
6343         /* mute_led_polarity is set to 0, so we pass inverted value here */
6344         alc_update_gpio_led(codec, 0x10, spec->mute_led_polarity,
6345                             !spec->gen.hp_jack_present);
6346 }
6347
6348 /* Manage GPIOs for HP EliteBook Folio 9480m.
6349  *
6350  * GPIO4 is the headphone amplifier power control
6351  * GPIO3 is the audio output mute indicator LED
6352  */
6353
6354 static void alc280_fixup_hp_9480m(struct hda_codec *codec,
6355                                   const struct hda_fixup *fix,
6356                                   int action)
6357 {
6358         struct alc_spec *spec = codec->spec;
6359
6360         alc_fixup_hp_gpio_led(codec, action, 0x08, 0);
6361         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6362                 /* amp at GPIO4; toggled via alc280_hp_gpio4_automute_hook() */
6363                 spec->gpio_mask |= 0x10;
6364                 spec->gpio_dir |= 0x10;
6365                 spec->gen.hp_automute_hook = alc280_hp_gpio4_automute_hook;
6366         }
6367 }
6368
6369 static void alc275_fixup_gpio4_off(struct hda_codec *codec,
6370                                    const struct hda_fixup *fix,
6371                                    int action)
6372 {
6373         struct alc_spec *spec = codec->spec;
6374
6375         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6376                 spec->gpio_mask |= 0x04;
6377                 spec->gpio_dir |= 0x04;
6378                 /* set data bit low */
6379         }
6380 }
6381
6382 /* Quirk for Thinkpad X1 7th and 8th Gen
6383  * The following fixed routing needed
6384  * DAC1 (NID 0x02) -> Speaker (NID 0x14); some eq applied secretly
6385  * DAC2 (NID 0x03) -> Bass (NID 0x17) & Headphone (NID 0x21); sharing a DAC
6386  * DAC3 (NID 0x06) -> Unused, due to the lack of volume amp
6387  */
6388 static void alc285_fixup_thinkpad_x1_gen7(struct hda_codec *codec,
6389                                           const struct hda_fixup *fix, int action)
6390 {
6391         static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
6392         static const hda_nid_t preferred_pairs[] = {
6393                 0x14, 0x02, 0x17, 0x03, 0x21, 0x03, 0
6394         };
6395         struct alc_spec *spec = codec->spec;
6396
6397         switch (action) {
6398         case HDA_FIXUP_ACT_PRE_PROBE:
6399                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6400                 spec->gen.preferred_dacs = preferred_pairs;
6401                 break;
6402         case HDA_FIXUP_ACT_BUILD:
6403                 /* The generic parser creates somewhat unintuitive volume ctls
6404                  * with the fixed routing above, and the shared DAC2 may be
6405                  * confusing for PA.
6406                  * Rename those to unique names so that PA doesn't touch them
6407                  * and use only Master volume.
6408                  */
6409                 rename_ctl(codec, "Front Playback Volume", "DAC1 Playback Volume");
6410                 rename_ctl(codec, "Bass Speaker Playback Volume", "DAC2 Playback Volume");
6411                 break;
6412         }
6413 }
6414
6415 static void alc233_alc662_fixup_lenovo_dual_codecs(struct hda_codec *codec,
6416                                          const struct hda_fixup *fix,
6417                                          int action)
6418 {
6419         alc_fixup_dual_codecs(codec, fix, action);
6420         switch (action) {
6421         case HDA_FIXUP_ACT_PRE_PROBE:
6422                 /* override card longname to provide a unique UCM profile */
6423                 strcpy(codec->card->longname, "HDAudio-Lenovo-DualCodecs");
6424                 break;
6425         case HDA_FIXUP_ACT_BUILD:
6426                 /* rename Capture controls depending on the codec */
6427                 rename_ctl(codec, "Capture Volume",
6428                            codec->addr == 0 ?
6429                            "Rear-Panel Capture Volume" :
6430                            "Front-Panel Capture Volume");
6431                 rename_ctl(codec, "Capture Switch",
6432                            codec->addr == 0 ?
6433                            "Rear-Panel Capture Switch" :
6434                            "Front-Panel Capture Switch");
6435                 break;
6436         }
6437 }
6438
6439 static void alc225_fixup_s3_pop_noise(struct hda_codec *codec,
6440                                       const struct hda_fixup *fix, int action)
6441 {
6442         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6443                 return;
6444
6445         codec->power_save_node = 1;
6446 }
6447
6448 /* Forcibly assign NID 0x03 to HP/LO while NID 0x02 to SPK for EQ */
6449 static void alc274_fixup_bind_dacs(struct hda_codec *codec,
6450                                     const struct hda_fixup *fix, int action)
6451 {
6452         struct alc_spec *spec = codec->spec;
6453         static const hda_nid_t preferred_pairs[] = {
6454                 0x21, 0x03, 0x1b, 0x03, 0x16, 0x02,
6455                 0
6456         };
6457
6458         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6459                 return;
6460
6461         spec->gen.preferred_dacs = preferred_pairs;
6462         spec->gen.auto_mute_via_amp = 1;
6463         codec->power_save_node = 0;
6464 }
6465
6466 /* avoid DAC 0x06 for bass speaker 0x17; it has no volume control */
6467 static void alc289_fixup_asus_ga401(struct hda_codec *codec,
6468                                     const struct hda_fixup *fix, int action)
6469 {
6470         static const hda_nid_t preferred_pairs[] = {
6471                 0x14, 0x02, 0x17, 0x02, 0x21, 0x03, 0
6472         };
6473         struct alc_spec *spec = codec->spec;
6474
6475         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
6476                 spec->gen.preferred_dacs = preferred_pairs;
6477                 spec->gen.obey_preferred_dacs = 1;
6478         }
6479 }
6480
6481 /* The DAC of NID 0x3 will introduce click/pop noise on headphones, so invalidate it */
6482 static void alc285_fixup_invalidate_dacs(struct hda_codec *codec,
6483                               const struct hda_fixup *fix, int action)
6484 {
6485         if (action != HDA_FIXUP_ACT_PRE_PROBE)
6486                 return;
6487
6488         snd_hda_override_wcaps(codec, 0x03, 0);
6489 }
6490
6491 static void alc_combo_jack_hp_jd_restart(struct hda_codec *codec)
6492 {
6493         switch (codec->core.vendor_id) {
6494         case 0x10ec0274:
6495         case 0x10ec0294:
6496         case 0x10ec0225:
6497         case 0x10ec0295:
6498         case 0x10ec0299:
6499                 alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
6500                 alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
6501                 break;
6502         case 0x10ec0230:
6503         case 0x10ec0235:
6504         case 0x10ec0236:
6505         case 0x10ec0255:
6506         case 0x10ec0256:
6507         case 0x19e58326:
6508                 alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
6509                 alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
6510                 break;
6511         }
6512 }
6513
6514 static void alc295_fixup_chromebook(struct hda_codec *codec,
6515                                     const struct hda_fixup *fix, int action)
6516 {
6517         struct alc_spec *spec = codec->spec;
6518
6519         switch (action) {
6520         case HDA_FIXUP_ACT_PRE_PROBE:
6521                 spec->ultra_low_power = true;
6522                 break;
6523         case HDA_FIXUP_ACT_INIT:
6524                 alc_combo_jack_hp_jd_restart(codec);
6525                 break;
6526         }
6527 }
6528
6529 static void alc_fixup_disable_mic_vref(struct hda_codec *codec,
6530                                   const struct hda_fixup *fix, int action)
6531 {
6532         if (action == HDA_FIXUP_ACT_PRE_PROBE)
6533                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6534 }
6535
6536
6537 static void alc294_gx502_toggle_output(struct hda_codec *codec,
6538                                         struct hda_jack_callback *cb)
6539 {
6540         /* The Windows driver sets the codec up in a very different way where
6541          * it appears to leave 0x10 = 0x8a20 set. For Linux we need to toggle it
6542          */
6543         if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6544                 alc_write_coef_idx(codec, 0x10, 0x8a20);
6545         else
6546                 alc_write_coef_idx(codec, 0x10, 0x0a20);
6547 }
6548
6549 static void alc294_fixup_gx502_hp(struct hda_codec *codec,
6550                                         const struct hda_fixup *fix, int action)
6551 {
6552         /* Pin 0x21: headphones/headset mic */
6553         if (!is_jack_detectable(codec, 0x21))
6554                 return;
6555
6556         switch (action) {
6557         case HDA_FIXUP_ACT_PRE_PROBE:
6558                 snd_hda_jack_detect_enable_callback(codec, 0x21,
6559                                 alc294_gx502_toggle_output);
6560                 break;
6561         case HDA_FIXUP_ACT_INIT:
6562                 /* Make sure to start in a correct state, i.e. if
6563                  * headphones have been plugged in before powering up the system
6564                  */
6565                 alc294_gx502_toggle_output(codec, NULL);
6566                 break;
6567         }
6568 }
6569
6570 static void alc294_gu502_toggle_output(struct hda_codec *codec,
6571                                        struct hda_jack_callback *cb)
6572 {
6573         /* Windows sets 0x10 to 0x8420 for Node 0x20 which is
6574          * responsible from changes between speakers and headphones
6575          */
6576         if (snd_hda_jack_detect_state(codec, 0x21) == HDA_JACK_PRESENT)
6577                 alc_write_coef_idx(codec, 0x10, 0x8420);
6578         else
6579                 alc_write_coef_idx(codec, 0x10, 0x0a20);
6580 }
6581
6582 static void alc294_fixup_gu502_hp(struct hda_codec *codec,
6583                                   const struct hda_fixup *fix, int action)
6584 {
6585         if (!is_jack_detectable(codec, 0x21))
6586                 return;
6587
6588         switch (action) {
6589         case HDA_FIXUP_ACT_PRE_PROBE:
6590                 snd_hda_jack_detect_enable_callback(codec, 0x21,
6591                                 alc294_gu502_toggle_output);
6592                 break;
6593         case HDA_FIXUP_ACT_INIT:
6594                 alc294_gu502_toggle_output(codec, NULL);
6595                 break;
6596         }
6597 }
6598
6599 static void  alc285_fixup_hp_gpio_amp_init(struct hda_codec *codec,
6600                               const struct hda_fixup *fix, int action)
6601 {
6602         if (action != HDA_FIXUP_ACT_INIT)
6603                 return;
6604
6605         msleep(100);
6606         alc_write_coef_idx(codec, 0x65, 0x0);
6607 }
6608
6609 static void alc274_fixup_hp_headset_mic(struct hda_codec *codec,
6610                                     const struct hda_fixup *fix, int action)
6611 {
6612         switch (action) {
6613         case HDA_FIXUP_ACT_INIT:
6614                 alc_combo_jack_hp_jd_restart(codec);
6615                 break;
6616         }
6617 }
6618
6619 static void alc_fixup_no_int_mic(struct hda_codec *codec,
6620                                     const struct hda_fixup *fix, int action)
6621 {
6622         struct alc_spec *spec = codec->spec;
6623
6624         switch (action) {
6625         case HDA_FIXUP_ACT_PRE_PROBE:
6626                 /* Mic RING SLEEVE swap for combo jack */
6627                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
6628                 spec->no_internal_mic_pin = true;
6629                 break;
6630         case HDA_FIXUP_ACT_INIT:
6631                 alc_combo_jack_hp_jd_restart(codec);
6632                 break;
6633         }
6634 }
6635
6636 /* GPIO1 = amplifier on/off
6637  * GPIO3 = mic mute LED
6638  */
6639 static void alc285_fixup_hp_spectre_x360_eb1(struct hda_codec *codec,
6640                                           const struct hda_fixup *fix, int action)
6641 {
6642         static const hda_nid_t conn[] = { 0x02 };
6643
6644         struct alc_spec *spec = codec->spec;
6645         static const struct hda_pintbl pincfgs[] = {
6646                 { 0x14, 0x90170110 },  /* front/high speakers */
6647                 { 0x17, 0x90170130 },  /* back/bass speakers */
6648                 { }
6649         };
6650
6651         //enable micmute led
6652         alc_fixup_hp_gpio_led(codec, action, 0x00, 0x04);
6653
6654         switch (action) {
6655         case HDA_FIXUP_ACT_PRE_PROBE:
6656                 spec->micmute_led_polarity = 1;
6657                 /* needed for amp of back speakers */
6658                 spec->gpio_mask |= 0x01;
6659                 spec->gpio_dir |= 0x01;
6660                 snd_hda_apply_pincfgs(codec, pincfgs);
6661                 /* share DAC to have unified volume control */
6662                 snd_hda_override_conn_list(codec, 0x14, ARRAY_SIZE(conn), conn);
6663                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6664                 break;
6665         case HDA_FIXUP_ACT_INIT:
6666                 /* need to toggle GPIO to enable the amp of back speakers */
6667                 alc_update_gpio_data(codec, 0x01, true);
6668                 msleep(100);
6669                 alc_update_gpio_data(codec, 0x01, false);
6670                 break;
6671         }
6672 }
6673
6674 static void alc285_fixup_hp_spectre_x360(struct hda_codec *codec,
6675                                           const struct hda_fixup *fix, int action)
6676 {
6677         static const hda_nid_t conn[] = { 0x02 };
6678         static const struct hda_pintbl pincfgs[] = {
6679                 { 0x14, 0x90170110 },  /* rear speaker */
6680                 { }
6681         };
6682
6683         switch (action) {
6684         case HDA_FIXUP_ACT_PRE_PROBE:
6685                 snd_hda_apply_pincfgs(codec, pincfgs);
6686                 /* force front speaker to DAC1 */
6687                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
6688                 break;
6689         }
6690 }
6691
6692 /* for hda_fixup_thinkpad_acpi() */
6693 #include "thinkpad_helper.c"
6694
6695 static void alc_fixup_thinkpad_acpi(struct hda_codec *codec,
6696                                     const struct hda_fixup *fix, int action)
6697 {
6698         alc_fixup_no_shutup(codec, fix, action); /* reduce click noise */
6699         hda_fixup_thinkpad_acpi(codec, fix, action);
6700 }
6701
6702 /* Fixup for Lenovo Legion 15IMHg05 speaker output on headset removal. */
6703 static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec,
6704                                                   const struct hda_fixup *fix,
6705                                                   int action)
6706 {
6707         struct alc_spec *spec = codec->spec;
6708
6709         switch (action) {
6710         case HDA_FIXUP_ACT_PRE_PROBE:
6711                 spec->gen.suppress_auto_mute = 1;
6712                 break;
6713         }
6714 }
6715
6716 static int comp_bind(struct device *dev)
6717 {
6718         struct hda_codec *cdc = dev_to_hda_codec(dev);
6719         struct alc_spec *spec = cdc->spec;
6720
6721         return component_bind_all(dev, spec->comps);
6722 }
6723
6724 static void comp_unbind(struct device *dev)
6725 {
6726         struct hda_codec *cdc = dev_to_hda_codec(dev);
6727         struct alc_spec *spec = cdc->spec;
6728
6729         component_unbind_all(dev, spec->comps);
6730 }
6731
6732 static const struct component_master_ops comp_master_ops = {
6733         .bind = comp_bind,
6734         .unbind = comp_unbind,
6735 };
6736
6737 static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_codec *cdc,
6738                                        struct snd_pcm_substream *sub, int action)
6739 {
6740         struct alc_spec *spec = cdc->spec;
6741         int i;
6742
6743         for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
6744                 if (spec->comps[i].dev && spec->comps[i].pre_playback_hook)
6745                         spec->comps[i].pre_playback_hook(spec->comps[i].dev, action);
6746         }
6747         for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
6748                 if (spec->comps[i].dev && spec->comps[i].playback_hook)
6749                         spec->comps[i].playback_hook(spec->comps[i].dev, action);
6750         }
6751         for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
6752                 if (spec->comps[i].dev && spec->comps[i].post_playback_hook)
6753                         spec->comps[i].post_playback_hook(spec->comps[i].dev, action);
6754         }
6755 }
6756
6757 struct scodec_dev_name {
6758         const char *bus;
6759         const char *hid;
6760         int index;
6761 };
6762
6763 /* match the device name in a slightly relaxed manner */
6764 static int comp_match_cs35l41_dev_name(struct device *dev, void *data)
6765 {
6766         struct scodec_dev_name *p = data;
6767         const char *d = dev_name(dev);
6768         int n = strlen(p->bus);
6769         char tmp[32];
6770
6771         /* check the bus name */
6772         if (strncmp(d, p->bus, n))
6773                 return 0;
6774         /* skip the bus number */
6775         if (isdigit(d[n]))
6776                 n++;
6777         /* the rest must be exact matching */
6778         snprintf(tmp, sizeof(tmp), "-%s:00-cs35l41-hda.%d", p->hid, p->index);
6779         return !strcmp(d + n, tmp);
6780 }
6781
6782 static int comp_match_tas2781_dev_name(struct device *dev,
6783         void *data)
6784 {
6785         struct scodec_dev_name *p = data;
6786         const char *d = dev_name(dev);
6787         int n = strlen(p->bus);
6788         char tmp[32];
6789
6790         /* check the bus name */
6791         if (strncmp(d, p->bus, n))
6792                 return 0;
6793         /* skip the bus number */
6794         if (isdigit(d[n]))
6795                 n++;
6796         /* the rest must be exact matching */
6797         snprintf(tmp, sizeof(tmp), "-%s:00", p->hid);
6798
6799         return !strcmp(d + n, tmp);
6800 }
6801
6802 static void cs35l41_generic_fixup(struct hda_codec *cdc, int action, const char *bus,
6803                                   const char *hid, int count)
6804 {
6805         struct device *dev = hda_codec_dev(cdc);
6806         struct alc_spec *spec = cdc->spec;
6807         struct scodec_dev_name *rec;
6808         int ret, i;
6809
6810         switch (action) {
6811         case HDA_FIXUP_ACT_PRE_PROBE:
6812                 for (i = 0; i < count; i++) {
6813                         rec = devm_kmalloc(dev, sizeof(*rec), GFP_KERNEL);
6814                         if (!rec)
6815                                 return;
6816                         rec->bus = bus;
6817                         rec->hid = hid;
6818                         rec->index = i;
6819                         spec->comps[i].codec = cdc;
6820                         component_match_add(dev, &spec->match,
6821                                             comp_match_cs35l41_dev_name, rec);
6822                 }
6823                 ret = component_master_add_with_match(dev, &comp_master_ops, spec->match);
6824                 if (ret)
6825                         codec_err(cdc, "Fail to register component aggregator %d\n", ret);
6826                 else
6827                         spec->gen.pcm_playback_hook = comp_generic_playback_hook;
6828                 break;
6829         case HDA_FIXUP_ACT_FREE:
6830                 component_master_del(dev, &comp_master_ops);
6831                 break;
6832         }
6833 }
6834
6835 static void tas2781_generic_fixup(struct hda_codec *cdc, int action,
6836         const char *bus, const char *hid)
6837 {
6838         struct device *dev = hda_codec_dev(cdc);
6839         struct alc_spec *spec = cdc->spec;
6840         struct scodec_dev_name *rec;
6841         int ret;
6842
6843         switch (action) {
6844         case HDA_FIXUP_ACT_PRE_PROBE:
6845                 rec = devm_kmalloc(dev, sizeof(*rec), GFP_KERNEL);
6846                 if (!rec)
6847                         return;
6848                 rec->bus = bus;
6849                 rec->hid = hid;
6850                 rec->index = 0;
6851                 spec->comps[0].codec = cdc;
6852                 component_match_add(dev, &spec->match,
6853                         comp_match_tas2781_dev_name, rec);
6854                 ret = component_master_add_with_match(dev, &comp_master_ops,
6855                         spec->match);
6856                 if (ret)
6857                         codec_err(cdc,
6858                                 "Fail to register component aggregator %d\n",
6859                                 ret);
6860                 else
6861                         spec->gen.pcm_playback_hook =
6862                                 comp_generic_playback_hook;
6863                 break;
6864         case HDA_FIXUP_ACT_FREE:
6865                 component_master_del(dev, &comp_master_ops);
6866                 break;
6867         }
6868 }
6869
6870 static void cs35l41_fixup_i2c_two(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
6871 {
6872         cs35l41_generic_fixup(cdc, action, "i2c", "CSC3551", 2);
6873 }
6874
6875 static void cs35l41_fixup_spi_two(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6876 {
6877         cs35l41_generic_fixup(codec, action, "spi", "CSC3551", 2);
6878 }
6879
6880 static void cs35l41_fixup_spi_four(struct hda_codec *codec, const struct hda_fixup *fix, int action)
6881 {
6882         cs35l41_generic_fixup(codec, action, "spi", "CSC3551", 4);
6883 }
6884
6885 static void alc287_fixup_legion_16achg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6886                                                  int action)
6887 {
6888         cs35l41_generic_fixup(cdc, action, "i2c", "CLSA0100", 2);
6889 }
6890
6891 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
6892                                                  int action)
6893 {
6894         cs35l41_generic_fixup(cdc, action, "i2c", "CLSA0101", 2);
6895 }
6896
6897 static void tas2781_fixup_i2c(struct hda_codec *cdc,
6898         const struct hda_fixup *fix, int action)
6899 {
6900          tas2781_generic_fixup(cdc, action, "i2c", "TIAS2781");
6901 }
6902
6903 /* for alc295_fixup_hp_top_speakers */
6904 #include "hp_x360_helper.c"
6905
6906 /* for alc285_fixup_ideapad_s740_coef() */
6907 #include "ideapad_s740_helper.c"
6908
6909 static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
6910         WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
6911         WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
6912         WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
6913         {}
6914 };
6915
6916 static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
6917                                            const struct hda_fixup *fix,
6918                                            int action)
6919 {
6920         /*
6921          * A certain other OS sets these coeffs to different values. On at least
6922          * one TongFang barebone these settings might survive even a cold
6923          * reboot. So to restore a clean slate the values are explicitly reset
6924          * to default here. Without this, the external microphone is always in a
6925          * plugged-in state, while the internal microphone is always in an
6926          * unplugged state, breaking the ability to use the internal microphone.
6927          */
6928         alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
6929 }
6930
6931 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
6932         WRITE_COEF(0x1a, 0x9003), WRITE_COEF(0x1b, 0x0e2b), WRITE_COEF(0x37, 0xfe06),
6933         WRITE_COEF(0x38, 0x4981), WRITE_COEF(0x45, 0xd489), WRITE_COEF(0x46, 0x0074),
6934         WRITE_COEF(0x49, 0x0149),
6935         {}
6936 };
6937
6938 static void alc233_fixup_no_audio_jack(struct hda_codec *codec,
6939                                        const struct hda_fixup *fix,
6940                                        int action)
6941 {
6942         /*
6943          * The audio jack input and output is not detected on the ASRock NUC Box
6944          * 1100 series when cold booting without this fix. Warm rebooting from a
6945          * certain other OS makes the audio functional, as COEF settings are
6946          * preserved in this case. This fix sets these altered COEF values as
6947          * the default.
6948          */
6949         alc_process_coef_fw(codec, alc233_fixup_no_audio_jack_coefs);
6950 }
6951
6952 static void alc256_fixup_mic_no_presence_and_resume(struct hda_codec *codec,
6953                                                     const struct hda_fixup *fix,
6954                                                     int action)
6955 {
6956         /*
6957          * The Clevo NJ51CU comes either with the ALC293 or the ALC256 codec,
6958          * but uses the 0x8686 subproduct id in both cases. The ALC256 codec
6959          * needs an additional quirk for sound working after suspend and resume.
6960          */
6961         if (codec->core.vendor_id == 0x10ec0256) {
6962                 alc_update_coef_idx(codec, 0x10, 1<<9, 0);
6963                 snd_hda_codec_set_pincfg(codec, 0x19, 0x04a11120);
6964         } else {
6965                 snd_hda_codec_set_pincfg(codec, 0x1a, 0x04a1113c);
6966         }
6967 }
6968
6969 static void alc_fixup_dell4_mic_no_presence_quiet(struct hda_codec *codec,
6970                                                   const struct hda_fixup *fix,
6971                                                   int action)
6972 {
6973         struct alc_spec *spec = codec->spec;
6974         struct hda_input_mux *imux = &spec->gen.input_mux;
6975         int i;
6976
6977         alc269_fixup_limit_int_mic_boost(codec, fix, action);
6978
6979         switch (action) {
6980         case HDA_FIXUP_ACT_PRE_PROBE:
6981                 /**
6982                  * Set the vref of pin 0x19 (Headset Mic) and pin 0x1b (Headphone Mic)
6983                  * to Hi-Z to avoid pop noises at startup and when plugging and
6984                  * unplugging headphones.
6985                  */
6986                 snd_hda_codec_set_pin_target(codec, 0x19, PIN_VREFHIZ);
6987                 snd_hda_codec_set_pin_target(codec, 0x1b, PIN_VREFHIZ);
6988                 break;
6989         case HDA_FIXUP_ACT_PROBE:
6990                 /**
6991                  * Make the internal mic (0x12) the default input source to
6992                  * prevent pop noises on cold boot.
6993                  */
6994                 for (i = 0; i < imux->num_items; i++) {
6995                         if (spec->gen.imux_pins[i] == 0x12) {
6996                                 spec->gen.cur_mux[0] = i;
6997                                 break;
6998                         }
6999                 }
7000                 break;
7001         }
7002 }
7003
7004 static void alc287_fixup_yoga9_14iap7_bass_spk_pin(struct hda_codec *codec,
7005                                           const struct hda_fixup *fix, int action)
7006 {
7007         /*
7008          * The Pin Complex 0x17 for the bass speakers is wrongly reported as
7009          * unconnected.
7010          */
7011         static const struct hda_pintbl pincfgs[] = {
7012                 { 0x17, 0x90170121 },
7013                 { }
7014         };
7015         /*
7016          * Avoid DAC 0x06 and 0x08, as they have no volume controls.
7017          * DAC 0x02 and 0x03 would be fine.
7018          */
7019         static const hda_nid_t conn[] = { 0x02, 0x03 };
7020         /*
7021          * Prefer both speakerbar (0x14) and bass speakers (0x17) connected to DAC 0x02.
7022          * Headphones (0x21) are connected to DAC 0x03.
7023          */
7024         static const hda_nid_t preferred_pairs[] = {
7025                 0x14, 0x02,
7026                 0x17, 0x02,
7027                 0x21, 0x03,
7028                 0
7029         };
7030         struct alc_spec *spec = codec->spec;
7031
7032         switch (action) {
7033         case HDA_FIXUP_ACT_PRE_PROBE:
7034                 snd_hda_apply_pincfgs(codec, pincfgs);
7035                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7036                 spec->gen.preferred_dacs = preferred_pairs;
7037                 break;
7038         }
7039 }
7040
7041 static void alc295_fixup_dell_inspiron_top_speakers(struct hda_codec *codec,
7042                                           const struct hda_fixup *fix, int action)
7043 {
7044         static const struct hda_pintbl pincfgs[] = {
7045                 { 0x14, 0x90170151 },
7046                 { 0x17, 0x90170150 },
7047                 { }
7048         };
7049         static const hda_nid_t conn[] = { 0x02, 0x03 };
7050         static const hda_nid_t preferred_pairs[] = {
7051                 0x14, 0x02,
7052                 0x17, 0x03,
7053                 0x21, 0x02,
7054                 0
7055         };
7056         struct alc_spec *spec = codec->spec;
7057
7058         alc_fixup_no_shutup(codec, fix, action);
7059
7060         switch (action) {
7061         case HDA_FIXUP_ACT_PRE_PROBE:
7062                 snd_hda_apply_pincfgs(codec, pincfgs);
7063                 snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7064                 spec->gen.preferred_dacs = preferred_pairs;
7065                 break;
7066         }
7067 }
7068
7069 /* Forcibly assign NID 0x03 to HP while NID 0x02 to SPK */
7070 static void alc287_fixup_bind_dacs(struct hda_codec *codec,
7071                                     const struct hda_fixup *fix, int action)
7072 {
7073         struct alc_spec *spec = codec->spec;
7074         static const hda_nid_t conn[] = { 0x02, 0x03 }; /* exclude 0x06 */
7075         static const hda_nid_t preferred_pairs[] = {
7076                 0x17, 0x02, 0x21, 0x03, 0
7077         };
7078
7079         if (action != HDA_FIXUP_ACT_PRE_PROBE)
7080                 return;
7081
7082         snd_hda_override_conn_list(codec, 0x17, ARRAY_SIZE(conn), conn);
7083         spec->gen.preferred_dacs = preferred_pairs;
7084         spec->gen.auto_mute_via_amp = 1;
7085         if (spec->gen.autocfg.speaker_pins[0] != 0x14) {
7086                 snd_hda_codec_write_cache(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
7087                                         0x0); /* Make sure 0x14 was disable */
7088         }
7089 }
7090 /* Fix none verb table of Headset Mic pin */
7091 static void alc_fixup_headset_mic(struct hda_codec *codec,
7092                                    const struct hda_fixup *fix, int action)
7093 {
7094         struct alc_spec *spec = codec->spec;
7095         static const struct hda_pintbl pincfgs[] = {
7096                 { 0x19, 0x03a1103c },
7097                 { }
7098         };
7099
7100         switch (action) {
7101         case HDA_FIXUP_ACT_PRE_PROBE:
7102                 snd_hda_apply_pincfgs(codec, pincfgs);
7103                 alc_update_coef_idx(codec, 0x45, 0xf<<12 | 1<<10, 5<<12);
7104                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
7105                 break;
7106         }
7107 }
7108
7109
7110 enum {
7111         ALC269_FIXUP_GPIO2,
7112         ALC269_FIXUP_SONY_VAIO,
7113         ALC275_FIXUP_SONY_VAIO_GPIO2,
7114         ALC269_FIXUP_DELL_M101Z,
7115         ALC269_FIXUP_SKU_IGNORE,
7116         ALC269_FIXUP_ASUS_G73JW,
7117         ALC269_FIXUP_ASUS_N7601ZM_PINS,
7118         ALC269_FIXUP_ASUS_N7601ZM,
7119         ALC269_FIXUP_LENOVO_EAPD,
7120         ALC275_FIXUP_SONY_HWEQ,
7121         ALC275_FIXUP_SONY_DISABLE_AAMIX,
7122         ALC271_FIXUP_DMIC,
7123         ALC269_FIXUP_PCM_44K,
7124         ALC269_FIXUP_STEREO_DMIC,
7125         ALC269_FIXUP_HEADSET_MIC,
7126         ALC269_FIXUP_QUANTA_MUTE,
7127         ALC269_FIXUP_LIFEBOOK,
7128         ALC269_FIXUP_LIFEBOOK_EXTMIC,
7129         ALC269_FIXUP_LIFEBOOK_HP_PIN,
7130         ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT,
7131         ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC,
7132         ALC269_FIXUP_AMIC,
7133         ALC269_FIXUP_DMIC,
7134         ALC269VB_FIXUP_AMIC,
7135         ALC269VB_FIXUP_DMIC,
7136         ALC269_FIXUP_HP_MUTE_LED,
7137         ALC269_FIXUP_HP_MUTE_LED_MIC1,
7138         ALC269_FIXUP_HP_MUTE_LED_MIC2,
7139         ALC269_FIXUP_HP_MUTE_LED_MIC3,
7140         ALC269_FIXUP_HP_GPIO_LED,
7141         ALC269_FIXUP_HP_GPIO_MIC1_LED,
7142         ALC269_FIXUP_HP_LINE1_MIC1_LED,
7143         ALC269_FIXUP_INV_DMIC,
7144         ALC269_FIXUP_LENOVO_DOCK,
7145         ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST,
7146         ALC269_FIXUP_NO_SHUTUP,
7147         ALC286_FIXUP_SONY_MIC_NO_PRESENCE,
7148         ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT,
7149         ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
7150         ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
7151         ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7152         ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
7153         ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET,
7154         ALC269_FIXUP_HEADSET_MODE,
7155         ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
7156         ALC269_FIXUP_ASPIRE_HEADSET_MIC,
7157         ALC269_FIXUP_ASUS_X101_FUNC,
7158         ALC269_FIXUP_ASUS_X101_VERB,
7159         ALC269_FIXUP_ASUS_X101,
7160         ALC271_FIXUP_AMIC_MIC2,
7161         ALC271_FIXUP_HP_GATE_MIC_JACK,
7162         ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572,
7163         ALC269_FIXUP_ACER_AC700,
7164         ALC269_FIXUP_LIMIT_INT_MIC_BOOST,
7165         ALC269VB_FIXUP_ASUS_ZENBOOK,
7166         ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A,
7167         ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE,
7168         ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED,
7169         ALC269VB_FIXUP_ORDISSIMO_EVE2,
7170         ALC283_FIXUP_CHROME_BOOK,
7171         ALC283_FIXUP_SENSE_COMBO_JACK,
7172         ALC282_FIXUP_ASUS_TX300,
7173         ALC283_FIXUP_INT_MIC,
7174         ALC290_FIXUP_MONO_SPEAKERS,
7175         ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7176         ALC290_FIXUP_SUBWOOFER,
7177         ALC290_FIXUP_SUBWOOFER_HSJACK,
7178         ALC269_FIXUP_THINKPAD_ACPI,
7179         ALC269_FIXUP_DMIC_THINKPAD_ACPI,
7180         ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
7181         ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
7182         ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
7183         ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
7184         ALC255_FIXUP_HEADSET_MODE,
7185         ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC,
7186         ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
7187         ALC292_FIXUP_TPT440_DOCK,
7188         ALC292_FIXUP_TPT440,
7189         ALC283_FIXUP_HEADSET_MIC,
7190         ALC255_FIXUP_MIC_MUTE_LED,
7191         ALC282_FIXUP_ASPIRE_V5_PINS,
7192         ALC269VB_FIXUP_ASPIRE_E1_COEF,
7193         ALC280_FIXUP_HP_GPIO4,
7194         ALC286_FIXUP_HP_GPIO_LED,
7195         ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
7196         ALC280_FIXUP_HP_DOCK_PINS,
7197         ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED,
7198         ALC280_FIXUP_HP_9480M,
7199         ALC245_FIXUP_HP_X360_AMP,
7200         ALC285_FIXUP_HP_SPECTRE_X360_EB1,
7201         ALC288_FIXUP_DELL_HEADSET_MODE,
7202         ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
7203         ALC288_FIXUP_DELL_XPS_13,
7204         ALC288_FIXUP_DISABLE_AAMIX,
7205         ALC292_FIXUP_DELL_E7X_AAMIX,
7206         ALC292_FIXUP_DELL_E7X,
7207         ALC292_FIXUP_DISABLE_AAMIX,
7208         ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK,
7209         ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
7210         ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
7211         ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
7212         ALC275_FIXUP_DELL_XPS,
7213         ALC293_FIXUP_LENOVO_SPK_NOISE,
7214         ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
7215         ALC255_FIXUP_DELL_SPK_NOISE,
7216         ALC225_FIXUP_DISABLE_MIC_VREF,
7217         ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
7218         ALC295_FIXUP_DISABLE_DAC3,
7219         ALC285_FIXUP_SPEAKER2_TO_DAC1,
7220         ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1,
7221         ALC285_FIXUP_ASUS_HEADSET_MIC,
7222         ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS,
7223         ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1,
7224         ALC285_FIXUP_ASUS_I2C_HEADSET_MIC,
7225         ALC280_FIXUP_HP_HEADSET_MIC,
7226         ALC221_FIXUP_HP_FRONT_MIC,
7227         ALC292_FIXUP_TPT460,
7228         ALC298_FIXUP_SPK_VOLUME,
7229         ALC298_FIXUP_LENOVO_SPK_VOLUME,
7230         ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER,
7231         ALC269_FIXUP_ATIV_BOOK_8,
7232         ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE,
7233         ALC221_FIXUP_HP_MIC_NO_PRESENCE,
7234         ALC256_FIXUP_ASUS_HEADSET_MODE,
7235         ALC256_FIXUP_ASUS_MIC,
7236         ALC256_FIXUP_ASUS_AIO_GPIO2,
7237         ALC233_FIXUP_ASUS_MIC_NO_PRESENCE,
7238         ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE,
7239         ALC233_FIXUP_LENOVO_MULTI_CODECS,
7240         ALC233_FIXUP_ACER_HEADSET_MIC,
7241         ALC294_FIXUP_LENOVO_MIC_LOCATION,
7242         ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE,
7243         ALC225_FIXUP_S3_POP_NOISE,
7244         ALC700_FIXUP_INTEL_REFERENCE,
7245         ALC274_FIXUP_DELL_BIND_DACS,
7246         ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
7247         ALC298_FIXUP_TPT470_DOCK_FIX,
7248         ALC298_FIXUP_TPT470_DOCK,
7249         ALC255_FIXUP_DUMMY_LINEOUT_VERB,
7250         ALC255_FIXUP_DELL_HEADSET_MIC,
7251         ALC256_FIXUP_HUAWEI_MACH_WX9_PINS,
7252         ALC298_FIXUP_HUAWEI_MBX_STEREO,
7253         ALC295_FIXUP_HP_X360,
7254         ALC221_FIXUP_HP_HEADSET_MIC,
7255         ALC285_FIXUP_LENOVO_HEADPHONE_NOISE,
7256         ALC295_FIXUP_HP_AUTO_MUTE,
7257         ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
7258         ALC294_FIXUP_ASUS_MIC,
7259         ALC294_FIXUP_ASUS_HEADSET_MIC,
7260         ALC294_FIXUP_ASUS_SPK,
7261         ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7262         ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
7263         ALC255_FIXUP_ACER_HEADSET_MIC,
7264         ALC295_FIXUP_CHROME_BOOK,
7265         ALC225_FIXUP_HEADSET_JACK,
7266         ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
7267         ALC225_FIXUP_WYSE_AUTO_MUTE,
7268         ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
7269         ALC286_FIXUP_ACER_AIO_HEADSET_MIC,
7270         ALC256_FIXUP_ASUS_HEADSET_MIC,
7271         ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
7272         ALC299_FIXUP_PREDATOR_SPK,
7273         ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE,
7274         ALC289_FIXUP_DELL_SPK1,
7275         ALC289_FIXUP_DELL_SPK2,
7276         ALC289_FIXUP_DUAL_SPK,
7277         ALC289_FIXUP_RTK_AMP_DUAL_SPK,
7278         ALC294_FIXUP_SPK2_TO_DAC1,
7279         ALC294_FIXUP_ASUS_DUAL_SPK,
7280         ALC285_FIXUP_THINKPAD_X1_GEN7,
7281         ALC285_FIXUP_THINKPAD_HEADSET_JACK,
7282         ALC294_FIXUP_ASUS_ALLY,
7283         ALC294_FIXUP_ASUS_ALLY_PINS,
7284         ALC294_FIXUP_ASUS_ALLY_VERBS,
7285         ALC294_FIXUP_ASUS_ALLY_SPEAKER,
7286         ALC294_FIXUP_ASUS_HPE,
7287         ALC294_FIXUP_ASUS_COEF_1B,
7288         ALC294_FIXUP_ASUS_GX502_HP,
7289         ALC294_FIXUP_ASUS_GX502_PINS,
7290         ALC294_FIXUP_ASUS_GX502_VERBS,
7291         ALC294_FIXUP_ASUS_GU502_HP,
7292         ALC294_FIXUP_ASUS_GU502_PINS,
7293         ALC294_FIXUP_ASUS_GU502_VERBS,
7294         ALC294_FIXUP_ASUS_G513_PINS,
7295         ALC285_FIXUP_ASUS_G533Z_PINS,
7296         ALC285_FIXUP_HP_GPIO_LED,
7297         ALC285_FIXUP_HP_MUTE_LED,
7298         ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED,
7299         ALC236_FIXUP_HP_MUTE_LED_COEFBIT2,
7300         ALC236_FIXUP_HP_GPIO_LED,
7301         ALC236_FIXUP_HP_MUTE_LED,
7302         ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
7303         ALC298_FIXUP_SAMSUNG_AMP,
7304         ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7305         ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET,
7306         ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
7307         ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS,
7308         ALC269VC_FIXUP_ACER_HEADSET_MIC,
7309         ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE,
7310         ALC289_FIXUP_ASUS_GA401,
7311         ALC289_FIXUP_ASUS_GA502,
7312         ALC256_FIXUP_ACER_MIC_NO_PRESENCE,
7313         ALC285_FIXUP_HP_GPIO_AMP_INIT,
7314         ALC269_FIXUP_CZC_B20,
7315         ALC269_FIXUP_CZC_TMI,
7316         ALC269_FIXUP_CZC_L101,
7317         ALC269_FIXUP_LEMOTE_A1802,
7318         ALC269_FIXUP_LEMOTE_A190X,
7319         ALC256_FIXUP_INTEL_NUC8_RUGGED,
7320         ALC233_FIXUP_INTEL_NUC8_DMIC,
7321         ALC233_FIXUP_INTEL_NUC8_BOOST,
7322         ALC256_FIXUP_INTEL_NUC10,
7323         ALC255_FIXUP_XIAOMI_HEADSET_MIC,
7324         ALC274_FIXUP_HP_MIC,
7325         ALC274_FIXUP_HP_HEADSET_MIC,
7326         ALC274_FIXUP_HP_ENVY_GPIO,
7327         ALC256_FIXUP_ASUS_HPE,
7328         ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
7329         ALC287_FIXUP_HP_GPIO_LED,
7330         ALC256_FIXUP_HP_HEADSET_MIC,
7331         ALC245_FIXUP_HP_GPIO_LED,
7332         ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
7333         ALC282_FIXUP_ACER_DISABLE_LINEOUT,
7334         ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST,
7335         ALC256_FIXUP_ACER_HEADSET_MIC,
7336         ALC285_FIXUP_IDEAPAD_S740_COEF,
7337         ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7338         ALC295_FIXUP_ASUS_DACS,
7339         ALC295_FIXUP_HP_OMEN,
7340         ALC285_FIXUP_HP_SPECTRE_X360,
7341         ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP,
7342         ALC623_FIXUP_LENOVO_THINKSTATION_P340,
7343         ALC255_FIXUP_ACER_HEADPHONE_AND_MIC,
7344         ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST,
7345         ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS,
7346         ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
7347         ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
7348         ALC298_FIXUP_LENOVO_C940_DUET7,
7349         ALC287_FIXUP_13S_GEN2_SPEAKERS,
7350         ALC256_FIXUP_SET_COEF_DEFAULTS,
7351         ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
7352         ALC233_FIXUP_NO_AUDIO_JACK,
7353         ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME,
7354         ALC285_FIXUP_LEGION_Y9000X_SPEAKERS,
7355         ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
7356         ALC287_FIXUP_LEGION_16ACHG6,
7357         ALC287_FIXUP_CS35L41_I2C_2,
7358         ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED,
7359         ALC245_FIXUP_CS35L41_SPI_2,
7360         ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED,
7361         ALC245_FIXUP_CS35L41_SPI_4,
7362         ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED,
7363         ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED,
7364         ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE,
7365         ALC287_FIXUP_LEGION_16ITHG6,
7366         ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
7367         ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN,
7368         ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS,
7369         ALC236_FIXUP_DELL_DUAL_CODECS,
7370         ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
7371         ALC287_FIXUP_TAS2781_I2C,
7372         ALC245_FIXUP_HP_MUTE_LED_COEFBIT,
7373         ALC245_FIXUP_HP_X360_MUTE_LEDS,
7374         ALC287_FIXUP_THINKPAD_I2S_SPK,
7375         ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD,
7376         ALC2XX_FIXUP_HEADSET_MIC,
7377         ALC289_FIXUP_DELL_CS35L41_SPI_2,
7378         ALC294_FIXUP_CS35L41_I2C_2,
7379 };
7380
7381 /* A special fixup for Lenovo C940 and Yoga Duet 7;
7382  * both have the very same PCI SSID, and we need to apply different fixups
7383  * depending on the codec ID
7384  */
7385 static void alc298_fixup_lenovo_c940_duet7(struct hda_codec *codec,
7386                                            const struct hda_fixup *fix,
7387                                            int action)
7388 {
7389         int id;
7390
7391         if (codec->core.vendor_id == 0x10ec0298)
7392                 id = ALC298_FIXUP_LENOVO_SPK_VOLUME; /* C940 */
7393         else
7394                 id = ALC287_FIXUP_YOGA7_14ITL_SPEAKERS; /* Duet 7 */
7395         __snd_hda_apply_fixup(codec, id, action, 0);
7396 }
7397
7398 static const struct hda_fixup alc269_fixups[] = {
7399         [ALC269_FIXUP_GPIO2] = {
7400                 .type = HDA_FIXUP_FUNC,
7401                 .v.func = alc_fixup_gpio2,
7402         },
7403         [ALC269_FIXUP_SONY_VAIO] = {
7404                 .type = HDA_FIXUP_PINCTLS,
7405                 .v.pins = (const struct hda_pintbl[]) {
7406                         {0x19, PIN_VREFGRD},
7407                         {}
7408                 }
7409         },
7410         [ALC275_FIXUP_SONY_VAIO_GPIO2] = {
7411                 .type = HDA_FIXUP_FUNC,
7412                 .v.func = alc275_fixup_gpio4_off,
7413                 .chained = true,
7414                 .chain_id = ALC269_FIXUP_SONY_VAIO
7415         },
7416         [ALC269_FIXUP_DELL_M101Z] = {
7417                 .type = HDA_FIXUP_VERBS,
7418                 .v.verbs = (const struct hda_verb[]) {
7419                         /* Enables internal speaker */
7420                         {0x20, AC_VERB_SET_COEF_INDEX, 13},
7421                         {0x20, AC_VERB_SET_PROC_COEF, 0x4040},
7422                         {}
7423                 }
7424         },
7425         [ALC269_FIXUP_SKU_IGNORE] = {
7426                 .type = HDA_FIXUP_FUNC,
7427                 .v.func = alc_fixup_sku_ignore,
7428         },
7429         [ALC269_FIXUP_ASUS_G73JW] = {
7430                 .type = HDA_FIXUP_PINS,
7431                 .v.pins = (const struct hda_pintbl[]) {
7432                         { 0x17, 0x99130111 }, /* subwoofer */
7433                         { }
7434                 }
7435         },
7436         [ALC269_FIXUP_ASUS_N7601ZM_PINS] = {
7437                 .type = HDA_FIXUP_PINS,
7438                 .v.pins = (const struct hda_pintbl[]) {
7439                         { 0x19, 0x03A11050 },
7440                         { 0x1a, 0x03A11C30 },
7441                         { 0x21, 0x03211420 },
7442                         { }
7443                 }
7444         },
7445         [ALC269_FIXUP_ASUS_N7601ZM] = {
7446                 .type = HDA_FIXUP_VERBS,
7447                 .v.verbs = (const struct hda_verb[]) {
7448                         {0x20, AC_VERB_SET_COEF_INDEX, 0x62},
7449                         {0x20, AC_VERB_SET_PROC_COEF, 0xa007},
7450                         {0x20, AC_VERB_SET_COEF_INDEX, 0x10},
7451                         {0x20, AC_VERB_SET_PROC_COEF, 0x8420},
7452                         {0x20, AC_VERB_SET_COEF_INDEX, 0x0f},
7453                         {0x20, AC_VERB_SET_PROC_COEF, 0x7774},
7454                         { }
7455                 },
7456                 .chained = true,
7457                 .chain_id = ALC269_FIXUP_ASUS_N7601ZM_PINS,
7458         },
7459         [ALC269_FIXUP_LENOVO_EAPD] = {
7460                 .type = HDA_FIXUP_VERBS,
7461                 .v.verbs = (const struct hda_verb[]) {
7462                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
7463                         {}
7464                 }
7465         },
7466         [ALC275_FIXUP_SONY_HWEQ] = {
7467                 .type = HDA_FIXUP_FUNC,
7468                 .v.func = alc269_fixup_hweq,
7469                 .chained = true,
7470                 .chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
7471         },
7472         [ALC275_FIXUP_SONY_DISABLE_AAMIX] = {
7473                 .type = HDA_FIXUP_FUNC,
7474                 .v.func = alc_fixup_disable_aamix,
7475                 .chained = true,
7476                 .chain_id = ALC269_FIXUP_SONY_VAIO
7477         },
7478         [ALC271_FIXUP_DMIC] = {
7479                 .type = HDA_FIXUP_FUNC,
7480                 .v.func = alc271_fixup_dmic,
7481         },
7482         [ALC269_FIXUP_PCM_44K] = {
7483                 .type = HDA_FIXUP_FUNC,
7484                 .v.func = alc269_fixup_pcm_44k,
7485                 .chained = true,
7486                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
7487         },
7488         [ALC269_FIXUP_STEREO_DMIC] = {
7489                 .type = HDA_FIXUP_FUNC,
7490                 .v.func = alc269_fixup_stereo_dmic,
7491         },
7492         [ALC269_FIXUP_HEADSET_MIC] = {
7493                 .type = HDA_FIXUP_FUNC,
7494                 .v.func = alc269_fixup_headset_mic,
7495         },
7496         [ALC269_FIXUP_QUANTA_MUTE] = {
7497                 .type = HDA_FIXUP_FUNC,
7498                 .v.func = alc269_fixup_quanta_mute,
7499         },
7500         [ALC269_FIXUP_LIFEBOOK] = {
7501                 .type = HDA_FIXUP_PINS,
7502                 .v.pins = (const struct hda_pintbl[]) {
7503                         { 0x1a, 0x2101103f }, /* dock line-out */
7504                         { 0x1b, 0x23a11040 }, /* dock mic-in */
7505                         { }
7506                 },
7507                 .chained = true,
7508                 .chain_id = ALC269_FIXUP_QUANTA_MUTE
7509         },
7510         [ALC269_FIXUP_LIFEBOOK_EXTMIC] = {
7511                 .type = HDA_FIXUP_PINS,
7512                 .v.pins = (const struct hda_pintbl[]) {
7513                         { 0x19, 0x01a1903c }, /* headset mic, with jack detect */
7514                         { }
7515                 },
7516         },
7517         [ALC269_FIXUP_LIFEBOOK_HP_PIN] = {
7518                 .type = HDA_FIXUP_PINS,
7519                 .v.pins = (const struct hda_pintbl[]) {
7520                         { 0x21, 0x0221102f }, /* HP out */
7521                         { }
7522                 },
7523         },
7524         [ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT] = {
7525                 .type = HDA_FIXUP_FUNC,
7526                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7527         },
7528         [ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC] = {
7529                 .type = HDA_FIXUP_FUNC,
7530                 .v.func = alc269_fixup_pincfg_U7x7_headset_mic,
7531         },
7532         [ALC269_FIXUP_AMIC] = {
7533                 .type = HDA_FIXUP_PINS,
7534                 .v.pins = (const struct hda_pintbl[]) {
7535                         { 0x14, 0x99130110 }, /* speaker */
7536                         { 0x15, 0x0121401f }, /* HP out */
7537                         { 0x18, 0x01a19c20 }, /* mic */
7538                         { 0x19, 0x99a3092f }, /* int-mic */
7539                         { }
7540                 },
7541         },
7542         [ALC269_FIXUP_DMIC] = {
7543                 .type = HDA_FIXUP_PINS,
7544                 .v.pins = (const struct hda_pintbl[]) {
7545                         { 0x12, 0x99a3092f }, /* int-mic */
7546                         { 0x14, 0x99130110 }, /* speaker */
7547                         { 0x15, 0x0121401f }, /* HP out */
7548                         { 0x18, 0x01a19c20 }, /* mic */
7549                         { }
7550                 },
7551         },
7552         [ALC269VB_FIXUP_AMIC] = {
7553                 .type = HDA_FIXUP_PINS,
7554                 .v.pins = (const struct hda_pintbl[]) {
7555                         { 0x14, 0x99130110 }, /* speaker */
7556                         { 0x18, 0x01a19c20 }, /* mic */
7557                         { 0x19, 0x99a3092f }, /* int-mic */
7558                         { 0x21, 0x0121401f }, /* HP out */
7559                         { }
7560                 },
7561         },
7562         [ALC269VB_FIXUP_DMIC] = {
7563                 .type = HDA_FIXUP_PINS,
7564                 .v.pins = (const struct hda_pintbl[]) {
7565                         { 0x12, 0x99a3092f }, /* int-mic */
7566                         { 0x14, 0x99130110 }, /* speaker */
7567                         { 0x18, 0x01a19c20 }, /* mic */
7568                         { 0x21, 0x0121401f }, /* HP out */
7569                         { }
7570                 },
7571         },
7572         [ALC269_FIXUP_HP_MUTE_LED] = {
7573                 .type = HDA_FIXUP_FUNC,
7574                 .v.func = alc269_fixup_hp_mute_led,
7575         },
7576         [ALC269_FIXUP_HP_MUTE_LED_MIC1] = {
7577                 .type = HDA_FIXUP_FUNC,
7578                 .v.func = alc269_fixup_hp_mute_led_mic1,
7579         },
7580         [ALC269_FIXUP_HP_MUTE_LED_MIC2] = {
7581                 .type = HDA_FIXUP_FUNC,
7582                 .v.func = alc269_fixup_hp_mute_led_mic2,
7583         },
7584         [ALC269_FIXUP_HP_MUTE_LED_MIC3] = {
7585                 .type = HDA_FIXUP_FUNC,
7586                 .v.func = alc269_fixup_hp_mute_led_mic3,
7587                 .chained = true,
7588                 .chain_id = ALC295_FIXUP_HP_AUTO_MUTE
7589         },
7590         [ALC269_FIXUP_HP_GPIO_LED] = {
7591                 .type = HDA_FIXUP_FUNC,
7592                 .v.func = alc269_fixup_hp_gpio_led,
7593         },
7594         [ALC269_FIXUP_HP_GPIO_MIC1_LED] = {
7595                 .type = HDA_FIXUP_FUNC,
7596                 .v.func = alc269_fixup_hp_gpio_mic1_led,
7597         },
7598         [ALC269_FIXUP_HP_LINE1_MIC1_LED] = {
7599                 .type = HDA_FIXUP_FUNC,
7600                 .v.func = alc269_fixup_hp_line1_mic1_led,
7601         },
7602         [ALC269_FIXUP_INV_DMIC] = {
7603                 .type = HDA_FIXUP_FUNC,
7604                 .v.func = alc_fixup_inv_dmic,
7605         },
7606         [ALC269_FIXUP_NO_SHUTUP] = {
7607                 .type = HDA_FIXUP_FUNC,
7608                 .v.func = alc_fixup_no_shutup,
7609         },
7610         [ALC269_FIXUP_LENOVO_DOCK] = {
7611                 .type = HDA_FIXUP_PINS,
7612                 .v.pins = (const struct hda_pintbl[]) {
7613                         { 0x19, 0x23a11040 }, /* dock mic */
7614                         { 0x1b, 0x2121103f }, /* dock headphone */
7615                         { }
7616                 },
7617                 .chained = true,
7618                 .chain_id = ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT
7619         },
7620         [ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST] = {
7621                 .type = HDA_FIXUP_FUNC,
7622                 .v.func = alc269_fixup_limit_int_mic_boost,
7623                 .chained = true,
7624                 .chain_id = ALC269_FIXUP_LENOVO_DOCK,
7625         },
7626         [ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT] = {
7627                 .type = HDA_FIXUP_FUNC,
7628                 .v.func = alc269_fixup_pincfg_no_hp_to_lineout,
7629                 .chained = true,
7630                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7631         },
7632         [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7633                 .type = HDA_FIXUP_PINS,
7634                 .v.pins = (const struct hda_pintbl[]) {
7635                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7636                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7637                         { }
7638                 },
7639                 .chained = true,
7640                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7641         },
7642         [ALC269_FIXUP_DELL2_MIC_NO_PRESENCE] = {
7643                 .type = HDA_FIXUP_PINS,
7644                 .v.pins = (const struct hda_pintbl[]) {
7645                         { 0x16, 0x21014020 }, /* dock line out */
7646                         { 0x19, 0x21a19030 }, /* dock mic */
7647                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7648                         { }
7649                 },
7650                 .chained = true,
7651                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7652         },
7653         [ALC269_FIXUP_DELL3_MIC_NO_PRESENCE] = {
7654                 .type = HDA_FIXUP_PINS,
7655                 .v.pins = (const struct hda_pintbl[]) {
7656                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7657                         { }
7658                 },
7659                 .chained = true,
7660                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
7661         },
7662         [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE] = {
7663                 .type = HDA_FIXUP_PINS,
7664                 .v.pins = (const struct hda_pintbl[]) {
7665                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7666                         { 0x1b, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7667                         { }
7668                 },
7669                 .chained = true,
7670                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7671         },
7672         [ALC269_FIXUP_HEADSET_MODE] = {
7673                 .type = HDA_FIXUP_FUNC,
7674                 .v.func = alc_fixup_headset_mode,
7675                 .chained = true,
7676                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7677         },
7678         [ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7679                 .type = HDA_FIXUP_FUNC,
7680                 .v.func = alc_fixup_headset_mode_no_hp_mic,
7681         },
7682         [ALC269_FIXUP_ASPIRE_HEADSET_MIC] = {
7683                 .type = HDA_FIXUP_PINS,
7684                 .v.pins = (const struct hda_pintbl[]) {
7685                         { 0x19, 0x01a1913c }, /* headset mic w/o jack detect */
7686                         { }
7687                 },
7688                 .chained = true,
7689                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
7690         },
7691         [ALC286_FIXUP_SONY_MIC_NO_PRESENCE] = {
7692                 .type = HDA_FIXUP_PINS,
7693                 .v.pins = (const struct hda_pintbl[]) {
7694                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7695                         { }
7696                 },
7697                 .chained = true,
7698                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7699         },
7700         [ALC256_FIXUP_HUAWEI_MACH_WX9_PINS] = {
7701                 .type = HDA_FIXUP_PINS,
7702                 .v.pins = (const struct hda_pintbl[]) {
7703                         {0x12, 0x90a60130},
7704                         {0x13, 0x40000000},
7705                         {0x14, 0x90170110},
7706                         {0x18, 0x411111f0},
7707                         {0x19, 0x04a11040},
7708                         {0x1a, 0x411111f0},
7709                         {0x1b, 0x90170112},
7710                         {0x1d, 0x40759a05},
7711                         {0x1e, 0x411111f0},
7712                         {0x21, 0x04211020},
7713                         { }
7714                 },
7715                 .chained = true,
7716                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7717         },
7718         [ALC298_FIXUP_HUAWEI_MBX_STEREO] = {
7719                 .type = HDA_FIXUP_FUNC,
7720                 .v.func = alc298_fixup_huawei_mbx_stereo,
7721                 .chained = true,
7722                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7723         },
7724         [ALC269_FIXUP_ASUS_X101_FUNC] = {
7725                 .type = HDA_FIXUP_FUNC,
7726                 .v.func = alc269_fixup_x101_headset_mic,
7727         },
7728         [ALC269_FIXUP_ASUS_X101_VERB] = {
7729                 .type = HDA_FIXUP_VERBS,
7730                 .v.verbs = (const struct hda_verb[]) {
7731                         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
7732                         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
7733                         {0x20, AC_VERB_SET_PROC_COEF,  0x0310},
7734                         { }
7735                 },
7736                 .chained = true,
7737                 .chain_id = ALC269_FIXUP_ASUS_X101_FUNC
7738         },
7739         [ALC269_FIXUP_ASUS_X101] = {
7740                 .type = HDA_FIXUP_PINS,
7741                 .v.pins = (const struct hda_pintbl[]) {
7742                         { 0x18, 0x04a1182c }, /* Headset mic */
7743                         { }
7744                 },
7745                 .chained = true,
7746                 .chain_id = ALC269_FIXUP_ASUS_X101_VERB
7747         },
7748         [ALC271_FIXUP_AMIC_MIC2] = {
7749                 .type = HDA_FIXUP_PINS,
7750                 .v.pins = (const struct hda_pintbl[]) {
7751                         { 0x14, 0x99130110 }, /* speaker */
7752                         { 0x19, 0x01a19c20 }, /* mic */
7753                         { 0x1b, 0x99a7012f }, /* int-mic */
7754                         { 0x21, 0x0121401f }, /* HP out */
7755                         { }
7756                 },
7757         },
7758         [ALC271_FIXUP_HP_GATE_MIC_JACK] = {
7759                 .type = HDA_FIXUP_FUNC,
7760                 .v.func = alc271_hp_gate_mic_jack,
7761                 .chained = true,
7762                 .chain_id = ALC271_FIXUP_AMIC_MIC2,
7763         },
7764         [ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572] = {
7765                 .type = HDA_FIXUP_FUNC,
7766                 .v.func = alc269_fixup_limit_int_mic_boost,
7767                 .chained = true,
7768                 .chain_id = ALC271_FIXUP_HP_GATE_MIC_JACK,
7769         },
7770         [ALC269_FIXUP_ACER_AC700] = {
7771                 .type = HDA_FIXUP_PINS,
7772                 .v.pins = (const struct hda_pintbl[]) {
7773                         { 0x12, 0x99a3092f }, /* int-mic */
7774                         { 0x14, 0x99130110 }, /* speaker */
7775                         { 0x18, 0x03a11c20 }, /* mic */
7776                         { 0x1e, 0x0346101e }, /* SPDIF1 */
7777                         { 0x21, 0x0321101f }, /* HP out */
7778                         { }
7779                 },
7780                 .chained = true,
7781                 .chain_id = ALC271_FIXUP_DMIC,
7782         },
7783         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST] = {
7784                 .type = HDA_FIXUP_FUNC,
7785                 .v.func = alc269_fixup_limit_int_mic_boost,
7786                 .chained = true,
7787                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7788         },
7789         [ALC269VB_FIXUP_ASUS_ZENBOOK] = {
7790                 .type = HDA_FIXUP_FUNC,
7791                 .v.func = alc269_fixup_limit_int_mic_boost,
7792                 .chained = true,
7793                 .chain_id = ALC269VB_FIXUP_DMIC,
7794         },
7795         [ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A] = {
7796                 .type = HDA_FIXUP_VERBS,
7797                 .v.verbs = (const struct hda_verb[]) {
7798                         /* class-D output amp +5dB */
7799                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x12 },
7800                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2800 },
7801                         {}
7802                 },
7803                 .chained = true,
7804                 .chain_id = ALC269VB_FIXUP_ASUS_ZENBOOK,
7805         },
7806         [ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7807                 .type = HDA_FIXUP_PINS,
7808                 .v.pins = (const struct hda_pintbl[]) {
7809                         { 0x18, 0x01a110f0 },  /* use as headset mic */
7810                         { }
7811                 },
7812                 .chained = true,
7813                 .chain_id = ALC269_FIXUP_HEADSET_MIC
7814         },
7815         [ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED] = {
7816                 .type = HDA_FIXUP_FUNC,
7817                 .v.func = alc269_fixup_limit_int_mic_boost,
7818                 .chained = true,
7819                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC1,
7820         },
7821         [ALC269VB_FIXUP_ORDISSIMO_EVE2] = {
7822                 .type = HDA_FIXUP_PINS,
7823                 .v.pins = (const struct hda_pintbl[]) {
7824                         { 0x12, 0x99a3092f }, /* int-mic */
7825                         { 0x18, 0x03a11d20 }, /* mic */
7826                         { 0x19, 0x411111f0 }, /* Unused bogus pin */
7827                         { }
7828                 },
7829         },
7830         [ALC283_FIXUP_CHROME_BOOK] = {
7831                 .type = HDA_FIXUP_FUNC,
7832                 .v.func = alc283_fixup_chromebook,
7833         },
7834         [ALC283_FIXUP_SENSE_COMBO_JACK] = {
7835                 .type = HDA_FIXUP_FUNC,
7836                 .v.func = alc283_fixup_sense_combo_jack,
7837                 .chained = true,
7838                 .chain_id = ALC283_FIXUP_CHROME_BOOK,
7839         },
7840         [ALC282_FIXUP_ASUS_TX300] = {
7841                 .type = HDA_FIXUP_FUNC,
7842                 .v.func = alc282_fixup_asus_tx300,
7843         },
7844         [ALC283_FIXUP_INT_MIC] = {
7845                 .type = HDA_FIXUP_VERBS,
7846                 .v.verbs = (const struct hda_verb[]) {
7847                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1a},
7848                         {0x20, AC_VERB_SET_PROC_COEF, 0x0011},
7849                         { }
7850                 },
7851                 .chained = true,
7852                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
7853         },
7854         [ALC290_FIXUP_SUBWOOFER_HSJACK] = {
7855                 .type = HDA_FIXUP_PINS,
7856                 .v.pins = (const struct hda_pintbl[]) {
7857                         { 0x17, 0x90170112 }, /* subwoofer */
7858                         { }
7859                 },
7860                 .chained = true,
7861                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK,
7862         },
7863         [ALC290_FIXUP_SUBWOOFER] = {
7864                 .type = HDA_FIXUP_PINS,
7865                 .v.pins = (const struct hda_pintbl[]) {
7866                         { 0x17, 0x90170112 }, /* subwoofer */
7867                         { }
7868                 },
7869                 .chained = true,
7870                 .chain_id = ALC290_FIXUP_MONO_SPEAKERS,
7871         },
7872         [ALC290_FIXUP_MONO_SPEAKERS] = {
7873                 .type = HDA_FIXUP_FUNC,
7874                 .v.func = alc290_fixup_mono_speakers,
7875         },
7876         [ALC290_FIXUP_MONO_SPEAKERS_HSJACK] = {
7877                 .type = HDA_FIXUP_FUNC,
7878                 .v.func = alc290_fixup_mono_speakers,
7879                 .chained = true,
7880                 .chain_id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
7881         },
7882         [ALC269_FIXUP_THINKPAD_ACPI] = {
7883                 .type = HDA_FIXUP_FUNC,
7884                 .v.func = alc_fixup_thinkpad_acpi,
7885                 .chained = true,
7886                 .chain_id = ALC269_FIXUP_SKU_IGNORE,
7887         },
7888         [ALC269_FIXUP_DMIC_THINKPAD_ACPI] = {
7889                 .type = HDA_FIXUP_FUNC,
7890                 .v.func = alc_fixup_inv_dmic,
7891                 .chained = true,
7892                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
7893         },
7894         [ALC255_FIXUP_ACER_MIC_NO_PRESENCE] = {
7895                 .type = HDA_FIXUP_PINS,
7896                 .v.pins = (const struct hda_pintbl[]) {
7897                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7898                         { }
7899                 },
7900                 .chained = true,
7901                 .chain_id = ALC255_FIXUP_HEADSET_MODE
7902         },
7903         [ALC255_FIXUP_ASUS_MIC_NO_PRESENCE] = {
7904                 .type = HDA_FIXUP_PINS,
7905                 .v.pins = (const struct hda_pintbl[]) {
7906                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7907                         { }
7908                 },
7909                 .chained = true,
7910                 .chain_id = ALC255_FIXUP_HEADSET_MODE
7911         },
7912         [ALC255_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7913                 .type = HDA_FIXUP_PINS,
7914                 .v.pins = (const struct hda_pintbl[]) {
7915                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7916                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7917                         { }
7918                 },
7919                 .chained = true,
7920                 .chain_id = ALC255_FIXUP_HEADSET_MODE
7921         },
7922         [ALC255_FIXUP_DELL2_MIC_NO_PRESENCE] = {
7923                 .type = HDA_FIXUP_PINS,
7924                 .v.pins = (const struct hda_pintbl[]) {
7925                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7926                         { }
7927                 },
7928                 .chained = true,
7929                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
7930         },
7931         [ALC255_FIXUP_HEADSET_MODE] = {
7932                 .type = HDA_FIXUP_FUNC,
7933                 .v.func = alc_fixup_headset_mode_alc255,
7934                 .chained = true,
7935                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
7936         },
7937         [ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC] = {
7938                 .type = HDA_FIXUP_FUNC,
7939                 .v.func = alc_fixup_headset_mode_alc255_no_hp_mic,
7940         },
7941         [ALC293_FIXUP_DELL1_MIC_NO_PRESENCE] = {
7942                 .type = HDA_FIXUP_PINS,
7943                 .v.pins = (const struct hda_pintbl[]) {
7944                         { 0x18, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
7945                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
7946                         { }
7947                 },
7948                 .chained = true,
7949                 .chain_id = ALC269_FIXUP_HEADSET_MODE
7950         },
7951         [ALC292_FIXUP_TPT440_DOCK] = {
7952                 .type = HDA_FIXUP_FUNC,
7953                 .v.func = alc_fixup_tpt440_dock,
7954                 .chained = true,
7955                 .chain_id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST
7956         },
7957         [ALC292_FIXUP_TPT440] = {
7958                 .type = HDA_FIXUP_FUNC,
7959                 .v.func = alc_fixup_disable_aamix,
7960                 .chained = true,
7961                 .chain_id = ALC292_FIXUP_TPT440_DOCK,
7962         },
7963         [ALC283_FIXUP_HEADSET_MIC] = {
7964                 .type = HDA_FIXUP_PINS,
7965                 .v.pins = (const struct hda_pintbl[]) {
7966                         { 0x19, 0x04a110f0 },
7967                         { },
7968                 },
7969         },
7970         [ALC255_FIXUP_MIC_MUTE_LED] = {
7971                 .type = HDA_FIXUP_FUNC,
7972                 .v.func = alc_fixup_micmute_led,
7973         },
7974         [ALC282_FIXUP_ASPIRE_V5_PINS] = {
7975                 .type = HDA_FIXUP_PINS,
7976                 .v.pins = (const struct hda_pintbl[]) {
7977                         { 0x12, 0x90a60130 },
7978                         { 0x14, 0x90170110 },
7979                         { 0x17, 0x40000008 },
7980                         { 0x18, 0x411111f0 },
7981                         { 0x19, 0x01a1913c },
7982                         { 0x1a, 0x411111f0 },
7983                         { 0x1b, 0x411111f0 },
7984                         { 0x1d, 0x40f89b2d },
7985                         { 0x1e, 0x411111f0 },
7986                         { 0x21, 0x0321101f },
7987                         { },
7988                 },
7989         },
7990         [ALC269VB_FIXUP_ASPIRE_E1_COEF] = {
7991                 .type = HDA_FIXUP_FUNC,
7992                 .v.func = alc269vb_fixup_aspire_e1_coef,
7993         },
7994         [ALC280_FIXUP_HP_GPIO4] = {
7995                 .type = HDA_FIXUP_FUNC,
7996                 .v.func = alc280_fixup_hp_gpio4,
7997         },
7998         [ALC286_FIXUP_HP_GPIO_LED] = {
7999                 .type = HDA_FIXUP_FUNC,
8000                 .v.func = alc286_fixup_hp_gpio_led,
8001         },
8002         [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
8003                 .type = HDA_FIXUP_FUNC,
8004                 .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
8005         },
8006         [ALC280_FIXUP_HP_DOCK_PINS] = {
8007                 .type = HDA_FIXUP_PINS,
8008                 .v.pins = (const struct hda_pintbl[]) {
8009                         { 0x1b, 0x21011020 }, /* line-out */
8010                         { 0x1a, 0x01a1903c }, /* headset mic */
8011                         { 0x18, 0x2181103f }, /* line-in */
8012                         { },
8013                 },
8014                 .chained = true,
8015                 .chain_id = ALC280_FIXUP_HP_GPIO4
8016         },
8017         [ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED] = {
8018                 .type = HDA_FIXUP_PINS,
8019                 .v.pins = (const struct hda_pintbl[]) {
8020                         { 0x1b, 0x21011020 }, /* line-out */
8021                         { 0x18, 0x2181103f }, /* line-in */
8022                         { },
8023                 },
8024                 .chained = true,
8025                 .chain_id = ALC269_FIXUP_HP_GPIO_MIC1_LED
8026         },
8027         [ALC280_FIXUP_HP_9480M] = {
8028                 .type = HDA_FIXUP_FUNC,
8029                 .v.func = alc280_fixup_hp_9480m,
8030         },
8031         [ALC245_FIXUP_HP_X360_AMP] = {
8032                 .type = HDA_FIXUP_FUNC,
8033                 .v.func = alc245_fixup_hp_x360_amp,
8034                 .chained = true,
8035                 .chain_id = ALC245_FIXUP_HP_GPIO_LED
8036         },
8037         [ALC288_FIXUP_DELL_HEADSET_MODE] = {
8038                 .type = HDA_FIXUP_FUNC,
8039                 .v.func = alc_fixup_headset_mode_dell_alc288,
8040                 .chained = true,
8041                 .chain_id = ALC255_FIXUP_MIC_MUTE_LED
8042         },
8043         [ALC288_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8044                 .type = HDA_FIXUP_PINS,
8045                 .v.pins = (const struct hda_pintbl[]) {
8046                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8047                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8048                         { }
8049                 },
8050                 .chained = true,
8051                 .chain_id = ALC288_FIXUP_DELL_HEADSET_MODE
8052         },
8053         [ALC288_FIXUP_DISABLE_AAMIX] = {
8054                 .type = HDA_FIXUP_FUNC,
8055                 .v.func = alc_fixup_disable_aamix,
8056                 .chained = true,
8057                 .chain_id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE
8058         },
8059         [ALC288_FIXUP_DELL_XPS_13] = {
8060                 .type = HDA_FIXUP_FUNC,
8061                 .v.func = alc_fixup_dell_xps13,
8062                 .chained = true,
8063                 .chain_id = ALC288_FIXUP_DISABLE_AAMIX
8064         },
8065         [ALC292_FIXUP_DISABLE_AAMIX] = {
8066                 .type = HDA_FIXUP_FUNC,
8067                 .v.func = alc_fixup_disable_aamix,
8068                 .chained = true,
8069                 .chain_id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE
8070         },
8071         [ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK] = {
8072                 .type = HDA_FIXUP_FUNC,
8073                 .v.func = alc_fixup_disable_aamix,
8074                 .chained = true,
8075                 .chain_id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE
8076         },
8077         [ALC292_FIXUP_DELL_E7X_AAMIX] = {
8078                 .type = HDA_FIXUP_FUNC,
8079                 .v.func = alc_fixup_dell_xps13,
8080                 .chained = true,
8081                 .chain_id = ALC292_FIXUP_DISABLE_AAMIX
8082         },
8083         [ALC292_FIXUP_DELL_E7X] = {
8084                 .type = HDA_FIXUP_FUNC,
8085                 .v.func = alc_fixup_micmute_led,
8086                 /* micmute fixup must be applied at last */
8087                 .chained_before = true,
8088                 .chain_id = ALC292_FIXUP_DELL_E7X_AAMIX,
8089         },
8090         [ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE] = {
8091                 .type = HDA_FIXUP_PINS,
8092                 .v.pins = (const struct hda_pintbl[]) {
8093                         { 0x18, 0x01a1913c }, /* headset mic w/o jack detect */
8094                         { }
8095                 },
8096                 .chained_before = true,
8097                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
8098         },
8099         [ALC298_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8100                 .type = HDA_FIXUP_PINS,
8101                 .v.pins = (const struct hda_pintbl[]) {
8102                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8103                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8104                         { }
8105                 },
8106                 .chained = true,
8107                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8108         },
8109         [ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE] = {
8110                 .type = HDA_FIXUP_PINS,
8111                 .v.pins = (const struct hda_pintbl[]) {
8112                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8113                         { }
8114                 },
8115                 .chained = true,
8116                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8117         },
8118         [ALC275_FIXUP_DELL_XPS] = {
8119                 .type = HDA_FIXUP_VERBS,
8120                 .v.verbs = (const struct hda_verb[]) {
8121                         /* Enables internal speaker */
8122                         {0x20, AC_VERB_SET_COEF_INDEX, 0x1f},
8123                         {0x20, AC_VERB_SET_PROC_COEF, 0x00c0},
8124                         {0x20, AC_VERB_SET_COEF_INDEX, 0x30},
8125                         {0x20, AC_VERB_SET_PROC_COEF, 0x00b1},
8126                         {}
8127                 }
8128         },
8129         [ALC293_FIXUP_LENOVO_SPK_NOISE] = {
8130                 .type = HDA_FIXUP_FUNC,
8131                 .v.func = alc_fixup_disable_aamix,
8132                 .chained = true,
8133                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8134         },
8135         [ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY] = {
8136                 .type = HDA_FIXUP_FUNC,
8137                 .v.func = alc233_fixup_lenovo_line2_mic_hotkey,
8138         },
8139         [ALC233_FIXUP_INTEL_NUC8_DMIC] = {
8140                 .type = HDA_FIXUP_FUNC,
8141                 .v.func = alc_fixup_inv_dmic,
8142                 .chained = true,
8143                 .chain_id = ALC233_FIXUP_INTEL_NUC8_BOOST,
8144         },
8145         [ALC233_FIXUP_INTEL_NUC8_BOOST] = {
8146                 .type = HDA_FIXUP_FUNC,
8147                 .v.func = alc269_fixup_limit_int_mic_boost
8148         },
8149         [ALC255_FIXUP_DELL_SPK_NOISE] = {
8150                 .type = HDA_FIXUP_FUNC,
8151                 .v.func = alc_fixup_disable_aamix,
8152                 .chained = true,
8153                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8154         },
8155         [ALC225_FIXUP_DISABLE_MIC_VREF] = {
8156                 .type = HDA_FIXUP_FUNC,
8157                 .v.func = alc_fixup_disable_mic_vref,
8158                 .chained = true,
8159                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8160         },
8161         [ALC225_FIXUP_DELL1_MIC_NO_PRESENCE] = {
8162                 .type = HDA_FIXUP_VERBS,
8163                 .v.verbs = (const struct hda_verb[]) {
8164                         /* Disable pass-through path for FRONT 14h */
8165                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8166                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8167                         {}
8168                 },
8169                 .chained = true,
8170                 .chain_id = ALC225_FIXUP_DISABLE_MIC_VREF
8171         },
8172         [ALC280_FIXUP_HP_HEADSET_MIC] = {
8173                 .type = HDA_FIXUP_FUNC,
8174                 .v.func = alc_fixup_disable_aamix,
8175                 .chained = true,
8176                 .chain_id = ALC269_FIXUP_HEADSET_MIC,
8177         },
8178         [ALC221_FIXUP_HP_FRONT_MIC] = {
8179                 .type = HDA_FIXUP_PINS,
8180                 .v.pins = (const struct hda_pintbl[]) {
8181                         { 0x19, 0x02a19020 }, /* Front Mic */
8182                         { }
8183                 },
8184         },
8185         [ALC292_FIXUP_TPT460] = {
8186                 .type = HDA_FIXUP_FUNC,
8187                 .v.func = alc_fixup_tpt440_dock,
8188                 .chained = true,
8189                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE,
8190         },
8191         [ALC298_FIXUP_SPK_VOLUME] = {
8192                 .type = HDA_FIXUP_FUNC,
8193                 .v.func = alc298_fixup_speaker_volume,
8194                 .chained = true,
8195                 .chain_id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE,
8196         },
8197         [ALC298_FIXUP_LENOVO_SPK_VOLUME] = {
8198                 .type = HDA_FIXUP_FUNC,
8199                 .v.func = alc298_fixup_speaker_volume,
8200         },
8201         [ALC295_FIXUP_DISABLE_DAC3] = {
8202                 .type = HDA_FIXUP_FUNC,
8203                 .v.func = alc295_fixup_disable_dac3,
8204         },
8205         [ALC285_FIXUP_SPEAKER2_TO_DAC1] = {
8206                 .type = HDA_FIXUP_FUNC,
8207                 .v.func = alc285_fixup_speaker2_to_dac1,
8208                 .chained = true,
8209                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8210         },
8211         [ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1] = {
8212                 .type = HDA_FIXUP_FUNC,
8213                 .v.func = alc285_fixup_speaker2_to_dac1,
8214                 .chained = true,
8215                 .chain_id = ALC245_FIXUP_CS35L41_SPI_2
8216         },
8217         [ALC285_FIXUP_ASUS_HEADSET_MIC] = {
8218                 .type = HDA_FIXUP_PINS,
8219                 .v.pins = (const struct hda_pintbl[]) {
8220                         { 0x19, 0x03a11050 },
8221                         { 0x1b, 0x03a11c30 },
8222                         { }
8223                 },
8224                 .chained = true,
8225                 .chain_id = ALC285_FIXUP_ASUS_SPEAKER2_TO_DAC1
8226         },
8227         [ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS] = {
8228                 .type = HDA_FIXUP_PINS,
8229                 .v.pins = (const struct hda_pintbl[]) {
8230                         { 0x14, 0x90170120 },
8231                         { }
8232                 },
8233                 .chained = true,
8234                 .chain_id = ALC285_FIXUP_ASUS_HEADSET_MIC
8235         },
8236         [ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1] = {
8237                 .type = HDA_FIXUP_FUNC,
8238                 .v.func = alc285_fixup_speaker2_to_dac1,
8239                 .chained = true,
8240                 .chain_id = ALC287_FIXUP_CS35L41_I2C_2
8241         },
8242         [ALC285_FIXUP_ASUS_I2C_HEADSET_MIC] = {
8243                 .type = HDA_FIXUP_PINS,
8244                 .v.pins = (const struct hda_pintbl[]) {
8245                         { 0x19, 0x03a11050 },
8246                         { 0x1b, 0x03a11c30 },
8247                         { }
8248                 },
8249                 .chained = true,
8250                 .chain_id = ALC285_FIXUP_ASUS_I2C_SPEAKER2_TO_DAC1
8251         },
8252         [ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER] = {
8253                 .type = HDA_FIXUP_PINS,
8254                 .v.pins = (const struct hda_pintbl[]) {
8255                         { 0x1b, 0x90170151 },
8256                         { }
8257                 },
8258                 .chained = true,
8259                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8260         },
8261         [ALC269_FIXUP_ATIV_BOOK_8] = {
8262                 .type = HDA_FIXUP_FUNC,
8263                 .v.func = alc_fixup_auto_mute_via_amp,
8264                 .chained = true,
8265                 .chain_id = ALC269_FIXUP_NO_SHUTUP
8266         },
8267         [ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE] = {
8268                 .type = HDA_FIXUP_PINS,
8269                 .v.pins = (const struct hda_pintbl[]) {
8270                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8271                         { 0x1a, 0x01813030 }, /* use as headphone mic, without its own jack detect */
8272                         { }
8273                 },
8274                 .chained = true,
8275                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8276         },
8277         [ALC221_FIXUP_HP_MIC_NO_PRESENCE] = {
8278                 .type = HDA_FIXUP_PINS,
8279                 .v.pins = (const struct hda_pintbl[]) {
8280                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8281                         { 0x1a, 0x01a1913d }, /* use as headphone mic, without its own jack detect */
8282                         { }
8283                 },
8284                 .chained = true,
8285                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8286         },
8287         [ALC256_FIXUP_ASUS_HEADSET_MODE] = {
8288                 .type = HDA_FIXUP_FUNC,
8289                 .v.func = alc_fixup_headset_mode,
8290         },
8291         [ALC256_FIXUP_ASUS_MIC] = {
8292                 .type = HDA_FIXUP_PINS,
8293                 .v.pins = (const struct hda_pintbl[]) {
8294                         { 0x13, 0x90a60160 }, /* use as internal mic */
8295                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8296                         { }
8297                 },
8298                 .chained = true,
8299                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8300         },
8301         [ALC256_FIXUP_ASUS_AIO_GPIO2] = {
8302                 .type = HDA_FIXUP_FUNC,
8303                 /* Set up GPIO2 for the speaker amp */
8304                 .v.func = alc_fixup_gpio4,
8305         },
8306         [ALC233_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8307                 .type = HDA_FIXUP_PINS,
8308                 .v.pins = (const struct hda_pintbl[]) {
8309                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8310                         { }
8311                 },
8312                 .chained = true,
8313                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8314         },
8315         [ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE] = {
8316                 .type = HDA_FIXUP_VERBS,
8317                 .v.verbs = (const struct hda_verb[]) {
8318                         /* Enables internal speaker */
8319                         {0x20, AC_VERB_SET_COEF_INDEX, 0x40},
8320                         {0x20, AC_VERB_SET_PROC_COEF, 0x8800},
8321                         {}
8322                 },
8323                 .chained = true,
8324                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8325         },
8326         [ALC233_FIXUP_LENOVO_MULTI_CODECS] = {
8327                 .type = HDA_FIXUP_FUNC,
8328                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
8329                 .chained = true,
8330                 .chain_id = ALC269_FIXUP_GPIO2
8331         },
8332         [ALC233_FIXUP_ACER_HEADSET_MIC] = {
8333                 .type = HDA_FIXUP_VERBS,
8334                 .v.verbs = (const struct hda_verb[]) {
8335                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8336                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8337                         { }
8338                 },
8339                 .chained = true,
8340                 .chain_id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE
8341         },
8342         [ALC294_FIXUP_LENOVO_MIC_LOCATION] = {
8343                 .type = HDA_FIXUP_PINS,
8344                 .v.pins = (const struct hda_pintbl[]) {
8345                         /* Change the mic location from front to right, otherwise there are
8346                            two front mics with the same name, pulseaudio can't handle them.
8347                            This is just a temporary workaround, after applying this fixup,
8348                            there will be one "Front Mic" and one "Mic" in this machine.
8349                          */
8350                         { 0x1a, 0x04a19040 },
8351                         { }
8352                 },
8353         },
8354         [ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE] = {
8355                 .type = HDA_FIXUP_PINS,
8356                 .v.pins = (const struct hda_pintbl[]) {
8357                         { 0x16, 0x0101102f }, /* Rear Headset HP */
8358                         { 0x19, 0x02a1913c }, /* use as Front headset mic, without its own jack detect */
8359                         { 0x1a, 0x01a19030 }, /* Rear Headset MIC */
8360                         { 0x1b, 0x02011020 },
8361                         { }
8362                 },
8363                 .chained = true,
8364                 .chain_id = ALC225_FIXUP_S3_POP_NOISE
8365         },
8366         [ALC225_FIXUP_S3_POP_NOISE] = {
8367                 .type = HDA_FIXUP_FUNC,
8368                 .v.func = alc225_fixup_s3_pop_noise,
8369                 .chained = true,
8370                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8371         },
8372         [ALC700_FIXUP_INTEL_REFERENCE] = {
8373                 .type = HDA_FIXUP_VERBS,
8374                 .v.verbs = (const struct hda_verb[]) {
8375                         /* Enables internal speaker */
8376                         {0x20, AC_VERB_SET_COEF_INDEX, 0x45},
8377                         {0x20, AC_VERB_SET_PROC_COEF, 0x5289},
8378                         {0x20, AC_VERB_SET_COEF_INDEX, 0x4A},
8379                         {0x20, AC_VERB_SET_PROC_COEF, 0x001b},
8380                         {0x58, AC_VERB_SET_COEF_INDEX, 0x00},
8381                         {0x58, AC_VERB_SET_PROC_COEF, 0x3888},
8382                         {0x20, AC_VERB_SET_COEF_INDEX, 0x6f},
8383                         {0x20, AC_VERB_SET_PROC_COEF, 0x2c0b},
8384                         {}
8385                 }
8386         },
8387         [ALC274_FIXUP_DELL_BIND_DACS] = {
8388                 .type = HDA_FIXUP_FUNC,
8389                 .v.func = alc274_fixup_bind_dacs,
8390                 .chained = true,
8391                 .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE
8392         },
8393         [ALC274_FIXUP_DELL_AIO_LINEOUT_VERB] = {
8394                 .type = HDA_FIXUP_PINS,
8395                 .v.pins = (const struct hda_pintbl[]) {
8396                         { 0x1b, 0x0401102f },
8397                         { }
8398                 },
8399                 .chained = true,
8400                 .chain_id = ALC274_FIXUP_DELL_BIND_DACS
8401         },
8402         [ALC298_FIXUP_TPT470_DOCK_FIX] = {
8403                 .type = HDA_FIXUP_FUNC,
8404                 .v.func = alc_fixup_tpt470_dock,
8405                 .chained = true,
8406                 .chain_id = ALC293_FIXUP_LENOVO_SPK_NOISE
8407         },
8408         [ALC298_FIXUP_TPT470_DOCK] = {
8409                 .type = HDA_FIXUP_FUNC,
8410                 .v.func = alc_fixup_tpt470_dacs,
8411                 .chained = true,
8412                 .chain_id = ALC298_FIXUP_TPT470_DOCK_FIX
8413         },
8414         [ALC255_FIXUP_DUMMY_LINEOUT_VERB] = {
8415                 .type = HDA_FIXUP_PINS,
8416                 .v.pins = (const struct hda_pintbl[]) {
8417                         { 0x14, 0x0201101f },
8418                         { }
8419                 },
8420                 .chained = true,
8421                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
8422         },
8423         [ALC255_FIXUP_DELL_HEADSET_MIC] = {
8424                 .type = HDA_FIXUP_PINS,
8425                 .v.pins = (const struct hda_pintbl[]) {
8426                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8427                         { }
8428                 },
8429                 .chained = true,
8430                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8431         },
8432         [ALC295_FIXUP_HP_X360] = {
8433                 .type = HDA_FIXUP_FUNC,
8434                 .v.func = alc295_fixup_hp_top_speakers,
8435                 .chained = true,
8436                 .chain_id = ALC269_FIXUP_HP_MUTE_LED_MIC3
8437         },
8438         [ALC221_FIXUP_HP_HEADSET_MIC] = {
8439                 .type = HDA_FIXUP_PINS,
8440                 .v.pins = (const struct hda_pintbl[]) {
8441                         { 0x19, 0x0181313f},
8442                         { }
8443                 },
8444                 .chained = true,
8445                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8446         },
8447         [ALC285_FIXUP_LENOVO_HEADPHONE_NOISE] = {
8448                 .type = HDA_FIXUP_FUNC,
8449                 .v.func = alc285_fixup_invalidate_dacs,
8450                 .chained = true,
8451                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8452         },
8453         [ALC295_FIXUP_HP_AUTO_MUTE] = {
8454                 .type = HDA_FIXUP_FUNC,
8455                 .v.func = alc_fixup_auto_mute_via_amp,
8456         },
8457         [ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE] = {
8458                 .type = HDA_FIXUP_PINS,
8459                 .v.pins = (const struct hda_pintbl[]) {
8460                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8461                         { }
8462                 },
8463                 .chained = true,
8464                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8465         },
8466         [ALC294_FIXUP_ASUS_MIC] = {
8467                 .type = HDA_FIXUP_PINS,
8468                 .v.pins = (const struct hda_pintbl[]) {
8469                         { 0x13, 0x90a60160 }, /* use as internal mic */
8470                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8471                         { }
8472                 },
8473                 .chained = true,
8474                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8475         },
8476         [ALC294_FIXUP_ASUS_HEADSET_MIC] = {
8477                 .type = HDA_FIXUP_PINS,
8478                 .v.pins = (const struct hda_pintbl[]) {
8479                         { 0x19, 0x01a1103c }, /* use as headset mic */
8480                         { }
8481                 },
8482                 .chained = true,
8483                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8484         },
8485         [ALC294_FIXUP_ASUS_SPK] = {
8486                 .type = HDA_FIXUP_VERBS,
8487                 .v.verbs = (const struct hda_verb[]) {
8488                         /* Set EAPD high */
8489                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x40 },
8490                         { 0x20, AC_VERB_SET_PROC_COEF, 0x8800 },
8491                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8492                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8493                         { }
8494                 },
8495                 .chained = true,
8496                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8497         },
8498         [ALC295_FIXUP_CHROME_BOOK] = {
8499                 .type = HDA_FIXUP_FUNC,
8500                 .v.func = alc295_fixup_chromebook,
8501                 .chained = true,
8502                 .chain_id = ALC225_FIXUP_HEADSET_JACK
8503         },
8504         [ALC225_FIXUP_HEADSET_JACK] = {
8505                 .type = HDA_FIXUP_FUNC,
8506                 .v.func = alc_fixup_headset_jack,
8507         },
8508         [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
8509                 .type = HDA_FIXUP_PINS,
8510                 .v.pins = (const struct hda_pintbl[]) {
8511                         { 0x1a, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8512                         { }
8513                 },
8514                 .chained = true,
8515                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8516         },
8517         [ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE] = {
8518                 .type = HDA_FIXUP_VERBS,
8519                 .v.verbs = (const struct hda_verb[]) {
8520                         /* Disable PCBEEP-IN passthrough */
8521                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x36 },
8522                         { 0x20, AC_VERB_SET_PROC_COEF, 0x57d7 },
8523                         { }
8524                 },
8525                 .chained = true,
8526                 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
8527         },
8528         [ALC255_FIXUP_ACER_HEADSET_MIC] = {
8529                 .type = HDA_FIXUP_PINS,
8530                 .v.pins = (const struct hda_pintbl[]) {
8531                         { 0x19, 0x03a11130 },
8532                         { 0x1a, 0x90a60140 }, /* use as internal mic */
8533                         { }
8534                 },
8535                 .chained = true,
8536                 .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
8537         },
8538         [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
8539                 .type = HDA_FIXUP_PINS,
8540                 .v.pins = (const struct hda_pintbl[]) {
8541                         { 0x16, 0x01011020 }, /* Rear Line out */
8542                         { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
8543                         { }
8544                 },
8545                 .chained = true,
8546                 .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
8547         },
8548         [ALC225_FIXUP_WYSE_AUTO_MUTE] = {
8549                 .type = HDA_FIXUP_FUNC,
8550                 .v.func = alc_fixup_auto_mute_via_amp,
8551                 .chained = true,
8552                 .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
8553         },
8554         [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
8555                 .type = HDA_FIXUP_FUNC,
8556                 .v.func = alc_fixup_disable_mic_vref,
8557                 .chained = true,
8558                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
8559         },
8560         [ALC286_FIXUP_ACER_AIO_HEADSET_MIC] = {
8561                 .type = HDA_FIXUP_VERBS,
8562                 .v.verbs = (const struct hda_verb[]) {
8563                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x4f },
8564                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5029 },
8565                         { }
8566                 },
8567                 .chained = true,
8568                 .chain_id = ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE
8569         },
8570         [ALC256_FIXUP_ASUS_HEADSET_MIC] = {
8571                 .type = HDA_FIXUP_PINS,
8572                 .v.pins = (const struct hda_pintbl[]) {
8573                         { 0x19, 0x03a11020 }, /* headset mic with jack detect */
8574                         { }
8575                 },
8576                 .chained = true,
8577                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8578         },
8579         [ALC256_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8580                 .type = HDA_FIXUP_PINS,
8581                 .v.pins = (const struct hda_pintbl[]) {
8582                         { 0x19, 0x04a11120 }, /* use as headset mic, without its own jack detect */
8583                         { }
8584                 },
8585                 .chained = true,
8586                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8587         },
8588         [ALC299_FIXUP_PREDATOR_SPK] = {
8589                 .type = HDA_FIXUP_PINS,
8590                 .v.pins = (const struct hda_pintbl[]) {
8591                         { 0x21, 0x90170150 }, /* use as headset mic, without its own jack detect */
8592                         { }
8593                 }
8594         },
8595         [ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE] = {
8596                 .type = HDA_FIXUP_PINS,
8597                 .v.pins = (const struct hda_pintbl[]) {
8598                         { 0x19, 0x04a11040 },
8599                         { 0x21, 0x04211020 },
8600                         { }
8601                 },
8602                 .chained = true,
8603                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8604         },
8605         [ALC289_FIXUP_DELL_SPK1] = {
8606                 .type = HDA_FIXUP_PINS,
8607                 .v.pins = (const struct hda_pintbl[]) {
8608                         { 0x14, 0x90170140 },
8609                         { }
8610                 },
8611                 .chained = true,
8612                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8613         },
8614         [ALC289_FIXUP_DELL_SPK2] = {
8615                 .type = HDA_FIXUP_PINS,
8616                 .v.pins = (const struct hda_pintbl[]) {
8617                         { 0x17, 0x90170130 }, /* bass spk */
8618                         { }
8619                 },
8620                 .chained = true,
8621                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE
8622         },
8623         [ALC289_FIXUP_DUAL_SPK] = {
8624                 .type = HDA_FIXUP_FUNC,
8625                 .v.func = alc285_fixup_speaker2_to_dac1,
8626                 .chained = true,
8627                 .chain_id = ALC289_FIXUP_DELL_SPK2
8628         },
8629         [ALC289_FIXUP_RTK_AMP_DUAL_SPK] = {
8630                 .type = HDA_FIXUP_FUNC,
8631                 .v.func = alc285_fixup_speaker2_to_dac1,
8632                 .chained = true,
8633                 .chain_id = ALC289_FIXUP_DELL_SPK1
8634         },
8635         [ALC294_FIXUP_SPK2_TO_DAC1] = {
8636                 .type = HDA_FIXUP_FUNC,
8637                 .v.func = alc285_fixup_speaker2_to_dac1,
8638                 .chained = true,
8639                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8640         },
8641         [ALC294_FIXUP_ASUS_DUAL_SPK] = {
8642                 .type = HDA_FIXUP_FUNC,
8643                 /* The GPIO must be pulled to initialize the AMP */
8644                 .v.func = alc_fixup_gpio4,
8645                 .chained = true,
8646                 .chain_id = ALC294_FIXUP_SPK2_TO_DAC1
8647         },
8648         [ALC294_FIXUP_ASUS_ALLY] = {
8649                 .type = HDA_FIXUP_FUNC,
8650                 .v.func = cs35l41_fixup_i2c_two,
8651                 .chained = true,
8652                 .chain_id = ALC294_FIXUP_ASUS_ALLY_PINS
8653         },
8654         [ALC294_FIXUP_ASUS_ALLY_PINS] = {
8655                 .type = HDA_FIXUP_PINS,
8656                 .v.pins = (const struct hda_pintbl[]) {
8657                         { 0x19, 0x03a11050 },
8658                         { 0x1a, 0x03a11c30 },
8659                         { 0x21, 0x03211420 },
8660                         { }
8661                 },
8662                 .chained = true,
8663                 .chain_id = ALC294_FIXUP_ASUS_ALLY_VERBS
8664         },
8665         [ALC294_FIXUP_ASUS_ALLY_VERBS] = {
8666                 .type = HDA_FIXUP_VERBS,
8667                 .v.verbs = (const struct hda_verb[]) {
8668                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
8669                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
8670                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x46 },
8671                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0004 },
8672                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x47 },
8673                         { 0x20, AC_VERB_SET_PROC_COEF, 0xa47a },
8674                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x49 },
8675                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0049},
8676                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x4a },
8677                         { 0x20, AC_VERB_SET_PROC_COEF, 0x201b },
8678                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x6b },
8679                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4278},
8680                         { }
8681                 },
8682                 .chained = true,
8683                 .chain_id = ALC294_FIXUP_ASUS_ALLY_SPEAKER
8684         },
8685         [ALC294_FIXUP_ASUS_ALLY_SPEAKER] = {
8686                 .type = HDA_FIXUP_FUNC,
8687                 .v.func = alc285_fixup_speaker2_to_dac1,
8688         },
8689         [ALC285_FIXUP_THINKPAD_X1_GEN7] = {
8690                 .type = HDA_FIXUP_FUNC,
8691                 .v.func = alc285_fixup_thinkpad_x1_gen7,
8692                 .chained = true,
8693                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
8694         },
8695         [ALC285_FIXUP_THINKPAD_HEADSET_JACK] = {
8696                 .type = HDA_FIXUP_FUNC,
8697                 .v.func = alc_fixup_headset_jack,
8698                 .chained = true,
8699                 .chain_id = ALC285_FIXUP_THINKPAD_X1_GEN7
8700         },
8701         [ALC294_FIXUP_ASUS_HPE] = {
8702                 .type = HDA_FIXUP_VERBS,
8703                 .v.verbs = (const struct hda_verb[]) {
8704                         /* Set EAPD high */
8705                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
8706                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7774 },
8707                         { }
8708                 },
8709                 .chained = true,
8710                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
8711         },
8712         [ALC294_FIXUP_ASUS_GX502_PINS] = {
8713                 .type = HDA_FIXUP_PINS,
8714                 .v.pins = (const struct hda_pintbl[]) {
8715                         { 0x19, 0x03a11050 }, /* front HP mic */
8716                         { 0x1a, 0x01a11830 }, /* rear external mic */
8717                         { 0x21, 0x03211020 }, /* front HP out */
8718                         { }
8719                 },
8720                 .chained = true,
8721                 .chain_id = ALC294_FIXUP_ASUS_GX502_VERBS
8722         },
8723         [ALC294_FIXUP_ASUS_GX502_VERBS] = {
8724                 .type = HDA_FIXUP_VERBS,
8725                 .v.verbs = (const struct hda_verb[]) {
8726                         /* set 0x15 to HP-OUT ctrl */
8727                         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8728                         /* unmute the 0x15 amp */
8729                         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8730                         { }
8731                 },
8732                 .chained = true,
8733                 .chain_id = ALC294_FIXUP_ASUS_GX502_HP
8734         },
8735         [ALC294_FIXUP_ASUS_GX502_HP] = {
8736                 .type = HDA_FIXUP_FUNC,
8737                 .v.func = alc294_fixup_gx502_hp,
8738         },
8739         [ALC294_FIXUP_ASUS_GU502_PINS] = {
8740                 .type = HDA_FIXUP_PINS,
8741                 .v.pins = (const struct hda_pintbl[]) {
8742                         { 0x19, 0x01a11050 }, /* rear HP mic */
8743                         { 0x1a, 0x01a11830 }, /* rear external mic */
8744                         { 0x21, 0x012110f0 }, /* rear HP out */
8745                         { }
8746                 },
8747                 .chained = true,
8748                 .chain_id = ALC294_FIXUP_ASUS_GU502_VERBS
8749         },
8750         [ALC294_FIXUP_ASUS_GU502_VERBS] = {
8751                 .type = HDA_FIXUP_VERBS,
8752                 .v.verbs = (const struct hda_verb[]) {
8753                         /* set 0x15 to HP-OUT ctrl */
8754                         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
8755                         /* unmute the 0x15 amp */
8756                         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000 },
8757                         /* set 0x1b to HP-OUT */
8758                         { 0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
8759                         { }
8760                 },
8761                 .chained = true,
8762                 .chain_id = ALC294_FIXUP_ASUS_GU502_HP
8763         },
8764         [ALC294_FIXUP_ASUS_GU502_HP] = {
8765                 .type = HDA_FIXUP_FUNC,
8766                 .v.func = alc294_fixup_gu502_hp,
8767         },
8768          [ALC294_FIXUP_ASUS_G513_PINS] = {
8769                 .type = HDA_FIXUP_PINS,
8770                 .v.pins = (const struct hda_pintbl[]) {
8771                                 { 0x19, 0x03a11050 }, /* front HP mic */
8772                                 { 0x1a, 0x03a11c30 }, /* rear external mic */
8773                                 { 0x21, 0x03211420 }, /* front HP out */
8774                                 { }
8775                 },
8776         },
8777         [ALC285_FIXUP_ASUS_G533Z_PINS] = {
8778                 .type = HDA_FIXUP_PINS,
8779                 .v.pins = (const struct hda_pintbl[]) {
8780                         { 0x14, 0x90170152 }, /* Speaker Surround Playback Switch */
8781                         { 0x19, 0x03a19020 }, /* Mic Boost Volume */
8782                         { 0x1a, 0x03a11c30 }, /* Mic Boost Volume */
8783                         { 0x1e, 0x90170151 }, /* Rear jack, IN OUT EAPD Detect */
8784                         { 0x21, 0x03211420 },
8785                         { }
8786                 },
8787         },
8788         [ALC294_FIXUP_ASUS_COEF_1B] = {
8789                 .type = HDA_FIXUP_VERBS,
8790                 .v.verbs = (const struct hda_verb[]) {
8791                         /* Set bit 10 to correct noisy output after reboot from
8792                          * Windows 10 (due to pop noise reduction?)
8793                          */
8794                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x1b },
8795                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4e4b },
8796                         { }
8797                 },
8798                 .chained = true,
8799                 .chain_id = ALC289_FIXUP_ASUS_GA401,
8800         },
8801         [ALC285_FIXUP_HP_GPIO_LED] = {
8802                 .type = HDA_FIXUP_FUNC,
8803                 .v.func = alc285_fixup_hp_gpio_led,
8804         },
8805         [ALC285_FIXUP_HP_MUTE_LED] = {
8806                 .type = HDA_FIXUP_FUNC,
8807                 .v.func = alc285_fixup_hp_mute_led,
8808         },
8809         [ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED] = {
8810                 .type = HDA_FIXUP_FUNC,
8811                 .v.func = alc285_fixup_hp_spectre_x360_mute_led,
8812         },
8813         [ALC236_FIXUP_HP_MUTE_LED_COEFBIT2] = {
8814             .type = HDA_FIXUP_FUNC,
8815             .v.func = alc236_fixup_hp_mute_led_coefbit2,
8816         },
8817         [ALC236_FIXUP_HP_GPIO_LED] = {
8818                 .type = HDA_FIXUP_FUNC,
8819                 .v.func = alc236_fixup_hp_gpio_led,
8820         },
8821         [ALC236_FIXUP_HP_MUTE_LED] = {
8822                 .type = HDA_FIXUP_FUNC,
8823                 .v.func = alc236_fixup_hp_mute_led,
8824         },
8825         [ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF] = {
8826                 .type = HDA_FIXUP_FUNC,
8827                 .v.func = alc236_fixup_hp_mute_led_micmute_vref,
8828         },
8829         [ALC298_FIXUP_SAMSUNG_AMP] = {
8830                 .type = HDA_FIXUP_FUNC,
8831                 .v.func = alc298_fixup_samsung_amp,
8832                 .chained = true,
8833                 .chain_id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET
8834         },
8835         [ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8836                 .type = HDA_FIXUP_VERBS,
8837                 .v.verbs = (const struct hda_verb[]) {
8838                         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc5 },
8839                         { }
8840                 },
8841         },
8842         [ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET] = {
8843                 .type = HDA_FIXUP_VERBS,
8844                 .v.verbs = (const struct hda_verb[]) {
8845                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x08},
8846                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2fcf},
8847                         { }
8848                 },
8849         },
8850         [ALC295_FIXUP_ASUS_MIC_NO_PRESENCE] = {
8851                 .type = HDA_FIXUP_PINS,
8852                 .v.pins = (const struct hda_pintbl[]) {
8853                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
8854                         { }
8855                 },
8856                 .chained = true,
8857                 .chain_id = ALC269_FIXUP_HEADSET_MODE
8858         },
8859         [ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS] = {
8860                 .type = HDA_FIXUP_PINS,
8861                 .v.pins = (const struct hda_pintbl[]) {
8862                         { 0x14, 0x90100120 }, /* use as internal speaker */
8863                         { 0x18, 0x02a111f0 }, /* use as headset mic, without its own jack detect */
8864                         { 0x1a, 0x01011020 }, /* use as line out */
8865                         { },
8866                 },
8867                 .chained = true,
8868                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8869         },
8870         [ALC269VC_FIXUP_ACER_HEADSET_MIC] = {
8871                 .type = HDA_FIXUP_PINS,
8872                 .v.pins = (const struct hda_pintbl[]) {
8873                         { 0x18, 0x02a11030 }, /* use as headset mic */
8874                         { }
8875                 },
8876                 .chained = true,
8877                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8878         },
8879         [ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE] = {
8880                 .type = HDA_FIXUP_PINS,
8881                 .v.pins = (const struct hda_pintbl[]) {
8882                         { 0x18, 0x01a11130 }, /* use as headset mic, without its own jack detect */
8883                         { }
8884                 },
8885                 .chained = true,
8886                 .chain_id = ALC269_FIXUP_HEADSET_MIC
8887         },
8888         [ALC289_FIXUP_ASUS_GA401] = {
8889                 .type = HDA_FIXUP_FUNC,
8890                 .v.func = alc289_fixup_asus_ga401,
8891                 .chained = true,
8892                 .chain_id = ALC289_FIXUP_ASUS_GA502,
8893         },
8894         [ALC289_FIXUP_ASUS_GA502] = {
8895                 .type = HDA_FIXUP_PINS,
8896                 .v.pins = (const struct hda_pintbl[]) {
8897                         { 0x19, 0x03a11020 }, /* headset mic with jack detect */
8898                         { }
8899                 },
8900         },
8901         [ALC256_FIXUP_ACER_MIC_NO_PRESENCE] = {
8902                 .type = HDA_FIXUP_PINS,
8903                 .v.pins = (const struct hda_pintbl[]) {
8904                         { 0x19, 0x02a11120 }, /* use as headset mic, without its own jack detect */
8905                         { }
8906                 },
8907                 .chained = true,
8908                 .chain_id = ALC256_FIXUP_ASUS_HEADSET_MODE
8909         },
8910         [ALC285_FIXUP_HP_GPIO_AMP_INIT] = {
8911                 .type = HDA_FIXUP_FUNC,
8912                 .v.func = alc285_fixup_hp_gpio_amp_init,
8913                 .chained = true,
8914                 .chain_id = ALC285_FIXUP_HP_GPIO_LED
8915         },
8916         [ALC269_FIXUP_CZC_B20] = {
8917                 .type = HDA_FIXUP_PINS,
8918                 .v.pins = (const struct hda_pintbl[]) {
8919                         { 0x12, 0x411111f0 },
8920                         { 0x14, 0x90170110 }, /* speaker */
8921                         { 0x15, 0x032f1020 }, /* HP out */
8922                         { 0x17, 0x411111f0 },
8923                         { 0x18, 0x03ab1040 }, /* mic */
8924                         { 0x19, 0xb7a7013f },
8925                         { 0x1a, 0x0181305f },
8926                         { 0x1b, 0x411111f0 },
8927                         { 0x1d, 0x411111f0 },
8928                         { 0x1e, 0x411111f0 },
8929                         { }
8930                 },
8931                 .chain_id = ALC269_FIXUP_DMIC,
8932         },
8933         [ALC269_FIXUP_CZC_TMI] = {
8934                 .type = HDA_FIXUP_PINS,
8935                 .v.pins = (const struct hda_pintbl[]) {
8936                         { 0x12, 0x4000c000 },
8937                         { 0x14, 0x90170110 }, /* speaker */
8938                         { 0x15, 0x0421401f }, /* HP out */
8939                         { 0x17, 0x411111f0 },
8940                         { 0x18, 0x04a19020 }, /* mic */
8941                         { 0x19, 0x411111f0 },
8942                         { 0x1a, 0x411111f0 },
8943                         { 0x1b, 0x411111f0 },
8944                         { 0x1d, 0x40448505 },
8945                         { 0x1e, 0x411111f0 },
8946                         { 0x20, 0x8000ffff },
8947                         { }
8948                 },
8949                 .chain_id = ALC269_FIXUP_DMIC,
8950         },
8951         [ALC269_FIXUP_CZC_L101] = {
8952                 .type = HDA_FIXUP_PINS,
8953                 .v.pins = (const struct hda_pintbl[]) {
8954                         { 0x12, 0x40000000 },
8955                         { 0x14, 0x01014010 }, /* speaker */
8956                         { 0x15, 0x411111f0 }, /* HP out */
8957                         { 0x16, 0x411111f0 },
8958                         { 0x18, 0x01a19020 }, /* mic */
8959                         { 0x19, 0x02a19021 },
8960                         { 0x1a, 0x0181302f },
8961                         { 0x1b, 0x0221401f },
8962                         { 0x1c, 0x411111f0 },
8963                         { 0x1d, 0x4044c601 },
8964                         { 0x1e, 0x411111f0 },
8965                         { }
8966                 },
8967                 .chain_id = ALC269_FIXUP_DMIC,
8968         },
8969         [ALC269_FIXUP_LEMOTE_A1802] = {
8970                 .type = HDA_FIXUP_PINS,
8971                 .v.pins = (const struct hda_pintbl[]) {
8972                         { 0x12, 0x40000000 },
8973                         { 0x14, 0x90170110 }, /* speaker */
8974                         { 0x17, 0x411111f0 },
8975                         { 0x18, 0x03a19040 }, /* mic1 */
8976                         { 0x19, 0x90a70130 }, /* mic2 */
8977                         { 0x1a, 0x411111f0 },
8978                         { 0x1b, 0x411111f0 },
8979                         { 0x1d, 0x40489d2d },
8980                         { 0x1e, 0x411111f0 },
8981                         { 0x20, 0x0003ffff },
8982                         { 0x21, 0x03214020 },
8983                         { }
8984                 },
8985                 .chain_id = ALC269_FIXUP_DMIC,
8986         },
8987         [ALC269_FIXUP_LEMOTE_A190X] = {
8988                 .type = HDA_FIXUP_PINS,
8989                 .v.pins = (const struct hda_pintbl[]) {
8990                         { 0x14, 0x99130110 }, /* speaker */
8991                         { 0x15, 0x0121401f }, /* HP out */
8992                         { 0x18, 0x01a19c20 }, /* rear  mic */
8993                         { 0x19, 0x99a3092f }, /* front mic */
8994                         { 0x1b, 0x0201401f }, /* front lineout */
8995                         { }
8996                 },
8997                 .chain_id = ALC269_FIXUP_DMIC,
8998         },
8999         [ALC256_FIXUP_INTEL_NUC8_RUGGED] = {
9000                 .type = HDA_FIXUP_PINS,
9001                 .v.pins = (const struct hda_pintbl[]) {
9002                         { 0x1b, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9003                         { }
9004                 },
9005                 .chained = true,
9006                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9007         },
9008         [ALC256_FIXUP_INTEL_NUC10] = {
9009                 .type = HDA_FIXUP_PINS,
9010                 .v.pins = (const struct hda_pintbl[]) {
9011                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9012                         { }
9013                 },
9014                 .chained = true,
9015                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9016         },
9017         [ALC255_FIXUP_XIAOMI_HEADSET_MIC] = {
9018                 .type = HDA_FIXUP_VERBS,
9019                 .v.verbs = (const struct hda_verb[]) {
9020                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9021                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9022                         { }
9023                 },
9024                 .chained = true,
9025                 .chain_id = ALC289_FIXUP_ASUS_GA502
9026         },
9027         [ALC274_FIXUP_HP_MIC] = {
9028                 .type = HDA_FIXUP_VERBS,
9029                 .v.verbs = (const struct hda_verb[]) {
9030                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x45 },
9031                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5089 },
9032                         { }
9033                 },
9034         },
9035         [ALC274_FIXUP_HP_HEADSET_MIC] = {
9036                 .type = HDA_FIXUP_FUNC,
9037                 .v.func = alc274_fixup_hp_headset_mic,
9038                 .chained = true,
9039                 .chain_id = ALC274_FIXUP_HP_MIC
9040         },
9041         [ALC274_FIXUP_HP_ENVY_GPIO] = {
9042                 .type = HDA_FIXUP_FUNC,
9043                 .v.func = alc274_fixup_hp_envy_gpio,
9044         },
9045         [ALC256_FIXUP_ASUS_HPE] = {
9046                 .type = HDA_FIXUP_VERBS,
9047                 .v.verbs = (const struct hda_verb[]) {
9048                         /* Set EAPD high */
9049                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x0f },
9050                         { 0x20, AC_VERB_SET_PROC_COEF, 0x7778 },
9051                         { }
9052                 },
9053                 .chained = true,
9054                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
9055         },
9056         [ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK] = {
9057                 .type = HDA_FIXUP_FUNC,
9058                 .v.func = alc_fixup_headset_jack,
9059                 .chained = true,
9060                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI
9061         },
9062         [ALC287_FIXUP_HP_GPIO_LED] = {
9063                 .type = HDA_FIXUP_FUNC,
9064                 .v.func = alc287_fixup_hp_gpio_led,
9065         },
9066         [ALC256_FIXUP_HP_HEADSET_MIC] = {
9067                 .type = HDA_FIXUP_FUNC,
9068                 .v.func = alc274_fixup_hp_headset_mic,
9069         },
9070         [ALC236_FIXUP_DELL_AIO_HEADSET_MIC] = {
9071                 .type = HDA_FIXUP_FUNC,
9072                 .v.func = alc_fixup_no_int_mic,
9073                 .chained = true,
9074                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE
9075         },
9076         [ALC282_FIXUP_ACER_DISABLE_LINEOUT] = {
9077                 .type = HDA_FIXUP_PINS,
9078                 .v.pins = (const struct hda_pintbl[]) {
9079                         { 0x1b, 0x411111f0 },
9080                         { 0x18, 0x01a1913c }, /* use as headset mic, without its own jack detect */
9081                         { },
9082                 },
9083                 .chained = true,
9084                 .chain_id = ALC269_FIXUP_HEADSET_MODE
9085         },
9086         [ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST] = {
9087                 .type = HDA_FIXUP_FUNC,
9088                 .v.func = alc269_fixup_limit_int_mic_boost,
9089                 .chained = true,
9090                 .chain_id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
9091         },
9092         [ALC256_FIXUP_ACER_HEADSET_MIC] = {
9093                 .type = HDA_FIXUP_PINS,
9094                 .v.pins = (const struct hda_pintbl[]) {
9095                         { 0x19, 0x02a1113c }, /* use as headset mic, without its own jack detect */
9096                         { 0x1a, 0x90a1092f }, /* use as internal mic */
9097                         { }
9098                 },
9099                 .chained = true,
9100                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9101         },
9102         [ALC285_FIXUP_IDEAPAD_S740_COEF] = {
9103                 .type = HDA_FIXUP_FUNC,
9104                 .v.func = alc285_fixup_ideapad_s740_coef,
9105                 .chained = true,
9106                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9107         },
9108         [ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9109                 .type = HDA_FIXUP_FUNC,
9110                 .v.func = alc269_fixup_limit_int_mic_boost,
9111                 .chained = true,
9112                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9113         },
9114         [ALC295_FIXUP_ASUS_DACS] = {
9115                 .type = HDA_FIXUP_FUNC,
9116                 .v.func = alc295_fixup_asus_dacs,
9117         },
9118         [ALC295_FIXUP_HP_OMEN] = {
9119                 .type = HDA_FIXUP_PINS,
9120                 .v.pins = (const struct hda_pintbl[]) {
9121                         { 0x12, 0xb7a60130 },
9122                         { 0x13, 0x40000000 },
9123                         { 0x14, 0x411111f0 },
9124                         { 0x16, 0x411111f0 },
9125                         { 0x17, 0x90170110 },
9126                         { 0x18, 0x411111f0 },
9127                         { 0x19, 0x02a11030 },
9128                         { 0x1a, 0x411111f0 },
9129                         { 0x1b, 0x04a19030 },
9130                         { 0x1d, 0x40600001 },
9131                         { 0x1e, 0x411111f0 },
9132                         { 0x21, 0x03211020 },
9133                         {}
9134                 },
9135                 .chained = true,
9136                 .chain_id = ALC269_FIXUP_HP_LINE1_MIC1_LED,
9137         },
9138         [ALC285_FIXUP_HP_SPECTRE_X360] = {
9139                 .type = HDA_FIXUP_FUNC,
9140                 .v.func = alc285_fixup_hp_spectre_x360,
9141         },
9142         [ALC285_FIXUP_HP_SPECTRE_X360_EB1] = {
9143                 .type = HDA_FIXUP_FUNC,
9144                 .v.func = alc285_fixup_hp_spectre_x360_eb1
9145         },
9146         [ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP] = {
9147                 .type = HDA_FIXUP_FUNC,
9148                 .v.func = alc285_fixup_ideapad_s740_coef,
9149                 .chained = true,
9150                 .chain_id = ALC285_FIXUP_THINKPAD_HEADSET_JACK,
9151         },
9152         [ALC623_FIXUP_LENOVO_THINKSTATION_P340] = {
9153                 .type = HDA_FIXUP_FUNC,
9154                 .v.func = alc_fixup_no_shutup,
9155                 .chained = true,
9156                 .chain_id = ALC283_FIXUP_HEADSET_MIC,
9157         },
9158         [ALC255_FIXUP_ACER_HEADPHONE_AND_MIC] = {
9159                 .type = HDA_FIXUP_PINS,
9160                 .v.pins = (const struct hda_pintbl[]) {
9161                         { 0x21, 0x03211030 }, /* Change the Headphone location to Left */
9162                         { }
9163                 },
9164                 .chained = true,
9165                 .chain_id = ALC255_FIXUP_XIAOMI_HEADSET_MIC
9166         },
9167         [ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST] = {
9168                 .type = HDA_FIXUP_FUNC,
9169                 .v.func = alc269_fixup_limit_int_mic_boost,
9170                 .chained = true,
9171                 .chain_id = ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF,
9172         },
9173         [ALC285_FIXUP_LEGION_Y9000X_SPEAKERS] = {
9174                 .type = HDA_FIXUP_FUNC,
9175                 .v.func = alc285_fixup_ideapad_s740_coef,
9176                 .chained = true,
9177                 .chain_id = ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE,
9178         },
9179         [ALC285_FIXUP_LEGION_Y9000X_AUTOMUTE] = {
9180                 .type = HDA_FIXUP_FUNC,
9181                 .v.func = alc287_fixup_legion_15imhg05_speakers,
9182                 .chained = true,
9183                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9184         },
9185         [ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS] = {
9186                 .type = HDA_FIXUP_VERBS,
9187                 //.v.verbs = legion_15imhg05_coefs,
9188                 .v.verbs = (const struct hda_verb[]) {
9189                          // set left speaker Legion 7i.
9190                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9191                          { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9192
9193                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9194                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9195                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9196                          { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9197                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9198
9199                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9200                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9201                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9202                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9203                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9204
9205                          // set right speaker Legion 7i.
9206                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9207                          { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9208
9209                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9210                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9211                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9212                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9213                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9214
9215                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9216                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9217                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9218                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9219                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9220                          {}
9221                 },
9222                 .chained = true,
9223                 .chain_id = ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
9224         },
9225         [ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE] = {
9226                 .type = HDA_FIXUP_FUNC,
9227                 .v.func = alc287_fixup_legion_15imhg05_speakers,
9228                 .chained = true,
9229                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9230         },
9231         [ALC287_FIXUP_YOGA7_14ITL_SPEAKERS] = {
9232                 .type = HDA_FIXUP_VERBS,
9233                 .v.verbs = (const struct hda_verb[]) {
9234                          // set left speaker Yoga 7i.
9235                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9236                          { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9237
9238                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9239                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9240                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9241                          { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9242                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9243
9244                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9245                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9246                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9247                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9248                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9249
9250                          // set right speaker Yoga 7i.
9251                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9252                          { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9253
9254                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9255                          { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9256                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9257                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9258                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9259
9260                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9261                          { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9262                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9263                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9264                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9265                          {}
9266                 },
9267                 .chained = true,
9268                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9269         },
9270         [ALC298_FIXUP_LENOVO_C940_DUET7] = {
9271                 .type = HDA_FIXUP_FUNC,
9272                 .v.func = alc298_fixup_lenovo_c940_duet7,
9273         },
9274         [ALC287_FIXUP_13S_GEN2_SPEAKERS] = {
9275                 .type = HDA_FIXUP_VERBS,
9276                 .v.verbs = (const struct hda_verb[]) {
9277                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9278                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9279                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9280                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9281                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9282                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9283                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9284                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9285                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9286                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9287                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9288                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9289                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9290                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9291                         {}
9292                 },
9293                 .chained = true,
9294                 .chain_id = ALC269_FIXUP_HEADSET_MODE,
9295         },
9296         [ALC256_FIXUP_SET_COEF_DEFAULTS] = {
9297                 .type = HDA_FIXUP_FUNC,
9298                 .v.func = alc256_fixup_set_coef_defaults,
9299         },
9300         [ALC245_FIXUP_HP_GPIO_LED] = {
9301                 .type = HDA_FIXUP_FUNC,
9302                 .v.func = alc245_fixup_hp_gpio_led,
9303         },
9304         [ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
9305                 .type = HDA_FIXUP_PINS,
9306                 .v.pins = (const struct hda_pintbl[]) {
9307                         { 0x19, 0x03a11120 }, /* use as headset mic, without its own jack detect */
9308                         { }
9309                 },
9310                 .chained = true,
9311                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC,
9312         },
9313         [ALC233_FIXUP_NO_AUDIO_JACK] = {
9314                 .type = HDA_FIXUP_FUNC,
9315                 .v.func = alc233_fixup_no_audio_jack,
9316         },
9317         [ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME] = {
9318                 .type = HDA_FIXUP_FUNC,
9319                 .v.func = alc256_fixup_mic_no_presence_and_resume,
9320                 .chained = true,
9321                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9322         },
9323         [ALC287_FIXUP_LEGION_16ACHG6] = {
9324                 .type = HDA_FIXUP_FUNC,
9325                 .v.func = alc287_fixup_legion_16achg6_speakers,
9326         },
9327         [ALC287_FIXUP_CS35L41_I2C_2] = {
9328                 .type = HDA_FIXUP_FUNC,
9329                 .v.func = cs35l41_fixup_i2c_two,
9330         },
9331         [ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED] = {
9332                 .type = HDA_FIXUP_FUNC,
9333                 .v.func = cs35l41_fixup_i2c_two,
9334                 .chained = true,
9335                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9336         },
9337         [ALC245_FIXUP_CS35L41_SPI_2] = {
9338                 .type = HDA_FIXUP_FUNC,
9339                 .v.func = cs35l41_fixup_spi_two,
9340         },
9341         [ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED] = {
9342                 .type = HDA_FIXUP_FUNC,
9343                 .v.func = cs35l41_fixup_spi_two,
9344                 .chained = true,
9345                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9346         },
9347         [ALC245_FIXUP_CS35L41_SPI_4] = {
9348                 .type = HDA_FIXUP_FUNC,
9349                 .v.func = cs35l41_fixup_spi_four,
9350         },
9351         [ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED] = {
9352                 .type = HDA_FIXUP_FUNC,
9353                 .v.func = cs35l41_fixup_spi_four,
9354                 .chained = true,
9355                 .chain_id = ALC285_FIXUP_HP_GPIO_LED,
9356         },
9357         [ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED] = {
9358                 .type = HDA_FIXUP_VERBS,
9359                 .v.verbs = (const struct hda_verb[]) {
9360                          { 0x20, AC_VERB_SET_COEF_INDEX, 0x19 },
9361                          { 0x20, AC_VERB_SET_PROC_COEF, 0x8e11 },
9362                          { }
9363                 },
9364                 .chained = true,
9365                 .chain_id = ALC285_FIXUP_HP_MUTE_LED,
9366         },
9367         [ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET] = {
9368                 .type = HDA_FIXUP_FUNC,
9369                 .v.func = alc_fixup_dell4_mic_no_presence_quiet,
9370                 .chained = true,
9371                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9372         },
9373         [ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE] = {
9374                 .type = HDA_FIXUP_PINS,
9375                 .v.pins = (const struct hda_pintbl[]) {
9376                         { 0x19, 0x02a1112c }, /* use as headset mic, without its own jack detect */
9377                         { }
9378                 },
9379                 .chained = true,
9380                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
9381         },
9382         [ALC287_FIXUP_LEGION_16ITHG6] = {
9383                 .type = HDA_FIXUP_FUNC,
9384                 .v.func = alc287_fixup_legion_16ithg6_speakers,
9385         },
9386         [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = {
9387                 .type = HDA_FIXUP_VERBS,
9388                 .v.verbs = (const struct hda_verb[]) {
9389                         // enable left speaker
9390                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9391                         { 0x20, AC_VERB_SET_PROC_COEF, 0x41 },
9392
9393                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9394                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9395                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9396                         { 0x20, AC_VERB_SET_PROC_COEF, 0x1a },
9397                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9398
9399                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9400                         { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9401                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9402                         { 0x20, AC_VERB_SET_PROC_COEF, 0x42 },
9403                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9404
9405                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9406                         { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9407                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9408                         { 0x20, AC_VERB_SET_PROC_COEF, 0x40 },
9409                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9410
9411                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9412                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9413                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9414                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9415                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9416
9417                         // enable right speaker
9418                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 },
9419                         { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9420
9421                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9422                         { 0x20, AC_VERB_SET_PROC_COEF, 0xc },
9423                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9424                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2a },
9425                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9426
9427                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9428                         { 0x20, AC_VERB_SET_PROC_COEF, 0xf },
9429                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9430                         { 0x20, AC_VERB_SET_PROC_COEF, 0x46 },
9431                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9432
9433                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9434                         { 0x20, AC_VERB_SET_PROC_COEF, 0x10 },
9435                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9436                         { 0x20, AC_VERB_SET_PROC_COEF, 0x44 },
9437                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9438
9439                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 },
9440                         { 0x20, AC_VERB_SET_PROC_COEF, 0x2 },
9441                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9442                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
9443                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
9444
9445                         { },
9446                 },
9447         },
9448         [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN] = {
9449                 .type = HDA_FIXUP_FUNC,
9450                 .v.func = alc287_fixup_yoga9_14iap7_bass_spk_pin,
9451                 .chained = true,
9452                 .chain_id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
9453         },
9454         [ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS] = {
9455                 .type = HDA_FIXUP_FUNC,
9456                 .v.func = alc295_fixup_dell_inspiron_top_speakers,
9457                 .chained = true,
9458                 .chain_id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
9459         },
9460         [ALC236_FIXUP_DELL_DUAL_CODECS] = {
9461                 .type = HDA_FIXUP_PINS,
9462                 .v.func = alc1220_fixup_gb_dual_codecs,
9463                 .chained = true,
9464                 .chain_id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
9465         },
9466         [ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI] = {
9467                 .type = HDA_FIXUP_FUNC,
9468                 .v.func = cs35l41_fixup_i2c_two,
9469                 .chained = true,
9470                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9471         },
9472         [ALC287_FIXUP_TAS2781_I2C] = {
9473                 .type = HDA_FIXUP_FUNC,
9474                 .v.func = tas2781_fixup_i2c,
9475                 .chained = true,
9476                 .chain_id = ALC269_FIXUP_THINKPAD_ACPI,
9477         },
9478         [ALC245_FIXUP_HP_MUTE_LED_COEFBIT] = {
9479                 .type = HDA_FIXUP_FUNC,
9480                 .v.func = alc245_fixup_hp_mute_led_coefbit,
9481         },
9482         [ALC245_FIXUP_HP_X360_MUTE_LEDS] = {
9483                 .type = HDA_FIXUP_FUNC,
9484                 .v.func = alc245_fixup_hp_mute_led_coefbit,
9485                 .chained = true,
9486                 .chain_id = ALC245_FIXUP_HP_GPIO_LED
9487         },
9488         [ALC287_FIXUP_THINKPAD_I2S_SPK] = {
9489                 .type = HDA_FIXUP_FUNC,
9490                 .v.func = alc287_fixup_bind_dacs,
9491         },
9492         [ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD] = {
9493                 .type = HDA_FIXUP_FUNC,
9494                 .v.func = alc287_fixup_bind_dacs,
9495                 .chained = true,
9496                 .chain_id = ALC287_FIXUP_CS35L41_I2C_2_THINKPAD_ACPI,
9497         },
9498         [ALC2XX_FIXUP_HEADSET_MIC] = {
9499                 .type = HDA_FIXUP_FUNC,
9500                 .v.func = alc_fixup_headset_mic,
9501         },
9502         [ALC289_FIXUP_DELL_CS35L41_SPI_2] = {
9503                 .type = HDA_FIXUP_FUNC,
9504                 .v.func = cs35l41_fixup_spi_two,
9505                 .chained = true,
9506                 .chain_id = ALC289_FIXUP_DUAL_SPK
9507         },
9508         [ALC294_FIXUP_CS35L41_I2C_2] = {
9509                 .type = HDA_FIXUP_FUNC,
9510                 .v.func = cs35l41_fixup_i2c_two,
9511         },
9512 };
9513
9514 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
9515         SND_PCI_QUIRK(0x1025, 0x0283, "Acer TravelMate 8371", ALC269_FIXUP_INV_DMIC),
9516         SND_PCI_QUIRK(0x1025, 0x029b, "Acer 1810TZ", ALC269_FIXUP_INV_DMIC),
9517         SND_PCI_QUIRK(0x1025, 0x0349, "Acer AOD260", ALC269_FIXUP_INV_DMIC),
9518         SND_PCI_QUIRK(0x1025, 0x047c, "Acer AC700", ALC269_FIXUP_ACER_AC700),
9519         SND_PCI_QUIRK(0x1025, 0x072d, "Acer Aspire V5-571G", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9520         SND_PCI_QUIRK(0x1025, 0x0740, "Acer AO725", ALC271_FIXUP_HP_GATE_MIC_JACK),
9521         SND_PCI_QUIRK(0x1025, 0x0742, "Acer AO756", ALC271_FIXUP_HP_GATE_MIC_JACK),
9522         SND_PCI_QUIRK(0x1025, 0x0762, "Acer Aspire E1-472", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9523         SND_PCI_QUIRK(0x1025, 0x0775, "Acer Aspire E1-572", ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572),
9524         SND_PCI_QUIRK(0x1025, 0x079b, "Acer Aspire V5-573G", ALC282_FIXUP_ASPIRE_V5_PINS),
9525         SND_PCI_QUIRK(0x1025, 0x080d, "Acer Aspire V5-122P", ALC269_FIXUP_ASPIRE_HEADSET_MIC),
9526         SND_PCI_QUIRK(0x1025, 0x0840, "Acer Aspire E1", ALC269VB_FIXUP_ASPIRE_E1_COEF),
9527         SND_PCI_QUIRK(0x1025, 0x101c, "Acer Veriton N2510G", ALC269_FIXUP_LIFEBOOK),
9528         SND_PCI_QUIRK(0x1025, 0x102b, "Acer Aspire C24-860", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
9529         SND_PCI_QUIRK(0x1025, 0x1065, "Acer Aspire C20-820", ALC269VC_FIXUP_ACER_HEADSET_MIC),
9530         SND_PCI_QUIRK(0x1025, 0x106d, "Acer Cloudbook 14", ALC283_FIXUP_CHROME_BOOK),
9531         SND_PCI_QUIRK(0x1025, 0x1094, "Acer Aspire E5-575T", ALC255_FIXUP_ACER_LIMIT_INT_MIC_BOOST),
9532         SND_PCI_QUIRK(0x1025, 0x1099, "Acer Aspire E5-523G", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9533         SND_PCI_QUIRK(0x1025, 0x110e, "Acer Aspire ES1-432", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9534         SND_PCI_QUIRK(0x1025, 0x1166, "Acer Veriton N4640G", ALC269_FIXUP_LIFEBOOK),
9535         SND_PCI_QUIRK(0x1025, 0x1167, "Acer Veriton N6640G", ALC269_FIXUP_LIFEBOOK),
9536         SND_PCI_QUIRK(0x1025, 0x1246, "Acer Predator Helios 500", ALC299_FIXUP_PREDATOR_SPK),
9537         SND_PCI_QUIRK(0x1025, 0x1247, "Acer vCopperbox", ALC269VC_FIXUP_ACER_VCOPPERBOX_PINS),
9538         SND_PCI_QUIRK(0x1025, 0x1248, "Acer Veriton N4660G", ALC269VC_FIXUP_ACER_MIC_NO_PRESENCE),
9539         SND_PCI_QUIRK(0x1025, 0x1269, "Acer SWIFT SF314-54", ALC256_FIXUP_ACER_HEADSET_MIC),
9540         SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9541         SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9542         SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9543         SND_PCI_QUIRK(0x1025, 0x129c, "Acer SWIFT SF314-55", ALC256_FIXUP_ACER_HEADSET_MIC),
9544         SND_PCI_QUIRK(0x1025, 0x129d, "Acer SWIFT SF313-51", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9545         SND_PCI_QUIRK(0x1025, 0x1300, "Acer SWIFT SF314-56", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9546         SND_PCI_QUIRK(0x1025, 0x1308, "Acer Aspire Z24-890", ALC286_FIXUP_ACER_AIO_HEADSET_MIC),
9547         SND_PCI_QUIRK(0x1025, 0x132a, "Acer TravelMate B114-21", ALC233_FIXUP_ACER_HEADSET_MIC),
9548         SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
9549         SND_PCI_QUIRK(0x1025, 0x141f, "Acer Spin SP513-54N", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9550         SND_PCI_QUIRK(0x1025, 0x142b, "Acer Swift SF314-42", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9551         SND_PCI_QUIRK(0x1025, 0x1430, "Acer TravelMate B311R-31", ALC256_FIXUP_ACER_MIC_NO_PRESENCE),
9552         SND_PCI_QUIRK(0x1025, 0x1466, "Acer Aspire A515-56", ALC255_FIXUP_ACER_HEADPHONE_AND_MIC),
9553         SND_PCI_QUIRK(0x1025, 0x1534, "Acer Predator PH315-54", ALC255_FIXUP_ACER_MIC_NO_PRESENCE),
9554         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
9555         SND_PCI_QUIRK(0x1028, 0x053c, "Dell Latitude E5430", ALC292_FIXUP_DELL_E7X),
9556         SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
9557         SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
9558         SND_PCI_QUIRK(0x1028, 0x05be, "Dell Latitude E6540", ALC292_FIXUP_DELL_E7X),
9559         SND_PCI_QUIRK(0x1028, 0x05ca, "Dell Latitude E7240", ALC292_FIXUP_DELL_E7X),
9560         SND_PCI_QUIRK(0x1028, 0x05cb, "Dell Latitude E7440", ALC292_FIXUP_DELL_E7X),
9561         SND_PCI_QUIRK(0x1028, 0x05da, "Dell Vostro 5460", ALC290_FIXUP_SUBWOOFER),
9562         SND_PCI_QUIRK(0x1028, 0x05f4, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9563         SND_PCI_QUIRK(0x1028, 0x05f5, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9564         SND_PCI_QUIRK(0x1028, 0x05f6, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE),
9565         SND_PCI_QUIRK(0x1028, 0x0615, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9566         SND_PCI_QUIRK(0x1028, 0x0616, "Dell Vostro 5470", ALC290_FIXUP_SUBWOOFER_HSJACK),
9567         SND_PCI_QUIRK(0x1028, 0x062c, "Dell Latitude E5550", ALC292_FIXUP_DELL_E7X),
9568         SND_PCI_QUIRK(0x1028, 0x062e, "Dell Latitude E7450", ALC292_FIXUP_DELL_E7X),
9569         SND_PCI_QUIRK(0x1028, 0x0638, "Dell Inspiron 5439", ALC290_FIXUP_MONO_SPEAKERS_HSJACK),
9570         SND_PCI_QUIRK(0x1028, 0x064a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9571         SND_PCI_QUIRK(0x1028, 0x064b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9572         SND_PCI_QUIRK(0x1028, 0x0665, "Dell XPS 13", ALC288_FIXUP_DELL_XPS_13),
9573         SND_PCI_QUIRK(0x1028, 0x0669, "Dell Optiplex 9020m", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9574         SND_PCI_QUIRK(0x1028, 0x069a, "Dell Vostro 5480", ALC290_FIXUP_SUBWOOFER_HSJACK),
9575         SND_PCI_QUIRK(0x1028, 0x06c7, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE),
9576         SND_PCI_QUIRK(0x1028, 0x06d9, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9577         SND_PCI_QUIRK(0x1028, 0x06da, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9578         SND_PCI_QUIRK(0x1028, 0x06db, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9579         SND_PCI_QUIRK(0x1028, 0x06dd, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9580         SND_PCI_QUIRK(0x1028, 0x06de, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9581         SND_PCI_QUIRK(0x1028, 0x06df, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9582         SND_PCI_QUIRK(0x1028, 0x06e0, "Dell", ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK),
9583         SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9584         SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
9585         SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
9586         SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
9587         SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
9588         SND_PCI_QUIRK(0x1028, 0x0798, "Dell Inspiron 17 7000 Gaming", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
9589         SND_PCI_QUIRK(0x1028, 0x07b0, "Dell Precision 7520", ALC295_FIXUP_DISABLE_DAC3),
9590         SND_PCI_QUIRK(0x1028, 0x080c, "Dell WYSE", ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE),
9591         SND_PCI_QUIRK(0x1028, 0x084b, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9592         SND_PCI_QUIRK(0x1028, 0x084e, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9593         SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9594         SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
9595         SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
9596         SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
9597         SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
9598         SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
9599         SND_PCI_QUIRK(0x1028, 0x097d, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9600         SND_PCI_QUIRK(0x1028, 0x097e, "Dell Precision", ALC289_FIXUP_DUAL_SPK),
9601         SND_PCI_QUIRK(0x1028, 0x098d, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9602         SND_PCI_QUIRK(0x1028, 0x09bf, "Dell Precision", ALC233_FIXUP_ASUS_MIC_NO_PRESENCE),
9603         SND_PCI_QUIRK(0x1028, 0x0a2e, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9604         SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC),
9605         SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET),
9606         SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC),
9607         SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK),
9608         SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK),
9609         SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9610         SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9611         SND_PCI_QUIRK(0x1028, 0x0b19, "Dell XPS 15 9520", ALC289_FIXUP_DUAL_SPK),
9612         SND_PCI_QUIRK(0x1028, 0x0b1a, "Dell Precision 5570", ALC289_FIXUP_DUAL_SPK),
9613         SND_PCI_QUIRK(0x1028, 0x0b37, "Dell Inspiron 16 Plus 7620 2-in-1", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9614         SND_PCI_QUIRK(0x1028, 0x0b71, "Dell Inspiron 16 Plus 7620", ALC295_FIXUP_DELL_INSPIRON_TOP_SPEAKERS),
9615         SND_PCI_QUIRK(0x1028, 0x0c03, "Dell Precision 5340", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE),
9616         SND_PCI_QUIRK(0x1028, 0x0c19, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9617         SND_PCI_QUIRK(0x1028, 0x0c1a, "Dell Precision 3340", ALC236_FIXUP_DELL_DUAL_CODECS),
9618         SND_PCI_QUIRK(0x1028, 0x0c1b, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9619         SND_PCI_QUIRK(0x1028, 0x0c1c, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9620         SND_PCI_QUIRK(0x1028, 0x0c1d, "Dell Precision 3440", ALC236_FIXUP_DELL_DUAL_CODECS),
9621         SND_PCI_QUIRK(0x1028, 0x0c1e, "Dell Precision 3540", ALC236_FIXUP_DELL_DUAL_CODECS),
9622         SND_PCI_QUIRK(0x1028, 0x0cbd, "Dell Oasis 13 CS MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9623         SND_PCI_QUIRK(0x1028, 0x0cbe, "Dell Oasis 13 2-IN-1 MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9624         SND_PCI_QUIRK(0x1028, 0x0cbf, "Dell Oasis 13 Low Weight MTU-L", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9625         SND_PCI_QUIRK(0x1028, 0x0cc0, "Dell Oasis 13", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9626         SND_PCI_QUIRK(0x1028, 0x0cc1, "Dell Oasis 14 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9627         SND_PCI_QUIRK(0x1028, 0x0cc2, "Dell Oasis 14 2-in-1 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9628         SND_PCI_QUIRK(0x1028, 0x0cc3, "Dell Oasis 14 Low Weight MTL-U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9629         SND_PCI_QUIRK(0x1028, 0x0cc4, "Dell Oasis 16 MTL-H/U", ALC289_FIXUP_DELL_CS35L41_SPI_2),
9630         SND_PCI_QUIRK(0x1028, 0x0cc5, "Dell Oasis 14", ALC289_FIXUP_RTK_AMP_DUAL_SPK),
9631         SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9632         SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
9633         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
9634         SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
9635         SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
9636         SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9637         SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9638         SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9639         SND_PCI_QUIRK(0x103c, 0x221b, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9640         SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
9641         SND_PCI_QUIRK(0x103c, 0x2221, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9642         SND_PCI_QUIRK(0x103c, 0x2225, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9643         SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9644         SND_PCI_QUIRK(0x103c, 0x2237, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9645         SND_PCI_QUIRK(0x103c, 0x2238, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9646         SND_PCI_QUIRK(0x103c, 0x2239, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9647         SND_PCI_QUIRK(0x103c, 0x224b, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
9648         SND_PCI_QUIRK(0x103c, 0x2253, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9649         SND_PCI_QUIRK(0x103c, 0x2254, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9650         SND_PCI_QUIRK(0x103c, 0x2255, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9651         SND_PCI_QUIRK(0x103c, 0x2256, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9652         SND_PCI_QUIRK(0x103c, 0x2257, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9653         SND_PCI_QUIRK(0x103c, 0x2259, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9654         SND_PCI_QUIRK(0x103c, 0x225a, "HP", ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED),
9655         SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
9656         SND_PCI_QUIRK(0x103c, 0x2260, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9657         SND_PCI_QUIRK(0x103c, 0x2263, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9658         SND_PCI_QUIRK(0x103c, 0x2264, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9659         SND_PCI_QUIRK(0x103c, 0x2265, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9660         SND_PCI_QUIRK(0x103c, 0x2268, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9661         SND_PCI_QUIRK(0x103c, 0x226a, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9662         SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9663         SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9664         SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
9665         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9666         SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9667         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9668         SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
9669         SND_PCI_QUIRK(0x103c, 0x2278, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9670         SND_PCI_QUIRK(0x103c, 0x227f, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9671         SND_PCI_QUIRK(0x103c, 0x2282, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9672         SND_PCI_QUIRK(0x103c, 0x228b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9673         SND_PCI_QUIRK(0x103c, 0x228e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9674         SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9675         SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9676         SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9677         SND_PCI_QUIRK(0x103c, 0x22bf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9678         SND_PCI_QUIRK(0x103c, 0x22c4, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9679         SND_PCI_QUIRK(0x103c, 0x22c5, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9680         SND_PCI_QUIRK(0x103c, 0x22c7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9681         SND_PCI_QUIRK(0x103c, 0x22c8, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9682         SND_PCI_QUIRK(0x103c, 0x22cf, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9683         SND_PCI_QUIRK(0x103c, 0x22db, "HP", ALC280_FIXUP_HP_9480M),
9684         SND_PCI_QUIRK(0x103c, 0x22dc, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9685         SND_PCI_QUIRK(0x103c, 0x22fb, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED),
9686         SND_PCI_QUIRK(0x103c, 0x2334, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9687         SND_PCI_QUIRK(0x103c, 0x2335, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9688         SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9689         SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
9690         SND_PCI_QUIRK(0x103c, 0x2b5e, "HP 288 Pro G2 MT", ALC221_FIXUP_HP_288PRO_MIC_NO_PRESENCE),
9691         SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9692         SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9693         SND_PCI_QUIRK(0x103c, 0x8077, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9694         SND_PCI_QUIRK(0x103c, 0x8158, "HP", ALC256_FIXUP_HP_HEADSET_MIC),
9695         SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC295_FIXUP_HP_X360),
9696         SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
9697         SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
9698         SND_PCI_QUIRK(0x103c, 0x827f, "HP x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9699         SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9700         SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
9701         SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9702         SND_PCI_QUIRK(0x103c, 0x841c, "HP Pavilion 15-CK0xx", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9703         SND_PCI_QUIRK(0x103c, 0x8497, "HP Envy x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9704         SND_PCI_QUIRK(0x103c, 0x84da, "HP OMEN dc0019-ur", ALC295_FIXUP_HP_OMEN),
9705         SND_PCI_QUIRK(0x103c, 0x84e7, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
9706         SND_PCI_QUIRK(0x103c, 0x8519, "HP Spectre x360 15-df0xxx", ALC285_FIXUP_HP_SPECTRE_X360),
9707         SND_PCI_QUIRK(0x103c, 0x860f, "HP ZBook 15 G6", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9708         SND_PCI_QUIRK(0x103c, 0x861f, "HP Elite Dragonfly G1", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9709         SND_PCI_QUIRK(0x103c, 0x869d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9710         SND_PCI_QUIRK(0x103c, 0x86c7, "HP Envy AiO 32", ALC274_FIXUP_HP_ENVY_GPIO),
9711         SND_PCI_QUIRK(0x103c, 0x86e7, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9712         SND_PCI_QUIRK(0x103c, 0x86e8, "HP Spectre x360 15-eb0xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9713         SND_PCI_QUIRK(0x103c, 0x86f9, "HP Spectre x360 13-aw0xxx", ALC285_FIXUP_HP_SPECTRE_X360_MUTE_LED),
9714         SND_PCI_QUIRK(0x103c, 0x8716, "HP Elite Dragonfly G2 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9715         SND_PCI_QUIRK(0x103c, 0x8720, "HP EliteBook x360 1040 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9716         SND_PCI_QUIRK(0x103c, 0x8724, "HP EliteBook 850 G7", ALC285_FIXUP_HP_GPIO_LED),
9717         SND_PCI_QUIRK(0x103c, 0x8728, "HP EliteBook 840 G7", ALC285_FIXUP_HP_GPIO_LED),
9718         SND_PCI_QUIRK(0x103c, 0x8729, "HP", ALC285_FIXUP_HP_GPIO_LED),
9719         SND_PCI_QUIRK(0x103c, 0x8730, "HP ProBook 445 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9720         SND_PCI_QUIRK(0x103c, 0x8735, "HP ProBook 435 G7", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9721         SND_PCI_QUIRK(0x103c, 0x8736, "HP", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9722         SND_PCI_QUIRK(0x103c, 0x8760, "HP", ALC285_FIXUP_HP_MUTE_LED),
9723         SND_PCI_QUIRK(0x103c, 0x877a, "HP", ALC285_FIXUP_HP_MUTE_LED),
9724         SND_PCI_QUIRK(0x103c, 0x877d, "HP", ALC236_FIXUP_HP_MUTE_LED),
9725         SND_PCI_QUIRK(0x103c, 0x8780, "HP ZBook Fury 17 G7 Mobile Workstation",
9726                       ALC285_FIXUP_HP_GPIO_AMP_INIT),
9727         SND_PCI_QUIRK(0x103c, 0x8783, "HP ZBook Fury 15 G7 Mobile Workstation",
9728                       ALC285_FIXUP_HP_GPIO_AMP_INIT),
9729         SND_PCI_QUIRK(0x103c, 0x8786, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9730         SND_PCI_QUIRK(0x103c, 0x8787, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9731         SND_PCI_QUIRK(0x103c, 0x8788, "HP OMEN 15", ALC285_FIXUP_HP_MUTE_LED),
9732         SND_PCI_QUIRK(0x103c, 0x87c8, "HP", ALC287_FIXUP_HP_GPIO_LED),
9733         SND_PCI_QUIRK(0x103c, 0x87e5, "HP ProBook 440 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9734         SND_PCI_QUIRK(0x103c, 0x87e7, "HP ProBook 450 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9735         SND_PCI_QUIRK(0x103c, 0x87f1, "HP ProBook 630 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9736         SND_PCI_QUIRK(0x103c, 0x87f2, "HP ProBook 640 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9737         SND_PCI_QUIRK(0x103c, 0x87f4, "HP", ALC287_FIXUP_HP_GPIO_LED),
9738         SND_PCI_QUIRK(0x103c, 0x87f5, "HP", ALC287_FIXUP_HP_GPIO_LED),
9739         SND_PCI_QUIRK(0x103c, 0x87f6, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9740         SND_PCI_QUIRK(0x103c, 0x87f7, "HP Spectre x360 14", ALC245_FIXUP_HP_X360_AMP),
9741         SND_PCI_QUIRK(0x103c, 0x8805, "HP ProBook 650 G8 Notebook PC", ALC236_FIXUP_HP_GPIO_LED),
9742         SND_PCI_QUIRK(0x103c, 0x880d, "HP EliteBook 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9743         SND_PCI_QUIRK(0x103c, 0x8811, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9744         SND_PCI_QUIRK(0x103c, 0x8812, "HP Spectre x360 15-eb1xxx", ALC285_FIXUP_HP_SPECTRE_X360_EB1),
9745         SND_PCI_QUIRK(0x103c, 0x881d, "HP 250 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9746         SND_PCI_QUIRK(0x103c, 0x8846, "HP EliteBook 850 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9747         SND_PCI_QUIRK(0x103c, 0x8847, "HP EliteBook x360 830 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9748         SND_PCI_QUIRK(0x103c, 0x884b, "HP EliteBook 840 Aero G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9749         SND_PCI_QUIRK(0x103c, 0x884c, "HP EliteBook 840 G8 Notebook PC", ALC285_FIXUP_HP_GPIO_LED),
9750         SND_PCI_QUIRK(0x103c, 0x8862, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9751         SND_PCI_QUIRK(0x103c, 0x8863, "HP ProBook 445 G8 Notebook PC", ALC236_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9752         SND_PCI_QUIRK(0x103c, 0x886d, "HP ZBook Fury 17.3 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9753         SND_PCI_QUIRK(0x103c, 0x8870, "HP ZBook Fury 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9754         SND_PCI_QUIRK(0x103c, 0x8873, "HP ZBook Studio 15.6 Inch G8 Mobile Workstation PC", ALC285_FIXUP_HP_GPIO_AMP_INIT),
9755         SND_PCI_QUIRK(0x103c, 0x887a, "HP Laptop 15s-eq2xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9756         SND_PCI_QUIRK(0x103c, 0x888a, "HP ENVY x360 Convertible 15-eu0xxx", ALC245_FIXUP_HP_X360_MUTE_LEDS),
9757         SND_PCI_QUIRK(0x103c, 0x888d, "HP ZBook Power 15.6 inch G8 Mobile Workstation PC", ALC236_FIXUP_HP_GPIO_LED),
9758         SND_PCI_QUIRK(0x103c, 0x8895, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED),
9759         SND_PCI_QUIRK(0x103c, 0x8896, "HP EliteBook 855 G8 Notebook PC", ALC285_FIXUP_HP_MUTE_LED),
9760         SND_PCI_QUIRK(0x103c, 0x8898, "HP EliteBook 845 G8 Notebook PC", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9761         SND_PCI_QUIRK(0x103c, 0x88d0, "HP Pavilion 15-eh1xxx (mainboard 88D0)", ALC287_FIXUP_HP_GPIO_LED),
9762         SND_PCI_QUIRK(0x103c, 0x8902, "HP OMEN 16", ALC285_FIXUP_HP_MUTE_LED),
9763         SND_PCI_QUIRK(0x103c, 0x890e, "HP 255 G8 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9764         SND_PCI_QUIRK(0x103c, 0x8919, "HP Pavilion Aero Laptop 13-be0xxx", ALC287_FIXUP_HP_GPIO_LED),
9765         SND_PCI_QUIRK(0x103c, 0x896d, "HP ZBook Firefly 16 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9766         SND_PCI_QUIRK(0x103c, 0x896e, "HP EliteBook x360 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9767         SND_PCI_QUIRK(0x103c, 0x8971, "HP EliteBook 830 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9768         SND_PCI_QUIRK(0x103c, 0x8972, "HP EliteBook 840 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9769         SND_PCI_QUIRK(0x103c, 0x8973, "HP EliteBook 860 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9770         SND_PCI_QUIRK(0x103c, 0x8974, "HP EliteBook 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9771         SND_PCI_QUIRK(0x103c, 0x8975, "HP EliteBook x360 840 Aero G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9772         SND_PCI_QUIRK(0x103c, 0x8981, "HP Elite Dragonfly G3", ALC245_FIXUP_CS35L41_SPI_4),
9773         SND_PCI_QUIRK(0x103c, 0x898e, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
9774         SND_PCI_QUIRK(0x103c, 0x898f, "HP EliteBook 835 G9", ALC287_FIXUP_CS35L41_I2C_2),
9775         SND_PCI_QUIRK(0x103c, 0x8991, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9776         SND_PCI_QUIRK(0x103c, 0x8992, "HP EliteBook 845 G9", ALC287_FIXUP_CS35L41_I2C_2),
9777         SND_PCI_QUIRK(0x103c, 0x8994, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9778         SND_PCI_QUIRK(0x103c, 0x8995, "HP EliteBook 855 G9", ALC287_FIXUP_CS35L41_I2C_2),
9779         SND_PCI_QUIRK(0x103c, 0x89a4, "HP ProBook 440 G9", ALC236_FIXUP_HP_GPIO_LED),
9780         SND_PCI_QUIRK(0x103c, 0x89a6, "HP ProBook 450 G9", ALC236_FIXUP_HP_GPIO_LED),
9781         SND_PCI_QUIRK(0x103c, 0x89aa, "HP EliteBook 630 G9", ALC236_FIXUP_HP_GPIO_LED),
9782         SND_PCI_QUIRK(0x103c, 0x89ac, "HP EliteBook 640 G9", ALC236_FIXUP_HP_GPIO_LED),
9783         SND_PCI_QUIRK(0x103c, 0x89ae, "HP EliteBook 650 G9", ALC236_FIXUP_HP_GPIO_LED),
9784         SND_PCI_QUIRK(0x103c, 0x89c0, "HP ZBook Power 15.6 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9785         SND_PCI_QUIRK(0x103c, 0x89c3, "Zbook Studio G9", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9786         SND_PCI_QUIRK(0x103c, 0x89c6, "Zbook Fury 17 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9787         SND_PCI_QUIRK(0x103c, 0x89ca, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9788         SND_PCI_QUIRK(0x103c, 0x89d3, "HP EliteBook 645 G9 (MB 89D2)", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9789         SND_PCI_QUIRK(0x103c, 0x8a20, "HP Laptop 15s-fq5xxx", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9790         SND_PCI_QUIRK(0x103c, 0x8a25, "HP Victus 16-d1xxx (MB 8A25)", ALC245_FIXUP_HP_MUTE_LED_COEFBIT),
9791         SND_PCI_QUIRK(0x103c, 0x8a78, "HP Dev One", ALC285_FIXUP_HP_LIMIT_INT_MIC_BOOST),
9792         SND_PCI_QUIRK(0x103c, 0x8aa0, "HP ProBook 440 G9 (MB 8A9E)", ALC236_FIXUP_HP_GPIO_LED),
9793         SND_PCI_QUIRK(0x103c, 0x8aa3, "HP ProBook 450 G9 (MB 8AA1)", ALC236_FIXUP_HP_GPIO_LED),
9794         SND_PCI_QUIRK(0x103c, 0x8aa8, "HP EliteBook 640 G9 (MB 8AA6)", ALC236_FIXUP_HP_GPIO_LED),
9795         SND_PCI_QUIRK(0x103c, 0x8aab, "HP EliteBook 650 G9 (MB 8AA9)", ALC236_FIXUP_HP_GPIO_LED),
9796         SND_PCI_QUIRK(0x103c, 0x8abb, "HP ZBook Firefly 14 G9", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9797         SND_PCI_QUIRK(0x103c, 0x8ad1, "HP EliteBook 840 14 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9798         SND_PCI_QUIRK(0x103c, 0x8ad2, "HP EliteBook 860 16 inch G9 Notebook PC", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9799         SND_PCI_QUIRK(0x103c, 0x8b2f, "HP 255 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_COEFBIT2),
9800         SND_PCI_QUIRK(0x103c, 0x8b42, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9801         SND_PCI_QUIRK(0x103c, 0x8b43, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9802         SND_PCI_QUIRK(0x103c, 0x8b44, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9803         SND_PCI_QUIRK(0x103c, 0x8b45, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9804         SND_PCI_QUIRK(0x103c, 0x8b46, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9805         SND_PCI_QUIRK(0x103c, 0x8b47, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9806         SND_PCI_QUIRK(0x103c, 0x8b5d, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9807         SND_PCI_QUIRK(0x103c, 0x8b5e, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9808         SND_PCI_QUIRK(0x103c, 0x8b63, "HP Elite Dragonfly 13.5 inch G4", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9809         SND_PCI_QUIRK(0x103c, 0x8b65, "HP ProBook 455 15.6 inch G10 Notebook PC", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9810         SND_PCI_QUIRK(0x103c, 0x8b66, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9811         SND_PCI_QUIRK(0x103c, 0x8b70, "HP EliteBook 835 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9812         SND_PCI_QUIRK(0x103c, 0x8b72, "HP EliteBook 845 G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9813         SND_PCI_QUIRK(0x103c, 0x8b74, "HP EliteBook 845W G10", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9814         SND_PCI_QUIRK(0x103c, 0x8b77, "HP ElieBook 865 G10", ALC287_FIXUP_CS35L41_I2C_2),
9815         SND_PCI_QUIRK(0x103c, 0x8b7a, "HP", ALC236_FIXUP_HP_GPIO_LED),
9816         SND_PCI_QUIRK(0x103c, 0x8b7d, "HP", ALC236_FIXUP_HP_GPIO_LED),
9817         SND_PCI_QUIRK(0x103c, 0x8b87, "HP", ALC236_FIXUP_HP_GPIO_LED),
9818         SND_PCI_QUIRK(0x103c, 0x8b8a, "HP", ALC236_FIXUP_HP_GPIO_LED),
9819         SND_PCI_QUIRK(0x103c, 0x8b8b, "HP", ALC236_FIXUP_HP_GPIO_LED),
9820         SND_PCI_QUIRK(0x103c, 0x8b8d, "HP", ALC236_FIXUP_HP_GPIO_LED),
9821         SND_PCI_QUIRK(0x103c, 0x8b8f, "HP", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9822         SND_PCI_QUIRK(0x103c, 0x8b92, "HP", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9823         SND_PCI_QUIRK(0x103c, 0x8b96, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9824         SND_PCI_QUIRK(0x103c, 0x8b97, "HP", ALC236_FIXUP_HP_MUTE_LED_MICMUTE_VREF),
9825         SND_PCI_QUIRK(0x103c, 0x8bf0, "HP", ALC236_FIXUP_HP_GPIO_LED),
9826         SND_PCI_QUIRK(0x103c, 0x8c46, "HP EliteBook 830 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9827         SND_PCI_QUIRK(0x103c, 0x8c47, "HP EliteBook 840 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9828         SND_PCI_QUIRK(0x103c, 0x8c48, "HP EliteBook 860 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9829         SND_PCI_QUIRK(0x103c, 0x8c49, "HP Elite x360 830 2-in-1 G11", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9830         SND_PCI_QUIRK(0x103c, 0x8c70, "HP EliteBook 835 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9831         SND_PCI_QUIRK(0x103c, 0x8c71, "HP EliteBook 845 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9832         SND_PCI_QUIRK(0x103c, 0x8c72, "HP EliteBook 865 G11", ALC287_FIXUP_CS35L41_I2C_2_HP_GPIO_LED),
9833         SND_PCI_QUIRK(0x103c, 0x8ca4, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9834         SND_PCI_QUIRK(0x103c, 0x8ca7, "HP ZBook Fury", ALC245_FIXUP_CS35L41_SPI_2_HP_GPIO_LED),
9835         SND_PCI_QUIRK(0x103c, 0x8cf5, "HP ZBook Studio 16", ALC245_FIXUP_CS35L41_SPI_4_HP_GPIO_LED),
9836         SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
9837         SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
9838         SND_PCI_QUIRK(0x1043, 0x106d, "Asus K53BE", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9839         SND_PCI_QUIRK(0x1043, 0x10a1, "ASUS UX391UA", ALC294_FIXUP_ASUS_SPK),
9840         SND_PCI_QUIRK(0x1043, 0x10c0, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
9841         SND_PCI_QUIRK(0x1043, 0x10d0, "ASUS X540LA/X540LJ", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9842         SND_PCI_QUIRK(0x1043, 0x10d3, "ASUS K6500ZC", ALC294_FIXUP_ASUS_SPK),
9843         SND_PCI_QUIRK(0x1043, 0x115d, "Asus 1015E", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9844         SND_PCI_QUIRK(0x1043, 0x11c0, "ASUS X556UR", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9845         SND_PCI_QUIRK(0x1043, 0x125e, "ASUS Q524UQK", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9846         SND_PCI_QUIRK(0x1043, 0x1271, "ASUS X430UN", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
9847         SND_PCI_QUIRK(0x1043, 0x1290, "ASUS X441SA", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
9848         SND_PCI_QUIRK(0x1043, 0x12a0, "ASUS X441UV", ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE),
9849         SND_PCI_QUIRK(0x1043, 0x12a3, "Asus N7691ZM", ALC269_FIXUP_ASUS_N7601ZM),
9850         SND_PCI_QUIRK(0x1043, 0x12af, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
9851         SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
9852         SND_PCI_QUIRK(0x1043, 0x12f0, "ASUS X541UV", ALC256_FIXUP_ASUS_MIC),
9853         SND_PCI_QUIRK(0x1043, 0x1313, "Asus K42JZ", ALC269VB_FIXUP_ASUS_MIC_NO_PRESENCE),
9854         SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
9855         SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
9856         SND_PCI_QUIRK(0x1043, 0x1433, "ASUS GX650P", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
9857         SND_PCI_QUIRK(0x1043, 0x1463, "Asus GA402X", ALC285_FIXUP_ASUS_I2C_HEADSET_MIC),
9858         SND_PCI_QUIRK(0x1043, 0x1473, "ASUS GU604V", ALC285_FIXUP_ASUS_HEADSET_MIC),
9859         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS GU603V", ALC285_FIXUP_ASUS_HEADSET_MIC),
9860         SND_PCI_QUIRK(0x1043, 0x1493, "ASUS GV601V", ALC285_FIXUP_ASUS_HEADSET_MIC),
9861         SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
9862         SND_PCI_QUIRK(0x1043, 0x1573, "ASUS GZ301V", ALC285_FIXUP_ASUS_HEADSET_MIC),
9863         SND_PCI_QUIRK(0x1043, 0x1662, "ASUS GV301QH", ALC294_FIXUP_ASUS_DUAL_SPK),
9864         SND_PCI_QUIRK(0x1043, 0x1663, "ASUS GU603ZV", ALC285_FIXUP_ASUS_HEADSET_MIC),
9865         SND_PCI_QUIRK(0x1043, 0x1683, "ASUS UM3402YAR", ALC287_FIXUP_CS35L41_I2C_2),
9866         SND_PCI_QUIRK(0x1043, 0x16b2, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
9867         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
9868         SND_PCI_QUIRK(0x1043, 0x1740, "ASUS UX430UA", ALC295_FIXUP_ASUS_DACS),
9869         SND_PCI_QUIRK(0x1043, 0x17d1, "ASUS UX431FL", ALC294_FIXUP_ASUS_DUAL_SPK),
9870         SND_PCI_QUIRK(0x1043, 0x17f3, "ROG Ally RC71L_RC71L", ALC294_FIXUP_ASUS_ALLY),
9871         SND_PCI_QUIRK(0x1043, 0x1881, "ASUS Zephyrus S/M", ALC294_FIXUP_ASUS_GX502_PINS),
9872         SND_PCI_QUIRK(0x1043, 0x18b1, "Asus MJ401TA", ALC256_FIXUP_ASUS_HEADSET_MIC),
9873         SND_PCI_QUIRK(0x1043, 0x18f1, "Asus FX505DT", ALC256_FIXUP_ASUS_HEADSET_MIC),
9874         SND_PCI_QUIRK(0x1043, 0x194e, "ASUS UX563FD", ALC294_FIXUP_ASUS_HPE),
9875         SND_PCI_QUIRK(0x1043, 0x1970, "ASUS UX550VE", ALC289_FIXUP_ASUS_GA401),
9876         SND_PCI_QUIRK(0x1043, 0x1982, "ASUS B1400CEPE", ALC256_FIXUP_ASUS_HPE),
9877         SND_PCI_QUIRK(0x1043, 0x19ce, "ASUS B9450FA", ALC294_FIXUP_ASUS_HPE),
9878         SND_PCI_QUIRK(0x1043, 0x19e1, "ASUS UX581LV", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE),
9879         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
9880         SND_PCI_QUIRK(0x1043, 0x1a30, "ASUS X705UD", ALC256_FIXUP_ASUS_MIC),
9881         SND_PCI_QUIRK(0x1043, 0x1a63, "ASUS UX3405MA", ALC245_FIXUP_CS35L41_SPI_2),
9882         SND_PCI_QUIRK(0x1043, 0x1a83, "ASUS UM5302LA", ALC294_FIXUP_CS35L41_I2C_2),
9883         SND_PCI_QUIRK(0x1043, 0x1a8f, "ASUS UX582ZS", ALC245_FIXUP_CS35L41_SPI_2),
9884         SND_PCI_QUIRK(0x1043, 0x1b11, "ASUS UX431DA", ALC294_FIXUP_ASUS_COEF_1B),
9885         SND_PCI_QUIRK(0x1043, 0x1b13, "Asus U41SV", ALC269_FIXUP_INV_DMIC),
9886         SND_PCI_QUIRK(0x1043, 0x1b93, "ASUS G614JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
9887         SND_PCI_QUIRK(0x1043, 0x1bbd, "ASUS Z550MA", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE),
9888         SND_PCI_QUIRK(0x1043, 0x1c03, "ASUS UM3406HA", ALC287_FIXUP_CS35L41_I2C_2),
9889         SND_PCI_QUIRK(0x1043, 0x1c23, "Asus X55U", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
9890         SND_PCI_QUIRK(0x1043, 0x1c33, "ASUS UX5304MA", ALC245_FIXUP_CS35L41_SPI_2),
9891         SND_PCI_QUIRK(0x1043, 0x1c43, "ASUS UX8406MA", ALC245_FIXUP_CS35L41_SPI_2),
9892         SND_PCI_QUIRK(0x1043, 0x1c62, "ASUS GU603", ALC289_FIXUP_ASUS_GA401),
9893         SND_PCI_QUIRK(0x1043, 0x1c92, "ASUS ROG Strix G15", ALC285_FIXUP_ASUS_G533Z_PINS),
9894         SND_PCI_QUIRK(0x1043, 0x1c9f, "ASUS G614JI", ALC285_FIXUP_ASUS_HEADSET_MIC),
9895         SND_PCI_QUIRK(0x1043, 0x1caf, "ASUS G634JYR/JZR", ALC285_FIXUP_ASUS_SPI_REAR_SPEAKERS),
9896         SND_PCI_QUIRK(0x1043, 0x1ccd, "ASUS X555UB", ALC256_FIXUP_ASUS_MIC),
9897         SND_PCI_QUIRK(0x1043, 0x1d1f, "ASUS ROG Strix G17 2023 (G713PV)", ALC287_FIXUP_CS35L41_I2C_2),
9898         SND_PCI_QUIRK(0x1043, 0x1d42, "ASUS Zephyrus G14 2022", ALC289_FIXUP_ASUS_GA401),
9899         SND_PCI_QUIRK(0x1043, 0x1d4e, "ASUS TM420", ALC256_FIXUP_ASUS_HPE),
9900         SND_PCI_QUIRK(0x1043, 0x1e02, "ASUS UX3402ZA", ALC245_FIXUP_CS35L41_SPI_2),
9901         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS UX3402VA", ALC245_FIXUP_CS35L41_SPI_2),
9902         SND_PCI_QUIRK(0x1043, 0x1f62, "ASUS UX7602ZM", ALC245_FIXUP_CS35L41_SPI_2),
9903         SND_PCI_QUIRK(0x1043, 0x1e11, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA502),
9904         SND_PCI_QUIRK(0x1043, 0x1e12, "ASUS UM3402", ALC287_FIXUP_CS35L41_I2C_2),
9905         SND_PCI_QUIRK(0x1043, 0x1e51, "ASUS Zephyrus M15", ALC294_FIXUP_ASUS_GU502_PINS),
9906         SND_PCI_QUIRK(0x1043, 0x1e5e, "ASUS ROG Strix G513", ALC294_FIXUP_ASUS_G513_PINS),
9907         SND_PCI_QUIRK(0x1043, 0x1e8e, "ASUS Zephyrus G15", ALC289_FIXUP_ASUS_GA401),
9908         SND_PCI_QUIRK(0x1043, 0x1c52, "ASUS Zephyrus G15 2022", ALC289_FIXUP_ASUS_GA401),
9909         SND_PCI_QUIRK(0x1043, 0x1f11, "ASUS Zephyrus G14", ALC289_FIXUP_ASUS_GA401),
9910         SND_PCI_QUIRK(0x1043, 0x1f12, "ASUS UM5302", ALC287_FIXUP_CS35L41_I2C_2),
9911         SND_PCI_QUIRK(0x1043, 0x1f92, "ASUS ROG Flow X16", ALC289_FIXUP_ASUS_GA401),
9912         SND_PCI_QUIRK(0x1043, 0x3030, "ASUS ZN270IE", ALC256_FIXUP_ASUS_AIO_GPIO2),
9913         SND_PCI_QUIRK(0x1043, 0x3a20, "ASUS G614JZR", ALC245_FIXUP_CS35L41_SPI_2),
9914         SND_PCI_QUIRK(0x1043, 0x3a30, "ASUS G814JVR/JIR", ALC245_FIXUP_CS35L41_SPI_2),
9915         SND_PCI_QUIRK(0x1043, 0x3a40, "ASUS G814JZR", ALC245_FIXUP_CS35L41_SPI_2),
9916         SND_PCI_QUIRK(0x1043, 0x3a50, "ASUS G834JYR/JZR", ALC245_FIXUP_CS35L41_SPI_2),
9917         SND_PCI_QUIRK(0x1043, 0x3a60, "ASUS G634JYR/JZR", ALC245_FIXUP_CS35L41_SPI_2),
9918         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS P901", ALC269_FIXUP_STEREO_DMIC),
9919         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS S101", ALC269_FIXUP_STEREO_DMIC),
9920         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
9921         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005", ALC269_FIXUP_STEREO_DMIC),
9922         SND_PCI_QUIRK(0x1043, 0x8516, "ASUS X101CH", ALC269_FIXUP_ASUS_X101),
9923         SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
9924         SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
9925         SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
9926         SND_PCI_QUIRK(0x104d, 0x9099, "Sony VAIO S13", ALC275_FIXUP_SONY_DISABLE_AAMIX),
9927         SND_PCI_QUIRK(0x104d, 0x90b5, "Sony VAIO Pro 11", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
9928         SND_PCI_QUIRK(0x104d, 0x90b6, "Sony VAIO Pro 13", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
9929         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook", ALC269_FIXUP_LIFEBOOK),
9930         SND_PCI_QUIRK(0x10cf, 0x159f, "Lifebook E780", ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT),
9931         SND_PCI_QUIRK(0x10cf, 0x15dc, "Lifebook T731", ALC269_FIXUP_LIFEBOOK_HP_PIN),
9932         SND_PCI_QUIRK(0x10cf, 0x1629, "Lifebook U7x7", ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC),
9933         SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN),
9934         SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC),
9935         SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE),
9936         SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE),
9937         SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
9938         SND_PCI_QUIRK(0x10ec, 0x124c, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
9939         SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
9940         SND_PCI_QUIRK(0x10ec, 0x1254, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
9941         SND_PCI_QUIRK(0x10ec, 0x12cc, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK),
9942         SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-SZ6", ALC269_FIXUP_HEADSET_MODE),
9943         SND_PCI_QUIRK(0x144d, 0xc109, "Samsung Ativ book 9 (NP900X3G)", ALC269_FIXUP_INV_DMIC),
9944         SND_PCI_QUIRK(0x144d, 0xc169, "Samsung Notebook 9 Pen (NP930SBE-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
9945         SND_PCI_QUIRK(0x144d, 0xc176, "Samsung Notebook 9 Pro (NP930MBE-K04US)", ALC298_FIXUP_SAMSUNG_AMP),
9946         SND_PCI_QUIRK(0x144d, 0xc189, "Samsung Galaxy Flex Book (NT950QCG-X716)", ALC298_FIXUP_SAMSUNG_AMP),
9947         SND_PCI_QUIRK(0x144d, 0xc18a, "Samsung Galaxy Book Ion (NP930XCJ-K01US)", ALC298_FIXUP_SAMSUNG_AMP),
9948         SND_PCI_QUIRK(0x144d, 0xc1a3, "Samsung Galaxy Book Pro (NP935XDB-KC1SE)", ALC298_FIXUP_SAMSUNG_AMP),
9949         SND_PCI_QUIRK(0x144d, 0xc1a6, "Samsung Galaxy Book Pro 360 (NP930QBD)", ALC298_FIXUP_SAMSUNG_AMP),
9950         SND_PCI_QUIRK(0x144d, 0xc740, "Samsung Ativ book 8 (NP870Z5G)", ALC269_FIXUP_ATIV_BOOK_8),
9951         SND_PCI_QUIRK(0x144d, 0xc812, "Samsung Notebook Pen S (NT950SBE-X58)", ALC298_FIXUP_SAMSUNG_AMP),
9952         SND_PCI_QUIRK(0x144d, 0xc830, "Samsung Galaxy Book Ion (NT950XCJ-X716A)", ALC298_FIXUP_SAMSUNG_AMP),
9953         SND_PCI_QUIRK(0x144d, 0xc832, "Samsung Galaxy Book Flex Alpha (NP730QCJ)", ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET),
9954         SND_PCI_QUIRK(0x144d, 0xca03, "Samsung Galaxy Book2 Pro 360 (NP930QED)", ALC298_FIXUP_SAMSUNG_AMP),
9955         SND_PCI_QUIRK(0x144d, 0xc868, "Samsung Galaxy Book2 Pro (NP930XED)", ALC298_FIXUP_SAMSUNG_AMP),
9956         SND_PCI_QUIRK(0x1458, 0xfa53, "Gigabyte BXBT-2807", ALC283_FIXUP_HEADSET_MIC),
9957         SND_PCI_QUIRK(0x1462, 0xb120, "MSI Cubi MS-B120", ALC283_FIXUP_HEADSET_MIC),
9958         SND_PCI_QUIRK(0x1462, 0xb171, "Cubi N 8GL (MS-B171)", ALC283_FIXUP_HEADSET_MIC),
9959         SND_PCI_QUIRK(0x152d, 0x1082, "Quanta NL3", ALC269_FIXUP_LIFEBOOK),
9960         SND_PCI_QUIRK(0x1558, 0x1323, "Clevo N130ZU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9961         SND_PCI_QUIRK(0x1558, 0x1325, "Clevo N15[01][CW]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9962         SND_PCI_QUIRK(0x1558, 0x1401, "Clevo L140[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9963         SND_PCI_QUIRK(0x1558, 0x1403, "Clevo N140CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9964         SND_PCI_QUIRK(0x1558, 0x1404, "Clevo N150CU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9965         SND_PCI_QUIRK(0x1558, 0x14a1, "Clevo L141MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9966         SND_PCI_QUIRK(0x1558, 0x4018, "Clevo NV40M[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9967         SND_PCI_QUIRK(0x1558, 0x4019, "Clevo NV40MZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9968         SND_PCI_QUIRK(0x1558, 0x4020, "Clevo NV40MB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9969         SND_PCI_QUIRK(0x1558, 0x4041, "Clevo NV4[15]PZ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9970         SND_PCI_QUIRK(0x1558, 0x40a1, "Clevo NL40GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9971         SND_PCI_QUIRK(0x1558, 0x40c1, "Clevo NL40[CZ]U", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9972         SND_PCI_QUIRK(0x1558, 0x40d1, "Clevo NL41DU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9973         SND_PCI_QUIRK(0x1558, 0x5015, "Clevo NH5[58]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9974         SND_PCI_QUIRK(0x1558, 0x5017, "Clevo NH7[79]H[HJK]Q", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9975         SND_PCI_QUIRK(0x1558, 0x50a3, "Clevo NJ51GU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9976         SND_PCI_QUIRK(0x1558, 0x50b3, "Clevo NK50S[BEZ]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9977         SND_PCI_QUIRK(0x1558, 0x50b6, "Clevo NK50S5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9978         SND_PCI_QUIRK(0x1558, 0x50b8, "Clevo NK50SZ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9979         SND_PCI_QUIRK(0x1558, 0x50d5, "Clevo NP50D5", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9980         SND_PCI_QUIRK(0x1558, 0x50e1, "Clevo NH5[58]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9981         SND_PCI_QUIRK(0x1558, 0x50e2, "Clevo NH7[79]HPQ", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9982         SND_PCI_QUIRK(0x1558, 0x50f0, "Clevo NH50A[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9983         SND_PCI_QUIRK(0x1558, 0x50f2, "Clevo NH50E[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9984         SND_PCI_QUIRK(0x1558, 0x50f3, "Clevo NH58DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9985         SND_PCI_QUIRK(0x1558, 0x50f5, "Clevo NH55EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9986         SND_PCI_QUIRK(0x1558, 0x50f6, "Clevo NH55DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9987         SND_PCI_QUIRK(0x1558, 0x5101, "Clevo S510WU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9988         SND_PCI_QUIRK(0x1558, 0x5157, "Clevo W517GU1", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9989         SND_PCI_QUIRK(0x1558, 0x51a1, "Clevo NS50MU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9990         SND_PCI_QUIRK(0x1558, 0x51b1, "Clevo NS50AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9991         SND_PCI_QUIRK(0x1558, 0x51b3, "Clevo NS70AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9992         SND_PCI_QUIRK(0x1558, 0x5630, "Clevo NP50RNJS", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9993         SND_PCI_QUIRK(0x1558, 0x70a1, "Clevo NB70T[HJK]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9994         SND_PCI_QUIRK(0x1558, 0x70b3, "Clevo NK70SB", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9995         SND_PCI_QUIRK(0x1558, 0x70f2, "Clevo NH79EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9996         SND_PCI_QUIRK(0x1558, 0x70f3, "Clevo NH77DPQ", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9997         SND_PCI_QUIRK(0x1558, 0x70f4, "Clevo NH77EPY", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9998         SND_PCI_QUIRK(0x1558, 0x70f6, "Clevo NH77DPQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
9999         SND_PCI_QUIRK(0x1558, 0x7716, "Clevo NS50PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10000         SND_PCI_QUIRK(0x1558, 0x7717, "Clevo NS70PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10001         SND_PCI_QUIRK(0x1558, 0x7718, "Clevo L140PU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10002         SND_PCI_QUIRK(0x1558, 0x7724, "Clevo L140AU", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10003         SND_PCI_QUIRK(0x1558, 0x8228, "Clevo NR40BU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10004         SND_PCI_QUIRK(0x1558, 0x8520, "Clevo NH50D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10005         SND_PCI_QUIRK(0x1558, 0x8521, "Clevo NH77D[CD]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10006         SND_PCI_QUIRK(0x1558, 0x8535, "Clevo NH50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10007         SND_PCI_QUIRK(0x1558, 0x8536, "Clevo NH79D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10008         SND_PCI_QUIRK(0x1558, 0x8550, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10009         SND_PCI_QUIRK(0x1558, 0x8551, "Clevo NH[57][0-9][ER][ACDH]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10010         SND_PCI_QUIRK(0x1558, 0x8560, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10011         SND_PCI_QUIRK(0x1558, 0x8561, "Clevo NH[57][0-9][ER][ACDH]Q", ALC269_FIXUP_HEADSET_MIC),
10012         SND_PCI_QUIRK(0x1558, 0x8562, "Clevo NH[57][0-9]RZ[Q]", ALC269_FIXUP_DMIC),
10013         SND_PCI_QUIRK(0x1558, 0x8668, "Clevo NP50B[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10014         SND_PCI_QUIRK(0x1558, 0x866d, "Clevo NP5[05]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10015         SND_PCI_QUIRK(0x1558, 0x867c, "Clevo NP7[01]PNP", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10016         SND_PCI_QUIRK(0x1558, 0x867d, "Clevo NP7[01]PN[HJK]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10017         SND_PCI_QUIRK(0x1558, 0x8680, "Clevo NJ50LU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10018         SND_PCI_QUIRK(0x1558, 0x8686, "Clevo NH50[CZ]U", ALC256_FIXUP_MIC_NO_PRESENCE_AND_RESUME),
10019         SND_PCI_QUIRK(0x1558, 0x8a20, "Clevo NH55DCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10020         SND_PCI_QUIRK(0x1558, 0x8a51, "Clevo NH70RCQ-Y", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10021         SND_PCI_QUIRK(0x1558, 0x8d50, "Clevo NH55RCQ-M", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10022         SND_PCI_QUIRK(0x1558, 0x951d, "Clevo N950T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10023         SND_PCI_QUIRK(0x1558, 0x9600, "Clevo N960K[PR]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10024         SND_PCI_QUIRK(0x1558, 0x961d, "Clevo N960S[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10025         SND_PCI_QUIRK(0x1558, 0x971d, "Clevo N970T[CDF]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10026         SND_PCI_QUIRK(0x1558, 0xa500, "Clevo NL5[03]RU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10027         SND_PCI_QUIRK(0x1558, 0xa600, "Clevo NL50NU", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10028         SND_PCI_QUIRK(0x1558, 0xa650, "Clevo NP[567]0SN[CD]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10029         SND_PCI_QUIRK(0x1558, 0xa671, "Clevo NP70SN[CDE]", ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10030         SND_PCI_QUIRK(0x1558, 0xb018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10031         SND_PCI_QUIRK(0x1558, 0xb019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10032         SND_PCI_QUIRK(0x1558, 0xb022, "Clevo NH77D[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10033         SND_PCI_QUIRK(0x1558, 0xc018, "Clevo NP50D[BE]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10034         SND_PCI_QUIRK(0x1558, 0xc019, "Clevo NH77D[BE]Q", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10035         SND_PCI_QUIRK(0x1558, 0xc022, "Clevo NH77[DC][QW]", ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE),
10036         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC233_FIXUP_LENOVO_MULTI_CODECS),
10037         SND_PCI_QUIRK(0x17aa, 0x1048, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10038         SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
10039         SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
10040         SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
10041         SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
10042         SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
10043         SND_PCI_QUIRK(0x17aa, 0x21f3, "Thinkpad T430", ALC269_FIXUP_LENOVO_DOCK),
10044         SND_PCI_QUIRK(0x17aa, 0x21f6, "Thinkpad T530", ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST),
10045         SND_PCI_QUIRK(0x17aa, 0x21fa, "Thinkpad X230", ALC269_FIXUP_LENOVO_DOCK),
10046         SND_PCI_QUIRK(0x17aa, 0x21fb, "Thinkpad T430s", ALC269_FIXUP_LENOVO_DOCK),
10047         SND_PCI_QUIRK(0x17aa, 0x2203, "Thinkpad X230 Tablet", ALC269_FIXUP_LENOVO_DOCK),
10048         SND_PCI_QUIRK(0x17aa, 0x2208, "Thinkpad T431s", ALC269_FIXUP_LENOVO_DOCK),
10049         SND_PCI_QUIRK(0x17aa, 0x220c, "Thinkpad T440s", ALC292_FIXUP_TPT440),
10050         SND_PCI_QUIRK(0x17aa, 0x220e, "Thinkpad T440p", ALC292_FIXUP_TPT440_DOCK),
10051         SND_PCI_QUIRK(0x17aa, 0x2210, "Thinkpad T540p", ALC292_FIXUP_TPT440_DOCK),
10052         SND_PCI_QUIRK(0x17aa, 0x2211, "Thinkpad W541", ALC292_FIXUP_TPT440_DOCK),
10053         SND_PCI_QUIRK(0x17aa, 0x2212, "Thinkpad T440", ALC292_FIXUP_TPT440_DOCK),
10054         SND_PCI_QUIRK(0x17aa, 0x2214, "Thinkpad X240", ALC292_FIXUP_TPT440_DOCK),
10055         SND_PCI_QUIRK(0x17aa, 0x2215, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10056         SND_PCI_QUIRK(0x17aa, 0x2218, "Thinkpad X1 Carbon 2nd", ALC292_FIXUP_TPT440_DOCK),
10057         SND_PCI_QUIRK(0x17aa, 0x2223, "ThinkPad T550", ALC292_FIXUP_TPT440_DOCK),
10058         SND_PCI_QUIRK(0x17aa, 0x2226, "ThinkPad X250", ALC292_FIXUP_TPT440_DOCK),
10059         SND_PCI_QUIRK(0x17aa, 0x222d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10060         SND_PCI_QUIRK(0x17aa, 0x222e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10061         SND_PCI_QUIRK(0x17aa, 0x2231, "Thinkpad T560", ALC292_FIXUP_TPT460),
10062         SND_PCI_QUIRK(0x17aa, 0x2233, "Thinkpad", ALC292_FIXUP_TPT460),
10063         SND_PCI_QUIRK(0x17aa, 0x2245, "Thinkpad T470", ALC298_FIXUP_TPT470_DOCK),
10064         SND_PCI_QUIRK(0x17aa, 0x2246, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10065         SND_PCI_QUIRK(0x17aa, 0x2247, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10066         SND_PCI_QUIRK(0x17aa, 0x2249, "Thinkpad", ALC292_FIXUP_TPT460),
10067         SND_PCI_QUIRK(0x17aa, 0x224b, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10068         SND_PCI_QUIRK(0x17aa, 0x224c, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10069         SND_PCI_QUIRK(0x17aa, 0x224d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10070         SND_PCI_QUIRK(0x17aa, 0x225d, "Thinkpad T480", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10071         SND_PCI_QUIRK(0x17aa, 0x2292, "Thinkpad X1 Carbon 7th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10072         SND_PCI_QUIRK(0x17aa, 0x22be, "Thinkpad X1 Carbon 8th", ALC285_FIXUP_THINKPAD_HEADSET_JACK),
10073         SND_PCI_QUIRK(0x17aa, 0x22c1, "Thinkpad P1 Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10074         SND_PCI_QUIRK(0x17aa, 0x22c2, "Thinkpad X1 Extreme Gen 3", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK),
10075         SND_PCI_QUIRK(0x17aa, 0x22f1, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10076         SND_PCI_QUIRK(0x17aa, 0x22f2, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10077         SND_PCI_QUIRK(0x17aa, 0x22f3, "Thinkpad", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10078         SND_PCI_QUIRK(0x17aa, 0x2316, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10079         SND_PCI_QUIRK(0x17aa, 0x2317, "Thinkpad P1 Gen 6", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10080         SND_PCI_QUIRK(0x17aa, 0x2318, "Thinkpad Z13 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10081         SND_PCI_QUIRK(0x17aa, 0x2319, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10082         SND_PCI_QUIRK(0x17aa, 0x231a, "Thinkpad Z16 Gen2", ALC287_FIXUP_MG_RTKC_CSAMP_CS35L41_I2C_THINKPAD),
10083         SND_PCI_QUIRK(0x17aa, 0x30bb, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10084         SND_PCI_QUIRK(0x17aa, 0x30e2, "ThinkCentre AIO", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY),
10085         SND_PCI_QUIRK(0x17aa, 0x310c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10086         SND_PCI_QUIRK(0x17aa, 0x3111, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10087         SND_PCI_QUIRK(0x17aa, 0x312a, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10088         SND_PCI_QUIRK(0x17aa, 0x312f, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10089         SND_PCI_QUIRK(0x17aa, 0x313c, "ThinkCentre Station", ALC294_FIXUP_LENOVO_MIC_LOCATION),
10090         SND_PCI_QUIRK(0x17aa, 0x3151, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10091         SND_PCI_QUIRK(0x17aa, 0x3176, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10092         SND_PCI_QUIRK(0x17aa, 0x3178, "ThinkCentre Station", ALC283_FIXUP_HEADSET_MIC),
10093         SND_PCI_QUIRK(0x17aa, 0x31af, "ThinkCentre Station", ALC623_FIXUP_LENOVO_THINKSTATION_P340),
10094         SND_PCI_QUIRK(0x17aa, 0x3801, "Lenovo Yoga9 14IAP7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10095         SND_PCI_QUIRK(0x17aa, 0x3802, "Lenovo Yoga DuetITL 2021", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10096         SND_PCI_QUIRK(0x17aa, 0x3813, "Legion 7i 15IMHG05", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10097         SND_PCI_QUIRK(0x17aa, 0x3818, "Lenovo C940 / Yoga Duet 7", ALC298_FIXUP_LENOVO_C940_DUET7),
10098         SND_PCI_QUIRK(0x17aa, 0x3819, "Lenovo 13s Gen2 ITL", ALC287_FIXUP_13S_GEN2_SPEAKERS),
10099         SND_PCI_QUIRK(0x17aa, 0x3820, "Yoga Duet 7 13ITL6", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10100         SND_PCI_QUIRK(0x17aa, 0x3824, "Legion Y9000X 2020", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10101         SND_PCI_QUIRK(0x17aa, 0x3827, "Ideapad S740", ALC285_FIXUP_IDEAPAD_S740_COEF),
10102         SND_PCI_QUIRK(0x17aa, 0x3834, "Lenovo IdeaPad Slim 9i 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10103         SND_PCI_QUIRK(0x17aa, 0x383d, "Legion Y9000X 2019", ALC285_FIXUP_LEGION_Y9000X_SPEAKERS),
10104         SND_PCI_QUIRK(0x17aa, 0x3843, "Yoga 9i", ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP),
10105         SND_PCI_QUIRK(0x17aa, 0x3847, "Legion 7 16ACHG6", ALC287_FIXUP_LEGION_16ACHG6),
10106         SND_PCI_QUIRK(0x17aa, 0x384a, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10107         SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10108         SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
10109         SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6),
10110         SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
10111         SND_PCI_QUIRK(0x17aa, 0x387d, "Yoga S780-16 pro Quad AAC", ALC287_FIXUP_TAS2781_I2C),
10112         SND_PCI_QUIRK(0x17aa, 0x387e, "Yoga S780-16 pro Quad YC", ALC287_FIXUP_TAS2781_I2C),
10113         SND_PCI_QUIRK(0x17aa, 0x3881, "YB9 dual power mode2 YC", ALC287_FIXUP_TAS2781_I2C),
10114         SND_PCI_QUIRK(0x17aa, 0x3884, "Y780 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10115         SND_PCI_QUIRK(0x17aa, 0x3886, "Y780 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10116         SND_PCI_QUIRK(0x17aa, 0x38a7, "Y780P AMD YG dual", ALC287_FIXUP_TAS2781_I2C),
10117         SND_PCI_QUIRK(0x17aa, 0x38a8, "Y780P AMD VECO dual", ALC287_FIXUP_TAS2781_I2C),
10118         SND_PCI_QUIRK(0x17aa, 0x38ba, "Yoga S780-14.5 Air AMD quad YC", ALC287_FIXUP_TAS2781_I2C),
10119         SND_PCI_QUIRK(0x17aa, 0x38bb, "Yoga S780-14.5 Air AMD quad AAC", ALC287_FIXUP_TAS2781_I2C),
10120         SND_PCI_QUIRK(0x17aa, 0x38be, "Yoga S980-14.5 proX YC Dual", ALC287_FIXUP_TAS2781_I2C),
10121         SND_PCI_QUIRK(0x17aa, 0x38bf, "Yoga S980-14.5 proX LX Dual", ALC287_FIXUP_TAS2781_I2C),
10122         SND_PCI_QUIRK(0x17aa, 0x38c3, "Y980 DUAL", ALC287_FIXUP_TAS2781_I2C),
10123         SND_PCI_QUIRK(0x17aa, 0x38cb, "Y790 YG DUAL", ALC287_FIXUP_TAS2781_I2C),
10124         SND_PCI_QUIRK(0x17aa, 0x38cd, "Y790 VECO DUAL", ALC287_FIXUP_TAS2781_I2C),
10125         SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10126         SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),
10127         SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo B50-70", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
10128         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_PCM_44K),
10129         SND_PCI_QUIRK(0x17aa, 0x5013, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10130         SND_PCI_QUIRK(0x17aa, 0x501a, "Thinkpad", ALC283_FIXUP_INT_MIC),
10131         SND_PCI_QUIRK(0x17aa, 0x501e, "Thinkpad L440", ALC292_FIXUP_TPT440_DOCK),
10132         SND_PCI_QUIRK(0x17aa, 0x5026, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10133         SND_PCI_QUIRK(0x17aa, 0x5034, "Thinkpad T450", ALC292_FIXUP_TPT440_DOCK),
10134         SND_PCI_QUIRK(0x17aa, 0x5036, "Thinkpad T450s", ALC292_FIXUP_TPT440_DOCK),
10135         SND_PCI_QUIRK(0x17aa, 0x503c, "Thinkpad L450", ALC292_FIXUP_TPT440_DOCK),
10136         SND_PCI_QUIRK(0x17aa, 0x504a, "ThinkPad X260", ALC292_FIXUP_TPT440_DOCK),
10137         SND_PCI_QUIRK(0x17aa, 0x504b, "Thinkpad", ALC293_FIXUP_LENOVO_SPK_NOISE),
10138         SND_PCI_QUIRK(0x17aa, 0x5050, "Thinkpad T560p", ALC292_FIXUP_TPT460),
10139         SND_PCI_QUIRK(0x17aa, 0x5051, "Thinkpad L460", ALC292_FIXUP_TPT460),
10140         SND_PCI_QUIRK(0x17aa, 0x5053, "Thinkpad T460", ALC292_FIXUP_TPT460),
10141         SND_PCI_QUIRK(0x17aa, 0x505d, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10142         SND_PCI_QUIRK(0x17aa, 0x505f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10143         SND_PCI_QUIRK(0x17aa, 0x5062, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10144         SND_PCI_QUIRK(0x17aa, 0x508b, "Thinkpad X12 Gen 1", ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS),
10145         SND_PCI_QUIRK(0x17aa, 0x5109, "Thinkpad", ALC269_FIXUP_LIMIT_INT_MIC_BOOST),
10146         SND_PCI_QUIRK(0x17aa, 0x511e, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10147         SND_PCI_QUIRK(0x17aa, 0x511f, "Thinkpad", ALC298_FIXUP_TPT470_DOCK),
10148         SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
10149         SND_PCI_QUIRK(0x17aa, 0x9e56, "Lenovo ZhaoYang CF4620Z", ALC286_FIXUP_SONY_MIC_NO_PRESENCE),
10150         SND_PCI_QUIRK(0x1849, 0x1233, "ASRock NUC Box 1100", ALC233_FIXUP_NO_AUDIO_JACK),
10151         SND_PCI_QUIRK(0x1849, 0xa233, "Positivo Master C6300", ALC269_FIXUP_HEADSET_MIC),
10152         SND_PCI_QUIRK(0x19e5, 0x3204, "Huawei MACH-WX9", ALC256_FIXUP_HUAWEI_MACH_WX9_PINS),
10153         SND_PCI_QUIRK(0x19e5, 0x320f, "Huawei WRT-WX9 ", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE),
10154         SND_PCI_QUIRK(0x1b35, 0x1235, "CZC B20", ALC269_FIXUP_CZC_B20),
10155         SND_PCI_QUIRK(0x1b35, 0x1236, "CZC TMI", ALC269_FIXUP_CZC_TMI),
10156         SND_PCI_QUIRK(0x1b35, 0x1237, "CZC L101", ALC269_FIXUP_CZC_L101),
10157         SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
10158         SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
10159         SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
10160         SND_PCI_QUIRK(0x1c6c, 0x1251, "Positivo N14KP6-TG", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE),
10161         SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
10162         SND_PCI_QUIRK(0x1d05, 0x1096, "TongFang GMxMRxx", ALC269_FIXUP_NO_SHUTUP),
10163         SND_PCI_QUIRK(0x1d05, 0x1100, "TongFang GKxNRxx", ALC269_FIXUP_NO_SHUTUP),
10164         SND_PCI_QUIRK(0x1d05, 0x1111, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10165         SND_PCI_QUIRK(0x1d05, 0x1119, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10166         SND_PCI_QUIRK(0x1d05, 0x1129, "TongFang GMxZGxx", ALC269_FIXUP_NO_SHUTUP),
10167         SND_PCI_QUIRK(0x1d05, 0x1147, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10168         SND_PCI_QUIRK(0x1d05, 0x115c, "TongFang GMxTGxx", ALC269_FIXUP_NO_SHUTUP),
10169         SND_PCI_QUIRK(0x1d05, 0x121b, "TongFang GMxAGxx", ALC269_FIXUP_NO_SHUTUP),
10170         SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10171         SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
10172         SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
10173         SND_PCI_QUIRK(0x1d72, 0x1945, "Redmi G", ALC256_FIXUP_ASUS_HEADSET_MIC),
10174         SND_PCI_QUIRK(0x1d72, 0x1947, "RedmiBook Air", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
10175         SND_PCI_QUIRK(0x8086, 0x2074, "Intel NUC 8", ALC233_FIXUP_INTEL_NUC8_DMIC),
10176         SND_PCI_QUIRK(0x8086, 0x2080, "Intel NUC 8 Rugged", ALC256_FIXUP_INTEL_NUC8_RUGGED),
10177         SND_PCI_QUIRK(0x8086, 0x2081, "Intel NUC 10", ALC256_FIXUP_INTEL_NUC10),
10178         SND_PCI_QUIRK(0x8086, 0x3038, "Intel NUC 13", ALC295_FIXUP_CHROME_BOOK),
10179         SND_PCI_QUIRK(0xf111, 0x0001, "Framework Laptop", ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE),
10180
10181 #if 0
10182         /* Below is a quirk table taken from the old code.
10183          * Basically the device should work as is without the fixup table.
10184          * If BIOS doesn't give a proper info, enable the corresponding
10185          * fixup entry.
10186          */
10187         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
10188                       ALC269_FIXUP_AMIC),
10189         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269_FIXUP_AMIC),
10190         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269_FIXUP_AMIC),
10191         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_FIXUP_AMIC),
10192         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269_FIXUP_AMIC),
10193         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269_FIXUP_AMIC),
10194         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269_FIXUP_AMIC),
10195         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269_FIXUP_AMIC),
10196         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_FIXUP_AMIC),
10197         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269_FIXUP_AMIC),
10198         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_FIXUP_AMIC),
10199         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_FIXUP_AMIC),
10200         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_FIXUP_AMIC),
10201         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_FIXUP_AMIC),
10202         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_FIXUP_AMIC),
10203         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_FIXUP_AMIC),
10204         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_FIXUP_AMIC),
10205         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_FIXUP_AMIC),
10206         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_FIXUP_AMIC),
10207         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_FIXUP_AMIC),
10208         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_FIXUP_AMIC),
10209         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_FIXUP_AMIC),
10210         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_FIXUP_AMIC),
10211         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_FIXUP_AMIC),
10212         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_FIXUP_AMIC),
10213         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_FIXUP_AMIC),
10214         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_FIXUP_AMIC),
10215         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_FIXUP_AMIC),
10216         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_FIXUP_AMIC),
10217         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_FIXUP_AMIC),
10218         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_FIXUP_AMIC),
10219         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_FIXUP_AMIC),
10220         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_FIXUP_AMIC),
10221         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_FIXUP_AMIC),
10222         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_FIXUP_AMIC),
10223         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_FIXUP_DMIC),
10224         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_FIXUP_AMIC),
10225         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_FIXUP_AMIC),
10226         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_FIXUP_DMIC),
10227         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_FIXUP_DMIC),
10228 #endif
10229         {}
10230 };
10231
10232 static const struct snd_pci_quirk alc269_fixup_vendor_tbl[] = {
10233         SND_PCI_QUIRK_VENDOR(0x1025, "Acer Aspire", ALC271_FIXUP_DMIC),
10234         SND_PCI_QUIRK_VENDOR(0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED),
10235         SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
10236         SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", ALC269_FIXUP_THINKPAD_ACPI),
10237         SND_PCI_QUIRK_VENDOR(0x19e5, "Huawei Matebook", ALC255_FIXUP_MIC_MUTE_LED),
10238         {}
10239 };
10240
10241 static const struct hda_model_fixup alc269_fixup_models[] = {
10242         {.id = ALC269_FIXUP_AMIC, .name = "laptop-amic"},
10243         {.id = ALC269_FIXUP_DMIC, .name = "laptop-dmic"},
10244         {.id = ALC269_FIXUP_STEREO_DMIC, .name = "alc269-dmic"},
10245         {.id = ALC271_FIXUP_DMIC, .name = "alc271-dmic"},
10246         {.id = ALC269_FIXUP_INV_DMIC, .name = "inv-dmic"},
10247         {.id = ALC269_FIXUP_HEADSET_MIC, .name = "headset-mic"},
10248         {.id = ALC269_FIXUP_HEADSET_MODE, .name = "headset-mode"},
10249         {.id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC, .name = "headset-mode-no-hp-mic"},
10250         {.id = ALC269_FIXUP_LENOVO_DOCK, .name = "lenovo-dock"},
10251         {.id = ALC269_FIXUP_LENOVO_DOCK_LIMIT_BOOST, .name = "lenovo-dock-limit-boost"},
10252         {.id = ALC269_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10253         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic1-led"},
10254         {.id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
10255         {.id = ALC269_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "dell-headset-dock"},
10256         {.id = ALC269_FIXUP_DELL3_MIC_NO_PRESENCE, .name = "dell-headset3"},
10257         {.id = ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, .name = "dell-headset4"},
10258         {.id = ALC283_FIXUP_CHROME_BOOK, .name = "alc283-dac-wcaps"},
10259         {.id = ALC283_FIXUP_SENSE_COMBO_JACK, .name = "alc283-sense-combo"},
10260         {.id = ALC292_FIXUP_TPT440_DOCK, .name = "tpt440-dock"},
10261         {.id = ALC292_FIXUP_TPT440, .name = "tpt440"},
10262         {.id = ALC292_FIXUP_TPT460, .name = "tpt460"},
10263         {.id = ALC298_FIXUP_TPT470_DOCK_FIX, .name = "tpt470-dock-fix"},
10264         {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"},
10265         {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
10266         {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"},
10267         {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"},
10268         {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"},
10269         {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},
10270         {.id = ALC269_FIXUP_LENOVO_EAPD, .name = "lenovo-eapd"},
10271         {.id = ALC275_FIXUP_SONY_HWEQ, .name = "sony-hweq"},
10272         {.id = ALC269_FIXUP_PCM_44K, .name = "pcm44k"},
10273         {.id = ALC269_FIXUP_LIFEBOOK, .name = "lifebook"},
10274         {.id = ALC269_FIXUP_LIFEBOOK_EXTMIC, .name = "lifebook-extmic"},
10275         {.id = ALC269_FIXUP_LIFEBOOK_HP_PIN, .name = "lifebook-hp-pin"},
10276         {.id = ALC255_FIXUP_LIFEBOOK_U7x7_HEADSET_MIC, .name = "lifebook-u7x7"},
10277         {.id = ALC269VB_FIXUP_AMIC, .name = "alc269vb-amic"},
10278         {.id = ALC269VB_FIXUP_DMIC, .name = "alc269vb-dmic"},
10279         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC1, .name = "hp-mute-led-mic1"},
10280         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC2, .name = "hp-mute-led-mic2"},
10281         {.id = ALC269_FIXUP_HP_MUTE_LED_MIC3, .name = "hp-mute-led-mic3"},
10282         {.id = ALC269_FIXUP_HP_GPIO_MIC1_LED, .name = "hp-gpio-mic1"},
10283         {.id = ALC269_FIXUP_HP_LINE1_MIC1_LED, .name = "hp-line1-mic1"},
10284         {.id = ALC269_FIXUP_NO_SHUTUP, .name = "noshutup"},
10285         {.id = ALC286_FIXUP_SONY_MIC_NO_PRESENCE, .name = "sony-nomic"},
10286         {.id = ALC269_FIXUP_ASPIRE_HEADSET_MIC, .name = "aspire-headset-mic"},
10287         {.id = ALC269_FIXUP_ASUS_X101, .name = "asus-x101"},
10288         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK, .name = "acer-ao7xx"},
10289         {.id = ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572, .name = "acer-aspire-e1"},
10290         {.id = ALC269_FIXUP_ACER_AC700, .name = "acer-ac700"},
10291         {.id = ALC269_FIXUP_LIMIT_INT_MIC_BOOST, .name = "limit-mic-boost"},
10292         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK, .name = "asus-zenbook"},
10293         {.id = ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A, .name = "asus-zenbook-ux31a"},
10294         {.id = ALC269VB_FIXUP_ORDISSIMO_EVE2, .name = "ordissimo"},
10295         {.id = ALC282_FIXUP_ASUS_TX300, .name = "asus-tx300"},
10296         {.id = ALC283_FIXUP_INT_MIC, .name = "alc283-int-mic"},
10297         {.id = ALC290_FIXUP_MONO_SPEAKERS_HSJACK, .name = "mono-speakers"},
10298         {.id = ALC290_FIXUP_SUBWOOFER_HSJACK, .name = "alc290-subwoofer"},
10299         {.id = ALC269_FIXUP_THINKPAD_ACPI, .name = "thinkpad"},
10300         {.id = ALC269_FIXUP_DMIC_THINKPAD_ACPI, .name = "dmic-thinkpad"},
10301         {.id = ALC255_FIXUP_ACER_MIC_NO_PRESENCE, .name = "alc255-acer"},
10302         {.id = ALC255_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc255-asus"},
10303         {.id = ALC255_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc255-dell1"},
10304         {.id = ALC255_FIXUP_DELL2_MIC_NO_PRESENCE, .name = "alc255-dell2"},
10305         {.id = ALC293_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc293-dell1"},
10306         {.id = ALC283_FIXUP_HEADSET_MIC, .name = "alc283-headset"},
10307         {.id = ALC255_FIXUP_MIC_MUTE_LED, .name = "alc255-dell-mute"},
10308         {.id = ALC282_FIXUP_ASPIRE_V5_PINS, .name = "aspire-v5"},
10309         {.id = ALC269VB_FIXUP_ASPIRE_E1_COEF, .name = "aspire-e1-coef"},
10310         {.id = ALC280_FIXUP_HP_GPIO4, .name = "hp-gpio4"},
10311         {.id = ALC286_FIXUP_HP_GPIO_LED, .name = "hp-gpio-led"},
10312         {.id = ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY, .name = "hp-gpio2-hotkey"},
10313         {.id = ALC280_FIXUP_HP_DOCK_PINS, .name = "hp-dock-pins"},
10314         {.id = ALC269_FIXUP_HP_DOCK_GPIO_MIC1_LED, .name = "hp-dock-gpio-mic"},
10315         {.id = ALC280_FIXUP_HP_9480M, .name = "hp-9480m"},
10316         {.id = ALC288_FIXUP_DELL_HEADSET_MODE, .name = "alc288-dell-headset"},
10317         {.id = ALC288_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc288-dell1"},
10318         {.id = ALC288_FIXUP_DELL_XPS_13, .name = "alc288-dell-xps13"},
10319         {.id = ALC292_FIXUP_DELL_E7X, .name = "dell-e7x"},
10320         {.id = ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK, .name = "alc293-dell"},
10321         {.id = ALC298_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc298-dell1"},
10322         {.id = ALC298_FIXUP_DELL_AIO_MIC_NO_PRESENCE, .name = "alc298-dell-aio"},
10323         {.id = ALC275_FIXUP_DELL_XPS, .name = "alc275-dell-xps"},
10324         {.id = ALC293_FIXUP_LENOVO_SPK_NOISE, .name = "lenovo-spk-noise"},
10325         {.id = ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY, .name = "lenovo-hotkey"},
10326         {.id = ALC255_FIXUP_DELL_SPK_NOISE, .name = "dell-spk-noise"},
10327         {.id = ALC225_FIXUP_DELL1_MIC_NO_PRESENCE, .name = "alc225-dell1"},
10328         {.id = ALC295_FIXUP_DISABLE_DAC3, .name = "alc295-disable-dac3"},
10329         {.id = ALC285_FIXUP_SPEAKER2_TO_DAC1, .name = "alc285-speaker2-to-dac1"},
10330         {.id = ALC280_FIXUP_HP_HEADSET_MIC, .name = "alc280-hp-headset"},
10331         {.id = ALC221_FIXUP_HP_FRONT_MIC, .name = "alc221-hp-mic"},
10332         {.id = ALC298_FIXUP_SPK_VOLUME, .name = "alc298-spk-volume"},
10333         {.id = ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER, .name = "dell-inspiron-7559"},
10334         {.id = ALC269_FIXUP_ATIV_BOOK_8, .name = "ativ-book"},
10335         {.id = ALC221_FIXUP_HP_MIC_NO_PRESENCE, .name = "alc221-hp-mic"},
10336         {.id = ALC256_FIXUP_ASUS_HEADSET_MODE, .name = "alc256-asus-headset"},
10337         {.id = ALC256_FIXUP_ASUS_MIC, .name = "alc256-asus-mic"},
10338         {.id = ALC256_FIXUP_ASUS_AIO_GPIO2, .name = "alc256-asus-aio"},
10339         {.id = ALC233_FIXUP_ASUS_MIC_NO_PRESENCE, .name = "alc233-asus"},
10340         {.id = ALC233_FIXUP_EAPD_COEF_AND_MIC_NO_PRESENCE, .name = "alc233-eapd"},
10341         {.id = ALC294_FIXUP_LENOVO_MIC_LOCATION, .name = "alc294-lenovo-mic"},
10342         {.id = ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, .name = "alc225-wyse"},
10343         {.id = ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, .name = "alc274-dell-aio"},
10344         {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
10345         {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
10346         {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
10347         {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-headset-jack"},
10348         {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-chrome-book"},
10349         {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"},
10350         {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"},
10351         {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"},
10352         {.id = ALC298_FIXUP_SAMSUNG_AMP, .name = "alc298-samsung-amp"},
10353         {.id = ALC256_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc256-samsung-headphone"},
10354         {.id = ALC255_FIXUP_XIAOMI_HEADSET_MIC, .name = "alc255-xiaomi-headset"},
10355         {.id = ALC274_FIXUP_HP_MIC, .name = "alc274-hp-mic-detect"},
10356         {.id = ALC245_FIXUP_HP_X360_AMP, .name = "alc245-hp-x360-amp"},
10357         {.id = ALC295_FIXUP_HP_OMEN, .name = "alc295-hp-omen"},
10358         {.id = ALC285_FIXUP_HP_SPECTRE_X360, .name = "alc285-hp-spectre-x360"},
10359         {.id = ALC285_FIXUP_HP_SPECTRE_X360_EB1, .name = "alc285-hp-spectre-x360-eb1"},
10360         {.id = ALC287_FIXUP_IDEAPAD_BASS_SPK_AMP, .name = "alc287-ideapad-bass-spk-amp"},
10361         {.id = ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN, .name = "alc287-yoga9-bass-spk-pin"},
10362         {.id = ALC623_FIXUP_LENOVO_THINKSTATION_P340, .name = "alc623-lenovo-thinkstation-p340"},
10363         {.id = ALC255_FIXUP_ACER_HEADPHONE_AND_MIC, .name = "alc255-acer-headphone-and-mic"},
10364         {.id = ALC285_FIXUP_HP_GPIO_AMP_INIT, .name = "alc285-hp-amp-init"},
10365         {}
10366 };
10367 #define ALC225_STANDARD_PINS \
10368         {0x21, 0x04211020}
10369
10370 #define ALC256_STANDARD_PINS \
10371         {0x12, 0x90a60140}, \
10372         {0x14, 0x90170110}, \
10373         {0x21, 0x02211020}
10374
10375 #define ALC282_STANDARD_PINS \
10376         {0x14, 0x90170110}
10377
10378 #define ALC290_STANDARD_PINS \
10379         {0x12, 0x99a30130}
10380
10381 #define ALC292_STANDARD_PINS \
10382         {0x14, 0x90170110}, \
10383         {0x15, 0x0221401f}
10384
10385 #define ALC295_STANDARD_PINS \
10386         {0x12, 0xb7a60130}, \
10387         {0x14, 0x90170110}, \
10388         {0x21, 0x04211020}
10389
10390 #define ALC298_STANDARD_PINS \
10391         {0x12, 0x90a60130}, \
10392         {0x21, 0x03211020}
10393
10394 static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
10395         SND_HDA_PIN_QUIRK(0x10ec0221, 0x103c, "HP Workstation", ALC221_FIXUP_HP_HEADSET_MIC,
10396                 {0x14, 0x01014020},
10397                 {0x17, 0x90170110},
10398                 {0x18, 0x02a11030},
10399                 {0x19, 0x0181303F},
10400                 {0x21, 0x0221102f}),
10401         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1025, "Acer", ALC255_FIXUP_ACER_MIC_NO_PRESENCE,
10402                 {0x12, 0x90a601c0},
10403                 {0x14, 0x90171120},
10404                 {0x21, 0x02211030}),
10405         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10406                 {0x14, 0x90170110},
10407                 {0x1b, 0x90a70130},
10408                 {0x21, 0x03211020}),
10409         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1043, "ASUS", ALC255_FIXUP_ASUS_MIC_NO_PRESENCE,
10410                 {0x1a, 0x90a70130},
10411                 {0x1b, 0x90170110},
10412                 {0x21, 0x03211020}),
10413         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10414                 ALC225_STANDARD_PINS,
10415                 {0x12, 0xb7a60130},
10416                 {0x14, 0x901701a0}),
10417         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10418                 ALC225_STANDARD_PINS,
10419                 {0x12, 0xb7a60130},
10420                 {0x14, 0x901701b0}),
10421         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10422                 ALC225_STANDARD_PINS,
10423                 {0x12, 0xb7a60150},
10424                 {0x14, 0x901701a0}),
10425         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10426                 ALC225_STANDARD_PINS,
10427                 {0x12, 0xb7a60150},
10428                 {0x14, 0x901701b0}),
10429         SND_HDA_PIN_QUIRK(0x10ec0225, 0x1028, "Dell", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE,
10430                 ALC225_STANDARD_PINS,
10431                 {0x12, 0xb7a60130},
10432                 {0x1b, 0x90170110}),
10433         SND_HDA_PIN_QUIRK(0x10ec0233, 0x8086, "Intel NUC Skull Canyon", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10434                 {0x1b, 0x01111010},
10435                 {0x1e, 0x01451130},
10436                 {0x21, 0x02211020}),
10437         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY,
10438                 {0x12, 0x90a60140},
10439                 {0x14, 0x90170110},
10440                 {0x19, 0x02a11030},
10441                 {0x21, 0x02211020}),
10442         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10443                 {0x14, 0x90170110},
10444                 {0x19, 0x02a11030},
10445                 {0x1a, 0x02a11040},
10446                 {0x1b, 0x01014020},
10447                 {0x21, 0x0221101f}),
10448         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10449                 {0x14, 0x90170110},
10450                 {0x19, 0x02a11030},
10451                 {0x1a, 0x02a11040},
10452                 {0x1b, 0x01011020},
10453                 {0x21, 0x0221101f}),
10454         SND_HDA_PIN_QUIRK(0x10ec0235, 0x17aa, "Lenovo", ALC294_FIXUP_LENOVO_MIC_LOCATION,
10455                 {0x14, 0x90170110},
10456                 {0x19, 0x02a11020},
10457                 {0x1a, 0x02a11030},
10458                 {0x21, 0x0221101f}),
10459         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC,
10460                 {0x21, 0x02211010}),
10461         SND_HDA_PIN_QUIRK(0x10ec0236, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10462                 {0x14, 0x90170110},
10463                 {0x19, 0x02a11020},
10464                 {0x21, 0x02211030}),
10465         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL2_MIC_NO_PRESENCE,
10466                 {0x14, 0x90170110},
10467                 {0x21, 0x02211020}),
10468         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10469                 {0x14, 0x90170130},
10470                 {0x21, 0x02211040}),
10471         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10472                 {0x12, 0x90a60140},
10473                 {0x14, 0x90170110},
10474                 {0x21, 0x02211020}),
10475         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10476                 {0x12, 0x90a60160},
10477                 {0x14, 0x90170120},
10478                 {0x21, 0x02211030}),
10479         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10480                 {0x14, 0x90170110},
10481                 {0x1b, 0x02011020},
10482                 {0x21, 0x0221101f}),
10483         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10484                 {0x14, 0x90170110},
10485                 {0x1b, 0x01011020},
10486                 {0x21, 0x0221101f}),
10487         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10488                 {0x14, 0x90170130},
10489                 {0x1b, 0x01014020},
10490                 {0x21, 0x0221103f}),
10491         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10492                 {0x14, 0x90170130},
10493                 {0x1b, 0x01011020},
10494                 {0x21, 0x0221103f}),
10495         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10496                 {0x14, 0x90170130},
10497                 {0x1b, 0x02011020},
10498                 {0x21, 0x0221103f}),
10499         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10500                 {0x14, 0x90170150},
10501                 {0x1b, 0x02011020},
10502                 {0x21, 0x0221105f}),
10503         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10504                 {0x14, 0x90170110},
10505                 {0x1b, 0x01014020},
10506                 {0x21, 0x0221101f}),
10507         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10508                 {0x12, 0x90a60160},
10509                 {0x14, 0x90170120},
10510                 {0x17, 0x90170140},
10511                 {0x21, 0x0321102f}),
10512         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10513                 {0x12, 0x90a60160},
10514                 {0x14, 0x90170130},
10515                 {0x21, 0x02211040}),
10516         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10517                 {0x12, 0x90a60160},
10518                 {0x14, 0x90170140},
10519                 {0x21, 0x02211050}),
10520         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10521                 {0x12, 0x90a60170},
10522                 {0x14, 0x90170120},
10523                 {0x21, 0x02211030}),
10524         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10525                 {0x12, 0x90a60170},
10526                 {0x14, 0x90170130},
10527                 {0x21, 0x02211040}),
10528         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10529                 {0x12, 0x90a60170},
10530                 {0x14, 0x90171130},
10531                 {0x21, 0x02211040}),
10532         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10533                 {0x12, 0x90a60170},
10534                 {0x14, 0x90170140},
10535                 {0x21, 0x02211050}),
10536         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5548", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10537                 {0x12, 0x90a60180},
10538                 {0x14, 0x90170130},
10539                 {0x21, 0x02211040}),
10540         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell Inspiron 5565", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10541                 {0x12, 0x90a60180},
10542                 {0x14, 0x90170120},
10543                 {0x21, 0x02211030}),
10544         SND_HDA_PIN_QUIRK(0x10ec0255, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10545                 {0x1b, 0x01011020},
10546                 {0x21, 0x02211010}),
10547         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10548                 {0x14, 0x90170110},
10549                 {0x1b, 0x90a70130},
10550                 {0x21, 0x04211020}),
10551         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC,
10552                 {0x14, 0x90170110},
10553                 {0x1b, 0x90a70130},
10554                 {0x21, 0x03211020}),
10555         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10556                 {0x12, 0x90a60130},
10557                 {0x14, 0x90170110},
10558                 {0x21, 0x03211020}),
10559         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10560                 {0x12, 0x90a60130},
10561                 {0x14, 0x90170110},
10562                 {0x21, 0x04211020}),
10563         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC256_FIXUP_ASUS_MIC_NO_PRESENCE,
10564                 {0x1a, 0x90a70130},
10565                 {0x1b, 0x90170110},
10566                 {0x21, 0x03211020}),
10567        SND_HDA_PIN_QUIRK(0x10ec0256, 0x103c, "HP", ALC256_FIXUP_HP_HEADSET_MIC,
10568                 {0x14, 0x90170110},
10569                 {0x19, 0x02a11020},
10570                 {0x21, 0x0221101f}),
10571        SND_HDA_PIN_QUIRK(0x10ec0274, 0x103c, "HP", ALC274_FIXUP_HP_HEADSET_MIC,
10572                 {0x17, 0x90170110},
10573                 {0x19, 0x03a11030},
10574                 {0x21, 0x03211020}),
10575         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC280_FIXUP_HP_GPIO4,
10576                 {0x12, 0x90a60130},
10577                 {0x14, 0x90170110},
10578                 {0x15, 0x0421101f},
10579                 {0x1a, 0x04a11020}),
10580         SND_HDA_PIN_QUIRK(0x10ec0280, 0x103c, "HP", ALC269_FIXUP_HP_GPIO_MIC1_LED,
10581                 {0x12, 0x90a60140},
10582                 {0x14, 0x90170110},
10583                 {0x15, 0x0421101f},
10584                 {0x18, 0x02811030},
10585                 {0x1a, 0x04a1103f},
10586                 {0x1b, 0x02011020}),
10587         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP 15 Touchsmart", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10588                 ALC282_STANDARD_PINS,
10589                 {0x12, 0x99a30130},
10590                 {0x19, 0x03a11020},
10591                 {0x21, 0x0321101f}),
10592         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10593                 ALC282_STANDARD_PINS,
10594                 {0x12, 0x99a30130},
10595                 {0x19, 0x03a11020},
10596                 {0x21, 0x03211040}),
10597         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10598                 ALC282_STANDARD_PINS,
10599                 {0x12, 0x99a30130},
10600                 {0x19, 0x03a11030},
10601                 {0x21, 0x03211020}),
10602         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10603                 ALC282_STANDARD_PINS,
10604                 {0x12, 0x99a30130},
10605                 {0x19, 0x04a11020},
10606                 {0x21, 0x0421101f}),
10607         SND_HDA_PIN_QUIRK(0x10ec0282, 0x103c, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED,
10608                 ALC282_STANDARD_PINS,
10609                 {0x12, 0x90a60140},
10610                 {0x19, 0x04a11030},
10611                 {0x21, 0x04211020}),
10612         SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10613                 ALC282_STANDARD_PINS,
10614                 {0x12, 0x90a609c0},
10615                 {0x18, 0x03a11830},
10616                 {0x19, 0x04a19831},
10617                 {0x1a, 0x0481303f},
10618                 {0x1b, 0x04211020},
10619                 {0x21, 0x0321101f}),
10620         SND_HDA_PIN_QUIRK(0x10ec0282, 0x1025, "Acer", ALC282_FIXUP_ACER_DISABLE_LINEOUT,
10621                 ALC282_STANDARD_PINS,
10622                 {0x12, 0x90a60940},
10623                 {0x18, 0x03a11830},
10624                 {0x19, 0x04a19831},
10625                 {0x1a, 0x0481303f},
10626                 {0x1b, 0x04211020},
10627                 {0x21, 0x0321101f}),
10628         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10629                 ALC282_STANDARD_PINS,
10630                 {0x12, 0x90a60130},
10631                 {0x21, 0x0321101f}),
10632         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10633                 {0x12, 0x90a60160},
10634                 {0x14, 0x90170120},
10635                 {0x21, 0x02211030}),
10636         SND_HDA_PIN_QUIRK(0x10ec0283, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
10637                 ALC282_STANDARD_PINS,
10638                 {0x12, 0x90a60130},
10639                 {0x19, 0x03a11020},
10640                 {0x21, 0x0321101f}),
10641         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10642                 {0x12, 0x90a60130},
10643                 {0x14, 0x90170110},
10644                 {0x19, 0x04a11040},
10645                 {0x21, 0x04211020}),
10646         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
10647                 {0x14, 0x90170110},
10648                 {0x19, 0x04a11040},
10649                 {0x1d, 0x40600001},
10650                 {0x21, 0x04211020}),
10651         SND_HDA_PIN_QUIRK(0x10ec0285, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_NO_BASS_SPK_HEADSET_JACK,
10652                 {0x14, 0x90170110},
10653                 {0x19, 0x04a11040},
10654                 {0x21, 0x04211020}),
10655         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC285_FIXUP_THINKPAD_HEADSET_JACK,
10656                 {0x14, 0x90170110},
10657                 {0x17, 0x90170111},
10658                 {0x19, 0x03a11030},
10659                 {0x21, 0x03211020}),
10660         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
10661                 {0x17, 0x90170110},
10662                 {0x19, 0x03a11030},
10663                 {0x21, 0x03211020}),
10664         SND_HDA_PIN_QUIRK(0x10ec0287, 0x17aa, "Lenovo", ALC287_FIXUP_THINKPAD_I2S_SPK,
10665                 {0x17, 0x90170110}, /* 0x231f with RTK I2S AMP */
10666                 {0x19, 0x04a11040},
10667                 {0x21, 0x04211020}),
10668         SND_HDA_PIN_QUIRK(0x10ec0286, 0x1025, "Acer", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE,
10669                 {0x12, 0x90a60130},
10670                 {0x17, 0x90170110},
10671                 {0x21, 0x02211020}),
10672         SND_HDA_PIN_QUIRK(0x10ec0288, 0x1028, "Dell", ALC288_FIXUP_DELL1_MIC_NO_PRESENCE,
10673                 {0x12, 0x90a60120},
10674                 {0x14, 0x90170110},
10675                 {0x21, 0x0321101f}),
10676         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10677                 ALC290_STANDARD_PINS,
10678                 {0x15, 0x04211040},
10679                 {0x18, 0x90170112},
10680                 {0x1a, 0x04a11020}),
10681         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10682                 ALC290_STANDARD_PINS,
10683                 {0x15, 0x04211040},
10684                 {0x18, 0x90170110},
10685                 {0x1a, 0x04a11020}),
10686         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10687                 ALC290_STANDARD_PINS,
10688                 {0x15, 0x0421101f},
10689                 {0x1a, 0x04a11020}),
10690         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10691                 ALC290_STANDARD_PINS,
10692                 {0x15, 0x04211020},
10693                 {0x1a, 0x04a11040}),
10694         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10695                 ALC290_STANDARD_PINS,
10696                 {0x14, 0x90170110},
10697                 {0x15, 0x04211020},
10698                 {0x1a, 0x04a11040}),
10699         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10700                 ALC290_STANDARD_PINS,
10701                 {0x14, 0x90170110},
10702                 {0x15, 0x04211020},
10703                 {0x1a, 0x04a11020}),
10704         SND_HDA_PIN_QUIRK(0x10ec0290, 0x103c, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1,
10705                 ALC290_STANDARD_PINS,
10706                 {0x14, 0x90170110},
10707                 {0x15, 0x0421101f},
10708                 {0x1a, 0x04a11020}),
10709         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
10710                 ALC292_STANDARD_PINS,
10711                 {0x12, 0x90a60140},
10712                 {0x16, 0x01014020},
10713                 {0x19, 0x01a19030}),
10714         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL2_MIC_NO_PRESENCE,
10715                 ALC292_STANDARD_PINS,
10716                 {0x12, 0x90a60140},
10717                 {0x16, 0x01014020},
10718                 {0x18, 0x02a19031},
10719                 {0x19, 0x01a1903e}),
10720         SND_HDA_PIN_QUIRK(0x10ec0292, 0x1028, "Dell", ALC269_FIXUP_DELL3_MIC_NO_PRESENCE,
10721                 ALC292_STANDARD_PINS,
10722                 {0x12, 0x90a60140}),
10723         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
10724                 ALC292_STANDARD_PINS,
10725                 {0x13, 0x90a60140},
10726                 {0x16, 0x21014020},
10727                 {0x19, 0x21a19030}),
10728         SND_HDA_PIN_QUIRK(0x10ec0293, 0x1028, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE,
10729                 ALC292_STANDARD_PINS,
10730                 {0x13, 0x90a60140}),
10731         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_HPE,
10732                 {0x17, 0x90170110},
10733                 {0x21, 0x04211020}),
10734         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_MIC,
10735                 {0x14, 0x90170110},
10736                 {0x1b, 0x90a70130},
10737                 {0x21, 0x04211020}),
10738         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10739                 {0x12, 0x90a60130},
10740                 {0x17, 0x90170110},
10741                 {0x21, 0x03211020}),
10742         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10743                 {0x12, 0x90a60130},
10744                 {0x17, 0x90170110},
10745                 {0x21, 0x04211020}),
10746         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
10747                 {0x12, 0x90a60130},
10748                 {0x17, 0x90170110},
10749                 {0x21, 0x03211020}),
10750         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10751                 {0x12, 0x90a60120},
10752                 {0x17, 0x90170110},
10753                 {0x21, 0x04211030}),
10754         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10755                 {0x12, 0x90a60130},
10756                 {0x17, 0x90170110},
10757                 {0x21, 0x03211020}),
10758         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1043, "ASUS", ALC295_FIXUP_ASUS_MIC_NO_PRESENCE,
10759                 {0x12, 0x90a60130},
10760                 {0x17, 0x90170110},
10761                 {0x21, 0x03211020}),
10762         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10763                 ALC298_STANDARD_PINS,
10764                 {0x17, 0x90170110}),
10765         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10766                 ALC298_STANDARD_PINS,
10767                 {0x17, 0x90170140}),
10768         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE,
10769                 ALC298_STANDARD_PINS,
10770                 {0x17, 0x90170150}),
10771         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_SPK_VOLUME,
10772                 {0x12, 0xb7a60140},
10773                 {0x13, 0xb7a60150},
10774                 {0x17, 0x90170110},
10775                 {0x1a, 0x03011020},
10776                 {0x21, 0x03211030}),
10777         SND_HDA_PIN_QUIRK(0x10ec0298, 0x1028, "Dell", ALC298_FIXUP_ALIENWARE_MIC_NO_PRESENCE,
10778                 {0x12, 0xb7a60140},
10779                 {0x17, 0x90170110},
10780                 {0x1a, 0x03a11030},
10781                 {0x21, 0x03211020}),
10782         SND_HDA_PIN_QUIRK(0x10ec0299, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10783                 ALC225_STANDARD_PINS,
10784                 {0x12, 0xb7a60130},
10785                 {0x17, 0x90170110}),
10786         SND_HDA_PIN_QUIRK(0x10ec0623, 0x17aa, "Lenovo", ALC283_FIXUP_HEADSET_MIC,
10787                 {0x14, 0x01014010},
10788                 {0x17, 0x90170120},
10789                 {0x18, 0x02a11030},
10790                 {0x19, 0x02a1103f},
10791                 {0x21, 0x0221101f}),
10792         {}
10793 };
10794
10795 /* This is the fallback pin_fixup_tbl for alc269 family, to make the tbl match
10796  * more machines, don't need to match all valid pins, just need to match
10797  * all the pins defined in the tbl. Just because of this reason, it is possible
10798  * that a single machine matches multiple tbls, so there is one limitation:
10799  *   at most one tbl is allowed to define for the same vendor and same codec
10800  */
10801 static const struct snd_hda_pin_quirk alc269_fallback_pin_fixup_tbl[] = {
10802         SND_HDA_PIN_QUIRK(0x10ec0289, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10803                 {0x19, 0x40000000},
10804                 {0x1b, 0x40000000}),
10805         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE,
10806                 {0x19, 0x40000000},
10807                 {0x1b, 0x40000000}),
10808         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10809                 {0x19, 0x40000000},
10810                 {0x1a, 0x40000000}),
10811         SND_HDA_PIN_QUIRK(0x10ec0236, 0x1028, "Dell", ALC255_FIXUP_DELL1_MIC_NO_PRESENCE,
10812                 {0x19, 0x40000000},
10813                 {0x1a, 0x40000000}),
10814         SND_HDA_PIN_QUIRK(0x10ec0274, 0x1028, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB,
10815                 {0x19, 0x40000000},
10816                 {0x1a, 0x40000000}),
10817         SND_HDA_PIN_QUIRK(0x10ec0256, 0x1043, "ASUS", ALC2XX_FIXUP_HEADSET_MIC,
10818                 {0x19, 0x40000000}),
10819         {}
10820 };
10821
10822 static void alc269_fill_coef(struct hda_codec *codec)
10823 {
10824         struct alc_spec *spec = codec->spec;
10825         int val;
10826
10827         if (spec->codec_variant != ALC269_TYPE_ALC269VB)
10828                 return;
10829
10830         if ((alc_get_coef0(codec) & 0x00ff) < 0x015) {
10831                 alc_write_coef_idx(codec, 0xf, 0x960b);
10832                 alc_write_coef_idx(codec, 0xe, 0x8817);
10833         }
10834
10835         if ((alc_get_coef0(codec) & 0x00ff) == 0x016) {
10836                 alc_write_coef_idx(codec, 0xf, 0x960b);
10837                 alc_write_coef_idx(codec, 0xe, 0x8814);
10838         }
10839
10840         if ((alc_get_coef0(codec) & 0x00ff) == 0x017) {
10841                 /* Power up output pin */
10842                 alc_update_coef_idx(codec, 0x04, 0, 1<<11);
10843         }
10844
10845         if ((alc_get_coef0(codec) & 0x00ff) == 0x018) {
10846                 val = alc_read_coef_idx(codec, 0xd);
10847                 if (val != -1 && (val & 0x0c00) >> 10 != 0x1) {
10848                         /* Capless ramp up clock control */
10849                         alc_write_coef_idx(codec, 0xd, val | (1<<10));
10850                 }
10851                 val = alc_read_coef_idx(codec, 0x17);
10852                 if (val != -1 && (val & 0x01c0) >> 6 != 0x4) {
10853                         /* Class D power on reset */
10854                         alc_write_coef_idx(codec, 0x17, val | (1<<7));
10855                 }
10856         }
10857
10858         /* HP */
10859         alc_update_coef_idx(codec, 0x4, 0, 1<<11);
10860 }
10861
10862 /*
10863  */
10864 static int patch_alc269(struct hda_codec *codec)
10865 {
10866         struct alc_spec *spec;
10867         int err;
10868
10869         err = alc_alloc_spec(codec, 0x0b);
10870         if (err < 0)
10871                 return err;
10872
10873         spec = codec->spec;
10874         spec->gen.shared_mic_vref_pin = 0x18;
10875         codec->power_save_node = 0;
10876         spec->en_3kpull_low = true;
10877
10878 #ifdef CONFIG_PM
10879         codec->patch_ops.suspend = alc269_suspend;
10880         codec->patch_ops.resume = alc269_resume;
10881 #endif
10882         spec->shutup = alc_default_shutup;
10883         spec->init_hook = alc_default_init;
10884
10885         switch (codec->core.vendor_id) {
10886         case 0x10ec0269:
10887                 spec->codec_variant = ALC269_TYPE_ALC269VA;
10888                 switch (alc_get_coef0(codec) & 0x00f0) {
10889                 case 0x0010:
10890                         if (codec->bus->pci &&
10891                             codec->bus->pci->subsystem_vendor == 0x1025 &&
10892                             spec->cdefine.platform_type == 1)
10893                                 err = alc_codec_rename(codec, "ALC271X");
10894                         spec->codec_variant = ALC269_TYPE_ALC269VB;
10895                         break;
10896                 case 0x0020:
10897                         if (codec->bus->pci &&
10898                             codec->bus->pci->subsystem_vendor == 0x17aa &&
10899                             codec->bus->pci->subsystem_device == 0x21f3)
10900                                 err = alc_codec_rename(codec, "ALC3202");
10901                         spec->codec_variant = ALC269_TYPE_ALC269VC;
10902                         break;
10903                 case 0x0030:
10904                         spec->codec_variant = ALC269_TYPE_ALC269VD;
10905                         break;
10906                 default:
10907                         alc_fix_pll_init(codec, 0x20, 0x04, 15);
10908                 }
10909                 if (err < 0)
10910                         goto error;
10911                 spec->shutup = alc269_shutup;
10912                 spec->init_hook = alc269_fill_coef;
10913                 alc269_fill_coef(codec);
10914                 break;
10915
10916         case 0x10ec0280:
10917         case 0x10ec0290:
10918                 spec->codec_variant = ALC269_TYPE_ALC280;
10919                 break;
10920         case 0x10ec0282:
10921                 spec->codec_variant = ALC269_TYPE_ALC282;
10922                 spec->shutup = alc282_shutup;
10923                 spec->init_hook = alc282_init;
10924                 break;
10925         case 0x10ec0233:
10926         case 0x10ec0283:
10927                 spec->codec_variant = ALC269_TYPE_ALC283;
10928                 spec->shutup = alc283_shutup;
10929                 spec->init_hook = alc283_init;
10930                 break;
10931         case 0x10ec0284:
10932         case 0x10ec0292:
10933                 spec->codec_variant = ALC269_TYPE_ALC284;
10934                 break;
10935         case 0x10ec0293:
10936                 spec->codec_variant = ALC269_TYPE_ALC293;
10937                 break;
10938         case 0x10ec0286:
10939         case 0x10ec0288:
10940                 spec->codec_variant = ALC269_TYPE_ALC286;
10941                 break;
10942         case 0x10ec0298:
10943                 spec->codec_variant = ALC269_TYPE_ALC298;
10944                 break;
10945         case 0x10ec0235:
10946         case 0x10ec0255:
10947                 spec->codec_variant = ALC269_TYPE_ALC255;
10948                 spec->shutup = alc256_shutup;
10949                 spec->init_hook = alc256_init;
10950                 break;
10951         case 0x10ec0230:
10952         case 0x10ec0236:
10953         case 0x10ec0256:
10954         case 0x19e58326:
10955                 spec->codec_variant = ALC269_TYPE_ALC256;
10956                 spec->shutup = alc256_shutup;
10957                 spec->init_hook = alc256_init;
10958                 spec->gen.mixer_nid = 0; /* ALC256 does not have any loopback mixer path */
10959                 if (codec->core.vendor_id == 0x10ec0236 &&
10960                     codec->bus->pci->vendor != PCI_VENDOR_ID_AMD)
10961                         spec->en_3kpull_low = false;
10962                 break;
10963         case 0x10ec0257:
10964                 spec->codec_variant = ALC269_TYPE_ALC257;
10965                 spec->shutup = alc256_shutup;
10966                 spec->init_hook = alc256_init;
10967                 spec->gen.mixer_nid = 0;
10968                 spec->en_3kpull_low = false;
10969                 break;
10970         case 0x10ec0215:
10971         case 0x10ec0245:
10972         case 0x10ec0285:
10973         case 0x10ec0289:
10974                 if (alc_get_coef0(codec) & 0x0010)
10975                         spec->codec_variant = ALC269_TYPE_ALC245;
10976                 else
10977                         spec->codec_variant = ALC269_TYPE_ALC215;
10978                 spec->shutup = alc225_shutup;
10979                 spec->init_hook = alc225_init;
10980                 spec->gen.mixer_nid = 0;
10981                 break;
10982         case 0x10ec0225:
10983         case 0x10ec0295:
10984         case 0x10ec0299:
10985                 spec->codec_variant = ALC269_TYPE_ALC225;
10986                 spec->shutup = alc225_shutup;
10987                 spec->init_hook = alc225_init;
10988                 spec->gen.mixer_nid = 0; /* no loopback on ALC225, ALC295 and ALC299 */
10989                 break;
10990         case 0x10ec0287:
10991                 spec->codec_variant = ALC269_TYPE_ALC287;
10992                 spec->shutup = alc225_shutup;
10993                 spec->init_hook = alc225_init;
10994                 spec->gen.mixer_nid = 0; /* no loopback on ALC287 */
10995                 break;
10996         case 0x10ec0234:
10997         case 0x10ec0274:
10998         case 0x10ec0294:
10999                 spec->codec_variant = ALC269_TYPE_ALC294;
11000                 spec->gen.mixer_nid = 0; /* ALC2x4 does not have any loopback mixer path */
11001                 alc_update_coef_idx(codec, 0x6b, 0x0018, (1<<4) | (1<<3)); /* UAJ MIC Vref control by verb */
11002                 spec->init_hook = alc294_init;
11003                 break;
11004         case 0x10ec0300:
11005                 spec->codec_variant = ALC269_TYPE_ALC300;
11006                 spec->gen.mixer_nid = 0; /* no loopback on ALC300 */
11007                 break;
11008         case 0x10ec0623:
11009                 spec->codec_variant = ALC269_TYPE_ALC623;
11010                 break;
11011         case 0x10ec0700:
11012         case 0x10ec0701:
11013         case 0x10ec0703:
11014         case 0x10ec0711:
11015                 spec->codec_variant = ALC269_TYPE_ALC700;
11016                 spec->gen.mixer_nid = 0; /* ALC700 does not have any loopback mixer path */
11017                 alc_update_coef_idx(codec, 0x4a, 1 << 15, 0); /* Combo jack auto trigger control */
11018                 spec->init_hook = alc294_init;
11019                 break;
11020
11021         }
11022
11023         if (snd_hda_codec_read(codec, 0x51, 0, AC_VERB_PARAMETERS, 0) == 0x10ec5505) {
11024                 spec->has_alc5505_dsp = 1;
11025                 spec->init_hook = alc5505_dsp_init;
11026         }
11027
11028         alc_pre_init(codec);
11029
11030         snd_hda_pick_fixup(codec, alc269_fixup_models,
11031                        alc269_fixup_tbl, alc269_fixups);
11032         /* FIXME: both TX300 and ROG Strix G17 have the same SSID, and
11033          * the quirk breaks the latter (bko#214101).
11034          * Clear the wrong entry.
11035          */
11036         if (codec->fixup_id == ALC282_FIXUP_ASUS_TX300 &&
11037             codec->core.vendor_id == 0x10ec0294) {
11038                 codec_dbg(codec, "Clear wrong fixup for ASUS ROG Strix G17\n");
11039                 codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
11040         }
11041
11042         snd_hda_pick_pin_fixup(codec, alc269_pin_fixup_tbl, alc269_fixups, true);
11043         snd_hda_pick_pin_fixup(codec, alc269_fallback_pin_fixup_tbl, alc269_fixups, false);
11044         snd_hda_pick_fixup(codec, NULL, alc269_fixup_vendor_tbl,
11045                            alc269_fixups);
11046         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11047
11048         alc_auto_parse_customize_define(codec);
11049
11050         if (has_cdefine_beep(codec))
11051                 spec->gen.beep_nid = 0x01;
11052
11053         /* automatic parse from the BIOS config */
11054         err = alc269_parse_auto_config(codec);
11055         if (err < 0)
11056                 goto error;
11057
11058         if (!spec->gen.no_analog && spec->gen.beep_nid && spec->gen.mixer_nid) {
11059                 err = set_beep_amp(spec, spec->gen.mixer_nid, 0x04, HDA_INPUT);
11060                 if (err < 0)
11061                         goto error;
11062         }
11063
11064         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11065
11066         return 0;
11067
11068  error:
11069         alc_free(codec);
11070         return err;
11071 }
11072
11073 /*
11074  * ALC861
11075  */
11076
11077 static int alc861_parse_auto_config(struct hda_codec *codec)
11078 {
11079         static const hda_nid_t alc861_ignore[] = { 0x1d, 0 };
11080         static const hda_nid_t alc861_ssids[] = { 0x0e, 0x0f, 0x0b, 0 };
11081         return alc_parse_auto_config(codec, alc861_ignore, alc861_ssids);
11082 }
11083
11084 /* Pin config fixes */
11085 enum {
11086         ALC861_FIXUP_FSC_AMILO_PI1505,
11087         ALC861_FIXUP_AMP_VREF_0F,
11088         ALC861_FIXUP_NO_JACK_DETECT,
11089         ALC861_FIXUP_ASUS_A6RP,
11090         ALC660_FIXUP_ASUS_W7J,
11091 };
11092
11093 /* On some laptops, VREF of pin 0x0f is abused for controlling the main amp */
11094 static void alc861_fixup_asus_amp_vref_0f(struct hda_codec *codec,
11095                         const struct hda_fixup *fix, int action)
11096 {
11097         struct alc_spec *spec = codec->spec;
11098         unsigned int val;
11099
11100         if (action != HDA_FIXUP_ACT_INIT)
11101                 return;
11102         val = snd_hda_codec_get_pin_target(codec, 0x0f);
11103         if (!(val & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)))
11104                 val |= AC_PINCTL_IN_EN;
11105         val |= AC_PINCTL_VREF_50;
11106         snd_hda_set_pin_ctl(codec, 0x0f, val);
11107         spec->gen.keep_vref_in_automute = 1;
11108 }
11109
11110 /* suppress the jack-detection */
11111 static void alc_fixup_no_jack_detect(struct hda_codec *codec,
11112                                      const struct hda_fixup *fix, int action)
11113 {
11114         if (action == HDA_FIXUP_ACT_PRE_PROBE)
11115                 codec->no_jack_detect = 1;
11116 }
11117
11118 static const struct hda_fixup alc861_fixups[] = {
11119         [ALC861_FIXUP_FSC_AMILO_PI1505] = {
11120                 .type = HDA_FIXUP_PINS,
11121                 .v.pins = (const struct hda_pintbl[]) {
11122                         { 0x0b, 0x0221101f }, /* HP */
11123                         { 0x0f, 0x90170310 }, /* speaker */
11124                         { }
11125                 }
11126         },
11127         [ALC861_FIXUP_AMP_VREF_0F] = {
11128                 .type = HDA_FIXUP_FUNC,
11129                 .v.func = alc861_fixup_asus_amp_vref_0f,
11130         },
11131         [ALC861_FIXUP_NO_JACK_DETECT] = {
11132                 .type = HDA_FIXUP_FUNC,
11133                 .v.func = alc_fixup_no_jack_detect,
11134         },
11135         [ALC861_FIXUP_ASUS_A6RP] = {
11136                 .type = HDA_FIXUP_FUNC,
11137                 .v.func = alc861_fixup_asus_amp_vref_0f,
11138                 .chained = true,
11139                 .chain_id = ALC861_FIXUP_NO_JACK_DETECT,
11140         },
11141         [ALC660_FIXUP_ASUS_W7J] = {
11142                 .type = HDA_FIXUP_VERBS,
11143                 .v.verbs = (const struct hda_verb[]) {
11144                         /* ASUS W7J needs a magic pin setup on unused NID 0x10
11145                          * for enabling outputs
11146                          */
11147                         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11148                         { }
11149                 },
11150         }
11151 };
11152
11153 static const struct snd_pci_quirk alc861_fixup_tbl[] = {
11154         SND_PCI_QUIRK(0x1043, 0x1253, "ASUS W7J", ALC660_FIXUP_ASUS_W7J),
11155         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS Z35HL", ALC660_FIXUP_ASUS_W7J),
11156         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS A6Rp", ALC861_FIXUP_ASUS_A6RP),
11157         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS laptop", ALC861_FIXUP_AMP_VREF_0F),
11158         SND_PCI_QUIRK(0x1462, 0x7254, "HP DX2200", ALC861_FIXUP_NO_JACK_DETECT),
11159         SND_PCI_QUIRK_VENDOR(0x1584, "Haier/Uniwill", ALC861_FIXUP_AMP_VREF_0F),
11160         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", ALC861_FIXUP_FSC_AMILO_PI1505),
11161         {}
11162 };
11163
11164 /*
11165  */
11166 static int patch_alc861(struct hda_codec *codec)
11167 {
11168         struct alc_spec *spec;
11169         int err;
11170
11171         err = alc_alloc_spec(codec, 0x15);
11172         if (err < 0)
11173                 return err;
11174
11175         spec = codec->spec;
11176         if (has_cdefine_beep(codec))
11177                 spec->gen.beep_nid = 0x23;
11178
11179 #ifdef CONFIG_PM
11180         spec->power_hook = alc_power_eapd;
11181 #endif
11182
11183         alc_pre_init(codec);
11184
11185         snd_hda_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
11186         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11187
11188         /* automatic parse from the BIOS config */
11189         err = alc861_parse_auto_config(codec);
11190         if (err < 0)
11191                 goto error;
11192
11193         if (!spec->gen.no_analog) {
11194                 err = set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
11195                 if (err < 0)
11196                         goto error;
11197         }
11198
11199         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11200
11201         return 0;
11202
11203  error:
11204         alc_free(codec);
11205         return err;
11206 }
11207
11208 /*
11209  * ALC861-VD support
11210  *
11211  * Based on ALC882
11212  *
11213  * In addition, an independent DAC
11214  */
11215 static int alc861vd_parse_auto_config(struct hda_codec *codec)
11216 {
11217         static const hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
11218         static const hda_nid_t alc861vd_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11219         return alc_parse_auto_config(codec, alc861vd_ignore, alc861vd_ssids);
11220 }
11221
11222 enum {
11223         ALC660VD_FIX_ASUS_GPIO1,
11224         ALC861VD_FIX_DALLAS,
11225 };
11226
11227 /* exclude VREF80 */
11228 static void alc861vd_fixup_dallas(struct hda_codec *codec,
11229                                   const struct hda_fixup *fix, int action)
11230 {
11231         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11232                 snd_hda_override_pin_caps(codec, 0x18, 0x00000734);
11233                 snd_hda_override_pin_caps(codec, 0x19, 0x0000073c);
11234         }
11235 }
11236
11237 /* reset GPIO1 */
11238 static void alc660vd_fixup_asus_gpio1(struct hda_codec *codec,
11239                                       const struct hda_fixup *fix, int action)
11240 {
11241         struct alc_spec *spec = codec->spec;
11242
11243         if (action == HDA_FIXUP_ACT_PRE_PROBE)
11244                 spec->gpio_mask |= 0x02;
11245         alc_fixup_gpio(codec, action, 0x01);
11246 }
11247
11248 static const struct hda_fixup alc861vd_fixups[] = {
11249         [ALC660VD_FIX_ASUS_GPIO1] = {
11250                 .type = HDA_FIXUP_FUNC,
11251                 .v.func = alc660vd_fixup_asus_gpio1,
11252         },
11253         [ALC861VD_FIX_DALLAS] = {
11254                 .type = HDA_FIXUP_FUNC,
11255                 .v.func = alc861vd_fixup_dallas,
11256         },
11257 };
11258
11259 static const struct snd_pci_quirk alc861vd_fixup_tbl[] = {
11260         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_FIX_DALLAS),
11261         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
11262         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_FIX_DALLAS),
11263         {}
11264 };
11265
11266 /*
11267  */
11268 static int patch_alc861vd(struct hda_codec *codec)
11269 {
11270         struct alc_spec *spec;
11271         int err;
11272
11273         err = alc_alloc_spec(codec, 0x0b);
11274         if (err < 0)
11275                 return err;
11276
11277         spec = codec->spec;
11278         if (has_cdefine_beep(codec))
11279                 spec->gen.beep_nid = 0x23;
11280
11281         spec->shutup = alc_eapd_shutup;
11282
11283         alc_pre_init(codec);
11284
11285         snd_hda_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
11286         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
11287
11288         /* automatic parse from the BIOS config */
11289         err = alc861vd_parse_auto_config(codec);
11290         if (err < 0)
11291                 goto error;
11292
11293         if (!spec->gen.no_analog) {
11294                 err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11295                 if (err < 0)
11296                         goto error;
11297         }
11298
11299         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
11300
11301         return 0;
11302
11303  error:
11304         alc_free(codec);
11305         return err;
11306 }
11307
11308 /*
11309  * ALC662 support
11310  *
11311  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
11312  * configuration.  Each pin widget can choose any input DACs and a mixer.
11313  * Each ADC is connected from a mixer of all inputs.  This makes possible
11314  * 6-channel independent captures.
11315  *
11316  * In addition, an independent DAC for the multi-playback (not used in this
11317  * driver yet).
11318  */
11319
11320 /*
11321  * BIOS auto configuration
11322  */
11323
11324 static int alc662_parse_auto_config(struct hda_codec *codec)
11325 {
11326         static const hda_nid_t alc662_ignore[] = { 0x1d, 0 };
11327         static const hda_nid_t alc663_ssids[] = { 0x15, 0x1b, 0x14, 0x21 };
11328         static const hda_nid_t alc662_ssids[] = { 0x15, 0x1b, 0x14, 0 };
11329         const hda_nid_t *ssids;
11330
11331         if (codec->core.vendor_id == 0x10ec0272 || codec->core.vendor_id == 0x10ec0663 ||
11332             codec->core.vendor_id == 0x10ec0665 || codec->core.vendor_id == 0x10ec0670 ||
11333             codec->core.vendor_id == 0x10ec0671)
11334                 ssids = alc663_ssids;
11335         else
11336                 ssids = alc662_ssids;
11337         return alc_parse_auto_config(codec, alc662_ignore, ssids);
11338 }
11339
11340 static void alc272_fixup_mario(struct hda_codec *codec,
11341                                const struct hda_fixup *fix, int action)
11342 {
11343         if (action != HDA_FIXUP_ACT_PRE_PROBE)
11344                 return;
11345         if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
11346                                       (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
11347                                       (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
11348                                       (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
11349                                       (0 << AC_AMPCAP_MUTE_SHIFT)))
11350                 codec_warn(codec, "failed to override amp caps for NID 0x2\n");
11351 }
11352
11353 static const struct snd_pcm_chmap_elem asus_pcm_2_1_chmaps[] = {
11354         { .channels = 2,
11355           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR } },
11356         { .channels = 4,
11357           .map = { SNDRV_CHMAP_FL, SNDRV_CHMAP_FR,
11358                    SNDRV_CHMAP_NA, SNDRV_CHMAP_LFE } }, /* LFE only on right */
11359         { }
11360 };
11361
11362 /* override the 2.1 chmap */
11363 static void alc_fixup_bass_chmap(struct hda_codec *codec,
11364                                     const struct hda_fixup *fix, int action)
11365 {
11366         if (action == HDA_FIXUP_ACT_BUILD) {
11367                 struct alc_spec *spec = codec->spec;
11368                 spec->gen.pcm_rec[0]->stream[0].chmap = asus_pcm_2_1_chmaps;
11369         }
11370 }
11371
11372 /* avoid D3 for keeping GPIO up */
11373 static unsigned int gpio_led_power_filter(struct hda_codec *codec,
11374                                           hda_nid_t nid,
11375                                           unsigned int power_state)
11376 {
11377         struct alc_spec *spec = codec->spec;
11378         if (nid == codec->core.afg && power_state == AC_PWRST_D3 && spec->gpio_data)
11379                 return AC_PWRST_D0;
11380         return power_state;
11381 }
11382
11383 static void alc662_fixup_led_gpio1(struct hda_codec *codec,
11384                                    const struct hda_fixup *fix, int action)
11385 {
11386         struct alc_spec *spec = codec->spec;
11387
11388         alc_fixup_hp_gpio_led(codec, action, 0x01, 0);
11389         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11390                 spec->mute_led_polarity = 1;
11391                 codec->power_filter = gpio_led_power_filter;
11392         }
11393 }
11394
11395 static void alc662_usi_automute_hook(struct hda_codec *codec,
11396                                          struct hda_jack_callback *jack)
11397 {
11398         struct alc_spec *spec = codec->spec;
11399         int vref;
11400         msleep(200);
11401         snd_hda_gen_hp_automute(codec, jack);
11402
11403         vref = spec->gen.hp_jack_present ? PIN_VREF80 : 0;
11404         msleep(100);
11405         snd_hda_codec_write(codec, 0x19, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11406                             vref);
11407 }
11408
11409 static void alc662_fixup_usi_headset_mic(struct hda_codec *codec,
11410                                      const struct hda_fixup *fix, int action)
11411 {
11412         struct alc_spec *spec = codec->spec;
11413         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11414                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11415                 spec->gen.hp_automute_hook = alc662_usi_automute_hook;
11416         }
11417 }
11418
11419 static void alc662_aspire_ethos_mute_speakers(struct hda_codec *codec,
11420                                         struct hda_jack_callback *cb)
11421 {
11422         /* surround speakers at 0x1b already get muted automatically when
11423          * headphones are plugged in, but we have to mute/unmute the remaining
11424          * channels manually:
11425          * 0x15 - front left/front right
11426          * 0x18 - front center/ LFE
11427          */
11428         if (snd_hda_jack_detect_state(codec, 0x1b) == HDA_JACK_PRESENT) {
11429                 snd_hda_set_pin_ctl_cache(codec, 0x15, 0);
11430                 snd_hda_set_pin_ctl_cache(codec, 0x18, 0);
11431         } else {
11432                 snd_hda_set_pin_ctl_cache(codec, 0x15, PIN_OUT);
11433                 snd_hda_set_pin_ctl_cache(codec, 0x18, PIN_OUT);
11434         }
11435 }
11436
11437 static void alc662_fixup_aspire_ethos_hp(struct hda_codec *codec,
11438                                         const struct hda_fixup *fix, int action)
11439 {
11440     /* Pin 0x1b: shared headphones jack and surround speakers */
11441         if (!is_jack_detectable(codec, 0x1b))
11442                 return;
11443
11444         switch (action) {
11445         case HDA_FIXUP_ACT_PRE_PROBE:
11446                 snd_hda_jack_detect_enable_callback(codec, 0x1b,
11447                                 alc662_aspire_ethos_mute_speakers);
11448                 /* subwoofer needs an extra GPIO setting to become audible */
11449                 alc_setup_gpio(codec, 0x02);
11450                 break;
11451         case HDA_FIXUP_ACT_INIT:
11452                 /* Make sure to start in a correct state, i.e. if
11453                  * headphones have been plugged in before powering up the system
11454                  */
11455                 alc662_aspire_ethos_mute_speakers(codec, NULL);
11456                 break;
11457         }
11458 }
11459
11460 static void alc671_fixup_hp_headset_mic2(struct hda_codec *codec,
11461                                              const struct hda_fixup *fix, int action)
11462 {
11463         struct alc_spec *spec = codec->spec;
11464
11465         static const struct hda_pintbl pincfgs[] = {
11466                 { 0x19, 0x02a11040 }, /* use as headset mic, with its own jack detect */
11467                 { 0x1b, 0x0181304f },
11468                 { }
11469         };
11470
11471         switch (action) {
11472         case HDA_FIXUP_ACT_PRE_PROBE:
11473                 spec->gen.mixer_nid = 0;
11474                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11475                 snd_hda_apply_pincfgs(codec, pincfgs);
11476                 break;
11477         case HDA_FIXUP_ACT_INIT:
11478                 alc_write_coef_idx(codec, 0x19, 0xa054);
11479                 break;
11480         }
11481 }
11482
11483 static void alc897_hp_automute_hook(struct hda_codec *codec,
11484                                          struct hda_jack_callback *jack)
11485 {
11486         struct alc_spec *spec = codec->spec;
11487         int vref;
11488
11489         snd_hda_gen_hp_automute(codec, jack);
11490         vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
11491         snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11492                             vref);
11493 }
11494
11495 static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
11496                                      const struct hda_fixup *fix, int action)
11497 {
11498         struct alc_spec *spec = codec->spec;
11499         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11500                 spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11501         }
11502 }
11503
11504 static void alc897_fixup_lenovo_headset_mode(struct hda_codec *codec,
11505                                      const struct hda_fixup *fix, int action)
11506 {
11507         struct alc_spec *spec = codec->spec;
11508
11509         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
11510                 spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
11511                 spec->gen.hp_automute_hook = alc897_hp_automute_hook;
11512         }
11513 }
11514
11515 static const struct coef_fw alc668_coefs[] = {
11516         WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
11517         WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
11518         WRITE_COEF(0x08, 0x0031), WRITE_COEF(0x0a, 0x0060), WRITE_COEF(0x0b,    0x0),
11519         WRITE_COEF(0x0c, 0x7cf7), WRITE_COEF(0x0d, 0x1080), WRITE_COEF(0x0e, 0x7f7f),
11520         WRITE_COEF(0x0f, 0xcccc), WRITE_COEF(0x10, 0xddcc), WRITE_COEF(0x11, 0x0001),
11521         WRITE_COEF(0x13,    0x0), WRITE_COEF(0x14, 0x2aa0), WRITE_COEF(0x17, 0xa940),
11522         WRITE_COEF(0x19,    0x0), WRITE_COEF(0x1a,    0x0), WRITE_COEF(0x1b,    0x0),
11523         WRITE_COEF(0x1c,    0x0), WRITE_COEF(0x1d,    0x0), WRITE_COEF(0x1e, 0x7418),
11524         WRITE_COEF(0x1f, 0x0804), WRITE_COEF(0x20, 0x4200), WRITE_COEF(0x21, 0x0468),
11525         WRITE_COEF(0x22, 0x8ccc), WRITE_COEF(0x23, 0x0250), WRITE_COEF(0x24, 0x7418),
11526         WRITE_COEF(0x27,    0x0), WRITE_COEF(0x28, 0x8ccc), WRITE_COEF(0x2a, 0xff00),
11527         WRITE_COEF(0x2b, 0x8000), WRITE_COEF(0xa7, 0xff00), WRITE_COEF(0xa8, 0x8000),
11528         WRITE_COEF(0xaa, 0x2e17), WRITE_COEF(0xab, 0xa0c0), WRITE_COEF(0xac,    0x0),
11529         WRITE_COEF(0xad,    0x0), WRITE_COEF(0xae, 0x2ac6), WRITE_COEF(0xaf, 0xa480),
11530         WRITE_COEF(0xb0,    0x0), WRITE_COEF(0xb1,    0x0), WRITE_COEF(0xb2,    0x0),
11531         WRITE_COEF(0xb3,    0x0), WRITE_COEF(0xb4,    0x0), WRITE_COEF(0xb5, 0x1040),
11532         WRITE_COEF(0xb6, 0xd697), WRITE_COEF(0xb7, 0x902b), WRITE_COEF(0xb8, 0xd697),
11533         WRITE_COEF(0xb9, 0x902b), WRITE_COEF(0xba, 0xb8ba), WRITE_COEF(0xbb, 0xaaab),
11534         WRITE_COEF(0xbc, 0xaaaf), WRITE_COEF(0xbd, 0x6aaa), WRITE_COEF(0xbe, 0x1c02),
11535         WRITE_COEF(0xc0, 0x00ff), WRITE_COEF(0xc1, 0x0fa6),
11536         {}
11537 };
11538
11539 static void alc668_restore_default_value(struct hda_codec *codec)
11540 {
11541         alc_process_coef_fw(codec, alc668_coefs);
11542 }
11543
11544 enum {
11545         ALC662_FIXUP_ASPIRE,
11546         ALC662_FIXUP_LED_GPIO1,
11547         ALC662_FIXUP_IDEAPAD,
11548         ALC272_FIXUP_MARIO,
11549         ALC662_FIXUP_CZC_ET26,
11550         ALC662_FIXUP_CZC_P10T,
11551         ALC662_FIXUP_SKU_IGNORE,
11552         ALC662_FIXUP_HP_RP5800,
11553         ALC662_FIXUP_ASUS_MODE1,
11554         ALC662_FIXUP_ASUS_MODE2,
11555         ALC662_FIXUP_ASUS_MODE3,
11556         ALC662_FIXUP_ASUS_MODE4,
11557         ALC662_FIXUP_ASUS_MODE5,
11558         ALC662_FIXUP_ASUS_MODE6,
11559         ALC662_FIXUP_ASUS_MODE7,
11560         ALC662_FIXUP_ASUS_MODE8,
11561         ALC662_FIXUP_NO_JACK_DETECT,
11562         ALC662_FIXUP_ZOTAC_Z68,
11563         ALC662_FIXUP_INV_DMIC,
11564         ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
11565         ALC668_FIXUP_DELL_MIC_NO_PRESENCE,
11566         ALC662_FIXUP_HEADSET_MODE,
11567         ALC668_FIXUP_HEADSET_MODE,
11568         ALC662_FIXUP_BASS_MODE4_CHMAP,
11569         ALC662_FIXUP_BASS_16,
11570         ALC662_FIXUP_BASS_1A,
11571         ALC662_FIXUP_BASS_CHMAP,
11572         ALC668_FIXUP_AUTO_MUTE,
11573         ALC668_FIXUP_DELL_DISABLE_AAMIX,
11574         ALC668_FIXUP_DELL_XPS13,
11575         ALC662_FIXUP_ASUS_Nx50,
11576         ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
11577         ALC668_FIXUP_ASUS_Nx51,
11578         ALC668_FIXUP_MIC_COEF,
11579         ALC668_FIXUP_ASUS_G751,
11580         ALC891_FIXUP_HEADSET_MODE,
11581         ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
11582         ALC662_FIXUP_ACER_VERITON,
11583         ALC892_FIXUP_ASROCK_MOBO,
11584         ALC662_FIXUP_USI_FUNC,
11585         ALC662_FIXUP_USI_HEADSET_MODE,
11586         ALC662_FIXUP_LENOVO_MULTI_CODECS,
11587         ALC669_FIXUP_ACER_ASPIRE_ETHOS,
11588         ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET,
11589         ALC671_FIXUP_HP_HEADSET_MIC2,
11590         ALC662_FIXUP_ACER_X2660G_HEADSET_MODE,
11591         ALC662_FIXUP_ACER_NITRO_HEADSET_MODE,
11592         ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
11593         ALC668_FIXUP_HEADSET_MIC,
11594         ALC668_FIXUP_MIC_DET_COEF,
11595         ALC897_FIXUP_LENOVO_HEADSET_MIC,
11596         ALC897_FIXUP_HEADSET_MIC_PIN,
11597         ALC897_FIXUP_HP_HSMIC_VERB,
11598         ALC897_FIXUP_LENOVO_HEADSET_MODE,
11599         ALC897_FIXUP_HEADSET_MIC_PIN2,
11600         ALC897_FIXUP_UNIS_H3C_X500S,
11601 };
11602
11603 static const struct hda_fixup alc662_fixups[] = {
11604         [ALC662_FIXUP_ASPIRE] = {
11605                 .type = HDA_FIXUP_PINS,
11606                 .v.pins = (const struct hda_pintbl[]) {
11607                         { 0x15, 0x99130112 }, /* subwoofer */
11608                         { }
11609                 }
11610         },
11611         [ALC662_FIXUP_LED_GPIO1] = {
11612                 .type = HDA_FIXUP_FUNC,
11613                 .v.func = alc662_fixup_led_gpio1,
11614         },
11615         [ALC662_FIXUP_IDEAPAD] = {
11616                 .type = HDA_FIXUP_PINS,
11617                 .v.pins = (const struct hda_pintbl[]) {
11618                         { 0x17, 0x99130112 }, /* subwoofer */
11619                         { }
11620                 },
11621                 .chained = true,
11622                 .chain_id = ALC662_FIXUP_LED_GPIO1,
11623         },
11624         [ALC272_FIXUP_MARIO] = {
11625                 .type = HDA_FIXUP_FUNC,
11626                 .v.func = alc272_fixup_mario,
11627         },
11628         [ALC662_FIXUP_CZC_ET26] = {
11629                 .type = HDA_FIXUP_PINS,
11630                 .v.pins = (const struct hda_pintbl[]) {
11631                         {0x12, 0x403cc000},
11632                         {0x14, 0x90170110}, /* speaker */
11633                         {0x15, 0x411111f0},
11634                         {0x16, 0x411111f0},
11635                         {0x18, 0x01a19030}, /* mic */
11636                         {0x19, 0x90a7013f}, /* int-mic */
11637                         {0x1a, 0x01014020},
11638                         {0x1b, 0x0121401f},
11639                         {0x1c, 0x411111f0},
11640                         {0x1d, 0x411111f0},
11641                         {0x1e, 0x40478e35},
11642                         {}
11643                 },
11644                 .chained = true,
11645                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11646         },
11647         [ALC662_FIXUP_CZC_P10T] = {
11648                 .type = HDA_FIXUP_VERBS,
11649                 .v.verbs = (const struct hda_verb[]) {
11650                         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
11651                         {}
11652                 }
11653         },
11654         [ALC662_FIXUP_SKU_IGNORE] = {
11655                 .type = HDA_FIXUP_FUNC,
11656                 .v.func = alc_fixup_sku_ignore,
11657         },
11658         [ALC662_FIXUP_HP_RP5800] = {
11659                 .type = HDA_FIXUP_PINS,
11660                 .v.pins = (const struct hda_pintbl[]) {
11661                         { 0x14, 0x0221201f }, /* HP out */
11662                         { }
11663                 },
11664                 .chained = true,
11665                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11666         },
11667         [ALC662_FIXUP_ASUS_MODE1] = {
11668                 .type = HDA_FIXUP_PINS,
11669                 .v.pins = (const struct hda_pintbl[]) {
11670                         { 0x14, 0x99130110 }, /* speaker */
11671                         { 0x18, 0x01a19c20 }, /* mic */
11672                         { 0x19, 0x99a3092f }, /* int-mic */
11673                         { 0x21, 0x0121401f }, /* HP out */
11674                         { }
11675                 },
11676                 .chained = true,
11677                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11678         },
11679         [ALC662_FIXUP_ASUS_MODE2] = {
11680                 .type = HDA_FIXUP_PINS,
11681                 .v.pins = (const struct hda_pintbl[]) {
11682                         { 0x14, 0x99130110 }, /* speaker */
11683                         { 0x18, 0x01a19820 }, /* mic */
11684                         { 0x19, 0x99a3092f }, /* int-mic */
11685                         { 0x1b, 0x0121401f }, /* HP out */
11686                         { }
11687                 },
11688                 .chained = true,
11689                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11690         },
11691         [ALC662_FIXUP_ASUS_MODE3] = {
11692                 .type = HDA_FIXUP_PINS,
11693                 .v.pins = (const struct hda_pintbl[]) {
11694                         { 0x14, 0x99130110 }, /* speaker */
11695                         { 0x15, 0x0121441f }, /* HP */
11696                         { 0x18, 0x01a19840 }, /* mic */
11697                         { 0x19, 0x99a3094f }, /* int-mic */
11698                         { 0x21, 0x01211420 }, /* HP2 */
11699                         { }
11700                 },
11701                 .chained = true,
11702                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11703         },
11704         [ALC662_FIXUP_ASUS_MODE4] = {
11705                 .type = HDA_FIXUP_PINS,
11706                 .v.pins = (const struct hda_pintbl[]) {
11707                         { 0x14, 0x99130110 }, /* speaker */
11708                         { 0x16, 0x99130111 }, /* speaker */
11709                         { 0x18, 0x01a19840 }, /* mic */
11710                         { 0x19, 0x99a3094f }, /* int-mic */
11711                         { 0x21, 0x0121441f }, /* HP */
11712                         { }
11713                 },
11714                 .chained = true,
11715                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11716         },
11717         [ALC662_FIXUP_ASUS_MODE5] = {
11718                 .type = HDA_FIXUP_PINS,
11719                 .v.pins = (const struct hda_pintbl[]) {
11720                         { 0x14, 0x99130110 }, /* speaker */
11721                         { 0x15, 0x0121441f }, /* HP */
11722                         { 0x16, 0x99130111 }, /* speaker */
11723                         { 0x18, 0x01a19840 }, /* mic */
11724                         { 0x19, 0x99a3094f }, /* int-mic */
11725                         { }
11726                 },
11727                 .chained = true,
11728                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11729         },
11730         [ALC662_FIXUP_ASUS_MODE6] = {
11731                 .type = HDA_FIXUP_PINS,
11732                 .v.pins = (const struct hda_pintbl[]) {
11733                         { 0x14, 0x99130110 }, /* speaker */
11734                         { 0x15, 0x01211420 }, /* HP2 */
11735                         { 0x18, 0x01a19840 }, /* mic */
11736                         { 0x19, 0x99a3094f }, /* int-mic */
11737                         { 0x1b, 0x0121441f }, /* HP */
11738                         { }
11739                 },
11740                 .chained = true,
11741                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11742         },
11743         [ALC662_FIXUP_ASUS_MODE7] = {
11744                 .type = HDA_FIXUP_PINS,
11745                 .v.pins = (const struct hda_pintbl[]) {
11746                         { 0x14, 0x99130110 }, /* speaker */
11747                         { 0x17, 0x99130111 }, /* speaker */
11748                         { 0x18, 0x01a19840 }, /* mic */
11749                         { 0x19, 0x99a3094f }, /* int-mic */
11750                         { 0x1b, 0x01214020 }, /* HP */
11751                         { 0x21, 0x0121401f }, /* HP */
11752                         { }
11753                 },
11754                 .chained = true,
11755                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11756         },
11757         [ALC662_FIXUP_ASUS_MODE8] = {
11758                 .type = HDA_FIXUP_PINS,
11759                 .v.pins = (const struct hda_pintbl[]) {
11760                         { 0x14, 0x99130110 }, /* speaker */
11761                         { 0x12, 0x99a30970 }, /* int-mic */
11762                         { 0x15, 0x01214020 }, /* HP */
11763                         { 0x17, 0x99130111 }, /* speaker */
11764                         { 0x18, 0x01a19840 }, /* mic */
11765                         { 0x21, 0x0121401f }, /* HP */
11766                         { }
11767                 },
11768                 .chained = true,
11769                 .chain_id = ALC662_FIXUP_SKU_IGNORE
11770         },
11771         [ALC662_FIXUP_NO_JACK_DETECT] = {
11772                 .type = HDA_FIXUP_FUNC,
11773                 .v.func = alc_fixup_no_jack_detect,
11774         },
11775         [ALC662_FIXUP_ZOTAC_Z68] = {
11776                 .type = HDA_FIXUP_PINS,
11777                 .v.pins = (const struct hda_pintbl[]) {
11778                         { 0x1b, 0x02214020 }, /* Front HP */
11779                         { }
11780                 }
11781         },
11782         [ALC662_FIXUP_INV_DMIC] = {
11783                 .type = HDA_FIXUP_FUNC,
11784                 .v.func = alc_fixup_inv_dmic,
11785         },
11786         [ALC668_FIXUP_DELL_XPS13] = {
11787                 .type = HDA_FIXUP_FUNC,
11788                 .v.func = alc_fixup_dell_xps13,
11789                 .chained = true,
11790                 .chain_id = ALC668_FIXUP_DELL_DISABLE_AAMIX
11791         },
11792         [ALC668_FIXUP_DELL_DISABLE_AAMIX] = {
11793                 .type = HDA_FIXUP_FUNC,
11794                 .v.func = alc_fixup_disable_aamix,
11795                 .chained = true,
11796                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
11797         },
11798         [ALC668_FIXUP_AUTO_MUTE] = {
11799                 .type = HDA_FIXUP_FUNC,
11800                 .v.func = alc_fixup_auto_mute_via_amp,
11801                 .chained = true,
11802                 .chain_id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE
11803         },
11804         [ALC662_FIXUP_DELL_MIC_NO_PRESENCE] = {
11805                 .type = HDA_FIXUP_PINS,
11806                 .v.pins = (const struct hda_pintbl[]) {
11807                         { 0x19, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11808                         /* headphone mic by setting pin control of 0x1b (headphone out) to in + vref_50 */
11809                         { }
11810                 },
11811                 .chained = true,
11812                 .chain_id = ALC662_FIXUP_HEADSET_MODE
11813         },
11814         [ALC662_FIXUP_HEADSET_MODE] = {
11815                 .type = HDA_FIXUP_FUNC,
11816                 .v.func = alc_fixup_headset_mode_alc662,
11817         },
11818         [ALC668_FIXUP_DELL_MIC_NO_PRESENCE] = {
11819                 .type = HDA_FIXUP_PINS,
11820                 .v.pins = (const struct hda_pintbl[]) {
11821                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
11822                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11823                         { }
11824                 },
11825                 .chained = true,
11826                 .chain_id = ALC668_FIXUP_HEADSET_MODE
11827         },
11828         [ALC668_FIXUP_HEADSET_MODE] = {
11829                 .type = HDA_FIXUP_FUNC,
11830                 .v.func = alc_fixup_headset_mode_alc668,
11831         },
11832         [ALC662_FIXUP_BASS_MODE4_CHMAP] = {
11833                 .type = HDA_FIXUP_FUNC,
11834                 .v.func = alc_fixup_bass_chmap,
11835                 .chained = true,
11836                 .chain_id = ALC662_FIXUP_ASUS_MODE4
11837         },
11838         [ALC662_FIXUP_BASS_16] = {
11839                 .type = HDA_FIXUP_PINS,
11840                 .v.pins = (const struct hda_pintbl[]) {
11841                         {0x16, 0x80106111}, /* bass speaker */
11842                         {}
11843                 },
11844                 .chained = true,
11845                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
11846         },
11847         [ALC662_FIXUP_BASS_1A] = {
11848                 .type = HDA_FIXUP_PINS,
11849                 .v.pins = (const struct hda_pintbl[]) {
11850                         {0x1a, 0x80106111}, /* bass speaker */
11851                         {}
11852                 },
11853                 .chained = true,
11854                 .chain_id = ALC662_FIXUP_BASS_CHMAP,
11855         },
11856         [ALC662_FIXUP_BASS_CHMAP] = {
11857                 .type = HDA_FIXUP_FUNC,
11858                 .v.func = alc_fixup_bass_chmap,
11859         },
11860         [ALC662_FIXUP_ASUS_Nx50] = {
11861                 .type = HDA_FIXUP_FUNC,
11862                 .v.func = alc_fixup_auto_mute_via_amp,
11863                 .chained = true,
11864                 .chain_id = ALC662_FIXUP_BASS_1A
11865         },
11866         [ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE] = {
11867                 .type = HDA_FIXUP_FUNC,
11868                 .v.func = alc_fixup_headset_mode_alc668,
11869                 .chain_id = ALC662_FIXUP_BASS_CHMAP
11870         },
11871         [ALC668_FIXUP_ASUS_Nx51] = {
11872                 .type = HDA_FIXUP_PINS,
11873                 .v.pins = (const struct hda_pintbl[]) {
11874                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
11875                         { 0x1a, 0x90170151 }, /* bass speaker */
11876                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11877                         {}
11878                 },
11879                 .chained = true,
11880                 .chain_id = ALC668_FIXUP_ASUS_Nx51_HEADSET_MODE,
11881         },
11882         [ALC668_FIXUP_MIC_COEF] = {
11883                 .type = HDA_FIXUP_VERBS,
11884                 .v.verbs = (const struct hda_verb[]) {
11885                         { 0x20, AC_VERB_SET_COEF_INDEX, 0xc3 },
11886                         { 0x20, AC_VERB_SET_PROC_COEF, 0x4000 },
11887                         {}
11888                 },
11889         },
11890         [ALC668_FIXUP_ASUS_G751] = {
11891                 .type = HDA_FIXUP_PINS,
11892                 .v.pins = (const struct hda_pintbl[]) {
11893                         { 0x16, 0x0421101f }, /* HP */
11894                         {}
11895                 },
11896                 .chained = true,
11897                 .chain_id = ALC668_FIXUP_MIC_COEF
11898         },
11899         [ALC891_FIXUP_HEADSET_MODE] = {
11900                 .type = HDA_FIXUP_FUNC,
11901                 .v.func = alc_fixup_headset_mode,
11902         },
11903         [ALC891_FIXUP_DELL_MIC_NO_PRESENCE] = {
11904                 .type = HDA_FIXUP_PINS,
11905                 .v.pins = (const struct hda_pintbl[]) {
11906                         { 0x19, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
11907                         { 0x1b, 0x03a1113c }, /* use as headset mic, without its own jack detect */
11908                         { }
11909                 },
11910                 .chained = true,
11911                 .chain_id = ALC891_FIXUP_HEADSET_MODE
11912         },
11913         [ALC662_FIXUP_ACER_VERITON] = {
11914                 .type = HDA_FIXUP_PINS,
11915                 .v.pins = (const struct hda_pintbl[]) {
11916                         { 0x15, 0x50170120 }, /* no internal speaker */
11917                         { }
11918                 }
11919         },
11920         [ALC892_FIXUP_ASROCK_MOBO] = {
11921                 .type = HDA_FIXUP_PINS,
11922                 .v.pins = (const struct hda_pintbl[]) {
11923                         { 0x15, 0x40f000f0 }, /* disabled */
11924                         { 0x16, 0x40f000f0 }, /* disabled */
11925                         { }
11926                 }
11927         },
11928         [ALC662_FIXUP_USI_FUNC] = {
11929                 .type = HDA_FIXUP_FUNC,
11930                 .v.func = alc662_fixup_usi_headset_mic,
11931         },
11932         [ALC662_FIXUP_USI_HEADSET_MODE] = {
11933                 .type = HDA_FIXUP_PINS,
11934                 .v.pins = (const struct hda_pintbl[]) {
11935                         { 0x19, 0x02a1913c }, /* use as headset mic, without its own jack detect */
11936                         { 0x18, 0x01a1903d },
11937                         { }
11938                 },
11939                 .chained = true,
11940                 .chain_id = ALC662_FIXUP_USI_FUNC
11941         },
11942         [ALC662_FIXUP_LENOVO_MULTI_CODECS] = {
11943                 .type = HDA_FIXUP_FUNC,
11944                 .v.func = alc233_alc662_fixup_lenovo_dual_codecs,
11945         },
11946         [ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET] = {
11947                 .type = HDA_FIXUP_FUNC,
11948                 .v.func = alc662_fixup_aspire_ethos_hp,
11949         },
11950         [ALC669_FIXUP_ACER_ASPIRE_ETHOS] = {
11951                 .type = HDA_FIXUP_PINS,
11952                 .v.pins = (const struct hda_pintbl[]) {
11953                         { 0x15, 0x92130110 }, /* front speakers */
11954                         { 0x18, 0x99130111 }, /* center/subwoofer */
11955                         { 0x1b, 0x11130012 }, /* surround plus jack for HP */
11956                         { }
11957                 },
11958                 .chained = true,
11959                 .chain_id = ALC669_FIXUP_ACER_ASPIRE_ETHOS_HEADSET
11960         },
11961         [ALC671_FIXUP_HP_HEADSET_MIC2] = {
11962                 .type = HDA_FIXUP_FUNC,
11963                 .v.func = alc671_fixup_hp_headset_mic2,
11964         },
11965         [ALC662_FIXUP_ACER_X2660G_HEADSET_MODE] = {
11966                 .type = HDA_FIXUP_PINS,
11967                 .v.pins = (const struct hda_pintbl[]) {
11968                         { 0x1a, 0x02a1113c }, /* use as headset mic, without its own jack detect */
11969                         { }
11970                 },
11971                 .chained = true,
11972                 .chain_id = ALC662_FIXUP_USI_FUNC
11973         },
11974         [ALC662_FIXUP_ACER_NITRO_HEADSET_MODE] = {
11975                 .type = HDA_FIXUP_PINS,
11976                 .v.pins = (const struct hda_pintbl[]) {
11977                         { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
11978                         { 0x1b, 0x0221144f },
11979                         { }
11980                 },
11981                 .chained = true,
11982                 .chain_id = ALC662_FIXUP_USI_FUNC
11983         },
11984         [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = {
11985                 .type = HDA_FIXUP_PINS,
11986                 .v.pins = (const struct hda_pintbl[]) {
11987                         { 0x1b, 0x04a1112c },
11988                         { }
11989                 },
11990                 .chained = true,
11991                 .chain_id = ALC668_FIXUP_HEADSET_MIC
11992         },
11993         [ALC668_FIXUP_HEADSET_MIC] = {
11994                 .type = HDA_FIXUP_FUNC,
11995                 .v.func = alc269_fixup_headset_mic,
11996                 .chained = true,
11997                 .chain_id = ALC668_FIXUP_MIC_DET_COEF
11998         },
11999         [ALC668_FIXUP_MIC_DET_COEF] = {
12000                 .type = HDA_FIXUP_VERBS,
12001                 .v.verbs = (const struct hda_verb[]) {
12002                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
12003                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
12004                         {}
12005                 },
12006         },
12007         [ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
12008                 .type = HDA_FIXUP_FUNC,
12009                 .v.func = alc897_fixup_lenovo_headset_mic,
12010         },
12011         [ALC897_FIXUP_HEADSET_MIC_PIN] = {
12012                 .type = HDA_FIXUP_PINS,
12013                 .v.pins = (const struct hda_pintbl[]) {
12014                         { 0x1a, 0x03a11050 },
12015                         { }
12016                 },
12017                 .chained = true,
12018                 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
12019         },
12020         [ALC897_FIXUP_HP_HSMIC_VERB] = {
12021                 .type = HDA_FIXUP_PINS,
12022                 .v.pins = (const struct hda_pintbl[]) {
12023                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
12024                         { }
12025                 },
12026         },
12027         [ALC897_FIXUP_LENOVO_HEADSET_MODE] = {
12028                 .type = HDA_FIXUP_FUNC,
12029                 .v.func = alc897_fixup_lenovo_headset_mode,
12030         },
12031         [ALC897_FIXUP_HEADSET_MIC_PIN2] = {
12032                 .type = HDA_FIXUP_PINS,
12033                 .v.pins = (const struct hda_pintbl[]) {
12034                         { 0x1a, 0x01a11140 }, /* use as headset mic, without its own jack detect */
12035                         { }
12036                 },
12037                 .chained = true,
12038                 .chain_id = ALC897_FIXUP_LENOVO_HEADSET_MODE
12039         },
12040         [ALC897_FIXUP_UNIS_H3C_X500S] = {
12041                 .type = HDA_FIXUP_VERBS,
12042                 .v.verbs = (const struct hda_verb[]) {
12043                         { 0x14, AC_VERB_SET_EAPD_BTLENABLE, 0 },
12044                         {}
12045                 },
12046         },
12047 };
12048
12049 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
12050         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_FIXUP_ASUS_MODE2),
12051         SND_PCI_QUIRK(0x1025, 0x022f, "Acer Aspire One", ALC662_FIXUP_INV_DMIC),
12052         SND_PCI_QUIRK(0x1025, 0x0241, "Packard Bell DOTS", ALC662_FIXUP_INV_DMIC),
12053         SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
12054         SND_PCI_QUIRK(0x1025, 0x031c, "Gateway NV79", ALC662_FIXUP_SKU_IGNORE),
12055         SND_PCI_QUIRK(0x1025, 0x0349, "eMachines eM250", ALC662_FIXUP_INV_DMIC),
12056         SND_PCI_QUIRK(0x1025, 0x034a, "Gateway LT27", ALC662_FIXUP_INV_DMIC),
12057         SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
12058         SND_PCI_QUIRK(0x1025, 0x0566, "Acer Aspire Ethos 8951G", ALC669_FIXUP_ACER_ASPIRE_ETHOS),
12059         SND_PCI_QUIRK(0x1025, 0x123c, "Acer Nitro N50-600", ALC662_FIXUP_ACER_NITRO_HEADSET_MODE),
12060         SND_PCI_QUIRK(0x1025, 0x124e, "Acer 2660G", ALC662_FIXUP_ACER_X2660G_HEADSET_MODE),
12061         SND_PCI_QUIRK(0x1028, 0x05d8, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12062         SND_PCI_QUIRK(0x1028, 0x05db, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12063         SND_PCI_QUIRK(0x1028, 0x05fe, "Dell XPS 15", ALC668_FIXUP_DELL_XPS13),
12064         SND_PCI_QUIRK(0x1028, 0x060a, "Dell XPS 13", ALC668_FIXUP_DELL_XPS13),
12065         SND_PCI_QUIRK(0x1028, 0x060d, "Dell M3800", ALC668_FIXUP_DELL_XPS13),
12066         SND_PCI_QUIRK(0x1028, 0x0625, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12067         SND_PCI_QUIRK(0x1028, 0x0626, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12068         SND_PCI_QUIRK(0x1028, 0x0696, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12069         SND_PCI_QUIRK(0x1028, 0x0698, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12070         SND_PCI_QUIRK(0x1028, 0x069f, "Dell", ALC668_FIXUP_DELL_MIC_NO_PRESENCE),
12071         SND_PCI_QUIRK(0x103c, 0x1632, "HP RP5800", ALC662_FIXUP_HP_RP5800),
12072         SND_PCI_QUIRK(0x103c, 0x870c, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12073         SND_PCI_QUIRK(0x103c, 0x8719, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12074         SND_PCI_QUIRK(0x103c, 0x872b, "HP", ALC897_FIXUP_HP_HSMIC_VERB),
12075         SND_PCI_QUIRK(0x103c, 0x873e, "HP", ALC671_FIXUP_HP_HEADSET_MIC2),
12076         SND_PCI_QUIRK(0x103c, 0x8768, "HP Slim Desktop S01", ALC671_FIXUP_HP_HEADSET_MIC2),
12077         SND_PCI_QUIRK(0x103c, 0x877e, "HP 288 Pro G6", ALC671_FIXUP_HP_HEADSET_MIC2),
12078         SND_PCI_QUIRK(0x103c, 0x885f, "HP 288 Pro G8", ALC671_FIXUP_HP_HEADSET_MIC2),
12079         SND_PCI_QUIRK(0x1043, 0x1080, "Asus UX501VW", ALC668_FIXUP_HEADSET_MODE),
12080         SND_PCI_QUIRK(0x1043, 0x11cd, "Asus N550", ALC662_FIXUP_ASUS_Nx50),
12081         SND_PCI_QUIRK(0x1043, 0x129d, "Asus N750", ALC662_FIXUP_ASUS_Nx50),
12082         SND_PCI_QUIRK(0x1043, 0x12ff, "ASUS G751", ALC668_FIXUP_ASUS_G751),
12083         SND_PCI_QUIRK(0x1043, 0x13df, "Asus N550JX", ALC662_FIXUP_BASS_1A),
12084         SND_PCI_QUIRK(0x1043, 0x1477, "ASUS N56VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12085         SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16),
12086         SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51),
12087         SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51),
12088         SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC),
12089         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8),
12090         SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16),
12091         SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP),
12092         SND_PCI_QUIRK(0x1043, 0x8469, "ASUS mobo", ALC662_FIXUP_NO_JACK_DETECT),
12093         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_FIXUP_ASUS_MODE2),
12094         SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
12095         SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
12096         SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
12097         SND_PCI_QUIRK(0x17aa, 0x1057, "Lenovo P360", ALC897_FIXUP_HEADSET_MIC_PIN),
12098         SND_PCI_QUIRK(0x17aa, 0x1064, "Lenovo P3 Tower", ALC897_FIXUP_HEADSET_MIC_PIN),
12099         SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
12100         SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
12101         SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
12102         SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
12103         SND_PCI_QUIRK(0x17aa, 0x3321, "Lenovo ThinkCentre M70 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12104         SND_PCI_QUIRK(0x17aa, 0x331b, "Lenovo ThinkCentre M90 Gen4", ALC897_FIXUP_HEADSET_MIC_PIN),
12105         SND_PCI_QUIRK(0x17aa, 0x3742, "Lenovo TianYi510Pro-14IOB", ALC897_FIXUP_HEADSET_MIC_PIN2),
12106         SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
12107         SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
12108         SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),
12109         SND_PCI_QUIRK(0x19da, 0xa130, "Zotac Z68", ALC662_FIXUP_ZOTAC_Z68),
12110         SND_PCI_QUIRK(0x1b0a, 0x01b8, "ACER Veriton", ALC662_FIXUP_ACER_VERITON),
12111         SND_PCI_QUIRK(0x1b35, 0x1234, "CZC ET26", ALC662_FIXUP_CZC_ET26),
12112         SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
12113         SND_PCI_QUIRK(0x1c6c, 0x1239, "Compaq N14JP6-V2", ALC897_FIXUP_HP_HSMIC_VERB),
12114
12115 #if 0
12116         /* Below is a quirk table taken from the old code.
12117          * Basically the device should work as is without the fixup table.
12118          * If BIOS doesn't give a proper info, enable the corresponding
12119          * fixup entry.
12120          */
12121         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC662_FIXUP_ASUS_MODE1),
12122         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC662_FIXUP_ASUS_MODE3),
12123         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC662_FIXUP_ASUS_MODE1),
12124         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC662_FIXUP_ASUS_MODE3),
12125         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12126         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12127         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12128         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC662_FIXUP_ASUS_MODE1),
12129         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC662_FIXUP_ASUS_MODE1),
12130         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12131         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC662_FIXUP_ASUS_MODE7),
12132         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC662_FIXUP_ASUS_MODE7),
12133         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC662_FIXUP_ASUS_MODE8),
12134         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC662_FIXUP_ASUS_MODE3),
12135         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC662_FIXUP_ASUS_MODE1),
12136         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12137         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_FIXUP_ASUS_MODE2),
12138         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC662_FIXUP_ASUS_MODE1),
12139         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12140         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12141         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12142         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12143         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC662_FIXUP_ASUS_MODE1),
12144         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC662_FIXUP_ASUS_MODE3),
12145         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_FIXUP_ASUS_MODE2),
12146         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12147         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC662_FIXUP_ASUS_MODE5),
12148         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC662_FIXUP_ASUS_MODE6),
12149         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12150         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC662_FIXUP_ASUS_MODE1),
12151         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12152         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12153         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC662_FIXUP_ASUS_MODE3),
12154         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC662_FIXUP_ASUS_MODE3),
12155         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC662_FIXUP_ASUS_MODE1),
12156         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC662_FIXUP_ASUS_MODE1),
12157         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC662_FIXUP_ASUS_MODE1),
12158         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC662_FIXUP_ASUS_MODE1),
12159         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC662_FIXUP_ASUS_MODE1),
12160         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_FIXUP_ASUS_MODE2),
12161         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_FIXUP_ASUS_MODE2),
12162         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC662_FIXUP_ASUS_MODE1),
12163         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12164         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC662_FIXUP_ASUS_MODE3),
12165         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC662_FIXUP_ASUS_MODE1),
12166         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC662_FIXUP_ASUS_MODE1),
12167         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC662_FIXUP_ASUS_MODE1),
12168         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_FIXUP_ASUS_MODE2),
12169         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC662_FIXUP_ASUS_MODE1),
12170         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC662_FIXUP_ASUS_MODE4),
12171 #endif
12172         {}
12173 };
12174
12175 static const struct hda_model_fixup alc662_fixup_models[] = {
12176         {.id = ALC662_FIXUP_ASPIRE, .name = "aspire"},
12177         {.id = ALC662_FIXUP_IDEAPAD, .name = "ideapad"},
12178         {.id = ALC272_FIXUP_MARIO, .name = "mario"},
12179         {.id = ALC662_FIXUP_HP_RP5800, .name = "hp-rp5800"},
12180         {.id = ALC662_FIXUP_ASUS_MODE1, .name = "asus-mode1"},
12181         {.id = ALC662_FIXUP_ASUS_MODE2, .name = "asus-mode2"},
12182         {.id = ALC662_FIXUP_ASUS_MODE3, .name = "asus-mode3"},
12183         {.id = ALC662_FIXUP_ASUS_MODE4, .name = "asus-mode4"},
12184         {.id = ALC662_FIXUP_ASUS_MODE5, .name = "asus-mode5"},
12185         {.id = ALC662_FIXUP_ASUS_MODE6, .name = "asus-mode6"},
12186         {.id = ALC662_FIXUP_ASUS_MODE7, .name = "asus-mode7"},
12187         {.id = ALC662_FIXUP_ASUS_MODE8, .name = "asus-mode8"},
12188         {.id = ALC662_FIXUP_ZOTAC_Z68, .name = "zotac-z68"},
12189         {.id = ALC662_FIXUP_INV_DMIC, .name = "inv-dmic"},
12190         {.id = ALC662_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc662-headset-multi"},
12191         {.id = ALC668_FIXUP_DELL_MIC_NO_PRESENCE, .name = "dell-headset-multi"},
12192         {.id = ALC662_FIXUP_HEADSET_MODE, .name = "alc662-headset"},
12193         {.id = ALC668_FIXUP_HEADSET_MODE, .name = "alc668-headset"},
12194         {.id = ALC662_FIXUP_BASS_16, .name = "bass16"},
12195         {.id = ALC662_FIXUP_BASS_1A, .name = "bass1a"},
12196         {.id = ALC668_FIXUP_AUTO_MUTE, .name = "automute"},
12197         {.id = ALC668_FIXUP_DELL_XPS13, .name = "dell-xps13"},
12198         {.id = ALC662_FIXUP_ASUS_Nx50, .name = "asus-nx50"},
12199         {.id = ALC668_FIXUP_ASUS_Nx51, .name = "asus-nx51"},
12200         {.id = ALC668_FIXUP_ASUS_G751, .name = "asus-g751"},
12201         {.id = ALC891_FIXUP_HEADSET_MODE, .name = "alc891-headset"},
12202         {.id = ALC891_FIXUP_DELL_MIC_NO_PRESENCE, .name = "alc891-headset-multi"},
12203         {.id = ALC662_FIXUP_ACER_VERITON, .name = "acer-veriton"},
12204         {.id = ALC892_FIXUP_ASROCK_MOBO, .name = "asrock-mobo"},
12205         {.id = ALC662_FIXUP_USI_HEADSET_MODE, .name = "usi-headset"},
12206         {.id = ALC662_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"},
12207         {.id = ALC669_FIXUP_ACER_ASPIRE_ETHOS, .name = "aspire-ethos"},
12208         {.id = ALC897_FIXUP_UNIS_H3C_X500S, .name = "unis-h3c-x500s"},
12209         {}
12210 };
12211
12212 static const struct snd_hda_pin_quirk alc662_pin_fixup_tbl[] = {
12213         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12214                 {0x17, 0x02211010},
12215                 {0x18, 0x01a19030},
12216                 {0x1a, 0x01813040},
12217                 {0x21, 0x01014020}),
12218         SND_HDA_PIN_QUIRK(0x10ec0867, 0x1028, "Dell", ALC891_FIXUP_DELL_MIC_NO_PRESENCE,
12219                 {0x16, 0x01813030},
12220                 {0x17, 0x02211010},
12221                 {0x18, 0x01a19040},
12222                 {0x21, 0x01014020}),
12223         SND_HDA_PIN_QUIRK(0x10ec0662, 0x1028, "Dell", ALC662_FIXUP_DELL_MIC_NO_PRESENCE,
12224                 {0x14, 0x01014010},
12225                 {0x18, 0x01a19020},
12226                 {0x1a, 0x0181302f},
12227                 {0x1b, 0x0221401f}),
12228         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12229                 {0x12, 0x99a30130},
12230                 {0x14, 0x90170110},
12231                 {0x15, 0x0321101f},
12232                 {0x16, 0x03011020}),
12233         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12234                 {0x12, 0x99a30140},
12235                 {0x14, 0x90170110},
12236                 {0x15, 0x0321101f},
12237                 {0x16, 0x03011020}),
12238         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12239                 {0x12, 0x99a30150},
12240                 {0x14, 0x90170110},
12241                 {0x15, 0x0321101f},
12242                 {0x16, 0x03011020}),
12243         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell", ALC668_FIXUP_AUTO_MUTE,
12244                 {0x14, 0x90170110},
12245                 {0x15, 0x0321101f},
12246                 {0x16, 0x03011020}),
12247         SND_HDA_PIN_QUIRK(0x10ec0668, 0x1028, "Dell XPS 15", ALC668_FIXUP_AUTO_MUTE,
12248                 {0x12, 0x90a60130},
12249                 {0x14, 0x90170110},
12250                 {0x15, 0x0321101f}),
12251         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12252                 {0x14, 0x01014010},
12253                 {0x17, 0x90170150},
12254                 {0x19, 0x02a11060},
12255                 {0x1b, 0x01813030},
12256                 {0x21, 0x02211020}),
12257         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12258                 {0x14, 0x01014010},
12259                 {0x18, 0x01a19040},
12260                 {0x1b, 0x01813030},
12261                 {0x21, 0x02211020}),
12262         SND_HDA_PIN_QUIRK(0x10ec0671, 0x103c, "HP cPC", ALC671_FIXUP_HP_HEADSET_MIC2,
12263                 {0x14, 0x01014020},
12264                 {0x17, 0x90170110},
12265                 {0x18, 0x01a19050},
12266                 {0x1b, 0x01813040},
12267                 {0x21, 0x02211030}),
12268         {}
12269 };
12270
12271 /*
12272  */
12273 static int patch_alc662(struct hda_codec *codec)
12274 {
12275         struct alc_spec *spec;
12276         int err;
12277
12278         err = alc_alloc_spec(codec, 0x0b);
12279         if (err < 0)
12280                 return err;
12281
12282         spec = codec->spec;
12283
12284         spec->shutup = alc_eapd_shutup;
12285
12286         /* handle multiple HPs as is */
12287         spec->parse_flags = HDA_PINCFG_NO_HP_FIXUP;
12288
12289         alc_fix_pll_init(codec, 0x20, 0x04, 15);
12290
12291         switch (codec->core.vendor_id) {
12292         case 0x10ec0668:
12293                 spec->init_hook = alc668_restore_default_value;
12294                 break;
12295         }
12296
12297         alc_pre_init(codec);
12298
12299         snd_hda_pick_fixup(codec, alc662_fixup_models,
12300                        alc662_fixup_tbl, alc662_fixups);
12301         snd_hda_pick_pin_fixup(codec, alc662_pin_fixup_tbl, alc662_fixups, true);
12302         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
12303
12304         alc_auto_parse_customize_define(codec);
12305
12306         if (has_cdefine_beep(codec))
12307                 spec->gen.beep_nid = 0x01;
12308
12309         if ((alc_get_coef0(codec) & (1 << 14)) &&
12310             codec->bus->pci && codec->bus->pci->subsystem_vendor == 0x1025 &&
12311             spec->cdefine.platform_type == 1) {
12312                 err = alc_codec_rename(codec, "ALC272X");
12313                 if (err < 0)
12314                         goto error;
12315         }
12316
12317         /* automatic parse from the BIOS config */
12318         err = alc662_parse_auto_config(codec);
12319         if (err < 0)
12320                 goto error;
12321
12322         if (!spec->gen.no_analog && spec->gen.beep_nid) {
12323                 switch (codec->core.vendor_id) {
12324                 case 0x10ec0662:
12325                         err = set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12326                         break;
12327                 case 0x10ec0272:
12328                 case 0x10ec0663:
12329                 case 0x10ec0665:
12330                 case 0x10ec0668:
12331                         err = set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
12332                         break;
12333                 case 0x10ec0273:
12334                         err = set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
12335                         break;
12336                 }
12337                 if (err < 0)
12338                         goto error;
12339         }
12340
12341         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
12342
12343         return 0;
12344
12345  error:
12346         alc_free(codec);
12347         return err;
12348 }
12349
12350 /*
12351  * ALC680 support
12352  */
12353
12354 static int alc680_parse_auto_config(struct hda_codec *codec)
12355 {
12356         return alc_parse_auto_config(codec, NULL, NULL);
12357 }
12358
12359 /*
12360  */
12361 static int patch_alc680(struct hda_codec *codec)
12362 {
12363         int err;
12364
12365         /* ALC680 has no aa-loopback mixer */
12366         err = alc_alloc_spec(codec, 0);
12367         if (err < 0)
12368                 return err;
12369
12370         /* automatic parse from the BIOS config */
12371         err = alc680_parse_auto_config(codec);
12372         if (err < 0) {
12373                 alc_free(codec);
12374                 return err;
12375         }
12376
12377         return 0;
12378 }
12379
12380 /*
12381  * patch entries
12382  */
12383 static const struct hda_device_id snd_hda_id_realtek[] = {
12384         HDA_CODEC_ENTRY(0x10ec0215, "ALC215", patch_alc269),
12385         HDA_CODEC_ENTRY(0x10ec0221, "ALC221", patch_alc269),
12386         HDA_CODEC_ENTRY(0x10ec0222, "ALC222", patch_alc269),
12387         HDA_CODEC_ENTRY(0x10ec0225, "ALC225", patch_alc269),
12388         HDA_CODEC_ENTRY(0x10ec0230, "ALC236", patch_alc269),
12389         HDA_CODEC_ENTRY(0x10ec0231, "ALC231", patch_alc269),
12390         HDA_CODEC_ENTRY(0x10ec0233, "ALC233", patch_alc269),
12391         HDA_CODEC_ENTRY(0x10ec0234, "ALC234", patch_alc269),
12392         HDA_CODEC_ENTRY(0x10ec0235, "ALC233", patch_alc269),
12393         HDA_CODEC_ENTRY(0x10ec0236, "ALC236", patch_alc269),
12394         HDA_CODEC_ENTRY(0x10ec0245, "ALC245", patch_alc269),
12395         HDA_CODEC_ENTRY(0x10ec0255, "ALC255", patch_alc269),
12396         HDA_CODEC_ENTRY(0x10ec0256, "ALC256", patch_alc269),
12397         HDA_CODEC_ENTRY(0x10ec0257, "ALC257", patch_alc269),
12398         HDA_CODEC_ENTRY(0x10ec0260, "ALC260", patch_alc260),
12399         HDA_CODEC_ENTRY(0x10ec0262, "ALC262", patch_alc262),
12400         HDA_CODEC_ENTRY(0x10ec0267, "ALC267", patch_alc268),
12401         HDA_CODEC_ENTRY(0x10ec0268, "ALC268", patch_alc268),
12402         HDA_CODEC_ENTRY(0x10ec0269, "ALC269", patch_alc269),
12403         HDA_CODEC_ENTRY(0x10ec0270, "ALC270", patch_alc269),
12404         HDA_CODEC_ENTRY(0x10ec0272, "ALC272", patch_alc662),
12405         HDA_CODEC_ENTRY(0x10ec0274, "ALC274", patch_alc269),
12406         HDA_CODEC_ENTRY(0x10ec0275, "ALC275", patch_alc269),
12407         HDA_CODEC_ENTRY(0x10ec0276, "ALC276", patch_alc269),
12408         HDA_CODEC_ENTRY(0x10ec0280, "ALC280", patch_alc269),
12409         HDA_CODEC_ENTRY(0x10ec0282, "ALC282", patch_alc269),
12410         HDA_CODEC_ENTRY(0x10ec0283, "ALC283", patch_alc269),
12411         HDA_CODEC_ENTRY(0x10ec0284, "ALC284", patch_alc269),
12412         HDA_CODEC_ENTRY(0x10ec0285, "ALC285", patch_alc269),
12413         HDA_CODEC_ENTRY(0x10ec0286, "ALC286", patch_alc269),
12414         HDA_CODEC_ENTRY(0x10ec0287, "ALC287", patch_alc269),
12415         HDA_CODEC_ENTRY(0x10ec0288, "ALC288", patch_alc269),
12416         HDA_CODEC_ENTRY(0x10ec0289, "ALC289", patch_alc269),
12417         HDA_CODEC_ENTRY(0x10ec0290, "ALC290", patch_alc269),
12418         HDA_CODEC_ENTRY(0x10ec0292, "ALC292", patch_alc269),
12419         HDA_CODEC_ENTRY(0x10ec0293, "ALC293", patch_alc269),
12420         HDA_CODEC_ENTRY(0x10ec0294, "ALC294", patch_alc269),
12421         HDA_CODEC_ENTRY(0x10ec0295, "ALC295", patch_alc269),
12422         HDA_CODEC_ENTRY(0x10ec0298, "ALC298", patch_alc269),
12423         HDA_CODEC_ENTRY(0x10ec0299, "ALC299", patch_alc269),
12424         HDA_CODEC_ENTRY(0x10ec0300, "ALC300", patch_alc269),
12425         HDA_CODEC_ENTRY(0x10ec0623, "ALC623", patch_alc269),
12426         HDA_CODEC_REV_ENTRY(0x10ec0861, 0x100340, "ALC660", patch_alc861),
12427         HDA_CODEC_ENTRY(0x10ec0660, "ALC660-VD", patch_alc861vd),
12428         HDA_CODEC_ENTRY(0x10ec0861, "ALC861", patch_alc861),
12429         HDA_CODEC_ENTRY(0x10ec0862, "ALC861-VD", patch_alc861vd),
12430         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100002, "ALC662 rev2", patch_alc882),
12431         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100101, "ALC662 rev1", patch_alc662),
12432         HDA_CODEC_REV_ENTRY(0x10ec0662, 0x100300, "ALC662 rev3", patch_alc662),
12433         HDA_CODEC_ENTRY(0x10ec0663, "ALC663", patch_alc662),
12434         HDA_CODEC_ENTRY(0x10ec0665, "ALC665", patch_alc662),
12435         HDA_CODEC_ENTRY(0x10ec0667, "ALC667", patch_alc662),
12436         HDA_CODEC_ENTRY(0x10ec0668, "ALC668", patch_alc662),
12437         HDA_CODEC_ENTRY(0x10ec0670, "ALC670", patch_alc662),
12438         HDA_CODEC_ENTRY(0x10ec0671, "ALC671", patch_alc662),
12439         HDA_CODEC_ENTRY(0x10ec0680, "ALC680", patch_alc680),
12440         HDA_CODEC_ENTRY(0x10ec0700, "ALC700", patch_alc269),
12441         HDA_CODEC_ENTRY(0x10ec0701, "ALC701", patch_alc269),
12442         HDA_CODEC_ENTRY(0x10ec0703, "ALC703", patch_alc269),
12443         HDA_CODEC_ENTRY(0x10ec0711, "ALC711", patch_alc269),
12444         HDA_CODEC_ENTRY(0x10ec0867, "ALC891", patch_alc662),
12445         HDA_CODEC_ENTRY(0x10ec0880, "ALC880", patch_alc880),
12446         HDA_CODEC_ENTRY(0x10ec0882, "ALC882", patch_alc882),
12447         HDA_CODEC_ENTRY(0x10ec0883, "ALC883", patch_alc882),
12448         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100101, "ALC889A", patch_alc882),
12449         HDA_CODEC_REV_ENTRY(0x10ec0885, 0x100103, "ALC889A", patch_alc882),
12450         HDA_CODEC_ENTRY(0x10ec0885, "ALC885", patch_alc882),
12451         HDA_CODEC_ENTRY(0x10ec0887, "ALC887", patch_alc882),
12452         HDA_CODEC_REV_ENTRY(0x10ec0888, 0x100101, "ALC1200", patch_alc882),
12453         HDA_CODEC_ENTRY(0x10ec0888, "ALC888", patch_alc882),
12454         HDA_CODEC_ENTRY(0x10ec0889, "ALC889", patch_alc882),
12455         HDA_CODEC_ENTRY(0x10ec0892, "ALC892", patch_alc662),
12456         HDA_CODEC_ENTRY(0x10ec0897, "ALC897", patch_alc662),
12457         HDA_CODEC_ENTRY(0x10ec0899, "ALC898", patch_alc882),
12458         HDA_CODEC_ENTRY(0x10ec0900, "ALC1150", patch_alc882),
12459         HDA_CODEC_ENTRY(0x10ec0b00, "ALCS1200A", patch_alc882),
12460         HDA_CODEC_ENTRY(0x10ec1168, "ALC1220", patch_alc882),
12461         HDA_CODEC_ENTRY(0x10ec1220, "ALC1220", patch_alc882),
12462         HDA_CODEC_ENTRY(0x19e58326, "HW8326", patch_alc269),
12463         {} /* terminator */
12464 };
12465 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_realtek);
12466
12467 MODULE_LICENSE("GPL");
12468 MODULE_DESCRIPTION("Realtek HD-audio codec");
12469
12470 static struct hda_codec_driver realtek_driver = {
12471         .id = snd_hda_id_realtek,
12472 };
12473
12474 module_hda_codec_driver(realtek_driver);